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_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_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 test_fast_forward_datetime_style(self):
"""Test that fast forwarding the time works properly when using datetime-style objects"""
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_datetime_now()
utc_start_time = datetime_tz.localize(start_time).astimezone(pytz.utc)
virtualtime.fast_forward_timedelta(datetime.timedelta(seconds=1))
assert virtualtime._time_offset == 1
virtualtime.fast_forward_timedelta(datetime.timedelta(seconds=2.5))
assert virtualtime._time_offset == 3.5
virtualtime.fast_forward_local_datetime(target=start_time + datetime.timedelta(seconds=9.1), step_size=datetime.timedelta(seconds=2.0))
assert 9 <= virtualtime._time_offset <= 9.2
virtualtime.fast_forward_utc_datetime(target=utc_start_time + datetime.timedelta(seconds=18.2), step_size=datetime.timedelta(seconds=20.0))
assert 18 <= virtualtime._time_offset <= 18.3
virtualtime.restore_time()
virtualtime.fast_forward_timedelta(datetime.timedelta(seconds=-1.3), step_size=datetime.timedelta(seconds=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 18 <= offsets[7] <= 18.3
assert offsets[8:12] == [0, -0.9, -1.3, 0]
# depends on how long the stop event takes?
assert (not offsets[12:]) or offsets[12:] == [0]
def test_sleep(self):
"""Tests that sleep comes back quicker than normal when time is advanced"""
first_time = time.time()
sleeper_thread = threading.Thread(target=time.sleep, args=(3,), name="test_sleep_sleeper")
sleeper_thread.start()
self.wait_sleep_started(1, 0.2)
virtualtime.set_time(first_time + 5)
sleeper_thread.join()
virtualtime.restore_time()
join_time = time.time()
if self.virtual_time_enabled:
assert join_time - first_time < 0.5
else:
assert join_time - first_time >= 3
def run_time_function_tst(time_function, set_function, diff, enabled=True):
"""Generic test for time_function and a set_function that can move the return of that time_function forwards or backwards by diff
Checks that the right thing will happen when virtualtime enabled/disabled"""
first_time = time_function()
set_function(first_time + diff)
late_time = time_function()
set_function(first_time - diff)
early_time = time_function()
virtualtime.restore_time()
last_time = time_function()
if enabled:
assert early_time < first_time < last_time < late_time
else:
assert first_time <= late_time <= early_time <= last_time
def run_time_function_tst(time_function, set_function, diff, enabled=True):
"""Generic test for time_function and a set_function that can move the return of that time_function forwards or backwards by diff
Checks that the right thing will happen when virtualtime enabled/disabled"""
first_time = time_function()
set_function(first_time + diff)
late_time = time_function()
set_function(first_time - diff)
early_time = time_function()
virtualtime.restore_time()
last_time = time_function()
if enabled:
assert early_time < first_time < last_time < late_time
else:
assert first_time <= late_time <= early_time <= last_time
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]
def test_sleep(self):
"""Tests that sleep comes back quicker than normal when time is advanced"""
first_time = time.time()
sleeper_thread = threading.Thread(target=time.sleep,
args=(3, ),
name="test_sleep_sleeper")
sleeper_thread.start()
self.wait_sleep_started(1, 0.2)
virtualtime.set_time(first_time + 5)
sleeper_thread.join()
virtualtime.restore_time()
join_time = time.time()
if self.virtual_time_enabled:
assert join_time - first_time < 0.5
else:
assert join_time - first_time >= 3
def run_time_derived_function_tst(derived_function, time_function, set_function, diff, min_diff=None, enabled=True):
"""Generic test for time_function and a set_function that can move the return of that time_function forwards or backwards by diff
Checks that the right thing will happen when virtualtime enabled/disabled"""
first_derived, first_time = derived_function(), time_function()
set_function(first_time + diff)
late_derived = derived_function()
set_function(first_time - diff)
early_derived = derived_function()
virtualtime.restore_time()
if min_diff:
time.sleep(min_diff)
last_derived = derived_function()
if enabled:
assert early_derived < first_derived < last_derived < late_derived
else:
assert first_derived <= late_derived <= early_derived <= last_derived
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 run_time_derived_function_tst(derived_function,
time_function,
set_function,
diff,
min_diff=None,
enabled=True):
"""Generic test for time_function and a set_function that can move the return of that time_function forwards or backwards by diff
Checks that the right thing will happen when virtualtime enabled/disabled"""
first_derived, first_time = derived_function(), time_function()
set_function(first_time + diff)
late_derived = derived_function()
set_function(first_time - diff)
early_derived = derived_function()
virtualtime.restore_time()
if min_diff:
time.sleep(min_diff)
last_derived = derived_function()
if enabled:
assert early_derived < first_derived < last_derived < late_derived
else:
assert first_derived <= late_derived <= early_derived <= last_derived
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_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_datetime_style(self):
"""Test that fast forwarding the time works properly when using datetime-style objects"""
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_datetime_now()
utc_start_time = datetime_tz.localize(start_time).astimezone(pytz.utc)
virtualtime.fast_forward_timedelta(datetime.timedelta(seconds=1))
assert virtualtime._time_offset == 1
virtualtime.fast_forward_timedelta(datetime.timedelta(seconds=2.5))
assert virtualtime._time_offset == 3.5
virtualtime.fast_forward_local_datetime(
target=start_time + datetime.timedelta(seconds=9.1),
step_size=datetime.timedelta(seconds=2.0))
assert 9 <= virtualtime._time_offset <= 9.2
virtualtime.fast_forward_utc_datetime(
target=utc_start_time + datetime.timedelta(seconds=18.2),
step_size=datetime.timedelta(seconds=20.0))
assert 18 <= virtualtime._time_offset <= 18.3
virtualtime.restore_time()
virtualtime.fast_forward_timedelta(
datetime.timedelta(seconds=-1.3),
step_size=datetime.timedelta(seconds=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 18 <= offsets[7] <= 18.3
assert offsets[8:12] == [0, -0.9, -1.3, 0]
# depends on how long the stop event takes?
assert (not offsets[12:]) or offsets[12:] == [0]
def restore_time_after(test_function, *args, **kwargs):
try:
return test_function(*args, **kwargs)
finally:
virtualtime.restore_time()
def restore_time_after(test_function, *args, **kwargs):
try:
return test_function(*args, **kwargs)
finally:
virtualtime.restore_time()
def tearDown(self):
"""Restores normal time after the method has finished"""
virtualtime.restore_time()
def tearDown(self):
"""Restores normal time after the method has finished"""
virtualtime.restore_time()
def setUp(self):
"""Restores normal time to ensure tests start cleanly"""
virtualtime.restore_time()
def setUp(self):
"""Restores normal time to ensure tests start cleanly"""
virtualtime.restore_time()
