This commit is contained in:
wittmannzl103469 committed 2026-11-05 15:08:42 +01:00
1 parent de41a02749
commit 9af09cebd3
764 files changed
+54218 -78859

No files matched your search

@@ -1,16 +1,13 @@
import unittest
import os
import sys
import time
import unittest
import pygame
import pygame.transform
from pygame import display
import pygame, pygame.transform
from pygame.tests.test_utils import question
pygame.display.init()
is_wayland = pygame.display.get_driver() == "wayland"
pygame.display.quit()
from pygame import display
class DisplayModuleTest(unittest.TestCase):
@@ -72,10 +69,9 @@ class DisplayModuleTest(unittest.TestCase):
self.assertEqual(pygame.display.get_active(), False)
@unittest.skipIf(
os.environ.get("SDL_VIDEODRIVER") == pygame.NULL_VIDEODRIVER,
"requires the SDL_VIDEODRIVER to be a non-null value",
os.environ.get("SDL_VIDEODRIVER") == "dummy",
"requires the SDL_VIDEODRIVER to be a non dummy value",
)
@unittest.skipIf(is_wayland, "broken on wayland")
def test_get_active_iconify(self):
"""Test the get_active function after an iconify"""
@@ -105,6 +101,14 @@ class DisplayModuleTest(unittest.TestCase):
self.assertEqual(display.get_caption()[0], TEST_CAPTION)
self.assertEqual(display.get_caption()[1], TEST_CAPTION)
def test_set_caption_kwargs(self):
TEST_CAPTION = "test"
screen = display.set_mode((100, 100))
self.assertIsNone(display.set_caption(title=TEST_CAPTION))
self.assertEqual(display.get_caption()[0], TEST_CAPTION)
self.assertEqual(display.get_caption()[1], TEST_CAPTION)
def test_caption_unicode(self):
TEST_CAPTION = "台"
display.set_caption(TEST_CAPTION)
@@ -119,7 +123,7 @@ class DisplayModuleTest(unittest.TestCase):
"dga",
"directx",
"directfb",
pygame.NULL_VIDEODRIVER,
"dummy",
"emscripten",
"fbcon",
"ggi",
@@ -154,31 +158,22 @@ class DisplayModuleTest(unittest.TestCase):
# display.init() already called in setUp()
self.assertTrue(display.get_init())
# This test can be uncommented when issues #991 and #993 are resolved.
@unittest.skipIf(True, "SDL2 issues")
def test_get_surface(self):
"""Ensures get_surface gets the current display surface.
We can't guarantee small screen sizes get respected, so the
sizes of the surfaces returned from set_mode must be compared
to the size of the surface from get_surface.
"""
"""Ensures get_surface gets the current display surface."""
lengths = (1, 5, 100)
correct_depth = pygame.display.Info().bitsize
for expected_size in ((w, h) for w in lengths for h in lengths):
for set_depth in (8, 16, 24, 32):
if set_depth == correct_depth:
expected_surface = display.set_mode(expected_size, 0, set_depth)
else:
with self.assertWarns(DeprecationWarning):
expected_surface = pygame.display.set_mode(
expected_size, 0, set_depth
)
for expected_depth in (8, 16, 24, 32):
expected_surface = display.set_mode(expected_size, 0, expected_depth)
surface = pygame.display.get_surface()
self.assertEqual(surface, expected_surface)
self.assertIsInstance(surface, pygame.Surface)
self.assertEqual(surface.get_size(), expected_surface.get_size())
self.assertEqual(surface.get_bitsize(), correct_depth)
self.assertEqual(surface.get_size(), expected_size)
self.assertEqual(surface.get_bitsize(), expected_depth)
def test_get_surface__mode_not_set(self):
"""Ensures get_surface handles the display mode not being set."""
@@ -224,9 +219,9 @@ class DisplayModuleTest(unittest.TestCase):
@unittest.skipIf(
(
"skipping for all because some failures on rasppi and maybe other platforms"
or os.environ.get("SDL_VIDEODRIVER") == pygame.NULL_VIDEODRIVER
or os.environ.get("SDL_VIDEODRIVER") == "dummy"
),
"OpenGL requires a non-null SDL_VIDEODRIVER",
'OpenGL requires a non-"dummy" SDL_VIDEODRIVER',
)
def test_gl_get_attribute(self):
screen = display.set_mode((0, 0), pygame.OPENGL)
@@ -348,9 +343,159 @@ class DisplayModuleTest(unittest.TestCase):
@unittest.skipIf(
(
"skipping for all because some failures on rasppi and maybe other platforms"
or os.environ.get("SDL_VIDEODRIVER") == pygame.NULL_VIDEODRIVER
or os.environ.get("SDL_VIDEODRIVER") == "dummy"
),
"OpenGL requires a non-null SDL_VIDEODRIVER",
'OpenGL requires a non-"dummy" SDL_VIDEODRIVER',
)
def test_gl_get_attribute_kwargs(self):
screen = display.set_mode((0, 0), pygame.OPENGL)
# We create a list where we store the original values of the
# flags before setting them with a different value.
original_values = []
original_values.append(
pygame.display.gl_get_attribute(flag=pygame.GL_ALPHA_SIZE)
)
original_values.append(
pygame.display.gl_get_attribute(flag=pygame.GL_DEPTH_SIZE)
)
original_values.append(
pygame.display.gl_get_attribute(flag=pygame.GL_STENCIL_SIZE)
)
original_values.append(
pygame.display.gl_get_attribute(flag=pygame.GL_ACCUM_RED_SIZE)
)
original_values.append(
pygame.display.gl_get_attribute(flag=pygame.GL_ACCUM_GREEN_SIZE)
)
original_values.append(
pygame.display.gl_get_attribute(flag=pygame.GL_ACCUM_BLUE_SIZE)
)
original_values.append(
pygame.display.gl_get_attribute(flag=pygame.GL_ACCUM_ALPHA_SIZE)
)
original_values.append(
pygame.display.gl_get_attribute(flag=pygame.GL_MULTISAMPLEBUFFERS)
)
original_values.append(
pygame.display.gl_get_attribute(flag=pygame.GL_MULTISAMPLESAMPLES)
)
original_values.append(pygame.display.gl_get_attribute(flag=pygame.GL_STEREO))
original_values.append(
pygame.display.gl_get_attribute(flag=pygame.GL_ACCELERATED_VISUAL)
)
original_values.append(
pygame.display.gl_get_attribute(flag=pygame.GL_CONTEXT_MAJOR_VERSION)
)
original_values.append(
pygame.display.gl_get_attribute(flag=pygame.GL_CONTEXT_MINOR_VERSION)
)
original_values.append(
pygame.display.gl_get_attribute(flag=pygame.GL_CONTEXT_FLAGS)
)
original_values.append(
pygame.display.gl_get_attribute(flag=pygame.GL_CONTEXT_PROFILE_MASK)
)
original_values.append(
pygame.display.gl_get_attribute(flag=pygame.GL_SHARE_WITH_CURRENT_CONTEXT)
)
original_values.append(
pygame.display.gl_get_attribute(flag=pygame.GL_FRAMEBUFFER_SRGB_CAPABLE)
)
# Setting the flags with values supposedly different from the original values
# assign SDL1-supported values with gl_set_attribute
pygame.display.gl_set_attribute(flag=pygame.GL_ALPHA_SIZE, value=8)
pygame.display.gl_set_attribute(flag=pygame.GL_DEPTH_SIZE, value=24)
pygame.display.gl_set_attribute(flag=pygame.GL_STENCIL_SIZE, value=8)
pygame.display.gl_set_attribute(flag=pygame.GL_ACCUM_RED_SIZE, value=16)
pygame.display.gl_set_attribute(flag=pygame.GL_ACCUM_GREEN_SIZE, value=16)
pygame.display.gl_set_attribute(flag=pygame.GL_ACCUM_BLUE_SIZE, value=16)
pygame.display.gl_set_attribute(flag=pygame.GL_ACCUM_ALPHA_SIZE, value=16)
pygame.display.gl_set_attribute(flag=pygame.GL_MULTISAMPLEBUFFERS, value=1)
pygame.display.gl_set_attribute(flag=pygame.GL_MULTISAMPLESAMPLES, value=1)
pygame.display.gl_set_attribute(flag=pygame.GL_STEREO, value=0)
pygame.display.gl_set_attribute(flag=pygame.GL_ACCELERATED_VISUAL, value=0)
pygame.display.gl_set_attribute(flag=pygame.GL_CONTEXT_MAJOR_VERSION, value=1)
pygame.display.gl_set_attribute(flag=pygame.GL_CONTEXT_MINOR_VERSION, value=1)
pygame.display.gl_set_attribute(flag=pygame.GL_CONTEXT_FLAGS, value=0)
pygame.display.gl_set_attribute(flag=pygame.GL_CONTEXT_PROFILE_MASK, value=0)
pygame.display.gl_set_attribute(
flag=pygame.GL_SHARE_WITH_CURRENT_CONTEXT, value=0
)
pygame.display.gl_set_attribute(
flag=pygame.GL_FRAMEBUFFER_SRGB_CAPABLE, value=0
)
# We create a list where we store the values that we set each flag to
set_values = [8, 24, 8, 16, 16, 16, 16, 1, 1, 0, 0, 1, 1, 0, 0, 0, 1, 0]
# We create a list where we store the values after getting them
get_values = []
get_values.append(pygame.display.gl_get_attribute(flag=pygame.GL_ALPHA_SIZE))
get_values.append(pygame.display.gl_get_attribute(flag=pygame.GL_DEPTH_SIZE))
get_values.append(pygame.display.gl_get_attribute(flag=pygame.GL_STENCIL_SIZE))
get_values.append(
pygame.display.gl_get_attribute(flag=pygame.GL_ACCUM_RED_SIZE)
)
get_values.append(
pygame.display.gl_get_attribute(flag=pygame.GL_ACCUM_GREEN_SIZE)
)
get_values.append(
pygame.display.gl_get_attribute(flag=pygame.GL_ACCUM_BLUE_SIZE)
)
get_values.append(
pygame.display.gl_get_attribute(flag=pygame.GL_ACCUM_ALPHA_SIZE)
)
get_values.append(
pygame.display.gl_get_attribute(flag=pygame.GL_MULTISAMPLEBUFFERS)
)
get_values.append(
pygame.display.gl_get_attribute(flag=pygame.GL_MULTISAMPLESAMPLES)
)
get_values.append(pygame.display.gl_get_attribute(flag=pygame.GL_STEREO))
get_values.append(
pygame.display.gl_get_attribute(flag=pygame.GL_ACCELERATED_VISUAL)
)
get_values.append(
pygame.display.gl_get_attribute(flag=pygame.GL_CONTEXT_MAJOR_VERSION)
)
get_values.append(
pygame.display.gl_get_attribute(flag=pygame.GL_CONTEXT_MINOR_VERSION)
)
get_values.append(pygame.display.gl_get_attribute(flag=pygame.GL_CONTEXT_FLAGS))
get_values.append(
pygame.display.gl_get_attribute(flag=pygame.GL_CONTEXT_PROFILE_MASK)
)
get_values.append(
pygame.display.gl_get_attribute(flag=pygame.GL_SHARE_WITH_CURRENT_CONTEXT)
)
get_values.append(
pygame.display.gl_get_attribute(flag=pygame.GL_FRAMEBUFFER_SRGB_CAPABLE)
)
# We check to see if the values that we get correspond to the values that we set
# them to or to the original values.
for i in range(len(original_values)):
self.assertTrue(
(get_values[i] == original_values[i])
or (get_values[i] == set_values[i])
)
# test using non-flag argument
with self.assertRaises(TypeError):
pygame.display.gl_get_attribute("DUMMY")
@unittest.skipIf(
(
"skipping for all because some failures on rasppi and maybe other platforms"
or os.environ.get("SDL_VIDEODRIVER") == "dummy"
),
'OpenGL requires a non-"dummy" SDL_VIDEODRIVER',
)
def test_gl_set_attribute(self):
# __doc__ (as of 2008-08-02) for pygame.display.gl_set_attribute:
@@ -413,10 +558,102 @@ class DisplayModuleTest(unittest.TestCase):
pygame.display.gl_get_attribute("DUMMY")
@unittest.skipIf(
os.environ.get("SDL_VIDEODRIVER") in [pygame.NULL_VIDEODRIVER, "android"],
(
"skipping for all because some failures on rasppi and maybe other platforms"
or os.environ.get("SDL_VIDEODRIVER") == "dummy"
),
'OpenGL requires a non-"dummy" SDL_VIDEODRIVER',
)
def test_gl_set_attribute_kwargs(self):
# __doc__ (as of 2008-08-02) for pygame.display.gl_set_attribute:
# pygame.display.gl_set_attribute(flag, value): return None
# request an opengl display attribute for the display mode
#
# When calling pygame.display.set_mode() with the pygame.OPENGL flag,
# Pygame automatically handles setting the OpenGL attributes like
# color and doublebuffering. OpenGL offers several other attributes
# you may want control over. Pass one of these attributes as the flag,
# and its appropriate value. This must be called before
# pygame.display.set_mode()
#
# The OPENGL flags are;
# GL_ALPHA_SIZE, GL_DEPTH_SIZE, GL_STENCIL_SIZE, GL_ACCUM_RED_SIZE,
# GL_ACCUM_GREEN_SIZE, GL_ACCUM_BLUE_SIZE, GL_ACCUM_ALPHA_SIZE,
# GL_MULTISAMPLEBUFFERS, GL_MULTISAMPLESAMPLES, GL_STEREO
screen = display.set_mode((0, 0), pygame.OPENGL)
# We create a list where we store the values that we set each flag to
set_values = [8, 24, 8, 16, 16, 16, 16, 1, 1, 0]
# Setting the flags with values supposedly different from the original values
# assign SDL1-supported values with gl_set_attribute
pygame.display.gl_set_attribute(flag=pygame.GL_ALPHA_SIZE, value=set_values[0])
pygame.display.gl_set_attribute(flag=pygame.GL_DEPTH_SIZE, value=set_values[1])
pygame.display.gl_set_attribute(
flag=pygame.GL_STENCIL_SIZE, value=set_values[2]
)
pygame.display.gl_set_attribute(
flag=pygame.GL_ACCUM_RED_SIZE, value=set_values[3]
)
pygame.display.gl_set_attribute(
flag=pygame.GL_ACCUM_GREEN_SIZE, value=set_values[4]
)
pygame.display.gl_set_attribute(
flag=pygame.GL_ACCUM_BLUE_SIZE, value=set_values[5]
)
pygame.display.gl_set_attribute(
flag=pygame.GL_ACCUM_ALPHA_SIZE, value=set_values[6]
)
pygame.display.gl_set_attribute(
flag=pygame.GL_MULTISAMPLEBUFFERS, value=set_values[7]
)
pygame.display.gl_set_attribute(
flag=pygame.GL_MULTISAMPLESAMPLES, value=set_values[8]
)
pygame.display.gl_set_attribute(flag=pygame.GL_STEREO, value=set_values[9])
# We create a list where we store the values after getting them
get_values = []
get_values.append(pygame.display.gl_get_attribute(flag=pygame.GL_ALPHA_SIZE))
get_values.append(pygame.display.gl_get_attribute(flag=pygame.GL_DEPTH_SIZE))
get_values.append(pygame.display.gl_get_attribute(flag=pygame.GL_STENCIL_SIZE))
get_values.append(
pygame.display.gl_get_attribute(flag=pygame.GL_ACCUM_RED_SIZE)
)
get_values.append(
pygame.display.gl_get_attribute(flag=pygame.GL_ACCUM_GREEN_SIZE)
)
get_values.append(
pygame.display.gl_get_attribute(flag=pygame.GL_ACCUM_BLUE_SIZE)
)
get_values.append(
pygame.display.gl_get_attribute(flag=pygame.GL_ACCUM_ALPHA_SIZE)
)
get_values.append(
pygame.display.gl_get_attribute(flag=pygame.GL_MULTISAMPLEBUFFERS)
)
get_values.append(
pygame.display.gl_get_attribute(flag=pygame.GL_MULTISAMPLESAMPLES)
)
get_values.append(pygame.display.gl_get_attribute(flag=pygame.GL_STEREO))
# We check to see if the values that we get correspond to the values that we set
# them to or to the original values.
for i in range(len(set_values)):
self.assertTrue(get_values[i] == set_values[i])
# test using non-flag argument
with self.assertRaises(TypeError):
pygame.display.gl_get_attribute("DUMMY")
@unittest.skipIf(
os.environ.get("SDL_VIDEODRIVER") in ["dummy", "android"],
"iconify is only supported on some video drivers/platforms",
)
@unittest.skipIf(is_wayland, "broken on wayland")
def test_iconify(self):
pygame.display.set_mode((640, 480))
@@ -518,14 +755,8 @@ class DisplayModuleTest(unittest.TestCase):
self.assertFalse(display.get_init())
@unittest.skipIf(
os.environ.get("SDL_VIDEODRIVER") == pygame.NULL_VIDEODRIVER,
"Needs a non-null videodriver",
os.environ.get("SDL_VIDEODRIVER") == "dummy", "Needs a not dummy videodriver"
)
@unittest.skipIf(
pygame.version.SDL >= (2, 32, 50),
"set_gamma is removed in SDL3, does not work in sdl2-compat either",
)
@unittest.skipIf(is_wayland, "not supported on wayland")
def test_set_gamma(self):
pygame.display.set_mode((1, 1))
@@ -537,14 +768,8 @@ class DisplayModuleTest(unittest.TestCase):
self.assertEqual(pygame.display.set_gamma(gamma), True)
@unittest.skipIf(
os.environ.get("SDL_VIDEODRIVER") == pygame.NULL_VIDEODRIVER,
"Needs a non-null videodriver",
os.environ.get("SDL_VIDEODRIVER") == "dummy", "Needs a not dummy videodriver"
)
@unittest.skipIf(
pygame.version.SDL >= (2, 32, 50),
"set_gamma is removed in SDL3, does not work in sdl2-compat either",
)
@unittest.skipIf(is_wayland, "not supported on wayland")
def test_set_gamma__tuple(self):
pygame.display.set_mode((1, 1))
@@ -554,8 +779,8 @@ class DisplayModuleTest(unittest.TestCase):
self.assertEqual(pygame.display.set_gamma(r, g, b), True)
@unittest.skipIf(
pygame.version.SDL >= (2, 32, 50),
"set_gamma_ramp is removed in SDL3, does not work in sdl2-compat either",
not hasattr(pygame.display, "set_gamma_ramp"),
"Not all systems and hardware support gamma ramps",
)
def test_set_gamma_ramp(self):
# __doc__ (as of 2008-08-02) for pygame.display.set_gamma_ramp:
@@ -608,7 +833,7 @@ class DisplayModuleTest(unittest.TestCase):
def test_set_mode_unscaled(self):
"""Ensures a window created with SCALED can become smaller."""
# see https://github.com/pygame-community/pygame-ce/issues/1194
# see https://github.com/pygame/pygame/issues/2327
screen = pygame.display.set_mode((300, 300), pygame.SCALED)
self.assertEqual(screen.get_size(), (300, 300))
@@ -653,11 +878,41 @@ class DisplayModuleTest(unittest.TestCase):
palette = [1, 2, 3]
pygame.display.set_palette(palette)
skip_list = [pygame.NULL_VIDEODRIVER, "android"]
skip_list = ["dummy", "android"]
@unittest.skipIf(True, "set_palette() not supported in SDL2")
def test_set_palette_kwargs(self):
with self.assertRaises(pygame.error):
palette = [1, 2, 3]
pygame.display.set_palette(palette=palette)
pygame.display.set_mode((1024, 768), 0, 8)
palette = []
self.assertIsNone(pygame.display.set_palette(palette=palette))
with self.assertRaises(ValueError):
palette = 12
pygame.display.set_palette(palette=palette)
with self.assertRaises(TypeError):
palette = [[1, 2], [1, 2]]
pygame.display.set_palette(palette=palette)
with self.assertRaises(TypeError):
palette = [[0, 0, 0, 0, 0]] + [[x, x, x, x, x] for x in range(1, 255)]
pygame.display.set_palette(palette=palette)
with self.assertRaises(TypeError):
palette = "qwerty"
pygame.display.set_palette(palette=palette)
with self.assertRaises(TypeError):
palette = [[123, 123, 123] * 10000]
pygame.display.set_palette(palette=palette)
with self.assertRaises(TypeError):
palette = [1, 2, 3]
pygame.display.set_palette(palette=palette)
skip_list = ["dummy", "android"]
@unittest.skipIf(
os.environ.get("SDL_VIDEODRIVER") in skip_list,
"requires the SDL_VIDEODRIVER to be non-null",
"requires the SDL_VIDEODRIVER to be non dummy",
)
def test_toggle_fullscreen(self):
"""Test for toggle fullscreen"""
@@ -698,14 +953,6 @@ class DisplayModuleTest(unittest.TestCase):
(test_surf.get_width(), test_surf.get_height()), width_height
)
@unittest.skipIf(is_wayland, "not supported on wayland")
def test_get_set_window_position(self):
pygame.display.set_mode((500, 500))
pygame.display.set_window_position((420, 360))
position = pygame.display.get_window_position()
self.assertEqual(position[0], 420)
self.assertEqual(position[1], 360)
class DisplayUpdateTest(unittest.TestCase):
def question(self, qstr):
@@ -734,9 +981,6 @@ class DisplayUpdateTest(unittest.TestCase):
r3 = pygame.Rect(-10, 0, -100, -100)
pygame.display.update(r3)
# random point in rect
self.assertEqual(self.screen.get_at((50, 50)), (0, 255, 0))
self.question("Is the screen green in (0, 0, 100, 100)?")
def test_update_sequence(self):
@@ -751,47 +995,6 @@ class DisplayUpdateTest(unittest.TestCase):
pygame.display.update(rects)
pygame.event.pump() # so mac updates
# random points in rect
for random_point in ((50, 50), (150, 50), (250, 50), (350, 350)):
self.assertEqual(self.screen.get_at(random_point), (0, 255, 0))
self.question(f"Is the screen green in {rects}?")
def test_update_dict_values(self):
"""only updates the part of the display given by the rects."""
self.screen.fill("green")
rects = {
"foo": pygame.Rect(0, 0, 100, 100),
"foobar": pygame.Rect(100, 0, 100, 100),
"hello": pygame.Rect(200, 0, 100, 100),
"hi": pygame.Rect(300, 300, 100, 100),
}
pygame.display.update(rects.values())
pygame.event.pump() # so mac updates
# random points in rect
for random_point in ((50, 50), (150, 50), (250, 50), (350, 350)):
self.assertEqual(self.screen.get_at(random_point), (0, 255, 0))
self.question(f"Is the screen green in {' '.join(map(str, rects.values()))}?")
def test_update_generator(self):
"""only updates the part of the display given by the rects."""
self.screen.fill("green")
rects = [
pygame.Rect(0, 0, 100, 100),
pygame.Rect(100, 0, 100, 100),
pygame.Rect(200, 0, 100, 100),
pygame.Rect(300, 300, 100, 100),
]
# make a generator from list, pass list with rect duplicates
pygame.display.update(i for i in (rects * 5))
pygame.event.pump() # so mac updates
# random points in rect
for random_point in ((50, 50), (150, 50), (250, 50), (350, 350)):
self.assertEqual(self.screen.get_at(random_point), (0, 255, 0))
self.question(f"Is the screen green in {rects}?")
def test_update_none_skipped(self):
@@ -807,10 +1010,6 @@ class DisplayUpdateTest(unittest.TestCase):
pygame.display.update(rects)
pygame.event.pump() # so mac updates
# random points in rect
for random_point in ((50, 50), (150, 50), (250, 50), (350, 350)):
self.assertEqual(self.screen.get_at(random_point), (0, 255, 0))
self.question(f"Is the screen green in {rects}?")
def test_update_none(self):
@@ -818,19 +1017,14 @@ class DisplayUpdateTest(unittest.TestCase):
self.screen.fill("green")
pygame.display.update(None)
pygame.event.pump() # so mac updates
self.question(f"Is the screen black and NOT green?")
self.question("Is the screen black and NOT green?")
def test_update_no_args(self):
"""does NOT update the display."""
self.screen.fill("green")
pygame.display.update()
pygame.event.pump() # so mac updates
# random points in rect
for random_point in ((50, 50), (150, 50), (250, 50), (350, 350)):
self.assertEqual(self.screen.get_at(random_point), (0, 255, 0))
self.question(f"Is the WHOLE screen green?")
self.question("Is the WHOLE screen green?")
def test_update_args(self):
"""updates the display using the args as a rect."""
@@ -839,9 +1033,6 @@ class DisplayUpdateTest(unittest.TestCase):
pygame.event.pump() # so mac updates
self.question("Is the screen green in (100, 100, 100, 100)?")
# random points in rect
self.assertEqual(self.screen.get_at((150, 150)), (0, 255, 0))
def test_update_incorrect_args(self):
"""raises a ValueError when inputs are wrong."""
@@ -889,10 +1080,6 @@ class DisplayInteractiveTest(unittest.TestCase):
self.assertTrue(response)
pygame.display.quit()
@unittest.skipIf(
pygame.version.SDL >= (2, 32, 50),
"set_gamma_ramp is removed in SDL3, does not work in sdl2-compat either",
)
def test_set_gamma_ramp(self):
os.environ["SDL_VIDEO_WINDOW_POS"] = "100,250"
pygame.display.quit()
@@ -919,7 +1106,7 @@ class DisplayInteractiveTest(unittest.TestCase):
pygame.display.quit()
class FullscreenToggleTestsInteractive(unittest.TestCase):
class FullscreenToggleTests(unittest.TestCase):
__tags__ = ["interactive"]
screen = None
@@ -985,8 +1172,8 @@ class FullscreenToggleTestsInteractive(unittest.TestCase):
@unittest.skipIf(
os.environ.get("SDL_VIDEODRIVER") == pygame.NULL_VIDEODRIVER,
"OpenGL requires a non-null SDL_VIDEODRIVER",
os.environ.get("SDL_VIDEODRIVER") == "dummy",
'OpenGL requires a non-"dummy" SDL_VIDEODRIVER',
)
class DisplayOpenGLTest(unittest.TestCase):
def test_screen_size_opengl(self):
@@ -1000,7 +1187,7 @@ class DisplayOpenGLTest(unittest.TestCase):
class X11CrashTest(unittest.TestCase):
def test_x11_set_mode_crash_gh1654(self):
# Test for https://github.com/pygame-community/pygame-ce/issues/924
# Test for https://github.com/pygame/pygame/issues/1654
# If unfixed, this will trip a segmentation fault
pygame.display.init()
pygame.display.quit()
@@ -1008,105 +1195,5 @@ class X11CrashTest(unittest.TestCase):
self.assertEqual((640, 480), screen.get_size())
class MessageBoxTest(unittest.TestCase):
def test_messagebox_args(self):
mb = pygame.display.message_box
self.assertRaises(IndexError, lambda: mb("", escape_button=1))
self.assertRaises(IndexError, lambda: mb("", escape_button=-2))
self.assertRaises(IndexError, lambda: mb("", return_button=1))
self.assertRaises(IndexError, lambda: mb("", return_button=-2))
self.assertRaises(
IndexError,
lambda: mb("", buttons=("A", "B", "C"), return_button=3),
)
self.assertRaises(
IndexError,
lambda: mb("", buttons=("A", "B", "C"), return_button=-4),
)
self.assertRaises(
IndexError,
lambda: mb("", buttons=("A", "B", "C"), escape_button=3),
)
self.assertRaises(
IndexError,
lambda: mb("", buttons=("A", "B", "C"), escape_button=-4),
)
self.assertRaises(ValueError, lambda: mb("", message_type="random_str"))
self.assertRaises(TypeError, lambda: mb("", buttons=()))
self.assertRaises(TypeError, lambda: mb("", parent_window=123456))
class MessageBoxInteractiveTest(unittest.TestCase):
__tags__ = ["interactive"]
def test_message_box_type(self):
result = pygame.display.message_box(
"Test",
"Is this an error message box?",
message_type="error",
buttons=("Yes", "No"),
)
self.assertEqual(result, 0)
result = pygame.display.message_box(
"Test",
"Is this an info message box?",
message_type="info",
buttons=("Yes", "No"),
)
self.assertEqual(result, 0)
result = pygame.display.message_box(
"Test",
"Is this a warn message box?",
message_type="warn",
buttons=("Yes", "No"),
)
self.assertEqual(result, 0)
def test_message_box_buttons(self):
result = pygame.display.message_box("Hit the 'OK' button")
self.assertEqual(result, 0)
result = pygame.display.message_box(
"Hit the 'Hello' button",
buttons=("Nope", "Nope", "Nope", "Hello", "Nope", "Nope"),
)
self.assertEqual(result, 3)
result = pygame.display.message_box(
"Press Enter on your keyboard",
buttons=("O", "O", "O", "O", "O", "O"),
return_button=4,
)
self.assertEqual(result, 4)
result = pygame.display.message_box(
"Press Enter on your keyboard",
buttons=("O", "O", "O", "O", "O", "O"),
return_button=-3,
)
self.assertEqual(result, 3)
result = pygame.display.message_box(
"Press Esc on your keyboard",
buttons=("O", "O", "O", "O", "O", "O"),
escape_button=2,
)
self.assertEqual(result, 2)
result = pygame.display.message_box(
"Test",
"You saw 'Yes' on the left and 'No' on the right. Is this correct?",
buttons=("Yes", "No"),
)
self.assertEqual(result, 0)
def test_message_box_parent_window_none(self):
pygame.display.message_box(
"Test", "Just close this messagebox", parent_window=None
)
if __name__ == "__main__":
unittest.main()