StreetLight
/
libxkbcommon
2
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

test: untangle interactive-evdev from the test headers 

Move (sometimes duplicate) the required bits into new shared files
tools-common.(c|h) that are compiled into the internal tools library. Rename the
test_foo() functions to tools_foo() and in one case just copy the code of the
keymap compile function to the tool.

Signed-off-by: Peter Hutterer <peter.hutterer@who-t.net>
master
Peter Hutterer 2020-06-23 14:01:48 +10:00
parent 2eb5d2c81d
commit c09bf36306
6 changed files with 163 additions and 100 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
meson.build
View File

@ -445,11 +445,13 @@ executable('fuzz-compose', 'fuzz/compose/target.c', dependencies: test_dep)
# Demo programs.
libxkbcommon_tools_internal = static_library(
'tools-internal',
'tools/tools-common.h',
'tools/tools-common.c',
libxkbcommon_sources,
include_directories: include_directories('src'),
)
tools_dep = declare_dependency(
include_directories: include_directories('src'),
include_directories: [include_directories('src'), include_directories('tools')],
link_with: libxkbcommon_tools_internal,
)
@ -460,7 +462,7 @@ if cc.has_header_symbol('getopt.h', 'getopt_long', prefix: '#define _GNU_SOURCE'
executable('how-to-type', 'tools/how-to-type.c', dependencies: tools_dep)
endif
if cc.has_header('linux/input.h')
executable('interactive-evdev', 'test/interactive-evdev.c', dependencies: test_dep)
executable('interactive-evdev', 'test/interactive-evdev.c', dependencies: tools_dep)
endif
if get_option('enable-x11')
executable('interactive-x11', 'test/interactive-x11.c', dependencies: x11_test_dep)

28
test/common.c
View File

@ -441,34 +441,6 @@ test_print_keycode_state(struct xkb_state *state,
printf("\n");
}
void
test_print_state_changes(enum xkb_state_component changed)
{
if (changed == 0)
return;
printf("changed [ ");
if (changed & XKB_STATE_LAYOUT_EFFECTIVE)
printf("effective-layout ");
if (changed & XKB_STATE_LAYOUT_DEPRESSED)
printf("depressed-layout ");
if (changed & XKB_STATE_LAYOUT_LATCHED)
printf("latched-layout ");
if (changed & XKB_STATE_LAYOUT_LOCKED)
printf("locked-layout ");
if (changed & XKB_STATE_MODS_EFFECTIVE)
printf("effective-mods ");
if (changed & XKB_STATE_MODS_DEPRESSED)
printf("depressed-mods ");
if (changed & XKB_STATE_MODS_LATCHED)
printf("latched-mods ");
if (changed & XKB_STATE_MODS_LOCKED)
printf("locked-mods ");
if (changed & XKB_STATE_LEDS)
printf("leds ");
printf("]\n");
}
#ifdef _MSC_VER
void
test_disable_stdin_echo(void)

41
test/interactive-evdev.c
View File

@ -23,6 +23,7 @@
#include "config.h"
#include <assert.h>
#include <dirent.h>
#include <errno.h>
#include <fcntl.h>
@ -30,13 +31,18 @@
#include <limits.h>
#include <locale.h>
#include <signal.h>
#include <stdbool.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/epoll.h>
#include <linux/input.h>
#include "test.h"
#include "xkbcommon/xkbcommon.h"
#include "tools-common.h"
struct keyboard {
char *path;
@ -264,8 +270,8 @@ process_event(struct keyboard *kbd, uint16_t type, uint16_t code, int32_t value)
}
if (value != KEY_STATE_RELEASE)
test_print_keycode_state(kbd->state, kbd->compose_state, keycode,
consumed_mode);
tools_print_keycode_state(kbd->state, kbd->compose_state, keycode,
consumed_mode);
if (with_compose) {
status = xkb_compose_state_get_status(kbd->compose_state);
@ -279,7 +285,7 @@ process_event(struct keyboard *kbd, uint16_t type, uint16_t code, int32_t value)
changed = xkb_state_update_key(kbd->state, keycode, XKB_KEY_DOWN);
if (report_state_changes)
test_print_state_changes(changed);
tools_print_state_changes(changed);
}
static int
@ -433,7 +439,7 @@ main(int argc, char *argv[])
}
}
ctx = test_get_context(0);
ctx = xkb_context_new(XKB_CONTEXT_NO_FLAGS);
if (!ctx) {
fprintf(stderr, "Couldn't create xkb context\n");
goto out;
@ -452,8 +458,25 @@ main(int argc, char *argv[])
fclose(file);
}
else {
keymap = test_compile_rules(ctx, rules, model, layout, variant,
options);
struct xkb_rule_names rmlvo = {
.rules = isempty(rules) ? NULL : rules,
.model = isempty(model) ? NULL : model,
.layout = isempty(layout) ? NULL : layout,
.variant = isempty(variant) ? NULL : variant,
.options = isempty(options) ? NULL : options
};
if (!rules && !model && !layout && !variant && !options)
keymap = xkb_keymap_new_from_names(ctx, NULL, 0);
else
keymap = xkb_keymap_new_from_names(ctx, &rmlvo, 0);
if (!keymap) {
fprintf(stderr,
"Failed to compile RMLVO: '%s', '%s', '%s', '%s', '%s'\n",
rules, model, layout, variant, options);
goto out;
}
}
if (!keymap) {
@ -483,9 +506,9 @@ main(int argc, char *argv[])
sigaction(SIGINT, &act, NULL);
sigaction(SIGTERM, &act, NULL);
test_disable_stdin_echo();
tools_disable_stdin_echo();
ret = loop(kbds);
test_enable_stdin_echo();
tools_enable_stdin_echo();
free_keyboards(kbds);
out:

2
test/test.h
View File

@ -87,8 +87,6 @@ test_print_keycode_state(struct xkb_state *state,
xkb_keycode_t keycode,
enum xkb_consumed_mode consumed_mode);
void
test_print_state_changes(enum xkb_state_component changed);
void
test_disable_stdin_echo(void);

119
tools/tools-common.c
View File

@ -46,9 +46,120 @@
#include "tools-common.h"
void
tools_print_keycode_state(struct xkb_state *state,
struct xkb_compose_state *compose_state,
xkb_keycode_t keycode,
enum xkb_consumed_mode consumed_mode)
{
struct xkb_keymap *keymap;
xkb_keysym_t sym;
const xkb_keysym_t *syms;
int nsyms;
char s[16];
xkb_layout_index_t layout;
enum xkb_compose_status status;
keymap = xkb_state_get_keymap(state);
nsyms = xkb_state_key_get_syms(state, keycode, &syms);
if (nsyms <= 0)
return;
status = XKB_COMPOSE_NOTHING;
if (compose_state)
status = xkb_compose_state_get_status(compose_state);
if (status == XKB_COMPOSE_COMPOSING || status == XKB_COMPOSE_CANCELLED)
return;
if (status == XKB_COMPOSE_COMPOSED) {
sym = xkb_compose_state_get_one_sym(compose_state);
syms = &sym;
nsyms = 1;
}
else if (nsyms == 1) {
sym = xkb_state_key_get_one_sym(state, keycode);
syms = &sym;
}
printf("keysyms [ ");
for (int i = 0; i < nsyms; i++) {
xkb_keysym_get_name(syms[i], s, sizeof(s));
printf("%-*s ", (int) sizeof(s), s);
}
printf("] ");
if (status == XKB_COMPOSE_COMPOSED)
xkb_compose_state_get_utf8(compose_state, s, sizeof(s));
else
xkb_state_key_get_utf8(state, keycode, s, sizeof(s));
printf("unicode [ %s ] ", s);
layout = xkb_state_key_get_layout(state, keycode);
printf("layout [ %s (%d) ] ",
xkb_keymap_layout_get_name(keymap, layout), layout);
printf("level [ %d ] ",
xkb_state_key_get_level(state, keycode, layout));
printf("mods [ ");
for (xkb_mod_index_t mod = 0; mod < xkb_keymap_num_mods(keymap); mod++) {
if (xkb_state_mod_index_is_active(state, mod,
XKB_STATE_MODS_EFFECTIVE) <= 0)
continue;
if (xkb_state_mod_index_is_consumed2(state, keycode, mod,
consumed_mode))
printf("-%s ", xkb_keymap_mod_get_name(keymap, mod));
else
printf("%s ", xkb_keymap_mod_get_name(keymap, mod));
}
printf("] ");
printf("leds [ ");
for (xkb_led_index_t led = 0; led < xkb_keymap_num_leds(keymap); led++) {
if (xkb_state_led_index_is_active(state, led) <= 0)
continue;
printf("%s ", xkb_keymap_led_get_name(keymap, led));
}
printf("] ");
printf("\n");
}
void
tools_print_state_changes(enum xkb_state_component changed)
{
if (changed == 0)
return;
printf("changed [ ");
if (changed & XKB_STATE_LAYOUT_EFFECTIVE)
printf("effective-layout ");
if (changed & XKB_STATE_LAYOUT_DEPRESSED)
printf("depressed-layout ");
if (changed & XKB_STATE_LAYOUT_LATCHED)
printf("latched-layout ");
if (changed & XKB_STATE_LAYOUT_LOCKED)
printf("locked-layout ");
if (changed & XKB_STATE_MODS_EFFECTIVE)
printf("effective-mods ");
if (changed & XKB_STATE_MODS_DEPRESSED)
printf("depressed-mods ");
if (changed & XKB_STATE_MODS_LATCHED)
printf("latched-mods ");
if (changed & XKB_STATE_MODS_LOCKED)
printf("locked-mods ");
if (changed & XKB_STATE_LEDS)
printf("leds ");
printf("]\n");
}
#ifdef _MSC_VER
void
test_disable_stdin_echo(void)
tools_disable_stdin_echo(void)
{
HANDLE stdin_handle = GetStdHandle(STD_INPUT_HANDLE);
DWORD mode = 0;
@ -57,7 +168,7 @@ test_disable_stdin_echo(void)
}
void
test_enable_stdin_echo(void)
tools_enable_stdin_echo(void)
{
HANDLE stdin_handle = GetStdHandle(STD_INPUT_HANDLE);
DWORD mode = 0;
@ -66,7 +177,7 @@ test_enable_stdin_echo(void)
}
#else
void
test_disable_stdin_echo(void)
tools_disable_stdin_echo(void)
{
/* Same as `stty -echo`. */
struct termios termios;
@ -77,7 +188,7 @@ test_disable_stdin_echo(void)
}
void
test_enable_stdin_echo(void)
tools_enable_stdin_echo(void)
{
/* Same as `stty echo`. */
struct termios termios;

67
tools/tools-common.h
View File

@ -23,6 +23,10 @@
* Author: Daniel Stone <daniel@fooishbar.org>
*/
#pragma once
#include "config.h"
#include <assert.h>
/* Don't use compat names in internal code. */
@ -31,67 +35,20 @@
#include "xkbcommon/xkbcommon-compose.h"
#include "utils.h"
/* The offset between KEY_* numbering, and keycodes in the XKB evdev
* dataset. */
#define EVDEV_OFFSET 8
enum key_seq_state {
DOWN,
REPEAT,
UP,
BOTH,
NEXT,
FINISH,
};
int
test_key_seq(struct xkb_keymap *keymap, ...);
int
test_key_seq_va(struct xkb_keymap *keymap, va_list args);
char *
test_get_path(const char *path_rel);
char *
test_read_file(const char *path_rel);
enum test_context_flags {
CONTEXT_NO_FLAG = 0,
CONTEXT_ALLOW_ENVIRONMENT_NAMES = (1 << 0),
};
struct xkb_context *
test_get_context(enum test_context_flags flags);
struct xkb_keymap *
test_compile_file(struct xkb_context *context, const char *path_rel);
struct xkb_keymap *
test_compile_string(struct xkb_context *context, const char *string);
struct xkb_keymap *
test_compile_buffer(struct xkb_context *context, const char *buf, size_t len);
struct xkb_keymap *
test_compile_rules(struct xkb_context *context, const char *rules,
const char *model, const char *layout, const char *variant,
const char *options);
void
tools_print_keycode_state(struct xkb_state *state,
struct xkb_compose_state *compose_state,
xkb_keycode_t keycode,
enum xkb_consumed_mode consumed_mode);
void
test_print_keycode_state(struct xkb_state *state,
struct xkb_compose_state *compose_state,
xkb_keycode_t keycode,
enum xkb_consumed_mode consumed_mode);
tools_print_state_changes(enum xkb_state_component changed);
void
test_print_state_changes(enum xkb_state_component changed);
tools_disable_stdin_echo(void);
void
test_disable_stdin_echo(void);
void
test_enable_stdin_echo(void);
tools_enable_stdin_echo(void);
#ifdef _MSC_VER
#define setenv(varname, value, overwrite) _putenv_s((varname), (value))