Example #1
0
 def test_render_blended(self):
     filename = RESOURCES.get_path("tuffy.ttf")
     font = sdlttf.open_font(filename, 10)
     color = SDL_Color(0, 0, 0)
     sf = sdlttf.render_blended(font, "Example", color)
     self.assertIsInstance(sf, surface.SDL_Surface)
     surface.free_surface(sf)
Example #2
0
    def test_load_texture(self):
        sf = surface.create_rgb_surface(10, 10, 32)
        rd = render.create_software_renderer(sf)

        fname = "surfacetest.%s"
        for fmt in formats:
            filename = RESOURCES.get_path(fname % fmt)
            tex = sdlimage.load_texture(rd, filename)
            self.assertIsInstance(tex, render.SDL_Texture)
            render.destroy_texture(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.destroy_renderer(rd)
        surface.free_surface(sf)
Example #3
0
 def test_render_draw_point(self):
     points = ((-4, -3), (-4, 3), (4, -3),
               (0, 0), (1, 1), (10, 10), (99, 99),
               (4, 22), (57, 88), (45, 15),
               (100, 100)
               )
     r, g, b, a = 0xAA, 0xBB, 0xCC, 0xDD
     w, h = 100, 100
     sf = surface.create_rgb_surface(w, h, 32, 0xFF000000, 0x00FF0000,
                                     0x0000FF00, 0x000000FF)
     color = pixels.map_rgba(sf.format, r, g, b, a)
     renderer = render.create_software_renderer(sf)
     render.set_render_draw_color(renderer, r, g, b, a)
     for x, y in points:
         render.render_draw_point(renderer, x, y)
     render.render_present(renderer)
     view = pvid.PixelView(sf)
     for x, y in points:
         npx = max(x + 1, w)
         npy = max(y + 1, h)
         ppx = max(x - 1, 0)
         ppy = max(y - 1, 0)
         if x < 0 or x >= w or y < 0 or y >= h:
             continue
         self.assertEqual(hex(view[y][x]), hex(color))
         if (npx, npy) not in points:
             self.assertNotEqual(hex(view[npy][npx]), hex(color))
         if (ppx, ppy) not in points:
             self.assertNotEqual(hex(view[ppy][ppx]), hex(color))
     render.destroy_renderer(renderer)
     del view
     surface.free_surface(sf)
Example #4
0
 def test_load_typed_rw(self):
     fname = "surfacetest.%s"
     for fmt in formats:
         fp = RESOURCES.get(fname % fmt)
         sf = sdlimage.load_typed_rw(rwops.rw_from_object(fp), False, fmt.upper())
         self.assertIsInstance(sf, surface.SDL_Surface)
         surface.free_surface(sf)
Example #5
0
 def test_get_set_color_key(self):
     colorkeys = ((0, 0, 0),
                  (32, 64, 128),
                  (10, 20, 30),
                  (1, 2, 4),
                  (255, 255, 255),
                  (128, 128, 128),
                  (127, 127, 127),
                  )
     for fmt in pixels.ALL_PIXELFORMATS:
         if pixels.SDL_ISPIXELFORMAT_FOURCC(fmt):
             continue
         pformat = pixels.alloc_format(fmt)
         bpp, rmask, gmask, bmask, amask = \
             pixels.pixelformat_enum_to_masks(fmt)
         sf = surface.create_rgb_surface(10, 10, bpp, rmask, gmask, bmask,
                                         amask)
         for r, g, b in colorkeys:
             key = pixels.map_rgb(pformat, r, g, b)
             surface.set_color_key(sf, 1, key)
             skey = surface.get_color_key(sf)
             self.assertEqual(skey, key,
                 "Could not set color key (%d, %d, %d)" % (r, g, b))
         pixels.free_format(pformat)
         surface.free_surface(sf)
Example #6
0
    def test_get_set_clip_rect(self):
        rectlist = ((rect.SDL_Rect(0, 0, 0, 0), False, False),
                    (rect.SDL_Rect(2, 2, 0, 0), False, False),
                    (rect.SDL_Rect(2, 2, 5, 1), True, True),
                    (rect.SDL_Rect(6, 5, 10, 3), True, False),
                    (rect.SDL_Rect(0, 0, 10, 10), True, True),
                    (rect.SDL_Rect(0, 0, -10, 10), False, False),
                    (rect.SDL_Rect(0, 0, -10, -10), False, False),
                    (rect.SDL_Rect(-10, -10, 10, 10), False, False),
                    (rect.SDL_Rect(10, -10, 10, 10), False, False),
                    (rect.SDL_Rect(10, 10, 10, 10), True, False)
                    )

        sf = surface.create_rgb_surface(15, 15, 32)
        clip = surface.get_clip_rect(sf)
        self.assertIsInstance(clip, rect.SDL_Rect)
        self.assertEqual(clip, rect.SDL_Rect(0, 0, 15, 15))

        for r, clipsetval, cmpval in rectlist:
            retval = surface.set_clip_rect(sf, r)
            clip = surface.get_clip_rect(sf)
            self.assertEqual(retval, clipsetval,
                "Could not set clip rect %s" % r)
            self.assertEqual(clip == r, cmpval,
                "Could not set clip rect %s" % r)
        surface.free_surface(sf)
Example #7
0
    def test_fill_rects(self):
        rectlist = (rect.SDL_Rect(0, 0, 0, 0),
                    rect.SDL_Rect(0, 0, 10, 10),
                    rect.SDL_Rect(0, 0, -10, 10),
                    rect.SDL_Rect(0, 0, -10, -10),
                    rect.SDL_Rect(-10, -10, 10, 10),
                    rect.SDL_Rect(10, -10, 10, 10),
                    rect.SDL_Rect(10, 10, 10, 10),
                    )

        for fmt in pixels.ALL_PIXELFORMATS:
            if pixels.SDL_ISPIXELFORMAT_FOURCC(fmt):
                continue
            if pixels.SDL_BITSPERPIXEL(fmt) < 8:
                continue  # Skip < 8bpp, SDL_FillRect does not work on those
            for w in range(1, 100, 5):
                for h in range(1, 100, 5):
                    bpp, rmask, gmask, bmask, amask = \
                        pixels.pixelformat_enum_to_masks(fmt)
                    sf = surface.create_rgb_surface(w, h, bpp, rmask, gmask,
                                                    bmask, amask)
                    self.assertIsInstance(sf, surface.SDL_Surface)
                    # TODO: check for changed pixels
                    surface.fill_rects(sf, rectlist, 0xff00ff00)
                    surface.free_surface(sf)
Example #8
0
 def test_lock_unlock_MUSTLOCK_surface(self):
     colormods = ((0, 0, 0),
                  (32, 64, 128),
                  (10, 20, 30),
                  (1, 2, 4),
                  (255, 255, 255),
                  (128, 128, 128),
                  (127, 127, 127),
                  )
     for fmt in pixels.ALL_PIXELFORMATS:
         if pixels.SDL_ISPIXELFORMAT_FOURCC(fmt):
             continue
         bpp, rmask, gmask, bmask, amask = \
             pixels.pixelformat_enum_to_masks(fmt)
         sf = surface.create_rgb_surface(10, 10, bpp, rmask, gmask, bmask,
                                         amask)
         # TODO: locking seems to be only necessary for RLE surfaces...
         if surface.SDL_MUSTLOCK(sf):
             self.assertFalse(sf.locked)
             surface.lock_surface(sf)
             self.assertTrue(sf.locked)
             surface.lock_surface(sf)
             self.assertTrue(sf.locked)
             surface.lock_surface(sf)
             self.assertTrue(sf.locked)
             surface.unlock_surface(sf)
             self.assertTrue(sf.locked)
             surface.unlock_surface(sf)
             self.assertTrue(sf.locked)
             surface.unlock_surface(sf)
             self.assertFalse(sf.locked)
         surface.free_surface(sf)
Example #9
0
 def __del__(self):
     """Releases the bound SDL_Surface, if it was created by the
     SoftwareSprite.
     """
     surface = getattr(self, "surface", None)
     if self.free and surface is not None:
         sdlsurface.free_surface(surface)
     self.surface = None
Example #10
0
 def test_load_rw(self):
     fname = "surfacetest.%s"
     for fmt in formats:
         if fmt == "tga":
             # SDL_image does not support loading TGA via IMG_Load_RW()
             continue
         fp = RESOURCES.get(fname % fmt)
         sf = sdlimage.load_rw(rwops.rw_from_object(fp), False)
         self.assertIsInstance(sf, surface.SDL_Surface)
         surface.free_surface(sf)
Example #11
0
 def test_load(self):
     fname = "surfacetest.%s"
     for fmt in formats:
         filename = RESOURCES.get_path(fname % fmt)
         sf = sdlimage.load(filename)
         self.assertIsInstance(sf, surface.SDL_Surface)
         surface.free_surface(sf)
     self.assertRaises(sdl.SDLError, sdlimage.load, RESOURCES.get_path("rwopstest.txt"))
     self.assertRaises(sdl.SDLError, sdlimage.load, None)
     self.assertRaises(sdl.SDLError, sdlimage.load, 1234)
Example #12
0
    def test_load_bmp(self):
        fpath = os.path.join(os.path.dirname(__file__), "resources")
        imgpath = os.path.join(fpath, "surfacetest.bmp")
        imgsurface = surface.load_bmp(imgpath)
        self.assertIsInstance(imgsurface, surface.SDL_Surface)
        surface.free_surface(imgsurface)

        self.assertRaises(sdl.SDLError, surface.load_bmp, "invalid path")
        self.assertRaises(sdl.SDLError, surface.load_bmp, None)
        self.assertRaises(sdl.SDLError, surface.load_bmp, 1234)
Example #13
0
    def test_load_bmp_rw(self):
        imgfile = RESOURCES.get("surfacetest.bmp")
        imgrw = rwops.rw_from_object(imgfile)
        imgsurface = surface.load_bmp_rw(imgrw, False)
        self.assertIsInstance(imgsurface, surface.SDL_Surface)
        surface.free_surface(imgsurface)

        self.assertRaises(TypeError, surface.load_bmp_rw, "Test")
        self.assertRaises(TypeError, surface.load_bmp_rw, None)
        self.assertRaises(TypeError, surface.load_bmp_rw, 1234)
Example #14
0
    def test_create_software_renderer(self):
        sf = surface.create_rgb_surface(100, 100, 32, 0xFF000000, 0x00FF0000,
                                        0x0000FF00, 0x000000FF)
        renderer = render.create_software_renderer(sf)
        self.assertIsInstance(renderer, render.SDL_Renderer)
        render.destroy_renderer(renderer)
        surface.free_surface(sf)

        self.assertRaises((AttributeError, TypeError),
                          render.create_software_renderer, None)
        self.assertRaises((AttributeError, TypeError),
                          render.create_software_renderer, 1234)
Example #15
0
    def test_load_texture_typed_rw(self):
        sf = surface.create_rgb_surface(10, 10, 32)
        rd = render.create_software_renderer(sf)

        fname = "surfacetest.%s"
        for fmt in formats:
            fp = RESOURCES.get(fname % fmt)
            tex = sdlimage.load_texture_typed_rw(rd, rwops.rw_from_object(fp), False, fmt.upper())
            self.assertIsInstance(tex, render.SDL_Texture)
            render.destroy_texture(tex)
        render.destroy_renderer(rd)
        surface.free_surface(sf)
Example #16
0
 def test_create_rgb_surface_from(self):
     for buf, bpp, pitch, masks, fmt in rgba_pixelations_16x16:
         arflag = None
         if bpp == 32:
             arflag = "I"
         elif bpp == 16:
             arflag = "H"
         bytebuf = pgarray.CTypesView(array.array(arflag, buf))
         sf = surface.create_rgb_surface_from(bytebuf.to_bytes(), 16, 16,
                                              bpp, pitch, masks[0],
                                              masks[1], masks[2], masks[3])
         self.assertIsInstance(sf, surface.SDL_Surface)
         surface.free_surface(sf)
Example #17
0
 def test_read_xpm_from_array(self):
     fp = RESOURCES.get("surfacetest.xpm")
     xpm = b""
     fp.readline()  # /* XPM */
     fp.readline()  # static char * surfacetest_xpm[] = {
     lbuf = fp.readlines()
     for line in lbuf:
         if line.endswith(b"};"):
             xpm += line[1:-4]
         else:
             xpm += line[1:-3]
     sf = sdlimage.read_xpm_from_array(xpm)
     self.assertIsInstance(sf, surface.SDL_Surface)
     surface.free_surface(sf)
Example #18
0
 def test_get_set_surface_alpha_mod(self):
     for fmt in pixels.ALL_PIXELFORMATS:
         if pixels.SDL_ISPIXELFORMAT_FOURCC(fmt):
             continue
         bpp, rmask, gmask, bmask, amask = \
             pixels.pixelformat_enum_to_masks(fmt)
         sf = surface.create_rgb_surface(10, 10, bpp, rmask, gmask, bmask,
                                         amask)
         salpha = surface.get_surface_alpha_mod(sf)
         self.assertEqual(salpha, 255)
         for alpha in range(0, 255):
             surface.set_surface_alpha_mod(sf, alpha)
             salpha = surface.get_surface_alpha_mod(sf)
             self.assertEqual(salpha, alpha)
         surface.free_surface(sf)
Example #19
0
    def from_surface(self, surface, free=False):
        """Creates a Sprite from the passed SDL_Surface.

        If free is set to True, the passed surface will be freed
        automatically.
        """
        if self.sprite_type == TEXTURE:
            renderer = self.default_args["renderer"]
            texture = render.create_texture_from_surface(renderer.renderer, surface)
            s = TextureSprite(texture)
            if free:
                sdlsurface.free_surface(surface)
        elif self.sprite_type == SOFTWARE:
            s = SoftwareSprite(surface, free)
        return s
Example #20
0
    def test_load_texture_rw(self):
        sf = surface.create_rgb_surface(10, 10, 32)
        rd = render.create_software_renderer(sf)

        fname = "surfacetest.%s"
        for fmt in formats:
            if fmt == "tga":
                # SDL_image does not support loading TGA via
                # IMG_LoadTexture_RW()
                continue
            fp = RESOURCES.get(fname % fmt)
            tex = sdlimage.load_texture_rw(rd, rwops.rw_from_object(fp), False)
            self.assertIsInstance(tex, render.SDL_Texture)
            render.destroy_texture(tex)

        render.destroy_renderer(rd)
        surface.free_surface(sf)
Example #21
0
 def test_get_set_surface_blend_mode(self):
     modes = (video.SDL_BLENDMODE_NONE,
              video.SDL_BLENDMODE_BLEND,
              video.SDL_BLENDMODE_ADD,
              video.SDL_BLENDMODE_MOD
              )
     for fmt in pixels.ALL_PIXELFORMATS:
         if pixels.SDL_ISPIXELFORMAT_FOURCC(fmt):
             continue
         bpp, rmask, gmask, bmask, amask = \
             pixels.pixelformat_enum_to_masks(fmt)
         sf = surface.create_rgb_surface(10, 10, bpp, rmask, gmask, bmask,
                                         amask)
         for mode in modes:
             surface.set_surface_blend_mode(sf, mode)
             smode = surface.get_surface_blend_mode(sf)
             self.assertEqual(smode, mode)
         surface.free_surface(sf)
Example #22
0
    def test_blit_surface(self):
        bpp = 32
        w, h = 10, 10
        # no alpha to prevent blending
        masks = (0xFF000000, 0x00FF0000, 0x0000FF00, 0x00000000)
        dest = surface.create_rgb_surface(w, h, bpp, masks[0], masks[1],
                                          masks[2], masks[3])
        pixelsize = h * dest.pitch
        rowlen = dest.pitch // 4

        sources = []
        for width, height in blitsizes:
            src = surface.create_rgb_surface(width, height, bpp, masks[0],
                                             masks[1], masks[2], masks[3])
            surface.fill_rect(src, None, 0xFFFFFFFF)  # fill with white
            sources.append(src)

        for src in sources:
            for pos in blitpositions:
                drect = pos.__copy__()
                surface.fill_rect(dest, None, 0x0)  # fill with black
                surface.blit_surface(src, None, dest, drect)
                buf = ctypes.cast(dest.pixels,
                                  ctypes.POINTER(ctypes.c_ubyte * pixelsize))
                pbuf = pgarray.CTypesView(buf.contents, itemsize=1,
                                          objsize=pixelsize)
                iview = pbuf.to_uint32()
                pw = drect.x + drect.w
                ph = drect.y + drect.h
                for y in range(dest.size[1]):
                    for x in range(dest.size[0]):
                        col = iview[y * rowlen + x]
                        if y >= drect.y and y < ph and \
                                x >= drect.x and x < pw:
                            self.assertEqual(col, 0xFFFFFFFF, msg="""color
mismatch at %d,%d for %s: %d != %d""" % (y, x, pos, col, 0xFFFFFFFF))
                        else:
                            self.assertEqual(col, 0x0, msg="""color mismatch
at %d,%d for %s: %d != %d""" % (y, x, pos, col, 0x0))

        while len(sources) > 0:
            sf = sources.pop()
            surface.free_surface(sf)
        surface.free_surface(dest)
Example #23
0
    def test_create_rgb_surface(self):
        for w in range(1, 100, 5):
            for h in range(1, 100, 5):
                for bpp in alldepths:
                    sf = surface.create_rgb_surface(w, h, bpp)
                    self.assertIsInstance(sf, surface.SDL_Surface)
                    surface.free_surface(sf)

        for fmt in pixels.ALL_PIXELFORMATS:
            if pixels.SDL_ISPIXELFORMAT_FOURCC(fmt):
                continue
            for w in range(1, 100, 5):
                for h in range(1, 100, 5):
                    bpp, rmask, gmask, bmask, amask = \
                        pixels.pixelformat_enum_to_masks(fmt)
                    sf = surface.create_rgb_surface(w, h, bpp, rmask, gmask,
                                                    bmask, amask)
                    self.assertIsInstance(sf, surface.SDL_Surface)
                    surface.free_surface(sf)

        # Broken ones
        # sizes = [(0, 0), (65536, 65536)]
        # for (w, h) in sizes:
        #    for bpp in alldepths:
        #        print w, h, bpp
        #        sf = surface.create_rgb_surface(w, h, bpp)
        #        self.assertIsInstance(sf, surface.SDL_Surface)
        #        surface.free_surface(sf)
        
        # TODO: raises a SDL Out of memory error, but 65536 works?!
        #
        # sf = surface.create_rgb_surface(65535, 65535, 32)
        # self.assertIsInstance(sf, surface.SDL_Surface)
        
        self.assertRaises(sdl.SDLError, surface.create_rgb_surface, 1, 1, 66)
        self.assertRaises(sdl.SDLError, surface.create_rgb_surface, 1, 1, 0)
        self.assertRaises(sdl.SDLError, surface.create_rgb_surface, 1, 1, 8,
                          0xf0, 0x0f, 0x01, 0x02)
        self.assertRaises(sdl.SDLError, surface.create_rgb_surface, 1, 1, 16,
                          0xf0, 0x0f, 0x01, 0x02)
        self.assertRaises(sdl.SDLError, surface.create_rgb_surface, 1, 1, 24,
                          0xf0, 0x0f, 0x01, 0x02)
        self.assertRaises(sdl.SDLError, surface.create_rgb_surface, 1, 1, 32,
                          0xf0, 0x0f, 0x01, 0x02)
Example #24
0
 def test_convert_surface_format(self):
     pfmt = pixels.SDL_PIXELFORMAT_RGB444
     for fmt in pixels.ALL_PIXELFORMATS:
         if pixels.SDL_ISPIXELFORMAT_FOURCC(fmt):
             continue
         if fmt in (pixels.SDL_PIXELFORMAT_RGB332,
                    pixels.SDL_PIXELFORMAT_ARGB2101010):
             # SDL2 segault in the DUFFS_LOOP() macros
             # http://bugzilla.libsdl.org/show_bug.cgi?id=1534
             continue
         bpp, rmask, gmask, bmask, amask = \
             pixels.pixelformat_enum_to_masks(fmt)
         sf = surface.create_rgb_surface(10, 20, bpp, rmask, gmask,
                                         bmask, amask)
         self.assertIsInstance(sf, surface.SDL_Surface)
         csf = surface.convert_surface_format(sf, pfmt, 0)
         self.assertIsInstance(csf, surface.SDL_Surface)
         surface.free_surface(sf)
         surface.free_surface(csf)
Example #25
0
 def _render_text(self):
     """ renders bw blended text. tinting is done in the shader. """
     self.surface.fill((0,0,0,0))
     i = 0
     dump = False
     for s in self.strings:
         if len(s) > 0:
             if isinstance(self.data, dict):
                 s = s.format(**self.data)
             strsurf = sdlttf.render_blended(self.font, s, SDL_Color())
             # since we render with white, we can set the pixelformat
             # to anything that starts with 'A' and has the same bpp and amask,
             # thus avoiding extra blit cost
             # or we can just render_shaded and use that as the alpha channel.
             
             self.surface.blit(strsurf, (self.padding, self.padding + i * self.ystep))
             sdlsurface.free_surface(strsurf)
         i += 1
     self.surface.upload_tex2d(self._texture_name)
     self._surface_dirty = False
Example #26
0
    def test_free_surface(self):
        self.assertRaises((AttributeError, TypeError),
                          surface.free_surface, None)
        self.assertRaises((AttributeError, TypeError),
                          surface.free_surface, "Test")
        self.assertRaises((AttributeError, TypeError),
                          surface.free_surface, 5)

        formats = (pixels.SDL_PIXELFORMAT_INDEX1LSB,
                   pixels.SDL_PIXELFORMAT_RGB332,
                   pixels.SDL_PIXELFORMAT_RGBA4444,
                   pixels.SDL_PIXELFORMAT_BGR888,
                   pixels.SDL_PIXELFORMAT_ARGB8888,
                   pixels.SDL_PIXELFORMAT_ARGB2101010
                   )
        for fmt in formats:
            bpp, rmask, gmask, bmask, amask = \
                pixels.pixelformat_enum_to_masks(fmt)
            sf = surface.create_rgb_surface(5, 5, bpp, rmask, gmask, bmask,
                                            amask)
            surface.free_surface(sf)
Example #27
0
 def test_get_set_surface_color_mod(self):
     colormods = ((0, 0, 0),
                  (32, 64, 128),
                  (10, 20, 30),
                  (1, 2, 4),
                  (255, 255, 255),
                  (128, 128, 128),
                  (127, 127, 127),
                  )
     for fmt in pixels.ALL_PIXELFORMATS:
         if pixels.SDL_ISPIXELFORMAT_FOURCC(fmt):
             continue
         bpp, rmask, gmask, bmask, amask = \
             pixels.pixelformat_enum_to_masks(fmt)
         sf = surface.create_rgb_surface(10, 10, bpp, rmask, gmask, bmask,
                                         amask)
         for r, g, b in colormods:
             surface.set_surface_color_mod(sf, r, g, b)
             sr, sg, sb = surface.get_surface_color_mod(sf)
             self.assertEqual((sr, sg, sb), (r, g, b))
         surface.free_surface(sf)
Example #28
0
    def test_set_surface_palette(self):
        invpalette = pixels.alloc_palette(10)
        palette = pixels.alloc_palette(1 << 16)
        sf = surface.create_rgb_surface(10, 10, 16)

        self.assertRaises((AttributeError, TypeError),
                          surface.set_surface_palette, None, None)
        self.assertRaises((AttributeError, TypeError),
                          surface.set_surface_palette, None, palette)
        self.assertIsNone(sf.format.palette)
        surface.set_surface_palette(sf, palette)
        self.assertIsNotNone(sf.format.palette)
        self.assertRaises(sdl.SDLError, surface.set_surface_palette, sf,
                          invpalette)
        self.assertIsNotNone(sf.format.palette)
        surface.set_surface_palette(sf, None)
        self.assertIsNone(sf.format.palette)

        surface.free_surface(sf)
        pixels.free_palette(invpalette)
        pixels.free_palette(palette)
Example #29
0
    def test_convert_surface(self):
        pfmt = pixels.alloc_format(pixels.SDL_PIXELFORMAT_RGB444)
        for fmt in pixels.ALL_PIXELFORMATS:
            if pixels.SDL_ISPIXELFORMAT_FOURCC(fmt):
                continue
            if fmt in (pixels.SDL_PIXELFORMAT_RGB332,
                       pixels.SDL_PIXELFORMAT_ARGB2101010):
                # SDL2 segfault in the DUFFS_LOOOP() macros
                # http://bugzilla.libsdl.org/show_bug.cgi?id=1534
                continue
            bpp, rmask, gmask, bmask, amask = \
                pixels.pixelformat_enum_to_masks(fmt)
            sf = surface.create_rgb_surface(10, 20, bpp, rmask, gmask,
                                            bmask, amask)
            self.assertIsInstance(sf, surface.SDL_Surface)
            csf = surface.convert_surface(sf, pfmt, 0)
            self.assertIsInstance(csf, surface.SDL_Surface)
            surface.free_surface(sf)
            surface.free_surface(csf)

        sf = surface.create_rgb_surface(10, 10, 32, 0, 0, 0)
        self.assertRaises((AttributeError, TypeError),
                          surface.convert_surface, None, None, None)
        self.assertRaises((AttributeError, TypeError),
                          surface.convert_surface, sf, None, None)
        self.assertRaises((AttributeError, TypeError),
                          surface.convert_surface, sf, "Test", 0)
        self.assertRaises((AttributeError, TypeError),
                          surface.convert_surface, sf, 12345, 0)
        self.assertRaises((AttributeError, TypeError),
                          surface.convert_surface, None, pfmt, 0)
        self.assertRaises((AttributeError, TypeError),
                          surface.convert_surface, "Test", pfmt, 0)
        self.assertRaises((AttributeError, TypeError),
                          surface.convert_surface, 12345, pfmt, 0)
        pixels.free_format(pfmt)
        surface.free_surface(sf)
Example #30
0
 def test_load_xv_rw(self):
     fp = RESOURCES.get("surfacetest.xv")
     sf = sdlimage.load_xpm_rw(rwops.rw_from_object(fp))
     self.assertIsInstance(sf, surface.SDL_Surface)
     surface.free_surface(sf)