SpringFocus/venv/lib/python3.8/site-packages/pygame-1.9.6-py3.8-linux-x86_64.egg/pygame/tests/pixelarray_test.py

import sys
import platform
try:
    reduce
except NameError:
    from functools import reduce
import operator
import weakref
import gc
import unittest

from pygame.tests.test_utils import SurfaceSubclass

try:
    from pygame.tests.test_utils import arrinter
except NameError:
    pass

import pygame
from pygame.compat import xrange_

PY3 = sys.version_info >= (3, 0, 0)
IS_PYPY = 'PyPy' == platform.python_implementation()


class TestMixin (object):
    def assert_surfaces_equal (self, s1, s2):
        # Assumes the surfaces are the same size.
        w, h = s1.get_size ()
        for x in range (w):
            for y in range (h):
                self.assertEqual (s1.get_at ((x, y)), s2.get_at ((x, y)),
                                  "size: (%i, %i), position: (%i, %i)" %
                                  (w, h, x, y))

class PixelArrayTypeTest (unittest.TestCase, TestMixin):
    def test_compare(self):
        # __doc__ (as of 2008-06-25) for pygame.pixelarray.PixelArray.compare:

          # PixelArray.compare (array, distance=0, weights=(0.299, 0.587, 0.114)): Return PixelArray
          # Compares the PixelArray with another one.

        w = 10
        h = 20
        size = w, h
        sf = pygame.Surface (size, 0, 32)
        ar = pygame.PixelArray (sf)
        sf2 = pygame.Surface (size, 0, 32)
        self.assertRaises (TypeError, ar.compare, sf2)
        ar2 = pygame.PixelArray (sf2)
        ar3 = ar.compare (ar2)
        self.assertTrue(isinstance (ar3, pygame.PixelArray))
        self.assertEqual (ar3.shape, size)
        sf2.fill (pygame.Color ('white'))
        self.assert_surfaces_equal (sf2, ar3.surface)
        del ar3
        r = pygame.Rect (2, 5, 6, 13)
        sf.fill (pygame.Color ('blue'), r)
        sf2.fill (pygame.Color ('red'))
        sf2.fill (pygame.Color ('blue'), r)
        ar3 = ar.compare (ar2)
        sf.fill (pygame.Color ('white'), r)
        self.assert_surfaces_equal (sf, ar3.surface)

        # FINISH ME!
        # Test other bit depths, slices, and distance != 0.

    def test_close(self):
        """ does not crash when it is deleted.
        """
        s = pygame.Surface((10,10))
        a = pygame.PixelArray(s)
        a.close()
        del a

    def test_close_raises(self):
        """ when you try to do an operation after it is closed.
        """
        s = pygame.Surface((10,10))
        a = pygame.PixelArray(s)
        a.close()
        def do_operation():
            a[:]
        self.assertRaises (ValueError, do_operation)

        def do_operation2():
            a[:] = 1
        self.assertRaises (ValueError, do_operation2)

        def do_operation3():
            a.make_surface()
        self.assertRaises (ValueError, do_operation3)

        def do_operation4():
            for x in a:
                pass
        self.assertRaises (ValueError, do_operation4)

    def test_context_manager(self):
        """ closes properly.
        """
        s = pygame.Surface((10,10))
        with pygame.PixelArray(s) as a:
            a[:]

    def test_pixel_array (self):
        for bpp in (8, 16, 24, 32):
            sf = pygame.Surface ((10, 20), 0, bpp)
            sf.fill ((0, 0, 0))
            ar = pygame.PixelArray (sf)

            self.assertEqual (ar._pixels_address, sf._pixels_address)

            if sf.mustlock ():
                self.assertTrue (sf.get_locked ())

            self.assertEqual (len (ar), 10)

            del ar
            if sf.mustlock ():
                self.assertFalse (sf.get_locked ())

    def test_as_class (self):
        # Check general new-style class freatures.
        sf = pygame.Surface ((2, 3), 0, 32)
        ar = pygame.PixelArray (sf)
        self.assertRaises (AttributeError, getattr, ar, 'nonnative')
        ar.nonnative = 'value'
        self.assertEqual (ar.nonnative, 'value')
        r = weakref.ref (ar)
        self.assertTrue (r() is ar)
        del ar
        gc.collect ()
        self.assertTrue (r() is None)

        class C (pygame.PixelArray):
            def __str__ (self):
                return "string (%i, %i)" % self.shape

        ar = C (sf)
        self.assertEqual (str (ar), "string (2, 3)")
        r = weakref.ref (ar)
        self.assertTrue (r() is ar)
        del ar
        gc.collect ()
        self.assertTrue (r() is None)

    def test_pixelarray__subclassed_surface(self):
        """Ensure the PixelArray constructor accepts subclassed surfaces."""
        surface = SurfaceSubclass((3, 5), 0, 32)
        pixelarray = pygame.PixelArray(surface)

        self.assertIsInstance(pixelarray, pygame.PixelArray)

    # Sequence interfaces
    def test_get_column (self):
        for bpp in (8, 16, 24, 32):
            sf = pygame.Surface ((6, 8), 0, bpp)
            sf.fill ((0, 0, 255))
            val = sf.map_rgb ((0, 0, 255))
            ar = pygame.PixelArray (sf)

            ar2 = ar.__getitem__ (1)
            self.assertEqual (len(ar2), 8)
            self.assertEqual (ar2.__getitem__ (0), val)
            self.assertEqual (ar2.__getitem__ (1), val)
            self.assertEqual (ar2.__getitem__ (2), val)

            ar2 = ar.__getitem__ (-1)
            self.assertEqual (len(ar2), 8)
            self.assertEqual (ar2.__getitem__ (0), val)
            self.assertEqual (ar2.__getitem__ (1), val)
            self.assertEqual (ar2.__getitem__ (2), val)

    def test_get_pixel (self):
        w = 10
        h = 20
        size = w, h
        bg_color = (0, 0, 255)
        fg_color_y = (0, 0, 128)
        fg_color_x = (0, 0, 11)
        for bpp in (8, 16, 24, 32):
            sf = pygame.Surface (size, 0, bpp)
            mapped_bg_color = sf.map_rgb (bg_color)
            mapped_fg_color_y = sf.map_rgb (fg_color_y)
            mapped_fg_color_x = sf.map_rgb (fg_color_x)
            self.assertNotEqual (mapped_fg_color_y, mapped_bg_color,
                                 "Unusable test colors for bpp %i" % (bpp,))
            self.assertNotEqual (mapped_fg_color_x, mapped_bg_color,
                                 "Unusable test colors for bpp %i" % (bpp,))
            self.assertNotEqual (mapped_fg_color_y, mapped_fg_color_x,
                                 "Unusable test colors for bpp %i" % (bpp,))
            sf.fill (bg_color)

            ar = pygame.PixelArray (sf)

            ar_y = ar.__getitem__ (1)
            for y in xrange_ (h):
                ar2 = ar_y.__getitem__ (y)
                self.assertEqual (ar2, mapped_bg_color,
                                  "ar[1][%i] == %i, mapped_bg_color == %i" %
                                  (y, ar2, mapped_bg_color))

                sf.set_at ((1, y), fg_color_y)
                ar2 = ar_y.__getitem__ (y)
                self.assertEqual (ar2, mapped_fg_color_y,
                                  "ar[1][%i] == %i, mapped_fg_color_y == %i" %
                                  (y, ar2, mapped_fg_color_y))

            sf.set_at ((1, 1), bg_color)
            for x in xrange_ (w):
                ar2 = ar.__getitem__ (x).__getitem__ (1)
                self.assertEqual (ar2, mapped_bg_color,
                                  "ar[%i][1] = %i, mapped_bg_color = %i" %
                                  (x, ar2, mapped_bg_color))
                sf.set_at ((x, 1), fg_color_x)
                ar2 = ar.__getitem__ (x).__getitem__ (1)
                self.assertEqual (ar2, mapped_fg_color_x,
                                  "ar[%i][1] = %i, mapped_fg_color_x = %i" %
                                  (x, ar2, mapped_fg_color_x))

            ar2 = ar.__getitem__ (0).__getitem__ (0)
            self.assertEqual (ar2, mapped_bg_color, "bpp = %i" % (bpp,))

            ar2 = ar.__getitem__ (1).__getitem__ (0)
            self.assertEqual (ar2, mapped_fg_color_y, "bpp = %i" % (bpp,))

            ar2 = ar.__getitem__ (-4).__getitem__ (1)
            self.assertEqual (ar2, mapped_fg_color_x, "bpp = %i" % (bpp,))

            ar2 = ar.__getitem__ (-4).__getitem__ (5)
            self.assertEqual (ar2, mapped_bg_color, "bpp = %i" % (bpp,))

            ar2 = ar.__getitem__ (-4).__getitem__ (0)
            self.assertEqual (ar2, mapped_bg_color, "bpp = %i" % (bpp,))

            ar2 = ar.__getitem__ (-w + 1).__getitem__ (0)
            self.assertEqual (ar2, mapped_fg_color_y, "bpp = %i" % (bpp,))

            ar2 = ar.__getitem__ (-w).__getitem__ (0)
            self.assertEqual (ar2, mapped_bg_color, "bpp = %i" % (bpp,))

            ar2 = ar.__getitem__ (5).__getitem__ (-4)
            self.assertEqual (ar2, mapped_bg_color, "bpp = %i" % (bpp,))

            ar2 = ar.__getitem__ (5).__getitem__ (-h + 1)
            self.assertEqual (ar2, mapped_fg_color_x, "bpp = %i" % (bpp,))

            ar2 = ar.__getitem__ (5).__getitem__ (-h)
            self.assertEqual (ar2, mapped_bg_color, "bpp = %i" % (bpp,))

            ar2 = ar.__getitem__ (0).__getitem__ (-h + 1)
            self.assertEqual (ar2, mapped_fg_color_x, "bpp = %i" % (bpp,))

            ar2 = ar.__getitem__ (0).__getitem__ (-h)
            self.assertEqual (ar2, mapped_bg_color, "bpp = %i" % (bpp,))

    def test_set_pixel (self):
        for bpp in (8, 16, 24, 32):
            sf = pygame.Surface ((10, 20), 0, bpp)
            sf.fill ((0, 0, 0))
            ar = pygame.PixelArray (sf)

            ar.__getitem__ (0).__setitem__ (0, (0, 255, 0))
            self.assertEqual (ar[0][0], sf.map_rgb ((0, 255, 0)))

            ar.__getitem__ (1).__setitem__ (1, (128, 128, 128))
            self.assertEqual (ar[1][1], sf.map_rgb ((128, 128, 128)))

            ar.__getitem__(-1).__setitem__ (-1, (128, 128, 128))
            self.assertEqual (ar[9][19], sf.map_rgb ((128, 128, 128)))

            ar.__getitem__ (-2).__setitem__ (-2, (128, 128, 128))
            self.assertEqual (ar[8][-2], sf.map_rgb ((128, 128, 128)))

    def test_set_column (self):
        for bpp in (8, 16, 24, 32):
            sf = pygame.Surface ((6, 8), 0, bpp)
            sf.fill ((0, 0, 0))
            ar = pygame.PixelArray (sf)

            sf2 = pygame.Surface ((6, 8), 0, bpp)
            sf2.fill ((0, 255, 255))
            ar2 = pygame.PixelArray (sf2)

            # Test single value assignment
            ar.__setitem__ (2, (128, 128, 128))
            self.assertEqual (ar[2][0], sf.map_rgb ((128, 128, 128)))
            self.assertEqual (ar[2][1], sf.map_rgb ((128, 128, 128)))

            ar.__setitem__ (-1, (0, 255, 255))
            self.assertEqual (ar[5][0], sf.map_rgb ((0, 255, 255)))
            self.assertEqual (ar[-1][1], sf.map_rgb ((0, 255, 255)))

            ar.__setitem__ (-2, (255, 255, 0))
            self.assertEqual (ar[4][0], sf.map_rgb ((255, 255, 0)))
            self.assertEqual (ar[-2][1], sf.map_rgb ((255, 255, 0)))

            # Test list assignment.
            ar.__setitem__ (0, [(255, 255, 255)] * 8)
            self.assertEqual (ar[0][0], sf.map_rgb ((255, 255, 255)))
            self.assertEqual (ar[0][1], sf.map_rgb ((255, 255, 255)))

            # Test tuple assignment.
            # Changed in Pygame 1.9.2 - Raises an exception.
            self.assertRaises (ValueError, ar.__setitem__, 1,
                               ((204, 0, 204), (17, 17, 17), (204, 0, 204),
                                (17, 17, 17), (204, 0, 204), (17, 17, 17),
                                (204, 0, 204), (17, 17, 17)))

            # Test pixel array assignment.
            ar.__setitem__ (1, ar2.__getitem__ (3))
            self.assertEqual (ar[1][0], sf.map_rgb ((0, 255, 255)))
            self.assertEqual (ar[1][1], sf.map_rgb ((0, 255, 255)))

    def test_get_slice (self):
        for bpp in (8, 16, 24, 32):
            sf = pygame.Surface ((10, 20), 0, bpp)
            sf.fill ((0, 0, 0))
            ar = pygame.PixelArray (sf)

            self.assertEqual (len (ar[0:2]), 2)
            self.assertEqual (len (ar[3:7][3]), 20)

            self.assertEqual (ar[0:0], None)
            self.assertEqual (ar[5:5], None)
            self.assertEqual (ar[9:9], None)

            # Has to resolve to ar[7:8]
            self.assertEqual (len (ar[-3:-2]), 1)      # 2D
            self.assertEqual (len (ar[-3:-2][0]), 20)  # 1D

            # Try assignments.

            # 2D assignment.
            ar[2:5] = (255, 255, 255)

            # 1D assignment
            ar[3][3:7] = (10, 10, 10)
            self.assertEqual (ar[3][5], sf.map_rgb ((10, 10, 10)))
            self.assertEqual (ar[3][6], sf.map_rgb ((10, 10, 10)))

    @unittest.skipIf(IS_PYPY, 'skipping for PyPy (segfaults on mac pypy3 6.0.0)')
    def test_contains (self):
        for bpp in (8, 16, 24, 32):
            sf = pygame.Surface ((10, 20), 0, bpp)
            sf.fill ((0, 0, 0))
            sf.set_at ((8, 8), (255, 255, 255))

            ar = pygame.PixelArray (sf)
            self.assertTrue ((0, 0, 0) in ar)
            self.assertTrue ((255, 255, 255) in ar)
            self.assertFalse ((255, 255, 0) in ar)
            self.assertFalse (0x0000ff in ar)

            # Test sliced array
            self.assertTrue ((0, 0, 0) in ar[8])
            self.assertTrue ((255, 255, 255) in ar[8])
            self.assertFalse ((255, 255, 0) in ar[8])
            self.assertFalse (0x0000ff in ar[8])

    def test_get_surface (self):
        for bpp in (8, 16, 24, 32):
            sf = pygame.Surface((10, 20), 0, bpp)
            sf.fill((0, 0, 0))
            ar = pygame.PixelArray(sf)
            self.assertTrue(ar.surface is sf)

    def test_get_surface__subclassed_surface(self):
        """Ensure the surface attribute can handle subclassed surfaces."""
        expected_surface = SurfaceSubclass((5, 3), 0, 32)
        pixelarray = pygame.PixelArray(expected_surface)

        surface = pixelarray.surface

        self.assertIs(surface, expected_surface)
        self.assertIsInstance(surface, pygame.Surface)
        self.assertIsInstance(surface, SurfaceSubclass)

    def test_set_slice (self):
        for bpp in (8, 16, 24, 32):
            sf = pygame.Surface ((6, 8), 0, bpp)
            sf.fill ((0, 0, 0))
            ar = pygame.PixelArray (sf)

            # Test single value assignment
            val = sf.map_rgb ((128, 128, 128))
            ar[0:2] = val
            self.assertEqual (ar[0][0], val)
            self.assertEqual (ar[0][1], val)
            self.assertEqual (ar[1][0], val)
            self.assertEqual (ar[1][1], val)

            val = sf.map_rgb ((0, 255, 255))
            ar[-3:-1] = val
            self.assertEqual (ar[3][0], val)
            self.assertEqual (ar[-2][1], val)

            val = sf.map_rgb ((255, 255, 255))
            ar[-3:] = (255, 255, 255)
            self.assertEqual (ar[4][0], val)
            self.assertEqual (ar[-1][1], val)

            # Test array size mismatch.
            # Changed in ver. 1.9.2
            # (was "Test list assignment, this is a vertical assignment.")
            val = sf.map_rgb ((0, 255, 0))
            self.assertRaises (ValueError, ar.__setitem__, slice (2, 4),
                               [val] * 8)

            # And the horizontal assignment.
            val = sf.map_rgb ((255, 0, 0))
            val2 = sf.map_rgb ((128, 0, 255))
            ar[0:2] = [val, val2]
            self.assertEqual (ar[0][0], val)
            self.assertEqual (ar[1][0], val2)
            self.assertEqual (ar[0][1], val)
            self.assertEqual (ar[1][1], val2)
            self.assertEqual (ar[0][4], val)
            self.assertEqual (ar[1][4], val2)
            self.assertEqual (ar[0][5], val)
            self.assertEqual (ar[1][5], val2)

            # Test pixelarray assignment.
            ar[:] = (0, 0, 0)
            sf2 = pygame.Surface ((6, 8), 0, bpp)
            sf2.fill ((255, 0, 255))

            val = sf.map_rgb ((255, 0, 255))
            ar2 = pygame.PixelArray (sf2)

            ar[:] = ar2[:]
            self.assertEqual (ar[0][0], val)
            self.assertEqual (ar[5][7], val)

            # Ensure p1 ... pn are freed for array[...] = [p1, ..., pn]
            # Bug fix: reference counting.
            if hasattr(sys, 'getrefcount'):
                class Int(int):
                    """Unique int instances"""
                    pass

                sf = pygame.Surface ((5, 2), 0, 32)
                ar = pygame.PixelArray (sf)
                pixel_list = [Int(i) for i in range(ar.shape[0])]
                refcnts_before = [sys.getrefcount (i) for i in pixel_list]
                ar[...] = pixel_list
                refcnts_after = [sys.getrefcount (i) for i in pixel_list]
                gc.collect ()
                self.assertEqual (refcnts_after, refcnts_before)

    def test_subscript (self):
        # By default we do not need to work with any special __***__
        # methods as map subscripts are the first looked up by the
        # object system.
        for bpp in (8, 16, 24, 32):
            sf = pygame.Surface ((6, 8), 0, bpp)
            sf.set_at ((1, 3), (0, 255, 0))
            sf.set_at ((0, 0), (0, 255, 0))
            sf.set_at ((4, 4), (0, 255, 0))
            val = sf.map_rgb ((0, 255, 0))

            ar = pygame.PixelArray (sf)

            # Test single value requests.
            self.assertEqual (ar[1,3], val)
            self.assertEqual (ar[0,0], val)
            self.assertEqual (ar[4,4], val)
            self.assertEqual (ar[1][3], val)
            self.assertEqual (ar[0][0], val)
            self.assertEqual (ar[4][4], val)

            # Test ellipse working.
            self.assertEqual (len (ar[...,...]), 6)
            self.assertEqual (len (ar[1,...]), 8)
            self.assertEqual (len (ar[...,3]), 6)

            # Test simple slicing
            self.assertEqual (len (ar[:,:]), 6)
            self.assertEqual (len (ar[:,]), 6)
            self.assertEqual (len (ar[1,:]), 8)
            self.assertEqual (len (ar[:,2]), 6)
            # Empty slices
            self.assertEqual (ar[4:4,], None)
            self.assertEqual (ar[4:4,...], None)
            self.assertEqual (ar[4:4,2:2], None)
            self.assertEqual (ar[4:4,1:4], None)
            self.assertEqual (ar[4:4:2,], None)
            self.assertEqual (ar[4:4:-2,], None)
            self.assertEqual (ar[4:4:1,...], None)
            self.assertEqual (ar[4:4:-1,...], None)
            self.assertEqual (ar[4:4:1,2:2], None)
            self.assertEqual (ar[4:4:-1,1:4], None)
            self.assertEqual (ar[...,4:4], None)
            self.assertEqual (ar[1:4,4:4], None)
            self.assertEqual (ar[...,4:4:1], None)
            self.assertEqual (ar[...,4:4:-1], None)
            self.assertEqual (ar[2:2,4:4:1], None)
            self.assertEqual (ar[1:4,4:4:-1], None)

            # Test advanced slicing
            ar[0] = 0
            ar[1] = 1
            ar[2] = 2
            ar[3] = 3
            ar[4] = 4
            ar[5] = 5

            # We should receive something like [0,2,4]
            self.assertEqual (ar[::2,1][0], 0)
            self.assertEqual (ar[::2,1][1], 2)
            self.assertEqual (ar[::2,1][2], 4)
            # We should receive something like [2,2,2]
            self.assertEqual (ar[2,::2][0], 2)
            self.assertEqual (ar[2,::2][1], 2)
            self.assertEqual (ar[2,::2][2], 2)

            # Should create a 3x3 array of [0,2,4]
            ar2 = ar[::2,::2]
            self.assertEqual (len (ar2), 3)
            self.assertEqual (ar2[0][0], 0)
            self.assertEqual (ar2[0][1], 0)
            self.assertEqual (ar2[0][2], 0)
            self.assertEqual (ar2[2][0], 4)
            self.assertEqual (ar2[2][1], 4)
            self.assertEqual (ar2[2][2], 4)
            self.assertEqual (ar2[1][0], 2)
            self.assertEqual (ar2[2][0], 4)
            self.assertEqual (ar2[1][1], 2)

            # Should create a reversed 3x8 array over X of [1,2,3] -> [3,2,1]
            ar2 = ar[3:0:-1]
            self.assertEqual (len (ar2), 3)
            self.assertEqual (ar2[0][0], 3)
            self.assertEqual (ar2[0][1], 3)
            self.assertEqual (ar2[0][2], 3)
            self.assertEqual (ar2[0][7], 3)
            self.assertEqual (ar2[2][0], 1)
            self.assertEqual (ar2[2][1], 1)
            self.assertEqual (ar2[2][2], 1)
            self.assertEqual (ar2[2][7], 1)
            self.assertEqual (ar2[1][0], 2)
            self.assertEqual (ar2[1][1], 2)
            # Should completely reverse the array over X -> [5,4,3,2,1,0]
            ar2 = ar[::-1]
            self.assertEqual (len (ar2), 6)
            self.assertEqual (ar2[0][0], 5)
            self.assertEqual (ar2[0][1], 5)
            self.assertEqual (ar2[0][3], 5)
            self.assertEqual (ar2[0][-1], 5)
            self.assertEqual (ar2[1][0], 4)
            self.assertEqual (ar2[1][1], 4)
            self.assertEqual (ar2[1][3], 4)
            self.assertEqual (ar2[1][-1], 4)
            self.assertEqual (ar2[-1][-1], 0)
            self.assertEqual (ar2[-2][-2], 1)
            self.assertEqual (ar2[-3][-1], 2)

            # Test advanced slicing
            ar[:] = 0
            ar2 = ar[:,1]
            ar2[:] = [99] * len(ar2)
            self.assertEqual (ar2[0], 99)
            self.assertEqual (ar2[-1], 99)
            self.assertEqual (ar2[-2], 99)
            self.assertEqual (ar2[2], 99)
            self.assertEqual (ar[0,1], 99)
            self.assertEqual (ar[1,1], 99)
            self.assertEqual (ar[2,1], 99)
            self.assertEqual (ar[-1,1], 99)
            self.assertEqual (ar[-2,1], 99)

            # Cases where a 2d array should have a dimension of length 1.
            ar2 = ar[1:2,:]
            self.assertEqual (ar2.shape, (1, ar.shape[1]))
            ar2 = ar[:,1:2]
            self.assertEqual (ar2.shape, (ar.shape[0], 1))
            sf2 = pygame.Surface ((1, 5), 0, 32)
            ar2 = pygame.PixelArray (sf2)
            self.assertEqual (ar2.shape, sf2.get_size ())
            sf2 = pygame.Surface ((7, 1), 0, 32)
            ar2 = pygame.PixelArray (sf2)
            self.assertEqual (ar2.shape, sf2.get_size ())

            # Array has a single ellipsis subscript: the identity operator
            ar2 = ar[...]
            self.assertTrue(ar2 is ar)

            # Ensure x and y are freed for p = array[x, y]
            # Bug fix: reference counting
            if hasattr(sys, 'getrefcount'):
                class Int(int):
                    """Unique int instances"""
                    pass

                sf = pygame.Surface ((2, 2), 0, 32)
                ar = pygame.PixelArray (sf)
                x, y = Int(0), Int(1)
                rx_before, ry_before = sys.getrefcount (x), sys.getrefcount (y)
                p = ar[x, y]
                rx_after, ry_after = sys.getrefcount (x), sys.getrefcount (y)
                self.assertEqual (rx_after, rx_before)
                self.assertEqual (ry_after, ry_before)

    def test_ass_subscript (self):
        for bpp in (8, 16, 24, 32):
            sf = pygame.Surface ((6, 8), 0, bpp)
            sf.fill ((255, 255, 255))
            ar = pygame.PixelArray (sf)

            # Test ellipse working
            ar[...,...] = (0, 0, 0)
            self.assertEqual (ar[0,0], 0)
            self.assertEqual (ar[1,0], 0)
            self.assertEqual (ar[-1,-1], 0)
            ar[...,] = (0, 0, 255)
            self.assertEqual (ar[0,0], sf.map_rgb ((0, 0, 255)))
            self.assertEqual (ar[1,0], sf.map_rgb ((0, 0, 255)))
            self.assertEqual (ar[-1,-1], sf.map_rgb ((0, 0, 255)))
            ar[:,...] = (255, 0, 0)
            self.assertEqual (ar[0,0], sf.map_rgb ((255, 0, 0)))
            self.assertEqual (ar[1,0], sf.map_rgb ((255, 0, 0)))
            self.assertEqual (ar[-1,-1], sf.map_rgb ((255, 0, 0)))
            ar[...] = (0, 255, 0)
            self.assertEqual (ar[0,0], sf.map_rgb ((0, 255, 0)))
            self.assertEqual (ar[1,0], sf.map_rgb ((0, 255, 0)))
            self.assertEqual (ar[-1,-1], sf.map_rgb ((0, 255, 0)))

            # Ensure x and y are freed for array[x, y] = p
            # Bug fix: reference counting
            if hasattr(sys, 'getrefcount'):
                class Int(int):
                    """Unique int instances"""
                    pass

                sf = pygame.Surface ((2, 2), 0, 32)
                ar = pygame.PixelArray (sf)
                x, y = Int(0), Int(1)
                rx_before, ry_before = sys.getrefcount (x), sys.getrefcount (y)
                ar[x, y] = 0
                rx_after, ry_after = sys.getrefcount (x), sys.getrefcount (y)
                self.assertEqual (rx_after, rx_before)
                self.assertEqual (ry_after, ry_before)

    def test_pixels_field(self):
        for bpp in [1, 2, 3, 4]:
            sf = pygame.Surface ((11, 7), 0, bpp * 8)
            ar = pygame.PixelArray (sf)
            ar2 = ar[1:,:]
            self.assertEqual (ar2._pixels_address - ar._pixels_address,
                              ar.itemsize)
            ar2 = ar[:,1:]
            self.assertEqual (ar2._pixels_address - ar._pixels_address,
                              ar.strides[1])
            ar2 = ar[::-1,:]
            self.assertEqual (ar2._pixels_address - ar._pixels_address,
                              (ar.shape[0] - 1) * ar.itemsize)
            ar2 = ar[::-2,:]
            self.assertEqual (ar2._pixels_address - ar._pixels_address,
                              (ar.shape[0] - 1) * ar.itemsize)
            ar2 = ar[:,::-1]
            self.assertEqual (ar2._pixels_address - ar._pixels_address,
                              (ar.shape[1] - 1) * ar.strides[1])
            ar3 = ar2[::-1,:]
            self.assertEqual (ar3._pixels_address - ar._pixels_address,
                              (ar.shape[0] - 1) * ar.strides[0] +
                              (ar.shape[1] - 1) * ar.strides[1])
            ar2 = ar[:,::-2]
            self.assertEqual (ar2._pixels_address - ar._pixels_address,
                              (ar.shape[1] - 1) * ar.strides[1])
            ar2 = ar[2::,3::]
            self.assertEqual (ar2._pixels_address - ar._pixels_address,
                              ar.strides[0] * 2 + ar.strides[1] * 3)
            ar2 = ar[2::2,3::4]
            self.assertEqual (ar2._pixels_address - ar._pixels_address,
                              ar.strides[0] * 2 + ar.strides[1] * 3)
            ar2 = ar[9:2:-1,:]
            self.assertEqual (ar2._pixels_address - ar._pixels_address,
                              ar.strides[0] * 9)
            ar2 = ar[:,5:2:-1]
            self.assertEqual (ar2._pixels_address - ar._pixels_address,
                              ar.strides[1] * 5)
            ##? ar2 = ar[:,9:2:-1]

    def test_make_surface (self):
        bg_color = pygame.Color (255, 255, 255)
        fg_color = pygame.Color (128, 100, 0)
        for bpp in (8, 16, 24, 32):
            sf = pygame.Surface ((10, 20), 0, bpp)
            bg_color_adj = sf.unmap_rgb (sf.map_rgb (bg_color))
            fg_color_adj = sf.unmap_rgb (sf.map_rgb (fg_color))
            sf.fill (bg_color_adj)
            sf.fill (fg_color_adj, (2, 5, 4, 11))
            ar = pygame.PixelArray (sf)
            newsf = ar[::2,::2].make_surface ()
            rect = newsf.get_rect ()
            self.assertEqual (rect.width, 5)
            self.assertEqual (rect.height, 10)
            for p in [(0, 2), (0, 3), (1, 2),
                      (2, 2), (3, 2), (3, 3),
                      (0, 7), (0, 8), (1, 8),
                      (2, 8), (3, 8), (3, 7)]:
                self.assertEqual (newsf.get_at (p), bg_color_adj)
            for p in [(1, 3), (2, 3), (1, 5), (2, 5), (1, 7), (2, 7)]:
                self.assertEqual (newsf.get_at (p), fg_color_adj)

        # Bug when array width is not a multiple of the slice step.
        w = 17
        lst = list(range(w))
        w_slice = len(lst[::2])
        h = 3
        sf = pygame.Surface ((w, h), 0, 32)
        ar = pygame.PixelArray (sf)
        ar2 = ar[::2,:]
        sf2 = ar2.make_surface ()
        w2, h2 = sf2.get_size ()
        self.assertEqual (w2, w_slice)
        self.assertEqual (h2, h)

        # Bug when array height is not a multiple of the slice step.
        # This can hang the Python interpreter.
        h = 17
        lst = list(range(h))
        h_slice = len(lst[::2])
        w = 3
        sf = pygame.Surface ((w, h), 0, 32)
        ar = pygame.PixelArray (sf)
        ar2 = ar[:,::2]
        sf2 = ar2.make_surface ()  # Hangs here.
        w2, h2 = sf2.get_size ()
        self.assertEqual (w2, w)
        self.assertEqual (h2, h_slice)

    def test_make_surface__subclassed_surface(self):
        """Ensure make_surface can handle subclassed surfaces."""
        expected_size = (3, 5)
        expected_flags = 0
        expected_depth = 32
        original_surface = SurfaceSubclass(expected_size, expected_flags,
                                           expected_depth)
        pixelarray = pygame.PixelArray(original_surface)

        surface = pixelarray.make_surface()

        self.assertIsNot(surface, original_surface)
        self.assertIsInstance(surface, pygame.Surface)
        self.assertNotIsInstance(surface, SurfaceSubclass)
        self.assertEqual(surface.get_size(), expected_size)
        self.assertEqual(surface.get_flags(), expected_flags)
        self.assertEqual(surface.get_bitsize(), expected_depth)

    def test_iter (self):
        for bpp in (8, 16, 24, 32):
            sf = pygame.Surface ((5, 10), 0, bpp)
            ar = pygame.PixelArray (sf)
            iterations = 0
            for col in ar:
                self.assertEqual (len (col), 10)
                iterations += 1
            self.assertEqual (iterations, 5)

    def test_replace (self):
        #print "replace start"
        for bpp in (8, 16, 24, 32):
            sf = pygame.Surface ((10, 10), 0, bpp)
            sf.fill ((255, 0, 0))
            rval = sf.map_rgb ((0, 0, 255))
            oval = sf.map_rgb ((255, 0, 0))
            ar = pygame.PixelArray (sf)
            ar[::2].replace ((255, 0, 0), (0, 0, 255))
            self.assertEqual (ar[0][0], rval)
            self.assertEqual (ar[1][0], oval)
            self.assertEqual (ar[2][3], rval)
            self.assertEqual (ar[3][6], oval)
            self.assertEqual (ar[8][9], rval)
            self.assertEqual (ar[9][9], oval)

            ar[::2].replace ((0, 0, 255), (255, 0, 0), weights=(10, 20, 50))
            self.assertEqual (ar[0][0], oval)
            self.assertEqual (ar[2][3], oval)
            self.assertEqual (ar[3][6], oval)
            self.assertEqual (ar[8][9], oval)
            self.assertEqual (ar[9][9], oval)
        #print "replace end"

    def test_extract (self):
        #print "extract start"
        for bpp in (8, 16, 24, 32):
            sf = pygame.Surface ((10, 10), 0, bpp)
            sf.fill ((0, 0, 255))
            sf.fill ((255, 0, 0), (2, 2, 6, 6))

            white = sf.map_rgb ((255, 255, 255))
            black = sf.map_rgb ((0, 0, 0))

            ar = pygame.PixelArray (sf)
            newar = ar.extract ((255, 0, 0))

            self.assertEqual (newar[0][0], black)
            self.assertEqual (newar[1][0], black)
            self.assertEqual (newar[2][3], white)
            self.assertEqual (newar[3][6], white)
            self.assertEqual (newar[8][9], black)
            self.assertEqual (newar[9][9], black)

            newar = ar.extract ((255, 0, 0), weights=(10, 0.1, 50))
            self.assertEqual (newar[0][0], black)
            self.assertEqual (newar[1][0], black)
            self.assertEqual (newar[2][3], white)
            self.assertEqual (newar[3][6], white)
            self.assertEqual (newar[8][9], black)
            self.assertEqual (newar[9][9], black)
        #print "extract end"

    def test_2dslice_assignment (self):
        w = 2 * 5 * 8
        h = 3 * 5 * 9
        sf = pygame.Surface ((w, h), 0, 32)
        ar = pygame.PixelArray (sf)
        size = (w, h)
        strides = (1, w)
        offset = 0
        self._test_assignment (sf, ar, size, strides, offset)
        xslice = slice (None, None, 2)
        yslice = slice (None, None, 3)
        ar, size, strides, offset = self._array_slice (
            ar, size, (xslice, yslice), strides, offset)
        self._test_assignment (sf, ar, size, strides, offset)
        xslice = slice (5, None, 5)
        yslice = slice (5, None, 5)
        ar, size, strides, offset = self._array_slice (
            ar, size, (xslice, yslice), strides, offset)
        self._test_assignment (sf, ar, size, strides, offset)

    def _test_assignment (self, sf, ar, ar_size, ar_strides, ar_offset):
        self.assertEqual (ar.shape, ar_size)
        ar_w, ar_h = ar_size
        ar_xstride, ar_ystride = ar_strides
        sf_w, sf_h = sf.get_size ()
        black = pygame.Color ('black')
        color = pygame.Color (0, 0, 12)
        pxcolor = sf.map_rgb (color)
        sf.fill (black)
        for ar_x, ar_y in [(0, 0),
                           (0, ar_h - 4),
                           (ar_w - 3, 0),
                           (0, ar_h - 1),
                           (ar_w - 1, 0),
                           (ar_w - 1, ar_h - 1)]:
            sf_offset = ar_offset + ar_x * ar_xstride + ar_y * ar_ystride
            sf_y = sf_offset // sf_w
            sf_x = sf_offset - sf_y * sf_w
            sf_posn = (sf_x, sf_y)
            sf_pix = sf.get_at (sf_posn)
            self.assertEqual (sf_pix, black,
                              "at pixarr posn (%i, %i) (surf posn (%i, %i)): "
                              "%s != %s" %
                              (ar_x, ar_y, sf_x, sf_y, sf_pix, black))
            ar[ar_x, ar_y] = pxcolor
            sf_pix = sf.get_at (sf_posn)
            self.assertEqual (sf_pix, color,
                              "at pixarr posn (%i, %i) (surf posn (%i, %i)): "
                              "%s != %s" %
                              (ar_x, ar_y, sf_x, sf_y, sf_pix, color))

    def _array_slice (self, ar, size, slices, strides, offset):
        ar = ar[slices]
        xslice, yslice = slices
        w, h = size
        xstart, xstop, xstep = xslice.indices(w)
        ystart, ystop, ystep = yslice.indices(h)
        w = (xstop - xstart + xstep - 1) // xstep
        h = (ystop - ystart + ystep - 1) // ystep
        xstride, ystride = strides
        offset += xstart * xstride + ystart * ystride
        xstride *= xstep
        ystride *= ystep
        return ar, (w, h), (xstride, ystride), offset

    def test_array_properties(self):
        # itemsize, ndim, shape, and strides.
        for bpp in [1, 2, 3, 4]:
            sf = pygame.Surface ((2, 2), 0, bpp * 8)
            ar = pygame.PixelArray (sf)
            self.assertEqual (ar.itemsize, bpp)

        for shape in [(4, 16), (5, 13)]:
            w, h = shape
            sf = pygame.Surface (shape, 0, 32)
            bpp = sf.get_bytesize ()
            pitch = sf.get_pitch ()
            ar = pygame.PixelArray (sf)
            self.assertEqual (ar.ndim, 2)
            self.assertEqual (ar.shape, shape)
            self.assertEqual (ar.strides, (bpp, pitch))
            ar2 = ar[::2,:]
            w2 = len(([0] * w)[::2])
            self.assertEqual (ar2.ndim, 2)
            self.assertEqual (ar2.shape, (w2, h))
            self.assertEqual (ar2.strides, (2 * bpp, pitch))
            ar2 = ar[:,::2]
            h2 = len(([0] * h)[::2])
            self.assertEqual (ar2.ndim, 2)
            self.assertEqual (ar2.shape, (w, h2))
            self.assertEqual (ar2.strides, (bpp, 2 * pitch))
            ar2 = ar[1]
            self.assertEqual (ar2.ndim, 1)
            self.assertEqual (ar2.shape, (h,))
            self.assertEqual (ar2.strides, (pitch,))
            ar2 = ar[:,1]
            self.assertEqual (ar2.ndim, 1)
            self.assertEqual (ar2.shape, (w,))
            self.assertEqual (ar2.strides, (bpp,))

    def test_self_assign(self):
        # This differs from NumPy arrays.
        w = 10
        max_x = w - 1
        h = 20
        max_y = h - 1
        for bpp in [1, 2, 3, 4]:
            sf = pygame.Surface ((w, h), 0, bpp * 8)
            ar = pygame.PixelArray (sf)
            for i in range (w * h):
                ar[i % w, i // w] = i
            ar[:,:] = ar[::-1,:]
            for i in range (w * h):
                self.assertEqual (ar[max_x - i % w, i // w], i)
            ar = pygame.PixelArray (sf)
            for i in range (w * h):
                ar[i % w, i // w] = i
            ar[:,:] = ar[:,::-1]
            for i in range (w * h):
                self.assertEqual (ar[i % w, max_y - i // w ], i)
            ar = pygame.PixelArray (sf)
            for i in range(w * h):
                ar[i % w, i // w] = i
            ar[:,:] = ar[::-1,::-1]
            for i in range (w * h):
                self.assertEqual (ar[max_x - i % w, max_y - i // w], i)

    def test_color_value (self):
        # Confirm that a PixelArray slice assignment distinguishes between
        # pygame.Color and tuple objects as single (r, g, b[, a]) colors
        # and other sequences as sequences of colors to be treated as
        # slices.
        sf = pygame.Surface ((5, 5), 0, 32)
        ar = pygame.PixelArray (sf)
        index = slice(None, None, 1)
        ar.__setitem__ (index, (1, 2, 3))
        self.assertEqual (ar[0, 0], sf.map_rgb ((1, 2, 3)))
        ar.__setitem__ (index, pygame.Color (10, 11, 12))
        self.assertEqual (ar[0, 0], sf.map_rgb ((10, 11, 12)))
        self.assertRaises (ValueError, ar.__setitem__, index, (1, 2, 3, 4, 5))
        self.assertRaises (ValueError, ar.__setitem__, (index, index),
                           (1, 2, 3, 4, 5))
        self.assertRaises (ValueError, ar.__setitem__, index, [1, 2, 3])
        self.assertRaises (ValueError, ar.__setitem__, (index, index),
                           [1, 2, 3])
        sf = pygame.Surface ((3, 3), 0, 32)
        ar = pygame.PixelArray (sf)
        ar[:] = (20, 30, 40)
        self.assertEqual (ar[0, 0], sf.map_rgb ((20, 30, 40)))
        ar[:] = [20, 30, 40]
        self.assertEqual (ar[0, 0], 20)
        self.assertEqual (ar[1, 0], 30)
        self.assertEqual (ar[2, 0], 40)

    def test_transpose (self):
        # PixelArray.transpose(): swap axis on a 2D array, add a length
        # 1 x axis to a 1D array.
        sf = pygame.Surface ((3, 7), 0, 32)
        ar = pygame.PixelArray (sf)
        w, h = ar.shape
        dx, dy = ar.strides
        for i in range (w * h):
            x = i % w
            y = i // w
            ar[x, y] = i
        ar_t = ar.transpose()
        self.assertEqual (ar_t.shape, (h, w))
        self.assertEqual (ar_t.strides, (dy, dx))
        for i in range (w * h):
            x = i % w
            y = i // w
            self.assertEqual (ar_t[y, x], ar[x, y])
        ar1D = ar[0]
        ar2D = ar1D.transpose()
        self.assertEqual (ar2D.shape, (1, h))
        for y in range (h):
            self.assertEqual (ar1D[y], ar2D[0, y])
        ar1D = ar[:,0]
        ar2D = ar1D.transpose()
        self.assertEqual (ar2D.shape, (1, w))
        for x in range (2):
            self.assertEqual (ar1D[x], ar2D[0, x])

    def test_length_1_dimension_broadcast (self):
        w = 5
        sf = pygame.Surface ((w, w), 0, 32)
        ar = pygame.PixelArray (sf)
        # y-axis broadcast.
        sf_x = pygame.Surface ((w, 1), 0, 32)
        ar_x = pygame.PixelArray (sf_x)
        for i in range (w):
            ar_x[i, 0] = (w + 1) * 10
        ar[...] = ar_x
        for y in range (w):
            for x in range (w):
                self.assertEqual (ar[x, y], ar_x[x, 0])
        # x-axis broadcast.
        ar[...] = 0
        sf_y = pygame.Surface ((1, w), 0, 32)
        ar_y = pygame.PixelArray (sf_y)
        for i in range (w):
            ar_y[0, i] = (w + 1) * 10
        ar[...] = ar_y
        for x in range (w):
            for y in range (w):
                self.assertEqual (ar[x, y], ar_y[0, y])
        # (1, 1) array broadcast.
        ar[...] = 0
        sf_1px = pygame.Surface ((1, 1), 0, 32)
        ar_1px = pygame.PixelArray (sf_1px)
        ar_1px[0, 0] = 42  # Well it had to show up somewhere.
        ar[...] = ar_1px
        for y in range (w):
            for x in range (w):
                self.assertEqual (ar[x, y], 42)

    def test_assign_size_mismatch (self):
        sf = pygame.Surface ((7, 11), 0, 32)
        ar = pygame.PixelArray (sf)
        self.assertRaises (ValueError, ar.__setitem__, Ellipsis, ar[:, 0:2])
        self.assertRaises (ValueError, ar.__setitem__, Ellipsis, ar[0:2, :])

    def test_repr (self):
        # Python 3.x bug: the tp_repr slot function returned NULL instead
        # of a Unicode string, triggering an exception.
        sf = pygame.Surface ((3, 1), pygame.SRCALPHA, 16)
        ar = pygame.PixelArray(sf)
        ar[...] = 42
        pixel = sf.get_at_mapped ((0, 0))
        self.assertEqual(repr (ar),
                         type (ar).__name__ + "([\n  [42, 42, 42]]\n)")


class PixelArrayArrayInterfaceTest(unittest.TestCase, TestMixin):

    @unittest.skipIf(IS_PYPY, 'skipping for PyPy (why?)')
    def test_basic (self):
        # Check unchanging fields.
        sf = pygame.Surface ((2, 2), 0, 32)
        ar = pygame.PixelArray (sf)

        ai = arrinter.ArrayInterface (ar)
        self.assertEqual (ai.two, 2)
        self.assertEqual (ai.typekind, 'u')
        self.assertEqual (ai.nd, 2)
        self.assertEqual (ai.data, ar._pixels_address)

    @unittest.skipIf(IS_PYPY, 'skipping for PyPy (why?)')
    def test_shape(self):

        for shape in [[4, 16], [5, 13]]:
            w, h = shape
            sf = pygame.Surface (shape, 0, 32)
            ar = pygame.PixelArray (sf)
            ai = arrinter.ArrayInterface (ar)
            ai_shape = [ai.shape[i] for i in range(ai.nd)]
            self.assertEqual (ai_shape, shape)
            ar2 = ar[::2,:]
            ai2 = arrinter.ArrayInterface (ar2)
            w2 = len(([0] * w)[::2])
            ai_shape = [ai2.shape[i] for i in range(ai2.nd)]
            self.assertEqual (ai_shape, [w2, h])
            ar2 = ar[:,::2]
            ai2 = arrinter.ArrayInterface (ar2)
            h2 = len(([0] * h)[::2])
            ai_shape = [ai2.shape[i] for i in range(ai2.nd)]
            self.assertEqual (ai_shape, [w, h2])

    @unittest.skipIf(IS_PYPY, 'skipping for PyPy (why?)')
    def test_itemsize (self):
        for bytes_per_pixel in range(1, 5):
            bits_per_pixel = 8 * bytes_per_pixel
            sf = pygame.Surface ((2, 2), 0, bits_per_pixel)
            ar = pygame.PixelArray (sf)
            ai = arrinter.ArrayInterface (ar)
            self.assertEqual (ai.itemsize, bytes_per_pixel)

    @unittest.skipIf(IS_PYPY, 'skipping for PyPy (why?)')
    def test_flags (self):
        aim = arrinter
        common_flags = (aim.PAI_NOTSWAPPED | aim.PAI_WRITEABLE |
                        aim.PAI_ALIGNED)
        s = pygame.Surface ((10, 2), 0, 32)
        ar = pygame.PixelArray (s)
        ai = aim.ArrayInterface (ar)
        self.assertEqual (ai.flags, common_flags | aim.PAI_FORTRAN)

        ar2 = ar[::2,:]
        ai = aim.ArrayInterface (ar2)
        self.assertEqual (ai.flags, common_flags)

        s = pygame.Surface ((8, 2), 0, 24)
        ar = pygame.PixelArray (s)
        ai = aim.ArrayInterface (ar)
        self.assertEqual (ai.flags, common_flags | aim.PAI_FORTRAN)

        s = pygame.Surface ((7, 2), 0, 24)
        ar = pygame.PixelArray (s)
        ai = aim.ArrayInterface (ar)
        self.assertEqual (ai.flags, common_flags)

    def test_slicing (self):
        # This will implicitly test data and strides fields.
        #
        # Need an 8 bit test surfaces because pixelcopy.make_surface
        # returns an 8 bit surface for a 2d array.

        factors = [7, 3, 11]

        w = reduce (operator.mul, factors, 1)
        h = 13
        sf = pygame.Surface ((w, h), 0, 8)
        color = sf.map_rgb ((1, 17, 128))
        ar = pygame.PixelArray (sf)
        for f in factors[:-1]:
            w = w // f
            sf.fill ((0, 0, 0))
            ar = ar[f:f + w,:]
            ar[0][0] = color
            ar[-1][-2] = color
            ar[0][-3] = color
            sf2 = ar.make_surface ()
            sf3 = pygame.pixelcopy.make_surface (ar)
            self.assert_surfaces_equal (sf3, sf2)

        h = reduce (operator.mul, factors, 1)
        w = 13
        sf = pygame.Surface ((w, h), 0, 8)
        color = sf.map_rgb ((1, 17, 128))
        ar = pygame.PixelArray (sf)
        for f in factors[:-1]:
            h = h // f
            sf.fill ((0, 0, 0))
            ar = ar[:,f:f + h]
            ar[0][0] = color
            ar[-1][-2] = color
            ar[0][-3] = color
            sf2 = ar.make_surface ()
            sf3 = pygame.pixelcopy.make_surface (ar)
            self.assert_surfaces_equal (sf3, sf2)

        w = 20
        h = 10
        sf = pygame.Surface ((w, h), 0, 8)
        color = sf.map_rgb ((1, 17, 128))
        ar = pygame.PixelArray (sf)
        for slices in [(slice (w), slice (h)),
                       (slice (0, w, 2), slice (h)),
                       (slice (0, w, 3), slice (h)),
                       (slice (w), slice (0, h, 2)),
                       (slice (w), slice (0, h, 3)),
                       (slice (0, w, 2), slice (0, h, 2)),
                       (slice (0, w, 3), slice (0, h, 3)),
                      ]:
            sf.fill ((0, 0, 0))
            ar2 = ar[slices]
            ar2[0][0] = color
            ar2[-1][-2] = color
            ar2[0][-3] = color
            sf2 = ar2.make_surface ()
            sf3 = pygame.pixelcopy.make_surface (ar2)
            self.assert_surfaces_equal (sf3, sf2)


@unittest.skipIf(not pygame.HAVE_NEWBUF, 'newbuf not implemented')
class PixelArrayNewBufferTest(unittest.TestCase, TestMixin):

    if pygame.HAVE_NEWBUF:
        from pygame.tests.test_utils import buftools

    bitsize_to_format = {8: 'B', 16: '=H', 24: '3x', 32: '=I'}

    def test_newbuf_2D (self):
        buftools = self.buftools
        Importer = buftools.Importer

        for bit_size in [8, 16, 24, 32]:
            s = pygame.Surface ((10, 2), 0, bit_size)
            ar = pygame.PixelArray (s)
            format = self.bitsize_to_format[bit_size]
            itemsize = ar.itemsize
            shape = ar.shape
            w, h = shape
            strides = ar.strides
            length = w * h * itemsize
            imp = Importer (ar, buftools.PyBUF_FULL)
            self.assertTrue (imp.obj, ar)
            self.assertEqual (imp.len, length)
            self.assertEqual (imp.ndim, 2)
            self.assertEqual (imp.itemsize, itemsize)
            self.assertEqual (imp.format, format)
            self.assertFalse (imp.readonly)
            self.assertEqual (imp.shape, shape)
            self.assertEqual (imp.strides, strides)
            self.assertTrue (imp.suboffsets is None)
            self.assertEqual (imp.buf, s._pixels_address)

        s = pygame.Surface ((8, 16), 0, 32)
        ar = pygame.PixelArray (s)
        format = self.bitsize_to_format[s.get_bitsize ()]
        itemsize = ar.itemsize
        shape = ar.shape
        w, h = shape
        strides = ar.strides
        length = w * h * itemsize
        imp = Importer (ar, buftools.PyBUF_SIMPLE)
        self.assertTrue (imp.obj, ar)
        self.assertEqual (imp.len, length)
        self.assertEqual (imp.ndim, 0)
        self.assertEqual (imp.itemsize, itemsize)
        self.assertTrue (imp.format is None)
        self.assertFalse (imp.readonly)
        self.assertTrue (imp.shape is None)
        self.assertTrue (imp.strides is None)
        self.assertTrue (imp.suboffsets is None)
        self.assertEqual (imp.buf, s._pixels_address)
        imp = Importer (ar, buftools.PyBUF_FORMAT)
        self.assertEqual (imp.ndim, 0)
        self.assertEqual (imp.format, format)
        imp = Importer (ar, buftools.PyBUF_WRITABLE)
        self.assertEqual (imp.ndim, 0)
        self.assertTrue (imp.format is None)
        imp = Importer (ar, buftools.PyBUF_F_CONTIGUOUS)
        self.assertEqual (imp.ndim, 2)
        self.assertTrue (imp.format is None)
        self.assertEqual (imp.shape, shape)
        self.assertEqual (imp.strides, strides)
        imp = Importer (ar, buftools.PyBUF_ANY_CONTIGUOUS)
        self.assertEqual (imp.ndim, 2)
        self.assertTrue (imp.format is None)
        self.assertEqual (imp.shape, shape)
        self.assertEqual (imp.strides, strides)
        self.assertRaises (BufferError, Importer, ar,
                           buftools.PyBUF_C_CONTIGUOUS)
        self.assertRaises (BufferError, Importer, ar, buftools.PyBUF_ND)

        ar_sliced = ar[:,::2]
        format = self.bitsize_to_format[s.get_bitsize ()]
        itemsize = ar_sliced.itemsize
        shape = ar_sliced.shape
        w, h = shape
        strides = ar_sliced.strides
        length = w * h * itemsize
        imp = Importer (ar_sliced, buftools.PyBUF_STRIDED)
        self.assertEqual (imp.len, length)
        self.assertEqual (imp.ndim, 2)
        self.assertEqual (imp.itemsize, itemsize)
        self.assertTrue (imp.format is None)
        self.assertFalse (imp.readonly)
        self.assertEqual (imp.shape, shape)
        self.assertEqual (imp.strides, strides)
        self.assertEqual (imp.buf, s._pixels_address)
        self.assertRaises (BufferError, Importer, ar_sliced,
                           buftools.PyBUF_SIMPLE)
        self.assertRaises (BufferError, Importer, ar_sliced,
                           buftools.PyBUF_ND)
        self.assertRaises (BufferError, Importer, ar_sliced,
                           buftools.PyBUF_C_CONTIGUOUS)
        self.assertRaises (BufferError, Importer, ar_sliced,
                           buftools.PyBUF_F_CONTIGUOUS)
        self.assertRaises (BufferError, Importer, ar_sliced,
                           buftools.PyBUF_ANY_CONTIGUOUS)

        ar_sliced = ar[::2,:]
        format = self.bitsize_to_format[s.get_bitsize ()]
        itemsize = ar_sliced.itemsize
        shape = ar_sliced.shape
        w, h = shape
        strides = ar_sliced.strides
        length = w * h * itemsize
        imp = Importer (ar_sliced, buftools.PyBUF_STRIDED)
        self.assertEqual (imp.len, length)
        self.assertEqual (imp.ndim, 2)
        self.assertEqual (imp.itemsize, itemsize)
        self.assertTrue (imp.format is None)
        self.assertFalse (imp.readonly)
        self.assertEqual (imp.shape, shape)
        self.assertEqual (imp.strides, strides)
        self.assertEqual (imp.buf, s._pixels_address)
        self.assertRaises (BufferError, Importer, ar_sliced,
                           buftools.PyBUF_SIMPLE)
        self.assertRaises (BufferError, Importer, ar_sliced,
                           buftools.PyBUF_ND)
        self.assertRaises (BufferError, Importer, ar_sliced,
                           buftools.PyBUF_C_CONTIGUOUS)
        self.assertRaises (BufferError, Importer, ar_sliced,
                           buftools.PyBUF_F_CONTIGUOUS)
        self.assertRaises (BufferError, Importer, ar_sliced,
                           buftools.PyBUF_ANY_CONTIGUOUS)

        s2 = s.subsurface ((2, 3, 5, 7))
        ar = pygame.PixelArray (s2)
        format = self.bitsize_to_format[s.get_bitsize ()]
        itemsize = ar.itemsize
        shape = ar.shape
        w, h = shape
        strides = ar.strides
        length = w * h * itemsize
        imp = Importer (ar, buftools.PyBUF_STRIDES)
        self.assertTrue (imp.obj, ar)
        self.assertEqual (imp.len, length)
        self.assertEqual (imp.ndim, 2)
        self.assertEqual (imp.itemsize, itemsize)
        self.assertTrue (imp.format is None)
        self.assertFalse (imp.readonly)
        self.assertEqual (imp.shape, shape)
        self.assertEqual (imp.strides, strides)
        self.assertTrue (imp.suboffsets is None)
        self.assertEqual (imp.buf, s2._pixels_address)
        self.assertRaises (BufferError, Importer, ar, buftools.PyBUF_SIMPLE)
        self.assertRaises (BufferError, Importer, ar, buftools.PyBUF_FORMAT)
        self.assertRaises (BufferError, Importer, ar, buftools.PyBUF_WRITABLE)
        self.assertRaises (BufferError, Importer, ar, buftools.PyBUF_ND)
        self.assertRaises (BufferError, Importer, ar,
                           buftools.PyBUF_C_CONTIGUOUS)
        self.assertRaises (BufferError, Importer, ar,
                           buftools.PyBUF_F_CONTIGUOUS)
        self.assertRaises (BufferError, Importer, ar,
                           buftools.PyBUF_ANY_CONTIGUOUS)

    def test_newbuf_1D(self):
        buftools = self.buftools
        Importer = buftools.Importer

        s = pygame.Surface ((2, 16), 0, 32)
        ar_2D = pygame.PixelArray (s)
        x = 0
        ar = ar_2D[x]
        format = self.bitsize_to_format[s.get_bitsize ()]
        itemsize = ar.itemsize
        shape = ar.shape
        h = shape[0]
        strides = ar.strides
        length = h * itemsize
        buf = s._pixels_address + x * itemsize
        imp = Importer (ar, buftools.PyBUF_STRIDES)
        self.assertTrue (imp.obj, ar)
        self.assertEqual (imp.len, length)
        self.assertEqual (imp.ndim, 1)
        self.assertEqual (imp.itemsize, itemsize)
        self.assertTrue (imp.format is None)
        self.assertFalse (imp.readonly)
        self.assertEqual (imp.shape, shape)
        self.assertEqual (imp.strides, strides)
        self.assertTrue (imp.suboffsets is None)
        self.assertEqual (imp.buf, buf)
        imp = Importer (ar, buftools.PyBUF_FULL)
        self.assertEqual (imp.ndim, 1)
        self.assertEqual (imp.format, format)
        self.assertRaises (BufferError, Importer, ar,
                           buftools.PyBUF_SIMPLE)
        self.assertRaises (BufferError, Importer, ar,
                           buftools.PyBUF_FORMAT)
        self.assertRaises (BufferError, Importer, ar,
                           buftools.PyBUF_WRITABLE)
        self.assertRaises (BufferError, Importer, ar,
                           buftools.PyBUF_ND)
        self.assertRaises (BufferError, Importer, ar,
                           buftools.PyBUF_C_CONTIGUOUS)
        self.assertRaises (BufferError, Importer, ar,
                           buftools.PyBUF_F_CONTIGUOUS)
        self.assertRaises (BufferError, Importer, ar,
                           buftools.PyBUF_ANY_CONTIGUOUS)
        y = 10
        ar = ar_2D[:,y]
        shape = ar.shape
        w = shape[0]
        strides = ar.strides
        length = w * itemsize
        buf = s._pixels_address + y * s.get_pitch()
        imp = Importer (ar, buftools.PyBUF_FULL)
        self.assertEqual (imp.len, length)
        self.assertEqual (imp.ndim, 1)
        self.assertEqual (imp.itemsize, itemsize)
        self.assertEqual (imp.format, format)
        self.assertFalse (imp.readonly)
        self.assertEqual (imp.shape, shape)
        self.assertEqual (imp.strides, strides)
        self.assertEqual (imp.buf, buf)
        self.assertTrue (imp.suboffsets is None)
        imp = Importer (ar, buftools.PyBUF_SIMPLE)
        self.assertEqual (imp.len, length)
        self.assertEqual (imp.ndim, 0)
        self.assertEqual (imp.itemsize, itemsize)
        self.assertTrue (imp.format is None)
        self.assertFalse (imp.readonly)
        self.assertTrue (imp.shape is None)
        self.assertTrue (imp.strides is None)
        imp = Importer (ar, buftools.PyBUF_ND)
        self.assertEqual (imp.len, length)
        self.assertEqual (imp.ndim, 1)
        self.assertEqual (imp.itemsize, itemsize)
        self.assertTrue (imp.format is None)
        self.assertFalse (imp.readonly)
        self.assertEqual (imp.shape, shape)
        self.assertTrue (imp.strides is None)
        imp = Importer (ar, buftools.PyBUF_C_CONTIGUOUS)
        self.assertEqual (imp.ndim, 1)
        imp = Importer (ar, buftools.PyBUF_F_CONTIGUOUS)
        self.assertEqual (imp.ndim, 1)
        imp = Importer (ar, buftools.PyBUF_ANY_CONTIGUOUS)
        self.assertEqual (imp.ndim, 1)


if __name__ == '__main__':
    unittest.main()