def test_eventloop_schedule_action_periodic(self):
        scheduler = EventLoopScheduler(exit_if_empty=False)
        gate = threading.Semaphore(0)
        period = 0.05
        counter = 3

        def action(state):
            nonlocal counter
            if state:
                counter -= 1
                return state - 1
            if counter == 0:
                gate.release()

        disp = scheduler.schedule_periodic(period, action, counter)

        def dispose(scheduler, state):
            disp.dispose()
            gate.release()

        gate.acquire()
        assert counter == 0
        assert scheduler._has_thread() is True
        scheduler.schedule(dispose)
        gate.acquire()
        assert scheduler._has_thread() is True
        sleep(period)
        scheduler.dispose()
        sleep(period)
        assert scheduler._has_thread() is False
    def test_eventloop_schedule_action_periodic(self):
        scheduler = EventLoopScheduler(exit_if_empty=False)
        gate = threading.Semaphore(0)
        period = 0.05
        counter = 3

        def action(state):
            nonlocal counter
            if state:
                counter -= 1
                return state - 1
            if counter == 0:
                gate.release()

        disp = scheduler.schedule_periodic(period, action, counter)

        def dispose(scheduler, state):
            disp.dispose()
            gate.release()

        gate.acquire()
        assert counter == 0
        assert scheduler._has_thread() is True
        scheduler.schedule(dispose)

        gate.acquire()
        assert scheduler._has_thread() is True
        sleep(period)
        scheduler.dispose()
        sleep(period)
        assert scheduler._has_thread() is False
Example #3
0
    def test_event_loop_schedule_action(self):
        scheduler = EventLoopScheduler(exit_if_empty=True)
        ran = [False]
        gate = threading.Semaphore(0)

        def action(scheduler, state):
            gate.release()
            ran[0] = True

        scheduler.schedule(action)
        gate.acquire()
        assert (ran[0] is True)
Example #4
0
    def test_event_loop_different_thread(self):
        thread_id = [None]
        scheduler = EventLoopScheduler(exit_if_empty=True)
        gate = threading.Semaphore(0)

        def action(scheduler, state):
            gate.release()
            thread_id[0] = threading.current_thread().ident

        scheduler.schedule(action)
        gate.acquire()
        assert (thread_id[0] != threading.current_thread().ident)
Example #5
0
    def test_event_loop_schedule_action(self):
        scheduler = EventLoopScheduler(exit_if_empty=True)
        ran = [False]
        gate = threading.Semaphore(0)

        def action(scheduler, state):
            gate.release()
            ran[0] = True

        scheduler.schedule(action)
        gate.acquire()
        assert (ran[0] == True)
Example #6
0
    def test_event_loop_different_thread(self):
        thread_id = [None]
        scheduler = EventLoopScheduler(exit_if_empty=True)
        gate = threading.Semaphore(0)

        def action(scheduler, state):
            gate.release()
            thread_id[0] = threading.current_thread().ident

        scheduler.schedule(action)
        gate.acquire()
        assert (thread_id[0] != threading.current_thread().ident)
Example #7
0
    def test_event_loop_schedule_action_cancel(self):
        scheduler = EventLoopScheduler(exit_if_empty=True)
        gate = threading.Semaphore(0)
        ran = [False]

        def action(scheduler, state):
            ran[0] = True

        d = scheduler.schedule_relative(timedelta(milliseconds=1), action)
        d.dispose()

        sleep(0.1)
        assert (not ran[0])
Example #8
0
    def test_event_loop_schedule_action_cancel(self):
        scheduler = EventLoopScheduler(exit_if_empty=True)
        gate = threading.Semaphore(0)
        ran = [False]

        def action(scheduler, state):
            ran[0] = True

        d = scheduler.schedule_relative(timedelta(milliseconds=1), action)
        d.dispose()

        sleep(0.1)
        assert (not ran[0])
    def test_event_loop_schedule_action(self):
        scheduler = EventLoopScheduler(exit_if_empty=True)
        ran = False
        gate = threading.Semaphore(0)

        def action(scheduler, state):
            nonlocal ran
            ran = True
            gate.release()

        scheduler.schedule(action)
        gate.acquire()
        assert ran is True
        assert scheduler._has_thread() is False
Example #10
0
    def test_event_loop_different_thread(self):
        thread_id = None
        scheduler = EventLoopScheduler(exit_if_empty=True)
        gate = threading.Semaphore(0)

        def action(scheduler, state):
            nonlocal thread_id
            thread_id = threading.current_thread().ident
            gate.release()

        scheduler.schedule(action)
        gate.acquire()
        assert thread_id != threading.current_thread().ident
        assert scheduler._has_thread() is False
Example #11
0
    def test_event_loop_schedule_action(self):
        scheduler = EventLoopScheduler(exit_if_empty=True)
        ran = False
        gate = threading.Semaphore(0)

        def action(scheduler, state):
            nonlocal ran
            ran = True
            gate.release()

        scheduler.schedule(action)
        gate.acquire()
        assert ran is True
        assert scheduler._has_thread() is False
    def test_event_loop_different_thread(self):
        thread_id = None
        scheduler = EventLoopScheduler(exit_if_empty=True)
        gate = threading.Semaphore(0)

        def action(scheduler, state):
            nonlocal thread_id
            thread_id = threading.current_thread().ident
            gate.release()

        scheduler.schedule(action)
        gate.acquire()
        assert thread_id != threading.current_thread().ident
        assert scheduler._has_thread() is False
Example #13
0
    def test_event_loop_schedule_ordered_actions(self):
        scheduler = EventLoopScheduler(exit_if_empty=True)
        gate = threading.Semaphore(0)
        result = []

        scheduler.schedule(lambda s, t: result.append(1))

        def action(scheduler, state):
            gate.release()
            result.append(2)

        scheduler.schedule(action)
        gate.acquire()
        assert (result == [1,2])
Example #14
0
    def test_event_loop_schedule_action_due(self):
        scheduler = EventLoopScheduler(exit_if_empty=True)
        gate = threading.Semaphore(0)
        starttime = datetime.utcnow()
        endtime = [None]

        def action(scheduler, state):
            endtime[0] = datetime.utcnow()
            gate.release()

        scheduler.schedule_relative(timedelta(milliseconds=200), action)

        gate.acquire()
        diff = endtime[0] - starttime
        assert (diff > timedelta(milliseconds=180))
    def test_event_loop_schedule_action_due(self):
        scheduler = EventLoopScheduler(exit_if_empty=True)
        gate = threading.Semaphore(0)
        starttime = datetime.utcnow()
        endtime = [None]

        def action(scheduler, state):
            endtime[0] = datetime.utcnow()
            gate.release()

        scheduler.schedule_relative(timedelta(milliseconds=200), action)

        gate.acquire()
        diff = endtime[0]-starttime
        assert(diff > timedelta(milliseconds=180))
Example #16
0
    def test_event_loop_schedule_action_absolute_due(self):
        scheduler = EventLoopScheduler(exit_if_empty=True)
        gate = threading.Semaphore(0)
        starttime = default_now()
        endtime = None

        def action(scheduler, state):
            nonlocal endtime
            endtime = default_now()
            gate.release()

        scheduler.schedule_absolute(scheduler.now, action)
        gate.acquire()
        diff = endtime - starttime
        assert diff < timedelta(milliseconds=180)
        assert scheduler._has_thread() is False
    def test_event_loop_schedule_action_absolute_due(self):
        scheduler = EventLoopScheduler(exit_if_empty=True)
        gate = threading.Semaphore(0)
        starttime = datetime.utcnow()
        endtime = None

        def action(scheduler, state):
            nonlocal endtime
            endtime = datetime.utcnow()
            gate.release()

        scheduler.schedule_absolute(scheduler.now, action)
        gate.acquire()
        diff = endtime - starttime
        assert diff < timedelta(milliseconds=180)
        assert scheduler._has_thread() is False
Example #18
0
    def test_eventloop_schedule_action_periodic(self):
        scheduler = EventLoopScheduler()
        gate = threading.Semaphore(0)
        period = 0.050
        counter = [3]

        def action(state):
            if state:
                counter[0] -= 1
                return state - 1
            if counter[0] == 0:
                gate.release()

        scheduler.schedule_periodic(period, action, counter[0])

        def done():
            assert counter[0] == 0

        gate.acquire()
    def test_eventloop_schedule_action_periodic(self):
        scheduler = EventLoopScheduler()
        gate = threading.Semaphore(0)
        period = 0.050
        counter = [3]

        def action(state):
            if state:
                counter[0] -= 1
                return state - 1
            if counter[0] == 0:
                gate.release()

        scheduler.schedule_periodic(period, action, counter[0])

        def done():
            assert counter[0] == 0

        gate.acquire()
    def test_event_loop_schedule_ordered_actions_due(self):
        scheduler = EventLoopScheduler(exit_if_empty=True)
        gate = threading.Semaphore(0)
        result = []

        def action(scheduler, state):
            result.append(3)
            gate.release()

        scheduler.schedule_relative(0.10, action)
        scheduler.schedule_relative(0.05, lambda s, t: result.append(2))
        scheduler.schedule(lambda s, t: result.append(1))

        gate.acquire()
        assert result == [1, 2, 3]
        assert scheduler._has_thread() is False
Example #21
0
    def test_event_loop_schedule_ordered_actions_due_mixed(self):
        scheduler = EventLoopScheduler(exit_if_empty=True)
        gate = threading.Semaphore(0)
        result = []

        def action(scheduler, state):
            result.append(1)
            scheduler.schedule_relative(0.2, action3)
            scheduler.schedule(action2)

        def action2(scheduler, state):
            result.append(2)

        def action3(scheduler, state):
            result.append(3)
            gate.release()

        scheduler.schedule(action)

        gate.acquire()
        assert result == [1, 2, 3]
        assert scheduler._has_thread() is False
Example #22
0
def bus_context(conf):
    blinker_ticks = Observable.interval(conf.blink.interval * 1000)
    montage_ticks = Observable.interval(conf.montage.interval * 1000)
    event_loop = EventLoopScheduler()
    buttons = [
        Button(Shoot, conf.event.shoot, conf.bounce_time, event_loop),
        Button(Quit, conf.event.quit, conf.bounce_time, event_loop),
        Button(Quit, conf.event.reboot, conf.bounce_time, event_loop),
        Button(Quit, conf.event.shutdown, conf.bounce_time, event_loop)
    ]
    commands = (Observable.merge([button.events for button in buttons]).merge(
        ThreadPoolScheduler(max_workers=conf.workers),
        blinker_ticks.map(const(Blink())),
        montage_ticks.map(const(ShowRandomMontage()))))
    with commands.subscribe(on_next=inject(handle_command, conf)):
        yield
    def test_eventloop_schedule_periodic_dispose_error(self):
        scheduler = EventLoopScheduler(exit_if_empty=False)

        scheduler.dispose()

        ran = False

        def action(scheduler, state):
            nonlocal ran
            ran = True

        with pytest.raises(DisposedException):
            scheduler.schedule_periodic(0.1, action)

        assert ran is False
        assert scheduler._has_thread() is False
Example #24
0
    def test_event_loop_schedule_ordered_actions(self):
        scheduler = EventLoopScheduler(exit_if_empty=True)
        gate = threading.Semaphore(0)
        result = []

        scheduler.schedule(lambda s, t: result.append(1))

        def action(scheduler, state):
            gate.release()
            result.append(2)

        scheduler.schedule(action)
        gate.acquire()
        assert (result == [1, 2])
Example #25
0
    def test_eventloop_schedule_periodic_dispose_error(self):
        scheduler = EventLoopScheduler(exit_if_empty=False)

        scheduler.dispose()

        ran = False

        def action(scheduler, state):
            nonlocal ran
            ran = True

        with pytest.raises(DisposedException):
            scheduler.schedule_periodic(0.1, action)

        assert ran is False
        assert scheduler._has_thread() is False
    def test_eventloop_schedule_periodic_dispose(self):
        scheduler = EventLoopScheduler(exit_if_empty=False)

        scheduler.dispose()

        ran = False

        def action(scheduler, state):
            nonlocal ran
            ran = True

        exc = None
        try:
            scheduler.schedule_periodic(0.1, scheduler.now, action)
        except Exception as e:
            exc = e
        finally:
            assert isinstance(exc, DisposedException)
            assert ran is False
            assert scheduler._has_thread() is False
Example #27
0
 def test_event_loop_now(self):
     scheduler = EventLoopScheduler()
     res = scheduler.now() - datetime.utcnow()
     assert res < timedelta(microseconds=1000)
 def test_event_loop_now_units(self):
     scheduler = EventLoopScheduler()
     diff = scheduler.now
     sleep(0.1)
     diff = scheduler.now - diff
     assert timedelta(milliseconds=80) < diff < timedelta(milliseconds=180)
 def test_event_loop_now(self):
     scheduler = EventLoopScheduler()
     diff = scheduler.now - default_now()
     assert abs(diff) < timedelta(milliseconds=1)
Example #30
0
 def test_event_loop_now(self):
     scheduler = EventLoopScheduler()
     res = scheduler.now - datetime.utcnow()
     assert res < timedelta(microseconds=1000)