512 lines
20 KiB
Python
512 lines
20 KiB
Python
import time
|
|
import unittest
|
|
|
|
import pygame
|
|
|
|
Clock = pygame.time.Clock
|
|
|
|
|
|
class ClockTypeTest(unittest.TestCase):
|
|
__tags__ = ["timing"]
|
|
|
|
def test_clock_alias(self):
|
|
"""Check if pygame.Clock is present and the correct type."""
|
|
self.assertIs(pygame.Clock, pygame.time.Clock)
|
|
|
|
def test_construction(self):
|
|
"""Ensure a Clock object can be created"""
|
|
c = Clock()
|
|
|
|
self.assertTrue(c, "Clock cannot be constructed")
|
|
|
|
def test_get_fps(self):
|
|
"""test_get_fps tests pygame.time.get_fps()"""
|
|
# Initialization check, first call should return 0 fps
|
|
c = Clock()
|
|
self.assertEqual(c.get_fps(), 0)
|
|
# Type check get_fps should return float
|
|
self.assertTrue(type(c.get_fps()) == float)
|
|
# Allowable margin of error in percentage
|
|
delta = 0.30
|
|
# Test fps correctness for 100, 60 and 30 fps
|
|
self._fps_test(c, 100, delta)
|
|
self._fps_test(c, 60, delta)
|
|
self._fps_test(c, 30, delta)
|
|
|
|
def _fps_test(self, clock, fps, delta):
|
|
"""ticks fps times each second, hence get_fps() should return fps"""
|
|
delay_per_frame = 1.0 / fps
|
|
for f in range(fps): # For one second tick and sleep
|
|
clock.tick()
|
|
time.sleep(delay_per_frame)
|
|
# We should get around fps (+- fps*delta -- delta % of fps)
|
|
self.assertAlmostEqual(clock.get_fps(), fps, delta=fps * delta)
|
|
|
|
def test_get_rawtime(self):
|
|
iterations = 10
|
|
delay = 0.1
|
|
delay_miliseconds = delay * (10**3) # actual time difference between ticks
|
|
framerate_limit = 5
|
|
delta = 50 # allowable error in milliseconds
|
|
|
|
# Testing Clock Initialization
|
|
c = Clock()
|
|
self.assertEqual(c.get_rawtime(), 0)
|
|
|
|
# Testing Raw Time with Frame Delay
|
|
for f in range(iterations):
|
|
time.sleep(delay)
|
|
c.tick(framerate_limit)
|
|
c1 = c.get_rawtime()
|
|
self.assertAlmostEqual(delay_miliseconds, c1, delta=delta)
|
|
|
|
# Testing get_rawtime() = get_time()
|
|
for f in range(iterations):
|
|
time.sleep(delay)
|
|
c.tick()
|
|
c1 = c.get_rawtime()
|
|
c2 = c.get_time()
|
|
self.assertAlmostEqual(c1, c2, delta=delta)
|
|
|
|
def test_get_time(self):
|
|
# Testing parameters
|
|
delay = 0.1 # seconds
|
|
delay_miliseconds = delay * (10**3)
|
|
iterations = 10
|
|
delta = 50 # milliseconds
|
|
|
|
# Testing Clock Initialization
|
|
c = Clock()
|
|
self.assertEqual(c.get_time(), 0)
|
|
|
|
# Testing within delay parameter range
|
|
for i in range(iterations):
|
|
time.sleep(delay)
|
|
c.tick()
|
|
c1 = c.get_time()
|
|
self.assertAlmostEqual(delay_miliseconds, c1, delta=delta)
|
|
|
|
# Comparing get_time() results with the 'time' module
|
|
for i in range(iterations):
|
|
t0 = time.time()
|
|
time.sleep(delay)
|
|
c.tick()
|
|
t1 = time.time()
|
|
c1 = c.get_time() # elapsed time in milliseconds
|
|
d0 = (t1 - t0) * (
|
|
10**3
|
|
) #'time' module elapsed time converted to milliseconds
|
|
self.assertAlmostEqual(d0, c1, delta=delta)
|
|
|
|
def test_tick(self):
|
|
"""Tests time.Clock.tick()"""
|
|
"""
|
|
Loops with a set delay a few times then checks what tick reports to
|
|
verify its accuracy. Then calls tick with a desired frame-rate and
|
|
verifies it is not faster than the desired frame-rate nor is it taking
|
|
a dramatically long time to complete
|
|
"""
|
|
|
|
# Adjust this value to increase the acceptable sleep jitter
|
|
epsilon = 1.5
|
|
# Adjust this value to increase the acceptable locked frame-rate jitter
|
|
epsilon2 = 0.3
|
|
# adjust this value to increase the acceptable frame-rate margin
|
|
epsilon3 = 20
|
|
testing_framerate = 60
|
|
milliseconds = 5.0
|
|
|
|
collection = []
|
|
c = Clock()
|
|
|
|
# verify time.Clock.tick() will measure the time correctly
|
|
c.tick()
|
|
for i in range(100):
|
|
time.sleep(milliseconds / 1000) # convert to seconds
|
|
collection.append(c.tick())
|
|
|
|
# removes the first highest and lowest value
|
|
for outlier in [min(collection), max(collection)]:
|
|
if outlier != milliseconds:
|
|
collection.remove(outlier)
|
|
|
|
average_time = float(sum(collection)) / len(collection)
|
|
|
|
# assert the deviation from the intended frame-rate is within the
|
|
# acceptable amount (the delay is not taking a dramatically long time)
|
|
self.assertAlmostEqual(average_time, milliseconds, delta=epsilon)
|
|
|
|
# verify tick will control the frame-rate
|
|
|
|
c = Clock()
|
|
collection = []
|
|
|
|
start = time.time()
|
|
|
|
for i in range(testing_framerate):
|
|
collection.append(c.tick(testing_framerate))
|
|
|
|
# remove the highest and lowest outliers
|
|
for outlier in [min(collection), max(collection)]:
|
|
if outlier != round(1000 / testing_framerate):
|
|
collection.remove(outlier)
|
|
|
|
end = time.time()
|
|
|
|
# Since calling tick with a desired fps will prevent the program from
|
|
# running at greater than the given fps, 100 iterations at 100 fps
|
|
# should last no less than 1 second
|
|
self.assertAlmostEqual(end - start, 1, delta=epsilon2)
|
|
|
|
average_tick_time = float(sum(collection)) / len(collection)
|
|
self.assertAlmostEqual(
|
|
1000 / average_tick_time, testing_framerate, delta=epsilon3
|
|
)
|
|
|
|
def test_tick_busy_loop(self):
|
|
"""Test tick_busy_loop"""
|
|
|
|
c = Clock()
|
|
|
|
# Test whether the return value of tick_busy_loop is equal to
|
|
# (FPS is accurate) or greater than (slower than the set FPS)
|
|
# with a small margin for error based on differences in how this
|
|
# test runs in practise - it either sometimes runs slightly fast
|
|
# or seems to based on a rounding error.
|
|
second_length = 1000
|
|
shortfall_tolerance = 1 # (ms) The amount of time a tick is allowed to run short of, to account for underlying rounding errors
|
|
sample_fps = 40
|
|
|
|
self.assertGreaterEqual(
|
|
c.tick_busy_loop(sample_fps),
|
|
(second_length / sample_fps) - shortfall_tolerance,
|
|
)
|
|
pygame.time.wait(10) # incur delay between ticks that's faster than sample_fps
|
|
self.assertGreaterEqual(
|
|
c.tick_busy_loop(sample_fps),
|
|
(second_length / sample_fps) - shortfall_tolerance,
|
|
)
|
|
pygame.time.wait(200) # incur delay between ticks that's slower than sample_fps
|
|
self.assertGreaterEqual(
|
|
c.tick_busy_loop(sample_fps),
|
|
(second_length / sample_fps) - shortfall_tolerance,
|
|
)
|
|
|
|
high_fps = 500
|
|
self.assertGreaterEqual(
|
|
c.tick_busy_loop(high_fps), (second_length / high_fps) - shortfall_tolerance
|
|
)
|
|
|
|
low_fps = 1
|
|
self.assertGreaterEqual(
|
|
c.tick_busy_loop(low_fps), (second_length / low_fps) - shortfall_tolerance
|
|
)
|
|
|
|
low_non_factor_fps = 35 # 1000/35 makes 28.5714285714
|
|
frame_length_without_decimal_places = int(
|
|
second_length / low_non_factor_fps
|
|
) # Same result as math.floor
|
|
self.assertGreaterEqual(
|
|
c.tick_busy_loop(low_non_factor_fps),
|
|
frame_length_without_decimal_places - shortfall_tolerance,
|
|
)
|
|
|
|
high_non_factor_fps = 750 # 1000/750 makes 1.3333...
|
|
frame_length_without_decimal_places_2 = int(
|
|
second_length / high_non_factor_fps
|
|
) # Same result as math.floor
|
|
self.assertGreaterEqual(
|
|
c.tick_busy_loop(high_non_factor_fps),
|
|
frame_length_without_decimal_places_2 - shortfall_tolerance,
|
|
)
|
|
|
|
zero_fps = 0
|
|
self.assertEqual(c.tick_busy_loop(zero_fps), 0)
|
|
|
|
# Check behaviour of unexpected values
|
|
|
|
negative_fps = -1
|
|
self.assertEqual(c.tick_busy_loop(negative_fps), 0)
|
|
|
|
fractional_fps = 32.75
|
|
frame_length_without_decimal_places_3 = int(second_length / fractional_fps)
|
|
self.assertGreaterEqual(
|
|
c.tick_busy_loop(fractional_fps),
|
|
frame_length_without_decimal_places_3 - shortfall_tolerance,
|
|
)
|
|
|
|
bool_fps = True
|
|
self.assertGreaterEqual(
|
|
c.tick_busy_loop(bool_fps), (second_length / bool_fps) - shortfall_tolerance
|
|
)
|
|
|
|
|
|
class TimeModuleTest(unittest.TestCase):
|
|
__tags__ = ["timing"]
|
|
|
|
def test_multiple_timers(self):
|
|
"""
|
|
Test for multiple timers running together, test repeat and dict
|
|
posting, test per event timing too
|
|
"""
|
|
pygame.init()
|
|
# other timers in background should not affect current timer
|
|
# test different kinds of timers simultaneously. Test repeat, early
|
|
# stop with repeat, and stopping timers running on infinite loops.
|
|
# test dict and no dict posting
|
|
events_tests_dict = {
|
|
# each value here is like
|
|
# (delay time(ms), event dict, set repeat, early repeat stop)
|
|
pygame.event.custom_type(): (20, {}, 3, None),
|
|
pygame.event.custom_type(): (13, {1: 2, 3: 1}, 1, None),
|
|
pygame.event.custom_type(): (30, {"attr1": 10}, 5, 5),
|
|
pygame.event.custom_type(): (15, {"foo": "bar", "spam": "eggs"}, 10, 8),
|
|
pygame.event.custom_type(): (16, {}, None, 4),
|
|
pygame.event.custom_type(): (12, {"test": 42.26}, None, 6),
|
|
pygame.event.custom_type(): (10, {"foo": "spam", "bar": "eggs"}, None, 8),
|
|
}
|
|
|
|
times = {k: 0.0 for k in events_tests_dict}
|
|
counts = {k: 0 for k in events_tests_dict}
|
|
|
|
# post events, note start times
|
|
for event, (delay, attrs, repeat, _) in events_tests_dict.items():
|
|
if repeat is None:
|
|
pygame.time.set_timer(pygame.event.Event(event, attrs), delay)
|
|
else:
|
|
pygame.time.set_timer(pygame.event.Event(event, attrs), delay, repeat)
|
|
times[event] = time.perf_counter()
|
|
|
|
# run for 500ms
|
|
loop_start = time.perf_counter()
|
|
while time.perf_counter() < loop_start + 0.5:
|
|
for event in pygame.event.get():
|
|
if event.type in events_tests_dict:
|
|
now_time = time.perf_counter()
|
|
set_time, set_dict, repeat, stop = events_tests_dict[event.type]
|
|
# measure time for each event, should almost match expected time
|
|
self.assertAlmostEqual(
|
|
(now_time - times[event.type]) * 1000, set_time, delta=4
|
|
)
|
|
|
|
# the dict attribute should be the same reference, if it exists
|
|
self.assertIs(event.dict, set_dict)
|
|
|
|
times[event.type] = now_time
|
|
counts[event.type] += 1
|
|
if counts[event.type] == stop:
|
|
# stop event
|
|
pygame.time.set_timer(event.type, 0)
|
|
|
|
# assert extra events are not created
|
|
if stop is None:
|
|
if counts[event.type] > repeat:
|
|
self.fail("got more events than expected with repeat")
|
|
else:
|
|
if counts[event.type] > stop:
|
|
self.fail("got more events, timer stop did not work")
|
|
|
|
# assert events don't come in after the stipulated time
|
|
time.sleep(0.5)
|
|
for event in pygame.event.get():
|
|
self.assertNotIn(event.type, events_tests_dict)
|
|
|
|
for event_type, (_, _, repeat, stop) in events_tests_dict.items():
|
|
# recheck that the counts exactly match, and we don't have lesser
|
|
# events than expected
|
|
if stop is not None:
|
|
self.assertEqual(stop, counts[event_type])
|
|
else:
|
|
self.assertEqual(repeat, counts[event_type])
|
|
|
|
pygame.quit()
|
|
|
|
def test_timer_wrong_args(self):
|
|
for out_of_range_val in (-1, -10, pygame.NUMEVENTS, pygame.NUMEVENTS + 1):
|
|
self.assertRaises(ValueError, pygame.time.set_timer, out_of_range_val, 10)
|
|
self.assertRaises(
|
|
ValueError, pygame.time.set_timer, event=out_of_range_val, millis=10
|
|
)
|
|
|
|
for incorrect_type in ("string", 4 + 3j, [1, 2, 3], {"a": "b"}):
|
|
self.assertRaises(TypeError, pygame.time.set_timer, incorrect_type, 15)
|
|
self.assertRaises(
|
|
TypeError, pygame.time.set_timer, event=incorrect_type, millis=15
|
|
)
|
|
|
|
def test_timer_common_reference(self):
|
|
pygame.init()
|
|
pygame.event.get() # empty queue
|
|
for event in (
|
|
pygame.event.Event(pygame.event.custom_type(), attr=(1, 2, 3, 4)),
|
|
pygame.event.Event(pygame.event.custom_type(), dict={"test": "yes"}),
|
|
pygame.event.Event(pygame.event.custom_type()),
|
|
pygame.event.custom_type(),
|
|
):
|
|
pygame.time.set_timer(event, 1, loops=2)
|
|
time.sleep(0.005)
|
|
events = pygame.event.get(pump=False)
|
|
self.assertEqual(len(events), 2)
|
|
|
|
if isinstance(event, int):
|
|
for ev in events:
|
|
self.assertEqual(ev.type, event)
|
|
self.assertEqual(ev.dict, {})
|
|
self.assertIsNot(events[0].dict, events[1].dict)
|
|
else:
|
|
for ev in events:
|
|
self.assertEqual(ev.type, event.type)
|
|
self.assertIs(ev.dict, event.dict)
|
|
pygame.quit()
|
|
|
|
def test_delay(self):
|
|
"""Tests time.delay() function."""
|
|
millis = 50 # millisecond to wait on each iteration
|
|
iterations = 20 # number of iterations
|
|
delta = 150 # Represents acceptable margin of error for wait in ms
|
|
# Call checking function
|
|
self._wait_delay_check(pygame.time.delay, millis, iterations, delta)
|
|
# After timing behaviour, check argument type exceptions
|
|
self._type_error_checks(pygame.time.delay)
|
|
|
|
def test_get_ticks(self):
|
|
"""Tests time.get_ticks()"""
|
|
"""
|
|
Iterates and delays for arbitrary amount of time for each iteration,
|
|
check get_ticks to equal correct gap time
|
|
"""
|
|
iterations = 20
|
|
millis = 50
|
|
delta = 15 # Acceptable margin of error in ms
|
|
# Assert return type to be int
|
|
self.assertTrue(type(pygame.time.get_ticks()) == int)
|
|
for i in range(iterations):
|
|
curr_ticks = pygame.time.get_ticks() # Save current tick count
|
|
curr_time = time.time() # Save current time
|
|
pygame.time.delay(millis) # Delay for millis
|
|
# Time and Ticks difference from start of the iteration
|
|
time_diff = round((time.time() - curr_time) * 1000)
|
|
ticks_diff = pygame.time.get_ticks() - curr_ticks
|
|
# Assert almost equality of the ticking time and time difference
|
|
self.assertAlmostEqual(ticks_diff, time_diff, delta=delta)
|
|
|
|
def test_set_timer(self):
|
|
"""Tests time.set_timer()"""
|
|
"""
|
|
Tests if a timer will post the correct amount of eventid events in
|
|
the specified delay. Test is posting event objects work.
|
|
Also tests if setting milliseconds to 0 stops the timer and if
|
|
the once argument and repeat arguments work.
|
|
"""
|
|
pygame.init()
|
|
TIMER_EVENT_TYPE = pygame.event.custom_type()
|
|
timer_event = pygame.event.Event(TIMER_EVENT_TYPE)
|
|
delta = 50
|
|
timer_delay = 100
|
|
test_number = 8 # Number of events to read for the test
|
|
events = 0 # Events read
|
|
|
|
pygame.event.clear()
|
|
pygame.time.set_timer(TIMER_EVENT_TYPE, timer_delay)
|
|
|
|
# Test that 'test_number' events are posted in the right amount of time
|
|
t1 = pygame.time.get_ticks()
|
|
max_test_time = t1 + timer_delay * test_number + delta
|
|
while events < test_number:
|
|
for event in pygame.event.get():
|
|
if event == timer_event:
|
|
events += 1
|
|
|
|
# The test takes too much time
|
|
if pygame.time.get_ticks() > max_test_time:
|
|
break
|
|
|
|
pygame.time.set_timer(TIMER_EVENT_TYPE, 0)
|
|
t2 = pygame.time.get_ticks()
|
|
# Is the number ef events and the timing right?
|
|
self.assertEqual(events, test_number)
|
|
self.assertAlmostEqual(timer_delay * test_number, t2 - t1, delta=delta)
|
|
|
|
# Test that the timer stopped when set with 0ms delay.
|
|
pygame.time.delay(200)
|
|
self.assertNotIn(timer_event, pygame.event.get())
|
|
|
|
# Test that the old timer for an event is deleted when a new timer is set
|
|
pygame.time.set_timer(TIMER_EVENT_TYPE, timer_delay)
|
|
pygame.time.delay(int(timer_delay * 3.5))
|
|
self.assertEqual(pygame.event.get().count(timer_event), 3)
|
|
pygame.time.set_timer(TIMER_EVENT_TYPE, timer_delay * 10) # long wait time
|
|
pygame.time.delay(timer_delay * 5)
|
|
self.assertNotIn(timer_event, pygame.event.get())
|
|
pygame.time.set_timer(TIMER_EVENT_TYPE, timer_delay * 3)
|
|
pygame.time.delay(timer_delay * 7)
|
|
self.assertEqual(pygame.event.get().count(timer_event), 2)
|
|
pygame.time.set_timer(TIMER_EVENT_TYPE, timer_delay)
|
|
pygame.time.delay(int(timer_delay * 5.5))
|
|
self.assertEqual(pygame.event.get().count(timer_event), 5)
|
|
|
|
# Test that the loops=True works
|
|
pygame.time.set_timer(TIMER_EVENT_TYPE, 10, True)
|
|
pygame.time.delay(40)
|
|
self.assertEqual(pygame.event.get().count(timer_event), 1)
|
|
|
|
# Test a variety of event objects, test loops argument
|
|
events_to_test = [
|
|
pygame.event.Event(TIMER_EVENT_TYPE),
|
|
pygame.event.Event(
|
|
TIMER_EVENT_TYPE, foo="9gwz5", baz=12, lol=[124, (34, "")]
|
|
),
|
|
pygame.event.Event(pygame.KEYDOWN, key=pygame.K_a, unicode="a"),
|
|
]
|
|
repeat = 3
|
|
millis = 50
|
|
for e in events_to_test:
|
|
pygame.time.set_timer(e, millis, loops=repeat)
|
|
pygame.time.delay(2 * millis * repeat)
|
|
self.assertEqual(pygame.event.get().count(e), repeat)
|
|
pygame.quit()
|
|
|
|
def test_wait(self):
|
|
"""Tests time.wait() function."""
|
|
millis = 100 # millisecond to wait on each iteration
|
|
iterations = 10 # number of iterations
|
|
delta = 50 # Represents acceptable margin of error for wait in ms
|
|
# Call checking function
|
|
self._wait_delay_check(pygame.time.wait, millis, iterations, delta)
|
|
# After timing behaviour, check argument type exceptions
|
|
self._type_error_checks(pygame.time.wait)
|
|
|
|
def _wait_delay_check(self, func_to_check, millis, iterations, delta):
|
|
"""
|
|
call func_to_check(millis) "iterations" times and check each time if
|
|
function "waited" for given millisecond (+- delta). At the end, take
|
|
average time for each call (whole_duration/iterations), which should
|
|
be equal to millis (+- delta - acceptable margin of error).
|
|
*Created to avoid code duplication during delay and wait tests
|
|
"""
|
|
# take starting time for duration calculation
|
|
start_time = time.time()
|
|
for i in range(iterations):
|
|
wait_time = func_to_check(millis)
|
|
# Check equality of wait_time and millis with margin of error delta
|
|
self.assertAlmostEqual(wait_time, millis, delta=delta)
|
|
stop_time = time.time()
|
|
# Cycle duration in millisecond
|
|
duration = round((stop_time - start_time) * 1000)
|
|
# Duration/Iterations should be (almost) equal to predefined millis
|
|
self.assertAlmostEqual(duration / iterations, millis, delta=delta)
|
|
|
|
def _type_error_checks(self, func_to_check):
|
|
"""Checks 3 TypeError (float, tuple, string) for the func_to_check"""
|
|
"""Intended for time.delay and time.wait functions"""
|
|
# Those methods throw no exceptions on negative integers
|
|
self.assertRaises(TypeError, func_to_check, 0.1) # check float
|
|
self.assertRaises(TypeError, pygame.time.delay, (0, 1)) # check tuple
|
|
self.assertRaises(TypeError, pygame.time.delay, "10") # check string
|
|
|
|
|
|
###############################################################################
|
|
|
|
if __name__ == "__main__":
|
|
unittest.main()
|