434 lines
15 KiB
Python
434 lines
15 KiB
Python
# -*- coding: utf-8 -*-
|
|
|
|
import unittest
|
|
import os
|
|
|
|
import pygame, pygame.transform
|
|
from pygame.compat import unicode_
|
|
|
|
from pygame import display
|
|
|
|
|
|
SDL2 = pygame.get_sdl_version()[0] >= 2
|
|
|
|
|
|
class DisplayModuleTest(unittest.TestCase):
|
|
default_caption = "pygame window"
|
|
|
|
def setUp(self):
|
|
display.init()
|
|
|
|
def tearDown(self):
|
|
display.quit()
|
|
|
|
def test_update(self):
|
|
""" see if pygame.display.update takes rects with negative values.
|
|
"|Tags:display|"
|
|
"""
|
|
screen = pygame.display.set_mode((100, 100))
|
|
screen.fill((55, 55, 55))
|
|
|
|
r1 = pygame.Rect(0, 0, 100, 100)
|
|
pygame.display.update(r1)
|
|
|
|
r2 = pygame.Rect(-10, 0, 100, 100)
|
|
pygame.display.update(r2)
|
|
|
|
r3 = pygame.Rect(-10, 0, -100, -100)
|
|
pygame.display.update(r3)
|
|
|
|
def test_Info(self):
|
|
inf = pygame.display.Info()
|
|
self.assertNotEqual(inf.current_h, -1)
|
|
self.assertNotEqual(inf.current_w, -1)
|
|
# probably have an older SDL than 1.2.10 if -1.
|
|
|
|
screen = pygame.display.set_mode((128, 128))
|
|
inf = pygame.display.Info()
|
|
self.assertEqual(inf.current_h, 128)
|
|
self.assertEqual(inf.current_w, 128)
|
|
|
|
def todo_test_flip(self):
|
|
|
|
# __doc__ (as of 2008-08-02) for pygame.display.flip:
|
|
|
|
# pygame.display.flip(): return None
|
|
# update the full display Surface to the screen
|
|
#
|
|
# This will update the contents of the entire display. If your display
|
|
# mode is using the flags pygame.HWSURFACE and pygame.DOUBLEBUF, this
|
|
# will wait for a vertical retrace and swap the surfaces. If you are
|
|
# using a different type of display mode, it will simply update the
|
|
# entire contents of the surface.
|
|
#
|
|
# When using an pygame.OPENGL display mode this will perform a gl buffer swap.
|
|
|
|
self.fail()
|
|
|
|
def todo_test_get_active(self):
|
|
|
|
# __doc__ (as of 2008-08-02) for pygame.display.get_active:
|
|
|
|
# pygame.display.get_active(): return bool
|
|
# true when the display is active on the display
|
|
#
|
|
# After pygame.display.set_mode() is called the display Surface will
|
|
# be visible on the screen. Most windowed displays can be hidden by
|
|
# the user. If the display Surface is hidden or iconified this will
|
|
# return False.
|
|
#
|
|
|
|
self.fail()
|
|
|
|
def test_get_caption(self):
|
|
screen = display.set_mode((100, 100))
|
|
|
|
self.assertEqual(display.get_caption()[0], self.default_caption)
|
|
|
|
def test_set_caption(self):
|
|
TEST_CAPTION = "test"
|
|
screen = display.set_mode((100, 100))
|
|
|
|
self.assertIsNone(display.set_caption(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 = u"台"
|
|
display.set_caption(TEST_CAPTION)
|
|
import sys
|
|
|
|
if sys.version_info.major >= 3:
|
|
self.assertEqual(display.get_caption()[0], TEST_CAPTION)
|
|
else:
|
|
self.assertEqual(unicode_(display.get_caption()[0], "utf8"), TEST_CAPTION)
|
|
|
|
def todo_test_get_driver(self):
|
|
|
|
# __doc__ (as of 2008-08-02) for pygame.display.get_driver:
|
|
|
|
# pygame.display.get_driver(): return name
|
|
# get the name of the pygame display backend
|
|
#
|
|
# Pygame chooses one of many available display backends when it is
|
|
# initialized. This returns the internal name used for the display
|
|
# backend. This can be used to provide limited information about what
|
|
# display capabilities might be accelerated. See the SDL_VIDEODRIVER
|
|
# flags in pygame.display.set_mode() to see some of the common
|
|
# options.
|
|
#
|
|
|
|
self.fail()
|
|
|
|
def test_get_init(self):
|
|
"""Ensures the module's initialization state can be retrieved."""
|
|
# display.init() already called in setUp()
|
|
self.assertTrue(display.get_init())
|
|
|
|
# This decorator can be removed (or test changed) when issues #991 and #993
|
|
# are resolved.
|
|
@unittest.skipIf(SDL2, "SDL2 issues")
|
|
def test_get_surface(self):
|
|
"""Ensures get_surface gets the current display surface."""
|
|
lengths = (1, 5, 100)
|
|
|
|
for expected_size in ((w, h) for w in lengths for h in lengths):
|
|
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_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."""
|
|
surface = pygame.display.get_surface()
|
|
|
|
self.assertIsNone(surface)
|
|
|
|
def todo_test_get_wm_info(self):
|
|
|
|
# __doc__ (as of 2008-08-02) for pygame.display.get_wm_info:
|
|
|
|
# pygame.display.get_wm_info(): return dict
|
|
# Get information about the current windowing system
|
|
#
|
|
# Creates a dictionary filled with string keys. The strings and values
|
|
# are arbitrarily created by the system. Some systems may have no
|
|
# information and an empty dictionary will be returned. Most platforms
|
|
# will return a "window" key with the value set to the system id for
|
|
# the current display.
|
|
#
|
|
# New with pygame 1.7.1
|
|
|
|
self.fail()
|
|
|
|
def todo_test_gl_get_attribute(self):
|
|
|
|
# __doc__ (as of 2008-08-02) for pygame.display.gl_get_attribute:
|
|
|
|
# pygame.display.gl_get_attribute(flag): return value
|
|
# get the value for an opengl flag for the current display
|
|
#
|
|
# After calling pygame.display.set_mode() with the pygame.OPENGL flag,
|
|
# it is a good idea to check the value of any requested OpenGL
|
|
# attributes. See pygame.display.gl_set_attribute() for a list of
|
|
# valid flags.
|
|
#
|
|
|
|
self.fail()
|
|
|
|
def todo_test_gl_set_attribute(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
|
|
|
|
self.fail()
|
|
|
|
def todo_test_iconify(self):
|
|
|
|
# __doc__ (as of 2008-08-02) for pygame.display.iconify:
|
|
|
|
# pygame.display.iconify(): return bool
|
|
# iconify the display surface
|
|
#
|
|
# Request the window for the display surface be iconified or hidden.
|
|
# Not all systems and displays support an iconified display. The
|
|
# function will return True if successfull.
|
|
#
|
|
# When the display is iconified pygame.display.get_active() will
|
|
# return False. The event queue should receive a ACTIVEEVENT event
|
|
# when the window has been iconified.
|
|
#
|
|
|
|
self.fail()
|
|
|
|
def test_init(self):
|
|
"""Ensures the module is initialized after init called."""
|
|
# display.init() already called in setUp(), so quit and re-init
|
|
display.quit()
|
|
display.init()
|
|
|
|
self.assertTrue(display.get_init())
|
|
|
|
def test_init__multiple(self):
|
|
"""Ensures the module is initialized after multiple init calls."""
|
|
display.init()
|
|
display.init()
|
|
|
|
self.assertTrue(display.get_init())
|
|
|
|
def test_list_modes(self):
|
|
modes = pygame.display.list_modes(depth=0, flags=pygame.FULLSCREEN, display=0)
|
|
# modes == -1 means any mode is supported.
|
|
if modes != -1:
|
|
self.assertEqual(len(modes[0]), 2)
|
|
self.assertEqual(type(modes[0][0]), int)
|
|
|
|
modes = pygame.display.list_modes()
|
|
if modes != -1:
|
|
self.assertEqual(len(modes[0]), 2)
|
|
self.assertEqual(type(modes[0][0]), int)
|
|
|
|
modes = pygame.display.list_modes(depth=0, flags=0, display=0)
|
|
if modes != -1:
|
|
self.assertEqual(len(modes[0]), 2)
|
|
self.assertEqual(type(modes[0][0]), int)
|
|
|
|
def test_mode_ok(self):
|
|
pygame.display.mode_ok((128, 128))
|
|
modes = pygame.display.list_modes()
|
|
if modes != -1:
|
|
size = modes[0]
|
|
self.assertNotEqual(pygame.display.mode_ok(size), 0)
|
|
|
|
pygame.display.mode_ok((128, 128), 0, 32)
|
|
pygame.display.mode_ok((128, 128), flags=0, depth=32, display=0)
|
|
|
|
def test_mode_ok_fullscreen(self):
|
|
modes = pygame.display.list_modes()
|
|
if modes != -1:
|
|
size = modes[0]
|
|
self.assertNotEqual(
|
|
pygame.display.mode_ok(size, flags=pygame.FULLSCREEN), 0
|
|
)
|
|
|
|
def test_mode_ok_scaled(self):
|
|
modes = pygame.display.list_modes()
|
|
if modes != -1:
|
|
size = modes[0]
|
|
self.assertNotEqual(pygame.display.mode_ok(size, flags=pygame.SCALED), 0)
|
|
|
|
def test_get_num_displays(self):
|
|
self.assertGreater(pygame.display.get_num_displays(), 0)
|
|
|
|
def test_quit(self):
|
|
"""Ensures the module is not initialized after quit called."""
|
|
display.quit()
|
|
|
|
self.assertFalse(display.get_init())
|
|
|
|
def test_quit__multiple(self):
|
|
"""Ensures the module is not initialized after multiple quit calls."""
|
|
display.quit()
|
|
display.quit()
|
|
|
|
self.assertFalse(display.get_init())
|
|
|
|
def todo_test_set_gamma(self):
|
|
|
|
# __doc__ (as of 2008-08-02) for pygame.display.set_gamma:
|
|
|
|
# pygame.display.set_gamma(red, green=None, blue=None): return bool
|
|
# change the hardware gamma ramps
|
|
#
|
|
# Set the red, green, and blue gamma values on the display hardware.
|
|
# If the green and blue arguments are not passed, they will both be
|
|
# the same as red. Not all systems and hardware support gamma ramps,
|
|
# if the function succeeds it will return True.
|
|
#
|
|
# A gamma value of 1.0 creates a linear color table. Lower values will
|
|
# darken the display and higher values will brighten.
|
|
#
|
|
|
|
self.fail()
|
|
|
|
def todo_test_set_gamma_ramp(self):
|
|
|
|
# __doc__ (as of 2008-08-02) for pygame.display.set_gamma_ramp:
|
|
|
|
# change the hardware gamma ramps with a custom lookup
|
|
# pygame.display.set_gamma_ramp(red, green, blue): return bool
|
|
# set_gamma_ramp(red, green, blue): return bool
|
|
#
|
|
# Set the red, green, and blue gamma ramps with an explicit lookup
|
|
# table. Each argument should be sequence of 256 integers. The
|
|
# integers should range between 0 and 0xffff. Not all systems and
|
|
# hardware support gamma ramps, if the function succeeds it will
|
|
# return True.
|
|
#
|
|
|
|
self.fail()
|
|
|
|
def todo_test_set_icon(self):
|
|
|
|
# __doc__ (as of 2008-08-02) for pygame.display.set_icon:
|
|
|
|
# pygame.display.set_icon(Surface): return None
|
|
# change the system image for the display window
|
|
#
|
|
# Sets the runtime icon the system will use to represent the display
|
|
# window. All windows default to a simple pygame logo for the window
|
|
# icon.
|
|
#
|
|
# You can pass any surface, but most systems want a smaller image
|
|
# around 32x32. The image can have colorkey transparency which will be
|
|
# passed to the system.
|
|
#
|
|
# Some systems do not allow the window icon to change after it has
|
|
# been shown. This function can be called before
|
|
# pygame.display.set_mode() to create the icon before the display mode
|
|
# is set.
|
|
#
|
|
|
|
self.fail()
|
|
|
|
def test_set_mode_kwargs(self):
|
|
|
|
pygame.display.set_mode(size=(1, 1), flags=0, depth=0, display=0)
|
|
|
|
def test_set_mode_scaled(self):
|
|
surf = pygame.display.set_mode(
|
|
size=(1, 1), flags=pygame.SCALED, depth=0, display=0
|
|
)
|
|
winsize = pygame.display.get_window_size()
|
|
self.assertEqual(
|
|
winsize[0] % surf.get_size()[0],
|
|
0,
|
|
"window width should be a multiple of the surface width",
|
|
)
|
|
self.assertEqual(
|
|
winsize[1] % surf.get_size()[1],
|
|
0,
|
|
"window height should be a multiple of the surface height",
|
|
)
|
|
self.assertEqual(
|
|
winsize[0] / surf.get_size()[0], winsize[1] / surf.get_size()[1]
|
|
)
|
|
|
|
def todo_test_set_palette(self):
|
|
|
|
# __doc__ (as of 2008-08-02) for pygame.display.set_palette:
|
|
|
|
# pygame.display.set_palette(palette=None): return None
|
|
# set the display color palette for indexed displays
|
|
#
|
|
# This will change the video display color palette for 8bit displays.
|
|
# This does not change the palette for the actual display Surface,
|
|
# only the palette that is used to display the Surface. If no palette
|
|
# argument is passed, the system default palette will be restored. The
|
|
# palette is a sequence of RGB triplets.
|
|
#
|
|
|
|
self.fail()
|
|
|
|
def todo_test_toggle_fullscreen(self):
|
|
|
|
# __doc__ (as of 2008-08-02) for pygame.display.toggle_fullscreen:
|
|
|
|
# pygame.display.toggle_fullscreen(): return bool
|
|
# switch between fullscreen and windowed displays
|
|
#
|
|
# Switches the display window between windowed and fullscreen modes.
|
|
# This function only works under the unix x11 video driver. For most
|
|
# situations it is better to call pygame.display.set_mode() with new
|
|
# display flags.
|
|
#
|
|
|
|
self.fail()
|
|
|
|
|
|
@unittest.skipIf(
|
|
os.environ.get("SDL_VIDEODRIVER") == "dummy",
|
|
'OpenGL requires a non-"dummy" SDL_VIDEODRIVER',
|
|
)
|
|
class DisplayOpenGLTest(unittest.TestCase):
|
|
def test_screen_size_opengl(self):
|
|
""" returns a surface with the same size requested.
|
|
|tags:display,slow,opengl|
|
|
"""
|
|
pygame.display.init()
|
|
screen = pygame.display.set_mode((640, 480), pygame.OPENGL)
|
|
self.assertEqual((640, 480), screen.get_size())
|
|
|
|
|
|
class X11CrashTest(unittest.TestCase):
|
|
def test_x11_set_mode_crash_gh1654(self):
|
|
# Test for https://github.com/pygame/pygame/issues/1654
|
|
# If unfixed, this will trip a segmentation fault
|
|
pygame.display.init()
|
|
pygame.display.quit()
|
|
screen = pygame.display.set_mode((640, 480), 0)
|
|
self.assertEqual((640, 480), screen.get_size())
|
|
|
|
|
|
if __name__ == "__main__":
|
|
unittest.main()
|