Add tests for SDL.

Author: HexDecimal

tcod/sdl/render.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import enum
 from typing import Any, Optional, Tuple
 
 import numpy as np
@@ -10,6 +11,17 @@
 from tcod.sdl import _check, _check_p
 
 
+class TextureAccess(enum.IntEnum):
+    """Determines how a texture is expected to be used."""
+
+    STATIC = lib.SDL_TEXTUREACCESS_STATIC or 0
+    """Texture rarely changes."""
+    STREAMING = lib.SDL_TEXTUREACCESS_STREAMING or 0
+    """Texture frequently changes."""
+    TARGET = lib.SDL_TEXTUREACCESS_TARGET or 0
+    """Texture will be used as a render target."""
+
+
 class Texture:
     def __init__(self, sdl_texture_p: Any, sdl_renderer_p: Any = None) -> None:
         self.p = sdl_texture_p
@@ -56,7 +68,9 @@ def height(self) -> int:
     @property
     def alpha_mod(self) -> int:
         """Texture alpha modulate value, can be set to: 0 - 255."""
-        return int(lib.SDL_GetTextureAlphaMod(self.p))
+        out = ffi.new("uint8_t*")
+        _check(lib.SDL_GetTextureAlphaMod(self.p, out))
+        return int(out[0])
 
     @alpha_mod.setter
     def alpha_mod(self, value: int) -> None:
@@ -65,7 +79,9 @@ def alpha_mod(self, value: int) -> None:
     @property
     def blend_mode(self) -> int:
         """Texture blend mode, can be set."""
-        return int(lib.SDL_GetTextureBlendMode(self.p))
+        out = ffi.new("SDL_BlendMode*")
+        _check(lib.SDL_GetTextureBlendMode(self.p, out))
+        return int(out[0])
 
     @blend_mode.setter
     def blend_mode(self, value: int) -> None:
@@ -101,6 +117,8 @@ class Renderer:
     def __init__(self, sdl_renderer_p: Any) -> None:
         if ffi.typeof(sdl_renderer_p) is not ffi.typeof("struct SDL_Renderer*"):
             raise TypeError(f"Expected a {ffi.typeof('struct SDL_Window*')} type (was {ffi.typeof(sdl_renderer_p)}).")
+        if not sdl_renderer_p:
+            raise TypeError("C pointer must not be null.")
         self.p = sdl_renderer_p
 
     def __eq__(self, other: Any) -> bool:
@@ -124,34 +142,49 @@ def present(self) -> None:
         """Present the currently rendered image to the screen."""
         lib.SDL_RenderPresent(self.p)
 
+    def set_render_target(self, texture: Texture) -> _RestoreTargetContext:
+        """Change the render target to `texture`, returns a context that will restore the original target when exited."""
+        restore = _RestoreTargetContext(self)
+        _check(lib.SDL_SetRenderTarget(self.p, texture.p))
+        return restore
+
     def new_texture(
         self, width: int, height: int, *, format: Optional[int] = None, access: Optional[int] = None
     ) -> Texture:
-        """Allocate and return a new Texture for this renderer."""
+        """Allocate and return a new Texture for this renderer.
+
+        Args:
+            width: The pixel width of the new texture.
+            height: The pixel height of the new texture.
+            format: The format the new texture.
+            access: The access mode of the texture.  Defaults to :any:`TextureAccess.STATIC`.
+                    See :any:`TextureAccess` for more options.
+        """
         if format is None:
             format = 0
         if access is None:
             access = int(lib.SDL_TEXTUREACCESS_STATIC)
         texture_p = ffi.gc(lib.SDL_CreateTexture(self.p, format, access, width, height), lib.SDL_DestroyTexture)
         return Texture(texture_p, self.p)
 
-    def set_render_target(self, texture: Texture) -> _RestoreTargetContext:
-        """Change the render target to `texture`, returns a context that will restore the original target when exited."""
-        restore = _RestoreTargetContext(self)
-        _check(lib.SDL_SetRenderTarget(self.p, texture.p))
-        return restore
-
     def upload_texture(
         self, pixels: NDArray[Any], *, format: Optional[int] = None, access: Optional[int] = None
     ) -> Texture:
-        """Return a new Texture from an array of pixels."""
+        """Return a new Texture from an array of pixels.
+
+        Args:
+            pixels: An RGB or RGBA array of pixels in row-major order.
+            format: The format of `pixels` when it isn't a simple RGB or RGBA array.
+            access: The access mode of the texture.  Defaults to :any:`TextureAccess.STATIC`.
+                    See :any:`TextureAccess` for more options.
+        """
         if format is None:
             assert len(pixels.shape) == 3
             assert pixels.dtype == np.uint8
             if pixels.shape[2] == 4:
                 format = int(lib.SDL_PIXELFORMAT_RGBA32)
             elif pixels.shape[2] == 3:
-                format = int(lib.SDL_PIXELFORMAT_RGB32)
+                format = int(lib.SDL_PIXELFORMAT_RGB24)
             else:
                 raise TypeError(f"Can't determine the format required for an array of shape {pixels.shape}.")
 
@@ -174,6 +207,13 @@ def new_renderer(
 ) -> Renderer:
     """Initialize and return a new SDL Renderer.
 
+    Args:
+        window: The window that this renderer will be attached to.
+        driver: Force SDL to use a specific video driver.
+        software: If True then a software renderer will be forced.  By default a hardware renderer is used.
+        vsync: If True then Vsync will be enabled.
+        target_textures: If True then target textures can be used by the renderer.
+
     Example::
 
         # Start by creating a window.

tcod/sdl/video.py

@@ -21,6 +21,7 @@
     "Window",
     "new_window",
     "get_grabbed_window",
+    "screen_saver_allowed",
 )
 
 
@@ -66,10 +67,10 @@ class _TempSurface:
 
     def __init__(self, pixels: ArrayLike) -> None:
         self._array: NDArray[np.uint8] = np.ascontiguousarray(pixels, dtype=np.uint8)
-        if len(self._array) != 3:
-            raise TypeError("NumPy shape must be 3D [y, x, ch] (got %r)" % (self._array.shape,))
-        if 3 <= self._array.shape[2] <= 4:
-            raise TypeError("NumPy array must have RGB or RGBA channels. (got %r)" % (self._array.shape,))
+        if len(self._array.shape) != 3:
+            raise TypeError(f"NumPy shape must be 3D [y, x, ch] (got {self._array.shape})")
+        if not (3 <= self._array.shape[2] <= 4):
+            raise TypeError(f"NumPy array must have RGB or RGBA channels. (got {self._array.shape})")
         self.p = ffi.gc(
             lib.SDL_CreateRGBSurfaceFrom(
                 ffi.from_buffer("void*", self._array),
@@ -95,32 +96,21 @@ def __init__(self, sdl_window_p: Any) -> None:
                 "sdl_window_p must be %r type (was %r)." % (ffi.typeof("struct SDL_Window*"), ffi.typeof(sdl_window_p))
             )
         if not sdl_window_p:
-            raise ValueError("sdl_window_p can not be a null pointer.")
+            raise TypeError("sdl_window_p can not be a null pointer.")
         self.p = sdl_window_p
 
     def __eq__(self, other: Any) -> bool:
         return bool(self.p == other.p)
 
-    def set_icon(self, image: ArrayLike) -> None:
+    def set_icon(self, pixels: ArrayLike) -> None:
         """Set the window icon from an image.
 
-        `image` is a C memory order RGB or RGBA NumPy array.
+        Args:
+            pixels: A row-major array of RGB or RGBA pixel values.
         """
-        surface = _TempSurface(image)
+        surface = _TempSurface(pixels)
         lib.SDL_SetWindowIcon(self.p, surface.p)
 
-    @property
-    def allow_screen_saver(self) -> bool:
-        """Get or set if the operating system is allowed to display a screen saver."""
-        return bool(lib.SDL_IsScreenSaverEnabled(self.p))
-
-    @allow_screen_saver.setter
-    def allow_screen_saver(self, value: bool) -> None:
-        if value:
-            lib.SDL_EnableScreenSaver(self.p)
-        else:
-            lib.SDL_DisableScreenSaver(self.p)
-
     @property
     def position(self) -> Tuple[int, int]:
         """Get or set the (x, y) position of the window.
@@ -180,11 +170,11 @@ def max_size(self, xy: Tuple[int, int]) -> None:
     @property
     def title(self) -> str:
         """Get or set the title of the window."""
-        return str(ffi.string(lib.SDL_GetWindowtitle(self.p)), encoding="utf-8")
+        return str(ffi.string(lib.SDL_GetWindowTitle(self.p)), encoding="utf-8")
 
     @title.setter
     def title(self, value: str) -> None:
-        lib.SDL_SetWindowtitle(self.p, value.encode("utf-8"))
+        lib.SDL_SetWindowTitle(self.p, value.encode("utf-8"))
 
     @property
     def flags(self) -> WindowFlags:
@@ -303,6 +293,15 @@ def new_window(
 ) -> Window:
     """Initialize and return a new SDL Window.
 
+    Args:
+        width: The requested pixel width of the window.
+        height: The requested pixel height of the window.
+        x: The left-most position of the window.
+        y: The top-most position of the window.
+        title: The title text of the new window.  If no option is given then `sys.arg[0]` will be used as the title.
+        flags: The SDL flags to use for this window, such as `tcod.sdl.video.WindowFlags.RESIZABLE`.
+               See :any:`WindowFlags` for more options.
+
     Example::
 
         # Create a new resizable window with a custom title.
@@ -325,12 +324,12 @@ def get_grabbed_window() -> Optional[Window]:
     return Window(sdl_window_p) if sdl_window_p else None
 
 
-def _get_active_window() -> Window:
-    """Return the SDL2 window current managed by libtcod.
-
-    Will raise an error if libtcod does not currently have a window.
-    """
-    sdl_window = lib.TCOD_sys_get_window()
-    if not sdl_window:
-        raise RuntimeError("TCOD does not have an active window.")
-    return Window(sdl_window)
+def screen_saver_allowed(allow: Optional[bool] = None) -> bool:
+    """Allow or prevent a screen saver from being displayed and return the current allowed status."""
+    if allow is None:
+        pass
+    elif allow:
+        lib.SDL_EnableScreenSaver()
+    else:
+        lib.SDL_DisableScreenSaver()
+    return bool(lib.SDL_IsScreenSaverEnabled())

tests/test_sdl.py

@@ -0,0 +1,74 @@
+import sys
+
+import numpy as np
+import pytest
+
+import tcod.sdl.render
+import tcod.sdl.video
+
+
+def test_sdl_window() -> None:
+    assert tcod.sdl.video.get_grabbed_window() is None
+    window = tcod.sdl.video.new_window(1, 1)
+    window.raise_window()
+    window.maximize()
+    window.restore()
+    window.minimize()
+    window.hide()
+    window.show()
+    assert window.title == sys.argv[0]
+    window.title = "Title"
+    assert window.title == "Title"
+    assert window.opacity == 1.0
+    window.position = window.position
+    window.fullscreen = window.fullscreen
+    window.resizable = window.resizable
+    window.size = window.size
+    window.min_size = window.min_size
+    window.max_size = window.max_size
+    window.border_size
+    window.set_icon(np.zeros((32, 32, 3), dtype=np.uint8))
+    with pytest.raises(TypeError):
+        window.set_icon(np.zeros((32, 32, 5), dtype=np.uint8))
+    with pytest.raises(TypeError):
+        window.set_icon(np.zeros((32, 32), dtype=np.uint8))
+    window.opacity = window.opacity
+    window.grab = window.grab
+
+
+def test_sdl_window_bad_types() -> None:
+    with pytest.raises(TypeError):
+        tcod.sdl.video.Window(tcod.ffi.cast("SDL_Window*", tcod.ffi.NULL))
+    with pytest.raises(TypeError):
+        tcod.sdl.video.Window(tcod.ffi.new("SDL_Rect*"))
+
+
+def test_sdl_screen_saver() -> None:
+    assert tcod.sdl.video.screen_saver_allowed(False) is False
+    assert tcod.sdl.video.screen_saver_allowed(True) is True
+    assert tcod.sdl.video.screen_saver_allowed() is True
+
+
+def test_sdl_render() -> None:
+    window = tcod.sdl.video.new_window(1, 1)
+    render = tcod.sdl.render.new_renderer(window, software=True, vsync=False, target_textures=True)
+    render.present()
+    rgb = render.upload_texture(np.zeros((8, 8, 3), np.uint8))
+    assert (rgb.width, rgb.height) == (8, 8)
+    assert rgb.access == tcod.sdl.render.TextureAccess.STATIC
+    assert rgb.format == tcod.lib.SDL_PIXELFORMAT_RGB24
+    rgb.alpha_mod = rgb.alpha_mod
+    rgb.blend_mode = rgb.blend_mode
+    rgb.rgb_mod = rgb.rgb_mod
+    rgba = render.upload_texture(np.zeros((8, 8, 4), np.uint8), access=tcod.sdl.render.TextureAccess.TARGET)
+    with render.set_render_target(rgba):
+        render.copy(rgb)
+    with pytest.raises(TypeError):
+        render.upload_texture(np.zeros((8, 8, 5), np.uint8))
+
+
+def test_sdl_render_bad_types() -> None:
+    with pytest.raises(TypeError):
+        tcod.sdl.render.Renderer(tcod.ffi.cast("SDL_Renderer*", tcod.ffi.NULL))
+    with pytest.raises(TypeError):
+        tcod.sdl.render.Renderer(tcod.ffi.new("SDL_Rect*"))