def test_call_repeatedly(self):
t = timer2.Timer()
try:
t.schedule.enter_after = Mock()
myfun = Mock()
myfun.__name__ = 'myfun'
t.call_repeatedly(0.03, myfun)
self.assertEqual(t.schedule.enter_after.call_count, 1)
args1, _ = t.schedule.enter_after.call_args_list[0]
sec1, tref1, _ = args1
self.assertEqual(sec1, 0.03)
tref1()
self.assertEqual(t.schedule.enter_after.call_count, 2)
args2, _ = t.schedule.enter_after.call_args_list[1]
sec2, tref2, _ = args2
self.assertEqual(sec2, 0.03)
tref2.canceled = True
tref2()
self.assertEqual(t.schedule.enter_after.call_count, 2)
finally:
t.stop()
def test_apply_interval(self):
t = timer2.Timer()
try:
t.schedule.enter_after = Mock()
myfun = Mock()
myfun.__name__ = 'myfun'
t.apply_interval(30, myfun)
self.assertEqual(t.schedule.enter_after.call_count, 1)
args1, _ = t.schedule.enter_after.call_args_list[0]
msec1, tref1, _ = args1
self.assertEqual(msec1, 30)
tref1()
self.assertEqual(t.schedule.enter_after.call_count, 2)
args2, _ = t.schedule.enter_after.call_args_list[1]
msec2, tref2, _ = args2
self.assertEqual(msec2, 30)
tref2.cancelled = True
tref2()
self.assertEqual(t.schedule.enter_after.call_count, 2)
finally:
t.stop()
def test_gc_race_lost(self):
t = timer2.Timer()
t._is_stopped.set = Mock()
t._is_stopped.set.side_effect = TypeError()
t._is_shutdown.set()
t.run()
t._is_stopped.set.assert_called_with()
def test_apply_entry_error_handled(self, logger):
t = timer2.Timer()
t.schedule.on_error = None
fun = Mock()
fun.side_effect = ValueError()
t.schedule.apply_entry(fun)
self.assertTrue(logger.error.called)
def test_on_tick(self, sleep):
on_tick = Mock(name='on_tick')
t = timer2.Timer(on_tick=on_tick)
ne = t._next_entry = Mock(name='_next_entry')
ne.return_value = 3.33
self.on_nth_call_do(ne, t._is_shutdown.set, 3)
t.run()
sleep.assert_called_with(3.33)
on_tick.assert_has_calls([call(3.33), call(3.33), call(3.33)])
def test_apply_entry_error_not_handled(self, stdout, stderr):
t = timer2.Timer()
t.schedule.on_error = Mock()
fun = Mock()
fun.side_effect = ValueError()
t.schedule.apply_entry(fun)
fun.assert_called_with()
self.assertFalse(stderr.getvalue())
def test_apply_entry_error_handled(self, stdout, stderr):
t = timer2.Timer()
t.schedule.on_error = None
fun = Mock()
fun.side_effect = ValueError()
with self.assertWarns(timer2.TimedFunctionFailed):
t.apply_entry(fun)
fun.assert_called_with()
def test_ensure_started_not_started(self):
t = timer2.Timer()
t.running = True
t.start = Mock()
t.ensure_started()
self.assertFalse(t.start.called)
t.running = False
t.on_start = Mock()
t.ensure_started()
t.on_start.assert_called_with(t)
t.start.assert_called_with()
def test_gc_race_lost(self):
t = timer2.Timer()
with patch.object(t, "_Timer__is_stopped") as mock_stop_event:
# Mark the timer as shutting down so we escape the run loop,
# mocking the running state so we don't block!
with patch.object(t, "running", new=False):
t.stop()
# Pretend like the interpreter has shutdown and GCed built-in
# modules, causing an exception
mock_stop_event.set.side_effect = TypeError()
t.run()
mock_stop_event.set.assert_called_with()
def test_apply_entry_error_not_handled(self, stdout, stderr):
t = timer2.Timer()
t.schedule.on_error = Mock()
fun = Mock()
fun.side_effect = ValueError()
warnings.resetwarnings()
with catch_warnings(record=True) as log:
t.apply_entry(fun)
fun.assert_called_with()
self.assertFalse(log)
self.assertFalse(stderr.getvalue())
def test_enter_after(self):
t = timer2.Timer()
done = [False]
def set_done():
done[0] = True
try:
t.apply_after(300, set_done)
while not done[0]:
time.sleep(0.1)
finally:
t.stop()
def test_enter_after(self):
t = timer2.Timer()
try:
done = [False]
def set_done():
done[0] = True
t.apply_after(300, set_done)
mss = 0
while not done[0]:
if mss >= 2.0:
raise Exception('test timed out')
time.sleep(0.1)
mss += 0.1
finally:
t.stop()
def test_on_tick(self, sleep):
def next_entry_side_effect():
# side effect simulating following scenario:
# 3.33, 3.33, 3.33, <shutdown event set>
for _ in range(3):
yield 3.33
while True:
yield t._is_shutdown.set()
on_tick = Mock(name='on_tick')
t = timer2.Timer(on_tick=on_tick)
t._next_entry = Mock(
name='_next_entry', side_effect=next_entry_side_effect()
)
t.run()
sleep.assert_called_with(3.33)
on_tick.assert_has_calls([call(3.33), call(3.33), call(3.33)])
def test_exit_after(self):
t = timer2.Timer()
t.apply_after = Mock()
t.exit_after(300, priority=10)
t.apply_after.assert_called_with(300, sys.exit, 10)
def test_cancel(self):
t = timer2.Timer()
tref = Mock()
t.cancel(tref)
tref.cancel.assert_called_with()
def test_test_enter_after(self):
t = timer2.Timer()
t._do_enter = Mock()
t.enter_after()
t._do_enter.assert_called_with('enter_after')
def test_test_enter(self):
t = timer2.Timer()
t._do_enter = Mock()
e = Mock()
t.enter(e, 13, 0)
t._do_enter.assert_called_with('enter', e, 13, priority=0)
def test_thread_crash(self, _exit):
t = timer2.Timer()
t._next_entry = Mock()
t._next_entry.side_effect = OSError(131)
t.run()
_exit.assert_called_with(1)
def test_exit_after(self):
t = timer2.Timer()
t.call_after = Mock()
t.exit_after(0.3, priority=10)
t.call_after.assert_called_with(0.3, sys.exit, 10)
