def test_handle_keycode_macro(self): history = [] code_a = 100 code_b = 101 system_mapping.clear() system_mapping._set('a', code_a) system_mapping._set('b', code_b) macro_mapping = { ((EV_KEY, 1, 1),): parse('k(a)', self.mapping), ((EV_KEY, 2, 1),): parse('r(5, k(b))', self.mapping) } context = Context(self.mapping) context.macros = macro_mapping keycode_mapper = KeycodeMapper(context, self.source, None) keycode_mapper.macro_write = lambda *args: history.append(args) keycode_mapper.macro_write = lambda *args: history.append(args) keycode_mapper.handle_keycode(new_event(EV_KEY, 1, 1)) keycode_mapper.handle_keycode(new_event(EV_KEY, 2, 1)) loop = asyncio.get_event_loop() sleeptime = config.get('macros.keystroke_sleep_ms', 10) * 12 # let the mainloop run for some time so that the macro does its stuff loop.run_until_complete(asyncio.sleep(sleeptime / 1000 + 0.1)) # 6 keycodes written, with down and up events self.assertEqual(len(history), 12) self.assertIn((EV_KEY, code_a, 1), history) self.assertIn((EV_KEY, code_a, 0), history) self.assertIn((EV_KEY, code_b, 1), history) self.assertIn((EV_KEY, code_b, 0), history) # releasing stuff self.assertIn((EV_KEY, 1), unreleased) self.assertIn((EV_KEY, 2), unreleased) keycode_mapper.handle_keycode(new_event(EV_KEY, 1, 0)) keycode_mapper.handle_keycode(new_event(EV_KEY, 2, 0)) self.assertNotIn((EV_KEY, 1), unreleased) self.assertNotIn((EV_KEY, 2), unreleased) loop.run_until_complete(asyncio.sleep(0.1)) self.assertEqual(len(history), 12)
def test_refresh_on_start(self): if os.path.exists(get_config_path('xmodmap.json')): os.remove(get_config_path('xmodmap.json')) ev = (EV_KEY, 9) keycode_to = 100 group_name = '9876 name' # expected key of the group group_key = group_name group = groups.find(name=group_name) # this test only makes sense if this device is unknown yet self.assertIsNone(group) custom_mapping.change(Key(*ev, 1), 'a') system_mapping.clear() system_mapping._set('a', keycode_to) # make the daemon load the file instead with open(get_config_path('xmodmap.json'), 'w') as file: json.dump(system_mapping._mapping, file, indent=4) system_mapping.clear() preset = 'foo' custom_mapping.save(get_preset_path(group_name, preset)) config.set_autoload_preset(group_key, preset) push_events(group_key, [new_event(*ev, 1)]) self.daemon = Daemon() # make sure the devices are populated groups.refresh() # the daemon is supposed to find this device by calling refresh fixtures[self.new_fixture_path] = { 'capabilities': { evdev.ecodes.EV_KEY: [ev[1]] }, 'phys': '9876 phys', 'info': evdev.device.DeviceInfo(4, 5, 6, 7), 'name': group_name } self.daemon.set_config_dir(get_config_path()) self.daemon.start_injecting(group_key, preset) # test if the injector called groups.refresh successfully group = groups.find(key=group_key) self.assertEqual(group.name, group_name) self.assertEqual(group.key, group_key) time.sleep(0.1) self.assertTrue(uinput_write_history_pipe[0].poll()) event = uinput_write_history_pipe[0].recv() self.assertEqual(event.t, (EV_KEY, keycode_to, 1)) self.daemon.stop_injecting(group_key) self.assertEqual(self.daemon.get_state(group_key), STOPPED)
def test_reading_ignore_duplicate_down(self): send_event_to_reader(new_event(EV_ABS, ABS_Z, 1, 10)) self.assertEqual(reader.read(), (EV_ABS, ABS_Z, 1)) self.assertEqual(reader.read(), None) # duplicate send_event_to_reader(new_event(EV_ABS, ABS_Z, 1, 10)) self.assertEqual(reader.read(), None) self.assertEqual(len(reader._unreleased), 1) self.assertEqual(len(reader.get_unreleased_keys()), 1) self.assertIsInstance(reader.get_unreleased_keys(), Key) # release send_event_to_reader(new_event(EV_ABS, ABS_Z, 0, 10)) self.assertEqual(reader.read(), None) self.assertEqual(len(reader._unreleased), 0) self.assertIsNone(reader.get_unreleased_keys())
def test_not_forward(self): down = (EV_KEY, 91, 1) up = (EV_KEY, 91, 0) uinput = UInput() context = Context(self.mapping) context.uinput = uinput keycode_mapper = KeycodeMapper(context, self.source, uinput) keycode_mapper.handle_keycode(new_event(*down), forward=False) self.assertEqual(unreleased[(EV_KEY, 91)].input_event_tuple, down) self.assertEqual(unreleased[(EV_KEY, 91)].target_type_code, down[:2]) self.assertEqual(len(unreleased), 1) self.assertEqual(uinput.write_count, 0) keycode_mapper.handle_keycode(new_event(*up), forward=False) self.assertEqual(len(unreleased), 0) self.assertEqual(uinput.write_count, 0)
def test_d_pad_combination(self): ev_1 = (EV_ABS, ABS_HAT0X, 1) ev_2 = (EV_ABS, ABS_HAT0Y, -1) ev_3 = (EV_ABS, ABS_HAT0X, 0) ev_4 = (EV_ABS, ABS_HAT0Y, 0) _key_to_code = { (ev_1, ev_2): 51, (ev_2,): 52, } uinput = UInput() context = Context(self.mapping) context.uinput = uinput context.key_to_code = _key_to_code keycode_mapper = KeycodeMapper(context, self.source, uinput) # a bunch of d-pad key down events at once keycode_mapper.handle_keycode(new_event(*ev_1)) keycode_mapper.handle_keycode(new_event(*ev_2)) # (what_will_be_released, what_caused_the_key_down) self.assertEqual(unreleased.get(ev_1[:2]).target_type_code, (EV_ABS, ABS_HAT0X)) self.assertEqual(unreleased.get(ev_1[:2]).input_event_tuple, ev_1) self.assertEqual(unreleased.get(ev_2[:2]).target_type_code, (EV_KEY, 51)) self.assertEqual(unreleased.get(ev_2[:2]).input_event_tuple, ev_2) self.assertEqual(len(unreleased), 2) # ev_1 is unmapped and the other is the triggered combination self.assertEqual(len(uinput_write_history), 2) self.assertEqual(uinput_write_history[0].t, ev_1) self.assertEqual(uinput_write_history[1].t, (EV_KEY, 51, 1)) # release all of them keycode_mapper.handle_keycode(new_event(*ev_3)) keycode_mapper.handle_keycode(new_event(*ev_4)) self.assertEqual(len(unreleased), 0) self.assertEqual(len(uinput_write_history), 4) self.assertEqual(uinput_write_history[2].t, ev_3) self.assertEqual(uinput_write_history[3].t, (EV_KEY, 51, 0))
def do(self, a, b, c, d, expectation): """Present fake values to the loop and observe the outcome.""" clear_write_history() self.event_producer.context.update_purposes() self.event_producer.notify(new_event(EV_ABS, ABS_X, a)) self.event_producer.notify(new_event(EV_ABS, ABS_Y, b)) self.event_producer.notify(new_event(EV_ABS, ABS_RX, c)) self.event_producer.notify(new_event(EV_ABS, ABS_RY, d)) # 3 frames loop = asyncio.get_event_loop() loop.run_until_complete(asyncio.sleep(3 / 60)) history = [h.t for h in uinput_write_history] # sleep long enough to test if multiple events are written self.assertGreater(len(history), 1) self.assertIn(expectation, history) for history_entry in history: self.assertEqual(history_entry[:2], expectation[:2]) # if the injected cursor movement is 19 or 20 doesn't really matter self.assertClose(history_entry[2], expectation[2], 0.1)
def test_reading_2(self): # a combination of events push_events('device 1', [ new_event(EV_KEY, CODE_1, 1, 10000.1234), new_event(EV_KEY, CODE_3, 1, 10001.1234), new_event(EV_ABS, ABS_HAT0X, -1, 10002.1234) ]) self.create_helper() reader.start_reading('device 1') # sending anything arbitrary does not stop the helper reader._commands.send(856794) time.sleep(0.2) self.assertEqual(reader.read(), ((EV_KEY, CODE_1, 1), (EV_KEY, CODE_3, 1), (EV_ABS, ABS_HAT0X, -1))) self.assertEqual(reader.read(), None) self.assertEqual(len(reader._unreleased), 3)
def test_filter_trigger_spam(self): # test_filter_duplicates trigger = (EV_KEY, BTN_TL) _key_to_code = { ((*trigger, 1),): 51, ((*trigger, -1),): 52 } uinput = UInput() context = Context(self.mapping) context.uinput = uinput context.key_to_code = _key_to_code keycode_mapper = KeycodeMapper(context, self.source, uinput) """positive""" for _ in range(1, 20): keycode_mapper.handle_keycode(new_event(*trigger, 1)) self.assertIn(trigger, unreleased) keycode_mapper.handle_keycode(new_event(*trigger, 0)) self.assertNotIn(trigger, unreleased) self.assertEqual(len(uinput_write_history), 2) """negative""" for _ in range(1, 20): keycode_mapper.handle_keycode(new_event(*trigger, -1)) self.assertIn(trigger, unreleased) keycode_mapper.handle_keycode(new_event(*trigger, 0)) self.assertNotIn(trigger, unreleased) self.assertEqual(len(uinput_write_history), 4) self.assertEqual(uinput_write_history[0].t, (EV_KEY, 51, 1)) self.assertEqual(uinput_write_history[1].t, (EV_KEY, 51, 0)) self.assertEqual(uinput_write_history[2].t, (EV_KEY, 52, 1)) self.assertEqual(uinput_write_history[3].t, (EV_KEY, 52, 0))
def test_switch_device(self): push_events('device 2', [new_event(EV_KEY, CODE_1, 1)]) push_events('device 1', [new_event(EV_KEY, CODE_3, 1)]) self.create_helper() reader.start_reading('device 2') self.assertFalse(reader._results.poll()) self.assertEqual(reader.device_name, 'device 2') time.sleep(EVENT_READ_TIMEOUT * 5) self.assertTrue(reader._results.poll()) reader.start_reading('device 1') self.assertEqual(reader.device_name, 'device 1') self.assertFalse(reader._results.poll()) # pipe resets time.sleep(EVENT_READ_TIMEOUT * 5) self.assertTrue(reader._results.poll()) self.assertEqual(reader.read(), (EV_KEY, CODE_3, 1)) self.assertEqual(reader.read(), None) self.assertEqual(len(reader._unreleased), 1)
def test_gamepad_forward_joysticks(self): push_events( 'gamepad', [ # should forward them unmodified new_event(EV_ABS, ABS_X, 10), new_event(EV_ABS, ABS_Y, 20), new_event(EV_ABS, ABS_X, -30), new_event(EV_ABS, ABS_Y, -40), new_event(EV_KEY, BTN_A, 1), new_event(EV_KEY, BTN_A, 0) ] * 2) custom_mapping.set('gamepad.joystick.left_purpose', NONE) custom_mapping.set('gamepad.joystick.right_purpose', NONE) # BTN_A -> 77 custom_mapping.change(Key((1, BTN_A, 1)), 'b') system_mapping._set('b', 77) self.injector = Injector(groups.find(name='gamepad'), custom_mapping) self.injector.start() # wait for the injector to start sending, at most 1s uinput_write_history_pipe[0].poll(1) time.sleep(0.2) # convert the write history to some easier to manage list history = read_write_history_pipe() self.assertEqual(history.count((EV_ABS, ABS_X, 10)), 2) self.assertEqual(history.count((EV_ABS, ABS_Y, 20)), 2) self.assertEqual(history.count((EV_ABS, ABS_X, -30)), 2) self.assertEqual(history.count((EV_ABS, ABS_Y, -40)), 2) self.assertEqual(history.count((EV_KEY, 77, 1)), 2) self.assertEqual(history.count((EV_KEY, 77, 0)), 2)
def test_macro_writes_to_context_uinput(self): macro_mapping = { ((EV_KEY, 1, 1),): parse('k(a)', self.mapping) } context = Context(self.mapping) context.macros = macro_mapping context.uinput = UInput() forward_to = UInput() keycode_mapper = KeycodeMapper(context, self.source, forward_to) keycode_mapper.handle_keycode(new_event(EV_KEY, 1, 1)) loop = asyncio.get_event_loop() sleeptime = config.get('macros.keystroke_sleep_ms', 10) * 12 loop.run_until_complete(asyncio.sleep(sleeptime / 1000 + 0.1)) self.assertEqual(context.uinput.write_count, 2) # down and up self.assertEqual(forward_to.write_count, 0) keycode_mapper.handle_keycode(new_event(EV_KEY, 2, 1)) self.assertEqual(forward_to.write_count, 1)
def test_change_wheel_direction(self): # not just wheel, anything that suddenly reports a different value. # as long as type and code are equal its the same key, so there is no # way both directions can be held down. self.assertEqual(reader.read(), None) self.create_helper() self.assertEqual(reader.read(), None) reader.start_reading('device 1') self.assertEqual(reader.read(), None) send_event_to_reader(new_event(EV_REL, REL_WHEEL, 1)) self.assertEqual(reader.read(), (EV_REL, REL_WHEEL, 1)) self.assertEqual(len(reader._unreleased), 1) self.assertEqual(reader.read(), None) send_event_to_reader(new_event(EV_REL, REL_WHEEL, -1)) self.assertEqual(reader.read(), (EV_REL, REL_WHEEL, -1)) # notice that this is no combination of two sides, the previous # entry in unreleased has to get overwritten. So there is still only # one element in it. self.assertEqual(len(reader._unreleased), 1) self.assertEqual(reader.read(), None)
def test_filter_combi_mapped_duplicate_down(self): # the opposite of the other test, but don't map the key directly # but rather as the trigger for a combination down_1 = (EV_KEY, 91, 1) down_2 = (EV_KEY, 92, 1) up_1 = (EV_KEY, 91, 0) up_2 = (EV_KEY, 92, 0) uinput = UInput() output = 71 key_to_code = { (down_1, down_2): 71 } context = Context(self.mapping) context.uinput = uinput context.key_to_code = key_to_code keycode_mapper = KeycodeMapper(context, self.source, uinput) keycode_mapper.handle_keycode(new_event(*down_1)) for _ in range(10): keycode_mapper.handle_keycode(new_event(*down_2)) # all duplicate down events should have been ignored self.assertEqual(len(unreleased), 2) self.assertEqual(uinput.write_count, 2) self.assertEqual(uinput_write_history[0].t, down_1) self.assertEqual(uinput_write_history[1].t, (EV_KEY, output, 1)) keycode_mapper.handle_keycode(new_event(*up_1)) keycode_mapper.handle_keycode(new_event(*up_2)) self.assertEqual(len(unreleased), 0) self.assertEqual(uinput.write_count, 4) self.assertEqual(uinput_write_history[2].t, up_1) self.assertEqual(uinput_write_history[3].t, (EV_KEY, output, 0))
def test_xmodmap_file(self): from_keycode = evdev.ecodes.KEY_A to_name = 'qux' to_keycode = 100 event = (EV_KEY, from_keycode, 1) device = 'device 2' preset = 'foo' config_dir = os.path.join(tmp, 'foo') path = os.path.join(config_dir, 'presets', device, f'{preset}.json') custom_mapping.change(Key(event), to_name) custom_mapping.save(path) system_mapping.clear() push_events(device, [ new_event(*event) ]) # an existing config file is needed otherwise set_config_dir refuses # to use the directory config_path = os.path.join(config_dir, 'config.json') config.path = config_path config.save_config() xmodmap_path = os.path.join(config_dir, 'xmodmap.json') with open(xmodmap_path, 'w') as file: file.write(f'{{"{to_name}":{to_keycode}}}') self.daemon = Daemon() self.daemon.set_config_dir(config_dir) self.daemon.start_injecting(device, preset) time.sleep(0.1) self.assertTrue(uinput_write_history_pipe[0].poll()) event = uinput_write_history_pipe[0].recv() self.assertEqual(event.type, EV_KEY) self.assertEqual(event.code, to_keycode) self.assertEqual(event.value, 1)
def test_reading_3(self): self.create_helper() # a combination of events via Socket with reads inbetween reader.start_reading(groups.find(name='gamepad')) send_event_to_reader(new_event(EV_KEY, CODE_1, 1, 1001)) self.assertEqual(reader.read(), ( (EV_KEY, CODE_1, 1) )) custom_mapping.set('gamepad.joystick.left_purpose', BUTTONS) send_event_to_reader(new_event(EV_ABS, ABS_Y, 1, 1002)) self.assertEqual(reader.read(), ( (EV_KEY, CODE_1, 1), (EV_ABS, ABS_Y, 1) )) send_event_to_reader(new_event(EV_ABS, ABS_HAT0X, -1, 1003)) self.assertEqual(reader.read(), ( (EV_KEY, CODE_1, 1), (EV_ABS, ABS_Y, 1), (EV_ABS, ABS_HAT0X, -1) )) # adding duplicate down events won't report a different combination. # import for triggers, as they keep reporting more down-events before # they are released send_event_to_reader(new_event(EV_ABS, ABS_Y, 1, 1005)) self.assertEqual(reader.read(), None) send_event_to_reader(new_event(EV_ABS, ABS_HAT0X, -1, 1006)) self.assertEqual(reader.read(), None) send_event_to_reader(new_event(EV_KEY, CODE_1, 0, 1004)) read = reader.read() self.assertEqual(read, None) send_event_to_reader(new_event(EV_ABS, ABS_Y, 0, 1007)) self.assertEqual(reader.read(), None) send_event_to_reader(new_event(EV_KEY, ABS_HAT0X, 0, 1008)) self.assertEqual(reader.read(), None)
def test_push_events(self): """Test that push_event works properly between helper and reader. Using push_events after the helper is already forked should work, as well as using push_event twice """ def create_helper(): # this will cause pending events to be copied over to the helper # process def start_helper(): helper = RootHelper() helper.run() self.helper = multiprocessing.Process(target=start_helper) self.helper.start() time.sleep(0.1) def wait_for_results(): # wait for the helper to send stuff for _ in range(10): time.sleep(EVENT_READ_TIMEOUT) if reader._results.poll(): break event = new_event(EV_KEY, 102, 1) create_helper() reader.start_reading(groups.find(key='Foo Device 2')) time.sleep(START_READING_DELAY) push_events('Foo Device 2', [event]) wait_for_results() self.assertTrue(reader._results.poll()) reader.clear() self.assertFalse(reader._results.poll()) # can push more events to the helper that is inside a separate # process, which end up being sent to the reader push_events('Foo Device 2', [event]) wait_for_results() self.assertTrue(reader._results.poll())
def test_combination_keycode(self): combination = ((EV_KEY, 1, 1), (EV_KEY, 2, 1)) _key_to_code = { combination: 101 } uinput = UInput() context = Context(self.mapping) context.uinput = uinput context.key_to_code = _key_to_code keycode_mapper = KeycodeMapper(context, self.source, uinput) keycode_mapper.handle_keycode(new_event(*combination[0])) keycode_mapper.handle_keycode(new_event(*combination[1])) self.assertEqual(len(uinput_write_history), 2) # the first event is written and then the triggered combination self.assertEqual(uinput_write_history[0].t, (EV_KEY, 1, 1)) self.assertEqual(uinput_write_history[1].t, (EV_KEY, 101, 1)) # release them keycode_mapper.handle_keycode(new_event(*combination[0][:2], 0)) keycode_mapper.handle_keycode(new_event(*combination[1][:2], 0)) # the first key writes its release event. The second key is hidden # behind the executed combination. The result of the combination is # also released, because it acts like a key. self.assertEqual(len(uinput_write_history), 4) self.assertEqual(uinput_write_history[2].t, (EV_KEY, 1, 0)) self.assertEqual(uinput_write_history[3].t, (EV_KEY, 101, 0)) # press them in the wrong order (the wrong key at the end, the order # of all other keys won't matter). no combination should be triggered keycode_mapper.handle_keycode(new_event(*combination[1])) keycode_mapper.handle_keycode(new_event(*combination[0])) self.assertEqual(len(uinput_write_history), 6) self.assertEqual(uinput_write_history[4].t, (EV_KEY, 2, 1)) self.assertEqual(uinput_write_history[5].t, (EV_KEY, 1, 1))
def test_wheel(self): # this tests both keycode_mapper and event_producer, and it seems # to test stuff not covered in test_keycode_mapper, so it's a quite # important one. # wheel release events are made up with a debouncer # map those two to stuff w_up = (EV_REL, REL_WHEEL, -1) hw_right = (EV_REL, REL_HWHEEL, 1) # should be forwarded and present in the capabilities hw_left = (EV_REL, REL_HWHEEL, -1) custom_mapping.change(Key(*hw_right), 'k(b)') custom_mapping.change(Key(*w_up), 'c') system_mapping.clear() code_b = 91 code_c = 92 system_mapping._set('b', code_b) system_mapping._set('c', code_c) group_key = 'Foo Device 2' push_events(group_key, [ new_event(*w_up), ] * 10 + [ new_event(*hw_right), new_event(*w_up), ] * 5 + [new_event(*hw_left)]) group = groups.find(key=group_key) self.injector = Injector(group, custom_mapping) device = InputDevice('/dev/input/event11') # make sure this test uses a device that has the needed capabilities # for the injector to grab it self.assertIn(EV_REL, device.capabilities()) self.assertIn(REL_WHEEL, device.capabilities()[EV_REL]) self.assertIn(REL_HWHEEL, device.capabilities()[EV_REL]) self.assertIn(device.path, group.paths) self.injector.start() # wait for the first injected key down event uinput_write_history_pipe[0].poll(timeout=1) self.assertTrue(uinput_write_history_pipe[0].poll()) event = uinput_write_history_pipe[0].recv() self.assertEqual(event.t, (EV_KEY, code_c, 1)) time.sleep(EVENT_READ_TIMEOUT * 5) # in 5 more read-loop ticks, nothing new should have happened self.assertFalse(uinput_write_history_pipe[0].poll()) time.sleep(EVENT_READ_TIMEOUT * 6) # 5 more and it should be within the second phase in which # the horizontal wheel is used. add some tolerance self.assertTrue(uinput_write_history_pipe[0].poll()) event = uinput_write_history_pipe[0].recv() self.assertEqual(event.t, (EV_KEY, code_b, 1)) time.sleep(EVENT_READ_TIMEOUT * 10 + 5 / 60) # after 21 read-loop ticks all events should be consumed, wait for # at least 3 (=5) producer-ticks so that the debouncers are triggered. # Key-up events for both wheel events should be written now that no # new key-down event arrived. events = read_write_history_pipe() self.assertEqual(events.count((EV_KEY, code_b, 0)), 1) self.assertEqual(events.count((EV_KEY, code_c, 0)), 1) self.assertEqual(events.count(hw_left), 1) # the unmapped wheel # the unmapped wheel won't get a debounced release command, it's # forwarded as is self.assertNotIn((EV_REL, REL_HWHEEL, 0), events) self.assertEqual(len(events), 3)
def test_injector(self): # the tests in test_keycode_mapper.py test this stuff in detail numlock_before = is_numlock_on() combination = Key((EV_KEY, 8, 1), (EV_KEY, 9, 1)) custom_mapping.change(combination, 'k(KEY_Q).k(w)') custom_mapping.change(Key(EV_ABS, ABS_HAT0X, -1), 'a') # one mapping that is unknown in the system_mapping on purpose input_b = 10 custom_mapping.change(Key(EV_KEY, input_b, 1), 'b') # stuff the custom_mapping outputs (except for the unknown b) system_mapping.clear() code_a = 100 code_q = 101 code_w = 102 system_mapping._set('a', code_a) system_mapping._set('key_q', code_q) system_mapping._set('w', code_w) push_events( 'Bar Device', [ # should execute a macro... new_event(EV_KEY, 8, 1), new_event(EV_KEY, 9, 1), # ...now new_event(EV_KEY, 8, 0), new_event(EV_KEY, 9, 0), # gamepad stuff. trigger a combination new_event(EV_ABS, ABS_HAT0X, -1), new_event(EV_ABS, ABS_HAT0X, 0), # just pass those over without modifying new_event(EV_KEY, 10, 1), new_event(EV_KEY, 10, 0), new_event(3124, 3564, 6542), ]) self.injector = Injector(groups.find(name='Bar Device'), custom_mapping) self.assertEqual(self.injector.get_state(), UNKNOWN) self.injector.start() self.assertEqual(self.injector.get_state(), STARTING) uinput_write_history_pipe[0].poll(timeout=1) self.assertEqual(self.injector.get_state(), RUNNING) time.sleep(EVENT_READ_TIMEOUT * 10) # sending anything arbitrary does not stop the process # (is_alive checked later after some time) self.injector._msg_pipe[1].send(1234) # convert the write history to some easier to manage list history = read_write_history_pipe() # 1 event before the combination was triggered (+1 for release) # 4 events for the macro # 2 for mapped keys # 3 for forwarded events self.assertEqual(len(history), 11) # since the macro takes a little bit of time to execute, its # keystrokes are all over the place. # just check if they are there and if so, remove them from the list. self.assertIn((EV_KEY, 8, 1), history) self.assertIn((EV_KEY, code_q, 1), history) self.assertIn((EV_KEY, code_q, 1), history) self.assertIn((EV_KEY, code_q, 0), history) self.assertIn((EV_KEY, code_w, 1), history) self.assertIn((EV_KEY, code_w, 0), history) index_q_1 = history.index((EV_KEY, code_q, 1)) index_q_0 = history.index((EV_KEY, code_q, 0)) index_w_1 = history.index((EV_KEY, code_w, 1)) index_w_0 = history.index((EV_KEY, code_w, 0)) self.assertGreater(index_q_0, index_q_1) self.assertGreater(index_w_1, index_q_0) self.assertGreater(index_w_0, index_w_1) del history[index_q_1] index_q_0 = history.index((EV_KEY, code_q, 0)) del history[index_q_0] index_w_1 = history.index((EV_KEY, code_w, 1)) del history[index_w_1] index_w_0 = history.index((EV_KEY, code_w, 0)) del history[index_w_0] # the rest should be in order. # first the incomplete combination key that wasn't mapped to anything # and just forwarded. The input event that triggered the macro # won't appear here. self.assertEqual(history[0], (EV_KEY, 8, 1)) self.assertEqual(history[1], (EV_KEY, 8, 0)) # value should be 1, even if the input event was -1. # Injected keycodes should always be either 0 or 1 self.assertEqual(history[2], (EV_KEY, code_a, 1)) self.assertEqual(history[3], (EV_KEY, code_a, 0)) self.assertEqual(history[4], (EV_KEY, input_b, 1)) self.assertEqual(history[5], (EV_KEY, input_b, 0)) self.assertEqual(history[6], (3124, 3564, 6542)) time.sleep(0.1) self.assertTrue(self.injector.is_alive()) numlock_after = is_numlock_on() self.assertEqual(numlock_before, numlock_after) self.assertEqual(self.injector.get_state(), RUNNING)
def test_daemon(self): # remove the existing system mapping to force our own into it if os.path.exists(get_config_path('xmodmap.json')): os.remove(get_config_path('xmodmap.json')) ev_1 = (EV_KEY, 9) ev_2 = (EV_ABS, 12) keycode_to_1 = 100 keycode_to_2 = 101 group = groups.find(name='Bar Device') # unrelated group that shouldn't be affected at all group2 = groups.find(name='gamepad') custom_mapping.change(Key(*ev_1, 1), 'a') custom_mapping.change(Key(*ev_2, -1), 'b') system_mapping.clear() # since this is in the same memory as the daemon, there is no need # to save it to disk system_mapping._set('a', keycode_to_1) system_mapping._set('b', keycode_to_2) preset = 'foo' custom_mapping.save(group.get_preset_path(preset)) config.set_autoload_preset(group.key, preset) """injection 1""" # should forward the event unchanged push_events(group.key, [new_event(EV_KEY, 13, 1)]) self.daemon = Daemon() self.daemon.set_config_dir(get_config_path()) self.assertFalse(uinput_write_history_pipe[0].poll()) self.daemon.start_injecting(group.key, preset) self.assertEqual(self.daemon.get_state(group.key), STARTING) self.assertEqual(self.daemon.get_state(group2.key), UNKNOWN) event = uinput_write_history_pipe[0].recv() self.assertEqual(self.daemon.get_state(group.key), RUNNING) self.assertEqual(event.type, EV_KEY) self.assertEqual(event.code, 13) self.assertEqual(event.value, 1) self.daemon.stop_injecting(group.key) self.assertEqual(self.daemon.get_state(group.key), STOPPED) time.sleep(0.1) try: self.assertFalse(uinput_write_history_pipe[0].poll()) except AssertionError: print('Unexpected', uinput_write_history_pipe[0].recv()) # possibly a duplicate write! raise """injection 2""" # -1234 will be normalized to -1 by the injector push_events(group.key, [new_event(*ev_2, -1234)]) self.daemon.start_injecting(group.key, preset) time.sleep(0.1) self.assertTrue(uinput_write_history_pipe[0].poll()) # the written key is a key-down event, not the original # event value of -1234 event = uinput_write_history_pipe[0].recv() self.assertEqual(event.type, EV_KEY) self.assertEqual(event.code, keycode_to_2) self.assertEqual(event.value, 1)
def test_combination_keycode_2(self): combination_1 = ( (EV_KEY, 1, 1), (EV_ABS, ABS_Y, MIN_ABS), (EV_KEY, 3, 1), (EV_KEY, 4, 1) ) combination_2 = ( # should not be triggered, combination_1 should be prioritized # when all of its keys are down (EV_KEY, 2, 1), (EV_KEY, 3, 1), (EV_KEY, 4, 1) ) down_5 = (EV_KEY, 5, 1) up_5 = (EV_KEY, 5, 0) up_4 = (EV_KEY, 4, 0) def sign_value(key): return key[0], key[1], key[2] / abs(key[2]) _key_to_code = { # key_to_code is supposed to only contain normalized values tuple([sign_value(a) for a in combination_1]): 101, combination_2: 102, (down_5,): 103 } uinput = UInput() source = InputDevice('/dev/input/event30') # ABS_Y is part of the combination, which only works if the joystick # is configured as D-Pad self.mapping.set('gamepad.joystick.left_purpose', BUTTONS) context = Context(self.mapping) context.uinput = uinput context.key_to_code = _key_to_code keycode_mapper = KeycodeMapper(context, source, uinput) # 10 and 11: insert some more arbitrary key-down events, # they should not break the combinations keycode_mapper.handle_keycode(new_event(EV_KEY, 10, 1)) keycode_mapper.handle_keycode(new_event(*combination_1[0])) keycode_mapper.handle_keycode(new_event(*combination_1[1])) keycode_mapper.handle_keycode(new_event(*combination_1[2])) keycode_mapper.handle_keycode(new_event(EV_KEY, 11, 1)) keycode_mapper.handle_keycode(new_event(*combination_1[3])) # combination_1 should have been triggered now self.assertEqual(len(uinput_write_history), 6) # the first events are written and then the triggered combination, # while the triggering event is the only one that is omitted self.assertEqual(uinput_write_history[1].t, combination_1[0]) self.assertEqual(uinput_write_history[2].t, combination_1[1]) self.assertEqual(uinput_write_history[3].t, combination_1[2]) self.assertEqual(uinput_write_history[5].t, (EV_KEY, 101, 1)) # while the combination is down, another unrelated key can be used keycode_mapper.handle_keycode(new_event(*down_5)) # the keycode_mapper searches for subsets of the current held-down # keys to activate combinations, down_5 should not trigger them # again. self.assertEqual(len(uinput_write_history), 7) self.assertEqual(uinput_write_history[6].t, (EV_KEY, 103, 1)) # release the combination by releasing the last key, and release # the unrelated key keycode_mapper.handle_keycode(new_event(*up_4)) keycode_mapper.handle_keycode(new_event(*up_5)) self.assertEqual(len(uinput_write_history), 9) self.assertEqual(uinput_write_history[7].t, (EV_KEY, 101, 0)) self.assertEqual(uinput_write_history[8].t, (EV_KEY, 103, 0))
def test_is_wheel(self): self.assertTrue(utils.is_wheel(new_event(EV_REL, REL_WHEEL, 1))) self.assertTrue(utils.is_wheel(new_event(EV_REL, REL_HWHEEL, -1))) self.assertFalse(utils.is_wheel(new_event(EV_KEY, KEY_A, 1))) self.assertFalse(utils.is_wheel(new_event(EV_ABS, ABS_HAT0X, -1)))
def test_should_map_as_btn(self): mapping = Mapping() def do(gamepad, event): return utils.should_map_as_btn(event, mapping, gamepad) """D-Pad""" self.assertTrue(do(1, new_event(EV_ABS, ABS_HAT0X, 1))) self.assertTrue(do(0, new_event(EV_ABS, ABS_HAT0X, -1))) """Mouse movements""" self.assertTrue(do(1, new_event(EV_REL, REL_WHEEL, 1))) self.assertTrue(do(0, new_event(EV_REL, REL_WHEEL, -1))) self.assertTrue(do(1, new_event(EV_REL, REL_HWHEEL, 1))) self.assertTrue(do(0, new_event(EV_REL, REL_HWHEEL, -1))) self.assertFalse(do(1, new_event(EV_REL, REL_X, -1))) """regular keys and buttons""" self.assertTrue(do(1, new_event(EV_KEY, KEY_A, 1))) self.assertTrue(do(0, new_event(EV_KEY, KEY_A, 1))) self.assertTrue(do(1, new_event(EV_ABS, ABS_HAT0X, -1))) self.assertTrue(do(0, new_event(EV_ABS, ABS_HAT0X, -1))) """mousepad events""" self.assertFalse(do(1, new_event(EV_ABS, ecodes.ABS_MT_SLOT, 1))) self.assertFalse(do(0, new_event(EV_ABS, ecodes.ABS_MT_SLOT, 1))) self.assertFalse(do(1, new_event(EV_ABS, ecodes.ABS_MT_TOOL_Y, 1))) self.assertFalse(do(0, new_event(EV_ABS, ecodes.ABS_MT_TOOL_Y, 1))) self.assertFalse(do(1, new_event(EV_ABS, ecodes.ABS_MT_POSITION_X, 1))) self.assertFalse(do(0, new_event(EV_ABS, ecodes.ABS_MT_POSITION_X, 1))) self.assertFalse(do(1, new_event(EV_KEY, ecodes.BTN_TOUCH, 1))) self.assertFalse(do(0, new_event(EV_KEY, ecodes.BTN_TOUCH, 1))) """stylus movements""" self.assertFalse(do(0, new_event(EV_KEY, ecodes.BTN_DIGI, 1))) self.assertFalse(do(1, new_event(EV_KEY, ecodes.BTN_DIGI, 1))) self.assertFalse(do(0, new_event(EV_ABS, ecodes.ABS_TILT_X, 1))) self.assertFalse(do(1, new_event(EV_ABS, ecodes.ABS_TILT_X, 1))) self.assertFalse(do(0, new_event(EV_ABS, ecodes.ABS_TILT_Y, 1))) self.assertFalse(do(1, new_event(EV_ABS, ecodes.ABS_TILT_Y, 1))) self.assertFalse(do(0, new_event(EV_ABS, ecodes.ABS_DISTANCE, 1))) self.assertFalse(do(1, new_event(EV_ABS, ecodes.ABS_DISTANCE, 1))) self.assertFalse(do(0, new_event(EV_ABS, ecodes.ABS_PRESSURE, 1))) self.assertFalse(do(1, new_event(EV_ABS, ecodes.ABS_PRESSURE, 1))) """joysticks""" # without a purpose of BUTTONS it won't map any button, even for # gamepads self.assertFalse(do(0, new_event(EV_ABS, ecodes.ABS_RX, 1234))) self.assertFalse(do(1, new_event(EV_ABS, ecodes.ABS_RX, 1234))) self.assertFalse(do(0, new_event(EV_ABS, ecodes.ABS_Y, -1))) self.assertFalse(do(1, new_event(EV_ABS, ecodes.ABS_Y, -1))) self.assertFalse(do(0, new_event(EV_ABS, ecodes.ABS_RY, -1))) self.assertFalse(do(1, new_event(EV_ABS, ecodes.ABS_RY, -1))) mapping.set('gamepad.joystick.right_purpose', BUTTONS) config.set('gamepad.joystick.left_purpose', BUTTONS) # but only for gamepads self.assertFalse(do(0, new_event(EV_ABS, ecodes.ABS_Y, -1))) self.assertTrue(do(1, new_event(EV_ABS, ecodes.ABS_Y, -1))) self.assertFalse(do(0, new_event(EV_ABS, ecodes.ABS_RY, -1))) self.assertTrue(do(1, new_event(EV_ABS, ecodes.ABS_RY, -1))) """weird events""" self.assertFalse(do(0, new_event(EV_ABS, ecodes.ABS_MISC, -1))) self.assertFalse(do(1, new_event(EV_ABS, ecodes.ABS_MISC, -1)))
def test_reading_wheel(self): # will be treated as released automatically at some point self.create_helper() reader.start_reading('device 1') send_event_to_reader(new_event(EV_REL, REL_WHEEL, 0)) self.assertIsNone(reader.read()) send_event_to_reader(new_event(EV_REL, REL_WHEEL, 1)) result = reader.read() self.assertIsInstance(result, Key) self.assertEqual(result, (EV_REL, REL_WHEEL, 1)) self.assertEqual(result, ((EV_REL, REL_WHEEL, 1), )) self.assertNotEqual(result, ((EV_REL, REL_WHEEL, 1), (1, 1, 1))) self.assertEqual(result.keys, ((EV_REL, REL_WHEEL, 1), )) # it won't return the same event twice self.assertEqual(reader.read(), None) # but it is still remembered unreleased self.assertEqual(len(reader._unreleased), 1) self.assertEqual(reader.get_unreleased_keys(), (EV_REL, REL_WHEEL, 1)) self.assertIsInstance(reader.get_unreleased_keys(), Key) # as long as new wheel events arrive, it is considered unreleased for _ in range(10): send_event_to_reader(new_event(EV_REL, REL_WHEEL, 1)) self.assertEqual(reader.read(), None) self.assertEqual(len(reader._unreleased), 1) # read a few more times, at some point it is treated as unreleased for _ in range(4): self.assertEqual(reader.read(), None) self.assertEqual(len(reader._unreleased), 0) self.assertIsNone(reader.get_unreleased_keys()) """combinations""" send_event_to_reader(new_event(EV_REL, REL_WHEEL, 1, 1000)) send_event_to_reader(new_event(EV_KEY, KEY_COMMA, 1, 1001)) combi_1 = ((EV_REL, REL_WHEEL, 1), (EV_KEY, KEY_COMMA, 1)) combi_2 = ((EV_KEY, KEY_COMMA, 1), (EV_KEY, KEY_A, 1)) read = reader.read() self.assertEqual(read, combi_1) self.assertEqual(reader.read(), None) self.assertEqual(len(reader._unreleased), 2) self.assertEqual(reader.get_unreleased_keys(), combi_1) # don't send new wheel down events, it should get released again i = 0 while len(reader._unreleased) == 2: read = reader.read() if i == 100: raise AssertionError('Did not release the wheel') i += 1 # and only the comma remains. However, a changed combination is # only returned when a new key is pressed. Only then the pressed # down keys are collected in a new Key object. self.assertEqual(read, None) self.assertEqual(reader.read(), None) self.assertEqual(len(reader._unreleased), 1) self.assertEqual(reader.get_unreleased_keys(), combi_1[1]) # press down a new key, now it will return a different combination send_event_to_reader(new_event(EV_KEY, KEY_A, 1, 1002)) self.assertEqual(reader.read(), combi_2) self.assertEqual(len(reader._unreleased), 2) # release all of them send_event_to_reader(new_event(EV_KEY, KEY_COMMA, 0)) send_event_to_reader(new_event(EV_KEY, KEY_A, 0)) self.assertEqual(reader.read(), None) self.assertEqual(len(reader._unreleased), 0) self.assertEqual(reader.get_unreleased_keys(), None)
def test_normalize_value(self): """""" """0 to MAX_ABS""" def do(event): return utils.normalize_value(event, (0, MAX_ABS)) event = new_event(EV_ABS, ecodes.ABS_RX, MAX_ABS) self.assertEqual(do(event), 1) event = new_event(EV_ABS, ecodes.ABS_Y, MAX_ABS) self.assertEqual(do(event), 1) event = new_event(EV_ABS, ecodes.ABS_Y, 0) self.assertEqual(do(event), -1) event = new_event(EV_ABS, ecodes.ABS_X, MAX_ABS // 4) self.assertEqual(do(event), -1) event = new_event(EV_ABS, ecodes.ABS_X, MAX_ABS // 2) self.assertEqual(do(event), 0) """MIN_ABS to MAX_ABS""" def do2(event): return utils.normalize_value(event, (MIN_ABS, MAX_ABS)) event = new_event(EV_ABS, ecodes.ABS_RX, MAX_ABS) self.assertEqual(do2(event), 1) event = new_event(EV_ABS, ecodes.ABS_Y, MIN_ABS) self.assertEqual(do2(event), -1) event = new_event(EV_ABS, ecodes.ABS_X, MIN_ABS // 4) self.assertEqual(do2(event), 0) event = new_event(EV_ABS, ecodes.ABS_RX, MAX_ABS) self.assertEqual(do2(event), 1) event = new_event(EV_ABS, ecodes.ABS_Y, MAX_ABS) self.assertEqual(do2(event), 1) event = new_event(EV_ABS, ecodes.ABS_X, MAX_ABS // 4) self.assertEqual(do2(event), 0) """None""" # it just forwards the value event = new_event(EV_ABS, ecodes.ABS_RX, MAX_ABS) self.assertEqual(utils.normalize_value(event, None), MAX_ABS) """Not a joystick""" event = new_event(EV_ABS, ecodes.ABS_Z, 1234) self.assertEqual(do(event), 1) self.assertEqual(do2(event), 1) event = new_event(EV_ABS, ecodes.ABS_Z, 0) self.assertEqual(do(event), 0) self.assertEqual(do2(event), 0) event = new_event(EV_ABS, ecodes.ABS_Z, -1234) self.assertEqual(do(event), -1) self.assertEqual(do2(event), -1) event = new_event(EV_KEY, ecodes.KEY_A, 1) self.assertEqual(do(event), 1) self.assertEqual(do2(event), 1) event = new_event(EV_ABS, ecodes.ABS_HAT0X, 0) self.assertEqual(do(event), 0) self.assertEqual(do2(event), 0) event = new_event(EV_ABS, ecodes.ABS_HAT0X, -1) self.assertEqual(do(event), -1) self.assertEqual(do2(event), -1)
def test_hold(self): history = [] code_a = 100 code_b = 101 code_c = 102 system_mapping.clear() system_mapping._set('a', code_a) system_mapping._set('b', code_b) system_mapping._set('c', code_c) macro_mapping = { ((EV_KEY, 1, 1),): parse('k(a).h(k(b)).k(c)', self.mapping) } def handler(*args): history.append(args) context = Context(self.mapping) context.macros = macro_mapping keycode_mapper = KeycodeMapper(context, self.source, None) keycode_mapper.macro_write = handler """start macro""" keycode_mapper.handle_keycode(new_event(EV_KEY, 1, 1)) loop = asyncio.get_event_loop() # let the mainloop run for some time so that the macro does its stuff sleeptime = 500 keystroke_sleep = config.get('macros.keystroke_sleep_ms', 10) loop.run_until_complete(asyncio.sleep(sleeptime / 1000)) self.assertTrue(active_macros[(EV_KEY, 1)].is_holding()) self.assertTrue(active_macros[(EV_KEY, 1)].running) """stop macro""" keycode_mapper.handle_keycode(new_event(EV_KEY, 1, 0)) loop.run_until_complete(asyncio.sleep(keystroke_sleep * 10 / 1000)) events = calculate_event_number(sleeptime, 1, 1) self.assertGreater(len(history), events * 0.9) self.assertLess(len(history), events * 1.1) self.assertIn((EV_KEY, code_a, 1), history) self.assertIn((EV_KEY, code_a, 0), history) self.assertIn((EV_KEY, code_b, 1), history) self.assertIn((EV_KEY, code_b, 0), history) self.assertIn((EV_KEY, code_c, 1), history) self.assertIn((EV_KEY, code_c, 0), history) self.assertGreater(history.count((EV_KEY, code_b, 1)), 1) self.assertGreater(history.count((EV_KEY, code_b, 0)), 1) # it's stopped and won't write stuff anymore count_before = len(history) loop.run_until_complete(asyncio.sleep(0.2)) count_after = len(history) self.assertEqual(count_before, count_after) self.assertFalse(active_macros[(EV_KEY, 1)].is_holding()) self.assertFalse(active_macros[(EV_KEY, 1)].running)
def test_hold_2(self): # test irregular input patterns code_a = 100 code_b = 101 code_c = 102 code_d = 103 system_mapping.clear() system_mapping._set('a', code_a) system_mapping._set('b', code_b) system_mapping._set('c', code_c) system_mapping._set('d', code_d) macro_mapping = { ((EV_KEY, 1, 1),): parse('h(k(b))', self.mapping), ((EV_KEY, 2, 1),): parse('k(c).r(1, r(1, r(1, h(k(a))))).k(d)', self.mapping), ((EV_KEY, 3, 1),): parse('h(k(b))', self.mapping) } history = [] def handler(*args): history.append(args) context = Context(self.mapping) context.macros = macro_mapping keycode_mapper = KeycodeMapper(context, self.source, None) keycode_mapper.macro_write = handler keycode_mapper.macro_write = handler keycode_mapper.macro_write = handler """start macro 2""" keycode_mapper.handle_keycode(new_event(EV_KEY, 2, 1)) loop = asyncio.get_event_loop() loop.run_until_complete(asyncio.sleep(0.1)) # starting code_c written self.assertEqual(history.count((EV_KEY, code_c, 1)), 1) self.assertEqual(history.count((EV_KEY, code_c, 0)), 1) # spam garbage events for _ in range(5): keycode_mapper.handle_keycode(new_event(EV_KEY, 1, 1)) keycode_mapper.handle_keycode(new_event(EV_KEY, 3, 1)) loop.run_until_complete(asyncio.sleep(0.05)) self.assertTrue(active_macros[(EV_KEY, 1)].is_holding()) self.assertTrue(active_macros[(EV_KEY, 1)].running) self.assertTrue(active_macros[(EV_KEY, 2)].is_holding()) self.assertTrue(active_macros[(EV_KEY, 2)].running) self.assertTrue(active_macros[(EV_KEY, 3)].is_holding()) self.assertTrue(active_macros[(EV_KEY, 3)].running) # there should only be one code_c in the events, because no key # up event was ever done so the hold just continued self.assertEqual(history.count((EV_KEY, code_c, 1)), 1) self.assertEqual(history.count((EV_KEY, code_c, 0)), 1) # without an key up event on 2, it won't write code_d self.assertNotIn((code_d, 1), history) self.assertNotIn((code_d, 0), history) # stop macro 2 keycode_mapper.handle_keycode(new_event(EV_KEY, 2, 0)) loop.run_until_complete(asyncio.sleep(0.1)) # it stopped and didn't restart, so the count stays at 1 self.assertEqual(history.count((EV_KEY, code_c, 1)), 1) self.assertEqual(history.count((EV_KEY, code_c, 0)), 1) # and the trailing d was written self.assertEqual(history.count((EV_KEY, code_d, 1)), 1) self.assertEqual(history.count((EV_KEY, code_d, 0)), 1) # it's stopped and won't write stuff anymore count_before = history.count((EV_KEY, code_a, 1)) self.assertGreater(count_before, 1) loop.run_until_complete(asyncio.sleep(0.1)) count_after = history.count((EV_KEY, code_a, 1)) self.assertEqual(count_before, count_after) """restart macro 2""" history = [] keycode_mapper.handle_keycode(new_event(EV_KEY, 2, 1)) loop.run_until_complete(asyncio.sleep(0.1)) self.assertEqual(history.count((EV_KEY, code_c, 1)), 1) self.assertEqual(history.count((EV_KEY, code_c, 0)), 1) # spam garbage events again, this time key-up events on all other # macros for _ in range(5): keycode_mapper.handle_keycode(new_event(EV_KEY, 1, 0)) keycode_mapper.handle_keycode(new_event(EV_KEY, 3, 0)) loop.run_until_complete(asyncio.sleep(0.05)) self.assertFalse(active_macros[(EV_KEY, 1)].is_holding()) self.assertFalse(active_macros[(EV_KEY, 1)].running) self.assertTrue(active_macros[(EV_KEY, 2)].is_holding()) self.assertTrue(active_macros[(EV_KEY, 2)].running) self.assertFalse(active_macros[(EV_KEY, 3)].is_holding()) self.assertFalse(active_macros[(EV_KEY, 3)].running) # stop macro 2 keycode_mapper.handle_keycode(new_event(EV_KEY, 2, 0)) loop.run_until_complete(asyncio.sleep(0.1)) # was started only once self.assertEqual(history.count((EV_KEY, code_c, 1)), 1) self.assertEqual(history.count((EV_KEY, code_c, 0)), 1) # and the trailing d was also written only once self.assertEqual(history.count((EV_KEY, code_d, 1)), 1) self.assertEqual(history.count((EV_KEY, code_d, 0)), 1) # stop all macros keycode_mapper.handle_keycode(new_event(EV_KEY, 1, 0)) keycode_mapper.handle_keycode(new_event(EV_KEY, 3, 0)) loop.run_until_complete(asyncio.sleep(0.1)) # it's stopped and won't write stuff anymore count_before = len(history) loop.run_until_complete(asyncio.sleep(0.1)) count_after = len(history) self.assertEqual(count_before, count_after) self.assertFalse(active_macros[(EV_KEY, 1)].is_holding()) self.assertFalse(active_macros[(EV_KEY, 1)].running) self.assertFalse(active_macros[(EV_KEY, 2)].is_holding()) self.assertFalse(active_macros[(EV_KEY, 2)].running) self.assertFalse(active_macros[(EV_KEY, 3)].is_holding()) self.assertFalse(active_macros[(EV_KEY, 3)].running)
def test_combine_triggers(self): reader.start_reading('device 1') i = 0 def next_timestamp(): nonlocal i i += 1 return time.time() + i # based on an observed bug send_event_to_reader(new_event(3, 1, 0, next_timestamp())) send_event_to_reader(new_event(3, 0, 0, next_timestamp())) send_event_to_reader(new_event(3, 2, 1, next_timestamp())) self.assertEqual(reader.read(), (EV_ABS, ABS_Z, 1)) send_event_to_reader(new_event(3, 0, 0, next_timestamp())) send_event_to_reader(new_event(3, 5, 1, next_timestamp())) self.assertEqual(reader.read(), ((EV_ABS, ABS_Z, 1), (EV_ABS, ABS_RZ, 1))) send_event_to_reader(new_event(3, 5, 0, next_timestamp())) send_event_to_reader(new_event(3, 0, 0, next_timestamp())) send_event_to_reader(new_event(3, 1, 0, next_timestamp())) self.assertEqual(reader.read(), None) send_event_to_reader(new_event(3, 2, 1, next_timestamp())) send_event_to_reader(new_event(3, 1, 0, next_timestamp())) send_event_to_reader(new_event(3, 0, 0, next_timestamp())) # due to not properly handling the duplicate down event it cleared # the combination and returned it. Instead it should report None # and by doing that keep the previous combination. self.assertEqual(reader.read(), None)
def test_hold_two(self): # holding two macros at the same time, # the first one is triggered by a combination history = [] code_1 = 100 code_2 = 101 code_3 = 102 code_a = 103 code_b = 104 code_c = 105 system_mapping.clear() system_mapping._set('1', code_1) system_mapping._set('2', code_2) system_mapping._set('3', code_3) system_mapping._set('a', code_a) system_mapping._set('b', code_b) system_mapping._set('c', code_c) key_0 = (EV_KEY, 10) key_1 = (EV_KEY, 11) key_2 = (EV_ABS, ABS_HAT0X) down_0 = (*key_0, 1) down_1 = (*key_1, 1) down_2 = (*key_2, -1) up_0 = (*key_0, 0) up_1 = (*key_1, 0) up_2 = (*key_2, 0) macro_mapping = { (down_0, down_1): parse('k(1).h(k(2)).k(3)', self.mapping), (down_2,): parse('k(a).h(k(b)).k(c)', self.mapping) } def handler(*args): history.append(args) loop = asyncio.get_event_loop() context = Context(self.mapping) context.macros = macro_mapping uinput_1 = UInput() context.uinput = uinput_1 keycode_mapper = KeycodeMapper(context, self.source, uinput_1) keycode_mapper.macro_write = handler # key up won't do anything keycode_mapper.handle_keycode(new_event(*up_0)) keycode_mapper.handle_keycode(new_event(*up_1)) keycode_mapper.handle_keycode(new_event(*up_2)) loop.run_until_complete(asyncio.sleep(0.1)) self.assertEqual(len(active_macros), 0) """start macros""" uinput_2 = UInput() context.uinput = uinput_2 keycode_mapper = KeycodeMapper(context, self.source, uinput_2) keycode_mapper.macro_write = handler keycode_mapper.handle_keycode(new_event(*down_0)) self.assertEqual(uinput_2.write_count, 1) keycode_mapper.handle_keycode(new_event(*down_1)) keycode_mapper.handle_keycode(new_event(*down_2)) self.assertEqual(uinput_2.write_count, 1) # let the mainloop run for some time so that the macro does its stuff sleeptime = 500 keystroke_sleep = config.get('macros.keystroke_sleep_ms', 10) loop.run_until_complete(asyncio.sleep(sleeptime / 1000)) self.assertEqual(len(active_macros), 2) self.assertTrue(active_macros[key_1].is_holding()) self.assertTrue(active_macros[key_1].running) self.assertTrue(active_macros[key_2].is_holding()) self.assertTrue(active_macros[key_2].running) self.assertIn(down_0[:2], unreleased) self.assertIn(down_1[:2], unreleased) self.assertIn(down_2[:2], unreleased) """stop macros""" keycode_mapper = KeycodeMapper(context, self.source, None) # releasing the last key of a combination releases the whole macro keycode_mapper.handle_keycode(new_event(*up_1)) keycode_mapper.handle_keycode(new_event(*up_2)) self.assertIn(down_0[:2], unreleased) self.assertNotIn(down_1[:2], unreleased) self.assertNotIn(down_2[:2], unreleased) loop.run_until_complete(asyncio.sleep(keystroke_sleep * 10 / 1000)) self.assertFalse(active_macros[key_1].is_holding()) self.assertFalse(active_macros[key_1].running) self.assertFalse(active_macros[key_2].is_holding()) self.assertFalse(active_macros[key_2].running) events = calculate_event_number(sleeptime, 1, 1) * 2 self.assertGreater(len(history), events * 0.9) self.assertLess(len(history), events * 1.1) self.assertIn((EV_KEY, code_a, 1), history) self.assertIn((EV_KEY, code_a, 0), history) self.assertIn((EV_KEY, code_b, 1), history) self.assertIn((EV_KEY, code_b, 0), history) self.assertIn((EV_KEY, code_c, 1), history) self.assertIn((EV_KEY, code_c, 0), history) self.assertIn((EV_KEY, code_1, 1), history) self.assertIn((EV_KEY, code_1, 0), history) self.assertIn((EV_KEY, code_2, 1), history) self.assertIn((EV_KEY, code_2, 0), history) self.assertIn((EV_KEY, code_3, 1), history) self.assertIn((EV_KEY, code_3, 0), history) self.assertGreater(history.count((EV_KEY, code_b, 1)), 1) self.assertGreater(history.count((EV_KEY, code_b, 0)), 1) self.assertGreater(history.count((EV_KEY, code_2, 1)), 1) self.assertGreater(history.count((EV_KEY, code_2, 0)), 1) # it's stopped and won't write stuff anymore count_before = len(history) loop.run_until_complete(asyncio.sleep(0.2)) count_after = len(history) self.assertEqual(count_before, count_after)
def test_wheel_combination_release_failure(self): # test based on a bug that once occurred # 1 | 22.6698, ((1, 276, 1)) -------------- forwarding # 2 | 22.9904, ((1, 276, 1), (2, 8, -1)) -- maps to 30 # 3 | 23.0103, ((1, 276, 1), (2, 8, -1)) -- duplicate key down # 4 | ... 34 more duplicate key downs (scrolling) # 5 | 23.7104, ((1, 276, 1), (2, 8, -1)) -- duplicate key down # 6 | 23.7283, ((1, 276, 0)) -------------- forwarding release # 7 | 23.7303, ((2, 8, -1)) --------------- forwarding # 8 | 23.7865, ((2, 8, 0)) ---------------- not forwarding release # line 7 should have been "duplicate key down" as well # line 8 should have released 30, instead it was never released scroll = (2, 8, -1) scroll_up = (2, 8, 0) btn_down = (1, 276, 1) btn_up = (1, 276, 0) combination = ((1, 276, 1), (2, 8, -1)) system_mapping.clear() system_mapping._set('a', 30) k2c = {combination: 30} uinput = UInput() context = Context(self.mapping) context.uinput = uinput context.key_to_code = k2c keycode_mapper = KeycodeMapper(context, self.source, uinput) keycode_mapper.handle_keycode(new_event(*btn_down)) # "forwarding" self.assertEqual(uinput_write_history[0].t, btn_down) keycode_mapper.handle_keycode(new_event(*scroll)) # "maps to 30" self.assertEqual(uinput_write_history[1].t, (1, 30, 1)) for _ in range(5): # keep scrolling # "duplicate key down" keycode_mapper.handle_keycode(new_event(*scroll)) # nothing new since all of them were duplicate key downs self.assertEqual(len(uinput_write_history), 2) keycode_mapper.handle_keycode(new_event(*btn_up)) # "forwarding release" self.assertEqual(uinput_write_history[2].t, btn_up) # one more scroll event. since the combination is still not released, # it should be ignored as duplicate key-down self.assertEqual(len(uinput_write_history), 3) # "forwarding" (should be "duplicate key down") keycode_mapper.handle_keycode(new_event(*scroll)) self.assertEqual(len(uinput_write_history), 3) # the failure to release the mapped key # forward=False is what the debouncer uses, because a # "scroll release" doesn't actually exist so it is not actually # written if it doesn't release any mapping keycode_mapper.handle_keycode(new_event(*scroll_up), forward=False) # 30 should be released self.assertEqual(uinput_write_history[3].t, (1, 30, 0)) self.assertEqual(len(uinput_write_history), 4)