def test_two_d_pad_macros(self): # executing two macros that stop automatically at the same time code_1 = 61 code_2 = 62 system_mapping.clear() system_mapping._set('1', code_1) system_mapping._set('2', code_2) # try two concurrent macros with D-Pad events because they are # more difficult to manage, since their only difference is their # value, and one of them is negative. right = (EV_ABS, ABS_HAT0X, 1) release = (EV_ABS, ABS_HAT0X, 0) left = (EV_ABS, ABS_HAT0X, -1) repeats = 10 macro_mapping = { (right,): parse(f'r({repeats}, k(1))', self.mapping), (left,): parse(f'r({repeats}, k(2))', 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.handle_keycode(new_event(*right)) self.assertIn((EV_ABS, ABS_HAT0X), unreleased) keycode_mapper.handle_keycode(new_event(*release)) self.assertNotIn((EV_ABS, ABS_HAT0X), unreleased) keycode_mapper.handle_keycode(new_event(*left)) self.assertIn((EV_ABS, ABS_HAT0X), unreleased) loop = asyncio.get_event_loop() sleeptime = config.get('macros.keystroke_sleep_ms') / 1000 loop.run_until_complete(asyncio.sleep(1.1 * repeats * 2 * sleeptime)) self.assertEqual(history.count((EV_KEY, code_1, 1)), 10) self.assertEqual(history.count((EV_KEY, code_1, 0)), 10) self.assertEqual(history.count((EV_KEY, code_2, 1)), 10) self.assertEqual(history.count((EV_KEY, code_2, 0)), 10) self.assertEqual(len(history), repeats * 4)
def test_hold(self): # repeats k(a) as long as the key is held down macro = parse('k(1).h(k(a)).k(3)', self.mapping) self.assertSetEqual( macro.get_capabilities()[EV_KEY], { system_mapping.get('1'), system_mapping.get('a'), system_mapping.get('3') }) """down""" macro.press_key() self.loop.run_until_complete(asyncio.sleep(0.05)) self.assertTrue(macro.is_holding()) macro.press_key() # redundantly calling doesn't break anything asyncio.ensure_future(macro.run(self.handler)) self.loop.run_until_complete(asyncio.sleep(0.2)) self.assertTrue(macro.is_holding()) self.assertGreater(len(self.result), 2) """up""" macro.release_key() self.loop.run_until_complete(asyncio.sleep(0.05)) self.assertFalse(macro.is_holding()) self.assertEqual(self.result[0], (EV_KEY, system_mapping.get('1'), 1)) self.assertEqual(self.result[-1], (EV_KEY, system_mapping.get('3'), 0)) code_a = system_mapping.get('a') self.assertGreater(self.result.count((EV_KEY, code_a, 1)), 2) self.assertEqual(len(macro.child_macros), 1)
def test_hold_down(self): # writes down and waits for the up event until the key is released macro = parse('h(a)', self.mapping) self.assertSetEqual(macro.get_capabilities()[EV_KEY], { system_mapping.get('a'), }) self.assertEqual(len(macro.child_macros), 0) """down""" macro.press_key() self.loop.run_until_complete(asyncio.sleep(0.05)) self.assertTrue(macro.is_holding()) asyncio.ensure_future(macro.run(self.handler)) macro.press_key() # redundantly calling doesn't break anything self.loop.run_until_complete(asyncio.sleep(0.2)) self.assertTrue(macro.is_holding()) self.assertEqual(len(self.result), 1) self.assertEqual(self.result[0], (EV_KEY, system_mapping.get('a'), 1)) """up""" macro.release_key() self.loop.run_until_complete(asyncio.sleep(0.05)) self.assertFalse(macro.is_holding()) self.assertEqual(len(self.result), 2) self.assertEqual(self.result[0], (EV_KEY, system_mapping.get('a'), 1)) self.assertEqual(self.result[1], (EV_KEY, system_mapping.get('a'), 0))
def test_ifeq_runs_multiprocessed(self): macro = parse('ifeq(foo, 3, k(a), k(b))', self.mapping) code_a = system_mapping.get('a') code_b = system_mapping.get('b') self.assertSetEqual(macro.get_capabilities()[EV_KEY], {code_a, code_b}) self.assertSetEqual(macro.get_capabilities()[EV_REL], set()) self.assertEqual(len(macro.child_macros), 2) def set_foo(value): # will write foo = 2 into the shared dictionary of macros macro_2 = parse(f'set(foo, {value})', self.mapping) loop = asyncio.new_event_loop() loop.run_until_complete(macro_2.run(lambda: None)) """foo is not 3""" process = multiprocessing.Process(target=set_foo, args=(2, )) process.start() process.join() self.loop.run_until_complete(macro.run(self.handler)) self.assertListEqual(self.result, [(EV_KEY, code_b, 1), (EV_KEY, code_b, 0)]) """foo is 3""" process = multiprocessing.Process(target=set_foo, args=(3, )) process.start() process.join() self.loop.run_until_complete(macro.run(self.handler)) self.assertListEqual(self.result, [(EV_KEY, code_b, 1), (EV_KEY, code_b, 0), (EV_KEY, code_a, 1), (EV_KEY, code_a, 0)])
def test_5(self): start = time.time() macro = parse('w(200).r(2,m(w,\nr(2,\tk(BtN_LeFt))).w(10).k(k))', self.mapping) self.assertEqual(len(macro.child_macros), 1) self.assertEqual(len(macro.child_macros[0].child_macros), 1) w = system_mapping.get('w') left = system_mapping.get('bTn_lEfT') k = system_mapping.get('k') self.assertSetEqual(macro.get_capabilities()[EV_KEY], {w, left, k}) self.loop.run_until_complete(macro.run(self.handler)) num_pauses = 8 + 6 + 4 keystroke_time = num_pauses * self.mapping.get( 'macros.keystroke_sleep_ms') wait_time = 220 total_time = (keystroke_time + wait_time) / 1000 self.assertLess(time.time() - start, total_time * 1.1) self.assertGreater(time.time() - start, total_time * 0.9) expected = [(EV_KEY, w, 1)] expected += [(EV_KEY, left, 1), (EV_KEY, left, 0)] * 2 expected += [(EV_KEY, w, 0)] expected += [(EV_KEY, k, 1), (EV_KEY, k, 0)] expected *= 2 self.assertListEqual(self.result, expected)
def test_run_plus_syntax(self): macro = parse('a + b + c + d', self.mapping) self.assertSetEqual( macro.get_capabilities()[EV_KEY], { system_mapping.get('a'), system_mapping.get('b'), system_mapping.get('c'), system_mapping.get('d') }) macro.press_key() asyncio.ensure_future(macro.run(self.handler)) self.loop.run_until_complete(asyncio.sleep(0.2)) self.assertTrue(macro.is_holding()) # starting from the left, presses each one down self.assertEqual(self.result[0], (EV_KEY, system_mapping.get('a'), 1)) self.assertEqual(self.result[1], (EV_KEY, system_mapping.get('b'), 1)) self.assertEqual(self.result[2], (EV_KEY, system_mapping.get('c'), 1)) self.assertEqual(self.result[3], (EV_KEY, system_mapping.get('d'), 1)) # and then releases starting with the previously pressed key macro.release_key() self.loop.run_until_complete(asyncio.sleep(0.2)) self.assertFalse(macro.is_holding()) self.assertEqual(self.result[4], (EV_KEY, system_mapping.get('d'), 0)) self.assertEqual(self.result[5], (EV_KEY, system_mapping.get('c'), 0)) self.assertEqual(self.result[6], (EV_KEY, system_mapping.get('b'), 0)) self.assertEqual(self.result[7], (EV_KEY, system_mapping.get('a'), 0))
def test_just_hold(self): macro = parse('k(1).h().k(3)', self.mapping) self.assertSetEqual(macro.get_capabilities()[EV_KEY], {system_mapping.get('1'), system_mapping.get('3')}) """down""" macro.press_key() asyncio.ensure_future(macro.run(self.handler)) self.loop.run_until_complete(asyncio.sleep(0.1)) self.assertTrue(macro.is_holding()) self.assertEqual(len(self.result), 2) self.loop.run_until_complete(asyncio.sleep(0.1)) # doesn't do fancy stuff, is blocking until the release self.assertEqual(len(self.result), 2) """up""" macro.release_key() self.loop.run_until_complete(asyncio.sleep(0.05)) self.assertFalse(macro.is_holding()) self.assertEqual(len(self.result), 4) self.assertEqual(self.result[0], (EV_KEY, system_mapping.get('1'), 1)) self.assertEqual(self.result[-1], (EV_KEY, system_mapping.get('3'), 0)) self.assertEqual(len(macro.child_macros), 0)
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_event_1(self): macro = parse('e(EV_KEY, KEY_A, 1)', self.mapping) a_code = system_mapping.get('a') self.assertSetEqual(macro.get_capabilities()[EV_KEY], {a_code}) self.assertSetEqual(macro.get_capabilities()[EV_REL], set()) self.loop.run_until_complete(macro.run(self.handler)) self.assertListEqual(self.result, [(EV_KEY, a_code, 1)]) self.assertEqual(len(macro.child_macros), 0)
def test_hold_3(self): # test irregular input patterns 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), } 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.handle_keycode(new_event(EV_KEY, 1, 1)) loop = asyncio.get_event_loop() loop.run_until_complete(asyncio.sleep(0.1)) for _ in range(5): self.assertTrue(active_macros[(EV_KEY, 1)].is_holding()) self.assertTrue(active_macros[(EV_KEY, 1)].running) keycode_mapper.handle_keycode(new_event(EV_KEY, 1, 1)) loop.run_until_complete(asyncio.sleep(0.05)) # duplicate key down events don't do anything self.assertEqual(history.count((EV_KEY, code_a, 1)), 1) self.assertEqual(history.count((EV_KEY, code_a, 0)), 1) self.assertEqual(history.count((EV_KEY, code_c, 1)), 0) self.assertEqual(history.count((EV_KEY, code_c, 0)), 0) # stop keycode_mapper.handle_keycode(new_event(EV_KEY, 1, 0)) loop.run_until_complete(asyncio.sleep(0.1)) self.assertEqual(history.count((EV_KEY, code_a, 1)), 1) self.assertEqual(history.count((EV_KEY, code_a, 0)), 1) self.assertEqual(history.count((EV_KEY, code_c, 1)), 1) self.assertEqual(history.count((EV_KEY, code_c, 0)), 1) self.assertFalse(active_macros[(EV_KEY, 1)].is_holding()) self.assertFalse(active_macros[(EV_KEY, 1)].running) # 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)
def test_keystroke_sleep_config(self): # global config as fallback config.set('macros.keystroke_sleep_ms', 100) start = time.time() macro = parse('k(a).k(b)', self.mapping) self.loop.run_until_complete(macro.run(self.handler)) delta = time.time() - start # is currently over 400, k(b) adds another sleep afterwards # that doesn't do anything self.assertGreater(delta, 0.300) # now set the value in the mapping, which is prioritized self.mapping.set('macros.keystroke_sleep_ms', 50) start = time.time() macro = parse('k(a).k(b)', self.mapping) self.loop.run_until_complete(macro.run(self.handler)) delta = time.time() - start self.assertGreater(delta, 0.150) self.assertLess(delta, 0.300)
def test_0(self): macro = parse('k(1)', self.mapping) one_code = system_mapping.get('1') self.assertSetEqual(macro.get_capabilities()[EV_KEY], {one_code}) self.assertSetEqual(macro.get_capabilities()[EV_REL], set()) self.loop.run_until_complete(macro.run(self.handler)) self.assertListEqual(self.result, [(EV_KEY, one_code, 1), (EV_KEY, one_code, 0)]) self.assertEqual(len(macro.child_macros), 0)
def test_event_2(self): macro = parse('r(1, e(5421, 324, 154))', self.mapping) code = 324 self.assertSetEqual(macro.get_capabilities()[5421], {324}) self.assertSetEqual(macro.get_capabilities()[EV_REL], set()) self.assertSetEqual(macro.get_capabilities()[EV_KEY], set()) self.loop.run_until_complete(macro.run(self.handler)) self.assertListEqual(self.result, [(5421, code, 154)]) self.assertEqual(len(macro.child_macros), 1)
def test_duplicate_run(self): # it won't restart the macro, because that may screw up the # internal state (in particular the _holding_lock). # I actually don't know at all what kind of bugs that might produce, # lets just avoid it. It might cause it to be held down forever. a = system_mapping.get('a') b = system_mapping.get('b') c = system_mapping.get('c') macro = parse('k(a).m(b, h()).k(c)', self.mapping) asyncio.ensure_future(macro.run(self.handler)) self.assertFalse(macro.is_holding()) asyncio.ensure_future(macro.run(self.handler)) # ignored self.assertFalse(macro.is_holding()) macro.press_key() self.loop.run_until_complete(asyncio.sleep(0.2)) self.assertTrue(macro.is_holding()) asyncio.ensure_future(macro.run(self.handler)) # ignored self.assertTrue(macro.is_holding()) macro.release_key() self.loop.run_until_complete(asyncio.sleep(0.2)) self.assertFalse(macro.is_holding()) expected = [ (EV_KEY, a, 1), (EV_KEY, a, 0), (EV_KEY, b, 1), (EV_KEY, b, 0), (EV_KEY, c, 1), (EV_KEY, c, 0), ] self.assertListEqual(self.result, expected) """not ignored, since previous run is over""" asyncio.ensure_future(macro.run(self.handler)) macro.press_key() self.loop.run_until_complete(asyncio.sleep(0.2)) self.assertTrue(macro.is_holding()) macro.release_key() self.loop.run_until_complete(asyncio.sleep(0.2)) self.assertFalse(macro.is_holding()) expected = [ (EV_KEY, a, 1), (EV_KEY, a, 0), (EV_KEY, b, 1), (EV_KEY, b, 0), (EV_KEY, c, 1), (EV_KEY, c, 0), ] * 2 self.assertListEqual(self.result, expected)
def test_ifeq_unknown_key(self): macro = parse('ifeq(qux, 2, k(a), k(b))', self.mapping) code_a = system_mapping.get('a') code_b = system_mapping.get('b') self.assertSetEqual(macro.get_capabilities()[EV_KEY], {code_a, code_b}) self.assertSetEqual(macro.get_capabilities()[EV_REL], set()) self.loop.run_until_complete(macro.run(self.handler)) self.assertListEqual(self.result, [(EV_KEY, code_b, 1), (EV_KEY, code_b, 0)]) self.assertEqual(len(macro.child_macros), 2)
def check_macro_syntax(self): """Check if the programmed macros are allright.""" self.show_status(CTX_MAPPING, None) for key, output in custom_mapping: if not is_this_a_macro(output): continue error = parse(output, custom_mapping, return_errors=True) if error is None: continue position = to_string(key) msg = f'Syntax error at {position}, hover for info' self.show_status(CTX_MAPPING, msg, error)
def test_mouse(self): macro_1 = parse('mouse(up, 4)', self.mapping) macro_2 = parse('wheel(left, 3)', self.mapping) macro_1.press_key() macro_2.press_key() asyncio.ensure_future(macro_1.run(self.handler)) asyncio.ensure_future(macro_2.run(self.handler)) self.loop.run_until_complete(asyncio.sleep(0.1)) self.assertTrue(macro_1.is_holding()) self.assertTrue(macro_2.is_holding()) macro_1.release_key() macro_2.release_key() self.assertIn((EV_REL, REL_Y, -4), self.result) self.assertIn((EV_REL, REL_HWHEEL, 1), self.result) self.assertIn(REL_WHEEL, macro_1.get_capabilities()[EV_REL]) self.assertIn(REL_Y, macro_1.get_capabilities()[EV_REL]) self.assertIn(REL_X, macro_1.get_capabilities()[EV_REL]) self.assertIn(REL_WHEEL, macro_2.get_capabilities()[EV_REL]) self.assertIn(REL_Y, macro_2.get_capabilities()[EV_REL]) self.assertIn(REL_X, macro_2.get_capabilities()[EV_REL])
def setUp(self): class FakeDevice: def __init__(self): self._capabilities = { evdev.ecodes.EV_SYN: [1, 2, 3], evdev.ecodes.EV_FF: [1, 2, 3], EV_ABS: [(1, evdev.AbsInfo(value=None, min=None, max=1234, fuzz=None, flat=None, resolution=None)), (2, evdev.AbsInfo(value=None, min=50, max=2345, fuzz=None, flat=None, resolution=None)), 3] } def capabilities(self, absinfo=False): assert absinfo is True return self._capabilities mapping = Mapping() mapping.change(Key(EV_KEY, 80, 1), 'a') mapping.change(Key(EV_KEY, 81, 1), DISABLE_NAME) macro_code = 'r(2, m(sHiFt_l, r(2, k(1).k(2))))' macro = parse(macro_code, mapping) mapping.change(Key(EV_KEY, 60, 111), macro_code) # going to be ignored, because EV_REL cannot be mapped, that's # mouse movements. mapping.change(Key(EV_REL, 1234, 3), 'b') self.a = system_mapping.get('a') self.shift_l = system_mapping.get('ShIfT_L') self.one = system_mapping.get(1) self.two = system_mapping.get('2') self.left = system_mapping.get('BtN_lEfT') self.fake_device = FakeDevice() self.mapping = mapping self.macro = macro
def _parse_macros(self): """To quickly get the target macro during operation.""" logger.debug('Parsing macros') macros = {} for key, output in self.mapping: if is_this_a_macro(output): macro = parse(output, self.mapping) if macro is None: continue for permutation in key.get_permutations(): macros[permutation.keys] = macro if len(macros) == 0: logger.debug('No macros configured') return macros
def test_dont_just_hold(self): macro = parse('k(1).h().k(3)', self.mapping) self.assertSetEqual(macro.get_capabilities()[EV_KEY], {system_mapping.get('1'), system_mapping.get('3')}) asyncio.ensure_future(macro.run(self.handler)) self.loop.run_until_complete(asyncio.sleep(0.1)) self.assertFalse(macro.is_holding()) # since press_key was never called it just does the macro # completely self.assertEqual(len(self.result), 4) self.assertEqual(self.result[0], (EV_KEY, system_mapping.get('1'), 1)) self.assertEqual(self.result[-1], (EV_KEY, system_mapping.get('3'), 0)) self.assertEqual(len(macro.child_macros), 0)
def test_2(self): start = time.time() repeats = 20 macro = parse(f'r({repeats}, k(k)).r(1, k(k))', self.mapping) k_code = system_mapping.get('k') self.assertSetEqual(macro.get_capabilities()[EV_KEY], {k_code}) self.loop.run_until_complete(macro.run(self.handler)) keystroke_sleep = self.mapping.get('macros.keystroke_sleep_ms') sleep_time = 2 * repeats * keystroke_sleep / 1000 self.assertGreater(time.time() - start, sleep_time * 0.9) self.assertLess(time.time() - start, sleep_time * 1.1) self.assertListEqual(self.result, [(EV_KEY, k_code, 1), (EV_KEY, k_code, 0)] * (repeats + 1)) self.assertEqual(len(macro.child_macros), 2) self.assertEqual(len(macro.child_macros[0].child_macros), 0)
def test_dont_hold(self): macro = parse('k(1).h(k(a)).k(3)', self.mapping) self.assertSetEqual( macro.get_capabilities()[EV_KEY], { system_mapping.get('1'), system_mapping.get('a'), system_mapping.get('3') }) asyncio.ensure_future(macro.run(self.handler)) self.loop.run_until_complete(asyncio.sleep(0.2)) self.assertFalse(macro.is_holding()) # press_key was never called, so the macro completes right away # and the child macro of hold is never called. self.assertEqual(len(self.result), 4) self.assertEqual(self.result[0], (EV_KEY, system_mapping.get('1'), 1)) self.assertEqual(self.result[-1], (EV_KEY, system_mapping.get('3'), 0)) self.assertEqual(len(macro.child_macros), 1)
def test_1(self): # quotation marks are removed automatically and don't do any harm macro = parse('k(1).k("a").k(3)', self.mapping) self.assertSetEqual( macro.get_capabilities()[EV_KEY], { system_mapping.get('1'), system_mapping.get('a'), system_mapping.get('3') }) self.loop.run_until_complete(macro.run(self.handler)) self.assertListEqual(self.result, [ (EV_KEY, system_mapping.get('1'), 1), (EV_KEY, system_mapping.get('1'), 0), (EV_KEY, system_mapping.get('a'), 1), (EV_KEY, system_mapping.get('a'), 0), (EV_KEY, system_mapping.get('3'), 1), (EV_KEY, system_mapping.get('3'), 0), ]) self.assertEqual(len(macro.child_macros), 0)
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_3(self): start = time.time() macro = parse('r(3, k(m).w(100))', self.mapping) m_code = system_mapping.get('m') self.assertSetEqual(macro.get_capabilities()[EV_KEY], {m_code}) self.loop.run_until_complete(macro.run(self.handler)) keystroke_time = 6 * self.mapping.get('macros.keystroke_sleep_ms') total_time = keystroke_time + 300 total_time /= 1000 self.assertGreater(time.time() - start, total_time * 0.9) self.assertLess(time.time() - start, total_time * 1.1) self.assertListEqual(self.result, [ (EV_KEY, m_code, 1), (EV_KEY, m_code, 0), (EV_KEY, m_code, 1), (EV_KEY, m_code, 0), (EV_KEY, m_code, 1), (EV_KEY, m_code, 0), ]) self.assertEqual(len(macro.child_macros), 1) self.assertEqual(len(macro.child_macros[0].child_macros), 0)
def test_4(self): macro = parse(' r(2,\nk(\nr ).k(minus\n )).k(m) ', self.mapping) r = system_mapping.get('r') minus = system_mapping.get('minus') m = system_mapping.get('m') self.assertSetEqual(macro.get_capabilities()[EV_KEY], {r, minus, m}) self.loop.run_until_complete(macro.run(self.handler)) self.assertListEqual(self.result, [ (EV_KEY, r, 1), (EV_KEY, r, 0), (EV_KEY, minus, 1), (EV_KEY, minus, 0), (EV_KEY, r, 1), (EV_KEY, r, 0), (EV_KEY, minus, 1), (EV_KEY, minus, 0), (EV_KEY, m, 1), (EV_KEY, m, 0), ]) self.assertEqual(len(macro.child_macros), 1) self.assertEqual(len(macro.child_macros[0].child_macros), 0)
def test_fails(self): self.assertIsNone(parse('r(1, a)', self.mapping)) self.assertIsNone(parse('r(a, k(b))', self.mapping)) self.assertIsNone(parse('m(a, b)', self.mapping))
def test_return_errors(self): error = parse('k(1).h(k(a)).k(3)', self.mapping, return_errors=True) self.assertIsNone(error) error = parse('k(1))', self.mapping, return_errors=True) self.assertIn('bracket', error) error = parse('k((1)', self.mapping, return_errors=True) self.assertIn('bracket', error) error = parse('k((1).k)', self.mapping, return_errors=True) self.assertIsNotNone(error) error = parse('r(a, k(1))', self.mapping, return_errors=True) self.assertIsNotNone(error) error = parse('k()', self.mapping, return_errors=True) self.assertIsNotNone(error) error = parse('k(1)', self.mapping, return_errors=True) self.assertIsNone(error) error = parse('k(1, 1)', self.mapping, return_errors=True) self.assertIsNotNone(error) error = parse('h(1, 1)', self.mapping, return_errors=True) self.assertIsNotNone(error) error = parse('h(h(h(1, 1)))', self.mapping, return_errors=True) self.assertIsNotNone(error) error = parse('r(1)', self.mapping, return_errors=True) self.assertIsNotNone(error) error = parse('r(1, 1)', self.mapping, return_errors=True) self.assertIsNotNone(error) error = parse('r(k(1), 1)', self.mapping, return_errors=True) self.assertIsNotNone(error) error = parse('r(1, k(1))', self.mapping, return_errors=True) self.assertIsNone(error) error = parse('m(asdf, k(a))', self.mapping, return_errors=True) self.assertIsNotNone(error) error = parse('foo(a)', self.mapping, return_errors=True) self.assertIn('unknown', error.lower()) self.assertIn('foo', error)
def set_foo(value): # will write foo = 2 into the shared dictionary of macros macro_2 = parse(f'set(foo, {value})', self.mapping) loop = asyncio.new_event_loop() loop.run_until_complete(macro_2.run(lambda: None))
def test_6(self): # does nothing without .run macro = parse('k(a).r(3, k(b))', self.mapping) self.assertIsInstance(macro, _Macro) self.assertListEqual(self.result, [])