def test_SDL_GL_CreateDeleteContext(self):
if video.SDL_GetCurrentVideoDriver() == b"dummy":
pytest.skip("dummy video driver does not support GL loading")
# 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)
assert video.SDL_GL_LoadLibrary(None) == 0, SDL_GetError()
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_GetSetSwapInterval(self):
if video.SDL_GetCurrentVideoDriver() == b"dummy":
pytest.skip("dummy video driver does not support GL loading")
#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)
assert video.SDL_GL_LoadLibrary(None) == 0, SDL_GetError()
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)
ret = video.SDL_GL_SetSwapInterval(0)
if ret == 0:
assert video.SDL_GL_GetSwapInterval() == 0
ret = video.SDL_GL_SetSwapInterval(1)
if ret == 0:
assert video.SDL_GL_GetSwapInterval() == 1
video.SDL_GL_DeleteContext(ctx)
video.SDL_DestroyWindow(window)
video.SDL_GL_UnloadLibrary()
def test_SDL_GetWindowsBordersSize(self):
if video.SDL_GetCurrentVideoDriver() == b"dummy":
pytest.skip(
"dummy video driver does not support the window border size")
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 ("cygwin", "darwin"):
assert ret == -1
assert t.value == 0
assert l.value == 0
assert b.value == 0
assert r.value == 0
else:
assert ret == 0
assert t.value != 0
assert l.value != 0
assert b.value != 0
assert 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 ("cygwin", "darwin"):
assert ret == 0
assert t.value == 0
assert l.value == 0
assert b.value == 0
assert r.value == 0
video.SDL_DestroyWindow(window)
def test_SDL_GetWindowsBordersSize(self):
if video.SDL_GetCurrentVideoDriver() == b"dummy":
self.skipTest(
"dummy video driver does not support the window border size")
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)
def setUpClass(cls):
cls._RENDERFLAGS = render.SDL_RENDERER_ACCELERATED
SDL_Init(SDL_INIT_EVERYTHING)
driver = video.SDL_GetCurrentVideoDriver()
if driver is None:
raise unittest.SkipTest('Video subsystem not supported')
if driver == b"dummy":
cls._RENDERFLAGS = render.SDL_RENDERER_SOFTWARE
def test_SDL_CreateShapedWindow(self):
if video.SDL_GetCurrentVideoDriver() == b"dummy":
self.skipTest("dummy video driver does not support shaped windows")
flags = (video.SDL_WINDOW_HIDDEN, )
for flag in flags:
window = shape.SDL_CreateShapedWindow(b"Test", 10, 10, 10, 10,
flag)
self.assertIsInstance(window.contents, video.SDL_Window)
video.SDL_DestroyWindow(window)
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
assert found, "Current video driver not found"
def test_SDL_GL_LoadUnloadLibrary(self):
if video.SDL_GetCurrentVideoDriver() == b"dummy":
pytest.skip("dummy video driver does not support GL loading")
# Try the default library
assert video.SDL_GL_LoadLibrary(None) == 0, SDL_GetError()
video.SDL_GL_UnloadLibrary()
if has_opengl_lib():
fpath = get_opengl_path().encode("utf-8")
assert video.SDL_GL_LoadLibrary(fpath) == 0, SDL_GetError()
video.SDL_GL_UnloadLibrary()
def test_SDL_GetDisplayDPI(self):
if video.SDL_GetCurrentVideoDriver() == b"dummy":
self.skipTest("dummy video driver does not support display DPI")
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, SDL_GetError())
self.assertGreaterEqual(ddpi.value, 96.0)
self.assertGreaterEqual(hdpi.value, 96.0)
self.assertGreaterEqual(vdpi.value, 96.0)
def test_SDL_GetDisplayDPI(self):
if video.SDL_GetCurrentVideoDriver() == b"dummy":
pytest.skip("dummy video driver does not support display DPI")
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))
assert ret == 0, SDL_GetError()
assert ddpi.value >= 96.0
assert hdpi.value >= 96.0
assert vdpi.value >= 96.0
def test_SDL_GetShapedWindowMode(self):
if video.SDL_GetCurrentVideoDriver() == b"dummy":
self.skipTest("dummy video driver does not support shaped windows")
flags = (video.SDL_WINDOW_HIDDEN, )
for flag in flags:
window = shape.SDL_CreateShapedWindow(b"Test", 10, 10, 10, 10,
flag)
self.assertIsInstance(window.contents, video.SDL_Window)
mode = shape.SDL_WindowShapeMode()
ret = shape.SDL_GetShapedWindowMode(window, ctypes.byref(mode))
self.assertEqual(ret, 0)
video.SDL_DestroyWindow(window)
def test_SDL_SetWindowResizable(self):
if video.SDL_GetCurrentVideoDriver() == b"dummy":
pytest.skip("dummy video driver does not support resizable flags")
window = video.SDL_CreateWindow(b"Resizable", 10, 10, 10, 10,
video.SDL_WINDOW_RESIZABLE)
flags = video.SDL_GetWindowFlags(window)
assert flags & video.SDL_WINDOW_RESIZABLE == video.SDL_WINDOW_RESIZABLE
video.SDL_SetWindowResizable(window, SDL_FALSE)
flags = video.SDL_GetWindowFlags(window)
assert flags & video.SDL_WINDOW_RESIZABLE != video.SDL_WINDOW_RESIZABLE
video.SDL_SetWindowResizable(window, SDL_TRUE)
flags = video.SDL_GetWindowFlags(window)
assert flags & video.SDL_WINDOW_RESIZABLE == video.SDL_WINDOW_RESIZABLE
video.SDL_DestroyWindow(window)
def test_SDL_GL_SwapWindow(self):
if video.SDL_GetCurrentVideoDriver() == b"dummy":
pytest.skip("dummy video driver does not support GL loading")
assert video.SDL_GL_LoadLibrary(None) == 0, SDL_GetError()
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()
def test_SDL_GetClosestDisplayMode(self):
if video.SDL_GetCurrentVideoDriver() == b"dummy":
pytest.skip(
"dummy video driver does not support closest display modes")
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)
assert 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))
assert closest == dmode, SDL_GetError()
def test_SDL_IsShapedWindow(self):
if video.SDL_GetCurrentVideoDriver() == b"dummy":
pytest.skip("dummy video driver does not support shaped windows")
flags = (video.SDL_WINDOW_HIDDEN, )
for flag in flags:
window = shape.SDL_CreateShapedWindow(b"Test", 10, 10, 10, 10,
flag)
assert isinstance(window.contents, video.SDL_Window)
val = shape.SDL_IsShapedWindow(window)
assert val
video.SDL_DestroyWindow(window)
window = video.SDL_CreateWindow(b"Test", 10, 10, 10, 10, flag)
assert isinstance(window.contents, video.SDL_Window)
val = shape.SDL_IsShapedWindow(window)
assert not val
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))
assert ret == 0
assert opacity.value == 1.0
if video.SDL_GetCurrentVideoDriver() != b"dummy":
ret = video.SDL_SetWindowOpacity(window, 0.0)
assert ret == 0, SDL_GetError()
ret = video.SDL_GetWindowOpacity(window, byref(opacity))
assert ret == 0
assert opacity.value == 0.0
ret = video.SDL_SetWindowOpacity(window, 0.653)
assert ret == 0
ret = video.SDL_GetWindowOpacity(window, byref(opacity))
assert ret == 0
assert round(abs(opacity.value - 0.653), 2) == 0
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)
if video.SDL_GetCurrentVideoDriver() != b"dummy":
ret = video.SDL_SetWindowOpacity(window, 0.0)
self.assertEqual(ret, 0, SDL_GetError())
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_GL_GetSetAttribute(self):
if video.SDL_GetCurrentVideoDriver() == b"dummy":
pytest.skip("dummy video driver does not support GL loading")
# self.assertRaises(sdl.SDLError, video.SDL_GL_GetAttribute,
# video.SDL_GL_DEPTH_SIZE)
# self.assertRaises(sdl.SDLError, video.SDL_GL_SetAttribute,
# 1455, 24)
assert video.SDL_GL_LoadLibrary(None) == 0, SDL_GetError()
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))
assert depth != val
assert val.value >= newdepth
# self.assertEqual(val.value, newdepth)
video.SDL_GL_DeleteContext(ctx)
video.SDL_DestroyWindow(window)
video.SDL_GL_UnloadLibrary()
def test_SDL_SetWindowShape(self):
if video.SDL_GetCurrentVideoDriver() == b"dummy":
self.skipTest("dummy video driver does not support shaped windows")
sf = surface.SDL_CreateRGBSurface(0, 10, 10, 32, 0xFF000000,
0x00FF0000, 0x0000FF00, 0x000000FF)
mode = shape.SDL_WindowShapeMode()
mode.mode = shape.ShapeModeDefault
mode.parameters = shape.SDL_WindowShapeParams()
mode.parameters.binarizationCutoff = 1
flags = (video.SDL_WINDOW_HIDDEN, )
for flag in flags:
# TODO: find out, how shaping is supposed to work :-)
# window = shape.SDL_CreateShapedWindow(b"Test", 10, 10, 10, 10,
# flag)
# self.assertIsInstance(window, video.SDL_Window)
# self.assertTrue(shape.SDL_IsShapedWindow(window))
# self.assertRaises(TypeError, shape.SDL_SetWindowShape,
# None, None, None)
# self.assertRaises(TypeError, shape.SDL_SetWindowShape,
# window, None, None)
# self.assertRaises(TypeError, shape.SDL_SetWindowShape,
# window, sf, None)
# self.assertRaises(TypeError, shape.SDL_SetWindowShape,
# "Test", sf, mode)
# self.assertRaises(TypeError, shape.SDL_SetWindowShape,
# window, 12345, mode)
# self.assertRaises(TypeError, shape.SDL_SetWindowShape,
# window, sf, "Test")
# shape.SDL_SetWindowShape(window, sf, mode)
# wmode = shape.SDL_GetShapedWindowMode(window)
# self.assertEqual(wmode.mode, mode.mode)
# self.assertEqual(wmode.parameters.binarizationCutoff,
# mode.parameters.binarizationCutoff)
# video.SDL_DestroyWindow(window)
window = video.SDL_CreateWindow(b"Test", 10, 10, 10, 10, flag)
self.assertIsInstance(window.contents, video.SDL_Window)
#self.assertRaises(sdl.SDLError, shape.SDL_SetWindowShape,
# window, sf, mode)
video.SDL_DestroyWindow(window)
surface.SDL_FreeSurface(sf)
def test_SDL_GL_MakeCurrent(self):
if video.SDL_GetCurrentVideoDriver() == b"dummy":
self.skipTest("dummy video driver does not support GL loading")
self.assertEqual(video.SDL_GL_LoadLibrary(None), 0, SDL_GetError())
# 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_ExtensionSupported(self):
if video.SDL_GetCurrentVideoDriver() == b"dummy":
self.skipTest("dummy video driver does not support GL loading")
self.assertFalse(video.SDL_GL_ExtensionSupported(b"GL_EXT_bgra"))
self.assertEqual(video.SDL_GL_LoadLibrary(None), 0, SDL_GetError())
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_GetSetWindowBrightness(self):
if video.SDL_GetCurrentVideoDriver() == b"dummy":
self.skipTest("dummy video driver does not support brightness")
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 1.0
gammas = (x * 0.1 for x in range(0, 10))
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
self.assertTrue(count > 0)
video.SDL_DestroyWindow(window)
def test_SDL_GetSetWindowBrightness(self):
if video.SDL_GetCurrentVideoDriver() == b"dummy":
pytest.skip("dummy video driver does not support brightness")
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)
assert isinstance(orig, float)
# Go from 0.0, 0.1 ... to 1.0
gammas = (x * 0.1 for x in range(0, 10))
count = 0
for b in gammas:
ret = video.SDL_SetWindowBrightness(window, b)
if ret == 0:
val = video.SDL_GetWindowBrightness(window)
assert round(abs(val - b), 7) == 0
count += 1
assert count > 0
video.SDL_DestroyWindow(window)
def test_SDL_GetWindowWMInfo(self):
if video.SDL_GetCurrentVideoDriver() == b"dummy":
pytest.skip("cannot retrieve WM information for the dummy video driver")
window = video.SDL_CreateWindow(b"Test", 10, 10, 10, 10,
video.SDL_WINDOW_HIDDEN)
wminfo = syswm.SDL_SysWMinfo()
version.SDL_VERSION(wminfo.version)
ret = syswm.SDL_GetWindowWMInfo(window, ctypes.byref(wminfo))
assert ret == SDL_TRUE
if sys.platform in ("win32", "cygwin"):
assert wminfo.subsystem == syswm.SDL_SYSWM_WINDOWS
elif sys.platform.startswith("linux"):
assert wminfo.subsystem in \
(syswm.SDL_SYSWM_X11, syswm.SDL_SYSWM_DIRECTFB)
elif sys.platform.startswith("freebsd"):
assert wminfo.subsystem in \
(syswm.SDL_SYSWM_X11, syswm.SDL_SYSWM_DIRECTFB)
elif sys.platform.startswith("darwin"):
assert wminfo.subsystem == syswm.SDL_SYSWM_COCOA
video.SDL_DestroyWindow(window)
def test_SDL_GL_GetProcAddress(self):
if video.SDL_GetCurrentVideoDriver() == b"dummy":
pytest.skip("dummy video driver does not support GL loading")
procaddr = video.SDL_GL_GetProcAddress(b"glGetString")
assert procaddr is None
assert video.SDL_GL_LoadLibrary(None) == 0, SDL_GetError()
# 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")
assert 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")
assert procaddr is None
def setup_class(cls):
SDL_Init(SDL_INIT_EVERYTHING)
if video.SDL_GetCurrentVideoDriver() is None:
raise pytest.skip('Video subsystem not supported')
def setUpClass(cls):
cls._RENDERFLAGS = render.SDL_RENDERER_ACCELERATED
SDL_Init(SDL_INIT_EVERYTHING)
driver = video.SDL_GetCurrentVideoDriver()
if driver == b"dummy":
cls._RENDERFLAGS = render.SDL_RENDERER_SOFTWARE
def setUpClass(cls):
SDL_Init(SDL_INIT_EVERYTHING)
if video.SDL_GetCurrentVideoDriver() is None:
raise unittest.SkipTest('Video subsystem not supported')
def test_SDL_GL_ResetAttributes(self):
if video.SDL_GetCurrentVideoDriver() == b"dummy":
pytest.skip("dummy video driver does not support GL loading")
pass
