406 lines
12 KiB
Python
406 lines
12 KiB
Python
"""
|
|
Unit tests for corelibs.debug_handling.timer module
|
|
"""
|
|
|
|
import time
|
|
from datetime import datetime, timedelta
|
|
|
|
from corelibs.debug_handling.timer import Timer
|
|
|
|
|
|
class TestTimerInitialization:
|
|
"""Test Timer class initialization"""
|
|
|
|
def test_timer_initialization(self):
|
|
"""Test that Timer initializes with correct default values"""
|
|
timer = Timer()
|
|
|
|
# Check that start times are set
|
|
assert isinstance(timer.get_overall_start_time(), datetime)
|
|
assert isinstance(timer.get_start_time(), datetime)
|
|
|
|
# Check that end times are None
|
|
assert timer.get_overall_end_time() is None
|
|
assert timer.get_end_time() is None
|
|
|
|
# Check that run times are None
|
|
assert timer.get_overall_run_time() is None
|
|
assert timer.get_run_time() is None
|
|
|
|
def test_timer_start_times_are_recent(self):
|
|
"""Test that start times are set to current time on initialization"""
|
|
before_init = datetime.now()
|
|
timer = Timer()
|
|
after_init = datetime.now()
|
|
|
|
overall_start = timer.get_overall_start_time()
|
|
start = timer.get_start_time()
|
|
|
|
assert before_init <= overall_start <= after_init
|
|
assert before_init <= start <= after_init
|
|
|
|
def test_timer_start_times_are_same(self):
|
|
"""Test that overall_start_time and start_time are initialized to the same time"""
|
|
timer = Timer()
|
|
|
|
overall_start = timer.get_overall_start_time()
|
|
start = timer.get_start_time()
|
|
|
|
# They should be very close (within a few microseconds)
|
|
time_diff = abs((overall_start - start).total_seconds())
|
|
assert time_diff < 0.001 # Less than 1 millisecond
|
|
|
|
|
|
class TestOverallRunTime:
|
|
"""Test overall run time functionality"""
|
|
|
|
def test_overall_run_time_returns_timedelta(self):
|
|
"""Test that overall_run_time returns a timedelta object"""
|
|
timer = Timer()
|
|
time.sleep(0.01) # Sleep for 10ms
|
|
|
|
result = timer.overall_run_time()
|
|
|
|
assert isinstance(result, timedelta)
|
|
|
|
def test_overall_run_time_sets_end_time(self):
|
|
"""Test that calling overall_run_time sets the end time"""
|
|
timer = Timer()
|
|
|
|
assert timer.get_overall_end_time() is None
|
|
|
|
timer.overall_run_time()
|
|
|
|
assert isinstance(timer.get_overall_end_time(), datetime)
|
|
|
|
def test_overall_run_time_sets_run_time(self):
|
|
"""Test that calling overall_run_time sets the run time"""
|
|
timer = Timer()
|
|
|
|
assert timer.get_overall_run_time() is None
|
|
|
|
timer.overall_run_time()
|
|
|
|
assert isinstance(timer.get_overall_run_time(), timedelta)
|
|
|
|
def test_overall_run_time_accuracy(self):
|
|
"""Test that overall_run_time calculates time difference accurately"""
|
|
timer = Timer()
|
|
sleep_duration = 0.05 # 50ms
|
|
time.sleep(sleep_duration)
|
|
|
|
result = timer.overall_run_time()
|
|
|
|
# Allow for some variance (10ms tolerance)
|
|
assert sleep_duration - 0.01 <= result.total_seconds() <= sleep_duration + 0.01
|
|
|
|
def test_overall_run_time_multiple_calls(self):
|
|
"""Test that calling overall_run_time multiple times updates the values"""
|
|
timer = Timer()
|
|
time.sleep(0.01)
|
|
|
|
first_result = timer.overall_run_time()
|
|
first_end_time = timer.get_overall_end_time()
|
|
|
|
time.sleep(0.01)
|
|
|
|
second_result = timer.overall_run_time()
|
|
second_end_time = timer.get_overall_end_time()
|
|
|
|
# Second call should have longer runtime
|
|
assert second_result > first_result
|
|
assert second_end_time is not None
|
|
assert first_end_time is not None
|
|
# End time should be updated
|
|
assert second_end_time > first_end_time
|
|
|
|
def test_overall_run_time_consistency(self):
|
|
"""Test that get_overall_run_time returns the same value as overall_run_time"""
|
|
timer = Timer()
|
|
time.sleep(0.01)
|
|
|
|
calculated_time = timer.overall_run_time()
|
|
retrieved_time = timer.get_overall_run_time()
|
|
|
|
assert calculated_time == retrieved_time
|
|
|
|
|
|
class TestRunTime:
|
|
"""Test run time functionality"""
|
|
|
|
def test_run_time_returns_timedelta(self):
|
|
"""Test that run_time returns a timedelta object"""
|
|
timer = Timer()
|
|
time.sleep(0.01)
|
|
|
|
result = timer.run_time()
|
|
|
|
assert isinstance(result, timedelta)
|
|
|
|
def test_run_time_sets_end_time(self):
|
|
"""Test that calling run_time sets the end time"""
|
|
timer = Timer()
|
|
|
|
assert timer.get_end_time() is None
|
|
|
|
timer.run_time()
|
|
|
|
assert isinstance(timer.get_end_time(), datetime)
|
|
|
|
def test_run_time_sets_run_time(self):
|
|
"""Test that calling run_time sets the run time"""
|
|
timer = Timer()
|
|
|
|
assert timer.get_run_time() is None
|
|
|
|
timer.run_time()
|
|
|
|
assert isinstance(timer.get_run_time(), timedelta)
|
|
|
|
def test_run_time_accuracy(self):
|
|
"""Test that run_time calculates time difference accurately"""
|
|
timer = Timer()
|
|
sleep_duration = 0.05 # 50ms
|
|
time.sleep(sleep_duration)
|
|
|
|
result = timer.run_time()
|
|
|
|
# Allow for some variance (10ms tolerance)
|
|
assert sleep_duration - 0.01 <= result.total_seconds() <= sleep_duration + 0.01
|
|
|
|
def test_run_time_multiple_calls(self):
|
|
"""Test that calling run_time multiple times updates the values"""
|
|
timer = Timer()
|
|
time.sleep(0.01)
|
|
|
|
first_result = timer.run_time()
|
|
first_end_time = timer.get_end_time()
|
|
|
|
time.sleep(0.01)
|
|
|
|
second_result = timer.run_time()
|
|
second_end_time = timer.get_end_time()
|
|
|
|
# Second call should have longer runtime
|
|
assert second_result > first_result
|
|
assert second_end_time is not None
|
|
assert first_end_time is not None
|
|
# End time should be updated
|
|
assert second_end_time > first_end_time
|
|
|
|
def test_run_time_consistency(self):
|
|
"""Test that get_run_time returns the same value as run_time"""
|
|
timer = Timer()
|
|
time.sleep(0.01)
|
|
|
|
calculated_time = timer.run_time()
|
|
retrieved_time = timer.get_run_time()
|
|
|
|
assert calculated_time == retrieved_time
|
|
|
|
|
|
class TestResetRunTime:
|
|
"""Test reset_run_time functionality"""
|
|
|
|
def test_reset_run_time_resets_start_time(self):
|
|
"""Test that reset_run_time updates the start time"""
|
|
timer = Timer()
|
|
original_start = timer.get_start_time()
|
|
|
|
time.sleep(0.02)
|
|
timer.reset_run_time()
|
|
|
|
new_start = timer.get_start_time()
|
|
|
|
assert new_start > original_start
|
|
|
|
def test_reset_run_time_clears_end_time(self):
|
|
"""Test that reset_run_time clears the end time"""
|
|
timer = Timer()
|
|
timer.run_time()
|
|
|
|
assert timer.get_end_time() is not None
|
|
|
|
timer.reset_run_time()
|
|
|
|
assert timer.get_end_time() is None
|
|
|
|
def test_reset_run_time_clears_run_time(self):
|
|
"""Test that reset_run_time clears the run time"""
|
|
timer = Timer()
|
|
timer.run_time()
|
|
|
|
assert timer.get_run_time() is not None
|
|
|
|
timer.reset_run_time()
|
|
|
|
assert timer.get_run_time() is None
|
|
|
|
def test_reset_run_time_does_not_affect_overall_times(self):
|
|
"""Test that reset_run_time does not affect overall times"""
|
|
timer = Timer()
|
|
|
|
overall_start = timer.get_overall_start_time()
|
|
timer.overall_run_time()
|
|
overall_end = timer.get_overall_end_time()
|
|
overall_run = timer.get_overall_run_time()
|
|
|
|
timer.reset_run_time()
|
|
|
|
# Overall times should remain unchanged
|
|
assert timer.get_overall_start_time() == overall_start
|
|
assert timer.get_overall_end_time() == overall_end
|
|
assert timer.get_overall_run_time() == overall_run
|
|
|
|
def test_reset_run_time_allows_new_measurement(self):
|
|
"""Test that reset_run_time allows for new time measurements"""
|
|
timer = Timer()
|
|
time.sleep(0.02)
|
|
timer.run_time()
|
|
|
|
first_run_time = timer.get_run_time()
|
|
|
|
timer.reset_run_time()
|
|
time.sleep(0.01)
|
|
timer.run_time()
|
|
|
|
second_run_time = timer.get_run_time()
|
|
|
|
assert second_run_time is not None
|
|
assert first_run_time is not None
|
|
# Second measurement should be shorter since we reset
|
|
assert second_run_time < first_run_time
|
|
|
|
|
|
class TestTimerIntegration:
|
|
"""Integration tests for Timer class"""
|
|
|
|
def test_independent_timers(self):
|
|
"""Test that multiple Timer instances are independent"""
|
|
timer1 = Timer()
|
|
time.sleep(0.01)
|
|
timer2 = Timer()
|
|
|
|
# timer1 should have earlier start time
|
|
assert timer1.get_start_time() < timer2.get_start_time()
|
|
assert timer1.get_overall_start_time() < timer2.get_overall_start_time()
|
|
|
|
def test_overall_and_run_time_independence(self):
|
|
"""Test that overall time and run time are independent"""
|
|
timer = Timer()
|
|
time.sleep(0.02)
|
|
|
|
# Reset run time but not overall
|
|
timer.reset_run_time()
|
|
time.sleep(0.01)
|
|
|
|
run_time = timer.run_time()
|
|
overall_time = timer.overall_run_time()
|
|
|
|
# Overall time should be longer than run time
|
|
assert overall_time > run_time
|
|
|
|
def test_typical_usage_pattern(self):
|
|
"""Test a typical usage pattern of the Timer class"""
|
|
timer = Timer()
|
|
|
|
# Measure first operation
|
|
time.sleep(0.01)
|
|
first_operation = timer.run_time()
|
|
assert first_operation.total_seconds() > 0
|
|
|
|
# Reset and measure second operation
|
|
timer.reset_run_time()
|
|
time.sleep(0.01)
|
|
second_operation = timer.run_time()
|
|
assert second_operation.total_seconds() > 0
|
|
|
|
# Get overall time
|
|
overall = timer.overall_run_time()
|
|
|
|
# Overall should be greater than individual operations
|
|
assert overall > first_operation
|
|
assert overall > second_operation
|
|
|
|
def test_zero_sleep_timer(self):
|
|
"""Test timer with minimal sleep (edge case)"""
|
|
timer = Timer()
|
|
|
|
# Call run_time immediately
|
|
result = timer.run_time()
|
|
|
|
# Should still return a valid timedelta (very small)
|
|
assert isinstance(result, timedelta)
|
|
assert result.total_seconds() >= 0
|
|
|
|
def test_getter_methods_before_calculation(self):
|
|
"""Test that getter methods return None before calculation methods are called"""
|
|
timer = Timer()
|
|
|
|
# Before calling run_time()
|
|
assert timer.get_end_time() is None
|
|
assert timer.get_run_time() is None
|
|
|
|
# Before calling overall_run_time()
|
|
assert timer.get_overall_end_time() is None
|
|
assert timer.get_overall_run_time() is None
|
|
|
|
# But start times should always be set
|
|
assert timer.get_start_time() is not None
|
|
assert timer.get_overall_start_time() is not None
|
|
|
|
|
|
class TestTimerEdgeCases:
|
|
"""Test edge cases and boundary conditions"""
|
|
|
|
def test_rapid_consecutive_calls(self):
|
|
"""Test rapid consecutive calls to run_time"""
|
|
timer = Timer()
|
|
|
|
results: list[timedelta] = []
|
|
for _ in range(5):
|
|
results.append(timer.run_time())
|
|
|
|
# Each result should be greater than or equal to the previous
|
|
for i in range(1, len(results)):
|
|
assert results[i] >= results[i - 1]
|
|
|
|
def test_very_short_duration(self):
|
|
"""Test timer with very short duration"""
|
|
timer = Timer()
|
|
result = timer.run_time()
|
|
|
|
# Should be a very small positive timedelta
|
|
assert isinstance(result, timedelta)
|
|
assert result.total_seconds() >= 0
|
|
assert result.total_seconds() < 0.1 # Less than 100ms
|
|
|
|
def test_reset_multiple_times(self):
|
|
"""Test resetting the timer multiple times"""
|
|
timer = Timer()
|
|
|
|
for _ in range(3):
|
|
timer.reset_run_time()
|
|
time.sleep(0.01)
|
|
result = timer.run_time()
|
|
|
|
assert isinstance(result, timedelta)
|
|
assert result.total_seconds() > 0
|
|
|
|
def test_overall_time_persists_through_resets(self):
|
|
"""Test that overall time continues even when run_time is reset"""
|
|
timer = Timer()
|
|
|
|
time.sleep(0.01)
|
|
timer.reset_run_time()
|
|
|
|
time.sleep(0.01)
|
|
timer.reset_run_time()
|
|
|
|
overall = timer.overall_run_time()
|
|
|
|
# Overall time should reflect total elapsed time
|
|
assert overall.total_seconds() >= 0.02
|
|
|
|
# __END__
|