def test_event_scheduler_stopped(self):
     event_scheduler = EventScheduler(TEST_THREAD, TestTimer.monotonic,
                                      TestTimer)
     result_list = []
     event_scheduler.enter(0, 0, insert_into_list, ('A', result_list))
     TestTimer.advance_time(0)
     self.assertFalse(result_list)
     event_scheduler.start()
     event_scheduler.stop()
     event_scheduler.enter(0, 0, insert_into_list, ('A', result_list))
     TestTimer.advance_time(0)
     self.assertFalse(result_list)
 def test_priority(self):
     event_scheduler = EventScheduler(TEST_THREAD, TestTimer.monotonic,
                                      TestTimer)
     TestTimer.set_event_scheduler(event_scheduler)
     event_scheduler.start()
     result_list = []
     event_scheduler.enterabs(4, 4, insert_into_list, ('C', result_list))
     event_scheduler.enterabs(4, 3, insert_into_list, ('B', result_list))
     event_scheduler.enterabs(4, 5, insert_into_list, ('D', result_list))
     event_scheduler.enterabs(4, 1, insert_into_list, ('A', result_list))
     TestTimer.advance_time(3.8)
     self.assertListEqual(result_list, [])
     TestTimer.advance_time(0.3)
     event_scheduler.stop()
     self.assertListEqual(result_list, ['A', 'B', 'C', 'D'])
 def test_no_double_start_or_stop(self):
     event_scheduler = EventScheduler(TEST_THREAD, TestTimer.monotonic,
                                      TestTimer)
     event_scheduler.start()
     result = event_scheduler.start()
     self.assertEqual(result, -1)
     event_scheduler.stop()
     result = event_scheduler.stop()
     self.assertEqual(result, -1)
 def test_execute_one_event(self):
     event_scheduler = EventScheduler(TEST_THREAD, TestTimer.monotonic,
                                      TestTimer)
     event_scheduler.start()
     result_list = []
     event_scheduler.enter(0, 0, insert_into_list, ('A', result_list))
     event_scheduler.stop()
     self.assertTrue(result_list)
     self.assertEqual(result_list[0], 'A')
 def test_multiple_recurring_events(self):
     event_scheduler = EventScheduler(TEST_THREAD, TestTimer.monotonic,
                                      TestTimer)
     TestTimer.set_event_scheduler(event_scheduler)
     event_scheduler.start()
     result_list = []
     event_scheduler.enter_recurring(5, 0, insert_into_list,
                                     ('A', result_list))
     event_scheduler.enter_recurring(2, 0, insert_into_list,
                                     ('B', result_list))
     TestTimer.advance_time(2)
     self.assertListEqual(result_list, ['B'])
     TestTimer.advance_time(3)
     self.assertListEqual(result_list, ['B', 'B', 'A'])
     TestTimer.advance_time(5)
     self.assertListEqual(result_list, ['B', 'B', 'A', 'B', 'B', 'A', 'B'])
     event_scheduler.stop(True)
 def test_stop_scheduler_hard_stop(self):
     # With a hard stop, the event scheduler clear all of the upcoming
     # events from the queue when stopping.
     event_scheduler = EventScheduler(TEST_THREAD)
     TestTimer.set_event_scheduler(event_scheduler)
     event_scheduler.start()
     result_list = []
     event_scheduler.enterabs(30, 1, insert_into_list, ('A', result_list))
     event_scheduler.stop(True)
     self.assertListEqual(result_list, [])
 def test_event_time_in_the_past(self):
     event_scheduler = EventScheduler(TEST_THREAD, TestTimer.monotonic,
                                      TestTimer)
     TestTimer.set_event_scheduler(event_scheduler)
     event_scheduler.start()
     result_list = []
     event_scheduler.enterabs(-1, 1, insert_into_list, ('A', result_list))
     TestTimer.advance_time(0)
     event_scheduler.stop()
     self.assertListEqual(result_list, ['A'])
 def test_cancel_recurring_event(self):
     event_scheduler = EventScheduler(TEST_THREAD, TestTimer.monotonic,
                                      TestTimer)
     TestTimer.set_event_scheduler(event_scheduler)
     event_scheduler.start()
     result_list = []
     event_id = event_scheduler.enter_recurring(5, 0, insert_into_list,
                                                ('A', result_list))
     TestTimer.advance_time(5)
     self.assertListEqual(result_list, ['A'])
     event_scheduler.cancel_recurring(event_id)
     TestTimer.advance_time(5)
     self.assertListEqual(result_list, ['A'])
     event_scheduler.stop(True)
 def test_cancel_event_after_execution(self):
     event_scheduler = EventScheduler(TEST_THREAD, TestTimer.monotonic,
                                      TestTimer)
     TestTimer.set_event_scheduler(event_scheduler)
     event_scheduler.start()
     result_list = []
     event = event_scheduler.enter(2, 4, insert_into_list, (), {
         'item': 'B',
         'list_obj': result_list
     })
     TestTimer.advance_time(2.5)
     # cancelling an already executed event should be a no-op
     event_scheduler.cancel(event)
     self.assertListEqual(result_list, ['B'])
     event_scheduler.stop(True)
 def test_relative_delay(self):
     event_scheduler = EventScheduler(TEST_THREAD, TestTimer.monotonic,
                                      TestTimer)
     TestTimer.set_event_scheduler(event_scheduler)
     event_scheduler.start()
     result_list = []
     item = 'A'
     event_scheduler.enter(3, 0, insert_into_list, (item, result_list))
     TestTimer.advance_time(2)
     self.assertListEqual(result_list, [])
     TestTimer.advance_time(1)
     self.assertListEqual(result_list, [item])
     event_scheduler.stop()
 def test_recurring_event_kwargs(self):
     event_scheduler = EventScheduler(TEST_THREAD, TestTimer.monotonic,
                                      TestTimer)
     TestTimer.set_event_scheduler(event_scheduler)
     event_scheduler.start()
     result_list = []
     event_scheduler.enter_recurring(5, 0, insert_into_list, (), {
         'item': 'A',
         'list_obj': result_list
     })
     TestTimer.advance_time(2)
     self.assertListEqual(result_list, [])
     TestTimer.advance_time(3)
     self.assertListEqual(result_list, ['A'])
     TestTimer.advance_time(5)
     self.assertListEqual(result_list, ['A', 'A'])
     event_scheduler.stop(True)
 def test_breathing(self):
     event_scheduler = EventScheduler(TEST_THREAD)
     result = event_scheduler.start()
     self.assertEqual(result, 0)
     result = event_scheduler.stop()
     self.assertEqual(result, 0)
    def test_event_scheduler_raises_invalid_priority(self):
        event_scheduler = EventScheduler(TEST_THREAD, TestTimer.monotonic,
                                         TestTimer)
        result_list = []

        # priority less than 0
        with self.assertRaises(ValueError):
            event_scheduler.enter(0, -1, insert_into_list, ('A', result_list))
        with self.assertRaises(ValueError):
            event_scheduler.enterabs(0, -1, insert_into_list,
                                     ('A', result_list))
        with self.assertRaises(ValueError):
            event_scheduler.enter_recurring(0, -1, insert_into_list,
                                            ('A', result_list))
        # priority > sys.maxsize
        with self.assertRaises(ValueError):
            event_scheduler.enter(0, sys.maxsize, insert_into_list,
                                  ('A', result_list))
        with self.assertRaises(ValueError):
            event_scheduler.enterabs(0, sys.maxsize, insert_into_list,
                                     ('A', result_list))
        with self.assertRaises(ValueError):
            event_scheduler.enter_recurring(0, sys.maxsize, insert_into_list,
                                            ('A', result_list))
 def test_cancel_event(self):
     event_scheduler = EventScheduler(TEST_THREAD, TestTimer.monotonic,
                                      TestTimer)
     TestTimer.set_event_scheduler(event_scheduler)
     event_scheduler.start()
     result_list = []
     event = event_scheduler.enterabs(2, 1, insert_into_list,
                                      ('A', result_list))
     event_scheduler.enterabs(2, 3, insert_into_list, ('B', result_list))
     TestTimer.advance_time(1)
     event_scheduler.cancel(event)
     TestTimer.advance_time(1)
     event_scheduler.stop()
     self.assertListEqual(result_list, ['B'])
 def test_multiple_events_built_in_timer(self):
     # We should test the built-in timer to make sure it's working as
     # expected. We can also test the hard stop being set to false, (the
     # event scheduler should execute all remaining events in the queue
     # before stopping).
     event_scheduler = EventScheduler(TEST_THREAD)
     event_scheduler.start()
     result_list = []
     event_scheduler.enter_recurring(1.2, 0, insert_into_list,
                                     ('#', result_list))
     event_scheduler.enterabs(0.2, 1, insert_into_list, ('A', result_list))
     event_scheduler.enterabs(0.4, 1, insert_into_list, ('B', result_list))
     event_scheduler.enterabs(0.7, 1, insert_into_list, ('C', result_list))
     event_scheduler.enterabs(1, 1, insert_into_list, ('D', result_list))
     event_scheduler.stop(False)
     self.assertListEqual(result_list, ['A', 'B', 'C', 'D', '#'])
 def test_cancel_all_events(self):
     event_scheduler = EventScheduler(TEST_THREAD, TestTimer.monotonic,
                                      TestTimer)
     TestTimer.set_event_scheduler(event_scheduler)
     event_scheduler.start()
     result_list = []
     event_scheduler.enter_recurring(5, 0, insert_into_list,
                                     ('A', result_list))
     event_scheduler.enter_recurring(2, 0, insert_into_list,
                                     ('B', result_list))
     event_scheduler.enter(0, 0, insert_into_list, ('C', result_list))
     TestTimer.advance_time(1)
     self.assertListEqual(result_list, ['C'])
     event_scheduler.enter(1, 0, insert_into_list, ('D', result_list))
     TestTimer.advance_time(0.2)
     event_scheduler.cancel_all()
     self.assertListEqual(result_list, ['C'])
     event_scheduler.stop(False)
 def test_multiple_events_different_times(self):
     event_scheduler = EventScheduler(TEST_THREAD, TestTimer.monotonic,
                                      TestTimer)
     TestTimer.set_event_scheduler(event_scheduler)
     event_scheduler.start()
     result_list = []
     event_scheduler.enterabs(5, 1, insert_into_list, ('D', result_list))
     event_scheduler.enterabs(4, 1, insert_into_list, ('B', result_list))
     event_scheduler.enterabs(7, 1, insert_into_list, ('E', result_list))
     event_scheduler.enterabs(1, 1, insert_into_list, ('A', result_list))
     self.assertListEqual(result_list, [])
     TestTimer.advance_time(1)
     self.assertListEqual(result_list, ['A'])
     TestTimer.advance_time(3)
     self.assertListEqual(result_list, ['A', 'B'])
     event_scheduler.enterabs(0.5, 1, insert_into_list, ('C', result_list))
     TestTimer.advance_time(1)
     self.assertListEqual(result_list, ['A', 'B', 'C', 'D'])
     TestTimer.advance_time(2)
     self.assertListEqual(result_list, ['A', 'B', 'C', 'D', 'E'])
     event_scheduler.stop()