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, [])
