Remove more misuse of SDL_GetError in tests (#271)

* Remove improper SDL_GetError usage

* Improve SetTextInputRect test

* Make error clearing explicit for unsafe tests

sdl2/test/clipboard_test.py

@@ -8,9 +8,8 @@
 def window(with_sdl):
  flag = sdl2.SDL_WINDOW_BORDERLESS
  w = sdl2.SDL_CreateWindow(b"Test", 10, 40, 12, 13, flag)
- if not isinstance(w.contents, sdl2.SDL_Window):
- assert sdl2.SDL_GetError() == b""
- assert isinstance(w.contents, sdl2.SDL_Window)
+ assert w, _check_error_msg()
+ assert isinstance(w.contents, sdl2.SDL_Window)
  sdl2.SDL_ClearError()
  yield w
  sdl2.SDL_DestroyWindow(w)

sdl2/test/joystick_test.py

@@ -57,7 +57,7 @@ def joysticks(with_sdl):
  count = sdl2.SDL_NumJoysticks()
  for i in range(count):
  stick = sdl2.SDL_JoystickOpen(i)
- assert sdl2.SDL_GetError() == b""
+ assert stick, _check_error_msg()
  assert isinstance(stick.contents, sdl2.SDL_Joystick)
  devices.append(stick)
  yield devices
@@ -121,47 +121,48 @@ def test_SDL_JoystickGetDeviceGUID(with_sdl):
 def test_SDL_JoystickGetDeviceVendor(with_sdl):
  count = sdl2.SDL_NumJoysticks()
  for index in range(count):
+ sdl2.SDL_ClearError()
  vid = sdl2.SDL_JoystickGetDeviceVendor(index)
- assert SDL_GetError() == b""
  if not is_virtual(index):
- assert vid > 0
+ assert vid > 0, _check_error_msg()
 
 def test_SDL_JoystickGetDeviceProduct(with_sdl):
  count = sdl2.SDL_NumJoysticks()
  for index in range(count):
+ sdl2.SDL_ClearError()
  pid = sdl2.SDL_JoystickGetDeviceProduct(index)
- assert SDL_GetError() == b""
  if not is_virtual(index):
- assert pid > 0
+ assert pid > 0, _check_error_msg()
 
 def test_SDL_JoystickGetDeviceProductVersion(with_sdl):
  count = sdl2.SDL_NumJoysticks()
  for index in range(count):
+ sdl2.SDL_ClearError()
  pver = sdl2.SDL_JoystickGetDeviceProductVersion(index)
- assert SDL_GetError() == b""
- assert pver >= 0
+ assert pver >= 0, _check_error_msg()
 
 def test_SDL_JoystickGetDeviceType(with_sdl):
  count = sdl2.SDL_NumJoysticks()
  for index in range(count):
  jtype = sdl2.SDL_JoystickGetDeviceType(index)
- assert SDL_GetError() == b""
  assert jtype in joystick_types
  if is_virtual(index):
  assert jtype == sdl2.SDL_JOYSTICK_TYPE_GAMECONTROLLER
 
 @pytest.mark.skipif(sdl2.dll.version < 2006, reason="not available")
 def test_SDL_JoystickGetDeviceInstanceID(joysticks):
  for index in range(len(joysticks)):
+ sdl2.SDL_ClearError()
  iid = sdl2.SDL_JoystickGetDeviceInstanceID(index)
- assert SDL_GetError() == b""
  stick = joysticks[index]
- assert iid == sdl2.SDL_JoystickInstanceID(stick)
+ assert iid == sdl2.SDL_JoystickInstanceID(stick), _check_error_msg()
 
 def test_SDL_JoystickOpenClose(with_sdl):
  count = sdl2.SDL_NumJoysticks()
  for index in range(count):
+ sdl2.SDL_ClearError()
  stick = sdl2.SDL_JoystickOpen(index)
+ assert stick, _check_error_msg()
  assert isinstance(stick.contents, sdl2.SDL_Joystick)
  sdl2.SDL_JoystickClose(stick)
 
@@ -316,42 +317,40 @@ def test_SDL_JoystickGetGUID(joysticks):
 
 def test_SDL_JoystickGetVendor(joysticks):
  for stick in joysticks:
+ sdl2.SDL_ClearError()
  vid = sdl2.SDL_JoystickGetVendor(stick)
- assert SDL_GetError() == b""
  if not is_virtual(stick):
- assert vid > 0
+ assert vid > 0, _check_error_msg()
 
 def test_SDL_JoystickGetProduct(joysticks):
  for stick in joysticks:
+ sdl2.SDL_ClearError()
  pid = sdl2.SDL_JoystickGetProduct(stick)
- assert SDL_GetError() == b""
  if not is_virtual(stick):
- assert pid > 0
+ assert pid > 0, _check_error_msg()
 
 def test_SDL_JoystickGetProductVersion(joysticks):
  for stick in joysticks:
+ sdl2.SDL_ClearError()
  pver = sdl2.SDL_JoystickGetProductVersion(stick)
- assert SDL_GetError() == b""
- assert pver >= 0
+ assert pver >= 0, _check_error_msg()
 
 @pytest.mark.skipif(sdl2.dll.version < 2231, reason="not available")
 def test_SDL_JoystickGetFirmwareVersion(joysticks):
  for stick in joysticks:
+ sdl2.SDL_ClearError()
  fw_ver = sdl2.SDL_JoystickGetFirmwareVersion(stick)
- assert SDL_GetError() == b""
- assert fw_ver >= 0
+ assert fw_ver >= 0, _check_error_msg()
 
 @pytest.mark.skipif(sdl2.dll.version < 2014, reason="not available")
 def test_SDL_JoystickGetSerial(joysticks):
  for stick in joysticks:
  serial = sdl2.SDL_JoystickGetSerial(stick)
- assert SDL_GetError() == b""
  assert serial == None or type(serial) in (str, bytes)
 
 def test_SDL_JoystickGetType(joysticks):
  for stick in joysticks:
  jtype = sdl2.SDL_JoystickGetType(stick)
- assert SDL_GetError() == b""
  assert jtype in joystick_types
  if is_virtual(stick):
  assert jtype == sdl2.SDL_JOYSTICK_TYPE_GAMECONTROLLER
@@ -426,7 +425,9 @@ def test_SDL_JoystickNumButtons(joysticks):
  assert buttons == 4
 
 def test_SDL_JoystickUpdate(with_sdl):
- # NOTE: Returns void, can't really test anything else
+ # TODO: This is not 100% safe, but in SDL2, JoystickUpdate returns void
+ # so we can't reliably detect error
+ sdl2.SDL_ClearError()
  sdl2.SDL_JoystickUpdate()
  assert SDL_GetError() == b""
 
@@ -450,7 +451,6 @@ def test_SDL_JoystickGetAxisInitialState(joysticks):
  ret = sdl2.SDL_JoystickGetAxisInitialState(
  stick, axis, byref(init_state)
  )
- assert SDL_GetError() == b""
  assert -32768 <= init_state.value <= 32767
  assert ret in [SDL_TRUE, SDL_FALSE]
 
@@ -544,5 +544,4 @@ def test_SDL_JoystickCurrentPowerLevel(joysticks):
  ]
  for stick in joysticks:
  pwr = sdl2.SDL_JoystickCurrentPowerLevel(stick)
- assert SDL_GetError() == b""
  assert pwr in levels

sdl2/test/keyboard_test.py

@@ -4,16 +4,16 @@
 import sdl2
 from sdl2 import SDL_TRUE, SDL_FALSE, SDL_GetError
 from sdl2 import rect, scancode, keycode, video
+from .conftest import _check_error_msg
 
 byteify = lambda x: x.encode("utf-8")
 
 @pytest.fixture
 def window(with_sdl):
  flag = video.SDL_WINDOW_INPUT_FOCUS
  w = video.SDL_CreateWindow(b"Test", 10, 40, 32, 24, flag)
- if not isinstance(w.contents, sdl2.SDL_Window):
- assert sdl2.SDL_GetError() == b""
- assert isinstance(w.contents, sdl2.SDL_Window)
+ assert w, _check_error_msg()
+ assert isinstance(w.contents, sdl2.SDL_Window)
  sdl2.SDL_ClearError()
  yield w
  video.SDL_DestroyWindow(w)
@@ -150,11 +150,9 @@ def test_SDL_GetKeyFromName(with_sdl):
 
 def test_SDL_StartStopTextInput(with_sdl):
  sdl2.SDL_StopTextInput()
- assert SDL_GetError() == b""
- assert sdl2.SDL_IsTextInputActive() == SDL_FALSE
+ assert sdl2.SDL_IsTextInputActive() == SDL_FALSE, _check_error_msg()
  sdl2.SDL_StartTextInput()
- assert SDL_GetError() == b""
- assert sdl2.SDL_IsTextInputActive() == SDL_TRUE
+ assert sdl2.SDL_IsTextInputActive() == SDL_TRUE, _check_error_msg()
 
 @pytest.mark.skipif(sdl2.dll.version < 2022, reason="not available")
 def test_SDL_ClearComposition(with_sdl):
@@ -166,12 +164,16 @@ def test_SDL_IsTextInputShown(with_sdl):
  assert ret in [SDL_TRUE, SDL_FALSE]
 
 def test_SDL_SetTextInputRect(with_sdl):
+ # TODO: This is not 100% safe, but in SDL2, SetTextInputRect returns
+ # void, so we can't reliably detect error
  sdl2.SDL_StartTextInput()
  coords = [(0, 0, 0, 0), (-10, -70, 3, 6), (10, 10, 10, 10)]
  for x, y, w, h in coords:
  r = rect.SDL_Rect(x, y, w, h)
+ sdl2.SDL_ClearError()
  sdl2.SDL_SetTextInputRect(r)
  assert SDL_GetError() == b""
+ sdl2.SDL_StopTextInput()
 
 def test_SDL_HasScreenKeyboardSupport(with_sdl):
  ret = sdl2.SDL_HasScreenKeyboardSupport()

sdl2/test/pixels_test.py

@@ -6,6 +6,7 @@
 from sdl2 import SDL_Init, SDL_Quit, SDL_INIT_EVERYTHING, SDL_TRUE
 from sdl2 import SDL_Color
 from sdl2.stdinc import Uint8, Uint16, Uint32
+from .conftest import _check_error_msg
 
 RGBA8888 = [0xFF000000, 0x00FF0000, 0x0000FF00, 0x000000FF]
 RGBX8888 = [0xFF000000, 0x00FF0000, 0x0000FF00, 0]
@@ -163,11 +164,11 @@ def test_SDL_PixelFormatEnumToMasks():
  bpp = c_int(0)
  r, g, b, a = Uint32(0), Uint32(0), Uint32(0), Uint32(0)
  for fmt, expected in formats:
+ sdl2.SDL_ClearError()
  ret = sdl2.SDL_PixelFormatEnumToMasks(
  fmt, byref(bpp), byref(r), byref(g), byref(b), byref(a)
  )
- assert sdl2.SDL_GetError() == b""
- assert ret == SDL_TRUE
+ assert ret == SDL_TRUE, _check_error_msg()
  assert [x.value for x in (bpp, r, g, b, a)] == expected
 
 def test_SDL_AllocFreeFormat():
@@ -232,8 +233,7 @@ def test_SDL_SetPixelFormatPalette():
  pixfmt = sdl2.SDL_AllocFormat(sdl2.SDL_PIXELFORMAT_INDEX1MSB)
  assert isinstance(pixfmt.contents, sdl2.SDL_PixelFormat)
  ret = sdl2.SDL_SetPixelFormatPalette(pixfmt, palette)
- assert sdl2.SDL_GetError() == b""
- assert ret == 0
+ assert ret == 0, _check_error_msg()
 
  fmt_palette = pixfmt.contents.palette.contents
  assert fmt_palette.colors[1].r == 128

sdl2/test/render_test.py

@@ -22,9 +22,8 @@ def _create_window(pos, size, flags=video.SDL_WINDOW_HIDDEN):
  window = video.SDL_CreateWindow(
  b"Test", pos[0], pos[1], size[0], size[1], video.SDL_WINDOW_HIDDEN
  )
- if not isinstance(window.contents, video.SDL_Window):
- assert SDL_GetError() == b""
- assert isinstance(window.contents, video.SDL_Window)
+ assert window, _check_error_msg()
+ assert isinstance(window.contents, video.SDL_Window)
  sdl2.SDL_ClearError()
  return window
 
@@ -59,18 +58,18 @@ def testsurf(with_sdl):
  sf = surface.SDL_CreateRGBSurface(
  0, 100, 100, 32, 0xFF000000, 0x00FF0000, 0x0000FF00, 0x000000FF
  )
- assert SDL_GetError() == b""
+ assert sf, _check_error_msg()
  pixfmt = sf.contents.format.contents
  fill = pixels.SDL_MapRGBA(pixfmt, 0, 0, 0, 255)
- surface.SDL_FillRect(sf, None, fill)
- assert SDL_GetError() == b""
+ ret = surface.SDL_FillRect(sf, None, fill)
+ assert ret == 0, _check_error_msg()
  yield sf
  surface.SDL_FreeSurface(sf)
 
 @pytest.fixture
 def sw_renderer(testsurf):
  renderer = sdl2.SDL_CreateSoftwareRenderer(testsurf)
- assert SDL_GetError() == b""
+ assert renderer, _check_error_msg()
  assert isinstance(renderer.contents, sdl2.SDL_Renderer)
  yield (renderer, testsurf)
  sdl2.SDL_DestroyRenderer(renderer)
@@ -82,12 +81,11 @@ def with_renderer(with_sdl):
  window = video.SDL_CreateWindow(
  b"Test", 30, 30, 100, 100, video.SDL_WINDOW_HIDDEN
  )
- if not isinstance(window.contents, sdl2.SDL_Window):
- assert sdl2.SDL_GetError() == b""
- assert isinstance(window.contents, sdl2.SDL_Window)
+ assert window, _check_error_msg()
+ assert isinstance(window.contents, sdl2.SDL_Window)
  sdl2.SDL_ClearError()
  renderer = sdl2.SDL_CreateRenderer(window, -1, flags)
- assert SDL_GetError() == b""
+ assert renderer, _check_error_msg()
  yield (renderer, window)
  sdl2.SDL_DestroyRenderer(renderer)
  video.SDL_DestroyWindow(window)
@@ -98,7 +96,7 @@ def texture(with_renderer):
  fmt = pixels.SDL_PIXELFORMAT_ARGB8888
  access = sdl2.SDL_TEXTUREACCESS_STREAMING
  tx = sdl2.SDL_CreateTexture(renderer, fmt, access, 16, 16)
- assert SDL_GetError() == b""
+ assert tx, _check_error_msg()
  assert isinstance(tx.contents, sdl2.SDL_Texture)
  yield tx
  sdl2.SDL_DestroyTexture(tx)
@@ -237,7 +235,7 @@ def test_SDL_CreateSoftwareRenderer(with_sdl):
  0, 100, 100, 32, 0xFF000000, 0x00FF0000, 0x0000FF00, 0x000000FF
  )
  renderer = sdl2.SDL_CreateSoftwareRenderer(sf)
- assert SDL_GetError() == b""
+ assert renderer, _check_error_msg()
  assert isinstance(renderer.contents, sdl2.SDL_Renderer)
  sdl2.SDL_DestroyRenderer(renderer)
  surface.SDL_FreeSurface(sf)
@@ -250,8 +248,9 @@ def test_SDL_GetRenderer(supported_renderers):
  renderer = sdl2.SDL_CreateRenderer(window, i, flags)
  if (renderer and renderer.contents):
  usable += 1
+ sdl2.SDL_ClearError()
  ren = sdl2.SDL_GetRenderer(window)
- assert SDL_GetError() == b""
+ assert ren, _check_error_msg()
  assert isinstance(ren.contents, sdl2.SDL_Renderer)
  sdl2.SDL_DestroyRenderer(renderer)
  assert not sdl2.SDL_GetRenderer(window)
@@ -265,8 +264,9 @@ def test_SDL_RenderGetWindow(supported_renderers):
  window = _create_window((30, 30), (100, 100))
  renderer = sdl2.SDL_CreateRenderer(window, i, flags)
  if (renderer and renderer.contents):
+ sdl2.SDL_ClearError()
  win = sdl2.SDL_RenderGetWindow(renderer)
- assert SDL_GetError() == b""
+ assert win, _check_error_msg()
  assert isinstance(win.contents, sdl2.SDL_Window)
  assert sdl2.SDL_GetWindowID(window) == sdl2.SDL_GetWindowID(win)
  sdl2.SDL_DestroyRenderer(renderer)
@@ -335,8 +335,9 @@ def test_SDL_CreateDestroyTexture(with_renderer):
  for fmt in formats:
  for acc in access:
  for w, h in sizes:
+ sdl2.SDL_ClearError()
  tx = sdl2.SDL_CreateTexture(renderer, fmt, acc, w, h)
- assert SDL_GetError() == b""
+ assert tx, _check_error_msg()
  assert isinstance(tx.contents, sdl2.SDL_Texture)
  sdl2.SDL_DestroyTexture(tx)
  # Test SDL error on bad input
@@ -348,8 +349,7 @@ def test_SDL_CreateDestroyTexture(with_renderer):
 def test_SDL_CreateTextureFromSurface(with_renderer, testsurf):
  renderer, win = with_renderer
  tx = sdl2.SDL_CreateTextureFromSurface(renderer, testsurf)
- if sdl2.dll.version != 2008: # Weird non-fatal colorkey error on 2.0.8
- assert SDL_GetError() == b"" 
+ assert tx, _check_error_msg()
  assert isinstance(tx.contents, sdl2.SDL_Texture)
  sdl2.SDL_DestroyTexture(tx)
 
@@ -454,8 +454,7 @@ def test_SDL_GetSetTextureUserData(texture):
  assert ret == 0, _check_error_msg()
  # Try retrieving the user data
  dat_ptr = sdl2.SDL_GetTextureUserData(texture)
- assert SDL_GetError() == b""
- assert dat_ptr != None
+ assert dat_ptr, _check_error_msg()
  dat_out = ctypes.cast(dat_ptr, ctypes.c_char_p)
  assert dat_raw.value == dat_out.value
 
@@ -491,7 +490,6 @@ def test_SDL_RenderTargetSupported(supported_renderers):
  usable += 1
  assert isinstance(renderer.contents, sdl2.SDL_Renderer)
  val = sdl2.SDL_RenderTargetSupported(renderer)
- assert SDL_GetError() == b""
  assert val in (SDL_TRUE, SDL_FALSE)
  sdl2.SDL_DestroyRenderer(renderer)
  video.SDL_DestroyWindow(window)
@@ -520,15 +518,17 @@ def test_SDL_GetSetRenderTarget(supported_renderers):
  pixfmt = pixels.SDL_PIXELFORMAT_ARGB8888
  for i in supports_targets:
  window = _create_window((30, 30), (100, 100))
+ sdl2.SDL_ClearError()
  renderer = sdl2.SDL_CreateRenderer(window, i, flags)
  # Try setting a texture as the render target
  tex = sdl2.SDL_CreateTexture(
  renderer, pixfmt, sdl2.SDL_TEXTUREACCESS_TARGET, 10, 10
  )
  ret = sdl2.SDL_SetRenderTarget(renderer, tex)
  assert ret == 0, _check_error_msg()
+ sdl2.SDL_ClearError()
  tgt = sdl2.SDL_GetRenderTarget(renderer)
- assert SDL_GetError() == b""
+ assert tgt, _check_error_msg()
  assert isinstance(tgt.contents, sdl2.SDL_Texture)
  # Try setting NULL as the render target (resets target to window)
  ret = sdl2.SDL_SetRenderTarget(renderer, None)