import os import platform import unittest import pygame from pygame import Window from pygame.version import SDL pygame.init() IS_PYPY = "PyPy" == platform.python_implementation() pygame.display.init() is_wayland = pygame.display.get_driver() == "wayland" pygame.display.quit() class WindowTypeTest(unittest.TestCase): DEFAULT_TITLE = "pygame window" def setUp(self): self.win = Window() # Used to check the presence and set-ability of boolean attributes without # testing the results of the actions, since the results are not propagated # by the NULL videodriver on CI for some things. def bool_attr_test(self, attr): setattr(self.win, attr, True) setattr(self.win, attr, False) setattr(self.win, attr, "a truthy string") setattr(self.win, attr, "") setattr(self.win, attr, 17) self.assertIsInstance(getattr(self.win, attr), bool) def test_grab_mouse_keyboard(self): self.bool_attr_test("grab_mouse") self.bool_attr_test("grab_keyboard") self.win.grab_mouse = True self.assertTrue(self.win.grab_mouse) self.win.grab_mouse = False self.assertFalse(self.win.grab_mouse) self.win.grab_keyboard = True self.assertTrue(self.win.grab_keyboard) self.win.grab_keyboard = False self.assertFalse(self.win.grab_keyboard) def test_mouse_keyboard_grabbed(self): self.assertIsInstance(getattr(self.win, "mouse_grabbed"), bool) self.assertIsInstance(getattr(self.win, "keyboard_grabbed"), bool) self.assertRaises( AttributeError, lambda: setattr(self.win, "mouse_grabbed", False) ) self.assertRaises( AttributeError, lambda: setattr(self.win, "keyboard_grabbed", False) ) def test_title(self): self.assertEqual(self.win.title, self.DEFAULT_TITLE) title = "Hello_World你好世界こにじわ" self.win.title = title self.assertEqual(self.win.title, title) def test_resizable(self): self.bool_attr_test("resizable") @unittest.skipIf( os.environ.get("SDL_VIDEODRIVER") == pygame.NULL_VIDEODRIVER, "requires the SDL_VIDEODRIVER to be a non-null value", ) def test_resizable_set(self): self.win.resizable = True self.assertTrue(self.win.resizable) self.win.resizable = False self.assertFalse(self.win.resizable) def test_borderless(self): self.bool_attr_test("borderless") @unittest.skipIf( os.environ.get("SDL_VIDEODRIVER") == pygame.NULL_VIDEODRIVER, "requires the SDL_VIDEODRIVER to be a non-null value", ) def test_borderless_set(self): self.win.borderless = True self.assertTrue(self.win.borderless) self.win.borderless = False self.assertFalse(self.win.borderless) def test_always_on_top(self): self.bool_attr_test("always_on_top") @unittest.skipIf( os.environ.get("SDL_VIDEODRIVER") == pygame.NULL_VIDEODRIVER, "requires the SDL_VIDEODRIVER to be a non-null value", ) @unittest.skipIf(is_wayland, "not supported on wayland") def test_always_on_top_set(self): self.win.always_on_top = True self.assertTrue(self.win.always_on_top) self.win.always_on_top = False self.assertFalse(self.win.always_on_top) @unittest.skipIf( os.environ.get("SDL_VIDEODRIVER") == pygame.NULL_VIDEODRIVER, "requires SDL_VIDEODRIVER to be a non-null value", ) def test_mouse_rect(self): self.win.mouse_rect = None self.assertIsNone(self.win.mouse_rect) TEST_MOUSE_RECT = (10, 10, 123, 456) self.win.mouse_rect = TEST_MOUSE_RECT self.assertIsInstance(self.win.mouse_rect, pygame.Rect) self.assertTupleEqual(tuple(self.win.mouse_rect), TEST_MOUSE_RECT) self.assertRaises( TypeError, lambda: setattr(self.win, "mouse_rect", "Incorrect type") ) # clean the status self.win.mouse_rect = None def test_size(self): self.win.size = (1280, 720) self.assertTupleEqual(self.win.size, (1280, 720)) self.assertRaises(ValueError, lambda: setattr(self.win, "size", (-1, 10))) self.assertRaises(ValueError, lambda: setattr(self.win, "size", (1, -10))) self.assertRaises(ValueError, lambda: setattr(self.win, "size", (-1, -10))) self.assertRaises(ValueError, lambda: setattr(self.win, "size", (0, 0))) # test set size when init # On Windows, if SDL <= 2.0.22, this test fails # This bug have been fixed in SDL 2.24.0 if SDL > (2, 0, 22): win = Window(size=(12, 34)) self.assertTupleEqual((12, 34), win.size) win.destroy() self.assertRaises(ValueError, lambda: Window(size=(-1, 0))) self.win.size = (640, 480) @unittest.skipIf(is_wayland, "not supported on wayland") def test_position(self): new_pos = (self.win.position[0] + 20, self.win.position[1] + 10) self.win.position = new_pos self.assertTupleEqual(self.win.position, new_pos) self.win.position = pygame.WINDOWPOS_CENTERED # raise TypeError if input is some random number instead of flag self.assertRaises(TypeError, lambda: setattr(self.win, "position", 123)) # test set position when init win = Window(position=new_pos) self.assertTupleEqual(new_pos, win.position) win.destroy() self.assertRaises(TypeError, lambda: Window(position=123)) def test_maximum_size(self): # Use a new window to prevent being influenced by other tests self.win = Window() self.win.maximum_size = (50, 50) self.assertTupleEqual(self.win.maximum_size, (50, 50)) # size should be limited to the maximum_size self.assertTupleEqual(self.win.size, (50, 50)) self.win.size = (640, 480) # size should not larger than maximum_size self.assertTupleEqual(self.win.size, (50, 50)) if SDL.major >= 3: # This part should pass in SDL3 self.win.maximum_size = (0, 0) # remove the size limit self.win.size = (640, 480) self.assertTupleEqual(self.win.size, (640, 480)) self.assertRaises( ValueError, lambda: setattr(self.win, "maximum_size", (-1, -1)) ) self.assertRaises( TypeError, lambda: setattr(self.win, "maximum_size", "placeholder_str") ) def test_minimum_size(self): # Use a new window to prevent being influenced by other tests self.win = Window() self.win.minimum_size = (700, 700) self.assertTupleEqual(self.win.minimum_size, (700, 700)) # size should be limited to the minimum_size self.assertTupleEqual(self.win.size, (700, 700)) self.win.size = (640, 480) # size should not small than minimum_size self.assertTupleEqual(self.win.size, (700, 700)) if SDL.major >= 3: # This part should pass in SDL3 self.win.minimum_size = (0, 0) # remove the size limit self.win.size = (640, 480) self.assertTupleEqual(self.win.size, (640, 480)) self.assertRaises( ValueError, lambda: setattr(self.win, "minimum_size", (-1, -1)) ) self.assertRaises( TypeError, lambda: setattr(self.win, "minimum_size", "null_str") ) def test_min_size_interact_with_max_size(self): # Use a new window to prevent being influenced by other tests self.win = Window() self.win.maximum_size = (100, 100) # min size should not larger than max size self.assertRaises( ValueError, lambda: setattr(self.win, "minimum_size", (200, 200)) ) self.win.minimum_size = (90, 90) # max size should not smaller than min size self.assertRaises( ValueError, lambda: setattr(self.win, "maximum_size", (50, 50)) ) # minimum size should be able to equal to maximum size self.win.minimum_size = (60, 60) self.win.maximum_size = (60, 60) self.assertTupleEqual(self.win.maximum_size, (60, 60)) self.assertTupleEqual(self.win.minimum_size, (60, 60)) def test_opacity(self): # Setting is not supported at all with SDL_VIDEODRIVER = pygame.NULL_VIDEODRIVER, # all we can test here is that the attribute exists and is a # float self.assertIsInstance(self.win.opacity, float) @unittest.skipIf( os.environ.get("SDL_VIDEODRIVER") == pygame.NULL_VIDEODRIVER, "requires the SDL_VIDEODRIVER to be a non-null value", ) @unittest.skipIf(is_wayland, "not supported on wayland") def test_opacity_set(self): self.win.opacity = 0.5 self.assertEqual(self.win.opacity, 0.5) self.win.opacity = 0 self.assertEqual(self.win.opacity, 0) self.win.opacity = 1 self.assertEqual(self.win.opacity, 1) self.win.opacity = -0.1 self.assertEqual(self.win.opacity, 0) self.win.opacity = 1.1 self.assertEqual(self.win.opacity, 1) self.assertRaises(TypeError, lambda: setattr(self.win, "opacity", "null str")) def test_init_flags(self): # test no opengl by default win = Window() self.assertFalse(win.opengl) win.destroy() # test borderless win = Window(borderless=True) self.assertTrue(win.borderless) win.destroy() # test always_on_top win = Window(always_on_top=True) self.assertTrue(win.always_on_top) win.destroy() # test resizable win = Window(resizable=True) self.assertTrue(win.resizable) win.destroy() # test utility win = Window(utility=True) self.assertTrue(win.utility) win.destroy() # should raise a TypeError if keyword is random self.assertRaises(TypeError, lambda: Window(aaa=True)) self.assertRaises(TypeError, lambda: Window(aaa=False)) def test_set_icon(self): self.assertRaises(TypeError, lambda: self.win.set_icon(1234)) test_icon = pygame.Surface((32, 32)) test_icon.fill((255, 0, 0)) return_value = self.win.set_icon(test_icon) self.assertIsNone(return_value) def test_window_object_repr(self): win = Window("awa") self.assertEqual(repr(win), f"") win.destroy() self.assertEqual(repr(win), "") pygame.display.set_mode((640, 480)) win = Window.from_display_module() self.assertEqual(repr(win), "") pygame.display.quit() pygame.init() def test_from_display_module(self): surf = pygame.display.set_mode((640, 480)) win1 = Window.from_display_module() win2 = Window.from_display_module() self.assertIs(win1, win2) self.assertIs(win1.get_surface(), surf) pygame.display.quit() pygame.init() @unittest.skipIf(IS_PYPY, "for some reason this test is flaky on pypy") def test_window_surface(self): win = Window(size=(640, 480)) surf = win.get_surface() self.assertIsInstance(surf, pygame.Surface) # test auto resize self.assertTupleEqual(win.size, surf.get_size()) win.size = (100, 100) self.assertTupleEqual(win.size, surf.get_size()) win.size = (1280, 720) self.assertTupleEqual(win.size, surf.get_size()) # window surface should be invalid after the window is destroyed win.destroy() self.assertRaises(pygame.error, lambda: surf.fill((0, 0, 0))) @unittest.skipIf(IS_PYPY, "for some reason this test is flaky on pypy") def test_window_surface_with_display_module(self): # get_surface() should raise an error if the set_mode() is not called. pygame.display.set_mode((640, 480)) win1 = Window.from_display_module() pygame.display.quit() pygame.init() self.assertRaises(pygame.error, lambda: win1.get_surface()) # the surface returned by get_surface() should be # the surface returned by set_mode() surf1 = pygame.display.set_mode((640, 480)) win2 = Window.from_display_module() surf2 = win2.get_surface() self.assertIs(surf1, surf2) def test_window_flip(self): win = Window(size=(640, 480)) surf = win.get_surface() surf.fill((255, 0, 0)) self.assertRaises(TypeError, lambda: win.flip("an argument")) self.assertIs(win.flip(), None) win.destroy() # creates a new window with no surface associated win = Window(size=(640, 480)) self.assertRaisesRegex( pygame.error, "the Window has no surface associated with it, did you forget to call Window.get_surface()", win.flip, ) win.destroy() @unittest.skipIf( os.environ.get("SDL_VIDEODRIVER") == pygame.NULL_VIDEODRIVER, "OpenGL requires a non-null SDL_VIDEODRIVER", ) def test_window_opengl(self): win1 = Window(opengl=True) self.assertTrue(win1.opengl) win1.flip() win1.destroy() win2 = Window(opengl=False) self.assertFalse(win2.opengl) win2.get_surface() win2.flip() win2.destroy() pygame.display.set_mode((640, 480), pygame.OPENGL) win = Window.from_display_module() self.assertTrue(win.opengl) pygame.display.quit() pygame.init() @unittest.skipIf(IS_PYPY, "for some reason this test is flaky on pypy") def test_window_subclassable(self): class WindowSubclass(Window): def __init__(self, title="Different title", size=(640, 480), **flags): super().__init__(title, size, pygame.WINDOWPOS_CENTERED, **flags) self.attribute = 10 window = WindowSubclass() self.assertTrue(issubclass(WindowSubclass, Window)) self.assertIsInstance(window, WindowSubclass) self.assertEqual(window.title, "Different title") self.assertEqual(window.attribute, 10) window.destroy() pygame.display.set_mode((200, 200)) window = WindowSubclass.from_display_module() self.assertIsInstance(window, WindowSubclass) self.assertEqual(window.size, (200, 200)) def test_window_flash(self): window = pygame.Window() with self.assertRaises(TypeError): window.flash("string") window.flash(2.2) window.flash([0]) with self.assertRaises(ValueError): window.flash(-1) window.flash(3) for operation in [ pygame.FLASH_CANCEL, pygame.FLASH_BRIEFLY, pygame.FLASH_UNTIL_FOCUSED, ]: try: result = window.flash(operation) self.assertIsNone(result) except pygame.error: pass def test_window_focused(self): window = pygame.Window() self.assertIsInstance(window.focused, bool) def test_handle(self): window = pygame.Window() self.assertIsInstance(window.handle, int) def tearDown(self): self.win.destroy() if __name__ == "__main__": unittest.main()