def test_priorityqueue_length(self): """Test that length is n after n invocations""" p = PriorityQueue() assert(len(p) == 0) for n in range(42): p.enqueue(n) assert(len(p) == 42) p.dequeue() assert(len(p) == 41) p.remove(10) assert(len(p) == 40) for n in range(len(p)): p.dequeue() assert(len(p) == 0)
def test_priorityqueue_length(self): """Test that length is n after n invocations""" p = PriorityQueue() assert len(p) == 0 for n in range(42): p.enqueue(n) assert len(p) == 42 p.dequeue() assert len(p) == 41 p.remove(10) assert len(p) == 40 for n in range(len(p)): p.dequeue() assert len(p) == 0
def test_priorityqueue_remove(self): """Remove item from queue""" p = PriorityQueue() assert(p.remove(42) == False) p.enqueue(42) p.enqueue(41) p.enqueue(43) assert(p.remove(42) == True) assert([p.dequeue(), p.dequeue()] == [41, 43]) p.enqueue(42) p.enqueue(41) p.enqueue(43) assert(p.remove(41) == True) assert([p.dequeue(), p.dequeue()] == [42, 43]) p.enqueue(42) p.enqueue(41) p.enqueue(43) assert(p.remove(43) == True) assert([p.dequeue(), p.dequeue()] == [41, 42])
def test_priorityqueue_remove(self): """Remove item from queue""" p = PriorityQueue() assert(p.remove(42) == False) p.enqueue(42) p.enqueue(41) p.enqueue(43) assert p.remove(42) == True assert [p.dequeue(), p.dequeue()] == [41, 43] p.enqueue(42) p.enqueue(41) p.enqueue(43) assert p.remove(41) == True assert [p.dequeue(), p.dequeue()] == [42, 43] p.enqueue(42) p.enqueue(41) p.enqueue(43) assert p.remove(43) == True assert [p.dequeue(), p.dequeue()] == [41, 42]
class VirtualTimeScheduler(Scheduler): """Virtual Scheduler. This scheduler should work with either datetime/timespan or ticks as int/int""" def __init__(self, initial_clock=0, comparer=None): """Creates a new virtual time scheduler with the specified initial clock value and absolute time comparer. Keyword arguments: initial_clock -- Initial value for the clock. comparer -- Comparer to determine causality of events based on absolute time. """ self.clock = initial_clock self.comparer = comparer self.is_enabled = False self.queue = PriorityQueue(1024) super(VirtualTimeScheduler, self).__init__() def local_now(self): return self.to_datetime(self.clock) def schedule_now(self, state, action): return self.schedule_absolute_with_state(state, self.clock, action) def now(self): """Gets the scheduler's absolute time clock value as datetime offset.""" return self.to_datetime(self.clock) def schedule(self, action, state=None): return self.schedule_absolute(self.clock, action, state) def schedule_relative(self, duetime, action, state=None): """Schedules an action to be executed at duetime. Return the disposable object used to cancel the scheduled action (best effort) Keyword arguments: due_time -- Relative time after which to execute the action. action -- Action to be executed. state -- [Optional] State passed to the action to be executed. """ log.debug("VirtualTimeScheduler.schedule_relative(duetime=%s, state=%s)" % (duetime, state)) runat = self.add(self.clock, self.to_relative(duetime)) return self.schedule_absolute(duetime=runat, action=action, state=state) def schedule_absolute(self, duetime, action, state=None): """Schedules an action to be executed at duetime.""" def run(scheduler, state1): self.queue.remove(si) return action(scheduler, state1) si = ScheduledItem(self, state, run, duetime, self.comparer) self.queue.enqueue(si) return si.disposable def schedule_periodic(self, period, action, state=None): scheduler = SchedulePeriodicRecursive(self, period, action, state) return scheduler.start() def start(self): """Starts the virtual time scheduler.""" next = None if not self.is_enabled: self.is_enabled = True while self.is_enabled: next = self.get_next() if next: if self.comparer(next.duetime, self.clock) > 0: self.clock = next.duetime log.info("VirtualTimeScheduler.start(), clock: %s", self.clock) next.invoke() else: self.is_enabled = False def stop(self): """Stops the virtual time scheduler.""" self.is_enabled = False def advance_to(self, time): """Advances the scheduler's clock to the specified time, running all work til that point. Keyword arguments: time -- Absolute time to advance the scheduler's clock to. """ next = None due_to_clock = self.comparer(self.clock, time) if due_to_clock > 0: raise ArgumentOutOfRangeException() if not due_to_clock: return if not self.is_enabled: self.is_enabled = True while self.is_enabled: next = self.get_next() if next and self.comparer(next.duetime, time) <= 0: if self.comparer(next.duetime, self.clock) > 0: self.clock = next.duetime next.invoke() else: self.is_enabled = False self.clock = time def advance_by(self, time): """Advances the scheduler's clock by the specified relative time, running all work scheduled for that timespan. Keyword arguments: time -- Relative time to advance the scheduler's clock by. """ log.debug("VirtualTimeScheduler.advance_by(time=%s)", time) dt = self.add(self.clock, time) if self.comparer(self.clock, dt) > 0: raise ArgumentOutOfRangeException() return self.advance_to(dt) def sleep(self, time): """Advances the scheduler's clock by the specified relative time. Keyword arguments: time -- Relative time to advance the scheduler's clock by. """ dt = self.add(self.clock, time) if self.comparer(self.clock, dt) >= 0: raise ArgumentOutOfRangeException() self.clock = dt def get_next(self): """Returns the next scheduled item to be executed.""" while self.queue.length > 0: next = self.queue.peek() if next.is_cancelled(): self.queue.dequeue() else: return next return None def add(self, absolute, relative): raise NotImplementedError
class VirtualTimeScheduler(Scheduler): """Virtual Scheduler. This scheduler should work with either datetime/timespan or ticks as int/int""" def __init__(self, initial_clock=0, comparer=None): """Creates a new virtual time scheduler with the specified initial clock value and absolute time comparer. Keyword arguments: initial_clock -- Initial value for the clock. comparer -- Comparer to determine causality of events based on absolute time.""" self.clock = initial_clock self.comparer = comparer self.is_enabled = False self.queue = PriorityQueue(1024) super(VirtualTimeScheduler, self).__init__() def now(self): """Gets the schedulers absolute time clock value as datetime offset.""" return self.to_datetime(self.clock) def schedule(self, action, state=None): """Schedules an action to be executed.""" return self.schedule_absolute(self.clock, action, state) def schedule_relative(self, duetime, action, state=None): """Schedules an action to be executed at duetime. Return the disposable object used to cancel the scheduled action (best effort) Keyword arguments: duetime -- Relative time after which to execute the action. action -- Action to be executed. state -- [Optional] State passed to the action to be executed.""" log.debug( "VirtualTimeScheduler.schedule_relative(duetime=%s, state=%s)" % (duetime, state)) runat = self.add(self.clock, self.to_relative(duetime)) return self.schedule_absolute(duetime=runat, action=action, state=state) def schedule_absolute(self, duetime, action, state=None): """Schedules an action to be executed at duetime.""" def run(scheduler, state1): self.queue.remove(si) return action(scheduler, state1) si = ScheduledItem(self, state, run, duetime, self.comparer) self.queue.enqueue(si) return si.disposable def schedule_periodic(self, period, action, state=None): scheduler = SchedulePeriodicRecursive(self, period, action, state) return scheduler.start() def start(self): """Starts the virtual time scheduler.""" if not self.is_enabled: self.is_enabled = True while self.is_enabled: next = self.get_next() if next: if self.comparer(next.duetime, self.clock) > 0: self.clock = next.duetime log.info("VirtualTimeScheduler.start(), clock: %s", self.clock) next.invoke() else: self.is_enabled = False def stop(self): """Stops the virtual time scheduler.""" self.is_enabled = False def advance_to(self, time): """Advances the schedulers clock to the specified time, running all work til that point. Keyword arguments: time -- Absolute time to advance the schedulers clock to.""" due_to_clock = self.comparer(self.clock, time) if due_to_clock > 0: raise ArgumentOutOfRangeException() if not due_to_clock: return if not self.is_enabled: self.is_enabled = True while self.is_enabled: next = self.get_next() if next and self.comparer(next.duetime, time) <= 0: if self.comparer(next.duetime, self.clock) > 0: self.clock = next.duetime next.invoke() else: self.is_enabled = False self.clock = time def advance_by(self, time): """Advances the schedulers clock by the specified relative time, running all work scheduled for that timespan. Keyword arguments: time -- Relative time to advance the schedulers clock by.""" log.debug("VirtualTimeScheduler.advance_by(time=%s)", time) dt = self.add(self.clock, time) if self.comparer(self.clock, dt) > 0: raise ArgumentOutOfRangeException() return self.advance_to(dt) def sleep(self, time): """Advances the schedulers clock by the specified relative time. Keyword arguments: time -- Relative time to advance the schedulers clock by.""" dt = self.add(self.clock, time) if self.comparer(self.clock, dt) >= 0: raise ArgumentOutOfRangeException() self.clock = dt def get_next(self): """Returns the next scheduled item to be executed.""" while len(self.queue): next = self.queue.peek() if next.is_cancelled(): self.queue.dequeue() else: return next return None @staticmethod def add(absolute, relative): raise NotImplementedError
class VirtualTimeScheduler(Scheduler): """Virtual Scheduler""" def __init__(self, initial_clock=0, comparer=None): """Creates a new virtual time scheduler with the specified initial clock value and absolute time comparer. Keyword arguments: initial_clock -- Initial value for the clock. comparer -- Comparer to determine causality of events based on absolute time. """ self.clock = initial_clock self.comparer = comparer self.is_enabled = False self.queue = PriorityQueue(1024) def now(self): #return self.clock return self.to_datetime_offset(self.clock) def schedule(self, action, state=None): return self.schedule_absolute(self.clock, action, state) def schedule_relative(self, duetime, action, state=None): """Schedules an action to be executed at duetime. Return the disposable object used to cancel the scheduled action (best effort) Keyword arguments: due_time -- Relative time after which to execute the action. action -- Action to be executed. state -- [Optional] State passed to the action to be executed. """ log.debug( "VirtualTimeScheduler.schedule_relative(duetime=%s, state=%s)" % (duetime, state)) runat = self.add(self.clock, self.to_relative(duetime)) return self.schedule_absolute(runat, action, state) def schedule_absolute(self, duetime, action, state=None): log.debug( "VirtualTimeScheduler.schedule_absolute(duetime=%s, state=%s)" % (duetime, state)) def run(scheduler, state1): #print ("VirtualTimeScheduler:schedule_absolute:run(%s)" % repr(state1)) self.queue.remove(si) #print ("running action", action.__doc__) return action(scheduler, state1) si = ScheduledItem(self, state, run, duetime, self.comparer) self.queue.enqueue(si) return si.disposable def schedule_periodic(self, period, action, state=None): scheduler = SchedulePeriodicRecursive(self, period, action, state) return scheduler.start() def start(self): """Starts the virtual time scheduler.""" next = None if not self.is_enabled: self.is_enabled = True while self.is_enabled: #print (self.clock) next = self.get_next() if next: if self.comparer(next.duetime, self.clock) > 0: self.clock = next.duetime log.info("VirtualTimeScheduler.start(), clock: %s" % self.clock) #else: # print ("skipping", next.duetime, self.clock) #print ("Invoke: ", self.clock, next.action) next.invoke() else: self.is_enabled = False def stop(self): """Stops the virtual time scheduler.""" self.is_enabled = False def advance_to(self, time): """Advances the scheduler's clock to the specified time, running all work till that point. Keyword arguments: time -- Absolute time to advance the scheduler's clock to. """ print("advance_to()") next = None if self.comparer(self.clock, time) >= 0: raise ArgumentOutOfRangeException() if not self.is_enabled: self.is_enabled = True while self.is_enabled: next = self.get_next() if next and self.comparer(next.duetime, time) <= 0: if self.comparer(next.duetime, self.clock) > 0: self.clock = next.duetime next.invoke() else: self.is_enabled = False self.clock = time def advance_by(self, time): """Advances the scheduler's clock by the specified relative time, running all work scheduled for that timespan. Keyword arguments: time -- Relative time to advance the scheduler's clock by. """ log.debug("VirtualTimeScheduler.advance_by(time=%s)" % time) dt = self.add(self.clock, time) if self.comparer(self.clock, dt) >= 0: raise ArgumentOutOfRangeException() return self.advance_to(dt) def sleep(self, time): """Advances the scheduler's clock by the specified relative time. Keyword arguments: time -- Relative time to advance the scheduler's clock by. """ dt = self.add(self.clock, time) if self.comparer(self.clock, dt) >= 0: raise ArgumentOutOfRangeException() self.clock = dt def get_next(self): """Returns the next scheduled item to be executed.""" while self.queue.length > 0: next = self.queue.peek() if next.is_cancelled(): self.queue.dequeue() else: return next return None