924 lines
40 KiB
Python
924 lines
40 KiB
Python
import sys
|
|
from ctypes.util import find_library
|
|
from ctypes import c_int, c_float, byref, cast, POINTER, py_object
|
|
import unittest
|
|
from .util.testutils import interactive, doprint
|
|
from ..stdinc import SDL_FALSE, SDL_TRUE
|
|
from .. import video, rect, surface
|
|
|
|
if sys.version_info[0] >= 3:
|
|
long = int
|
|
|
|
to_ctypes = lambda seq, dtype: (dtype * len(seq))(*seq)
|
|
|
|
|
|
def has_opengl_lib():
|
|
for libname in("gl", "opengl", "opengl32"):
|
|
path = find_library(libname)
|
|
if path is not None:
|
|
return True
|
|
|
|
|
|
def get_opengl_path():
|
|
for libname in("gl", "opengl", "opengl32"):
|
|
path = find_library(libname)
|
|
if path is not None:
|
|
return path
|
|
|
|
|
|
# TODO: mostly covers positive tests right now - fix this!
|
|
class SDLVideoTest(unittest.TestCase):
|
|
__tags__ = ["sdl"]
|
|
|
|
def setUp(self):
|
|
video.SDL_VideoInit(None)
|
|
|
|
def tearDown(self):
|
|
video.SDL_VideoQuit()
|
|
|
|
def test_SDL_WINDOWPOS_UNDEFINED_DISPLAY(self):
|
|
for x in range(0xFFFF):
|
|
self.assertEqual(video.SDL_WINDOWPOS_UNDEFINED_MASK | x,
|
|
video.SDL_WINDOWPOS_UNDEFINED_DISPLAY(x))
|
|
self.assertEqual((video.SDL_WINDOWPOS_UNDEFINED_DISPLAY(x) &
|
|
video.SDL_WINDOWPOS_UNDEFINED_MASK),
|
|
video.SDL_WINDOWPOS_UNDEFINED_MASK)
|
|
self.assertTrue(video.SDL_WINDOWPOS_UNDEFINED_DISPLAY(x) !=
|
|
video.SDL_WINDOWPOS_CENTERED_DISPLAY(x))
|
|
|
|
def test_SDL_WINDOWPOS_ISUNDEFINED(self):
|
|
self.assertTrue(video.SDL_WINDOWPOS_ISUNDEFINED
|
|
(video.SDL_WINDOWPOS_UNDEFINED))
|
|
self.assertFalse(video.SDL_WINDOWPOS_ISUNDEFINED
|
|
(video.SDL_WINDOWPOS_CENTERED))
|
|
for x in range(0xFFFF):
|
|
self.assertTrue(video.SDL_WINDOWPOS_ISUNDEFINED
|
|
(video.SDL_WINDOWPOS_UNDEFINED_DISPLAY(x)))
|
|
|
|
def test_SDL_WINDOWPOS_CENTERED_DISPLAY(self):
|
|
for x in range(0xFFFF):
|
|
self.assertEqual(video.SDL_WINDOWPOS_CENTERED_MASK | x,
|
|
video.SDL_WINDOWPOS_CENTERED_DISPLAY(x))
|
|
self.assertEqual((video.SDL_WINDOWPOS_CENTERED_DISPLAY(x) &
|
|
video.SDL_WINDOWPOS_CENTERED_MASK),
|
|
video.SDL_WINDOWPOS_CENTERED_MASK)
|
|
self.assertTrue(video.SDL_WINDOWPOS_CENTERED_DISPLAY(x) !=
|
|
video.SDL_WINDOWPOS_UNDEFINED_DISPLAY(x))
|
|
|
|
def test_SDL_WINDOWPOS_ISCENTERED(self):
|
|
self.assertTrue(video.SDL_WINDOWPOS_ISCENTERED
|
|
(video.SDL_WINDOWPOS_CENTERED))
|
|
self.assertFalse(video.SDL_WINDOWPOS_ISCENTERED
|
|
(video.SDL_WINDOWPOS_UNDEFINED))
|
|
for x in range(0xFFFF):
|
|
self.assertTrue(video.SDL_WINDOWPOS_ISCENTERED
|
|
(video.SDL_WINDOWPOS_CENTERED_DISPLAY(x)))
|
|
|
|
def test_SDL_DisplayMode(self):
|
|
mode = video.SDL_DisplayMode()
|
|
self.assertIsInstance(mode, video.SDL_DisplayMode)
|
|
for fmt in range(0, 10):
|
|
for w in range(0, 20):
|
|
for h in range(0, 30):
|
|
for r in range(0, 40):
|
|
mode = video.SDL_DisplayMode(fmt, w, h, r)
|
|
self.assertIsInstance(mode, video.SDL_DisplayMode)
|
|
self.assertEqual(mode.format, fmt)
|
|
self.assertEqual(mode.w, w)
|
|
self.assertEqual(mode.h, h)
|
|
self.assertEqual(mode.refresh_rate, r)
|
|
self.assertRaises(TypeError, video.SDL_DisplayMode, "Test")
|
|
self.assertRaises(TypeError, video.SDL_DisplayMode, "Test", 10, 10, 10)
|
|
self.assertRaises(TypeError, video.SDL_DisplayMode, 10, "Test", 10, 10)
|
|
self.assertRaises(TypeError, video.SDL_DisplayMode, 10, 10, "Test", 10)
|
|
self.assertRaises(TypeError, video.SDL_DisplayMode, 10, 10, 10, "Test")
|
|
self.assertRaises(TypeError, video.SDL_DisplayMode, None)
|
|
self.assertRaises(TypeError, video.SDL_DisplayMode, None, 10, 10, 10)
|
|
self.assertRaises(TypeError, video.SDL_DisplayMode, 10, None, 10, 10)
|
|
self.assertRaises(TypeError, video.SDL_DisplayMode, 10, 10, None, 10)
|
|
self.assertRaises(TypeError, video.SDL_DisplayMode, 10, 10, 10, None)
|
|
|
|
def test_SDL_DisplayMode__eq__(self):
|
|
DMode = video.SDL_DisplayMode
|
|
self.assertTrue(DMode() == DMode())
|
|
self.assertTrue(DMode(10, 0, 0, 0) == DMode(10, 0, 0, 0))
|
|
self.assertTrue(DMode(10, 10, 0, 0) == DMode(10, 10, 0, 0))
|
|
self.assertTrue(DMode(10, 10, 10, 0) == DMode(10, 10, 10, 0))
|
|
self.assertTrue(DMode(10, 10, 10, 10) == DMode(10, 10, 10, 10))
|
|
self.assertTrue(DMode(0, 10, 0, 0) == DMode(0, 10, 0, 0))
|
|
self.assertTrue(DMode(0, 0, 10, 0) == DMode(0, 0, 10, 0))
|
|
self.assertTrue(DMode(0, 0, 0, 10) == DMode(0, 0, 0, 10))
|
|
|
|
self.assertFalse(DMode() == DMode(10, 0, 0, 0))
|
|
self.assertFalse(DMode(10, 0, 0, 0) == DMode(0, 0, 0, 0))
|
|
self.assertFalse(DMode(10, 0, 0, 0) == DMode(0, 10, 0, 0))
|
|
self.assertFalse(DMode(10, 0, 0, 0) == DMode(0, 0, 10, 0))
|
|
self.assertFalse(DMode(10, 0, 0, 0) == DMode(0, 0, 0, 10))
|
|
|
|
def test_SDL_DisplayMode__ne__(self):
|
|
DMode = video.SDL_DisplayMode
|
|
self.assertFalse(DMode() != DMode())
|
|
self.assertFalse(DMode(10, 0, 0, 0) != DMode(10, 0, 0, 0))
|
|
self.assertFalse(DMode(10, 10, 0, 0) != DMode(10, 10, 0, 0))
|
|
self.assertFalse(DMode(10, 10, 10, 0) != DMode(10, 10, 10, 0))
|
|
self.assertFalse(DMode(10, 10, 10, 10) != DMode(10, 10, 10, 10))
|
|
self.assertFalse(DMode(0, 10, 0, 0) != DMode(0, 10, 0, 0))
|
|
self.assertFalse(DMode(0, 0, 10, 0) != DMode(0, 0, 10, 0))
|
|
self.assertFalse(DMode(0, 0, 0, 10) != DMode(0, 0, 0, 10))
|
|
|
|
self.assertTrue(DMode() != DMode(10, 0, 0, 0))
|
|
self.assertTrue(DMode(10, 0, 0, 0) != DMode(0, 0, 0, 0))
|
|
self.assertTrue(DMode(10, 0, 0, 0) != DMode(0, 10, 0, 0))
|
|
self.assertTrue(DMode(10, 0, 0, 0) != DMode(0, 0, 10, 0))
|
|
self.assertTrue(DMode(10, 0, 0, 0) != DMode(0, 0, 0, 10))
|
|
|
|
def test_SDL_Window(self):
|
|
window = video.SDL_Window()
|
|
self.assertIsInstance(window, video.SDL_Window)
|
|
|
|
def test_SDL_GetNumVideoDrivers(self):
|
|
numdrivers = video.SDL_GetNumVideoDrivers()
|
|
self.assertGreaterEqual(numdrivers, 1)
|
|
|
|
def test_SDL_GetVideoDriver(self):
|
|
numdrivers = video.SDL_GetNumVideoDrivers()
|
|
for i in range(numdrivers):
|
|
name = video.SDL_GetVideoDriver(i)
|
|
self.assertIn(type(name), (str, bytes))
|
|
|
|
def test_SDL_GetCurrentVideoDriver(self):
|
|
curdriver = video.SDL_GetCurrentVideoDriver()
|
|
found = False
|
|
numdrivers = video.SDL_GetNumVideoDrivers()
|
|
for i in range(numdrivers):
|
|
name = video.SDL_GetVideoDriver(i)
|
|
if name == curdriver:
|
|
found = True
|
|
break
|
|
self.assertTrue(found, "Current video driver not found")
|
|
|
|
def test_SDL_GetNumVideoDisplays(self):
|
|
numdisplays = video.SDL_GetNumVideoDisplays()
|
|
self.assertGreaterEqual(numdisplays, 1)
|
|
|
|
def test_SDL_GetNumDisplayModes(self):
|
|
numdisplays = video.SDL_GetNumVideoDisplays()
|
|
for index in range(numdisplays):
|
|
modes = video.SDL_GetNumDisplayModes(index)
|
|
self.assertGreaterEqual(modes, 1)
|
|
|
|
def test_SDL_GetDisplayMode(self):
|
|
numdisplays = video.SDL_GetNumVideoDisplays()
|
|
for index in range(numdisplays):
|
|
modes = video.SDL_GetNumDisplayModes(index)
|
|
for mode in range(modes):
|
|
dmode = video.SDL_DisplayMode()
|
|
ret = video.SDL_GetDisplayMode(index, mode, byref(dmode))
|
|
self.assertEqual(ret, 0)
|
|
|
|
def test_SDL_GetCurrentDisplayMode(self):
|
|
numdisplays = video.SDL_GetNumVideoDisplays()
|
|
for index in range(numdisplays):
|
|
dmode = video.SDL_DisplayMode()
|
|
ret = video.SDL_GetCurrentDisplayMode(index, byref(dmode))
|
|
self.assertEqual(ret, 0)
|
|
|
|
def test_SDL_GetDesktopDisplayMode(self):
|
|
numdisplays = video.SDL_GetNumVideoDisplays()
|
|
for index in range(numdisplays):
|
|
dmode = video.SDL_DisplayMode()
|
|
ret = video.SDL_GetDesktopDisplayMode(index, byref(dmode))
|
|
self.assertEqual(ret, 0)
|
|
|
|
def test_SDL_GetClosestDisplayMode(self):
|
|
numdisplays = video.SDL_GetNumVideoDisplays()
|
|
for index in range(numdisplays):
|
|
modes = video.SDL_GetNumDisplayModes(index)
|
|
dmode = video.SDL_DisplayMode()
|
|
for mode in range(modes):
|
|
ret = video.SDL_GetDisplayMode(index, mode, byref(dmode))
|
|
#self.assertIsInstance(dmode.contents, video.SDL_DisplayMode)
|
|
self.assertEqual(ret, 0)
|
|
cmode = video.SDL_DisplayMode(dmode.format,
|
|
dmode.w - 1, dmode.h - 1,
|
|
dmode.refresh_rate)
|
|
closest = video.SDL_DisplayMode()
|
|
video.SDL_GetClosestDisplayMode(index, cmode, byref(closest))
|
|
self.assertEqual(closest, dmode)
|
|
|
|
def test_SDL_VideoInit(self):
|
|
video.SDL_VideoInit(None)
|
|
video.SDL_VideoInit(None)
|
|
video.SDL_VideoInit(None)
|
|
video.SDL_VideoQuit(None)
|
|
video.SDL_VideoInit(None)
|
|
|
|
def test_SDL_VideoQuit(self):
|
|
video.SDL_VideoQuit()
|
|
video.SDL_VideoQuit()
|
|
video.SDL_VideoQuit()
|
|
video.SDL_VideoInit(None)
|
|
|
|
def test_SDL_GetDisplayBounds(self):
|
|
numdisplays = video.SDL_GetNumVideoDisplays()
|
|
for index in range(numdisplays):
|
|
bounds = rect.SDL_Rect()
|
|
ret = video.SDL_GetDisplayBounds(index, byref(bounds))
|
|
self.assertEqual(ret, 0)
|
|
self.assertFalse(rect.SDL_RectEmpty(bounds))
|
|
|
|
def test_screensaver(self):
|
|
initial = video.SDL_IsScreenSaverEnabled()
|
|
self.assertIn(initial, (SDL_FALSE, SDL_TRUE))
|
|
|
|
video.SDL_EnableScreenSaver()
|
|
self.assertEqual(video.SDL_IsScreenSaverEnabled(), SDL_TRUE)
|
|
video.SDL_EnableScreenSaver()
|
|
self.assertEqual(video.SDL_IsScreenSaverEnabled(), SDL_TRUE)
|
|
video.SDL_DisableScreenSaver()
|
|
self.assertEqual(video.SDL_IsScreenSaverEnabled(), SDL_FALSE)
|
|
video.SDL_DisableScreenSaver()
|
|
self.assertEqual(video.SDL_IsScreenSaverEnabled(), SDL_FALSE)
|
|
video.SDL_EnableScreenSaver()
|
|
self.assertEqual(video.SDL_IsScreenSaverEnabled(), SDL_TRUE)
|
|
video.SDL_DisableScreenSaver()
|
|
self.assertEqual(video.SDL_IsScreenSaverEnabled(), SDL_FALSE)
|
|
|
|
if initial == SDL_TRUE:
|
|
video.SDL_EnableScreenSaver()
|
|
else:
|
|
video.SDL_DisableScreenSaver()
|
|
|
|
def test_SDL_CreateWindow(self):
|
|
# Borderless to ensure that the size check works
|
|
flags = (video.SDL_WINDOW_BORDERLESS,
|
|
video.SDL_WINDOW_BORDERLESS | video.SDL_WINDOW_HIDDEN)
|
|
for flag in flags:
|
|
window = video.SDL_CreateWindow(b"Test", 10, 11, 12, 13, flag)
|
|
self.assertIsInstance(window.contents, video.SDL_Window)
|
|
px, py = c_int(), c_int()
|
|
video.SDL_GetWindowPosition(window, byref(px), byref(py))
|
|
self.assertEqual((px.value, py.value), (10, 11))
|
|
video.SDL_GetWindowSize(window, byref(px), byref(py))
|
|
self.assertEqual((px.value, py.value), (12, 13))
|
|
self.assertEqual(video.SDL_GetWindowFlags(window) & flag, flag)
|
|
self.assertEqual(video.SDL_GetWindowTitle(window), b"Test")
|
|
video.SDL_DestroyWindow(window)
|
|
# TODO
|
|
|
|
def test_SDL_DestroyWindow(self):
|
|
flags = (video.SDL_WINDOW_BORDERLESS,
|
|
video.SDL_WINDOW_BORDERLESS | video.SDL_WINDOW_HIDDEN)
|
|
for flag in flags:
|
|
window = video.SDL_CreateWindow(b"Test", 10, 10, 10, 10, flag)
|
|
# TODO: how to check for this in a meaningful way?
|
|
video.SDL_DestroyWindow(window)
|
|
|
|
@unittest.skip("not implemented")
|
|
def test_SDL_CreateWindowFrom(self):
|
|
pass
|
|
|
|
def test_SDL_GetWindowDisplayIndex(self):
|
|
numdisplays = video.SDL_GetNumVideoDisplays()
|
|
flags = (video.SDL_WINDOW_BORDERLESS,
|
|
video.SDL_WINDOW_BORDERLESS | video.SDL_WINDOW_HIDDEN)
|
|
for flag in flags:
|
|
window = video.SDL_CreateWindow(b"Test", 10, 11, 12, 13, flag)
|
|
self.assertIsInstance(window.contents, video.SDL_Window)
|
|
px, py = c_int(), c_int()
|
|
video.SDL_GetWindowPosition(window, byref(px), byref(py))
|
|
self.assertEqual((px.value, py.value), (10, 11))
|
|
video.SDL_GetWindowSize(window, byref(px), byref(py))
|
|
self.assertEqual((px.value, py.value), (12, 13))
|
|
self.assertEqual(video.SDL_GetWindowFlags(window) & flag, flag)
|
|
self.assertEqual(video.SDL_GetWindowTitle(window), b"Test")
|
|
|
|
dindex = video.SDL_GetWindowDisplayIndex(window)
|
|
self.assertTrue(0 <= dindex <= numdisplays,
|
|
"Invalid display index")
|
|
video.SDL_DestroyWindow(window)
|
|
# self.assertRaises(sdl.SDLError, video.SDL_GetWindowDisplay,
|
|
# window)
|
|
|
|
def test_SDL_GetWindowDisplayMode(self):
|
|
flags = (video.SDL_WINDOW_BORDERLESS,
|
|
video.SDL_WINDOW_BORDERLESS | video.SDL_WINDOW_HIDDEN)
|
|
for flag in flags:
|
|
window = video.SDL_CreateWindow(b"Test", 10, 10, 10, 10, flag)
|
|
dmode = video.SDL_DisplayMode()
|
|
ret = video.SDL_GetWindowDisplayMode(window, byref(dmode))
|
|
self.assertEqual(ret, 0)
|
|
video.SDL_DestroyWindow(window)
|
|
# self.assertRaises(sdl.SDLError, video.SDL_GetWindowDisplayMode,
|
|
# window)
|
|
|
|
def test_SDL_SetWindowDisplayMode(self):
|
|
flags = (video.SDL_WINDOW_BORDERLESS,
|
|
video.SDL_WINDOW_BORDERLESS | video.SDL_WINDOW_HIDDEN)
|
|
for flag in flags:
|
|
window = video.SDL_CreateWindow(b"Test", 10, 10, 10, 10, flag)
|
|
dindex = video.SDL_GetWindowDisplayIndex(window)
|
|
dmode = video.SDL_DisplayMode()
|
|
|
|
ret = video.SDL_GetCurrentDisplayMode(dindex, byref(dmode))
|
|
self.assertEqual(ret, 0)
|
|
|
|
video.SDL_SetWindowDisplayMode(window, dmode)
|
|
wmode = video.SDL_DisplayMode()
|
|
ret = video.SDL_GetWindowDisplayMode(window, byref(wmode))
|
|
self.assertEqual(ret, 0)
|
|
# TODO: refresh rates differ
|
|
#self.assertEqual(dmode, wmode)
|
|
|
|
video.SDL_DestroyWindow(window)
|
|
# self.assertRaises(sdl.SDLError, video.SDL_SetWindowDisplayMode,
|
|
# window, dmode)
|
|
|
|
def test_SDL_GetWindowPixelFormat(self):
|
|
flags = (video.SDL_WINDOW_BORDERLESS,
|
|
video.SDL_WINDOW_BORDERLESS | video.SDL_WINDOW_HIDDEN)
|
|
for flag in flags:
|
|
window = video.SDL_CreateWindow(b"Test", 10, 10, 10, 10, flag)
|
|
fmt = video.SDL_GetWindowPixelFormat(window)
|
|
self.assertTrue(type(fmt) in(int, long))
|
|
video.SDL_DestroyWindow(window)
|
|
# self.assertRaises(sdl.SDLError, video.SDL_GetWindowPixelFormat,
|
|
# window)
|
|
|
|
def test_SDL_GetWindowID(self):
|
|
flags = (video.SDL_WINDOW_BORDERLESS,
|
|
video.SDL_WINDOW_BORDERLESS | video.SDL_WINDOW_HIDDEN)
|
|
for flag in flags:
|
|
window = video.SDL_CreateWindow(b"Test", 10, 10, 10, 10, flag)
|
|
self.assertGreaterEqual(video.SDL_GetWindowID(window), 0)
|
|
|
|
video.SDL_DestroyWindow(window)
|
|
#self.assertRaises(sdl.SDLError, video.SDL_GetWindowID, window)
|
|
|
|
def test_SDL_GetWindowFromID(self):
|
|
flags = (video.SDL_WINDOW_BORDERLESS,
|
|
video.SDL_WINDOW_BORDERLESS | video.SDL_WINDOW_HIDDEN)
|
|
for flag in flags:
|
|
window = video.SDL_CreateWindow(b"Test", 10, 10, 10, 10, flag)
|
|
window2 = video.SDL_GetWindowFromID(video.SDL_GetWindowID(window))
|
|
self.assertEqual(video.SDL_GetWindowID(window),
|
|
video.SDL_GetWindowID(window2))
|
|
self.assertEqual(video.SDL_GetWindowTitle(window),
|
|
video.SDL_GetWindowTitle(window2))
|
|
px1, py1, px2, py2 = c_int(), c_int(), c_int(), c_int()
|
|
video.SDL_GetWindowPosition(window, byref(px1), byref(px2))
|
|
video.SDL_GetWindowPosition(window2, byref(px2), byref(px2))
|
|
self.assertEqual((px1.value, py1.value), (px2.value, py2.value))
|
|
video.SDL_GetWindowSize(window, byref(px1), byref(px2))
|
|
video.SDL_GetWindowSize(window2, byref(px2), byref(px2))
|
|
self.assertEqual((px1.value, py1.value), (px2.value, py2.value))
|
|
|
|
def test_SDL_GetWindowFlags(self):
|
|
flags = (video.SDL_WINDOW_BORDERLESS,
|
|
video.SDL_WINDOW_BORDERLESS | video.SDL_WINDOW_HIDDEN,
|
|
video.SDL_WINDOW_RESIZABLE)
|
|
for flag in flags:
|
|
window = video.SDL_CreateWindow(b"Test", 10, 10, 10, 10, flag)
|
|
wflags = video.SDL_GetWindowFlags(window)
|
|
self.assertEqual((wflags & flag), flag)
|
|
|
|
def test_SDL_GetSetWindowTitle(self):
|
|
window = video.SDL_CreateWindow(b"Test", 10, 10, 10, 10, 0)
|
|
self.assertEqual(video.SDL_GetWindowTitle(window), b"Test")
|
|
video.SDL_SetWindowTitle(window, b"Hello there")
|
|
self.assertEqual(video.SDL_GetWindowTitle(window), b"Hello there")
|
|
video.SDL_DestroyWindow(window)
|
|
#self.assertRaises(sdl.SDLError, video.SDL_GetWindowTitle, window)
|
|
|
|
def test_SDL_SetWindowIcon(self):
|
|
sf = surface.SDL_CreateRGBSurface(0, 16, 16, 16, 0xF000, 0x0F00,
|
|
0x00F0, 0x000F)
|
|
self.assertIsInstance(sf.contents, surface.SDL_Surface)
|
|
window = video.SDL_CreateWindow(b"Test", 10, 10, 10, 10, 0)
|
|
video.SDL_SetWindowIcon(window, sf)
|
|
|
|
# self.assertRaises((AttributeError, TypeError),
|
|
# video.SDL_SetWindowIcon, None, None)
|
|
# self.assertRaises((AttributeError, TypeError),
|
|
# video.SDL_SetWindowIcon, window, None)
|
|
# self.assertRaises((AttributeError, TypeError),
|
|
# video.SDL_SetWindowIcon, None, sf)
|
|
# self.assertRaises((AttributeError, TypeError),
|
|
# video.SDL_SetWindowIcon, window, "Test")
|
|
# self.assertRaises((AttributeError, TypeError),
|
|
# video.SDL_SetWindowIcon, window, 123456)
|
|
|
|
@unittest.skipIf(hasattr(sys, "pypy_version_info"),
|
|
"PyPy can't create proper py_object() values")
|
|
def test_SDL_GetSetWindowData(self):
|
|
# TODO: fix this
|
|
window = video.SDL_CreateWindow(b"Test", 10, 10, 10, 10, 0)
|
|
self.assertIsInstance(window.contents, video.SDL_Window)
|
|
values = {b"text": py_object("Teststring"),
|
|
b"object": py_object(self),
|
|
b"list": py_object([1, 2, 3, 4]),
|
|
b"tuple": py_object(("a", 1, self))
|
|
}
|
|
|
|
for k, v in values.items():
|
|
retval = video.SDL_GetWindowData(window, k)
|
|
self.assertFalse(retval)
|
|
video.SDL_SetWindowData(window, k, v)
|
|
retval = video.SDL_GetWindowData(window, k)
|
|
self.assertEqual(retval.contents.value, v.value)
|
|
video.SDL_DestroyWindow(window)
|
|
|
|
def test_SDL_GetSetWindowPosition(self):
|
|
window = video.SDL_CreateWindow(b"Test", 10, 10, 10, 10, 0)
|
|
px, py = c_int(), c_int()
|
|
video.SDL_GetWindowPosition(window, byref(px), byref(py))
|
|
self.assertEqual((px.value, py.value), (10, 10))
|
|
video.SDL_SetWindowPosition(window, 0, 0)
|
|
video.SDL_GetWindowPosition(window, byref(px), byref(py))
|
|
self.assertEqual((px.value, py.value), (0, 0))
|
|
video.SDL_SetWindowPosition(window, 600, 900)
|
|
video.SDL_GetWindowPosition(window, byref(px), byref(py))
|
|
self.assertEqual((px.value, py.value), (600, 900))
|
|
video.SDL_SetWindowPosition(window, -200, -10)
|
|
video.SDL_GetWindowPosition(window, byref(px), byref(py))
|
|
self.assertEqual((px.value, py.value), (-200, -10))
|
|
video.SDL_DestroyWindow(window)
|
|
|
|
def test_SDL_GetSetWindowSize(self):
|
|
flags = video.SDL_WINDOW_BORDERLESS
|
|
window = video.SDL_CreateWindow(b"Test", 10, 10, 10, 10, flags)
|
|
sx, sy = c_int(), c_int()
|
|
video.SDL_GetWindowSize(window, byref(sx), byref(sy))
|
|
self.assertEqual((sx.value, sy.value), (10, 10))
|
|
video.SDL_SetWindowSize(window, 1, 1)
|
|
video.SDL_GetWindowSize(window, byref(sx), byref(sy))
|
|
self.assertEqual((sx.value, sy.value), (1, 1))
|
|
video.SDL_SetWindowSize(window, 600, 900)
|
|
video.SDL_GetWindowSize(window, byref(sx), byref(sy))
|
|
self.assertEqual((sx.value, sy.value), (600, 900))
|
|
video.SDL_SetWindowSize(window, -200, -10)
|
|
video.SDL_GetWindowSize(window, byref(sx), byref(sy))
|
|
self.assertEqual((sx.value, sy.value), (600, 900))
|
|
video.SDL_DestroyWindow(window)
|
|
|
|
@interactive("Was the window shown?")
|
|
def test_SDL_ShowWindow(self):
|
|
window = video.SDL_CreateWindow(b"test_SDL_ShowWindow",
|
|
200, 200, 200, 200, 0)
|
|
video.SDL_ShowWindow(window)
|
|
doprint("""Please check, if a window with the title
|
|
'test_SDL_ShowWindow' is shown""")
|
|
video.SDL_DestroyWindow(window)
|
|
|
|
@interactive("Did the window vanish from your sight and pop up again?")
|
|
def test_SDL_HideWindow(self):
|
|
window = video.SDL_CreateWindow(b"test_SDL_HideWindow",
|
|
200, 200, 200, 200, 0)
|
|
video.SDL_ShowWindow(window)
|
|
doprint("""Please check, if a window with the title
|
|
'test_SDL_HideWindow' is shown""")
|
|
video.SDL_HideWindow(window)
|
|
doprint("Please check, that the window is not shown anymore")
|
|
video.SDL_ShowWindow(window)
|
|
doprint("Please check, if the window is shown again")
|
|
video.SDL_DestroyWindow(window)
|
|
|
|
@interactive("Did the window raise properly?")
|
|
def test_SDL_RaiseWindow(self):
|
|
window = video.SDL_CreateWindow(b"test_SDL_RaiseWindow",
|
|
200, 200, 200, 200, 0)
|
|
video.SDL_ShowWindow(window)
|
|
doprint("""Please check, that a window with the title
|
|
'test_SDL_RaiseWindow' is shown""")
|
|
doprint("Move another window on top of the window, so it is hidden")
|
|
video.SDL_RaiseWindow(window)
|
|
doprint("The window should be raised to the foreground now")
|
|
video.SDL_DestroyWindow(window)
|
|
|
|
@interactive("Was the window maximized?")
|
|
def test_SDL_MaximizeWindow(self):
|
|
window = video.SDL_CreateWindow(b"test_SDL_MaximizeWindow", 200, 200,
|
|
200, 200, video.SDL_WINDOW_RESIZABLE)
|
|
video.SDL_ShowWindow(window)
|
|
doprint("""Please check, that a window with the title
|
|
'test_SDL_MaximizeWindow' is shown""")
|
|
video.SDL_MaximizeWindow(window)
|
|
doprint("Please check, if the window was maximized properly")
|
|
video.SDL_DestroyWindow(window)
|
|
|
|
@interactive("Was the window minimized?")
|
|
def test_SDL_MinimizeWindow(self):
|
|
window = video.SDL_CreateWindow(b"test_SDL_MinimizeWindow", 200, 200,
|
|
200, 200, 0)
|
|
video.SDL_ShowWindow(window)
|
|
doprint("""Please check, that a window with the title
|
|
'test_SDL_MinimizeWindow' is shown""")
|
|
video.SDL_MinimizeWindow(window)
|
|
doprint("Please check, if the window was minimized properly")
|
|
video.SDL_DestroyWindow(window)
|
|
|
|
@interactive("Was the window maximized and restored properly?")
|
|
def test_SDL_RestoreWindow(self):
|
|
window = video.SDL_CreateWindow(b"test_SDL_RestoreWindow", 200, 200,
|
|
200, 200, video.SDL_WINDOW_RESIZABLE)
|
|
video.SDL_ShowWindow(window)
|
|
doprint("""Please check, that a window with the title
|
|
'test_SDL_RestoreWindow' is shown""")
|
|
video.SDL_MaximizeWindow(window)
|
|
doprint("Please check, if the window was maximized properly")
|
|
video.SDL_RestoreWindow(window)
|
|
doprint("Please check, if the window was restored properly")
|
|
video.SDL_DestroyWindow(window)
|
|
|
|
def test_SDL_SetWindowFullscreen(self):
|
|
# TODO: HIDDEN avoids flickering, but is this really a sufficient test?
|
|
flags = (video.SDL_WINDOW_BORDERLESS | video.SDL_WINDOW_HIDDEN,
|
|
video.SDL_WINDOW_BORDERLESS | video.SDL_WINDOW_HIDDEN,
|
|
video.SDL_WINDOW_RESIZABLE | video.SDL_WINDOW_MINIMIZED |
|
|
video.SDL_WINDOW_HIDDEN)
|
|
for flag in flags:
|
|
window = video.SDL_CreateWindow(b"Test", 0, 0, 1024, 768, flag)
|
|
video.SDL_SetWindowFullscreen(window, True)
|
|
flags = video.SDL_GetWindowFlags(window)
|
|
self.assertEqual(flags & video.SDL_WINDOW_FULLSCREEN,
|
|
video.SDL_WINDOW_FULLSCREEN)
|
|
video.SDL_SetWindowFullscreen(window, False)
|
|
flags = video.SDL_GetWindowFlags(window)
|
|
self.assertNotEqual(flags & video.SDL_WINDOW_FULLSCREEN,
|
|
video.SDL_WINDOW_FULLSCREEN)
|
|
video.SDL_DestroyWindow(window)
|
|
|
|
def test_SDL_GetWindowSurface(self):
|
|
flags = (video.SDL_WINDOW_BORDERLESS,
|
|
video.SDL_WINDOW_BORDERLESS | video.SDL_WINDOW_HIDDEN,
|
|
video.SDL_WINDOW_RESIZABLE | video.SDL_WINDOW_MINIMIZED)
|
|
for flag in flags:
|
|
window = video.SDL_CreateWindow(b"Test", 200, 200, 200, 200, flag)
|
|
sf = video.SDL_GetWindowSurface(window)
|
|
self.assertIsInstance(sf.contents, surface.SDL_Surface)
|
|
video.SDL_DestroyWindow(window)
|
|
# self.assertRaises(sdl.SDLError, video.SDL_GetWindowSurface,
|
|
# window)
|
|
|
|
def test_SDL_UpdateWindowSurface(self):
|
|
flags = (video.SDL_WINDOW_BORDERLESS,
|
|
video.SDL_WINDOW_BORDERLESS | video.SDL_WINDOW_HIDDEN,
|
|
video.SDL_WINDOW_RESIZABLE | video.SDL_WINDOW_MINIMIZED)
|
|
for flag in flags:
|
|
window = video.SDL_CreateWindow(b"Test", 200, 200, 200, 200, flag)
|
|
video.SDL_UpdateWindowSurface(window)
|
|
video.SDL_DestroyWindow(window)
|
|
|
|
def test_SDL_UpdateWindowSurfaceRects(self):
|
|
rectlist = (rect.SDL_Rect * 4)(rect.SDL_Rect(),
|
|
rect.SDL_Rect(10, 10, 10, 10),
|
|
rect.SDL_Rect(0, 0, 5, 4),
|
|
rect.SDL_Rect(-5, -5, 6, 2))
|
|
rptr = cast(rectlist, POINTER(rect.SDL_Rect))
|
|
|
|
flags = (video.SDL_WINDOW_BORDERLESS,
|
|
video.SDL_WINDOW_BORDERLESS | video.SDL_WINDOW_HIDDEN,
|
|
video.SDL_WINDOW_RESIZABLE | video.SDL_WINDOW_MINIMIZED)
|
|
for flag in flags:
|
|
window = video.SDL_CreateWindow(b"Test", 200, 200, 200, 200, flag)
|
|
# self.assertRaises(sdl.SDLError,
|
|
# video.SDL_UpdateWindowSurfaceRects,
|
|
# window, rectlist)
|
|
sf = surface.SDL_Surface()
|
|
video.SDL_GetWindowSurface(window, byref(sf))
|
|
ret = video.SDL_UpdateWindowSurfaceRects(window, rptr, 4)
|
|
self.assertEqual(ret, 0)
|
|
video.SDL_DestroyWindow(window)
|
|
|
|
@unittest.skip("SDL_GetWindowGrab fails right now")
|
|
def test_SDL_GetSetWindowGrab(self):
|
|
flags = (video.SDL_WINDOW_BORDERLESS,
|
|
video.SDL_WINDOW_BORDERLESS | video.SDL_WINDOW_HIDDEN,
|
|
video.SDL_WINDOW_RESIZABLE | video.SDL_WINDOW_MINIMIZED)
|
|
for flag in flags:
|
|
window = video.SDL_CreateWindow(b"Test", 200, 200, 200, 200, flag)
|
|
self.assertEqual(video.SDL_GetWindowGrab(window), SDL_FALSE)
|
|
video.SDL_SetWindowGrab(window, SDL_TRUE)
|
|
self.assertEqual(video.SDL_GetWindowGrab(window), SDL_TRUE)
|
|
video.SDL_SetWindowGrab(window, SDL_FALSE)
|
|
self.assertEqual(video.SDL_GetWindowGrab(window), SDL_FALSE)
|
|
|
|
@unittest.skip("not implemented")
|
|
def test_SDL_GetGrabbedWindow(self):
|
|
pass
|
|
|
|
def test_SDL_GetSetWindowBrightness(self):
|
|
flags = (video.SDL_WINDOW_BORDERLESS,
|
|
video.SDL_WINDOW_BORDERLESS | video.SDL_WINDOW_HIDDEN,
|
|
video.SDL_WINDOW_RESIZABLE | video.SDL_WINDOW_MINIMIZED)
|
|
for flag in flags:
|
|
window = video.SDL_CreateWindow(b"Test", 200, 200, 200, 200, flag)
|
|
orig = video.SDL_GetWindowBrightness(window)
|
|
self.assertIsInstance(orig, float)
|
|
# Go from 0.0, 0.1 ... to 3.0
|
|
gammas = (x * 0.1 for x in range(0, 20))
|
|
count = 0
|
|
for b in gammas:
|
|
ret = video.SDL_SetWindowBrightness(window, b)
|
|
if ret == 0:
|
|
val = video.SDL_GetWindowBrightness(window)
|
|
self.assertAlmostEqual(val, b)
|
|
count += 1
|
|
# At least one gamma(1.0) must have worked.
|
|
self.assertTrue(count > 0)
|
|
|
|
@unittest.skip("not implemented")
|
|
def test_SDL_SetWindowGammaRamp(self):
|
|
pass
|
|
|
|
@unittest.skip("not implemented")
|
|
def test_SDL_GetWindowGammaRamp(self):
|
|
pass
|
|
|
|
@unittest.skip("not implemented")
|
|
def test_SDL_SetWindowHitTest(self):
|
|
pass
|
|
|
|
def test_SDL_GL_LoadUnloadLibrary(self):
|
|
# Try the default library
|
|
self.assertEqual(video.SDL_GL_LoadLibrary(None), 0)
|
|
video.SDL_GL_UnloadLibrary()
|
|
|
|
if has_opengl_lib():
|
|
fpath = get_opengl_path().encode("utf-8")
|
|
self.assertEqual(video.SDL_GL_LoadLibrary(fpath), 0)
|
|
video.SDL_GL_UnloadLibrary()
|
|
|
|
#self.assertRaises(sdl.SDLError, video.SDL_GL_LoadLibrary, "Test")
|
|
#self.assertRaises(sdl.SDLError, video.SDL_GL_LoadLibrary, False)
|
|
#self.assertRaises(sdl.SDLError, video.SDL_GL_LoadLibrary, 0)
|
|
|
|
def test_SDL_GL_GetProcAddress(self):
|
|
procaddr = video.SDL_GL_GetProcAddress(b"glGetString")
|
|
self.assertIsNone(procaddr)
|
|
|
|
self.assertEqual(video.SDL_GL_LoadLibrary(None), 0)
|
|
|
|
# Behaviour is undefined as long as there is no window and context.
|
|
window = video.SDL_CreateWindow(b"OpenGL", 10, 10, 10, 10,
|
|
video.SDL_WINDOW_OPENGL)
|
|
|
|
ctx = video.SDL_GL_CreateContext(window)
|
|
|
|
procaddr = video.SDL_GL_GetProcAddress(b"glGetString")
|
|
self.assertTrue(procaddr is not None and int(procaddr) != 0)
|
|
|
|
video.SDL_GL_DeleteContext(ctx)
|
|
video.SDL_DestroyWindow(window)
|
|
video.SDL_GL_UnloadLibrary()
|
|
|
|
procaddr = video.SDL_GL_GetProcAddress(b"glGetString")
|
|
self.assertIsNone(procaddr)
|
|
|
|
def test_SDL_GL_ExtensionSupported(self):
|
|
self.assertFalse(video.SDL_GL_ExtensionSupported(b"GL_EXT_bgra"))
|
|
|
|
self.assertEqual(video.SDL_GL_LoadLibrary(None), 0)
|
|
window = video.SDL_CreateWindow(b"OpenGL", 10, 10, 10, 10,
|
|
video.SDL_WINDOW_OPENGL)
|
|
|
|
ctx = video.SDL_GL_CreateContext(window)
|
|
|
|
self.assertTrue(video.SDL_GL_ExtensionSupported(b"GL_EXT_bgra"))
|
|
|
|
video.SDL_GL_DeleteContext(ctx)
|
|
video.SDL_DestroyWindow(window)
|
|
video.SDL_GL_UnloadLibrary()
|
|
|
|
self.assertFalse(video.SDL_GL_ExtensionSupported(b"GL_EXT_bgra"))
|
|
|
|
def test_SDL_GL_GetSetAttribute(self):
|
|
# self.assertRaises(sdl.SDLError, video.SDL_GL_GetAttribute,
|
|
# video.SDL_GL_DEPTH_SIZE)
|
|
# self.assertRaises(sdl.SDLError, video.SDL_GL_SetAttribute,
|
|
# 1455, 24)
|
|
|
|
self.assertEqual(video.SDL_GL_LoadLibrary(None), 0)
|
|
|
|
window = video.SDL_CreateWindow(b"OpenGL", 10, 10, 10, 10,
|
|
video.SDL_WINDOW_OPENGL)
|
|
|
|
ctx = video.SDL_GL_CreateContext(window)
|
|
|
|
depth = c_int()
|
|
video.SDL_GL_GetAttribute(video.SDL_GL_DEPTH_SIZE, byref(depth))
|
|
|
|
video.SDL_GL_DeleteContext(ctx)
|
|
video.SDL_DestroyWindow(window)
|
|
|
|
newdepth = 24
|
|
if depth == 8:
|
|
newdepth = 16
|
|
elif depth == 16:
|
|
newdepth = 24
|
|
elif depth == 24:
|
|
newdepth = 16
|
|
video.SDL_GL_SetAttribute(video.SDL_GL_DEPTH_SIZE, newdepth)
|
|
|
|
window = video.SDL_CreateWindow(b"OpenGL", 10, 10, 10, 10,
|
|
video.SDL_WINDOW_OPENGL)
|
|
|
|
ctx = video.SDL_GL_CreateContext(window)
|
|
|
|
val = c_int()
|
|
video.SDL_GL_GetAttribute(video.SDL_GL_DEPTH_SIZE, byref(val))
|
|
self.assertNotEqual(depth, val)
|
|
self.assertEqual(val.value, newdepth)
|
|
|
|
video.SDL_GL_DeleteContext(ctx)
|
|
video.SDL_DestroyWindow(window)
|
|
video.SDL_GL_UnloadLibrary()
|
|
|
|
def test_SDL_GL_CreateDeleteContext(self):
|
|
# self.assertRaises((AttributeError, TypeError),
|
|
# video.SDL_GL_CreateContext, None)
|
|
# self.assertRaises((AttributeError, TypeError),
|
|
# video.SDL_GL_CreateContext, "Test")
|
|
# self.assertRaises((AttributeError, TypeError),
|
|
# video.SDL_GL_CreateContext, 1234)
|
|
|
|
window = video.SDL_CreateWindow(b"No OpenGL", 10, 10, 10, 10,
|
|
video.SDL_WINDOW_BORDERLESS)
|
|
|
|
#self.assertRaises(sdl.SDLError, video.SDL_GL_CreateContext, window)
|
|
video.SDL_DestroyWindow(window)
|
|
|
|
self.assertEqual(video.SDL_GL_LoadLibrary(None), 0)
|
|
window = video.SDL_CreateWindow(b"OpenGL", 10, 10, 10, 10,
|
|
video.SDL_WINDOW_OPENGL)
|
|
|
|
ctx = video.SDL_GL_CreateContext(window)
|
|
|
|
video.SDL_GL_DeleteContext(ctx)
|
|
video.SDL_DestroyWindow(window)
|
|
|
|
window = video.SDL_CreateWindow(b"OpenGL", 10, 10, 10, 10,
|
|
video.SDL_WINDOW_OPENGL)
|
|
|
|
ctx = video.SDL_GL_CreateContext(window)
|
|
video.SDL_DestroyWindow(window)
|
|
video.SDL_GL_DeleteContext(ctx)
|
|
|
|
video.SDL_GL_UnloadLibrary()
|
|
|
|
def test_SDL_GL_MakeCurrent(self):
|
|
self.assertEqual(video.SDL_GL_LoadLibrary(None), 0)
|
|
|
|
# self.assertRaises((AttributeError, TypeError),
|
|
# video.SDL_GL_MakeCurrent, None, None)
|
|
|
|
window = video.SDL_CreateWindow(b"No OpenGL", 10, 10, 10, 10,
|
|
video.SDL_WINDOW_BORDERLESS)
|
|
|
|
#self.assertRaises(sdl.SDLError, video.SDL_GL_CreateContext, window)
|
|
video.SDL_DestroyWindow(window)
|
|
|
|
# self.assertRaises((AttributeError, TypeError),
|
|
# video.SDL_GL_MakeCurrent, None, None)
|
|
|
|
video.SDL_GL_UnloadLibrary()
|
|
|
|
def test_SDL_GL_GetSetSwapInterval(self):
|
|
#self.assertRaises(ValueError, video.SDL_GL_SetSwapInterval, None)
|
|
#self.assertRaises(ValueError, video.SDL_GL_SetSwapInterval, "Test")
|
|
#self.assertRaises(ValueError, video.SDL_GL_SetSwapInterval, 1234)
|
|
|
|
# No current OpenGL context yet.
|
|
# Might crash on certain platforms, since the internal state of
|
|
# SDL2 does not support calling GL functions without having a
|
|
# GL library loaded.
|
|
# self.assertRaises(sdl.SDLError, video.SDL_GL_SetSwapInterval, 1)
|
|
# self.assertRaises(sdl.SDLError, video.SDL_GL_SetSwapInterval, 0)
|
|
|
|
self.assertEqual(video.SDL_GL_LoadLibrary(None), 0)
|
|
window = video.SDL_CreateWindow(b"OpenGL", 10, 10, 10, 10,
|
|
video.SDL_WINDOW_OPENGL)
|
|
ctx = video.SDL_GL_CreateContext(window)
|
|
video.SDL_GL_MakeCurrent(window, ctx)
|
|
|
|
video.SDL_GL_SetSwapInterval(0)
|
|
self.assertEqual(video.SDL_GL_GetSwapInterval(), 0)
|
|
video.SDL_GL_SetSwapInterval(1)
|
|
self.assertEqual(video.SDL_GL_GetSwapInterval(), 1)
|
|
|
|
video.SDL_GL_DeleteContext(ctx)
|
|
video.SDL_DestroyWindow(window)
|
|
video.SDL_GL_UnloadLibrary()
|
|
|
|
def test_SDL_GL_SwapWindow(self):
|
|
self.assertEqual(video.SDL_GL_LoadLibrary(None), 0)
|
|
window = video.SDL_CreateWindow(b"OpenGL", 10, 10, 10, 10,
|
|
video.SDL_WINDOW_OPENGL)
|
|
ctx = video.SDL_GL_CreateContext(window)
|
|
video.SDL_GL_MakeCurrent(window, ctx)
|
|
video.SDL_GL_SwapWindow(window)
|
|
video.SDL_GL_SwapWindow(window)
|
|
video.SDL_GL_SwapWindow(window)
|
|
video.SDL_GL_SwapWindow(window)
|
|
video.SDL_GL_DeleteContext(ctx)
|
|
video.SDL_DestroyWindow(window)
|
|
video.SDL_GL_UnloadLibrary()
|
|
|
|
@unittest.skip("not implemented")
|
|
def test_SDL_GL_ResetAttributes(self):
|
|
pass
|
|
|
|
def test_SDL_GetDisplayDPI(self):
|
|
numdisplays = video.SDL_GetNumVideoDisplays()
|
|
for index in range(numdisplays):
|
|
ddpi, hdpi, vdpi = c_float(), c_float(), c_float()
|
|
ret = video.SDL_GetDisplayDPI(index, byref(ddpi), byref(hdpi),
|
|
byref(vdpi))
|
|
self.assertEqual(ret, 0)
|
|
self.assertGreaterEqual(ddpi.value, 96.0)
|
|
self.assertGreaterEqual(hdpi.value, 96.0)
|
|
self.assertGreaterEqual(vdpi.value, 96.0)
|
|
|
|
def test_SDL_SetWindowResizable(self):
|
|
window = video.SDL_CreateWindow(b"Resizable", 10, 10, 10, 10,
|
|
video.SDL_WINDOW_RESIZABLE)
|
|
flags = video.SDL_GetWindowFlags(window)
|
|
self.assertEqual(flags & video.SDL_WINDOW_RESIZABLE,
|
|
video.SDL_WINDOW_RESIZABLE)
|
|
video.SDL_SetWindowResizable(window, SDL_FALSE)
|
|
flags = video.SDL_GetWindowFlags(window)
|
|
self.assertNotEqual(flags & video.SDL_WINDOW_RESIZABLE,
|
|
video.SDL_WINDOW_RESIZABLE)
|
|
video.SDL_SetWindowResizable(window, SDL_TRUE)
|
|
flags = video.SDL_GetWindowFlags(window)
|
|
self.assertEqual(flags & video.SDL_WINDOW_RESIZABLE,
|
|
video.SDL_WINDOW_RESIZABLE)
|
|
video.SDL_DestroyWindow(window)
|
|
|
|
def test_SDL_GetSetWindowOpacity(self):
|
|
window = video.SDL_CreateWindow(b"Opacity", 10, 10, 10, 10, 0)
|
|
opacity = c_float()
|
|
ret = video.SDL_GetWindowOpacity(window, byref(opacity))
|
|
self.assertEqual(ret, 0)
|
|
self.assertEqual(opacity.value, 1.0)
|
|
ret = video.SDL_SetWindowOpacity(window, 0.0)
|
|
self.assertEqual(ret, 0)
|
|
ret = video.SDL_GetWindowOpacity(window, byref(opacity))
|
|
self.assertEqual(ret, 0)
|
|
self.assertEqual(opacity.value, 0.0)
|
|
ret = video.SDL_SetWindowOpacity(window, 0.653)
|
|
self.assertEqual(ret, 0)
|
|
ret = video.SDL_GetWindowOpacity(window, byref(opacity))
|
|
self.assertEqual(ret, 0)
|
|
self.assertAlmostEqual(opacity.value, 0.653, 2)
|
|
video.SDL_DestroyWindow(window)
|
|
|
|
def test_SDL_GetDisplayUsableBounds(self):
|
|
numdisplays = video.SDL_GetNumVideoDisplays()
|
|
for index in range(numdisplays):
|
|
bounds = rect.SDL_Rect()
|
|
ret = video.SDL_GetDisplayUsableBounds(index, byref(bounds))
|
|
self.assertEqual(ret, 0)
|
|
self.assertFalse(rect.SDL_RectEmpty(bounds))
|
|
|
|
def test_SDL_GetWindowsBordersSize(self):
|
|
window = video.SDL_CreateWindow(b"Borders", 10, 10, 10, 10, 0)
|
|
l, r, t, b = c_int(), c_int(), c_int(), c_int()
|
|
ret = video.SDL_GetWindowBordersSize(window, byref(t), byref(l),
|
|
byref(b), byref(r))
|
|
if sys.platform in ("win32", "cygwin", "darwin"):
|
|
self.assertEqual(ret, -1)
|
|
self.assertEqual(t.value, 0)
|
|
self.assertEqual(l.value, 0)
|
|
self.assertEqual(b.value, 0)
|
|
self.assertEqual(r.value, 0)
|
|
else:
|
|
self.assertEqual(ret, 0)
|
|
self.assertNotEqual(t.value, 0)
|
|
self.assertNotEqual(l.value, 0)
|
|
self.assertNotEqual(b.value, 0)
|
|
self.assertNotEqual(r.value, 0)
|
|
video.SDL_DestroyWindow(window)
|
|
window = video.SDL_CreateWindow(b"No Borders", 10, 10, 10, 10,
|
|
video.SDL_WINDOW_BORDERLESS)
|
|
ret = video.SDL_GetWindowBordersSize(window, byref(t), byref(l),
|
|
byref(b), byref(r))
|
|
if sys.platform not in ("win32", "cygwin", "darwin"):
|
|
self.assertEqual(ret, 0)
|
|
self.assertEqual(t.value, 0)
|
|
self.assertEqual(l.value, 0)
|
|
self.assertEqual(b.value, 0)
|
|
self.assertEqual(r.value, 0)
|
|
video.SDL_DestroyWindow(window)
|
|
|
|
@unittest.skip("not implemented")
|
|
def test_SDL_SetWindowModalFor(self):
|
|
pass
|
|
|
|
@unittest.skip("not implemented")
|
|
def test_SDL_SetWindowInputFocus(self):
|
|
pass
|
|
|
|
if __name__ == '__main__':
|
|
sys.exit(unittest.main())
|