Files
2026-11-04 21:01:26 +01:00

462 lines
15 KiB
Python

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"<Window(title='{win.title}', id={win.id})>")
win.destroy()
self.assertEqual(repr(win), "<Window(Destroyed)>")
pygame.display.set_mode((640, 480))
win = Window.from_display_module()
self.assertEqual(repr(win), "<Window(From Display)>")
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()