text: import os
  import sys
  import ctypes
  import pytest
  
  import sdl2
  from sdl2 import SDL_Init, SDL_Quit, version, surface, rwops, render
  
  sdlimage = pytest.importorskip("sdl2.sdlimage")
  
  
  is32bit = sys.maxsize <= 2**32
  ismacos = sys.platform == "darwin"
  
  formats = ["bmp",
             "cur",
             "gif",
             "ico",
             "jpg",
             "lbm",
             "pbm",
             "pcx",
             "pgm",
             "png",
             "pnm",
             "ppm",
             "svg",
             "tga",
             "tif",
             "webp",
             "xcf",
             "xpm",
             #"xv",
             ]
  
  # SVG unsupported on SDL2_image < 2.0.2
  if sdlimage.dll.version < 2002:
      formats.remove("svg")
  
  # As of SDL2_image 2.0.5, XCF support seems to be broken on 32-bit builds
  # XCF support is also broken in official SDL2_image macOS .frameworks
  if is32bit or ismacos:
      formats.remove("xcf")
  
  # WEBP support seems to be broken in the 32-bit Windows SDL2_image 2.0.2 binary
  bad_webp = is32bit and sdlimage.dll.version == 2002
  if bad_webp:
      formats.remove("webp")
  
  
  def test_IMG_Linked_Version():
      v = sdlimage.IMG_Linked_Version()
      assert isinstance(v.contents, version.SDL_version)
      assert v.contents.major == 2
      assert v.contents.minor == 0
      assert v.contents.patch >= 1
  
  def test_IMG_Init():
      SDL_Init(0)
      supported = []
      libs = {
          'JPEG': sdlimage.IMG_INIT_JPG,
          'PNG': sdlimage.IMG_INIT_PNG,
          'TIFF': sdlimage.IMG_INIT_TIF,
          'WEBP': sdlimage.IMG_INIT_WEBP
      }
      for lib in libs.keys():
          flags = libs[lib]
          ret = sdlimage.IMG_Init(flags)
          err = sdlimage.IMG_GetError()
          if err:
              err = err.decode('utf-8')
              print("Error loading {0} library: {1}".format(lib, err))
              sdl2.SDL_ClearError()
          if ret & flags == flags:
              supported.append(lib)
          sdlimage.IMG_Quit()
      print("Supported image libraries:")
      print(supported)
      assert len(supported) == len(libs.keys())
  
  
  class TestSDLImage(object):
      __tags__ = ["sdl", "sdlimage"]
  
      @classmethod
      def setup_class(cls):
          flags = (
              sdlimage.IMG_INIT_JPG | sdlimage.IMG_INIT_PNG |
              sdlimage.IMG_INIT_TIF  | sdlimage.IMG_INIT_WEBP
          )
          SDL_Init(0)
          sdlimage.IMG_Init(flags)
  
      @classmethod
      def teardown_class(cls):
          sdlimage.IMG_Quit()
          SDL_Quit()
  
      def test_IMG_Load(self):
          fname = "surfacetest.%s"
          for fmt in formats:
              testdir = os.path.dirname(os.path.abspath(__file__))
              filename = os.path.join(testdir, "resources", fname % fmt)
              sf = sdlimage.IMG_Load(filename.encode("utf-8"))
              assert isinstance(sf.contents, surface.SDL_Surface)
              surface.SDL_FreeSurface(sf)
  
      def test_IMG_Load_RW(self):
          skip = ['tga'] # TGA broken for Load_RW
          fname = "surfacetest.%s"
          for fmt in formats:
              if fmt in skip:
                  continue
              testdir = os.path.dirname(os.path.abspath(__file__))
              filename = os.path.join(testdir, "resources", fname % fmt)
              with open(filename, "rb") as fp:
                  sf = sdlimage.IMG_Load_RW(rwops.rw_from_object(fp), False)
              assert isinstance(sf.contents, surface.SDL_Surface)
              surface.SDL_FreeSurface(sf)
  
      def test_IMG_LoadTexture(self):
          sf = surface.SDL_CreateRGBSurface(0, 10, 10, 32, 0, 0, 0, 0)
          rd = render.SDL_CreateSoftwareRenderer(sf)
          skip = []
          fname = "surfacetest.%s"
          for fmt in formats:
              if fmt in skip:
                  continue
              testdir = os.path.dirname(os.path.abspath(__file__))
              filename = os.path.join(testdir, "resources", fname % fmt)
              tex = sdlimage.IMG_LoadTexture(rd, filename.encode("utf-8"))
              assert isinstance(tex.contents, render.SDL_Texture)
              render.SDL_DestroyTexture(tex)
  
          #self.assertRaises(sdl.SDLError, sdlimage.load_texture, rd,
          #                  RESOURCES.get_path("rwopstest.txt"))
  
          #self.assertRaises(sdl.SDLError, sdlimage.load_texture, rd, None)
          #self.assertRaises(sdl.SDLError, sdlimage.load_texture, rd, 1234)
          #self.assertRaises((AttributeError, TypeError),
          #                  sdlimage.load_texture, None,
          #                  RESOURCES.get_path("surfacetest.bmp"))
          #self.assertRaises((AttributeError, TypeError),
          #                  sdlimage.load_texture, "Test",
          #                  RESOURCES.get_path("surfacetest.bmp"))
          #self.assertRaises((AttributeError, TypeError),
          #                  sdlimage.load_texture, 1234,
          #                  RESOURCES.get_path("surfacetest.bmp"))
  
          render.SDL_DestroyRenderer(rd)
          surface.SDL_FreeSurface(sf)
  
      def test_IMG_LoadTexture_RW(self):
          sf = surface.SDL_CreateRGBSurface(0, 10, 10, 32, 0, 0, 0, 0)
          rd = render.SDL_CreateSoftwareRenderer(sf)
          skip = ['svg', 'tga'] # TGA & SVG broken for LoadTexture_RW
          fname = "surfacetest.%s"
          for fmt in formats:
              if fmt in skip:
                  continue
              testdir = os.path.dirname(os.path.abspath(__file__))
              filename = os.path.join(testdir, "resources", fname % fmt)
              with open(filename, "rb") as fp:
                  tex = sdlimage.IMG_LoadTexture_RW(rd, rwops.rw_from_object(fp), 0)
                  assert tex is not None
                  assert isinstance(tex.contents, render.SDL_Texture)
                  render.SDL_DestroyTexture(tex)
  
          render.SDL_DestroyRenderer(rd)
          surface.SDL_FreeSurface(sf)
  
      def test_IMG_LoadTextureTyped_RW(self):
          sf = surface.SDL_CreateRGBSurface(0, 10, 10, 32, 0, 0, 0, 0)
          rd = render.SDL_CreateSoftwareRenderer(sf)
          skip = ['svg'] # SVG broken for LoadTextureTyped_RW
          fname = "surfacetest.%s"
          for fmt in formats:
              if fmt in skip:
                  continue
              testdir = os.path.dirname(os.path.abspath(__file__))
              filename = os.path.join(testdir, "resources", fname % fmt)
              with open(filename, "rb") as fp:
                  rw = rwops.rw_from_object(fp)
                  fmtx = fmt.upper().encode("utf-8")
                  tex = sdlimage.IMG_LoadTextureTyped_RW(rd, rw, 0, fmtx)
                  assert tex is not None
                  assert isinstance(tex.contents, render.SDL_Texture)
              render.SDL_DestroyTexture(tex)
          render.SDL_DestroyRenderer(rd)
          surface.SDL_FreeSurface(sf)
  
      def test_IMG_LoadTyped_RW(self):
          skip = []
          fname = "surfacetest.%s"
          for fmt in formats:
              if fmt in skip:
                  continue
              testdir = os.path.dirname(os.path.abspath(__file__))
              filename = os.path.join(testdir, "resources", fname % fmt)
              with open(filename, "rb") as fp:
                  sf = sdlimage.IMG_LoadTyped_RW(rwops.rw_from_object(fp), False,
                                              fmt.upper().encode("utf-8"))
                  assert isinstance(sf.contents, surface.SDL_Surface)
                  surface.SDL_FreeSurface(sf)
  
      def test_IMG_LoadBMP_RW(self):
          testdir = os.path.dirname(os.path.abspath(__file__))
          fp = open(os.path.join(testdir, "resources", "surfacetest.bmp"), "rb")
          sf = sdlimage.IMG_LoadBMP_RW(rwops.rw_from_object(fp))
          fp.close()
          assert isinstance(sf.contents, surface.SDL_Surface)
          surface.SDL_FreeSurface(sf)
  
      def test_IMG_LoadCUR_RW(self):
          testdir = os.path.dirname(os.path.abspath(__file__))
          fp = open(os.path.join(testdir, "resources", "surfacetest.cur"), "rb")
          sf = sdlimage.IMG_LoadCUR_RW(rwops.rw_from_object(fp))
          fp.close()
          assert isinstance(sf.contents, surface.SDL_Surface)
          surface.SDL_FreeSurface(sf)
  
      def test_IMG_LoadGIF_RW(self):
          testdir = os.path.dirname(os.path.abspath(__file__))
          fp = open(os.path.join(testdir, "resources", "surfacetest.gif"), "rb")
          sf = sdlimage.IMG_LoadGIF_RW(rwops.rw_from_object(fp))
          fp.close()
          assert isinstance(sf.contents, surface.SDL_Surface)
          surface.SDL_FreeSurface(sf)
  
      def test_IMG_LoadICO_RW(self):
          testdir = os.path.dirname(os.path.abspath(__file__))
          fp = open(os.path.join(testdir, "resources", "surfacetest.ico"), "rb")
          sf = sdlimage.IMG_LoadICO_RW(rwops.rw_from_object(fp))
          fp.close()
          assert isinstance(sf.contents, surface.SDL_Surface)
          surface.SDL_FreeSurface(sf)
  
      def test_IMG_LoadJPG_RW(self):
          testdir = os.path.dirname(os.path.abspath(__file__))
          fp = open(os.path.join(testdir, "resources", "surfacetest.jpg"), "rb")
          sf = sdlimage.IMG_LoadJPG_RW(rwops.rw_from_object(fp))
          fp.close()
          assert isinstance(sf.contents, surface.SDL_Surface)
          surface.SDL_FreeSurface(sf)
  
      def test_IMG_LoadLBM_RW(self):
          testdir = os.path.dirname(os.path.abspath(__file__))
          fp = open(os.path.join(testdir, "resources", "surfacetest.lbm"), "rb")
          sf = sdlimage.IMG_LoadLBM_RW(rwops.rw_from_object(fp))
          fp.close()
          assert isinstance(sf.contents, surface.SDL_Surface)
          surface.SDL_FreeSurface(sf)
  
      def test_IMG_LoadPCX_RW(self):
          testdir = os.path.dirname(os.path.abspath(__file__))
          fp = open(os.path.join(testdir, "resources", "surfacetest.pcx"), "rb")
          sf = sdlimage.IMG_LoadPCX_RW(rwops.rw_from_object(fp))
          fp.close()
          assert isinstance(sf.contents, surface.SDL_Surface)
          surface.SDL_FreeSurface(sf)
  
      def test_IMG_LoadPNG_RW(self):
          testdir = os.path.dirname(os.path.abspath(__file__))
          fp = open(os.path.join(testdir, "resources", "surfacetest.png"), "rb")
          sf = sdlimage.IMG_LoadPNG_RW(rwops.rw_from_object(fp))
          fp.close()
          assert isinstance(sf.contents, surface.SDL_Surface)
          surface.SDL_FreeSurface(sf)
  
      def test_IMG_LoadPNM_RW(self):
          testdir = os.path.dirname(os.path.abspath(__file__))
          fp = open(os.path.join(testdir, "resources", "surfacetest.pnm"), "rb")
          sf = sdlimage.IMG_LoadPNM_RW(rwops.rw_from_object(fp))
          fp.close()
          assert isinstance(sf.contents, surface.SDL_Surface)
          surface.SDL_FreeSurface(sf)
  
      @pytest.mark.skipif(sdlimage.dll.version < 2002, reason="Added in 2.0.2")
      def test_IMG_LoadSVG_RW(self):
          testdir = os.path.dirname(os.path.abspath(__file__))
          fp = open(os.path.join(testdir, "resources", "surfacetest.svg"), "rb")
          sf = sdlimage.IMG_LoadSVG_RW(rwops.rw_from_object(fp))
          fp.close()
          assert isinstance(sf.contents, surface.SDL_Surface)
          surface.SDL_FreeSurface(sf)
  
      def test_IMG_LoadTGA_RW(self):
          testdir = os.path.dirname(os.path.abspath(__file__))
          fp = open(os.path.join(testdir, "resources", "surfacetest.tga"), "rb")
          sf = sdlimage.IMG_LoadTGA_RW(rwops.rw_from_object(fp))
          fp.close()
          assert isinstance(sf.contents, surface.SDL_Surface)
          surface.SDL_FreeSurface(sf)
  
      def test_IMG_LoadTIF_RW(self):
          testdir = os.path.dirname(os.path.abspath(__file__))
          fp = open(os.path.join(testdir, "resources", "surfacetest.tif"), "rb")
          sf = sdlimage.IMG_LoadTIF_RW(rwops.rw_from_object(fp))
          fp.close()
          assert isinstance(sf.contents, surface.SDL_Surface)
          surface.SDL_FreeSurface(sf)
  
      @pytest.mark.xfail(bad_webp, reason="WEBP broken in 2.0.2 binaries for 32-bit Windows")
      def test_IMG_LoadWEBP_RW(self):
          testdir = os.path.dirname(os.path.abspath(__file__))
          fp = open(os.path.join(testdir, "resources", "surfacetest.webp"), "rb")
          sf = sdlimage.IMG_LoadWEBP_RW(rwops.rw_from_object(fp))
          fp.close()
          assert isinstance(sf.contents, surface.SDL_Surface)
          surface.SDL_FreeSurface(sf)
  
      @pytest.mark.xfail(is32bit or ismacos, reason="XCF currently broken on 32-bit and macOS")
      def test_IMG_LoadXCF_RW(self):
          testdir = os.path.dirname(os.path.abspath(__file__))
          fp = open(os.path.join(testdir, "resources", "surfacetest.xcf"), "rb")
          sf = sdlimage.IMG_LoadXCF_RW(rwops.rw_from_object(fp))
          fp.close()
          assert isinstance(sf.contents, surface.SDL_Surface)
          surface.SDL_FreeSurface(sf)
  
      def test_IMG_LoadXPM_RW(self):
          testdir = os.path.dirname(os.path.abspath(__file__))
          fp = open(os.path.join(testdir, "resources", "surfacetest.xpm"), "rb")
          sf = sdlimage.IMG_LoadXPM_RW(rwops.rw_from_object(fp))
          fp.close()
          assert isinstance(sf.contents, surface.SDL_Surface)
          surface.SDL_FreeSurface(sf)
  
      @pytest.mark.skip("not implemented")
      def test_IMG_LoadXV_RW(self):
          testdir = os.path.dirname(os.path.abspath(__file__))
          fp = open(os.path.join(testdir, "resources", "surfacetest.xv"), "rb")
          sf = sdlimage.IMG_LoadXV_RW(rwops.rw_from_object(fp))
          fp.close()
          assert isinstance(sf.contents, surface.SDL_Surface)
          surface.SDL_FreeSurface(sf)
  
      def test_IMG_isBMP(self):
          fname = "surfacetest.%s"
          for fmt in formats:
              testdir = os.path.dirname(os.path.abspath(__file__))
              filename = os.path.join(testdir, "resources", fname % fmt)
              with open(filename, "rb") as fp:
                  imgrw = rwops.rw_from_object(fp)
                  if fmt == "bmp":
                      assert sdlimage.IMG_isBMP(imgrw)
                  else:
                      assert not sdlimage.IMG_isBMP(imgrw)
  
      def test_IMG_isCUR(self):
          fname = "surfacetest.%s"
          for fmt in formats:
              testdir = os.path.dirname(os.path.abspath(__file__))
              filename = os.path.join(testdir, "resources", fname % fmt)
              with open(filename, "rb") as fp:
                  imgrw = rwops.rw_from_object(fp)
                  if fmt == "cur":
                      assert sdlimage.IMG_isCUR(imgrw)
                  else:
                      assert not sdlimage.IMG_isCUR(imgrw)
  
      def test_IMG_isGIF(self):
          fname = "surfacetest.%s"
          for fmt in formats:
              testdir = os.path.dirname(os.path.abspath(__file__))
              filename = os.path.join(testdir, "resources", fname % fmt)
              with open(filename, "rb") as fp:
                  imgrw = rwops.rw_from_object(fp)
                  if fmt == "gif":
                      assert sdlimage.IMG_isGIF(imgrw)
                  else:
                      assert not sdlimage.IMG_isGIF(imgrw)
  
      def test_IMG_isICO(self):
          fname = "surfacetest.%s"
          for fmt in formats:
              testdir = os.path.dirname(os.path.abspath(__file__))
              filename = os.path.join(testdir, "resources", fname % fmt)
              with open(filename, "rb") as fp:
                  imgrw = rwops.rw_from_object(fp)
                  if fmt == "ico":
                      assert sdlimage.IMG_isICO(imgrw)
                  else:
                      assert not sdlimage.IMG_isICO(imgrw)
  
      def test_IMG_isJPG(self):
          fname = "surfacetest.%s"
          for fmt in formats:
              testdir = os.path.dirname(os.path.abspath(__file__))
              filename = os.path.join(testdir, "resources", fname % fmt)
              with open(filename, "rb") as fp:
                  imgrw = rwops.rw_from_object(fp)
                  if fmt == "jpg":
                      assert sdlimage.IMG_isJPG(imgrw)
                  else:
                      assert not sdlimage.IMG_isJPG(imgrw)
  
      def test_IMG_isLBM(self):
          fname = "surfacetest.%s"
          for fmt in formats:
              testdir = os.path.dirname(os.path.abspath(__file__))
              filename = os.path.join(testdir, "resources", fname % fmt)
              with open(filename, "rb") as fp:
                  imgrw = rwops.rw_from_object(fp)
                  if fmt == "lbm":
                      assert sdlimage.IMG_isLBM(imgrw)
                  else:
                      assert not sdlimage.IMG_isLBM(imgrw)
  
      def test_IMG_isPCX(self):
          fname = "surfacetest.%s"
          for fmt in formats:
              testdir = os.path.dirname(os.path.abspath(__file__))
              filename = os.path.join(testdir, "resources", fname % fmt)
              with open(filename, "rb") as fp:
                  imgrw = rwops.rw_from_object(fp)
                  if fmt == "pcx":
                      assert sdlimage.IMG_isPCX(imgrw)
                  else:
                      assert not sdlimage.IMG_isPCX(imgrw)
  
      def test_IMG_isPNG(self):
          fname = "surfacetest.%s"
          for fmt in formats:
              testdir = os.path.dirname(os.path.abspath(__file__))
              filename = os.path.join(testdir, "resources", fname % fmt)
              with open(filename, "rb") as fp:
                  imgrw = rwops.rw_from_object(fp)
                  if fmt == "png":
                      assert sdlimage.IMG_isPNG(imgrw)
                  else:
                      assert not sdlimage.IMG_isPNG(imgrw)
  
      def test_IMG_isPNM(self):
          fname = "surfacetest.%s"
          for fmt in formats:
              testdir = os.path.dirname(os.path.abspath(__file__))
              filename = os.path.join(testdir, "resources", fname % fmt)
              with open(filename, "rb") as fp:
                  imgrw = rwops.rw_from_object(fp)
                  if fmt in ("pnm", "pbm", "ppm", "pgm"):
                      assert sdlimage.IMG_isPNM(imgrw)
                  else:
                      assert not sdlimage.IMG_isPNM(imgrw)
  
      @pytest.mark.skipif(sdlimage.dll.version < 2002, reason="Added in 2.0.2")
      def test_IMG_isSVG(self):
          fname = "surfacetest.%s"
          for fmt in formats:
              testdir = os.path.dirname(os.path.abspath(__file__))
              filename = os.path.join(testdir, "resources", fname % fmt)
              with open(filename, "rb") as fp:
                  imgrw = rwops.rw_from_object(fp)
                  if fmt == "svg":
                      assert sdlimage.IMG_isSVG(imgrw)
                  else:
                      assert not sdlimage.IMG_isSVG(imgrw)
  
      def test_IMG_isTIF(self):
          fname = "surfacetest.%s"
          for fmt in formats:
              testdir = os.path.dirname(os.path.abspath(__file__))
              filename = os.path.join(testdir, "resources", fname % fmt)
              with open(filename, "rb") as fp:
                  imgrw = rwops.rw_from_object(fp)
                  if fmt == "tif":
                      assert sdlimage.IMG_isTIF(imgrw)
                  else:
                      assert not sdlimage.IMG_isTIF(imgrw)
  
      def test_IMG_isWEBP(self):
          fname = "surfacetest.%s"
          for fmt in formats:
              testdir = os.path.dirname(os.path.abspath(__file__))
              filename = os.path.join(testdir, "resources", fname % fmt)
              with open(filename, "rb") as fp:
                  imgrw = rwops.rw_from_object(fp)
                  if fmt == "webp":
                      assert sdlimage.IMG_isWEBP(imgrw)
                  else:
                      assert not sdlimage.IMG_isWEBP(imgrw)
  
      @pytest.mark.xfail(ismacos, reason="XCF currently broken on macOS")
      def test_IMG_isXCF(self):
          fname = "surfacetest.%s"
          for fmt in formats:
              testdir = os.path.dirname(os.path.abspath(__file__))
              filename = os.path.join(testdir, "resources", fname % fmt)
              with open(filename, "rb") as fp:
                  imgrw = rwops.rw_from_object(fp)
                  if fmt == "xcf":
                      assert sdlimage.IMG_isXCF(imgrw)
                  else:
                      assert not sdlimage.IMG_isXCF(imgrw)
  
      def test_IMG_isXPM(self):
          fname = "surfacetest.%s"
          for fmt in formats:
              testdir = os.path.dirname(os.path.abspath(__file__))
              filename = os.path.join(testdir, "resources", fname % fmt)
              with open(filename, "rb") as fp:
                  imgrw = rwops.rw_from_object(fp)
                  if fmt == "xpm":
                      assert sdlimage.IMG_isXPM(imgrw)
                  else:
                      assert not sdlimage.IMG_isXPM(imgrw)
  
      @pytest.mark.skip("not implemented")
      def test_IMG_isXV(self):
          fname = "surfacetest.%s"
          for fmt in formats:
              testdir = os.path.dirname(os.path.abspath(__file__))
              filename = os.path.join(testdir, "resources", fname % fmt)
              with open(filename, "rb") as fp:
                  imgrw = rwops.rw_from_object(fp)
                  if fmt == "xv":
                      assert sdlimage.IMG_isXV(imgrw)
                  else:
                      assert not sdlimage.IMG_isXV(imgrw)
  
      @pytest.mark.skipif(hasattr(sys, "pypy_version_info"),
          reason="PyPy's ctypes fails to pass a correct string array")
      def test_IMG_ReadXPMFromArray(self):
          testdir = os.path.dirname(os.path.abspath(__file__))
          fp = open(os.path.join(testdir, "resources", "surfacetest.xpm"), "rb")
          xpm = b""
          fp.readline()  # /* XPM */
          fp.readline()  # static char * surfacetest_xpm[] = {
          lbuf = fp.readlines()
          fp.close()
          for line in lbuf:
              if line.endswith(b"};"):
                  xpm += line[1:-4]
              else:
                  xpm += line[1:-3]
          pxpm = ctypes.c_char_p(xpm)
          sf = sdlimage.IMG_ReadXPMFromArray(ctypes.byref(pxpm))
          assert isinstance(sf.contents, surface.SDL_Surface)
          surface.SDL_FreeSurface(sf)
  
      @pytest.mark.skip("not implemented")
      def test_IMG_SavePNG(self):
          pass
  
      @pytest.mark.skip("not implemented")
      def test_IMG_SavePNG_RW(self):
          pass
  
      @pytest.mark.skip("not implemented")
      def test_IMG_SaveJPG(self):
          pass
  
      @pytest.mark.skip("not implemented")
      def test_IMG_SaveJPG_RW(self):
          pass
  