def test_query_texture(self):
window = video.create_window("Test", 10, 10, 10, 10,
video.SDL_WINDOW_HIDDEN)
self.assertIsInstance(window, video.SDL_Window)
renderer = render.create_renderer(window, -1,
render.SDL_RENDERER_SOFTWARE)
self.assertIsInstance(renderer, render.SDL_Renderer)
formats = (pixels.SDL_PIXELFORMAT_ARGB8888,
pixels.SDL_PIXELFORMAT_RGB555,
pixels.SDL_PIXELFORMAT_RGBA4444,
pixels.SDL_PIXELFORMAT_ARGB2101010,
pixels.SDL_PIXELFORMAT_YUY2
)
access = (render.SDL_TEXTUREACCESS_STATIC,
render.SDL_TEXTUREACCESS_STREAMING,
render.SDL_TEXTUREACCESS_TARGET)
for fmt in formats:
for acc in access:
for w in range(1, 300, 5):
for h in range(1, 300, 5):
tex = render.create_texture(renderer, fmt, acc, w, h)
self.assertIsInstance(tex, render.SDL_Texture)
qf, qa, qw, qh = render.query_texture(tex)
self.assertEqual(qf, fmt)
self.assertEqual(qa, acc)
self.assertEqual(w, qw)
self.assertEqual(h, qh)
render.destroy_texture(tex)
render.destroy_renderer(renderer)
video.destroy_window(window)
def test_destroy_window(self):
flags = (video.SDL_WINDOW_BORDERLESS,
video.SDL_WINDOW_BORDERLESS | video.SDL_WINDOW_HIDDEN)
for flag in flags:
window = video.create_window("Test", 10, 10, 10, 10, flag)
# TODO: how to check for this in a meaningful way?
video.destroy_window(window)
def test_get_set_render_draw_color(self):
window = video.create_window("Test", 10, 10, 10, 10,
video.SDL_WINDOW_HIDDEN)
self.assertIsInstance(window, video.SDL_Window)
for i in range(render.get_num_render_drivers()):
renderer = render.create_renderer(window, i,
render.SDL_RENDERER_ACCELERATED)
self.assertIsInstance(renderer, render.SDL_Renderer)
colors = ((16, 22, 185, 217),
(32, 64, 128, 255),
(64, 32, 128, 255),
(64, 32, 255, 128),
(255, 32, 64, 128),
(255, 32, 128, 64),
(0, 0, 0, 0),
(255, 255, 255, 255),
(128, 128, 128, 255),
)
for r, g, b, a in colors:
render.set_render_draw_color(renderer, r, g, b, a)
dr, dg, db, da = render.get_render_draw_color(renderer)
self.assertEqual((dr, dg, db, da), (r, g, b, a))
render.destroy_renderer(renderer)
self.assertRaises(sdl.SDLError, render.set_render_draw_color,
renderer, 10, 20, 30, 40)
self.assertRaises(sdl.SDLError, render.get_render_draw_color,
renderer)
video.destroy_window(window)
def test_get_set_render_draw_blend_mode(self):
window = video.create_window("Test", 10, 10, 10, 10,
video.SDL_WINDOW_HIDDEN)
self.assertIsInstance(window, video.SDL_Window)
for i in range(render.get_num_render_drivers()):
renderer = render.create_renderer(window, i,
render.SDL_RENDERER_ACCELERATED)
self.assertIsInstance(renderer, render.SDL_Renderer)
modes = (video.SDL_BLENDMODE_NONE,
video.SDL_BLENDMODE_ADD,
video.SDL_BLENDMODE_BLEND,
video.SDL_BLENDMODE_MOD,
)
for mode in modes:
render.set_render_draw_blend_mode(renderer, mode)
bmode = render.get_render_draw_blend_mode(renderer)
self.assertEqual(bmode, mode)
render.destroy_renderer(renderer)
self.assertRaises(sdl.SDLError, render.set_render_draw_blend_mode,
renderer, video.SDL_BLENDMODE_ADD)
self.assertRaises(sdl.SDLError, render.get_render_draw_blend_mode,
renderer)
video.destroy_window(window)
def test_get_set_texture_blend_mode(self):
window = video.create_window("Test", 10, 10, 10, 10,
video.SDL_WINDOW_HIDDEN)
self.assertIsInstance(window, video.SDL_Window)
renderer = render.create_renderer(window, -1,
render.SDL_RENDERER_SOFTWARE)
self.assertIsInstance(renderer, render.SDL_Renderer)
tex = render.create_texture(renderer, pixels.SDL_PIXELFORMAT_ARGB8888,
render.SDL_TEXTUREACCESS_STREAMING, 10, 10)
self.assertIsInstance(tex, render.SDL_Texture)
modes = (video.SDL_BLENDMODE_NONE,
video.SDL_BLENDMODE_ADD,
video.SDL_BLENDMODE_BLEND,
video.SDL_BLENDMODE_MOD,
)
for mode in modes:
render.set_texture_blend_mode(tex, mode)
tmode = render.get_texture_blend_mode(tex)
self.assertEqual(tmode, mode)
render.destroy_texture(tex)
self.assertRaises(sdl.SDLError, render.set_texture_blend_mode, tex,
modes[2])
self.assertRaises(sdl.SDLError, render.get_texture_blend_mode, tex)
render.destroy_renderer(renderer)
video.destroy_window(window)
def test_get_set_texture_color_mod(self):
window = video.create_window("Test", 10, 10, 10, 10,
video.SDL_WINDOW_HIDDEN)
self.assertIsInstance(window, video.SDL_Window)
renderer = render.create_renderer(window, -1,
render.SDL_RENDERER_SOFTWARE)
self.assertIsInstance(renderer, render.SDL_Renderer)
tex = render.create_texture(renderer, pixels.SDL_PIXELFORMAT_ARGB8888,
render.SDL_TEXTUREACCESS_STREAMING, 10, 10)
self.assertIsInstance(tex, render.SDL_Texture)
colors = ((16, 22, 185),
(32, 64, 128),
(64, 32, 128),
(64, 32, 255),
(255, 32, 64),
(255, 32, 128),
(0, 0, 0),
(255, 255, 255),
(128, 128, 128),
)
for r, g, b in colors:
render.set_texture_color_mod(tex, r, g, b)
tr, tg, tb = render.get_texture_color_mod(tex)
self.assertEqual((tr, tg, tb), (r, g, b))
render.destroy_texture(tex)
self.assertRaises(sdl.SDLError, render.set_texture_color_mod, tex,
10, 20, 30)
self.assertRaises(sdl.SDLError, render.get_texture_color_mod, tex)
render.destroy_renderer(renderer)
video.destroy_window(window)
def test_gl_get_set_swap_interval(self):
self.assertRaises(ValueError, video.gl_set_swap_interval, None)
self.assertRaises(ValueError, video.gl_set_swap_interval, "Test")
self.assertRaises(ValueError, video.gl_set_swap_interval, 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.gl_set_swap_interval, 1)
# self.assertRaises(sdl.SDLError, video.gl_set_swap_interval, 0)
self.assertTrue(video.gl_load_library())
window = video.create_window("OpenGL", 10, 10, 10, 10,
video.SDL_WINDOW_OPENGL)
ctx = video.gl_create_context(window)
video.gl_make_current(window, ctx)
video.gl_set_swap_interval(0)
self.assertEqual(video.gl_get_swap_interval(), 0)
video.gl_set_swap_interval(1)
self.assertEqual(video.gl_get_swap_interval(), 1)
video.gl_delete_context(ctx)
video.destroy_window(window)
video.gl_unload_library()
def test_get_shaped_window_mode(self):
flags = (video.SDL_WINDOW_HIDDEN, )
for flag in flags:
window = shape.create_shaped_window("Test", 10, 10, 10, 10, flag)
self.assertIsInstance(window, video.SDL_Window)
mode = shape.get_shaped_window_mode(window)
self.assertIsInstance(mode, shape.SDL_WindowShapeMode)
video.destroy_window(window)
def test_get_window_wm_info(self):
window = video.create_window("Test", 10, 10, 10, 10,
video.SDL_WINDOW_HIDDEN)
wminfo = syswm.get_window_wm_info(window)
self.assertEqual(wminfo.version.major, 2)
self.assertEqual(wminfo.version.minor, 0)
self.assertEqual(wminfo.version.patch, 0)
video.destroy_window(window)
def test_create_window_and_renderer(self):
window, renderer = render.create_window_and_renderer \
(10, 10, video.SDL_WINDOW_HIDDEN)
self.assertIsInstance(window, video.SDL_Window)
self.assertIsInstance(renderer, render.SDL_Renderer)
render.destroy_renderer(renderer)
video.destroy_window(window)
def test_update_window_surface(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.create_window("Test", 200, 200, 200, 200, flag)
video.update_window_surface(window)
video.destroy_window(window)
def test_get_set_window_title(self):
window = video.create_window("Test", 10, 10, 10, 10, 0)
self.assertEqual(video.get_window_title(window), "Test")
video.set_window_title(window, "Hello there")
self.assertEqual(video.get_window_title(window), "Hello there")
video.set_window_title(window, 123456789)
self.assertEqual(video.get_window_title(window), "123456789")
video.destroy_window(window)
self.assertRaises(sdl.SDLError, video.get_window_title, window)
def test_maximize_window(self):
window = video.create_window("test_maximize_window", 200, 200,
200, 200, video.SDL_WINDOW_RESIZABLE)
video.show_window(window)
doprint("""Please check, that a window with the title
'test_maximize_window' is shown""")
video.maximize_window(window)
doprint("Please check, if the window was maximized properly")
video.destroy_window(window)
def test_minimize_window(self):
window = video.create_window("test_minimize_window", 200, 200,
200, 200, 0)
video.show_window(window)
doprint("""Please check, that a window with the title
'test_minimize_window' is shown""")
video.minimize_window(window)
doprint("Please check, if the window was minimized properly")
video.destroy_window(window)
def test_get_window_id(self):
flags = (video.SDL_WINDOW_BORDERLESS,
video.SDL_WINDOW_BORDERLESS | video.SDL_WINDOW_HIDDEN)
for flag in flags:
window = video.create_window("Test", 10, 10, 10, 10, flag)
id = video.get_window_id(window)
self.assertIsInstance(id, int)
video.destroy_window(window)
self.assertRaises(sdl.SDLError, video.get_window_id, window)
def test_get_window_display_mode(self):
flags = (video.SDL_WINDOW_BORDERLESS,
video.SDL_WINDOW_BORDERLESS | video.SDL_WINDOW_HIDDEN)
for flag in flags:
window = video.create_window("Test", 10, 10, 10, 10, flag)
dmode = video.get_window_display_mode(window)
self.assertIsInstance(dmode, video.SDL_DisplayMode)
video.destroy_window(window)
self.assertRaises(sdl.SDLError, video.get_window_display_mode,
window)
def test_get_window_pixelformat(self):
flags = (video.SDL_WINDOW_BORDERLESS,
video.SDL_WINDOW_BORDERLESS | video.SDL_WINDOW_HIDDEN)
for flag in flags:
window = video.create_window("Test", 10, 10, 10, 10, flag)
fmt = video.get_window_pixelformat(window)
self.assertTrue(type(fmt) in(int, long))
video.destroy_window(window)
self.assertRaises(sdl.SDLError, video.get_window_pixelformat,
window)
def test_get_window_surface(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.create_window("Test", 200, 200, 200, 200, flag)
sf = video.get_window_surface(window)
self.assertIsInstance(sf, surface.SDL_Surface)
video.destroy_window(window)
self.assertRaises(sdl.SDLError, video.get_window_surface, window)
def test_raise_window(self):
window = video.create_window("test_raise_window", 200, 200, 200, 200,
0)
video.show_window(window)
doprint("""Please check, that a window with the title
'test_raise_window' is shown""")
doprint("Move another window on top of the window, so it is hidden")
video.raise_window(window)
doprint("The window should be raised to the foreground now")
video.destroy_window(window)
def test_hide_window(self):
window = video.create_window("test_hide_window", 200, 200, 200, 200, 0)
video.show_window(window)
doprint("""Please check, if a window with the title
'test_hide_window' is shown""")
video.hide_window(window)
doprint("Please check, that the window is not shown anymore")
video.show_window(window)
doprint("Please check, if the window is shown again")
video.destroy_window(window)
def test_get_set_window_position(self):
window = video.create_window("Test", 10, 10, 10, 10, 0)
self.assertEqual(video.get_window_position(window), (10, 10))
video.set_window_position(window, 0, 0)
self.assertEqual(video.get_window_position(window), (0, 0))
video.set_window_position(window, 600, 900)
self.assertEqual(video.get_window_position(window), (600, 900))
video.set_window_position(window, -200, -10)
self.assertEqual(video.get_window_position(window), (-200, -10))
video.destroy_window(window)
def test_get_set_window_size(self):
flags = video.SDL_WINDOW_BORDERLESS
window = video.create_window("Test", 10, 10, 10, 10, flags)
self.assertEqual(video.get_window_size(window), (10, 10))
video.set_window_size(window, 0, 0)
self.assertEqual(video.get_window_size(window), (0, 0))
video.set_window_size(window, 600, 900)
self.assertEqual(video.get_window_size(window), (600, 900))
video.set_window_size(window, -200, -10)
self.assertEqual(video.get_window_size(window), (-200, -10))
video.destroy_window(window)
def test_create_destroy_texture(self):
window = video.create_window("Test", 10, 10, 10, 10,
video.SDL_WINDOW_HIDDEN)
self.assertIsInstance(window, video.SDL_Window)
renderer = render.create_renderer(window, -1,
render.SDL_RENDERER_SOFTWARE)
self.assertIsInstance(renderer, render.SDL_Renderer)
formats = (pixels.SDL_PIXELFORMAT_ARGB8888,
pixels.SDL_PIXELFORMAT_RGB555,
pixels.SDL_PIXELFORMAT_RGBA4444,
pixels.SDL_PIXELFORMAT_RGBA8888,
pixels.SDL_PIXELFORMAT_ARGB2101010,
pixels.SDL_PIXELFORMAT_YUY2
)
access = (render.SDL_TEXTUREACCESS_STATIC,
render.SDL_TEXTUREACCESS_STREAMING,
render.SDL_TEXTUREACCESS_TARGET)
for fmt in formats:
for acc in access:
for w in range(1, 300, 5):
for h in range(1, 300, 5):
tex = render.create_texture(renderer, fmt, acc, w, h)
self.assertIsInstance(tex, render.SDL_Texture)
render.destroy_texture(tex)
self.assertRaises(sdl.SDLError, render.create_texture, renderer,
pixels.SDL_PIXELFORMAT_RGB555, 1, -10, 10)
self.assertRaises(sdl.SDLError, render.create_texture, renderer,
pixels.SDL_PIXELFORMAT_RGB555, 1, 10, -10)
self.assertRaises(sdl.SDLError, render.create_texture, renderer,
pixels.SDL_PIXELFORMAT_RGB555, 1, -10, -10)
self.assertRaises(ValueError, render.create_texture, renderer,
pixels.SDL_PIXELFORMAT_RGB555, -5, 10, 10)
self.assertRaises(ValueError, render.create_texture, renderer,
-10, 1, 10, 10)
self.assertRaises((AttributeError, TypeError),
render.create_texture, None,
pixels.SDL_PIXELFORMAT_RGB555, 1, 10, 10)
self.assertRaises((AttributeError, TypeError),
render.create_texture, "Test",
pixels.SDL_PIXELFORMAT_RGB555, 1, 10, 10)
self.assertRaises(ValueError, render.create_texture, renderer,
"Test", 1, 10, 10)
self.assertRaises(ValueError, render.create_texture, renderer,
pixels.SDL_PIXELFORMAT_RGB555, None, 10, 10)
self.assertRaises(ValueError, render.create_texture, renderer,
pixels.SDL_PIXELFORMAT_RGB555, "Test", 10, 10)
render.destroy_renderer(renderer)
self.assertRaises(sdl.SDLError, render.create_texture, renderer,
pixels.SDL_PIXELFORMAT_RGB555, 1, 10, 10)
video.destroy_window(window)
def test_get_keyboard_focus(self):
window = keyboard.get_keyboard_focus()
self.assertEqual(window, None)
rwin = video.create_window("", 10, 10, 10, 10, 0)
window = keyboard.get_keyboard_focus()
if window:
self.assertEqual(video.get_window_id(window),
video.get_window_id(rwin))
video.destroy_window(rwin)
window = keyboard.get_keyboard_focus()
self.assertEqual(window, None)
def test_create_window(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.create_window("Test", 10, 10, 10, 10, flag)
self.assertIsInstance(window, video.SDL_Window)
self.assertEqual(video.get_window_position(window), (10, 10))
self.assertEqual(video.get_window_size(window), (10, 10))
self.assertEqual(video.get_window_flags(window) & flag, flag)
self.assertEqual(video.get_window_title(window), "Test")
video.destroy_window(window)
def test_update_window_surface_rects(self):
rectlist = [rect.SDL_Rect(), rect.SDL_Rect(10, 10, 10, 10),
rect.SDL_Rect(0, 0, 5, 4), rect.SDL_Rect(-5, -5, 6, 2)]
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.create_window("Test", 200, 200, 200, 200, flag)
self.assertRaises(sdl.SDLError, video.update_window_surface_rects,
window, rectlist)
surface = video.get_window_surface(window)
video.update_window_surface_rects(window, rectlist)
video.destroy_window(window)
def test_render_target_supported(self):
window = video.create_window("Test", 10, 10, 10, 10,
video.SDL_WINDOW_HIDDEN)
self.assertIsInstance(window, video.SDL_Window)
for i in range(render.get_num_render_drivers()):
renderer = render.create_renderer(window, i,
render.SDL_RENDERER_ACCELERATED)
self.assertIsInstance(renderer, render.SDL_Renderer)
val = render.render_target_supported(renderer)
self.assertIsInstance(val, bool)
render.destroy_renderer(renderer)
video.destroy_window(window)
def test_is_shaped_window(self):
flags = (video.SDL_WINDOW_HIDDEN, )
for flag in flags:
window = shape.create_shaped_window("Test", 10, 10, 10, 10, flag)
self.assertIsInstance(window, video.SDL_Window)
val = shape.is_shaped_window(window)
self.assertTrue(val)
video.destroy_window(window)
window = video.create_window("Test", 10, 10, 10, 10, flag)
self.assertIsInstance(window, video.SDL_Window)
val = shape.is_shaped_window(window)
self.assertFalse(val)
video.destroy_window(window)
def test_gl_make_current(self):
self.assertTrue(video.gl_load_library())
self.assertRaises((AttributeError, TypeError),
video.gl_make_current, None, None)
window = video.create_window("No OpenGL", 10, 10, 10, 10,
video.SDL_WINDOW_BORDERLESS)
self.assertRaises(sdl.SDLError, video.gl_create_context, window)
video.destroy_window(window)
self.assertRaises((AttributeError, TypeError),
video.gl_make_current, None, None)
video.gl_unload_library()
def test_gl_extension_supported(self):
self.assertFalse(video.gl_extension_supported("GL_EXT_bgra"))
self.assertTrue(video.gl_load_library())
window = video.create_window("OpenGL", 10, 10, 10, 10,
video.SDL_WINDOW_OPENGL)
ctx = video.gl_create_context(window)
self.assertTrue(video.gl_extension_supported("GL_EXT_bgra"))
video.gl_delete_context(ctx)
video.destroy_window(window)
video.gl_unload_library()
self.assertFalse(video.gl_extension_supported("GL_EXT_bgra"))
