def test_fast_forward_delay(self):
"""Test that fast forwarding the time works properly"""
notify_event = threading.Event()
virtualtime.notify_on_change(notify_event)
delay_event = threading.Event()
offsets = []
positions = ["start_job", ""]
msg_dict = {'offsets': offsets, 'positions': positions}
catcher_thread = threading.Thread(target=self.fast_forward_delayer,
args=(notify_event, delay_event,
msg_dict))
catcher_thread.start()
start_time = virtualtime._original_time()
virtualtime.fast_forward_time(2)
assert virtualtime._time_offset == 2
virtualtime.restore_time()
msg_dict['stop'] = True
notify_event.set()
catcher_thread.join()
completion_time = virtualtime._original_time()
assert offsets[:3] == [1.0, 2.0, 0]
# depends on how long the stop event takes?
assert (not offsets[3:]) or offsets[3:] == [0]
assert completion_time - start_time < 0.2
assert delay_event.is_set()
def test_callback(self):
self.notify_event = threading.Event()
virtualtime.notify_on_change(self.notify_event)
self.callback_stop = False
self.callback_event = threading.Event()
self.callback_logs = []
self.callback_missed = []
ct = threading.Thread(target=self.callback_thread)
ct.start()
virtualtime.wait_for_callback_on_change(self.callback_event)
try:
start_time = virtualtime._original_time()
virtualtime.set_offset(1)
assert len(self.callback_logs) == 1 and not self.callback_missed
assert self.callback_logs[0][1:] == (1, False)
offset_time = virtualtime._original_time()
assert offset_time - start_time < 0.1
virtualtime.set_time(0)
assert len(self.callback_logs) == 2 and not self.callback_missed
assert self.callback_logs[1][1] < -start_time + 1 and self.callback_logs[1][2] is False
set_time = virtualtime._original_time()
assert set_time - offset_time < 0.1
virtualtime.restore_time()
assert len(self.callback_logs) == 3 and not self.callback_missed
assert self.callback_logs[1][1] < -start_time + 1 and self.callback_logs[1][2] is False
restore_time = virtualtime._original_time()
assert restore_time - set_time < 0.1
finally:
# deleting this should ensure it drops out of the weak set and doesn't hang things up later...
del self.callback_event
self.callback_stop = True
self.notify_event.set()
ct.join()
def test_parallel_sleeps(self):
"""Tests that sleep comes back quicker than normal when time is advanced, and that this works with lots of threads"""
first_time = virtualtime._original_time()
sleeper_threads = {}
REPEATS = 100
for n in range(REPEATS):
sleeper_threads[n] = sleeper_thread = threading.Thread(
target=time.sleep,
args=(3, ),
name="test_sleep_sleeper_%d" % n)
sleeper_thread.start()
self.wait_sleep_started(REPEATS, 0.5)
thread_time = virtualtime._original_time()
setup_duration = thread_time - first_time
assert setup_duration < 0.5
virtualtime.set_time(thread_time + 20)
for n in range(REPEATS):
sleeper_threads[n].join()
join_time = virtualtime._original_time()
sleep_duration = join_time - thread_time
virtualtime.restore_time()
if self.virtual_time_enabled:
assert sleep_duration < 0.2
else:
assert sleep_duration >= 3
def test_callback(self):
self.notify_event = threading.Event()
virtualtime.notify_on_change(self.notify_event)
self.callback_stop = False
self.callback_event = threading.Event()
self.callback_logs = []
self.callback_missed = []
ct = threading.Thread(target=self.callback_thread)
ct.start()
virtualtime.wait_for_callback_on_change(self.callback_event)
try:
start_time = virtualtime._original_time()
virtualtime.set_offset(1)
assert len(self.callback_logs) == 1 and not self.callback_missed
assert self.callback_logs[0][1:] == (1, False)
offset_time = virtualtime._original_time()
assert offset_time - start_time < 0.1
virtualtime.set_time(0)
assert len(self.callback_logs) == 2 and not self.callback_missed
assert self.callback_logs[1][
1] < -start_time + 1 and self.callback_logs[1][2] is False
set_time = virtualtime._original_time()
assert set_time - offset_time < 0.1
virtualtime.restore_time()
assert len(self.callback_logs) == 3 and not self.callback_missed
assert self.callback_logs[1][
1] < -start_time + 1 and self.callback_logs[1][2] is False
restore_time = virtualtime._original_time()
assert restore_time - set_time < 0.1
finally:
# deleting this should ensure it drops out of the weak set and doesn't hang things up later...
del self.callback_event
self.callback_stop = True
self.notify_event.set()
ct.join()
def wait_sleep_started(self, sleep_count, max_wait=5.0):
"""Waits for the given number of sleeps to start before continuing (with a timeout)"""
if not self.virtual_time_enabled:
return
start_wait_check = virtualtime._original_time()
while self.count_waiters() < self.initial_waiter_count + sleep_count:
virtualtime._original_sleep(0.001)
delay = virtualtime._original_time() - start_wait_check
if delay > max_wait:
raise ValueError("Not enough sleepers started waiting in time...")
def wait_sleep_started(self, sleep_count, max_wait=5.0):
"""Waits for the given number of sleeps to start before continuing (with a timeout)"""
if not self.virtual_time_enabled:
return
start_wait_check = virtualtime._original_time()
while self.count_waiters() < self.initial_waiter_count + sleep_count:
virtualtime._original_sleep(0.001)
delay = virtualtime._original_time() - start_wait_check
if delay > max_wait:
raise ValueError(
"Not enough sleepers started waiting in time...")
def callback_thread(self):
"""Repeatedly sets the target event whilst recording the offsets"""
while not self.callback_stop:
if self.notify_event.wait(5):
if self.callback_stop:
break
self.callback_logs.append((virtualtime._original_time(), virtualtime._time_offset, self.callback_event.is_set()))
self.notify_event.clear()
self.callback_event.set()
elif not self.callback_stop:
self.callback_missed.append((virtualtime._original_time(), virtualtime._time_offset))
def callback_thread(self):
"""Repeatedly sets the target event whilst recording the offsets"""
while not self.callback_stop:
if self.notify_event.wait(5):
if self.callback_stop:
break
self.callback_logs.append(
(virtualtime._original_time(), virtualtime._time_offset,
self.callback_event.is_set()))
self.notify_event.clear()
self.callback_event.set()
elif not self.callback_stop:
self.callback_missed.append(
(virtualtime._original_time(), virtualtime._time_offset))
def test_fast_forward_time(self):
"""Test that fast forwarding the time works properly"""
event = threading.Event()
virtualtime.notify_on_change(event)
offsets = []
msg_dict = {'offsets': offsets}
catcher_thread = threading.Thread(target=self.fast_forward_catcher, args=(event, msg_dict))
catcher_thread.start()
start_time = virtualtime._original_time()
virtualtime.fast_forward_time(1)
assert virtualtime._time_offset == 1
virtualtime.fast_forward_time(2.5)
assert virtualtime._time_offset == 3.5
virtualtime.fast_forward_time(target=start_time + 9.1, step_size=2.0)
assert 9 <= virtualtime._time_offset <= 9.2
virtualtime.restore_time()
virtualtime.fast_forward_time(-1.3, step_size=0.9)
virtualtime.restore_time()
msg_dict['stop'] = True
event.set()
catcher_thread.join()
assert offsets[:6] == [1.0, 2.0, 3.0, 3.5, 5.5, 7.5]
assert 9 <= offsets[6] <= 9.2
assert offsets[7:11] == [0, -0.9, -1.3, 0]
# depends on how long the stop event takes?
assert (not offsets[11:]) or offsets[11:] == [0]
def test_fast_forward_time(self):
"""Test that fast forwarding the time works properly"""
event = threading.Event()
virtualtime.notify_on_change(event)
offsets = []
msg_dict = {'offsets': offsets}
catcher_thread = threading.Thread(target=self.fast_forward_catcher,
args=(event, msg_dict))
catcher_thread.start()
start_time = virtualtime._original_time()
virtualtime.fast_forward_time(1)
assert virtualtime._time_offset == 1
virtualtime.fast_forward_time(2.5)
assert virtualtime._time_offset == 3.5
virtualtime.fast_forward_time(target=start_time + 9.1, step_size=2.0)
assert 9 <= virtualtime._time_offset <= 9.2
virtualtime.restore_time()
virtualtime.fast_forward_time(-1.3, step_size=0.9)
virtualtime.restore_time()
msg_dict['stop'] = True
event.set()
catcher_thread.join()
assert offsets[:6] == [1.0, 2.0, 3.0, 3.5, 5.5, 7.5]
assert 9 <= offsets[6] <= 9.2
assert offsets[7:11] == [0, -0.9, -1.3, 0]
# depends on how long the stop event takes?
assert (not offsets[11:]) or offsets[11:] == [0]
def test_notify_on_change(self):
self.notify_event = threading.Event()
virtualtime.notify_on_change(self.notify_event)
start_time = virtualtime._original_time()
virtualtime.set_offset(1)
assert self.notify_event.wait(0.1)
self.notify_event.clear()
offset_time = virtualtime._original_time()
assert offset_time - start_time < 0.1
virtualtime.set_time(0)
assert self.notify_event.wait(0.1)
self.notify_event.clear()
set_time = virtualtime._original_time()
assert set_time - offset_time < 0.1
virtualtime.restore_time()
assert self.notify_event.wait(0.1)
self.notify_event.clear()
restore_time = virtualtime._original_time()
assert restore_time - set_time < 0.1
def test_notify_on_change(self):
self.notify_event = threading.Event()
virtualtime.notify_on_change(self.notify_event)
start_time = virtualtime._original_time()
virtualtime.set_offset(1)
assert self.notify_event.wait(0.1)
self.notify_event.clear()
offset_time = virtualtime._original_time()
assert offset_time - start_time < 0.1
virtualtime.set_time(0)
assert self.notify_event.wait(0.1)
self.notify_event.clear()
set_time = virtualtime._original_time()
assert set_time - offset_time < 0.1
virtualtime.restore_time()
assert self.notify_event.wait(0.1)
self.notify_event.clear()
restore_time = virtualtime._original_time()
assert restore_time - set_time < 0.1
def test_parallel_sleeps(self):
"""Tests that sleep comes back quicker than normal when time is advanced, and that this works with lots of threads"""
first_time = virtualtime._original_time()
sleeper_threads = {}
REPEATS = 100
for n in range(REPEATS):
sleeper_threads[n] = sleeper_thread = threading.Thread(target=time.sleep, args=(3,), name="test_sleep_sleeper_%d" % n)
sleeper_thread.start()
self.wait_sleep_started(REPEATS, 0.5)
thread_time = virtualtime._original_time()
setup_duration = thread_time - first_time
assert setup_duration < 0.5
virtualtime.set_time(thread_time + 20)
for n in range(REPEATS):
sleeper_threads[n].join()
join_time = virtualtime._original_time()
sleep_duration = join_time - thread_time
virtualtime.restore_time()
if self.virtual_time_enabled:
assert sleep_duration < 0.2
else:
assert sleep_duration >= 3
def test_missed(self):
"""Test missing time events by sleeping in the target function"""
tm = TimerDriver(1)
timer = Timer.Timer(tm.sleepfunc, args=(iter([0, 2, 3, 0, 6]), ))
thread = threading.Thread(target=timer.start)
thread.start()
start_time = virtualtime._original_time()
# make sure our sleep happens within the last 6-second pause
self.sleep(12)
print(time.time(), tm.lasttime)
timer.stop = True
assert tm.lasttime is not None
assert 4 <= tm.ticks <= 5
self.finish_wait(thread, tm.errors, 6)
def test_missed(self):
"""Test missing time events by sleeping in the target function"""
tm = TimerDriver(1)
timer = Timer.Timer(tm.sleepfunc, args=(iter([0,2,3,0,6]),))
thread = threading.Thread(target=timer.start)
thread.start()
start_time = virtualtime._original_time()
# make sure our sleep happens within the last 6-second pause
self.sleep(12)
print time.time(), tm.lasttime
timer.stop = True
assert tm.lasttime is not None
assert 4 <= tm.ticks <= 5
self.finish_wait(thread, tm.errors, 6)
def test_fast_forward_delay(self):
"""Test that fast forwarding the time works properly"""
notify_event = threading.Event()
virtualtime.notify_on_change(notify_event)
delay_event = threading.Event()
offsets = []
positions = ["start_job", ""]
msg_dict = {'offsets': offsets, 'positions': positions}
catcher_thread = threading.Thread(target=self.fast_forward_delayer, args=(notify_event, delay_event, msg_dict))
catcher_thread.start()
start_time = virtualtime._original_time()
virtualtime.fast_forward_time(2)
assert virtualtime._time_offset == 2
virtualtime.restore_time()
msg_dict['stop'] = True
notify_event.set()
catcher_thread.join()
completion_time = virtualtime._original_time()
assert offsets[:3] == [1.0, 2.0, 0]
# depends on how long the stop event takes?
assert (not offsets[3:]) or offsets[3:] == [0]
assert completion_time - start_time < 0.2
assert delay_event.is_set()
def test_fast_forward_time_long(self):
"""Test that fast forwarding the time a long way works properly"""
event = threading.Event()
virtualtime.notify_on_change(event)
offsets = []
msg_dict = {'offsets': offsets}
catcher_thread = threading.Thread(target=self.fast_forward_catcher, args=(event, msg_dict))
catcher_thread.start()
start_time = virtualtime._original_time()
virtualtime.fast_forward_time(1000, step_size=1)
virtualtime.restore_time()
msg_dict['stop'] = True
event.set()
catcher_thread.join()
assert offsets == list(range(1, 1001)) + [0]
def test_fast_forward_time_long(self):
"""Test that fast forwarding the time a long way works properly"""
event = threading.Event()
virtualtime.notify_on_change(event)
offsets = []
msg_dict = {'offsets': offsets}
catcher_thread = threading.Thread(target=self.fast_forward_catcher,
args=(event, msg_dict))
catcher_thread.start()
start_time = virtualtime._original_time()
virtualtime.fast_forward_time(1000, step_size=1)
virtualtime.restore_time()
msg_dict['stop'] = True
event.set()
catcher_thread.join()
assert offsets == list(range(1, 1001)) + [0]
