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()