from collections import OrderedDict
import copy
import platform
import random
import unittest
import sys

import pygame
from pygame.locals import *
from pygame.math import Vector2
from pygame.tests.test_utils import AssertRaisesRegexMixin


IS_PYPY = "PyPy" == platform.python_implementation()


def random_mask(size=(100, 100)):
    """random_mask(size=(100,100)): return Mask
    Create a mask of the given size, with roughly half the bits set at random."""
    m = pygame.Mask(size)
    for i in range(size[0] * size[1] // 2):
        x, y = random.randint(0, size[0] - 1), random.randint(0, size[1] - 1)
        m.set_at((x, y))
    return m


def maskFromSurface(surface, threshold=127):
    mask = pygame.Mask(surface.get_size())
    key = surface.get_colorkey()
    if key:
        for y in range(surface.get_height()):
            for x in range(surface.get_width()):
                if surface.get_at((x + 0.1, y + 0.1)) != key:
                    mask.set_at((x, y), 1)
    else:
        for y in range(surface.get_height()):
            for x in range(surface.get_width()):
                if surface.get_at((x, y))[3] > threshold:
                    mask.set_at((x, y), 1)
    return mask


def create_bounding_rect(points):
    """Creates a bounding rect from the given points."""
    xmin = xmax = points[0][0]
    ymin = ymax = points[0][1]

    for x, y in points[1:]:
        xmin = min(x, xmin)
        xmax = max(x, xmax)
        ymin = min(y, ymin)
        ymax = max(y, ymax)

    return pygame.Rect((xmin, ymin), (xmax - xmin + 1, ymax - ymin + 1))


def zero_size_pairs(width, height):
    """Creates a generator which yields pairs of sizes.

    For each pair of sizes at least one of the sizes will have a 0 in it.
    """
    sizes = ((width, height), (width, 0), (0, height), (0, 0))

    return ((a, b) for a in sizes for b in sizes if 0 in a or 0 in b)


def corners(mask):
    """Returns a tuple with the corner positions of the given mask.

    Clockwise from the top left corner.
    """
    width, height = mask.get_size()
    return ((0, 0), (width - 1, 0), (width - 1, height - 1), (0, height - 1))


def off_corners(rect):
    """Returns a tuple with the positions off of the corners of the given rect.

    Clockwise from the top left corner.
    """
    return (
        (rect.left - 1, rect.top),
        (rect.left - 1, rect.top - 1),
        (rect.left, rect.top - 1),
        (rect.right - 1, rect.top - 1),
        (rect.right, rect.top - 1),
        (rect.right, rect.top),
        (rect.right, rect.bottom - 1),
        (rect.right, rect.bottom),
        (rect.right - 1, rect.bottom),
        (rect.left, rect.bottom),
        (rect.left - 1, rect.bottom),
        (rect.left - 1, rect.bottom - 1),
    )


def assertSurfaceFilled(testcase, surface, expected_color, area_rect=None):
    """Checks to see if the given surface is filled with the given color.

    If an area_rect is provided, only check that area of the surface.
    """
    if area_rect is None:
        x_range = range(surface.get_width())
        y_range = range(surface.get_height())
    else:
        area_rect.normalize()
        area_rect = area_rect.clip(surface.get_rect())
        x_range = range(area_rect.left, area_rect.right)
        y_range = range(area_rect.top, area_rect.bottom)

    surface.lock()  # Lock for possible speed up.
    for pos in ((x, y) for y in y_range for x in x_range):
        testcase.assertEqual(surface.get_at(pos), expected_color, pos)
    surface.unlock()


def assertSurfaceFilledIgnoreArea(testcase, surface, expected_color, ignore_rect):
    """Checks if the surface is filled with the given color. The
    ignore_rect area is not checked.
    """
    x_range = range(surface.get_width())
    y_range = range(surface.get_height())
    ignore_rect.normalize()

    surface.lock()  # Lock for possible speed up.
    for pos in ((x, y) for y in y_range for x in x_range):
        if not ignore_rect.collidepoint(pos):
            testcase.assertEqual(surface.get_at(pos), expected_color, pos)
    surface.unlock()


def assertMaskEqual(testcase, m1, m2, msg=None):
    """Checks to see if the 2 given masks are equal."""
    m1_count = m1.count()

    testcase.assertEqual(m1.get_size(), m2.get_size(), msg=msg)
    testcase.assertEqual(m1_count, m2.count(), msg=msg)
    testcase.assertEqual(m1_count, m1.overlap_area(m2, (0, 0)), msg=msg)

    # This can be used to help debug exact locations.
    ##for i in range(m1.get_size()[0]):
    ##    for j in range(m1.get_size()[1]):
    ##        testcase.assertEqual(m1.get_at((i, j)), m2.get_at((i, j)))


# @unittest.skipIf(IS_PYPY, "pypy has lots of mask failures")  # TODO
class MaskTypeTest(AssertRaisesRegexMixin, unittest.TestCase):
    ORIGIN_OFFSETS = (
        (0, 0),
        (0, 1),
        (1, 1),
        (1, 0),
        (1, -1),
        (0, -1),
        (-1, -1),
        (-1, 0),
        (-1, 1),
    )

    @unittest.skipIf(IS_PYPY, "Segfaults on pypy")
    def test_mask(self):
        """Ensure masks are created correctly without fill parameter."""
        expected_count = 0
        expected_size = (11, 23)

        mask1 = pygame.mask.Mask(expected_size)
        mask2 = pygame.mask.Mask(size=expected_size)

        self.assertIsInstance(mask1, pygame.mask.Mask)
        self.assertEqual(mask1.count(), expected_count)
        self.assertEqual(mask1.get_size(), expected_size)

        self.assertIsInstance(mask2, pygame.mask.Mask)
        self.assertEqual(mask2.count(), expected_count)
        self.assertEqual(mask2.get_size(), expected_size)

    def test_mask__negative_size(self):
        """Ensure the mask constructor handles negative sizes correctly."""
        for size in ((1, -1), (-1, 1), (-1, -1)):
            with self.assertRaises(ValueError):
                mask = pygame.Mask(size)

    def test_mask__fill_kwarg(self):
        """Ensure masks are created correctly using the fill keyword."""
        width, height = 37, 47
        expected_size = (width, height)
        fill_counts = {True: width * height, False: 0}

        for fill, expected_count in fill_counts.items():
            msg = "fill={}".format(fill)

            mask = pygame.mask.Mask(expected_size, fill=fill)

            self.assertIsInstance(mask, pygame.mask.Mask, msg)
            self.assertEqual(mask.count(), expected_count, msg)
            self.assertEqual(mask.get_size(), expected_size, msg)

    @unittest.skipIf(IS_PYPY, "Segfaults on pypy")
    def test_mask__fill_kwarg_bit_boundaries(self):
        """Ensures masks are created correctly using the fill keyword
        over a range of sizes.

        Tests masks of different sizes, including:
           -masks 31 to 33 bits wide (32 bit boundaries)
           -masks 63 to 65 bits wide (64 bit boundaries)
        """
        for height in range(1, 4):
            for width in range(1, 66):
                expected_count = width * height
                expected_size = (width, height)
                msg = "size={}".format(expected_size)

                mask = pygame.mask.Mask(expected_size, fill=True)

                self.assertIsInstance(mask, pygame.mask.Mask, msg)
                self.assertEqual(mask.count(), expected_count, msg)
                self.assertEqual(mask.get_size(), expected_size, msg)

    def test_mask__fill_arg(self):
        """Ensure masks are created correctly using a fill arg."""
        width, height = 59, 71
        expected_size = (width, height)
        fill_counts = {True: width * height, False: 0}

        for fill, expected_count in fill_counts.items():
            msg = "fill={}".format(fill)

            mask = pygame.mask.Mask(expected_size, fill)

            self.assertIsInstance(mask, pygame.mask.Mask, msg)
            self.assertEqual(mask.count(), expected_count, msg)
            self.assertEqual(mask.get_size(), expected_size, msg)

    def test_mask__size_kwarg(self):
        """Ensure masks are created correctly using the size keyword."""
        width, height = 73, 83
        expected_size = (width, height)
        fill_counts = {True: width * height, False: 0}

        for fill, expected_count in fill_counts.items():
            msg = "fill={}".format(fill)

            mask1 = pygame.mask.Mask(fill=fill, size=expected_size)
            mask2 = pygame.mask.Mask(size=expected_size, fill=fill)

            self.assertIsInstance(mask1, pygame.mask.Mask, msg)
            self.assertIsInstance(mask2, pygame.mask.Mask, msg)
            self.assertEqual(mask1.count(), expected_count, msg)
            self.assertEqual(mask2.count(), expected_count, msg)
            self.assertEqual(mask1.get_size(), expected_size, msg)
            self.assertEqual(mask2.get_size(), expected_size, msg)

    def test_copy(self):
        """Ensures copy works correctly with some bits set and unset."""
        # Test different widths and heights.
        for width in (31, 32, 33, 63, 64, 65):
            for height in (31, 32, 33, 63, 64, 65):
                mask = pygame.mask.Mask((width, height))

                # Create a checkerboard pattern of set/unset bits.
                for x in range(width):
                    for y in range(x & 1, height, 2):
                        mask.set_at((x, y))

                # Test both the copy() and __copy__() methods.
                for mask_copy in (mask.copy(), copy.copy(mask)):
                    self.assertIsInstance(mask_copy, pygame.mask.Mask)
                    self.assertIsNot(mask_copy, mask)
                    assertMaskEqual(self, mask_copy, mask)

    def test_copy__full(self):
        """Ensures copy works correctly on a filled masked."""
        # Test different widths and heights.
        for width in (31, 32, 33, 63, 64, 65):
            for height in (31, 32, 33, 63, 64, 65):
                mask = pygame.mask.Mask((width, height), fill=True)

                # Test both the copy() and __copy__() methods.
                for mask_copy in (mask.copy(), copy.copy(mask)):
                    self.assertIsInstance(mask_copy, pygame.mask.Mask)
                    self.assertIsNot(mask_copy, mask)
                    assertMaskEqual(self, mask_copy, mask)

    def test_copy__empty(self):
        """Ensures copy works correctly on an empty mask."""
        for width in (31, 32, 33, 63, 64, 65):
            for height in (31, 32, 33, 63, 64, 65):
                mask = pygame.mask.Mask((width, height))

                # Test both the copy() and __copy__() methods.
                for mask_copy in (mask.copy(), copy.copy(mask)):
                    self.assertIsInstance(mask_copy, pygame.mask.Mask)
                    self.assertIsNot(mask_copy, mask)
                    assertMaskEqual(self, mask_copy, mask)

    def test_copy__independent(self):
        """Ensures copy makes an independent copy of the mask."""
        mask_set_pos = (64, 1)
        mask_copy_set_pos = (64, 2)
        mask = pygame.mask.Mask((65, 3))

        # Test both the copy() and __copy__() methods.
        mask_copies = (mask.copy(), copy.copy(mask))
        mask.set_at(mask_set_pos)

        for mask_copy in mask_copies:
            mask_copy.set_at(mask_copy_set_pos)

            self.assertIsNot(mask_copy, mask)
            self.assertNotEqual(
                mask_copy.get_at(mask_set_pos), mask.get_at(mask_set_pos)
            )
            self.assertNotEqual(
                mask_copy.get_at(mask_copy_set_pos), mask.get_at(mask_copy_set_pos)
            )

    def test_get_size(self):
        """Ensure a mask's size is correctly retrieved."""
        expected_size = (93, 101)
        mask = pygame.mask.Mask(expected_size)

        self.assertEqual(mask.get_size(), expected_size)

    def test_get_rect(self):
        """Ensures get_rect works correctly."""
        expected_rect = pygame.Rect((0, 0), (11, 13))

        # Test on full and empty masks.
        for fill in (True, False):
            mask = pygame.mask.Mask(expected_rect.size, fill=fill)

            rect = mask.get_rect()

            self.assertEqual(rect, expected_rect)

    @unittest.skipIf(IS_PYPY, "Segfaults on pypy")
    def test_get_rect__one_kwarg(self):
        """Ensures get_rect supports a single rect attribute kwarg.

        Tests all the rect attributes.
        """
        # Rect attributes that take a single value.
        RECT_SINGLE_VALUE_ATTRIBUTES = (
            "x",
            "y",
            "top",
            "left",
            "bottom",
            "right",
            "centerx",
            "centery",
            "width",
            "height",
            "w",
            "h",
        )

        # Rect attributes that take 2 values.
        RECT_DOUBLE_VALUE_ATTRIBUTES = (
            "topleft",
            "bottomleft",
            "topright",
            "bottomright",
            "midtop",
            "midleft",
            "midbottom",
            "midright",
            "center",
            "size",
        )

        # Testing ints/floats and tuples/lists/Vector2s.
        # {attribute_names : attribute_values}
        rect_attributes = {
            RECT_SINGLE_VALUE_ATTRIBUTES: (3, 5.1),
            RECT_DOUBLE_VALUE_ATTRIBUTES: ((1, 2.2), [2.3, 3], Vector2(0, 1)),
        }

        size = (7, 3)
        mask = pygame.mask.Mask(size)

        for attributes, values in rect_attributes.items():
            for attribute in attributes:
                for value in values:
                    expected_rect = pygame.Rect((0, 0), size)
                    setattr(expected_rect, attribute, value)

                    rect = mask.get_rect(**{attribute: value})

                    self.assertEqual(rect, expected_rect)

    def test_get_rect__multiple_kwargs(self):
        """Ensures get_rect supports multiple rect attribute kwargs."""
        mask = pygame.mask.Mask((5, 4))
        expected_rect = pygame.Rect((0, 0), (0, 0))
        kwargs = {"x": 7.1, "top": -1, "size": Vector2(2, 3.2)}

        for attrib, value in kwargs.items():
            setattr(expected_rect, attrib, value)

        rect = mask.get_rect(**kwargs)

        self.assertEqual(rect, expected_rect)

    def test_get_rect__no_arg_support(self):
        """Ensures get_rect only supports kwargs."""
        mask = pygame.mask.Mask((4, 5))

        with self.assertRaises(TypeError):
            rect = mask.get_rect(3)

        with self.assertRaises(TypeError):
            rect = mask.get_rect((1, 2))

    @unittest.skipIf(IS_PYPY, "Segfaults on pypy")
    def test_get_rect__invalid_kwarg_name(self):
        """Ensures get_rect detects invalid kwargs."""
        mask = pygame.mask.Mask((1, 2))

        with self.assertRaises(AttributeError):
            rect = mask.get_rect(righte=11)

        with self.assertRaises(AttributeError):
            rect = mask.get_rect(toplef=(1, 1))

        with self.assertRaises(AttributeError):
            rect = mask.get_rect(move=(3, 2))

    def test_get_rect__invalid_kwarg_format(self):
        """Ensures get_rect detects invalid kwarg formats."""
        mask = pygame.mask.Mask((3, 11))

        with self.assertRaises(TypeError):
            rect = mask.get_rect(right="1")  # Wrong type.

        with self.assertRaises(TypeError):
            rect = mask.get_rect(bottom=(1,))  # Wrong type.

        with self.assertRaises(TypeError):
            rect = mask.get_rect(centerx=(1, 1))  # Wrong type.

        with self.assertRaises(TypeError):
            rect = mask.get_rect(midleft=(1, "1"))  # Wrong type.

        with self.assertRaises(TypeError):
            rect = mask.get_rect(topright=(1,))  # Too few.

        with self.assertRaises(TypeError):
            rect = mask.get_rect(bottomleft=(1, 2, 3))  # Too many.

        with self.assertRaises(TypeError):
            rect = mask.get_rect(midbottom=1)  # Wrong type.

    def test_get_at(self):
        """Ensure individual mask bits are correctly retrieved."""
        width, height = 5, 7
        mask0 = pygame.mask.Mask((width, height))
        mask1 = pygame.mask.Mask((width, height), fill=True)
        mask0_expected_bit = 0
        mask1_expected_bit = 1
        pos = (width - 1, height - 1)

        # Check twice to make sure bits aren't toggled.
        self.assertEqual(mask0.get_at(pos), mask0_expected_bit)
        self.assertEqual(mask0.get_at(pos=pos), mask0_expected_bit)
        self.assertEqual(mask1.get_at(Vector2(pos)), mask1_expected_bit)
        self.assertEqual(mask1.get_at(pos=Vector2(pos)), mask1_expected_bit)

    def test_get_at__out_of_bounds(self):
        """Ensure get_at() checks bounds."""
        width, height = 11, 3
        mask = pygame.mask.Mask((width, height))

        with self.assertRaises(IndexError):
            mask.get_at((width, 0))

        with self.assertRaises(IndexError):
            mask.get_at((0, height))

        with self.assertRaises(IndexError):
            mask.get_at((-1, 0))

        with self.assertRaises(IndexError):
            mask.get_at((0, -1))

    def test_set_at(self):
        """Ensure individual mask bits are set to 1."""
        width, height = 13, 17
        mask0 = pygame.mask.Mask((width, height))
        mask1 = pygame.mask.Mask((width, height), fill=True)
        mask0_expected_count = 1
        mask1_expected_count = mask1.count()
        expected_bit = 1
        pos = (width - 1, height - 1)

        mask0.set_at(pos, expected_bit)  # set 0 to 1
        mask1.set_at(pos=Vector2(pos), value=expected_bit)  # set 1 to 1

        self.assertEqual(mask0.get_at(pos), expected_bit)
        self.assertEqual(mask0.count(), mask0_expected_count)
        self.assertEqual(mask1.get_at(pos), expected_bit)
        self.assertEqual(mask1.count(), mask1_expected_count)

    def test_set_at__to_0(self):
        """Ensure individual mask bits are set to 0."""
        width, height = 11, 7
        mask0 = pygame.mask.Mask((width, height))
        mask1 = pygame.mask.Mask((width, height), fill=True)
        mask0_expected_count = 0
        mask1_expected_count = mask1.count() - 1
        expected_bit = 0
        pos = (width - 1, height - 1)

        mask0.set_at(pos, expected_bit)  # set 0 to 0
        mask1.set_at(pos, expected_bit)  # set 1 to 0

        self.assertEqual(mask0.get_at(pos), expected_bit)
        self.assertEqual(mask0.count(), mask0_expected_count)
        self.assertEqual(mask1.get_at(pos), expected_bit)
        self.assertEqual(mask1.count(), mask1_expected_count)

    def test_set_at__default_value(self):
        """Ensure individual mask bits are set using the default value."""
        width, height = 3, 21
        mask0 = pygame.mask.Mask((width, height))
        mask1 = pygame.mask.Mask((width, height), fill=True)
        mask0_expected_count = 1
        mask1_expected_count = mask1.count()
        expected_bit = 1
        pos = (width - 1, height - 1)

        mask0.set_at(pos)  # set 0 to 1
        mask1.set_at(pos)  # set 1 to 1

        self.assertEqual(mask0.get_at(pos), expected_bit)
        self.assertEqual(mask0.count(), mask0_expected_count)
        self.assertEqual(mask1.get_at(pos), expected_bit)
        self.assertEqual(mask1.count(), mask1_expected_count)

    def test_set_at__out_of_bounds(self):
        """Ensure set_at() checks bounds."""
        width, height = 11, 3
        mask = pygame.mask.Mask((width, height))

        with self.assertRaises(IndexError):
            mask.set_at((width, 0))

        with self.assertRaises(IndexError):
            mask.set_at((0, height))

        with self.assertRaises(IndexError):
            mask.set_at((-1, 0))

        with self.assertRaises(IndexError):
            mask.set_at((0, -1))

    def test_overlap(self):
        """Ensure the overlap intersection is correctly calculated.

        Testing the different combinations of full/empty masks:
            (mask1-filled) 1 overlap 1 (mask2-filled)
            (mask1-empty)  0 overlap 1 (mask2-filled)
            (mask1-filled) 1 overlap 0 (mask2-empty)
            (mask1-empty)  0 overlap 0 (mask2-empty)
        """
        expected_size = (4, 4)
        offset = (0, 0)
        expected_default = None
        expected_overlaps = {(True, True): offset}

        for fill2 in (True, False):
            mask2 = pygame.mask.Mask(expected_size, fill=fill2)
            mask2_count = mask2.count()

            for fill1 in (True, False):
                key = (fill1, fill2)
                msg = "key={}".format(key)
                mask1 = pygame.mask.Mask(expected_size, fill=fill1)
                mask1_count = mask1.count()
                expected_pos = expected_overlaps.get(key, expected_default)

                overlap_pos = mask1.overlap(mask2, offset)

                self.assertEqual(overlap_pos, expected_pos, msg)

                # Ensure mask1/mask2 unchanged.
                self.assertEqual(mask1.count(), mask1_count, msg)
                self.assertEqual(mask2.count(), mask2_count, msg)
                self.assertEqual(mask1.get_size(), expected_size, msg)
                self.assertEqual(mask2.get_size(), expected_size, msg)

    def test_overlap__offset(self):
        """Ensure an offset overlap intersection is correctly calculated."""
        mask1 = pygame.mask.Mask((65, 3), fill=True)
        mask2 = pygame.mask.Mask((66, 4), fill=True)
        mask1_count = mask1.count()
        mask2_count = mask2.count()
        mask1_size = mask1.get_size()
        mask2_size = mask2.get_size()

        for offset in self.ORIGIN_OFFSETS:
            msg = "offset={}".format(offset)
            expected_pos = (max(offset[0], 0), max(offset[1], 0))

            overlap_pos = mask1.overlap(other=mask2, offset=offset)

            self.assertEqual(overlap_pos, expected_pos, msg)

            # Ensure mask1/mask2 unchanged.
            self.assertEqual(mask1.count(), mask1_count, msg)
            self.assertEqual(mask2.count(), mask2_count, msg)
            self.assertEqual(mask1.get_size(), mask1_size, msg)
            self.assertEqual(mask2.get_size(), mask2_size, msg)

    def test_overlap__offset_with_unset_bits(self):
        """Ensure an offset overlap intersection is correctly calculated
        when (0, 0) bits not set."""
        mask1 = pygame.mask.Mask((65, 3), fill=True)
        mask2 = pygame.mask.Mask((66, 4), fill=True)
        unset_pos = (0, 0)
        mask1.set_at(unset_pos, 0)
        mask2.set_at(unset_pos, 0)
        mask1_count = mask1.count()
        mask2_count = mask2.count()
        mask1_size = mask1.get_size()
        mask2_size = mask2.get_size()

        for offset in self.ORIGIN_OFFSETS:
            msg = "offset={}".format(offset)
            x, y = offset
            expected_y = max(y, 0)
            if 0 == y:
                expected_x = max(x + 1, 1)
            elif 0 < y:
                expected_x = max(x + 1, 0)
            else:
                expected_x = max(x, 1)

            overlap_pos = mask1.overlap(mask2, Vector2(offset))

            self.assertEqual(overlap_pos, (expected_x, expected_y), msg)

            # Ensure mask1/mask2 unchanged.
            self.assertEqual(mask1.count(), mask1_count, msg)
            self.assertEqual(mask2.count(), mask2_count, msg)
            self.assertEqual(mask1.get_size(), mask1_size, msg)
            self.assertEqual(mask2.get_size(), mask2_size, msg)
            self.assertEqual(mask1.get_at(unset_pos), 0, msg)
            self.assertEqual(mask2.get_at(unset_pos), 0, msg)

    def test_overlap__no_overlap(self):
        """Ensure an offset overlap intersection is correctly calculated
        when there is no overlap."""
        mask1 = pygame.mask.Mask((65, 3), fill=True)
        mask1_count = mask1.count()
        mask1_size = mask1.get_size()

        mask2_w, mask2_h = 67, 5
        mask2_size = (mask2_w, mask2_h)
        mask2 = pygame.mask.Mask(mask2_size)
        set_pos = (mask2_w - 1, mask2_h - 1)
        mask2.set_at(set_pos)
        mask2_count = 1

        for offset in self.ORIGIN_OFFSETS:
            msg = "offset={}".format(offset)

            overlap_pos = mask1.overlap(mask2, offset)

            self.assertIsNone(overlap_pos, msg)

            # Ensure mask1/mask2 unchanged.
            self.assertEqual(mask1.count(), mask1_count, msg)
            self.assertEqual(mask2.count(), mask2_count, msg)
            self.assertEqual(mask1.get_size(), mask1_size, msg)
            self.assertEqual(mask2.get_size(), mask2_size, msg)
            self.assertEqual(mask2.get_at(set_pos), 1, msg)

    def test_overlap__offset_boundary(self):
        """Ensures overlap handles offsets and boundaries correctly."""
        mask1 = pygame.mask.Mask((13, 3), fill=True)
        mask2 = pygame.mask.Mask((7, 5), fill=True)
        mask1_count = mask1.count()
        mask2_count = mask2.count()
        mask1_size = mask1.get_size()
        mask2_size = mask2.get_size()

        # Check the 4 boundaries.
        offsets = (
            (mask1_size[0], 0),  # off right
            (0, mask1_size[1]),  # off bottom
            (-mask2_size[0], 0),  # off left
            (0, -mask2_size[1]),
        )  # off top

        for offset in offsets:
            msg = "offset={}".format(offset)

            overlap_pos = mask1.overlap(mask2, offset)

            self.assertIsNone(overlap_pos, msg)

            # Ensure mask1/mask2 unchanged.
            self.assertEqual(mask1.count(), mask1_count, msg)
            self.assertEqual(mask2.count(), mask2_count, msg)
            self.assertEqual(mask1.get_size(), mask1_size, msg)
            self.assertEqual(mask2.get_size(), mask2_size, msg)

    @unittest.skipIf(IS_PYPY, "Segfaults on pypy")
    def test_overlap__bit_boundaries(self):
        """Ensures overlap handles masks of different sizes correctly.

        Tests masks of different sizes, including:
           -masks 31 to 33 bits wide (32 bit boundaries)
           -masks 63 to 65 bits wide (64 bit boundaries)
        """
        for height in range(2, 4):
            for width in range(2, 66):
                mask_size = (width, height)
                mask_count = width * height
                mask1 = pygame.mask.Mask(mask_size, fill=True)
                mask2 = pygame.mask.Mask(mask_size, fill=True)

                # Testing masks offset from each other.
                for offset in self.ORIGIN_OFFSETS:
                    msg = "size={}, offset={}".format(mask_size, offset)
                    expected_pos = (max(offset[0], 0), max(offset[1], 0))

                    overlap_pos = mask1.overlap(mask2, offset)

                    self.assertEqual(overlap_pos, expected_pos, msg)

                    # Ensure mask1/mask2 unchanged.
                    self.assertEqual(mask1.count(), mask_count, msg)
                    self.assertEqual(mask2.count(), mask_count, msg)
                    self.assertEqual(mask1.get_size(), mask_size, msg)
                    self.assertEqual(mask2.get_size(), mask_size, msg)

    @unittest.skipIf(IS_PYPY, "Segfaults on pypy")
    def test_overlap__invalid_mask_arg(self):
        """Ensure overlap handles invalid mask arguments correctly."""
        size = (5, 3)
        offset = (0, 0)
        mask = pygame.mask.Mask(size)
        invalid_mask = pygame.Surface(size)

        with self.assertRaises(TypeError):
            overlap_pos = mask.overlap(invalid_mask, offset)

    def test_overlap__invalid_offset_arg(self):
        """Ensure overlap handles invalid offset arguments correctly."""
        size = (2, 7)
        offset = "(0, 0)"
        mask1 = pygame.mask.Mask(size)
        mask2 = pygame.mask.Mask(size)

        with self.assertRaises(TypeError):
            overlap_pos = mask1.overlap(mask2, offset)

    @unittest.skipIf(IS_PYPY, "Segfaults on pypy")
    def test_overlap_area(self):
        """Ensure the overlap_area is correctly calculated.

        Testing the different combinations of full/empty masks:
            (mask1-filled) 1 overlap_area 1 (mask2-filled)
            (mask1-empty)  0 overlap_area 1 (mask2-filled)
            (mask1-filled) 1 overlap_area 0 (mask2-empty)
            (mask1-empty)  0 overlap_area 0 (mask2-empty)
        """
        expected_size = width, height = (4, 4)
        offset = (0, 0)
        expected_default = 0
        expected_counts = {(True, True): width * height}

        for fill2 in (True, False):
            mask2 = pygame.mask.Mask(expected_size, fill=fill2)
            mask2_count = mask2.count()

            for fill1 in (True, False):
                key = (fill1, fill2)
                msg = "key={}".format(key)
                mask1 = pygame.mask.Mask(expected_size, fill=fill1)
                mask1_count = mask1.count()
                expected_count = expected_counts.get(key, expected_default)

                overlap_count = mask1.overlap_area(mask2, offset)

                self.assertEqual(overlap_count, expected_count, msg)

                # Ensure mask1/mask2 unchanged.
                self.assertEqual(mask1.count(), mask1_count, msg)
                self.assertEqual(mask2.count(), mask2_count, msg)
                self.assertEqual(mask1.get_size(), expected_size, msg)
                self.assertEqual(mask2.get_size(), expected_size, msg)

    @unittest.skipIf(IS_PYPY, "Segfaults on pypy")
    def test_overlap_area__offset(self):
        """Ensure an offset overlap_area is correctly calculated."""
        mask1 = pygame.mask.Mask((65, 3), fill=True)
        mask2 = pygame.mask.Mask((66, 4), fill=True)
        mask1_count = mask1.count()
        mask2_count = mask2.count()
        mask1_size = mask1.get_size()
        mask2_size = mask2.get_size()

        # Using rects to help determine the overlapping area.
        rect1 = mask1.get_rect()
        rect2 = mask2.get_rect()

        for offset in self.ORIGIN_OFFSETS:
            msg = "offset={}".format(offset)
            rect2.topleft = offset
            overlap_rect = rect1.clip(rect2)
            expected_count = overlap_rect.w * overlap_rect.h

            overlap_count = mask1.overlap_area(other=mask2, offset=offset)

            self.assertEqual(overlap_count, expected_count, msg)

            # Ensure mask1/mask2 unchanged.
            self.assertEqual(mask1.count(), mask1_count, msg)
            self.assertEqual(mask2.count(), mask2_count, msg)
            self.assertEqual(mask1.get_size(), mask1_size, msg)
            self.assertEqual(mask2.get_size(), mask2_size, msg)

    def test_overlap_area__offset_boundary(self):
        """Ensures overlap_area handles offsets and boundaries correctly."""
        mask1 = pygame.mask.Mask((11, 3), fill=True)
        mask2 = pygame.mask.Mask((5, 7), fill=True)
        mask1_count = mask1.count()
        mask2_count = mask2.count()
        mask1_size = mask1.get_size()
        mask2_size = mask2.get_size()
        expected_count = 0

        # Check the 4 boundaries.
        offsets = (
            (mask1_size[0], 0),  # off right
            (0, mask1_size[1]),  # off bottom
            (-mask2_size[0], 0),  # off left
            (0, -mask2_size[1]),
        )  # off top

        for offset in offsets:
            msg = "offset={}".format(offset)

            overlap_count = mask1.overlap_area(mask2, Vector2(offset))

            self.assertEqual(overlap_count, expected_count, msg)

            # Ensure mask1/mask2 unchanged.
            self.assertEqual(mask1.count(), mask1_count, msg)
            self.assertEqual(mask2.count(), mask2_count, msg)
            self.assertEqual(mask1.get_size(), mask1_size, msg)
            self.assertEqual(mask2.get_size(), mask2_size, msg)

    @unittest.skipIf(IS_PYPY, "Segfaults on pypy")
    def test_overlap_area__bit_boundaries(self):
        """Ensures overlap_area handles masks of different sizes correctly.

        Tests masks of different sizes, including:
           -masks 31 to 33 bits wide (32 bit boundaries)
           -masks 63 to 65 bits wide (64 bit boundaries)
        """
        for height in range(2, 4):
            for width in range(2, 66):
                mask_size = (width, height)
                mask_count = width * height
                mask1 = pygame.mask.Mask(mask_size, fill=True)
                mask2 = pygame.mask.Mask(mask_size, fill=True)

                # Using rects to help determine the overlapping area.
                rect1 = mask1.get_rect()
                rect2 = mask2.get_rect()

                # Testing masks offset from each other.
                for offset in self.ORIGIN_OFFSETS:
                    msg = "size={}, offset={}".format(mask_size, offset)
                    rect2.topleft = offset
                    overlap_rect = rect1.clip(rect2)
                    expected_overlap_count = overlap_rect.w * overlap_rect.h

                    overlap_count = mask1.overlap_area(mask2, offset)

                    self.assertEqual(overlap_count, expected_overlap_count, msg)

                    # Ensure mask1/mask2 unchanged.
                    self.assertEqual(mask1.count(), mask_count, msg)
                    self.assertEqual(mask2.count(), mask_count, msg)
                    self.assertEqual(mask1.get_size(), mask_size, msg)
                    self.assertEqual(mask2.get_size(), mask_size, msg)

    def test_overlap_area__invalid_mask_arg(self):
        """Ensure overlap_area handles invalid mask arguments correctly."""
        size = (3, 5)
        offset = (0, 0)
        mask = pygame.mask.Mask(size)
        invalid_mask = pygame.Surface(size)

        with self.assertRaises(TypeError):
            overlap_count = mask.overlap_area(invalid_mask, offset)

    def test_overlap_area__invalid_offset_arg(self):
        """Ensure overlap_area handles invalid offset arguments correctly."""
        size = (7, 2)
        offset = "(0, 0)"
        mask1 = pygame.mask.Mask(size)
        mask2 = pygame.mask.Mask(size)

        with self.assertRaises(TypeError):
            overlap_count = mask1.overlap_area(mask2, offset)

    def test_overlap_mask(self):
        """Ensure overlap_mask's mask has correct bits set.

        Testing the different combinations of full/empty masks:
            (mask1-filled) 1 overlap_mask 1 (mask2-filled)
            (mask1-empty)  0 overlap_mask 1 (mask2-filled)
            (mask1-filled) 1 overlap_mask 0 (mask2-empty)
            (mask1-empty)  0 overlap_mask 0 (mask2-empty)
        """
        expected_size = (4, 4)
        offset = (0, 0)
        expected_default = pygame.mask.Mask(expected_size)
        expected_masks = {(True, True): pygame.mask.Mask(expected_size, fill=True)}

        for fill2 in (True, False):
            mask2 = pygame.mask.Mask(expected_size, fill=fill2)
            mask2_count = mask2.count()

            for fill1 in (True, False):
                key = (fill1, fill2)
                msg = "key={}".format(key)
                mask1 = pygame.mask.Mask(expected_size, fill=fill1)
                mask1_count = mask1.count()
                expected_mask = expected_masks.get(key, expected_default)

                overlap_mask = mask1.overlap_mask(other=mask2, offset=offset)

                self.assertIsInstance(overlap_mask, pygame.mask.Mask, msg)
                assertMaskEqual(self, overlap_mask, expected_mask, msg)

                # Ensure mask1/mask2 unchanged.
                self.assertEqual(mask1.count(), mask1_count, msg)
                self.assertEqual(mask2.count(), mask2_count, msg)
                self.assertEqual(mask1.get_size(), expected_size, msg)
                self.assertEqual(mask2.get_size(), expected_size, msg)

    @unittest.skipIf(IS_PYPY, "Segfaults on pypy")
    def test_overlap_mask__bits_set(self):
        """Ensure overlap_mask's mask has correct bits set."""
        mask1 = pygame.mask.Mask((50, 50), fill=True)
        mask2 = pygame.mask.Mask((300, 10), fill=True)
        mask1_count = mask1.count()
        mask2_count = mask2.count()
        mask1_size = mask1.get_size()
        mask2_size = mask2.get_size()

        mask3 = mask1.overlap_mask(mask2, (-1, 0))

        for i in range(50):
            for j in range(10):
                self.assertEqual(mask3.get_at((i, j)), 1, "({}, {})".format(i, j))

        for i in range(50):
            for j in range(11, 50):
                self.assertEqual(mask3.get_at((i, j)), 0, "({}, {})".format(i, j))

        # Ensure mask1/mask2 unchanged.
        self.assertEqual(mask1.count(), mask1_count)
        self.assertEqual(mask2.count(), mask2_count)
        self.assertEqual(mask1.get_size(), mask1_size)
        self.assertEqual(mask2.get_size(), mask2_size)

    def test_overlap_mask__offset(self):
        """Ensure an offset overlap_mask's mask is correctly calculated."""
        mask1 = pygame.mask.Mask((65, 3), fill=True)
        mask2 = pygame.mask.Mask((66, 4), fill=True)
        mask1_count = mask1.count()
        mask2_count = mask2.count()
        mask1_size = mask1.get_size()
        mask2_size = mask2.get_size()
        expected_mask = pygame.Mask(mask1_size)

        # Using rects to help determine the overlapping area.
        rect1 = mask1.get_rect()
        rect2 = mask2.get_rect()

        for offset in self.ORIGIN_OFFSETS:
            msg = "offset={}".format(offset)
            rect2.topleft = offset
            overlap_rect = rect1.clip(rect2)
            expected_mask.clear()
            expected_mask.draw(
                pygame.Mask(overlap_rect.size, fill=True), overlap_rect.topleft
            )

            overlap_mask = mask1.overlap_mask(mask2, offset)

            self.assertIsInstance(overlap_mask, pygame.mask.Mask, msg)
            assertMaskEqual(self, overlap_mask, expected_mask, msg)

            # Ensure mask1/mask2 unchanged.
            self.assertEqual(mask1.count(), mask1_count, msg)
            self.assertEqual(mask2.count(), mask2_count, msg)
            self.assertEqual(mask1.get_size(), mask1_size, msg)
            self.assertEqual(mask2.get_size(), mask2_size, msg)

    @unittest.skipIf(IS_PYPY, "Segfaults on pypy")
    def test_overlap_mask__specific_offsets(self):
        """Ensure an offset overlap_mask's mask is correctly calculated.

        Testing the specific case of:
            -both masks are wider than 32 bits
            -a positive offset is used
            -the mask calling overlap_mask() is wider than the mask passed in
        """
        mask1 = pygame.mask.Mask((65, 5), fill=True)
        mask2 = pygame.mask.Mask((33, 3), fill=True)
        expected_mask = pygame.Mask(mask1.get_size())

        # Using rects to help determine the overlapping area.
        rect1 = mask1.get_rect()
        rect2 = mask2.get_rect()

        # This rect's corners are used to move rect2 around the inside of
        # rect1.
        corner_rect = rect1.inflate(-2, -2)

        for corner in ("topleft", "topright", "bottomright", "bottomleft"):
            setattr(rect2, corner, getattr(corner_rect, corner))
            offset = rect2.topleft
            msg = "offset={}".format(offset)
            overlap_rect = rect1.clip(rect2)
            expected_mask.clear()
            expected_mask.draw(
                pygame.Mask(overlap_rect.size, fill=True), overlap_rect.topleft
            )

            overlap_mask = mask1.overlap_mask(mask2, offset)

            self.assertIsInstance(overlap_mask, pygame.mask.Mask, msg)
            assertMaskEqual(self, overlap_mask, expected_mask, msg)

    def test_overlap_mask__offset_boundary(self):
        """Ensures overlap_mask handles offsets and boundaries correctly."""
        mask1 = pygame.mask.Mask((9, 3), fill=True)
        mask2 = pygame.mask.Mask((11, 5), fill=True)
        mask1_count = mask1.count()
        mask2_count = mask2.count()
        mask1_size = mask1.get_size()
        mask2_size = mask2.get_size()
        expected_count = 0
        expected_size = mask1_size

        # Check the 4 boundaries.
        offsets = (
            (mask1_size[0], 0),  # off right
            (0, mask1_size[1]),  # off bottom
            (-mask2_size[0], 0),  # off left
            (0, -mask2_size[1]),
        )  # off top

        for offset in offsets:
            msg = "offset={}".format(offset)

            overlap_mask = mask1.overlap_mask(mask2, offset)

            self.assertIsInstance(overlap_mask, pygame.mask.Mask, msg)
            self.assertEqual(overlap_mask.count(), expected_count, msg)
            self.assertEqual(overlap_mask.get_size(), expected_size, msg)

            # Ensure mask1/mask2 unchanged.
            self.assertEqual(mask1.count(), mask1_count, msg)
            self.assertEqual(mask2.count(), mask2_count, msg)
            self.assertEqual(mask1.get_size(), mask1_size, msg)
            self.assertEqual(mask2.get_size(), mask2_size, msg)

    @unittest.skipIf(IS_PYPY, "Segfaults on pypy")
    def test_overlap_mask__bit_boundaries(self):
        """Ensures overlap_mask handles masks of different sizes correctly.

        Tests masks of different sizes, including:
           -masks 31 to 33 bits wide (32 bit boundaries)
           -masks 63 to 65 bits wide (64 bit boundaries)
        """
        for height in range(2, 4):
            for width in range(2, 66):
                mask_size = (width, height)
                mask_count = width * height
                mask1 = pygame.mask.Mask(mask_size, fill=True)
                mask2 = pygame.mask.Mask(mask_size, fill=True)
                expected_mask = pygame.Mask(mask_size)

                # Using rects to help determine the overlapping area.
                rect1 = mask1.get_rect()
                rect2 = mask2.get_rect()

                # Testing masks offset from each other.
                for offset in self.ORIGIN_OFFSETS:
                    msg = "size={}, offset={}".format(mask_size, offset)
                    rect2.topleft = offset
                    overlap_rect = rect1.clip(rect2)
                    expected_mask.clear()
                    expected_mask.draw(
                        pygame.Mask(overlap_rect.size, fill=True), overlap_rect.topleft
                    )

                    overlap_mask = mask1.overlap_mask(mask2, offset)

                    self.assertIsInstance(overlap_mask, pygame.mask.Mask, msg)
                    assertMaskEqual(self, overlap_mask, expected_mask, msg)

                    # Ensure mask1/mask2 unchanged.
                    self.assertEqual(mask1.count(), mask_count, msg)
                    self.assertEqual(mask2.count(), mask_count, msg)
                    self.assertEqual(mask1.get_size(), mask_size, msg)
                    self.assertEqual(mask2.get_size(), mask_size, msg)

    def test_overlap_mask__invalid_mask_arg(self):
        """Ensure overlap_mask handles invalid mask arguments correctly."""
        size = (3, 2)
        offset = (0, 0)
        mask = pygame.mask.Mask(size)
        invalid_mask = pygame.Surface(size)

        with self.assertRaises(TypeError):
            overlap_mask = mask.overlap_mask(invalid_mask, offset)

    def test_overlap_mask__invalid_offset_arg(self):
        """Ensure overlap_mask handles invalid offset arguments correctly."""
        size = (5, 2)
        offset = "(0, 0)"
        mask1 = pygame.mask.Mask(size)
        mask2 = pygame.mask.Mask(size)

        with self.assertRaises(TypeError):
            overlap_mask = mask1.overlap_mask(mask2, offset)

    def test_mask_access(self):
        """do the set_at, and get_at parts work correctly?"""
        m = pygame.Mask((10, 10))
        m.set_at((0, 0), 1)
        self.assertEqual(m.get_at((0, 0)), 1)
        m.set_at((9, 0), 1)
        self.assertEqual(m.get_at((9, 0)), 1)

        # s = pygame.Surface((10,10))
        # s.set_at((1,0), (0, 0, 1, 255))
        # self.assertEqual(s.get_at((1,0)), (0, 0, 1, 255))
        # s.set_at((-1,0), (0, 0, 1, 255))

        # out of bounds, should get IndexError
        self.assertRaises(IndexError, lambda: m.get_at((-1, 0)))
        self.assertRaises(IndexError, lambda: m.set_at((-1, 0), 1))
        self.assertRaises(IndexError, lambda: m.set_at((10, 0), 1))
        self.assertRaises(IndexError, lambda: m.set_at((0, 10), 1))

    def test_fill(self):
        """Ensure a mask can be filled."""
        width, height = 11, 23
        expected_count = width * height
        expected_size = (width, height)
        mask = pygame.mask.Mask(expected_size)

        mask.fill()

        self.assertEqual(mask.count(), expected_count)
        self.assertEqual(mask.get_size(), expected_size)

    @unittest.skipIf(IS_PYPY, "Segfaults on pypy")
    def test_fill__bit_boundaries(self):
        """Ensures masks of different sizes are filled correctly.

        Tests masks of different sizes, including:
           -masks 31 to 33 bits wide (32 bit boundaries)
           -masks 63 to 65 bits wide (64 bit boundaries)
        """
        for height in range(1, 4):
            for width in range(1, 66):
                mask = pygame.mask.Mask((width, height))
                expected_count = width * height

                mask.fill()

                self.assertEqual(
                    mask.count(), expected_count, "size=({}, {})".format(width, height)
                )

    def test_clear(self):
        """Ensure a mask can be cleared."""
        expected_count = 0
        expected_size = (13, 27)
        mask = pygame.mask.Mask(expected_size, fill=True)

        mask.clear()

        self.assertEqual(mask.count(), expected_count)
        self.assertEqual(mask.get_size(), expected_size)

    def test_clear__bit_boundaries(self):
        """Ensures masks of different sizes are cleared correctly.

        Tests masks of different sizes, including:
           -masks 31 to 33 bits wide (32 bit boundaries)
           -masks 63 to 65 bits wide (64 bit boundaries)
        """
        expected_count = 0

        for height in range(1, 4):
            for width in range(1, 66):
                mask = pygame.mask.Mask((width, height), fill=True)

                mask.clear()

                self.assertEqual(
                    mask.count(), expected_count, "size=({}, {})".format(width, height)
                )

    @unittest.skipIf(IS_PYPY, "Segfaults on pypy")
    def test_invert(self):
        """Ensure a mask can be inverted."""
        side = 73
        expected_size = (side, side)
        mask1 = pygame.mask.Mask(expected_size)
        mask2 = pygame.mask.Mask(expected_size, fill=True)
        expected_count1 = side * side
        expected_count2 = 0

        for i in range(side):
            expected_count1 -= 1
            expected_count2 += 1
            pos = (i, i)
            mask1.set_at(pos)
            mask2.set_at(pos, 0)

        mask1.invert()
        mask2.invert()

        self.assertEqual(mask1.count(), expected_count1)
        self.assertEqual(mask2.count(), expected_count2)
        self.assertEqual(mask1.get_size(), expected_size)
        self.assertEqual(mask2.get_size(), expected_size)

        for i in range(side):
            pos = (i, i)
            msg = "pos={}".format(pos)

            self.assertEqual(mask1.get_at(pos), 0, msg)
            self.assertEqual(mask2.get_at(pos), 1, msg)

    def test_invert__full(self):
        """Ensure a full mask can be inverted."""
        expected_count = 0
        expected_size = (43, 97)
        mask = pygame.mask.Mask(expected_size, fill=True)

        mask.invert()

        self.assertEqual(mask.count(), expected_count)
        self.assertEqual(mask.get_size(), expected_size)

    def test_invert__empty(self):
        """Ensure an empty mask can be inverted."""
        width, height = 43, 97
        expected_size = (width, height)
        expected_count = width * height
        mask = pygame.mask.Mask(expected_size)

        mask.invert()

        self.assertEqual(mask.count(), expected_count)
        self.assertEqual(mask.get_size(), expected_size)

    @unittest.skipIf(IS_PYPY, "Segfaults on pypy")
    def test_invert__bit_boundaries(self):
        """Ensures masks of different sizes are inverted correctly.

        Tests masks of different sizes, including:
           -masks 31 to 33 bits wide (32 bit boundaries)
           -masks 63 to 65 bits wide (64 bit boundaries)
        """
        for fill in (True, False):
            for height in range(1, 4):
                for width in range(1, 66):
                    mask = pygame.mask.Mask((width, height), fill=fill)
                    expected_count = 0 if fill else width * height

                    mask.invert()

                    self.assertEqual(
                        mask.count(),
                        expected_count,
                        "fill={}, size=({}, {})".format(fill, width, height),
                    )

    @unittest.skipIf(IS_PYPY, "Segfaults on pypy")
    def test_scale(self):
        """Ensure a mask can be scaled."""
        width, height = 43, 61
        original_size = (width, height)

        for fill in (True, False):
            original_mask = pygame.mask.Mask(original_size, fill=fill)
            original_count = width * height if fill else 0

            # Test a range of sizes. Also tests scaling to 'same'
            # size when new_w, new_h = width, height
            for new_w in range(width - 10, width + 10):
                for new_h in range(height - 10, height + 10):
                    expected_size = (new_w, new_h)
                    expected_count = new_w * new_h if fill else 0
                    msg = "size={}".format(expected_size)

                    mask = original_mask.scale(scale=expected_size)

                    self.assertIsInstance(mask, pygame.mask.Mask, msg)
                    self.assertEqual(mask.count(), expected_count, msg)
                    self.assertEqual(mask.get_size(), expected_size)

                    # Ensure the original mask is unchanged.
                    self.assertEqual(original_mask.count(), original_count, msg)
                    self.assertEqual(original_mask.get_size(), original_size, msg)

    def test_scale__negative_size(self):
        """Ensure scale handles negative sizes correctly."""
        mask = pygame.Mask((100, 100))

        with self.assertRaises(ValueError):
            mask.scale((-1, -1))

        with self.assertRaises(ValueError):
            mask.scale(Vector2(-1, 10))

        with self.assertRaises(ValueError):
            mask.scale((10, -1))

    def test_draw(self):
        """Ensure a mask can be drawn onto another mask.

        Testing the different combinations of full/empty masks:
            (mask1-filled) 1 draw 1 (mask2-filled)
            (mask1-empty)  0 draw 1 (mask2-filled)
            (mask1-filled) 1 draw 0 (mask2-empty)
            (mask1-empty)  0 draw 0 (mask2-empty)
        """
        expected_size = (4, 4)
        offset = (0, 0)
        expected_default = pygame.mask.Mask(expected_size, fill=True)
        expected_masks = {(False, False): pygame.mask.Mask(expected_size)}

        for fill2 in (True, False):
            mask2 = pygame.mask.Mask(expected_size, fill=fill2)
            mask2_count = mask2.count()

            for fill1 in (True, False):
                key = (fill1, fill2)
                msg = "key={}".format(key)
                mask1 = pygame.mask.Mask(expected_size, fill=fill1)
                expected_mask = expected_masks.get(key, expected_default)

                mask1.draw(mask2, offset)

                assertMaskEqual(self, mask1, expected_mask, msg)

                # Ensure mask2 unchanged.
                self.assertEqual(mask2.count(), mask2_count, msg)
                self.assertEqual(mask2.get_size(), expected_size, msg)

    def test_draw__offset(self):
        """Ensure an offset mask can be drawn onto another mask."""
        mask1 = pygame.mask.Mask((65, 3))
        mask2 = pygame.mask.Mask((66, 4), fill=True)
        mask2_count = mask2.count()
        mask2_size = mask2.get_size()
        expected_mask = pygame.Mask(mask1.get_size())

        # Using rects to help determine the overlapping area.
        rect1 = mask1.get_rect()
        rect2 = mask2.get_rect()

        for offset in self.ORIGIN_OFFSETS:
            msg = "offset={}".format(offset)
            rect2.topleft = offset
            overlap_rect = rect1.clip(rect2)
            expected_mask.clear()

            # Normally draw() could be used to set these bits, but the draw()
            # method is being tested here, so a loop is used instead.
            for x in range(overlap_rect.left, overlap_rect.right):
                for y in range(overlap_rect.top, overlap_rect.bottom):
                    expected_mask.set_at((x, y))
            mask1.clear()  # Ensure it's empty for testing each offset.

            mask1.draw(other=mask2, offset=offset)

            assertMaskEqual(self, mask1, expected_mask, msg)

            # Ensure mask2 unchanged.
            self.assertEqual(mask2.count(), mask2_count, msg)
            self.assertEqual(mask2.get_size(), mask2_size, msg)

    def test_draw__specific_offsets(self):
        """Ensure an offset mask can be drawn onto another mask.

        Testing the specific case of:
            -both masks are wider than 32 bits
            -a positive offset is used
            -the mask calling draw() is wider than the mask passed in
        """
        mask1 = pygame.mask.Mask((65, 5))
        mask2 = pygame.mask.Mask((33, 3), fill=True)
        expected_mask = pygame.Mask(mask1.get_size())

        # Using rects to help determine the overlapping area.
        rect1 = mask1.get_rect()
        rect2 = mask2.get_rect()

        # This rect's corners are used to move rect2 around the inside of
        # rect1.
        corner_rect = rect1.inflate(-2, -2)

        for corner in ("topleft", "topright", "bottomright", "bottomleft"):
            setattr(rect2, corner, getattr(corner_rect, corner))
            offset = rect2.topleft
            msg = "offset={}".format(offset)
            overlap_rect = rect1.clip(rect2)
            expected_mask.clear()

            # Normally draw() could be used to set these bits, but the draw()
            # method is being tested here, so a loop is used instead.
            for x in range(overlap_rect.left, overlap_rect.right):
                for y in range(overlap_rect.top, overlap_rect.bottom):
                    expected_mask.set_at((x, y))
            mask1.clear()  # Ensure it's empty for testing each offset.

            mask1.draw(mask2, offset)

            assertMaskEqual(self, mask1, expected_mask, msg)

    def test_draw__offset_boundary(self):
        """Ensures draw handles offsets and boundaries correctly."""
        mask1 = pygame.mask.Mask((13, 5))
        mask2 = pygame.mask.Mask((7, 3), fill=True)
        mask1_count = mask1.count()
        mask2_count = mask2.count()
        mask1_size = mask1.get_size()
        mask2_size = mask2.get_size()

        # Check the 4 boundaries.
        offsets = (
            (mask1_size[0], 0),  # off right
            (0, mask1_size[1]),  # off bottom
            (-mask2_size[0], 0),  # off left
            (0, -mask2_size[1]),
        )  # off top

        for offset in offsets:
            msg = "offset={}".format(offset)

            mask1.draw(mask2, offset)

            # Ensure mask1/mask2 unchanged.
            self.assertEqual(mask1.count(), mask1_count, msg)
            self.assertEqual(mask2.count(), mask2_count, msg)
            self.assertEqual(mask1.get_size(), mask1_size, msg)
            self.assertEqual(mask2.get_size(), mask2_size, msg)

    @unittest.skipIf(IS_PYPY, "Segfaults on pypy")
    def test_draw__bit_boundaries(self):
        """Ensures draw handles masks of different sizes correctly.

        Tests masks of different sizes, including:
           -masks 31 to 33 bits wide (32 bit boundaries)
           -masks 63 to 65 bits wide (64 bit boundaries)
        """
        for height in range(2, 4):
            for width in range(2, 66):
                mask_size = (width, height)
                mask_count = width * height
                mask1 = pygame.mask.Mask(mask_size)
                mask2 = pygame.mask.Mask(mask_size, fill=True)
                expected_mask = pygame.Mask(mask_size)

                # Using rects to help determine the overlapping area.
                rect1 = mask1.get_rect()
                rect2 = mask2.get_rect()

                # Testing masks offset from each other.
                for offset in self.ORIGIN_OFFSETS:
                    msg = "size={}, offset={}".format(mask_size, offset)
                    rect2.topleft = offset
                    overlap_rect = rect1.clip(rect2)
                    expected_mask.clear()

                    # Normally draw() could be used to set these bits, but the
                    # draw() method is being tested here, so a loop is used
                    # instead.
                    for x in range(overlap_rect.left, overlap_rect.right):
                        for y in range(overlap_rect.top, overlap_rect.bottom):
                            expected_mask.set_at((x, y))
                    mask1.clear()  # Ensure it's empty for each test.

                    mask1.draw(mask2, offset)

                    assertMaskEqual(self, mask1, expected_mask, msg)

                    # Ensure mask2 unchanged.
                    self.assertEqual(mask2.count(), mask_count, msg)
                    self.assertEqual(mask2.get_size(), mask_size, msg)

    def test_draw__invalid_mask_arg(self):
        """Ensure draw handles invalid mask arguments correctly."""
        size = (7, 3)
        offset = (0, 0)
        mask = pygame.mask.Mask(size)
        invalid_mask = pygame.Surface(size)

        with self.assertRaises(TypeError):
            mask.draw(invalid_mask, offset)

    def test_draw__invalid_offset_arg(self):
        """Ensure draw handles invalid offset arguments correctly."""
        size = (5, 7)
        offset = "(0, 0)"
        mask1 = pygame.mask.Mask(size)
        mask2 = pygame.mask.Mask(size)

        with self.assertRaises(TypeError):
            mask1.draw(mask2, offset)

    def test_erase(self):
        """Ensure a mask can erase another mask.

        Testing the different combinations of full/empty masks:
            (mask1-filled) 1 erase 1 (mask2-filled)
            (mask1-empty)  0 erase 1 (mask2-filled)
            (mask1-filled) 1 erase 0 (mask2-empty)
            (mask1-empty)  0 erase 0 (mask2-empty)
        """
        expected_size = (4, 4)
        offset = (0, 0)
        expected_default = pygame.mask.Mask(expected_size)
        expected_masks = {(True, False): pygame.mask.Mask(expected_size, fill=True)}

        for fill2 in (True, False):
            mask2 = pygame.mask.Mask(expected_size, fill=fill2)
            mask2_count = mask2.count()

            for fill1 in (True, False):
                key = (fill1, fill2)
                msg = "key={}".format(key)
                mask1 = pygame.mask.Mask(expected_size, fill=fill1)
                expected_mask = expected_masks.get(key, expected_default)

                mask1.erase(mask2, offset)

                assertMaskEqual(self, mask1, expected_mask, msg)

                # Ensure mask2 unchanged.
                self.assertEqual(mask2.count(), mask2_count, msg)
                self.assertEqual(mask2.get_size(), expected_size, msg)

    def test_erase__offset(self):
        """Ensure an offset mask can erase another mask."""
        mask1 = pygame.mask.Mask((65, 3))
        mask2 = pygame.mask.Mask((66, 4), fill=True)
        mask2_count = mask2.count()
        mask2_size = mask2.get_size()
        expected_mask = pygame.Mask(mask1.get_size())

        # Using rects to help determine the overlapping area.
        rect1 = mask1.get_rect()
        rect2 = mask2.get_rect()

        for offset in self.ORIGIN_OFFSETS:
            msg = "offset={}".format(offset)
            rect2.topleft = offset
            overlap_rect = rect1.clip(rect2)
            expected_mask.fill()

            # Normally erase() could be used to clear these bits, but the
            # erase() method is being tested here, so a loop is used instead.
            for x in range(overlap_rect.left, overlap_rect.right):
                for y in range(overlap_rect.top, overlap_rect.bottom):
                    expected_mask.set_at((x, y), 0)
            mask1.fill()  # Ensure it's filled for testing each offset.

            mask1.erase(other=mask2, offset=offset)

            assertMaskEqual(self, mask1, expected_mask, msg)

            # Ensure mask2 unchanged.
            self.assertEqual(mask2.count(), mask2_count, msg)
            self.assertEqual(mask2.get_size(), mask2_size, msg)

    def test_erase__specific_offsets(self):
        """Ensure an offset mask can erase another mask.

        Testing the specific case of:
            -both masks are wider than 32 bits
            -a positive offset is used
            -the mask calling erase() is wider than the mask passed in
        """
        mask1 = pygame.mask.Mask((65, 5))
        mask2 = pygame.mask.Mask((33, 3), fill=True)
        expected_mask = pygame.Mask(mask1.get_size())

        # Using rects to help determine the overlapping area.
        rect1 = mask1.get_rect()
        rect2 = mask2.get_rect()

        # This rect's corners are used to move rect2 around the inside of
        # rect1.
        corner_rect = rect1.inflate(-2, -2)

        for corner in ("topleft", "topright", "bottomright", "bottomleft"):
            setattr(rect2, corner, getattr(corner_rect, corner))
            offset = rect2.topleft
            msg = "offset={}".format(offset)
            overlap_rect = rect1.clip(rect2)
            expected_mask.fill()

            # Normally erase() could be used to clear these bits, but the
            # erase() method is being tested here, so a loop is used instead.
            for x in range(overlap_rect.left, overlap_rect.right):
                for y in range(overlap_rect.top, overlap_rect.bottom):
                    expected_mask.set_at((x, y), 0)
            mask1.fill()  # Ensure it's filled for testing each offset.

            mask1.erase(mask2, Vector2(offset))

            assertMaskEqual(self, mask1, expected_mask, msg)

    def test_erase__offset_boundary(self):
        """Ensures erase handles offsets and boundaries correctly."""
        mask1 = pygame.mask.Mask((7, 11), fill=True)
        mask2 = pygame.mask.Mask((3, 13), fill=True)
        mask1_count = mask1.count()
        mask2_count = mask2.count()
        mask1_size = mask1.get_size()
        mask2_size = mask2.get_size()

        # Check the 4 boundaries.
        offsets = (
            (mask1_size[0], 0),  # off right
            (0, mask1_size[1]),  # off bottom
            (-mask2_size[0], 0),  # off left
            (0, -mask2_size[1]),
        )  # off top

        for offset in offsets:
            msg = "offset={}".format(offset)

            mask1.erase(mask2, offset)

            # Ensure mask1/mask2 unchanged.
            self.assertEqual(mask1.count(), mask1_count, msg)
            self.assertEqual(mask2.count(), mask2_count, msg)
            self.assertEqual(mask1.get_size(), mask1_size, msg)
            self.assertEqual(mask2.get_size(), mask2_size, msg)

    @unittest.skipIf(IS_PYPY, "Segfaults on pypy")
    def test_erase__bit_boundaries(self):
        """Ensures erase handles masks of different sizes correctly.

        Tests masks of different sizes, including:
           -masks 31 to 33 bits wide (32 bit boundaries)
           -masks 63 to 65 bits wide (64 bit boundaries)
        """
        for height in range(2, 4):
            for width in range(2, 66):
                mask_size = (width, height)
                mask_count = width * height
                mask1 = pygame.mask.Mask(mask_size)
                mask2 = pygame.mask.Mask(mask_size, fill=True)
                expected_mask = pygame.Mask(mask_size)

                # Using rects to help determine the overlapping area.
                rect1 = mask1.get_rect()
                rect2 = mask2.get_rect()

                # Testing masks offset from each other.
                for offset in self.ORIGIN_OFFSETS:
                    msg = "size={}, offset={}".format(mask_size, offset)
                    rect2.topleft = offset
                    overlap_rect = rect1.clip(rect2)
                    expected_mask.fill()

                    # Normally erase() could be used to clear these bits, but
                    # the erase() method is being tested here, so a loop is
                    # used instead.
                    for x in range(overlap_rect.left, overlap_rect.right):
                        for y in range(overlap_rect.top, overlap_rect.bottom):
                            expected_mask.set_at((x, y), 0)
                    mask1.fill()  # Ensure it's filled for each test.

                    mask1.erase(mask2, offset)

                    assertMaskEqual(self, mask1, expected_mask, msg)

                    # Ensure mask2 unchanged.
                    self.assertEqual(mask2.count(), mask_count, msg)
                    self.assertEqual(mask2.get_size(), mask_size, msg)

    def test_erase__invalid_mask_arg(self):
        """Ensure erase handles invalid mask arguments correctly."""
        size = (3, 7)
        offset = (0, 0)
        mask = pygame.mask.Mask(size)
        invalid_mask = pygame.Surface(size)

        with self.assertRaises(TypeError):
            mask.erase(invalid_mask, offset)

    def test_erase__invalid_offset_arg(self):
        """Ensure erase handles invalid offset arguments correctly."""
        size = (7, 5)
        offset = "(0, 0)"
        mask1 = pygame.mask.Mask(size)
        mask2 = pygame.mask.Mask(size)

        with self.assertRaises(TypeError):
            mask1.erase(mask2, offset)

    def test_count(self):
        """Ensure a mask's set bits are correctly counted."""
        side = 67
        expected_size = (side, side)
        expected_count = 0
        mask = pygame.mask.Mask(expected_size)

        for i in range(side):
            expected_count += 1
            mask.set_at((i, i))

        count = mask.count()

        self.assertEqual(count, expected_count)
        self.assertEqual(mask.get_size(), expected_size)

    @unittest.skipIf(IS_PYPY, "Segfaults on pypy")
    def test_count__bit_boundaries(self):
        """Ensures the set bits of different sized masks are counted correctly.

        Tests masks of different sizes, including:
           -masks 31 to 33 bits wide (32 bit boundaries)
           -masks 63 to 65 bits wide (64 bit boundaries)
        """
        for fill in (True, False):
            for height in range(1, 4):
                for width in range(1, 66):
                    mask = pygame.mask.Mask((width, height), fill=fill)
                    expected_count = width * height if fill else 0

                    # Test toggling each bit.
                    for pos in ((x, y) for y in range(height) for x in range(width)):
                        if fill:
                            mask.set_at(pos, 0)
                            expected_count -= 1
                        else:
                            mask.set_at(pos, 1)
                            expected_count += 1

                        count = mask.count()

                        self.assertEqual(
                            count,
                            expected_count,
                            "fill={}, size=({}, {}), pos={}".format(
                                fill, width, height, pos
                            ),
                        )

    def test_count__full_mask(self):
        """Ensure a full mask's set bits are correctly counted."""
        width, height = 17, 97
        expected_size = (width, height)
        expected_count = width * height
        mask = pygame.mask.Mask(expected_size, fill=True)

        count = mask.count()

        self.assertEqual(count, expected_count)
        self.assertEqual(mask.get_size(), expected_size)

    def test_count__empty_mask(self):
        """Ensure an empty mask's set bits are correctly counted."""
        expected_count = 0
        expected_size = (13, 27)
        mask = pygame.mask.Mask(expected_size)

        count = mask.count()

        self.assertEqual(count, expected_count)
        self.assertEqual(mask.get_size(), expected_size)

    def test_centroid(self):
        """Ensure a filled mask's centroid is correctly calculated."""
        mask = pygame.mask.Mask((5, 7), fill=True)
        expected_centroid = mask.get_rect().center

        centroid = mask.centroid()

        self.assertEqual(centroid, expected_centroid)

    def test_centroid__empty_mask(self):
        """Ensure an empty mask's centroid is correctly calculated."""
        expected_centroid = (0, 0)
        expected_size = (101, 103)
        mask = pygame.mask.Mask(expected_size)

        centroid = mask.centroid()

        self.assertEqual(centroid, expected_centroid)
        self.assertEqual(mask.get_size(), expected_size)

    def test_centroid__single_row(self):
        """Ensure a mask's centroid is correctly calculated
        when setting points along a single row."""
        width, height = (5, 7)
        mask = pygame.mask.Mask((width, height))

        for y in range(height):
            mask.clear()  # Clear for each row.

            for x in range(width):
                mask.set_at((x, y))
                expected_centroid = (x // 2, y)

                centroid = mask.centroid()

                self.assertEqual(centroid, expected_centroid)

    def test_centroid__two_rows(self):
        """Ensure a mask's centroid is correctly calculated
        when setting points along two rows."""
        width, height = (5, 7)
        mask = pygame.mask.Mask((width, height))

        # The first row is tested with each of the other rows.
        for y in range(1, height):
            mask.clear()  # Clear for each set of rows.

            for x in range(width):
                mask.set_at((x, 0))
                mask.set_at((x, y))
                expected_centroid = (x // 2, y // 2)

                centroid = mask.centroid()

                self.assertEqual(centroid, expected_centroid)

    def test_centroid__single_column(self):
        """Ensure a mask's centroid is correctly calculated
        when setting points along a single column."""
        width, height = (5, 7)
        mask = pygame.mask.Mask((width, height))

        for x in range(width):
            mask.clear()  # Clear for each column.

            for y in range(height):
                mask.set_at((x, y))
                expected_centroid = (x, y // 2)

                centroid = mask.centroid()

                self.assertEqual(centroid, expected_centroid)

    def test_centroid__two_columns(self):
        """Ensure a mask's centroid is correctly calculated
        when setting points along two columns."""
        width, height = (5, 7)
        mask = pygame.mask.Mask((width, height))

        # The first column is tested with each of the other columns.
        for x in range(1, width):
            mask.clear()  # Clear for each set of columns.

            for y in range(height):
                mask.set_at((0, y))
                mask.set_at((x, y))
                expected_centroid = (x // 2, y // 2)

                centroid = mask.centroid()

                self.assertEqual(centroid, expected_centroid)

    def test_centroid__all_corners(self):
        """Ensure a mask's centroid is correctly calculated
        when its corners are set."""
        mask = pygame.mask.Mask((5, 7))
        expected_centroid = mask.get_rect().center

        for corner in corners(mask):
            mask.set_at(corner)

        centroid = mask.centroid()

        self.assertEqual(centroid, expected_centroid)

    def test_centroid__two_corners(self):
        """Ensure a mask's centroid is correctly calculated
        when only two corners are set."""
        mask = pygame.mask.Mask((5, 7))
        mask_rect = mask.get_rect()
        mask_corners = corners(mask)

        for i, corner1 in enumerate(mask_corners):
            for corner2 in mask_corners[i + 1 :]:
                mask.clear()  # Clear for each pair of corners.
                mask.set_at(corner1)
                mask.set_at(corner2)

                if corner1[0] == corner2[0]:
                    expected_centroid = (corner1[0], abs(corner1[1] - corner2[1]) // 2)
                elif corner1[1] == corner2[1]:
                    expected_centroid = (abs(corner1[0] - corner2[0]) // 2, corner1[1])
                else:
                    expected_centroid = mask_rect.center

                centroid = mask.centroid()

                self.assertEqual(centroid, expected_centroid)

    def todo_test_angle(self):
        """Ensure a mask's orientation angle is correctly calculated."""
        self.fail()

    def test_angle__empty_mask(self):
        """Ensure an empty mask's angle is correctly calculated."""
        expected_angle = 0.0
        expected_size = (107, 43)
        mask = pygame.mask.Mask(expected_size)

        angle = mask.angle()

        self.assertIsInstance(angle, float)
        self.assertAlmostEqual(angle, expected_angle)
        self.assertEqual(mask.get_size(), expected_size)

    def test_drawing(self):
        """Test fill, clear, invert, draw, erase"""
        m = pygame.Mask((100, 100))
        self.assertEqual(m.count(), 0)

        m.fill()
        self.assertEqual(m.count(), 10000)

        m2 = pygame.Mask((10, 10), fill=True)
        m.erase(m2, (50, 50))
        self.assertEqual(m.count(), 9900)

        m.invert()
        self.assertEqual(m.count(), 100)

        m.draw(m2, (0, 0))
        self.assertEqual(m.count(), 200)

        m.clear()
        self.assertEqual(m.count(), 0)

    def test_outline(self):
        """ """

        m = pygame.Mask((20, 20))
        self.assertEqual(m.outline(), [])

        m.set_at((10, 10), 1)
        self.assertEqual(m.outline(), [(10, 10)])

        m.set_at((10, 12), 1)
        self.assertEqual(m.outline(10), [(10, 10)])

        m.set_at((11, 11), 1)
        self.assertEqual(
            m.outline(), [(10, 10), (11, 11), (10, 12), (11, 11), (10, 10)]
        )
        self.assertEqual(m.outline(every=2), [(10, 10), (10, 12), (10, 10)])

        # TODO: Test more corner case outlines.

    def test_convolve__size(self):
        sizes = [(1, 1), (31, 31), (32, 32), (100, 100)]
        for s1 in sizes:
            m1 = pygame.Mask(s1)
            for s2 in sizes:
                m2 = pygame.Mask(s2)
                o = m1.convolve(m2)

                self.assertIsInstance(o, pygame.mask.Mask)

                for i in (0, 1):
                    self.assertEqual(
                        o.get_size()[i], m1.get_size()[i] + m2.get_size()[i] - 1
                    )

    def test_convolve__point_identities(self):
        """Convolving with a single point is the identity, while convolving a point with something flips it."""
        m = random_mask((100, 100))
        k = pygame.Mask((1, 1))
        k.set_at((0, 0))

        convolve_mask = m.convolve(k)

        self.assertIsInstance(convolve_mask, pygame.mask.Mask)
        assertMaskEqual(self, m, convolve_mask)

        convolve_mask = k.convolve(k.convolve(m))

        self.assertIsInstance(convolve_mask, pygame.mask.Mask)
        assertMaskEqual(self, m, convolve_mask)

    def test_convolve__with_output(self):
        """checks that convolution modifies only the correct portion of the output"""

        m = random_mask((10, 10))
        k = pygame.Mask((2, 2))
        k.set_at((0, 0))

        o = pygame.Mask((50, 50))
        test = pygame.Mask((50, 50))

        m.convolve(k, o)
        test.draw(m, (1, 1))

        self.assertIsInstance(o, pygame.mask.Mask)
        assertMaskEqual(self, o, test)

        o.clear()
        test.clear()

        m.convolve(other=k, output=o, offset=Vector2(10, 10))
        test.draw(m, (11, 11))

        self.assertIsInstance(o, pygame.mask.Mask)
        assertMaskEqual(self, o, test)

    def test_convolve__out_of_range(self):
        full = pygame.Mask((2, 2), fill=True)
        # Tuple of points (out of range) and the expected count for each.
        pts_data = (((0, 3), 0), ((0, 2), 3), ((-2, -2), 1), ((-3, -3), 0))

        for pt, expected_count in pts_data:
            convolve_mask = full.convolve(full, None, pt)

            self.assertIsInstance(convolve_mask, pygame.mask.Mask)
            self.assertEqual(convolve_mask.count(), expected_count)

    @unittest.skipIf(IS_PYPY, "Segfaults on pypy")
    def test_convolve(self):
        """Tests the definition of convolution"""
        m1 = random_mask((100, 100))
        m2 = random_mask((100, 100))
        conv = m1.convolve(m2)

        self.assertIsInstance(conv, pygame.mask.Mask)
        for i in range(conv.get_size()[0]):
            for j in range(conv.get_size()[1]):
                self.assertEqual(
                    conv.get_at((i, j)) == 0, m1.overlap(m2, (i - 99, j - 99)) is None
                )

    def _draw_component_pattern_box(self, mask, size, pos, inverse=False):
        # Helper method to create/draw a 'box' pattern for testing.
        #
        # 111
        # 101  3x3 example pattern
        # 111
        pattern = pygame.mask.Mask((size, size), fill=True)
        pattern.set_at((size // 2, size // 2), 0)

        if inverse:
            mask.erase(pattern, pos)
            pattern.invert()
        else:
            mask.draw(pattern, pos)

        return pattern

    def _draw_component_pattern_x(self, mask, size, pos, inverse=False):
        # Helper method to create/draw an 'X' pattern for testing.
        #
        # 101
        # 010  3x3 example pattern
        # 101
        pattern = pygame.mask.Mask((size, size))

        ymax = size - 1
        for y in range(size):
            for x in range(size):
                if x in [y, ymax - y]:
                    pattern.set_at((x, y))

        if inverse:
            mask.erase(pattern, pos)
            pattern.invert()
        else:
            mask.draw(pattern, pos)

        return pattern

    def _draw_component_pattern_plus(self, mask, size, pos, inverse=False):
        # Helper method to create/draw a '+' pattern for testing.
        #
        # 010
        # 111  3x3 example pattern
        # 010
        pattern = pygame.mask.Mask((size, size))

        xmid = ymid = size // 2
        for y in range(size):
            for x in range(size):
                if x == xmid or y == ymid:
                    pattern.set_at((x, y))

        if inverse:
            mask.erase(pattern, pos)
            pattern.invert()
        else:
            mask.draw(pattern, pos)

        return pattern

    def test_connected_component(self):
        """Ensure a mask's connected component is correctly calculated."""
        width, height = 41, 27
        expected_size = (width, height)
        original_mask = pygame.mask.Mask(expected_size)
        patterns = []  # Patterns and offsets.

        # Draw some connected patterns on the original mask.
        offset = (0, 0)
        pattern = self._draw_component_pattern_x(original_mask, 3, offset)
        patterns.append((pattern, offset))

        size = 4
        offset = (width - size, 0)
        pattern = self._draw_component_pattern_plus(original_mask, size, offset)
        patterns.append((pattern, offset))

        # Make this one the largest connected component.
        offset = (width // 2, height // 2)
        pattern = self._draw_component_pattern_box(original_mask, 7, offset)
        patterns.append((pattern, offset))

        expected_pattern, expected_offset = patterns[-1]
        expected_count = expected_pattern.count()
        original_count = sum(p.count() for p, _ in patterns)

        mask = original_mask.connected_component()

        self.assertIsInstance(mask, pygame.mask.Mask)
        self.assertEqual(mask.count(), expected_count)
        self.assertEqual(mask.get_size(), expected_size)
        self.assertEqual(
            mask.overlap_area(expected_pattern, expected_offset), expected_count
        )

        # Ensure the original mask is unchanged.
        self.assertEqual(original_mask.count(), original_count)
        self.assertEqual(original_mask.get_size(), expected_size)

        for pattern, offset in patterns:
            self.assertEqual(
                original_mask.overlap_area(pattern, offset), pattern.count()
            )

    def test_connected_component__full_mask(self):
        """Ensure a mask's connected component is correctly calculated
        when the mask is full.
        """
        expected_size = (23, 31)
        original_mask = pygame.mask.Mask(expected_size, fill=True)
        expected_count = original_mask.count()

        mask = original_mask.connected_component()

        self.assertIsInstance(mask, pygame.mask.Mask)
        self.assertEqual(mask.count(), expected_count)
        self.assertEqual(mask.get_size(), expected_size)

        # Ensure the original mask is unchanged.
        self.assertEqual(original_mask.count(), expected_count)
        self.assertEqual(original_mask.get_size(), expected_size)

    def test_connected_component__empty_mask(self):
        """Ensure a mask's connected component is correctly calculated
        when the mask is empty.
        """
        expected_size = (37, 43)
        original_mask = pygame.mask.Mask(expected_size)
        original_count = original_mask.count()
        expected_count = 0

        mask = original_mask.connected_component()

        self.assertIsInstance(mask, pygame.mask.Mask)
        self.assertEqual(mask.count(), expected_count)
        self.assertEqual(mask.get_size(), expected_size)

        # Ensure the original mask is unchanged.
        self.assertEqual(original_mask.count(), original_count)
        self.assertEqual(original_mask.get_size(), expected_size)

    def test_connected_component__one_set_bit(self):
        """Ensure a mask's connected component is correctly calculated
        when the coordinate's bit is set with a connected component of 1 bit.
        """
        width, height = 71, 67
        expected_size = (width, height)
        original_mask = pygame.mask.Mask(expected_size, fill=True)
        xset, yset = width // 2, height // 2
        set_pos = (xset, yset)
        expected_offset = (xset - 1, yset - 1)

        # This isolates the bit at set_pos from all the other bits.
        expected_pattern = self._draw_component_pattern_box(
            original_mask, 3, expected_offset, inverse=True
        )
        expected_count = 1
        original_count = original_mask.count()

        mask = original_mask.connected_component(set_pos)

        self.assertIsInstance(mask, pygame.mask.Mask)
        self.assertEqual(mask.count(), expected_count)
        self.assertEqual(mask.get_size(), expected_size)
        self.assertEqual(
            mask.overlap_area(expected_pattern, expected_offset), expected_count
        )

        # Ensure the original mask is unchanged.
        self.assertEqual(original_mask.count(), original_count)
        self.assertEqual(original_mask.get_size(), expected_size)
        self.assertEqual(
            original_mask.overlap_area(expected_pattern, expected_offset),
            expected_count,
        )

    def test_connected_component__multi_set_bits(self):
        """Ensure a mask's connected component is correctly calculated
        when the coordinate's bit is set with a connected component of > 1 bit.
        """
        expected_size = (113, 67)
        original_mask = pygame.mask.Mask(expected_size)
        p_width, p_height = 11, 13
        set_pos = xset, yset = 11, 21
        expected_offset = (xset - 1, yset - 1)
        expected_pattern = pygame.mask.Mask((p_width, p_height), fill=True)

        # Make an unsymmetrical pattern. All the set bits need to be connected
        # in the resulting pattern for this to work properly.
        for y in range(3, p_height):
            for x in range(1, p_width):
                if x in [y, y - 3, p_width - 4]:
                    expected_pattern.set_at((x, y), 0)

        expected_count = expected_pattern.count()
        original_mask.draw(expected_pattern, expected_offset)

        mask = original_mask.connected_component(set_pos)

        self.assertIsInstance(mask, pygame.mask.Mask)
        self.assertEqual(mask.count(), expected_count)
        self.assertEqual(mask.get_size(), expected_size)
        self.assertEqual(
            mask.overlap_area(expected_pattern, expected_offset), expected_count
        )

        # Ensure the original mask is unchanged.
        self.assertEqual(original_mask.count(), expected_count)
        self.assertEqual(original_mask.get_size(), expected_size)
        self.assertEqual(
            original_mask.overlap_area(expected_pattern, expected_offset),
            expected_count,
        )

    def test_connected_component__unset_bit(self):
        """Ensure a mask's connected component is correctly calculated
        when the coordinate's bit is unset.
        """
        width, height = 109, 101
        expected_size = (width, height)
        original_mask = pygame.mask.Mask(expected_size, fill=True)
        unset_pos = (width // 2, height // 2)
        original_mask.set_at(unset_pos, 0)
        original_count = original_mask.count()
        expected_count = 0

        mask = original_mask.connected_component(unset_pos)

        self.assertIsInstance(mask, pygame.mask.Mask)
        self.assertEqual(mask.count(), expected_count)
        self.assertEqual(mask.get_size(), expected_size)

        # Ensure the original mask is unchanged.
        self.assertEqual(original_mask.count(), original_count)
        self.assertEqual(original_mask.get_size(), expected_size)
        self.assertEqual(original_mask.get_at(unset_pos), 0)

    def test_connected_component__out_of_bounds(self):
        """Ensure connected_component() checks bounds."""
        width, height = 19, 11
        original_size = (width, height)
        original_mask = pygame.mask.Mask(original_size, fill=True)
        original_count = original_mask.count()

        for pos in ((0, -1), (-1, 0), (0, height + 1), (width + 1, 0)):
            with self.assertRaises(IndexError):
                mask = original_mask.connected_component(pos)

            # Ensure the original mask is unchanged.
            self.assertEqual(original_mask.count(), original_count)
            self.assertEqual(original_mask.get_size(), original_size)

    def test_connected_components(self):
        """ """
        m = pygame.Mask((10, 10))

        self.assertListEqual(m.connected_components(), [])

        comp = m.connected_component()

        self.assertEqual(m.count(), comp.count())

        m.set_at((0, 0), 1)
        m.set_at((1, 1), 1)
        comp = m.connected_component()
        comps = m.connected_components()
        comps1 = m.connected_components(1)
        comps2 = m.connected_components(2)
        comps3 = m.connected_components(3)

        self.assertEqual(comp.count(), comps[0].count())
        self.assertEqual(comps1[0].count(), 2)
        self.assertEqual(comps2[0].count(), 2)
        self.assertListEqual(comps3, [])

        m.set_at((9, 9), 1)
        comp = m.connected_component()
        comp1 = m.connected_component((1, 1))
        comp2 = m.connected_component((2, 2))
        comps = m.connected_components()
        comps1 = m.connected_components(1)
        comps2 = m.connected_components(minimum=2)
        comps3 = m.connected_components(3)

        self.assertEqual(comp.count(), 2)
        self.assertEqual(comp1.count(), 2)
        self.assertEqual(comp2.count(), 0)
        self.assertEqual(len(comps), 2)
        self.assertEqual(len(comps1), 2)
        self.assertEqual(len(comps2), 1)
        self.assertEqual(len(comps3), 0)

        for mask in comps:
            self.assertIsInstance(mask, pygame.mask.Mask)

    def test_connected_components__negative_min_with_empty_mask(self):
        """Ensures connected_components() properly handles negative min values
        when the mask is empty.

        Negative and zero values for the min parameter (minimum number of bits
        per connected component) equate to setting it to one.
        """
        expected_comps = []
        mask_count = 0
        mask_size = (65, 13)
        mask = pygame.mask.Mask(mask_size)

        connected_comps = mask.connected_components(-1)

        self.assertListEqual(connected_comps, expected_comps)

        # Ensure the original mask is unchanged.
        self.assertEqual(mask.count(), mask_count)
        self.assertEqual(mask.get_size(), mask_size)

    def test_connected_components__negative_min_with_full_mask(self):
        """Ensures connected_components() properly handles negative min values
        when the mask is full.

        Negative and zero values for the min parameter (minimum number of bits
        per connected component) equate to setting it to one.
        """
        mask_size = (64, 11)
        mask = pygame.mask.Mask(mask_size, fill=True)
        mask_count = mask.count()
        expected_len = 1

        connected_comps = mask.connected_components(-2)

        self.assertEqual(len(connected_comps), expected_len)
        assertMaskEqual(self, connected_comps[0], mask)

        # Ensure the original mask is unchanged.
        self.assertEqual(mask.count(), mask_count)
        self.assertEqual(mask.get_size(), mask_size)

    def test_connected_components__negative_min_with_some_bits_set(self):
        """Ensures connected_components() properly handles negative min values
        when the mask has some bits set.

        Negative and zero values for the min parameter (minimum number of bits
        per connected component) equate to setting it to one.
        """
        mask_size = (64, 12)
        mask = pygame.mask.Mask(mask_size)
        expected_comps = {}

        # Set the corners and the center positions. A new expected component
        # mask is created for each point.
        for corner in corners(mask):
            mask.set_at(corner)

            new_mask = pygame.mask.Mask(mask_size)
            new_mask.set_at(corner)
            expected_comps[corner] = new_mask

        center = (mask_size[0] // 2, mask_size[1] // 2)
        mask.set_at(center)

        new_mask = pygame.mask.Mask(mask_size)
        new_mask.set_at(center)
        expected_comps[center] = new_mask
        mask_count = mask.count()

        connected_comps = mask.connected_components(-3)

        self.assertEqual(len(connected_comps), len(expected_comps))

        for comp in connected_comps:
            # Since the masks in the connected component list can be in any
            # order, loop the expected components to find its match.
            found = False

            for pt in tuple(expected_comps.keys()):
                if comp.get_at(pt):
                    found = True
                    assertMaskEqual(self, comp, expected_comps[pt])
                    del expected_comps[pt]  # Entry removed so it isn't reused.
                    break

            self.assertTrue(found, "missing component for pt={}".format(pt))

        # Ensure the original mask is unchanged.
        self.assertEqual(mask.count(), mask_count)
        self.assertEqual(mask.get_size(), mask_size)

    @unittest.skipIf(IS_PYPY, "Segfaults on pypy")
    def test_get_bounding_rects(self):
        """Ensures get_bounding_rects works correctly."""
        # Create masks with different set point groups. Each group of
        # connected set points will be contained in its own bounding rect.
        # Diagonal points are considered connected.
        mask_data = []  # [((size), ((rect1_pts), ...)), ...]

        # Mask 1:
        #  |0123456789
        # -+----------
        # 0|1100000000
        # 1|1000000000
        # 2|0000000000
        # 3|1001000000
        # 4|0000000000
        # 5|0000000000
        # 6|0000000000
        # 7|0000000000
        # 8|0000000000
        # 9|0000000000
        mask_data.append(
            (
                (10, 10),  # size
                # Points to set for the 3 bounding rects.
                (((0, 0), (1, 0), (0, 1)), ((0, 3),), ((3, 3),)),  # rect1  # rect2
            )
        )  # rect3

        # Mask 2:
        #  |0123
        # -+----
        # 0|1100
        # 1|1111
        mask_data.append(
            (
                (4, 2),  # size
                # Points to set for the 1 bounding rect.
                (((0, 0), (1, 0), (0, 1), (1, 1), (2, 1), (3, 1)),),
            )
        )

        # Mask 3:
        #  |01234
        # -+-----
        # 0|00100
        # 1|01110
        # 2|00100
        mask_data.append(
            (
                (5, 3),  # size
                # Points to set for the 1 bounding rect.
                (((2, 0), (1, 1), (2, 1), (3, 1), (2, 2)),),
            )
        )

        # Mask 4:
        #  |01234
        # -+-----
        # 0|00010
        # 1|00100
        # 2|01000
        mask_data.append(
            (
                (5, 3),  # size
                # Points to set for the 1 bounding rect.
                (((3, 0), (2, 1), (1, 2)),),
            )
        )

        # Mask 5:
        #  |01234
        # -+-----
        # 0|00011
        # 1|11111
        mask_data.append(
            (
                (5, 2),  # size
                # Points to set for the 1 bounding rect.
                (((3, 0), (4, 0), (0, 1), (1, 1), (2, 1), (3, 1)),),
            )
        )

        # Mask 6:
        #  |01234
        # -+-----
        # 0|10001
        # 1|00100
        # 2|10001
        mask_data.append(
            (
                (5, 3),  # size
                # Points to set for the 5 bounding rects.
                (
                    ((0, 0),),  # rect1
                    ((4, 0),),  # rect2
                    ((2, 1),),  # rect3
                    ((0, 2),),  # rect4
                    ((4, 2),),
                ),
            )
        )  # rect5

        for size, rect_point_tuples in mask_data:
            rects = []
            mask = pygame.Mask(size)

            for rect_points in rect_point_tuples:
                rects.append(create_bounding_rect(rect_points))
                for pt in rect_points:
                    mask.set_at(pt)

            expected_rects = sorted(rects, key=tuple)

            rects = mask.get_bounding_rects()

            self.assertListEqual(
                sorted(mask.get_bounding_rects(), key=tuple),
                expected_rects,
                "size={}".format(size),
            )

    @unittest.skipIf(IS_PYPY, "Segfaults on pypy")
    def test_to_surface(self):
        """Ensures empty and full masks can be drawn onto surfaces."""
        expected_ref_count = 3
        size = (33, 65)
        surface = pygame.Surface(size, SRCALPHA, 32)
        surface_color = pygame.Color("red")
        test_fills = ((pygame.Color("white"), True), (pygame.Color("black"), False))

        for expected_color, fill in test_fills:
            surface.fill(surface_color)
            mask = pygame.mask.Mask(size, fill=fill)

            to_surface = mask.to_surface(surface)

            self.assertIs(to_surface, surface)
            if not IS_PYPY:
                self.assertEqual(sys.getrefcount(to_surface), expected_ref_count)
            self.assertEqual(to_surface.get_size(), size)
            assertSurfaceFilled(self, to_surface, expected_color)

    def test_to_surface__create_surface(self):
        """Ensures empty and full masks can be drawn onto a created surface."""
        expected_ref_count = 2
        expected_flag = SRCALPHA
        expected_depth = 32
        size = (33, 65)
        test_fills = ((pygame.Color("white"), True), (pygame.Color("black"), False))

        for expected_color, fill in test_fills:
            mask = pygame.mask.Mask(size, fill=fill)

            for use_arg in (True, False):
                if use_arg:
                    to_surface = mask.to_surface(None)
                else:
                    to_surface = mask.to_surface()

                self.assertIsInstance(to_surface, pygame.Surface)
                if not IS_PYPY:
                    self.assertEqual(sys.getrefcount(to_surface), expected_ref_count)
                self.assertTrue(to_surface.get_flags() & expected_flag)
                self.assertEqual(to_surface.get_bitsize(), expected_depth)
                self.assertEqual(to_surface.get_size(), size)
                assertSurfaceFilled(self, to_surface, expected_color)

    def test_to_surface__surface_param(self):
        """Ensures to_surface accepts a surface arg/kwarg."""
        expected_ref_count = 4
        expected_color = pygame.Color("white")
        surface_color = pygame.Color("red")
        size = (5, 3)
        mask = pygame.mask.Mask(size, fill=True)
        surface = pygame.Surface(size)
        kwargs = {"surface": surface}

        for use_kwargs in (True, False):
            surface.fill(surface_color)

            if use_kwargs:
                to_surface = mask.to_surface(**kwargs)
            else:
                to_surface = mask.to_surface(kwargs["surface"])

            self.assertIs(to_surface, surface)
            if not IS_PYPY:
                self.assertEqual(sys.getrefcount(to_surface), expected_ref_count)
            self.assertEqual(to_surface.get_size(), size)
            assertSurfaceFilled(self, to_surface, expected_color)

    def test_to_surface__setsurface_param(self):
        """Ensures to_surface accepts a setsurface arg/kwarg."""
        expected_ref_count = 2
        expected_flag = SRCALPHA
        expected_depth = 32
        expected_color = pygame.Color("red")
        size = (5, 3)
        mask = pygame.mask.Mask(size, fill=True)
        setsurface = pygame.Surface(size, expected_flag, expected_depth)
        setsurface.fill(expected_color)
        kwargs = {"setsurface": setsurface}

        for use_kwargs in (True, False):
            if use_kwargs:
                to_surface = mask.to_surface(**kwargs)
            else:
                to_surface = mask.to_surface(None, kwargs["setsurface"])

            self.assertIsInstance(to_surface, pygame.Surface)

            if not IS_PYPY:
                self.assertEqual(sys.getrefcount(to_surface), expected_ref_count)
            self.assertTrue(to_surface.get_flags() & expected_flag)
            self.assertEqual(to_surface.get_bitsize(), expected_depth)
            self.assertEqual(to_surface.get_size(), size)
            assertSurfaceFilled(self, to_surface, expected_color)

    def test_to_surface__unsetsurface_param(self):
        """Ensures to_surface accepts a unsetsurface arg/kwarg."""
        expected_ref_count = 2
        expected_flag = SRCALPHA
        expected_depth = 32
        expected_color = pygame.Color("red")
        size = (5, 3)
        mask = pygame.mask.Mask(size)
        unsetsurface = pygame.Surface(size, expected_flag, expected_depth)
        unsetsurface.fill(expected_color)
        kwargs = {"unsetsurface": unsetsurface}

        for use_kwargs in (True, False):
            if use_kwargs:
                to_surface = mask.to_surface(**kwargs)
            else:
                to_surface = mask.to_surface(None, None, kwargs["unsetsurface"])

            self.assertIsInstance(to_surface, pygame.Surface)
            if not IS_PYPY:
                self.assertEqual(sys.getrefcount(to_surface), expected_ref_count)
            self.assertTrue(to_surface.get_flags() & expected_flag)
            self.assertEqual(to_surface.get_bitsize(), expected_depth)
            self.assertEqual(to_surface.get_size(), size)
            assertSurfaceFilled(self, to_surface, expected_color)

    def test_to_surface__setcolor_param(self):
        """Ensures to_surface accepts a setcolor arg/kwarg."""
        expected_ref_count = 2
        expected_flag = SRCALPHA
        expected_depth = 32
        expected_color = pygame.Color("red")
        size = (5, 3)
        mask = pygame.mask.Mask(size, fill=True)
        kwargs = {"setcolor": expected_color}

        for use_kwargs in (True, False):
            if use_kwargs:
                to_surface = mask.to_surface(**kwargs)
            else:
                to_surface = mask.to_surface(None, None, None, kwargs["setcolor"])

            self.assertIsInstance(to_surface, pygame.Surface)
            if not IS_PYPY:
                self.assertEqual(sys.getrefcount(to_surface), expected_ref_count)
            self.assertTrue(to_surface.get_flags() & expected_flag)
            self.assertEqual(to_surface.get_bitsize(), expected_depth)
            self.assertEqual(to_surface.get_size(), size)
            assertSurfaceFilled(self, to_surface, expected_color)

    def test_to_surface__setcolor_default(self):
        """Ensures the default setcolor is correct."""
        expected_color = pygame.Color("white")
        size = (3, 7)
        mask = pygame.mask.Mask(size, fill=True)

        to_surface = mask.to_surface(
            surface=None, setsurface=None, unsetsurface=None, unsetcolor=None
        )

        self.assertEqual(to_surface.get_size(), size)
        assertSurfaceFilled(self, to_surface, expected_color)

    def test_to_surface__unsetcolor_param(self):
        """Ensures to_surface accepts a unsetcolor arg/kwarg."""
        expected_ref_count = 2
        expected_flag = SRCALPHA
        expected_depth = 32
        expected_color = pygame.Color("red")
        size = (5, 3)
        mask = pygame.mask.Mask(size)
        kwargs = {"unsetcolor": expected_color}

        for use_kwargs in (True, False):
            if use_kwargs:
                to_surface = mask.to_surface(**kwargs)
            else:
                to_surface = mask.to_surface(
                    None, None, None, None, kwargs["unsetcolor"]
                )

            self.assertIsInstance(to_surface, pygame.Surface)
            if not IS_PYPY:
                self.assertEqual(sys.getrefcount(to_surface), expected_ref_count)
            self.assertTrue(to_surface.get_flags() & expected_flag)
            self.assertEqual(to_surface.get_bitsize(), expected_depth)
            self.assertEqual(to_surface.get_size(), size)
            assertSurfaceFilled(self, to_surface, expected_color)

    def test_to_surface__unsetcolor_default(self):
        """Ensures the default unsetcolor is correct."""
        expected_color = pygame.Color("black")
        size = (3, 7)
        mask = pygame.mask.Mask(size)

        to_surface = mask.to_surface(
            surface=None, setsurface=None, unsetsurface=None, setcolor=None
        )

        self.assertEqual(to_surface.get_size(), size)
        assertSurfaceFilled(self, to_surface, expected_color)

    def test_to_surface__dest_param(self):
        """Ensures to_surface accepts a dest arg/kwarg."""
        expected_ref_count = 2
        expected_flag = SRCALPHA
        expected_depth = 32
        default_surface_color = (0, 0, 0, 0)
        default_unsetcolor = pygame.Color("black")
        dest = (0, 0)
        size = (5, 3)
        mask = pygame.mask.Mask(size)
        kwargs = {"dest": dest}

        for use_kwargs in (True, False):
            if use_kwargs:
                expected_color = default_unsetcolor

                to_surface = mask.to_surface(**kwargs)
            else:
                expected_color = default_surface_color

                to_surface = mask.to_surface(
                    None, None, None, None, None, kwargs["dest"]
                )

            self.assertIsInstance(to_surface, pygame.Surface)
            if not IS_PYPY:
                self.assertEqual(sys.getrefcount(to_surface), expected_ref_count)
            self.assertTrue(to_surface.get_flags() & expected_flag)
            self.assertEqual(to_surface.get_bitsize(), expected_depth)
            self.assertEqual(to_surface.get_size(), size)
            assertSurfaceFilled(self, to_surface, expected_color)

    def test_to_surface__dest_default(self):
        """Ensures the default dest is correct."""
        expected_color = pygame.Color("white")
        surface_color = pygame.Color("red")

        mask_size = (3, 2)
        mask = pygame.mask.Mask(mask_size, fill=True)
        mask_rect = mask.get_rect()

        # Make the surface bigger than the mask.
        surf_size = (mask_size[0] + 2, mask_size[1] + 1)
        surface = pygame.Surface(surf_size, SRCALPHA, 32)
        surface.fill(surface_color)

        to_surface = mask.to_surface(
            surface, setsurface=None, unsetsurface=None, unsetcolor=None
        )

        self.assertIs(to_surface, surface)
        self.assertEqual(to_surface.get_size(), surf_size)
        assertSurfaceFilled(self, to_surface, expected_color, mask_rect)
        assertSurfaceFilledIgnoreArea(self, to_surface, surface_color, mask_rect)

    @unittest.expectedFailure
    def test_to_surface__area_param(self):
        """Ensures to_surface accepts an area arg/kwarg."""
        expected_ref_count = 2
        expected_flag = SRCALPHA
        expected_depth = 32
        default_surface_color = (0, 0, 0, 0)
        default_unsetcolor = pygame.Color("black")
        size = (5, 3)
        mask = pygame.mask.Mask(size)
        kwargs = {"area": mask.get_rect()}

        for use_kwargs in (True, False):
            if use_kwargs:
                expected_color = default_unsetcolor

                to_surface = mask.to_surface(**kwargs)
            else:
                expected_color = default_surface_color

                to_surface = mask.to_surface(
                    None, None, None, None, None, (0, 0), kwargs["area"]
                )

            self.assertIsInstance(to_surface, pygame.Surface)
            if not IS_PYPY:
                self.assertEqual(sys.getrefcount(to_surface), expected_ref_count)
            self.assertTrue(to_surface.get_flags() & expected_flag)
            self.assertEqual(to_surface.get_bitsize(), expected_depth)
            self.assertEqual(to_surface.get_size(), size)
            assertSurfaceFilled(self, to_surface, expected_color)

    def test_to_surface__area_default(self):
        """Ensures the default area is correct."""
        expected_color = pygame.Color("white")
        surface_color = pygame.Color("red")

        mask_size = (3, 2)
        mask = pygame.mask.Mask(mask_size, fill=True)
        mask_rect = mask.get_rect()

        # Make the surface bigger than the mask. The default area is the full
        # area of the mask.
        surf_size = (mask_size[0] + 2, mask_size[1] + 1)
        surface = pygame.Surface(surf_size, SRCALPHA, 32)
        surface.fill(surface_color)

        to_surface = mask.to_surface(
            surface, setsurface=None, unsetsurface=None, unsetcolor=None
        )

        self.assertIs(to_surface, surface)
        self.assertEqual(to_surface.get_size(), surf_size)
        assertSurfaceFilled(self, to_surface, expected_color, mask_rect)
        assertSurfaceFilledIgnoreArea(self, to_surface, surface_color, mask_rect)

    def test_to_surface__kwargs(self):
        """Ensures to_surface accepts the correct kwargs."""
        expected_color = pygame.Color("white")
        size = (5, 3)
        mask = pygame.mask.Mask(size, fill=True)
        surface = pygame.Surface(size)
        surface_color = pygame.Color("red")
        setsurface = surface.copy()
        setsurface.fill(expected_color)

        test_data = (
            (None, None),  # None entry allows loop to test all kwargs on first pass.
            ("dest", (0, 0)),
            ("unsetcolor", pygame.Color("yellow")),
            ("setcolor", expected_color),
            ("unsetsurface", surface.copy()),
            ("setsurface", setsurface),
            ("surface", surface),
        )

        kwargs = dict(test_data)

        for name, _ in test_data:
            kwargs.pop(name)
            surface.fill(surface_color)  # Clear for each test.

            to_surface = mask.to_surface(**kwargs)

            self.assertEqual(to_surface.get_size(), size)
            assertSurfaceFilled(self, to_surface, expected_color)

    def test_to_surface__kwargs_create_surface(self):
        """Ensures to_surface accepts the correct kwargs
        when creating a surface.
        """
        expected_color = pygame.Color("black")
        size = (5, 3)
        mask = pygame.mask.Mask(size)
        setsurface = pygame.Surface(size, SRCALPHA, 32)
        setsurface_color = pygame.Color("red")
        setsurface.fill(setsurface_color)
        unsetsurface = setsurface.copy()
        unsetsurface.fill(expected_color)

        test_data = (
            (None, None),  # None entry allows loop to test all kwargs on first pass.
            ("dest", (0, 0)),
            ("unsetcolor", expected_color),
            ("setcolor", pygame.Color("yellow")),
            ("unsetsurface", unsetsurface),
            ("setsurface", setsurface),
            ("surface", None),
        )
        kwargs = dict(test_data)

        for name, _ in test_data:
            kwargs.pop(name)

            to_surface = mask.to_surface(**kwargs)

            self.assertIsInstance(to_surface, pygame.Surface)
            self.assertEqual(to_surface.get_size(), size)
            assertSurfaceFilled(self, to_surface, expected_color)

    def test_to_surface__kwargs_order_independent(self):
        """Ensures to_surface kwargs are not order dependent."""
        expected_color = pygame.Color("blue")
        size = (3, 2)
        mask = pygame.mask.Mask(size, fill=True)
        surface = pygame.Surface(size)

        to_surface = mask.to_surface(
            dest=(0, 0),
            setcolor=expected_color,
            unsetcolor=None,
            surface=surface,
            unsetsurface=pygame.Surface(size),
            setsurface=None,
        )

        self.assertIs(to_surface, surface)
        self.assertEqual(to_surface.get_size(), size)
        assertSurfaceFilled(self, to_surface, expected_color)

    def test_to_surface__args_invalid_types(self):
        """Ensures to_surface detects invalid kwarg types."""
        size = (3, 2)
        mask = pygame.mask.Mask(size, fill=True)
        invalid_surf = pygame.Color("green")
        invalid_color = pygame.Surface(size)

        with self.assertRaises(TypeError):
            # Invalid dest.
            mask.to_surface(None, None, None, None, None, (0,))

        with self.assertRaises(TypeError):
            # Invalid unsetcolor.
            mask.to_surface(None, None, None, None, invalid_color)

        with self.assertRaises(TypeError):
            # Invalid setcolor.
            mask.to_surface(None, None, None, invalid_color, None)

        with self.assertRaises(TypeError):
            # Invalid unsetsurface.
            mask.to_surface(None, None, invalid_surf, None, None)

        with self.assertRaises(TypeError):
            # Invalid setsurface.
            mask.to_surface(None, invalid_surf, None, None, None)

        with self.assertRaises(TypeError):
            # Invalid surface.
            mask.to_surface(invalid_surf, None, None, None, None)

    def test_to_surface__kwargs_invalid_types(self):
        """Ensures to_surface detects invalid kwarg types."""
        size = (3, 2)
        mask = pygame.mask.Mask(size)

        valid_kwargs = {
            "surface": pygame.Surface(size),
            "setsurface": pygame.Surface(size),
            "unsetsurface": pygame.Surface(size),
            "setcolor": pygame.Color("green"),
            "unsetcolor": pygame.Color("green"),
            "dest": (0, 0),
        }

        invalid_kwargs = {
            "surface": (1, 2, 3, 4),
            "setsurface": pygame.Color("green"),
            "unsetsurface": ((1, 2), (2, 1)),
            "setcolor": pygame.Mask((1, 2)),
            "unsetcolor": pygame.Surface((2, 2)),
            "dest": (0, 0, 0),
        }

        kwarg_order = (
            "surface",
            "setsurface",
            "unsetsurface",
            "setcolor",
            "unsetcolor",
            "dest",
        )

        for kwarg in kwarg_order:
            kwargs = dict(valid_kwargs)
            kwargs[kwarg] = invalid_kwargs[kwarg]

            with self.assertRaises(TypeError):
                mask.to_surface(**kwargs)

    def test_to_surface__kwargs_invalid_name(self):
        """Ensures to_surface detects invalid kwarg names."""
        mask = pygame.mask.Mask((3, 2))
        kwargs = {"setcolour": pygame.Color("red")}

        with self.assertRaises(TypeError):
            mask.to_surface(**kwargs)

    def test_to_surface__args_and_kwargs(self):
        """Ensures to_surface accepts a combination of args/kwargs"""
        size = (5, 3)

        surface_color = pygame.Color("red")
        setsurface_color = pygame.Color("yellow")
        unsetsurface_color = pygame.Color("blue")
        setcolor = pygame.Color("green")
        unsetcolor = pygame.Color("cyan")

        surface = pygame.Surface(size, SRCALPHA, 32)
        setsurface = surface.copy()
        unsetsurface = surface.copy()

        setsurface.fill(setsurface_color)
        unsetsurface.fill(unsetsurface_color)

        mask = pygame.mask.Mask(size, fill=True)
        expected_color = setsurface_color

        test_data = (
            (None, None),  # None entry allows loop to test all kwargs on first pass.
            ("surface", surface),
            ("setsurface", setsurface),
            ("unsetsurface", unsetsurface),
            ("setcolor", setcolor),
            ("unsetcolor", unsetcolor),
            ("dest", (0, 0)),
        )

        args = []
        kwargs = dict(test_data)

        # Loop gradually moves the kwargs to args.
        for name, value in test_data:
            if name is not None:
                args.append(value)
            kwargs.pop(name)

            surface.fill(surface_color)

            to_surface = mask.to_surface(*args, **kwargs)

            assertSurfaceFilled(self, to_surface, expected_color)

    def test_to_surface__valid_setcolor_formats(self):
        """Ensures to_surface handles valid setcolor formats correctly."""
        size = (5, 3)
        mask = pygame.mask.Mask(size, fill=True)
        surface = pygame.Surface(size, SRCALPHA, 32)
        expected_color = pygame.Color("green")
        test_colors = (
            (0, 255, 0),
            (0, 255, 0, 255),
            surface.map_rgb(expected_color),
            expected_color,
            "green",
            "#00FF00FF",
            "0x00FF00FF",
        )

        for setcolor in test_colors:
            to_surface = mask.to_surface(setcolor=setcolor)

            assertSurfaceFilled(self, to_surface, expected_color)

    def test_to_surface__valid_unsetcolor_formats(self):
        """Ensures to_surface handles valid unsetcolor formats correctly."""
        size = (5, 3)
        mask = pygame.mask.Mask(size)
        surface = pygame.Surface(size, SRCALPHA, 32)
        expected_color = pygame.Color("green")
        test_colors = (
            (0, 255, 0),
            (0, 255, 0, 255),
            surface.map_rgb(expected_color),
            expected_color,
            "green",
            "#00FF00FF",
            "0x00FF00FF",
        )

        for unsetcolor in test_colors:
            to_surface = mask.to_surface(unsetcolor=unsetcolor)

            assertSurfaceFilled(self, to_surface, expected_color)

    def test_to_surface__invalid_setcolor_formats(self):
        """Ensures to_surface handles invalid setcolor formats correctly."""
        mask = pygame.mask.Mask((5, 3))

        for setcolor in ("green color", "#00FF00FF0", "0x00FF00FF0", (1, 2)):
            with self.assertRaises(ValueError):
                mask.to_surface(setcolor=setcolor)

        for setcolor in (pygame.Surface((1, 2)), pygame.Mask((2, 1)), 1.1):
            with self.assertRaises(TypeError):
                mask.to_surface(setcolor=setcolor)

    def test_to_surface__invalid_unsetcolor_formats(self):
        """Ensures to_surface handles invalid unsetcolor formats correctly."""
        mask = pygame.mask.Mask((5, 3))

        for unsetcolor in ("green color", "#00FF00FF0", "0x00FF00FF0", (1, 2)):
            with self.assertRaises(ValueError):
                mask.to_surface(unsetcolor=unsetcolor)

        for unsetcolor in (pygame.Surface((1, 2)), pygame.Mask((2, 1)), 1.1):
            with self.assertRaises(TypeError):
                mask.to_surface(unsetcolor=unsetcolor)

    def test_to_surface__valid_dest_formats(self):
        """Ensures to_surface handles valid dest formats correctly."""
        expected_color = pygame.Color("white")
        mask = pygame.mask.Mask((3, 5), fill=True)
        dests = (
            (0, 0),
            [0, 0],
            Vector2(0, 0),
            (0, 0, 100, 100),
            pygame.Rect((0, 0), (10, 10)),
        )

        for dest in dests:
            to_surface = mask.to_surface(dest=dest)

            assertSurfaceFilled(self, to_surface, expected_color)

    def test_to_surface__invalid_dest_formats(self):
        """Ensures to_surface handles invalid dest formats correctly."""
        mask = pygame.mask.Mask((3, 5))
        invalid_dests = (
            (0,),  # Incorrect size.
            (0, 0, 0),  # Incorrect size.
            set([0, 1]),  # Incorrect type.
            {0: 1},  # Incorrect type.
            Rect,
        )  # Incorrect type.

        for dest in invalid_dests:
            with self.assertRaises(TypeError):
                mask.to_surface(dest=dest)

    def test_to_surface__negative_sized_dest_rect(self):
        """Ensures to_surface correctly handles negative sized dest rects."""
        expected_color = pygame.Color("white")
        mask = pygame.mask.Mask((3, 5), fill=True)
        dests = (
            pygame.Rect((0, 0), (10, -10)),
            pygame.Rect((0, 0), (-10, 10)),
            pygame.Rect((0, 0), (-10, -10)),
        )

        for dest in dests:
            to_surface = mask.to_surface(dest=dest)

            assertSurfaceFilled(self, to_surface, expected_color)

    def test_to_surface__zero_sized_dest_rect(self):
        """Ensures to_surface correctly handles zero sized dest rects."""
        expected_color = pygame.Color("white")
        mask = pygame.mask.Mask((3, 5), fill=True)
        dests = (
            pygame.Rect((0, 0), (0, 10)),
            pygame.Rect((0, 0), (10, 0)),
            pygame.Rect((0, 0), (0, 0)),
        )

        for dest in dests:
            to_surface = mask.to_surface(dest=dest)

            assertSurfaceFilled(self, to_surface, expected_color)

    @unittest.expectedFailure
    def test_to_surface__valid_area_formats(self):
        """Ensures to_surface handles valid area formats correctly."""
        size = (3, 5)
        surface_color = pygame.Color("red")
        expected_color = pygame.Color("white")
        surface = pygame.Surface(size)
        mask = pygame.mask.Mask(size, fill=True)
        area_pos = (0, 0)
        area_size = (2, 1)
        areas = (
            (area_pos[0], area_pos[1], area_size[0], area_size[1]),
            (area_pos, area_size),
            (area_pos, list(area_size)),
            (list(area_pos), area_size),
            (list(area_pos), list(area_size)),
            [area_pos[0], area_pos[1], area_size[0], area_size[1]],
            [area_pos, area_size],
            [area_pos, list(area_size)],
            [list(area_pos), area_size],
            [list(area_pos), list(area_size)],
            pygame.Rect(area_pos, area_size),
        )

        for area in areas:
            surface.fill(surface_color)
            area_rect = pygame.Rect(area)

            to_surface = mask.to_surface(surface, area=area)

            assertSurfaceFilled(self, to_surface, expected_color, area_rect)
            assertSurfaceFilledIgnoreArea(self, to_surface, surface_color, area_rect)

    @unittest.expectedFailure
    def test_to_surface__invalid_area_formats(self):
        """Ensures to_surface handles invalid area formats correctly."""
        mask = pygame.mask.Mask((3, 5))
        invalid_areas = (
            (0,),  # Incorrect size.
            (0, 0),  # Incorrect size.
            (0, 0, 1),  # Incorrect size.
            ((0, 0), (1,)),  # Incorrect size.
            ((0,), (1, 1)),  # Incorrect size.
            set([0, 1, 2, 3]),  # Incorrect type.
            {0: 1, 2: 3},  # Incorrect type.
            Rect,  # Incorrect type.
        )

        for area in invalid_areas:
            with self.assertRaisesRegex(TypeError, "invalid area argument"):
                unused_to_surface = mask.to_surface(area=area)

    @unittest.expectedFailure
    def test_to_surface__negative_sized_area_rect(self):
        """Ensures to_surface correctly handles negative sized area rects."""
        size = (3, 5)
        surface_color = pygame.Color("red")
        expected_color = pygame.Color("white")
        surface = pygame.Surface(size)
        mask = pygame.mask.Mask(size)
        mask.set_at((0, 0))

        # These rects should cause position (0, 0) of the mask to be drawn.
        areas = (
            pygame.Rect((0, 1), (1, -1)),
            pygame.Rect((1, 0), (-1, 1)),
            pygame.Rect((1, 1), (-1, -1)),
        )

        for area in areas:
            surface.fill(surface_color)

            to_surface = mask.to_surface(surface, area=area)

            assertSurfaceFilled(self, to_surface, expected_color, area)
            assertSurfaceFilledIgnoreArea(self, to_surface, surface_color, area)

    @unittest.expectedFailure
    def test_to_surface__zero_sized_area_rect(self):
        """Ensures to_surface correctly handles zero sized area rects."""
        size = (3, 5)
        expected_color = pygame.Color("red")
        surface = pygame.Surface(size)
        mask = pygame.mask.Mask(size, fill=True)

        # Zero sized rect areas should cause none of the mask to be drawn.
        areas = (
            pygame.Rect((0, 0), (0, 1)),
            pygame.Rect((0, 0), (1, 0)),
            pygame.Rect((0, 0), (0, 0)),
        )

        for area in areas:
            surface.fill(expected_color)

            to_surface = mask.to_surface(surface, area=area)

            assertSurfaceFilled(self, to_surface, expected_color)

    def test_to_surface__default_surface_with_param_combinations(self):
        """Ensures to_surface works with a default surface value
        and combinations of other parameters.

        This tests many different parameter combinations with full and empty
        masks.
        """
        expected_ref_count = 2
        expected_flag = SRCALPHA
        expected_depth = 32
        size = (5, 3)
        dest = (0, 0)

        default_surface_color = (0, 0, 0, 0)
        setsurface_color = pygame.Color("yellow")
        unsetsurface_color = pygame.Color("blue")
        setcolor = pygame.Color("green")
        unsetcolor = pygame.Color("cyan")

        setsurface = pygame.Surface(size, expected_flag, expected_depth)
        unsetsurface = setsurface.copy()

        setsurface.fill(setsurface_color)
        unsetsurface.fill(unsetsurface_color)

        kwargs = {
            "setsurface": None,
            "unsetsurface": None,
            "setcolor": None,
            "unsetcolor": None,
            "dest": None,
        }

        for fill in (True, False):
            mask = pygame.mask.Mask(size, fill=fill)

            # Test different combinations of parameters.
            for setsurface_param in (setsurface, None):
                kwargs["setsurface"] = setsurface_param

                for unsetsurface_param in (unsetsurface, None):
                    kwargs["unsetsurface"] = unsetsurface_param

                    for setcolor_param in (setcolor, None):
                        kwargs["setcolor"] = setcolor_param

                        for unsetcolor_param in (unsetcolor, None):
                            kwargs["unsetcolor"] = unsetcolor_param

                            for dest_param in (dest, None):
                                if dest_param is None:
                                    kwargs.pop("dest", None)
                                else:
                                    kwargs["dest"] = dest_param

                                if fill:
                                    if setsurface_param is not None:
                                        expected_color = setsurface_color
                                    elif setcolor_param is not None:
                                        expected_color = setcolor
                                    else:
                                        expected_color = default_surface_color
                                else:
                                    if unsetsurface_param is not None:
                                        expected_color = unsetsurface_color
                                    elif unsetcolor_param is not None:
                                        expected_color = unsetcolor
                                    else:
                                        expected_color = default_surface_color

                                to_surface = mask.to_surface(**kwargs)

                                self.assertIsInstance(to_surface, pygame.Surface)
                                if not IS_PYPY:
                                    self.assertEqual(
                                        sys.getrefcount(to_surface), expected_ref_count
                                    )
                                self.assertTrue(to_surface.get_flags() & expected_flag)
                                self.assertEqual(
                                    to_surface.get_bitsize(), expected_depth
                                )
                                self.assertEqual(to_surface.get_size(), size)
                                assertSurfaceFilled(self, to_surface, expected_color)

    def test_to_surface__surface_with_param_combinations(self):
        """Ensures to_surface works with a surface value
        and combinations of other parameters.

        This tests many different parameter combinations with full and empty
        masks.
        """
        expected_ref_count = 4
        expected_flag = SRCALPHA
        expected_depth = 32
        size = (5, 3)
        dest = (0, 0)

        surface_color = pygame.Color("red")
        setsurface_color = pygame.Color("yellow")
        unsetsurface_color = pygame.Color("blue")
        setcolor = pygame.Color("green")
        unsetcolor = pygame.Color("cyan")

        surface = pygame.Surface(size, expected_flag, expected_depth)
        setsurface = surface.copy()
        unsetsurface = surface.copy()

        setsurface.fill(setsurface_color)
        unsetsurface.fill(unsetsurface_color)

        kwargs = {
            "surface": surface,
            "setsurface": None,
            "unsetsurface": None,
            "setcolor": None,
            "unsetcolor": None,
            "dest": None,
        }

        for fill in (True, False):
            mask = pygame.mask.Mask(size, fill=fill)

            # Test different combinations of parameters.
            for setsurface_param in (setsurface, None):
                kwargs["setsurface"] = setsurface_param

                for unsetsurface_param in (unsetsurface, None):
                    kwargs["unsetsurface"] = unsetsurface_param

                    for setcolor_param in (setcolor, None):
                        kwargs["setcolor"] = setcolor_param

                        for unsetcolor_param in (unsetcolor, None):
                            kwargs["unsetcolor"] = unsetcolor_param
                            surface.fill(surface_color)  # Clear for each test.

                            for dest_param in (dest, None):
                                if dest_param is None:
                                    kwargs.pop("dest", None)
                                else:
                                    kwargs["dest"] = dest_param

                                if fill:
                                    if setsurface_param is not None:
                                        expected_color = setsurface_color
                                    elif setcolor_param is not None:
                                        expected_color = setcolor
                                    else:
                                        expected_color = surface_color
                                else:
                                    if unsetsurface_param is not None:
                                        expected_color = unsetsurface_color
                                    elif unsetcolor_param is not None:
                                        expected_color = unsetcolor
                                    else:
                                        expected_color = surface_color

                                to_surface = mask.to_surface(**kwargs)

                                self.assertIs(to_surface, surface)
                                if not IS_PYPY:
                                    self.assertEqual(
                                        sys.getrefcount(to_surface), expected_ref_count
                                    )
                                self.assertTrue(to_surface.get_flags() & expected_flag)
                                self.assertEqual(
                                    to_surface.get_bitsize(), expected_depth
                                )
                                self.assertEqual(to_surface.get_size(), size)
                                assertSurfaceFilled(self, to_surface, expected_color)

    def test_to_surface__set_and_unset_bits(self):
        """Ensures that to_surface works correctly with with set/unset bits
        when using the defaults for setcolor and unsetcolor.
        """
        default_setcolor = pygame.Color("white")
        default_unsetcolor = pygame.Color("black")
        width, height = size = (10, 20)
        mask = pygame.mask.Mask(size)
        mask_rect = mask.get_rect()

        surface = pygame.Surface(size)
        surface_color = pygame.Color("red")

        # Create a checkerboard pattern of set/unset bits.
        for pos in ((x, y) for x in range(width) for y in range(x & 1, height, 2)):
            mask.set_at(pos)

        # Test different dest values.
        for dest in self.ORIGIN_OFFSETS:
            mask_rect.topleft = dest
            surface.fill(surface_color)

            to_surface = mask.to_surface(surface, dest=dest)

            to_surface.lock()  # Lock for possible speed up.
            for pos in ((x, y) for x in range(width) for y in range(height)):
                mask_pos = (pos[0] - dest[0], pos[1] - dest[1])
                if not mask_rect.collidepoint(pos):
                    expected_color = surface_color
                elif mask.get_at(mask_pos):
                    expected_color = default_setcolor
                else:
                    expected_color = default_unsetcolor

                self.assertEqual(to_surface.get_at(pos), expected_color, (dest, pos))
            to_surface.unlock()

    def test_to_surface__set_and_unset_bits_with_setsurface_unsetsurface(self):
        """Ensures that to_surface works correctly with with set/unset bits
        when using setsurface and unsetsurface.
        """
        width, height = size = (10, 20)
        mask = pygame.mask.Mask(size)
        mask_rect = mask.get_rect()

        surface = pygame.Surface(size)
        surface_color = pygame.Color("red")

        setsurface = surface.copy()
        setsurface_color = pygame.Color("green")
        setsurface.fill(setsurface_color)

        unsetsurface = surface.copy()
        unsetsurface_color = pygame.Color("blue")
        unsetsurface.fill(unsetsurface_color)

        # Create a checkerboard pattern of set/unset bits.
        for pos in ((x, y) for x in range(width) for y in range(x & 1, height, 2)):
            mask.set_at(pos)

        # Test different dest values.
        for dest in self.ORIGIN_OFFSETS:
            mask_rect.topleft = dest

            # Tests the color parameters set to None and also as their
            # default values. Should have no effect as they are not being
            # used, but this exercises different to_surface() code.
            for disable_color_params in (True, False):
                surface.fill(surface_color)  # Clear for each test.

                if disable_color_params:
                    to_surface = mask.to_surface(
                        surface,
                        dest=dest,
                        setsurface=setsurface,
                        unsetsurface=unsetsurface,
                        setcolor=None,
                        unsetcolor=None,
                    )
                else:
                    to_surface = mask.to_surface(
                        surface,
                        dest=dest,
                        setsurface=setsurface,
                        unsetsurface=unsetsurface,
                    )

                to_surface.lock()  # Lock for possible speed up.

                for pos in ((x, y) for x in range(width) for y in range(height)):
                    mask_pos = (pos[0] - dest[0], pos[1] - dest[1])

                    if not mask_rect.collidepoint(pos):
                        expected_color = surface_color
                    elif mask.get_at(mask_pos):
                        expected_color = setsurface_color
                    else:
                        expected_color = unsetsurface_color

                    self.assertEqual(to_surface.get_at(pos), expected_color)
                to_surface.unlock()

    def test_to_surface__surface_narrower_than_mask(self):
        """Ensures that surfaces narrower than the mask work correctly.

        For this test the surface's width is less than the mask's width.
        """
        default_setcolor = pygame.Color("white")
        default_unsetcolor = pygame.Color("black")
        mask_size = (10, 20)
        narrow_size = (6, 20)

        surface = pygame.Surface(narrow_size)
        surface_color = pygame.Color("red")

        for fill in (True, False):
            mask = pygame.mask.Mask(mask_size, fill=fill)
            surface.fill(surface_color)  # Clear for each test.
            expected_color = default_setcolor if fill else default_unsetcolor

            to_surface = mask.to_surface(surface)

            self.assertIs(to_surface, surface)
            self.assertEqual(to_surface.get_size(), narrow_size)
            assertSurfaceFilled(self, to_surface, expected_color)

    def test_to_surface__setsurface_narrower_than_mask(self):
        """Ensures that setsurfaces narrower than the mask work correctly.

        For this test the setsurface's width is less than the mask's width.
        """
        default_setcolor = pygame.Color("white")
        default_unsetcolor = pygame.Color("black")
        mask_size = (10, 20)
        narrow_size = (6, 20)

        setsurface = pygame.Surface(narrow_size, SRCALPHA, 32)
        setsurface_color = pygame.Color("red")
        setsurface.fill(setsurface_color)
        setsurface_rect = setsurface.get_rect()

        for fill in (True, False):
            mask = pygame.mask.Mask(mask_size, fill=fill)

            to_surface = mask.to_surface(setsurface=setsurface)

            self.assertIsInstance(to_surface, pygame.Surface)
            self.assertEqual(to_surface.get_size(), mask_size)

            # Different checks depending on if the mask was filled or not.
            if fill:
                assertSurfaceFilled(self, to_surface, setsurface_color, setsurface_rect)
                assertSurfaceFilledIgnoreArea(
                    self, to_surface, default_setcolor, setsurface_rect
                )
            else:
                assertSurfaceFilled(self, to_surface, default_unsetcolor)

    def test_to_surface__unsetsurface_narrower_than_mask(self):
        """Ensures that unsetsurfaces narrower than the mask work correctly.

        For this test the unsetsurface's width is less than the mask's width.
        """
        default_setcolor = pygame.Color("white")
        default_unsetcolor = pygame.Color("black")
        mask_size = (10, 20)
        narrow_size = (6, 20)

        unsetsurface = pygame.Surface(narrow_size, SRCALPHA, 32)
        unsetsurface_color = pygame.Color("red")
        unsetsurface.fill(unsetsurface_color)
        unsetsurface_rect = unsetsurface.get_rect()

        for fill in (True, False):
            mask = pygame.mask.Mask(mask_size, fill=fill)

            to_surface = mask.to_surface(unsetsurface=unsetsurface)

            self.assertIsInstance(to_surface, pygame.Surface)
            self.assertEqual(to_surface.get_size(), mask_size)

            # Different checks depending on if the mask was filled or not.
            if fill:
                assertSurfaceFilled(self, to_surface, default_setcolor)
            else:
                assertSurfaceFilled(
                    self, to_surface, unsetsurface_color, unsetsurface_rect
                )
                assertSurfaceFilledIgnoreArea(
                    self, to_surface, default_unsetcolor, unsetsurface_rect
                )

    def test_to_surface__setsurface_narrower_than_mask_and_colors_none(self):
        """Ensures that setsurfaces narrower than the mask work correctly
        when setcolor and unsetcolor are set to None.

        For this test the setsurface's width is less than the mask's width.
        """
        default_surface_color = (0, 0, 0, 0)
        mask_size = (10, 20)
        narrow_size = (6, 20)

        setsurface = pygame.Surface(narrow_size, SRCALPHA, 32)
        setsurface_color = pygame.Color("red")
        setsurface.fill(setsurface_color)
        setsurface_rect = setsurface.get_rect()

        for fill in (True, False):
            mask = pygame.mask.Mask(mask_size, fill=fill)

            to_surface = mask.to_surface(
                setsurface=setsurface, setcolor=None, unsetcolor=None
            )

            self.assertIsInstance(to_surface, pygame.Surface)
            self.assertEqual(to_surface.get_size(), mask_size)

            # Different checks depending on if the mask was filled or not.
            if fill:
                assertSurfaceFilled(self, to_surface, setsurface_color, setsurface_rect)
                assertSurfaceFilledIgnoreArea(
                    self, to_surface, default_surface_color, setsurface_rect
                )
            else:
                assertSurfaceFilled(self, to_surface, default_surface_color)

    def test_to_surface__unsetsurface_narrower_than_mask_and_colors_none(self):
        """Ensures that unsetsurfaces narrower than the mask work correctly
        when setcolor and unsetcolor are set to None.

        For this test the unsetsurface's width is less than the mask's width.
        """
        default_surface_color = (0, 0, 0, 0)
        mask_size = (10, 20)
        narrow_size = (6, 20)

        unsetsurface = pygame.Surface(narrow_size, SRCALPHA, 32)
        unsetsurface_color = pygame.Color("red")
        unsetsurface.fill(unsetsurface_color)
        unsetsurface_rect = unsetsurface.get_rect()

        for fill in (True, False):
            mask = pygame.mask.Mask(mask_size, fill=fill)

            to_surface = mask.to_surface(
                unsetsurface=unsetsurface, setcolor=None, unsetcolor=None
            )

            self.assertIsInstance(to_surface, pygame.Surface)
            self.assertEqual(to_surface.get_size(), mask_size)

            # Different checks depending on if the mask was filled or not.
            if fill:
                assertSurfaceFilled(self, to_surface, default_surface_color)
            else:
                assertSurfaceFilled(
                    self, to_surface, unsetsurface_color, unsetsurface_rect
                )
                assertSurfaceFilledIgnoreArea(
                    self, to_surface, default_surface_color, unsetsurface_rect
                )

    def test_to_surface__surface_wider_than_mask(self):
        """Ensures that surfaces wider than the mask work correctly.

        For this test the surface's width is greater than the mask's width.
        """
        default_setcolor = pygame.Color("white")
        default_unsetcolor = pygame.Color("black")
        mask_size = (6, 15)
        wide_size = (11, 15)

        surface = pygame.Surface(wide_size)
        surface_color = pygame.Color("red")

        for fill in (True, False):
            mask = pygame.mask.Mask(mask_size, fill=fill)
            mask_rect = mask.get_rect()
            surface.fill(surface_color)  # Clear for each test.
            expected_color = default_setcolor if fill else default_unsetcolor

            to_surface = mask.to_surface(surface)

            self.assertIs(to_surface, surface)
            self.assertEqual(to_surface.get_size(), wide_size)
            assertSurfaceFilled(self, to_surface, expected_color, mask_rect)
            assertSurfaceFilledIgnoreArea(self, to_surface, surface_color, mask_rect)

    def test_to_surface__setsurface_wider_than_mask(self):
        """Ensures that setsurfaces wider than the mask work correctly.

        For this test the setsurface's width is greater than the mask's width.
        """
        default_unsetcolor = pygame.Color("black")
        mask_size = (6, 15)
        wide_size = (11, 15)

        setsurface = pygame.Surface(wide_size, SRCALPHA, 32)
        setsurface_color = pygame.Color("red")
        setsurface.fill(setsurface_color)

        for fill in (True, False):
            mask = pygame.mask.Mask(mask_size, fill=fill)
            expected_color = setsurface_color if fill else default_unsetcolor

            to_surface = mask.to_surface(setsurface=setsurface)

            self.assertIsInstance(to_surface, pygame.Surface)
            self.assertEqual(to_surface.get_size(), mask_size)
            assertSurfaceFilled(self, to_surface, expected_color)

    def test_to_surface__unsetsurface_wider_than_mask(self):
        """Ensures that unsetsurfaces wider than the mask work correctly.

        For this test the unsetsurface's width is greater than the mask's
        width.
        """
        default_setcolor = pygame.Color("white")
        mask_size = (6, 15)
        wide_size = (11, 15)

        unsetsurface = pygame.Surface(wide_size, SRCALPHA, 32)
        unsetsurface_color = pygame.Color("red")
        unsetsurface.fill(unsetsurface_color)

        for fill in (True, False):
            mask = pygame.mask.Mask(mask_size, fill=fill)
            expected_color = default_setcolor if fill else unsetsurface_color

            to_surface = mask.to_surface(unsetsurface=unsetsurface)

            self.assertIsInstance(to_surface, pygame.Surface)
            self.assertEqual(to_surface.get_size(), mask_size)
            assertSurfaceFilled(self, to_surface, expected_color)

    def test_to_surface__surface_shorter_than_mask(self):
        """Ensures that surfaces shorter than the mask work correctly.

        For this test the surface's height is less than the mask's height.
        """
        default_setcolor = pygame.Color("white")
        default_unsetcolor = pygame.Color("black")
        mask_size = (10, 11)
        short_size = (10, 6)

        surface = pygame.Surface(short_size)
        surface_color = pygame.Color("red")

        for fill in (True, False):
            mask = pygame.mask.Mask(mask_size, fill=fill)
            surface.fill(surface_color)  # Clear for each test.
            expected_color = default_setcolor if fill else default_unsetcolor

            to_surface = mask.to_surface(surface)

            self.assertIs(to_surface, surface)
            self.assertEqual(to_surface.get_size(), short_size)
            assertSurfaceFilled(self, to_surface, expected_color)

    def test_to_surface__setsurface_shorter_than_mask(self):
        """Ensures that setsurfaces shorter than the mask work correctly.

        For this test the setsurface's height is less than the mask's height.
        """
        default_setcolor = pygame.Color("white")
        default_unsetcolor = pygame.Color("black")
        mask_size = (10, 11)
        short_size = (10, 6)

        setsurface = pygame.Surface(short_size, SRCALPHA, 32)
        setsurface_color = pygame.Color("red")
        setsurface.fill(setsurface_color)
        setsurface_rect = setsurface.get_rect()

        for fill in (True, False):
            mask = pygame.mask.Mask(mask_size, fill=fill)

            to_surface = mask.to_surface(setsurface=setsurface)

            self.assertIsInstance(to_surface, pygame.Surface)
            self.assertEqual(to_surface.get_size(), mask_size)

            # Different checks depending on if the mask was filled or not.
            if fill:
                assertSurfaceFilled(self, to_surface, setsurface_color, setsurface_rect)
                assertSurfaceFilledIgnoreArea(
                    self, to_surface, default_setcolor, setsurface_rect
                )
            else:
                assertSurfaceFilled(self, to_surface, default_unsetcolor)

    def test_to_surface__unsetsurface_shorter_than_mask(self):
        """Ensures that unsetsurfaces shorter than the mask work correctly.

        For this test the unsetsurface's height is less than the mask's height.
        """
        default_setcolor = pygame.Color("white")
        default_unsetcolor = pygame.Color("black")
        mask_size = (10, 11)
        short_size = (10, 6)

        unsetsurface = pygame.Surface(short_size, SRCALPHA, 32)
        unsetsurface_color = pygame.Color("red")
        unsetsurface.fill(unsetsurface_color)
        unsetsurface_rect = unsetsurface.get_rect()

        for fill in (True, False):
            mask = pygame.mask.Mask(mask_size, fill=fill)

            to_surface = mask.to_surface(unsetsurface=unsetsurface)

            self.assertIsInstance(to_surface, pygame.Surface)
            self.assertEqual(to_surface.get_size(), mask_size)

            # Different checks depending on if the mask was filled or not.
            if fill:
                assertSurfaceFilled(self, to_surface, default_setcolor)
            else:
                assertSurfaceFilled(
                    self, to_surface, unsetsurface_color, unsetsurface_rect
                )
                assertSurfaceFilledIgnoreArea(
                    self, to_surface, default_unsetcolor, unsetsurface_rect
                )

    def test_to_surface__setsurface_shorter_than_mask_and_colors_none(self):
        """Ensures that setsurfaces shorter than the mask work correctly
        when setcolor and unsetcolor are set to None.

        For this test the setsurface's height is less than the mask's height.
        """
        default_surface_color = (0, 0, 0, 0)
        mask_size = (10, 11)
        short_size = (10, 6)

        setsurface = pygame.Surface(short_size, SRCALPHA, 32)
        setsurface_color = pygame.Color("red")
        setsurface.fill(setsurface_color)
        setsurface_rect = setsurface.get_rect()

        for fill in (True, False):
            mask = pygame.mask.Mask(mask_size, fill=fill)

            to_surface = mask.to_surface(
                setsurface=setsurface, setcolor=None, unsetcolor=None
            )

            self.assertIsInstance(to_surface, pygame.Surface)
            self.assertEqual(to_surface.get_size(), mask_size)

            # Different checks depending on if the mask was filled or not.
            if fill:
                assertSurfaceFilled(self, to_surface, setsurface_color, setsurface_rect)
                assertSurfaceFilledIgnoreArea(
                    self, to_surface, default_surface_color, setsurface_rect
                )
            else:
                assertSurfaceFilled(self, to_surface, default_surface_color)

    def test_to_surface__unsetsurface_shorter_than_mask_and_colors_none(self):
        """Ensures that unsetsurfaces shorter than the mask work correctly
        when setcolor and unsetcolor are set to None.

        For this test the unsetsurface's height is less than the mask's height.
        """
        default_surface_color = (0, 0, 0, 0)
        mask_size = (10, 11)
        short_size = (10, 6)

        unsetsurface = pygame.Surface(short_size, SRCALPHA, 32)
        unsetsurface_color = pygame.Color("red")
        unsetsurface.fill(unsetsurface_color)
        unsetsurface_rect = unsetsurface.get_rect()

        for fill in (True, False):
            mask = pygame.mask.Mask(mask_size, fill=fill)

            to_surface = mask.to_surface(
                unsetsurface=unsetsurface, setcolor=None, unsetcolor=None
            )

            self.assertIsInstance(to_surface, pygame.Surface)
            self.assertEqual(to_surface.get_size(), mask_size)

            # Different checks depending on if the mask was filled or not.
            if fill:
                assertSurfaceFilled(self, to_surface, default_surface_color)
            else:
                assertSurfaceFilled(
                    self, to_surface, unsetsurface_color, unsetsurface_rect
                )
                assertSurfaceFilledIgnoreArea(
                    self, to_surface, default_surface_color, unsetsurface_rect
                )

    def test_to_surface__surface_taller_than_mask(self):
        """Ensures that surfaces taller than the mask work correctly.

        For this test the surface's height is greater than the mask's height.
        """
        default_setcolor = pygame.Color("white")
        default_unsetcolor = pygame.Color("black")
        mask_size = (10, 6)
        tall_size = (10, 11)

        surface = pygame.Surface(tall_size)
        surface_color = pygame.Color("red")

        for fill in (True, False):
            mask = pygame.mask.Mask(mask_size, fill=fill)
            mask_rect = mask.get_rect()
            surface.fill(surface_color)  # Clear for each test.
            expected_color = default_setcolor if fill else default_unsetcolor

            to_surface = mask.to_surface(surface)

            self.assertIs(to_surface, surface)
            self.assertEqual(to_surface.get_size(), tall_size)
            assertSurfaceFilled(self, to_surface, expected_color, mask_rect)
            assertSurfaceFilledIgnoreArea(self, to_surface, surface_color, mask_rect)

    def test_to_surface__setsurface_taller_than_mask(self):
        """Ensures that setsurfaces taller than the mask work correctly.

        For this test the setsurface's height is greater than the mask's
        height.
        """
        default_unsetcolor = pygame.Color("black")
        mask_size = (10, 6)
        tall_size = (10, 11)

        setsurface = pygame.Surface(tall_size, SRCALPHA, 32)
        setsurface_color = pygame.Color("red")
        setsurface.fill(setsurface_color)

        for fill in (True, False):
            mask = pygame.mask.Mask(mask_size, fill=fill)
            expected_color = setsurface_color if fill else default_unsetcolor

            to_surface = mask.to_surface(setsurface=setsurface)

            self.assertIsInstance(to_surface, pygame.Surface)
            self.assertEqual(to_surface.get_size(), mask_size)
            assertSurfaceFilled(self, to_surface, expected_color)

    def test_to_surface__unsetsurface_taller_than_mask(self):
        """Ensures that unsetsurfaces taller than the mask work correctly.

        For this test the unsetsurface's height is greater than the mask's
        height.
        """
        default_setcolor = pygame.Color("white")
        mask_size = (10, 6)
        tall_size = (10, 11)

        unsetsurface = pygame.Surface(tall_size, SRCALPHA, 32)
        unsetsurface_color = pygame.Color("red")
        unsetsurface.fill(unsetsurface_color)

        for fill in (True, False):
            mask = pygame.mask.Mask(mask_size, fill=fill)
            expected_color = default_setcolor if fill else unsetsurface_color

            to_surface = mask.to_surface(unsetsurface=unsetsurface)

            self.assertIsInstance(to_surface, pygame.Surface)
            self.assertEqual(to_surface.get_size(), mask_size)
            assertSurfaceFilled(self, to_surface, expected_color)

    def test_to_surface__surface_wider_and_taller_than_mask(self):
        """Ensures that surfaces wider and taller than the mask work correctly.

        For this test the surface's width is greater than the mask's width and
        the surface's height is greater than the mask's height.
        """
        default_setcolor = pygame.Color("white")
        default_unsetcolor = pygame.Color("black")
        mask_size = (6, 8)
        wide_tall_size = (11, 15)

        surface = pygame.Surface(wide_tall_size)
        surface_color = pygame.Color("red")

        for fill in (True, False):
            mask = pygame.mask.Mask(mask_size, fill=fill)
            mask_rect = mask.get_rect()
            surface.fill(surface_color)  # Clear for each test.
            expected_color = default_setcolor if fill else default_unsetcolor

            to_surface = mask.to_surface(surface)

            self.assertIs(to_surface, surface)
            self.assertEqual(to_surface.get_size(), wide_tall_size)
            assertSurfaceFilled(self, to_surface, expected_color, mask_rect)
            assertSurfaceFilledIgnoreArea(self, to_surface, surface_color, mask_rect)

    def test_to_surface__setsurface_wider_and_taller_than_mask(self):
        """Ensures that setsurfaces wider and taller than the mask work
        correctly.

        For this test the setsurface's width is greater than the mask's width
        and the setsurface's height is greater than the mask's height.
        """
        default_unsetcolor = pygame.Color("black")
        mask_size = (6, 8)
        wide_tall_size = (11, 15)

        setsurface = pygame.Surface(wide_tall_size, SRCALPHA, 32)
        setsurface_color = pygame.Color("red")
        setsurface.fill(setsurface_color)

        for fill in (True, False):
            mask = pygame.mask.Mask(mask_size, fill=fill)
            expected_color = setsurface_color if fill else default_unsetcolor

            to_surface = mask.to_surface(setsurface=setsurface)

            self.assertIsInstance(to_surface, pygame.Surface)
            self.assertEqual(to_surface.get_size(), mask_size)
            assertSurfaceFilled(self, to_surface, expected_color)

    def test_to_surface__unsetsurface_wider_and_taller_than_mask(self):
        """Ensures that unsetsurfaces wider and taller than the mask work
        correctly.

        For this test the unsetsurface's width is greater than the mask's width
        and the unsetsurface's height is greater than the mask's height.
        """
        default_setcolor = pygame.Color("white")
        mask_size = (6, 8)
        wide_tall_size = (11, 15)

        unsetsurface = pygame.Surface(wide_tall_size, SRCALPHA, 32)
        unsetsurface_color = pygame.Color("red")
        unsetsurface.fill(unsetsurface_color)

        for fill in (True, False):
            mask = pygame.mask.Mask(mask_size, fill=fill)
            expected_color = default_setcolor if fill else unsetsurface_color

            to_surface = mask.to_surface(unsetsurface=unsetsurface)

            self.assertIsInstance(to_surface, pygame.Surface)
            self.assertEqual(to_surface.get_size(), mask_size)
            assertSurfaceFilled(self, to_surface, expected_color)

    def test_to_surface__surface_wider_and_shorter_than_mask(self):
        """Ensures that surfaces wider and shorter than the mask work
        correctly.

        For this test the surface's width is greater than the mask's width and
        the surface's height is less than the mask's height.
        """
        default_setcolor = pygame.Color("white")
        default_unsetcolor = pygame.Color("black")
        mask_size = (7, 11)
        wide_short_size = (13, 6)

        surface = pygame.Surface(wide_short_size)
        surface_color = pygame.Color("red")

        for fill in (True, False):
            mask = pygame.mask.Mask(mask_size, fill=fill)
            mask_rect = mask.get_rect()
            surface.fill(surface_color)  # Clear for each test.
            expected_color = default_setcolor if fill else default_unsetcolor

            to_surface = mask.to_surface(surface)

            self.assertIs(to_surface, surface)
            self.assertEqual(to_surface.get_size(), wide_short_size)
            assertSurfaceFilled(self, to_surface, expected_color, mask_rect)
            assertSurfaceFilledIgnoreArea(self, to_surface, surface_color, mask_rect)

    def test_to_surface__setsurface_wider_and_shorter_than_mask(self):
        """Ensures that setsurfaces wider and shorter than the mask work
        correctly.

        For this test the setsurface's width is greater than the mask's width
        and the setsurface's height is less than the mask's height.
        """
        default_setcolor = pygame.Color("white")
        default_unsetcolor = pygame.Color("black")
        mask_size = (7, 11)
        wide_short_size = (10, 6)

        setsurface = pygame.Surface(wide_short_size, SRCALPHA, 32)
        setsurface_color = pygame.Color("red")
        setsurface.fill(setsurface_color)
        setsurface_rect = setsurface.get_rect()

        for fill in (True, False):
            mask = pygame.mask.Mask(mask_size, fill=fill)

            to_surface = mask.to_surface(setsurface=setsurface)

            self.assertIsInstance(to_surface, pygame.Surface)
            self.assertEqual(to_surface.get_size(), mask_size)

            # Different checks depending on if the mask was filled or not.
            if fill:
                assertSurfaceFilled(self, to_surface, setsurface_color, setsurface_rect)
                assertSurfaceFilledIgnoreArea(
                    self, to_surface, default_setcolor, setsurface_rect
                )
            else:
                assertSurfaceFilled(self, to_surface, default_unsetcolor)

    def test_to_surface__unsetsurface_wider_and_shorter_than_mask(self):
        """Ensures that unsetsurfaces wider and shorter than the mask work
        correctly.

        For this test the unsetsurface's width is greater than the mask's width
        and the unsetsurface's height is less than the mask's height.
        """
        default_setcolor = pygame.Color("white")
        default_unsetcolor = pygame.Color("black")
        mask_size = (7, 11)
        wide_short_size = (10, 6)

        unsetsurface = pygame.Surface(wide_short_size, SRCALPHA, 32)
        unsetsurface_color = pygame.Color("red")
        unsetsurface.fill(unsetsurface_color)
        unsetsurface_rect = unsetsurface.get_rect()

        for fill in (True, False):
            mask = pygame.mask.Mask(mask_size, fill=fill)

            to_surface = mask.to_surface(unsetsurface=unsetsurface)

            self.assertIsInstance(to_surface, pygame.Surface)
            self.assertEqual(to_surface.get_size(), mask_size)

            # Different checks depending on if the mask was filled or not.
            if fill:
                assertSurfaceFilled(self, to_surface, default_setcolor)
            else:
                assertSurfaceFilled(
                    self, to_surface, unsetsurface_color, unsetsurface_rect
                )
                assertSurfaceFilledIgnoreArea(
                    self, to_surface, default_unsetcolor, unsetsurface_rect
                )

    def test_to_surface__surface_narrower_and_taller_than_mask(self):
        """Ensures that surfaces narrower and taller than the mask work
        correctly.

        For this test the surface's width is less than the mask's width and
        the surface's height is greater than the mask's height.
        """
        default_setcolor = pygame.Color("white")
        default_unsetcolor = pygame.Color("black")
        mask_size = (10, 8)
        narrow_tall_size = (6, 15)

        surface = pygame.Surface(narrow_tall_size)
        surface_color = pygame.Color("red")

        for fill in (True, False):
            mask = pygame.mask.Mask(mask_size, fill=fill)
            mask_rect = mask.get_rect()
            surface.fill(surface_color)  # Clear for each test.
            expected_color = default_setcolor if fill else default_unsetcolor

            to_surface = mask.to_surface(surface)

            self.assertIs(to_surface, surface)
            self.assertEqual(to_surface.get_size(), narrow_tall_size)
            assertSurfaceFilled(self, to_surface, expected_color, mask_rect)
            assertSurfaceFilledIgnoreArea(self, to_surface, surface_color, mask_rect)

    def test_to_surface__setsurface_narrower_and_taller_than_mask(self):
        """Ensures that setsurfaces narrower and taller than the mask work
        correctly.

        For this test the setsurface's width is less than the mask's width
        and the setsurface's height is greater than the mask's height.
        """
        default_setcolor = pygame.Color("white")
        default_unsetcolor = pygame.Color("black")
        mask_size = (10, 8)
        narrow_tall_size = (6, 15)

        setsurface = pygame.Surface(narrow_tall_size, SRCALPHA, 32)
        setsurface_color = pygame.Color("red")
        setsurface.fill(setsurface_color)
        setsurface_rect = setsurface.get_rect()

        for fill in (True, False):
            mask = pygame.mask.Mask(mask_size, fill=fill)

            to_surface = mask.to_surface(setsurface=setsurface)

            self.assertIsInstance(to_surface, pygame.Surface)
            self.assertEqual(to_surface.get_size(), mask_size)

            # Different checks depending on if the mask was filled or not.
            if fill:
                assertSurfaceFilled(self, to_surface, setsurface_color, setsurface_rect)
                assertSurfaceFilledIgnoreArea(
                    self, to_surface, default_setcolor, setsurface_rect
                )
            else:
                assertSurfaceFilled(self, to_surface, default_unsetcolor)

    def test_to_surface__unsetsurface_narrower_and_taller_than_mask(self):
        """Ensures that unsetsurfaces narrower and taller than the mask work
        correctly.

        For this test the unsetsurface's width is less than the mask's width
        and the unsetsurface's height is greater than the mask's height.
        """
        default_setcolor = pygame.Color("white")
        default_unsetcolor = pygame.Color("black")
        mask_size = (10, 8)
        narrow_tall_size = (6, 15)

        unsetsurface = pygame.Surface(narrow_tall_size, SRCALPHA, 32)
        unsetsurface_color = pygame.Color("red")
        unsetsurface.fill(unsetsurface_color)
        unsetsurface_rect = unsetsurface.get_rect()

        for fill in (True, False):
            mask = pygame.mask.Mask(mask_size, fill=fill)

            to_surface = mask.to_surface(unsetsurface=unsetsurface)

            self.assertIsInstance(to_surface, pygame.Surface)
            self.assertEqual(to_surface.get_size(), mask_size)

            # Different checks depending on if the mask was filled or not.
            if fill:
                assertSurfaceFilled(self, to_surface, default_setcolor)
            else:
                assertSurfaceFilled(
                    self, to_surface, unsetsurface_color, unsetsurface_rect
                )
                assertSurfaceFilledIgnoreArea(
                    self, to_surface, default_unsetcolor, unsetsurface_rect
                )

    def test_to_surface__surface_narrower_and_shorter_than_mask(self):
        """Ensures that surfaces narrower and shorter than the mask work
        correctly.

        For this test the surface's width is less than the mask's width and
        the surface's height is less than the mask's height.
        """
        default_setcolor = pygame.Color("white")
        default_unsetcolor = pygame.Color("black")
        mask_size = (10, 18)
        narrow_short_size = (6, 15)

        surface = pygame.Surface(narrow_short_size)
        surface_color = pygame.Color("red")

        for fill in (True, False):
            mask = pygame.mask.Mask(mask_size, fill=fill)
            mask_rect = mask.get_rect()
            surface.fill(surface_color)  # Clear for each test.
            expected_color = default_setcolor if fill else default_unsetcolor

            to_surface = mask.to_surface(surface)

            self.assertIs(to_surface, surface)
            self.assertEqual(to_surface.get_size(), narrow_short_size)
            assertSurfaceFilled(self, to_surface, expected_color, mask_rect)
            assertSurfaceFilledIgnoreArea(self, to_surface, surface_color, mask_rect)

    def test_to_surface__setsurface_narrower_and_shorter_than_mask(self):
        """Ensures that setsurfaces narrower and shorter than the mask work
        correctly.

        For this test the setsurface's width is less than the mask's width
        and the setsurface's height is less than the mask's height.
        """
        default_setcolor = pygame.Color("white")
        default_unsetcolor = pygame.Color("black")
        mask_size = (10, 18)
        narrow_short_size = (6, 15)

        setsurface = pygame.Surface(narrow_short_size, SRCALPHA, 32)
        setsurface_color = pygame.Color("red")
        setsurface.fill(setsurface_color)
        setsurface_rect = setsurface.get_rect()

        for fill in (True, False):
            mask = pygame.mask.Mask(mask_size, fill=fill)

            to_surface = mask.to_surface(setsurface=setsurface)

            self.assertIsInstance(to_surface, pygame.Surface)
            self.assertEqual(to_surface.get_size(), mask_size)

            # Different checks depending on if the mask was filled or not.
            if fill:
                assertSurfaceFilled(self, to_surface, setsurface_color, setsurface_rect)
                assertSurfaceFilledIgnoreArea(
                    self, to_surface, default_setcolor, setsurface_rect
                )
            else:
                assertSurfaceFilled(self, to_surface, default_unsetcolor)

    def test_to_surface__unsetsurface_narrower_and_shorter_than_mask(self):
        """Ensures that unsetsurfaces narrower and shorter than the mask work
        correctly.

        For this test the unsetsurface's width is less than the mask's width
        and the unsetsurface's height is less than the mask's height.
        """
        default_setcolor = pygame.Color("white")
        default_unsetcolor = pygame.Color("black")
        mask_size = (10, 18)
        narrow_short_size = (6, 15)

        unsetsurface = pygame.Surface(narrow_short_size, SRCALPHA, 32)
        unsetsurface_color = pygame.Color("red")
        unsetsurface.fill(unsetsurface_color)
        unsetsurface_rect = unsetsurface.get_rect()

        for fill in (True, False):
            mask = pygame.mask.Mask(mask_size, fill=fill)

            to_surface = mask.to_surface(unsetsurface=unsetsurface)

            self.assertIsInstance(to_surface, pygame.Surface)
            self.assertEqual(to_surface.get_size(), mask_size)

            # Different checks depending on if the mask was filled or not.
            if fill:
                assertSurfaceFilled(self, to_surface, default_setcolor)
            else:
                assertSurfaceFilled(
                    self, to_surface, unsetsurface_color, unsetsurface_rect
                )
                assertSurfaceFilledIgnoreArea(
                    self, to_surface, default_unsetcolor, unsetsurface_rect
                )

    @unittest.skipIf(IS_PYPY, "Segfaults on pypy")
    def test_to_surface__all_surfaces_different_sizes_than_mask(self):
        """Ensures that all the surface parameters can be of different sizes."""
        default_setcolor = pygame.Color("white")
        default_unsetcolor = pygame.Color("black")
        surface_color = pygame.Color("red")
        setsurface_color = pygame.Color("green")
        unsetsurface_color = pygame.Color("blue")

        mask_size = (10, 15)
        surface_size = (11, 14)
        setsurface_size = (9, 8)
        unsetsurface_size = (12, 16)

        surface = pygame.Surface(surface_size)
        setsurface = pygame.Surface(setsurface_size)
        unsetsurface = pygame.Surface(unsetsurface_size)

        surface.fill(surface_color)
        setsurface.fill(setsurface_color)
        unsetsurface.fill(unsetsurface_color)

        surface_rect = surface.get_rect()
        setsurface_rect = setsurface.get_rect()
        unsetsurface_rect = unsetsurface.get_rect()

        # Create a mask that is filled except for a rect in the center.
        mask = pygame.mask.Mask(mask_size, fill=True)
        mask_rect = mask.get_rect()
        unfilled_rect = pygame.Rect((0, 0), (4, 5))
        unfilled_rect.center = mask_rect.center

        for pos in (
            (x, y)
            for x in range(unfilled_rect.x, unfilled_rect.w)
            for y in range(unfilled_rect.y, unfilled_rect.h)
        ):
            mask.set_at(pos, 0)

        to_surface = mask.to_surface(surface, setsurface, unsetsurface)

        self.assertIs(to_surface, surface)
        self.assertEqual(to_surface.get_size(), surface_size)

        # Check each surface pixel for the correct color.
        to_surface.lock()  # Lock for possible speed up.

        for pos in (
            (x, y) for x in range(surface_rect.w) for y in range(surface_rect.h)
        ):
            if not mask_rect.collidepoint(pos):
                expected_color = surface_color
            elif mask.get_at(pos):
                # Checking set bit colors.
                if setsurface_rect.collidepoint(pos):
                    expected_color = setsurface_color
                else:
                    expected_color = default_setcolor
            else:
                # Checking unset bit colors.
                if unsetsurface_rect.collidepoint(pos):
                    expected_color = unsetsurface_color
                else:
                    expected_color = default_unsetcolor

            self.assertEqual(to_surface.get_at(pos), expected_color)

        to_surface.unlock()

    def test_to_surface__dest_locations(self):
        """Ensures dest values can be different locations on/off the surface."""
        SIDE = 7
        surface = pygame.Surface((SIDE, SIDE))
        surface_rect = surface.get_rect()
        dest_rect = surface_rect.copy()

        surface_color = pygame.Color("red")
        default_setcolor = pygame.Color("white")
        default_unsetcolor = pygame.Color("black")

        directions = (
            ((s, 0) for s in range(-SIDE, SIDE + 1)),  # left to right
            ((0, s) for s in range(-SIDE, SIDE + 1)),  # top to bottom
            ((s, s) for s in range(-SIDE, SIDE + 1)),  # topleft to bottomright diag
            ((-s, s) for s in range(-SIDE, SIDE + 1)),  # topright to bottomleft diag
        )

        for fill in (True, False):
            mask = pygame.mask.Mask((SIDE, SIDE), fill=fill)
            expected_color = default_setcolor if fill else default_unsetcolor

            for direction in directions:
                for pos in direction:
                    dest_rect.topleft = pos
                    overlap_rect = dest_rect.clip(surface_rect)
                    surface.fill(surface_color)

                    to_surface = mask.to_surface(surface, dest=dest_rect)

                    assertSurfaceFilled(self, to_surface, expected_color, overlap_rect)
                    assertSurfaceFilledIgnoreArea(
                        self, to_surface, surface_color, overlap_rect
                    )

    @unittest.expectedFailure
    @unittest.skipIf(IS_PYPY, "Segfaults on pypy")
    def test_to_surface__area_locations(self):
        """Ensures area rects can be different locations on/off the mask."""
        SIDE = 7
        surface = pygame.Surface((SIDE, SIDE))

        surface_color = pygame.Color("red")
        default_setcolor = pygame.Color("white")
        default_unsetcolor = pygame.Color("black")

        directions = (
            ((s, 0) for s in range(-SIDE, SIDE + 1)),  # left to right
            ((0, s) for s in range(-SIDE, SIDE + 1)),  # top to bottom
            ((s, s) for s in range(-SIDE, SIDE + 1)),  # topleft to bottomright diag
            ((-s, s) for s in range(-SIDE, SIDE + 1)),  # topright to bottomleft diag
        )

        for fill in (True, False):
            mask = pygame.mask.Mask((SIDE, SIDE), fill=fill)
            mask_rect = mask.get_rect()
            area_rect = mask_rect.copy()
            expected_color = default_setcolor if fill else default_unsetcolor

            for direction in directions:
                for pos in direction:
                    area_rect.topleft = pos
                    overlap_rect = area_rect.clip(mask_rect)
                    overlap_rect.topleft = (0, 0)
                    surface.fill(surface_color)

                    to_surface = mask.to_surface(surface, area=area_rect)

                    assertSurfaceFilled(self, to_surface, expected_color, overlap_rect)
                    assertSurfaceFilledIgnoreArea(
                        self, to_surface, surface_color, overlap_rect
                    )

    @unittest.expectedFailure
    def test_to_surface__dest_and_area_locations(self):
        """Ensures dest/area values can be different locations on/off the
        surface/mask.
        """
        SIDE = 5
        surface = pygame.Surface((SIDE, SIDE))
        surface_rect = surface.get_rect()
        dest_rect = surface_rect.copy()

        surface_color = pygame.Color("red")
        default_setcolor = pygame.Color("white")
        default_unsetcolor = pygame.Color("black")

        dest_directions = (
            ((s, 0) for s in range(-SIDE, SIDE + 1)),  # left to right
            ((0, s) for s in range(-SIDE, SIDE + 1)),  # top to bottom
            ((s, s) for s in range(-SIDE, SIDE + 1)),  # topleft to bottomright diag
            ((-s, s) for s in range(-SIDE, SIDE + 1)),  # topright to bottomleft diag
        )

        # Using only the topleft to bottomright diagonal to test the area (to
        # reduce the number of loop iterations).
        area_positions = list(dest_directions[2])

        for fill in (True, False):
            mask = pygame.mask.Mask((SIDE, SIDE), fill=fill)
            mask_rect = mask.get_rect()
            area_rect = mask_rect.copy()
            expected_color = default_setcolor if fill else default_unsetcolor

            for dest_direction in dest_directions:
                for dest_pos in dest_direction:
                    dest_rect.topleft = dest_pos

                    for area_pos in area_positions:
                        area_rect.topleft = area_pos
                        area_overlap_rect = area_rect.clip(mask_rect)
                        area_overlap_rect.topleft = dest_rect.topleft
                        dest_overlap_rect = dest_rect.clip(area_overlap_rect)

                        surface.fill(surface_color)

                        to_surface = mask.to_surface(
                            surface, dest=dest_rect, area=area_rect
                        )

                        assertSurfaceFilled(
                            self, to_surface, expected_color, dest_overlap_rect
                        )
                        assertSurfaceFilledIgnoreArea(
                            self, to_surface, surface_color, dest_overlap_rect
                        )

    @unittest.expectedFailure
    def test_to_surface__area_sizes(self):
        """Ensures area rects can be different sizes."""
        SIDE = 7
        SIZES = (
            (0, 0),
            (0, 1),
            (1, 0),
            (1, 1),
            (SIDE - 1, SIDE - 1),
            (SIDE - 1, SIDE),
            (SIDE, SIDE - 1),
            (SIDE, SIDE),
            (SIDE + 1, SIDE),
            (SIDE, SIDE + 1),
            (SIDE + 1, SIDE + 1),
        )

        surface = pygame.Surface((SIDE, SIDE))
        surface_color = pygame.Color("red")
        default_setcolor = pygame.Color("white")
        default_unsetcolor = pygame.Color("black")

        for fill in (True, False):
            mask = pygame.mask.Mask((SIDE, SIDE), fill=fill)
            mask_rect = mask.get_rect()
            expected_color = default_setcolor if fill else default_unsetcolor

            for size in SIZES:
                area_rect = pygame.Rect((0, 0), size)

                for pos in self.ORIGIN_OFFSETS:
                    area_rect.topleft = pos
                    overlap_rect = area_rect.clip(mask_rect)
                    overlap_rect.topleft = (0, 0)
                    surface.fill(surface_color)

                    to_surface = mask.to_surface(surface, area=area_rect)

                    assertSurfaceFilled(self, to_surface, expected_color, overlap_rect)
                    assertSurfaceFilledIgnoreArea(
                        self, to_surface, surface_color, overlap_rect
                    )

    def test_to_surface__surface_color_alphas(self):
        """Ensures the setsurface/unsetsurface color alpha values are respected."""
        size = (13, 17)
        setsurface_color = pygame.Color("green")
        setsurface_color.a = 53
        unsetsurface_color = pygame.Color("blue")
        unsetsurface_color.a = 109

        setsurface = pygame.Surface(size, flags=SRCALPHA, depth=32)
        unsetsurface = pygame.Surface(size, flags=SRCALPHA, depth=32)

        setsurface.fill(setsurface_color)
        unsetsurface.fill(unsetsurface_color)

        for fill in (True, False):
            mask = pygame.mask.Mask(size, fill=fill)
            expected_color = setsurface_color if fill else unsetsurface_color

            to_surface = mask.to_surface(
                setsurface=setsurface, unsetsurface=unsetsurface
            )

            self.assertIsInstance(to_surface, pygame.Surface)
            self.assertEqual(to_surface.get_size(), size)
            assertSurfaceFilled(self, to_surface, expected_color)

    def test_to_surface__color_alphas(self):
        """Ensures the setcolor/unsetcolor alpha values are respected."""
        size = (13, 17)
        setcolor = pygame.Color("green")
        setcolor.a = 35
        unsetcolor = pygame.Color("blue")
        unsetcolor.a = 213

        for fill in (True, False):
            mask = pygame.mask.Mask(size, fill=fill)
            expected_color = setcolor if fill else unsetcolor

            to_surface = mask.to_surface(setcolor=setcolor, unsetcolor=unsetcolor)

            self.assertIsInstance(to_surface, pygame.Surface)
            self.assertEqual(to_surface.get_size(), size)
            assertSurfaceFilled(self, to_surface, expected_color)

    def test_to_surface__depths(self):
        """Ensures to_surface works correctly with supported surface depths."""
        size = (13, 17)
        surface_color = pygame.Color("red")
        setsurface_color = pygame.Color("green")
        unsetsurface_color = pygame.Color("blue")

        for depth in (8, 16, 24, 32):
            surface = pygame.Surface(size, depth=depth)
            setsurface = pygame.Surface(size, depth=depth)
            unsetsurface = pygame.Surface(size, depth=depth)

            surface.fill(surface_color)
            setsurface.fill(setsurface_color)
            unsetsurface.fill(unsetsurface_color)

            for fill in (True, False):
                mask = pygame.mask.Mask(size, fill=fill)

                # For non-32 bit depths, the actual color can be different from
                # what was filled.
                expected_color = (
                    setsurface.get_at((0, 0)) if fill else unsetsurface.get_at((0, 0))
                )

                to_surface = mask.to_surface(surface, setsurface, unsetsurface)

                self.assertIsInstance(to_surface, pygame.Surface)
                self.assertEqual(to_surface.get_size(), size)
                assertSurfaceFilled(self, to_surface, expected_color)

    def test_to_surface__different_depths(self):
        """Ensures an exception is raised when surfaces have different depths."""
        size = (13, 17)
        surface_color = pygame.Color("red")
        setsurface_color = pygame.Color("green")
        unsetsurface_color = pygame.Color("blue")
        mask = pygame.mask.Mask(size)

        # Test different combinations of depths.
        test_depths = (
            (8, 8, 16),  # surface/setsurface/unsetsurface
            (8, 8, 24),
            (8, 8, 32),
            (16, 16, 24),
            (16, 16, 32),
            (24, 16, 8),
            (32, 16, 16),
            (32, 32, 16),
            (32, 24, 32),
        )

        for depths in test_depths:
            surface = pygame.Surface(size, depth=depths[0])
            setsurface = pygame.Surface(size, depth=depths[1])
            unsetsurface = pygame.Surface(size, depth=depths[2])

            surface.fill(surface_color)
            setsurface.fill(setsurface_color)
            unsetsurface.fill(unsetsurface_color)

            with self.assertRaises(ValueError):
                mask.to_surface(surface, setsurface, unsetsurface)

    def test_to_surface__different_depths_with_created_surfaces(self):
        """Ensures an exception is raised when surfaces have different depths
        than the created surface.
        """
        size = (13, 17)
        setsurface_color = pygame.Color("green")
        unsetsurface_color = pygame.Color("blue")
        mask = pygame.mask.Mask(size)

        # Test different combinations of depths. The created surface always has
        # a depth of 32.
        test_depths = (
            (8, 8),  # setsurface/unsetsurface
            (16, 16),
            (24, 24),
            (24, 16),
            (32, 8),
            (32, 16),
            (32, 24),
            (16, 32),
        )

        for set_depth, unset_depth in test_depths:
            setsurface = pygame.Surface(size, depth=set_depth)
            unsetsurface = pygame.Surface(size, depth=unset_depth)

            setsurface.fill(setsurface_color)
            unsetsurface.fill(unsetsurface_color)

            with self.assertRaises(ValueError):
                mask.to_surface(setsurface=setsurface, unsetsurface=unsetsurface)

    def test_to_surface__same_srcalphas(self):
        """Ensures to_surface works correctly when the SRCALPHA flag is set or not."""
        size = (13, 17)
        surface_color = pygame.Color("red")
        setsurface_color = pygame.Color("green")
        unsetsurface_color = pygame.Color("blue")

        for depth in (16, 32):
            for flags in (0, SRCALPHA):
                surface = pygame.Surface(size, flags=flags, depth=depth)
                setsurface = pygame.Surface(size, flags=flags, depth=depth)
                unsetsurface = pygame.Surface(size, flags=flags, depth=depth)

                surface.fill(surface_color)
                setsurface.fill(setsurface_color)
                unsetsurface.fill(unsetsurface_color)

                for fill in (True, False):
                    mask = pygame.mask.Mask(size, fill=fill)
                    expected_color = setsurface_color if fill else unsetsurface_color

                    to_surface = mask.to_surface(surface, setsurface, unsetsurface)

                    self.assertIsInstance(to_surface, pygame.Surface)
                    self.assertEqual(to_surface.get_size(), size)
                    assertSurfaceFilled(self, to_surface, expected_color)
                    if flags:
                        self.assertTrue(to_surface.get_flags() & flags)

    def test_to_surface__same_srcalphas_with_created_surfaces(self):
        """Ensures to_surface works correctly when it creates a surface
        and the SRCALPHA flag is set on both setsurface and unsetsurface.
        """
        size = (13, 17)
        setsurface_color = pygame.Color("green")
        unsetsurface_color = pygame.Color("blue")
        # The created surface always has a depth of 32 and the SRCALPHA flag set.
        expected_flags = SRCALPHA

        setsurface = pygame.Surface(size, flags=expected_flags, depth=32)
        unsetsurface = pygame.Surface(size, flags=expected_flags, depth=32)

        setsurface.fill(setsurface_color)
        unsetsurface.fill(unsetsurface_color)

        for fill in (True, False):
            mask = pygame.mask.Mask(size, fill=fill)
            expected_color = setsurface_color if fill else unsetsurface_color

            to_surface = mask.to_surface(
                setsurface=setsurface, unsetsurface=unsetsurface
            )

            self.assertIsInstance(to_surface, pygame.Surface)
            self.assertEqual(to_surface.get_size(), size)
            assertSurfaceFilled(self, to_surface, expected_color)
            self.assertTrue(to_surface.get_flags() & expected_flags)

    def test_to_surface__different_srcalphas(self):
        """Ensures an exception is raised when surfaces have different SRCALPHA
        flag settings.
        """
        size = (13, 17)
        surface_color = pygame.Color("red")
        setsurface_color = pygame.Color("green")
        unsetsurface_color = pygame.Color("blue")
        mask = pygame.mask.Mask(size)

        # Test different combinations of SRCALPHA flags.
        test_flags = (
            (SRCALPHA, 0, 0),  # surface/setsurface/unsetsurface
            (SRCALPHA, SRCALPHA, 0),
            (0, SRCALPHA, SRCALPHA),
            (0, 0, SRCALPHA),
        )

        for depth in (16, 32):
            for flags in test_flags:
                surface = pygame.Surface(size, flags=flags[0], depth=depth)
                setsurface = pygame.Surface(size, flags=flags[1], depth=depth)
                unsetsurface = pygame.Surface(size, flags=flags[2], depth=depth)

                surface.fill(surface_color)
                setsurface.fill(setsurface_color)
                unsetsurface.fill(unsetsurface_color)

                with self.assertRaises(ValueError):
                    mask.to_surface(surface, setsurface, unsetsurface)

    def test_to_surface__different_srcalphas_with_created_surfaces(self):
        """Ensures an exception is raised when surfaces have different SRCALPHA
        flag settings than the created surface.
        """
        size = (13, 17)
        setsurface_color = pygame.Color("green")
        unsetsurface_color = pygame.Color("blue")
        mask = pygame.mask.Mask(size)

        for depth in (16, 32):
            # Test different combinations of SRCALPHA flags. The created
            # surface always has the SRCALPHA flag set.
            for flags in ((0, 0), (SRCALPHA, 0), (0, SRCALPHA)):
                setsurface = pygame.Surface(size, flags=flags[0], depth=depth)
                unsetsurface = pygame.Surface(size, flags=flags[1], depth=depth)

                setsurface.fill(setsurface_color)
                unsetsurface.fill(unsetsurface_color)

                with self.assertRaises(ValueError):
                    mask.to_surface(setsurface=setsurface, unsetsurface=unsetsurface)

    def test_to_surface__dest_on_surface(self):
        """Ensures dest values on the surface work correctly
        when using the defaults for setcolor and unsetcolor.
        """
        default_setcolor = pygame.Color("white")
        default_unsetcolor = pygame.Color("black")
        width, height = size = (5, 9)
        surface = pygame.Surface(size, SRCALPHA, 32)
        surface_color = pygame.Color("red")

        for fill in (True, False):
            mask = pygame.mask.Mask(size, fill=fill)
            mask_rect = mask.get_rect()
            expected_color = default_setcolor if fill else default_unsetcolor

            # Test the dest parameter at different locations on the surface.
            for dest in ((x, y) for y in range(height) for x in range(width)):
                surface.fill(surface_color)  # Clear for each test.
                mask_rect.topleft = dest

                to_surface = mask.to_surface(surface, dest=dest)

                self.assertIs(to_surface, surface)
                self.assertEqual(to_surface.get_size(), size)
                assertSurfaceFilled(self, to_surface, expected_color, mask_rect)
                assertSurfaceFilledIgnoreArea(
                    self, to_surface, surface_color, mask_rect
                )

    def test_to_surface__dest_on_surface_with_setsurface_unsetsurface(self):
        """Ensures dest values on the surface work correctly
        when using setsurface and unsetsurface.
        """
        width, height = size = (5, 9)
        surface = pygame.Surface(size, SRCALPHA, 32)
        surface_color = pygame.Color("red")

        setsurface = surface.copy()
        setsurface_color = pygame.Color("green")
        setsurface.fill(setsurface_color)

        unsetsurface = surface.copy()
        unsetsurface_color = pygame.Color("blue")
        unsetsurface.fill(unsetsurface_color)

        # Using different kwargs to exercise different to_surface() code.
        # Should not have any impact on the resulting drawn surfaces.
        kwargs = {
            "surface": surface,
            "setsurface": setsurface,
            "unsetsurface": unsetsurface,
            "dest": None,
        }

        color_kwargs = dict(kwargs)
        color_kwargs.update((("setcolor", None), ("unsetcolor", None)))

        for fill in (True, False):
            mask = pygame.mask.Mask(size, fill=fill)
            mask_rect = mask.get_rect()
            expected_color = setsurface_color if fill else unsetsurface_color

            # Test the dest parameter at different locations on the surface.
            for dest in ((x, y) for y in range(height) for x in range(width)):
                mask_rect.topleft = dest

                for use_color_params in (True, False):
                    surface.fill(surface_color)  # Clear for each test.

                    test_kwargs = color_kwargs if use_color_params else kwargs
                    test_kwargs["dest"] = dest
                    to_surface = mask.to_surface(**test_kwargs)

                    self.assertIs(to_surface, surface)
                    self.assertEqual(to_surface.get_size(), size)
                    assertSurfaceFilled(self, to_surface, expected_color, mask_rect)
                    assertSurfaceFilledIgnoreArea(
                        self, to_surface, surface_color, mask_rect
                    )

    def test_to_surface__dest_off_surface(self):
        """Ensures dest values off the surface work correctly
        when using the defaults for setcolor and unsetcolor.
        """
        default_setcolor = pygame.Color("white")
        default_unsetcolor = pygame.Color("black")
        width, height = size = (5, 7)
        surface = pygame.Surface(size, SRCALPHA, 32)
        surface_color = pygame.Color("red")

        # Test different dests off the surface.
        dests = [(-width, -height), (-width, 0), (0, -height)]
        dests.extend(off_corners(surface.get_rect()))

        for fill in (True, False):
            mask = pygame.mask.Mask(size, fill=fill)
            mask_rect = mask.get_rect()
            expected_color = default_setcolor if fill else default_unsetcolor

            for dest in dests:
                surface.fill(surface_color)  # Clear for each test.
                mask_rect.topleft = dest

                to_surface = mask.to_surface(surface, dest=dest)

                self.assertIs(to_surface, surface)
                self.assertEqual(to_surface.get_size(), size)
                assertSurfaceFilled(self, to_surface, expected_color, mask_rect)
                assertSurfaceFilledIgnoreArea(
                    self, to_surface, surface_color, mask_rect
                )

    def test_to_surface__dest_off_surface_with_setsurface_unsetsurface(self):
        """Ensures dest values off the surface work correctly
        when using setsurface and unsetsurface.
        """
        width, height = size = (5, 7)
        surface = pygame.Surface(size, SRCALPHA, 32)
        surface_color = pygame.Color("red")

        setsurface = surface.copy()
        setsurface_color = pygame.Color("green")
        setsurface.fill(setsurface_color)

        unsetsurface = surface.copy()
        unsetsurface_color = pygame.Color("blue")
        unsetsurface.fill(unsetsurface_color)

        # Test different dests off the surface.
        dests = [(-width, -height), (-width, 0), (0, -height)]
        dests.extend(off_corners(surface.get_rect()))

        # Using different kwargs to exercise different to_surface() code.
        # Should not have any impact on the resulting drawn surfaces.
        kwargs = {
            "surface": surface,
            "setsurface": setsurface,
            "unsetsurface": unsetsurface,
            "dest": None,
        }

        color_kwargs = dict(kwargs)
        color_kwargs.update((("setcolor", None), ("unsetcolor", None)))

        for fill in (True, False):
            mask = pygame.mask.Mask(size, fill=fill)
            mask_rect = mask.get_rect()
            expected_color = setsurface_color if fill else unsetsurface_color

            for dest in dests:
                mask_rect.topleft = dest

                for use_color_params in (True, False):
                    surface.fill(surface_color)  # Clear for each test.
                    test_kwargs = color_kwargs if use_color_params else kwargs
                    test_kwargs["dest"] = dest
                    to_surface = mask.to_surface(**test_kwargs)

                    self.assertIs(to_surface, surface)
                    self.assertEqual(to_surface.get_size(), size)
                    assertSurfaceFilled(self, to_surface, expected_color, mask_rect)
                    assertSurfaceFilledIgnoreArea(
                        self, to_surface, surface_color, mask_rect
                    )

    @unittest.expectedFailure
    @unittest.skipIf(IS_PYPY, "Segfaults on pypy")
    def test_to_surface__area_on_mask(self):
        """Ensures area values on the mask work correctly
        when using the defaults for setcolor and unsetcolor.
        """
        default_setcolor = pygame.Color("white")
        default_unsetcolor = pygame.Color("black")
        width, height = size = (5, 9)
        surface = pygame.Surface(size, SRCALPHA, 32)
        surface_color = pygame.Color("red")

        for fill in (True, False):
            mask = pygame.mask.Mask(size, fill=fill)
            mask_rect = mask.get_rect()
            area_rect = mask_rect.copy()
            expected_color = default_setcolor if fill else default_unsetcolor

            # Testing the area parameter at different locations on the mask.
            for pos in ((x, y) for y in range(height) for x in range(width)):
                surface.fill(surface_color)  # Clear for each test.
                area_rect.topleft = pos
                overlap_rect = mask_rect.clip(area_rect)
                overlap_rect.topleft = (0, 0)

                to_surface = mask.to_surface(surface, area=area_rect)

                self.assertIs(to_surface, surface)
                self.assertEqual(to_surface.get_size(), size)
                assertSurfaceFilled(self, to_surface, expected_color, overlap_rect)
                assertSurfaceFilledIgnoreArea(
                    self, to_surface, surface_color, overlap_rect
                )

    @unittest.expectedFailure
    def test_to_surface__area_on_mask_with_setsurface_unsetsurface(self):
        """Ensures area values on the mask work correctly
        when using setsurface and unsetsurface.
        """
        width, height = size = (5, 9)
        surface = pygame.Surface(size, SRCALPHA, 32)
        surface_color = pygame.Color("red")

        setsurface = surface.copy()
        setsurface_color = pygame.Color("green")
        setsurface.fill(setsurface_color)

        unsetsurface = surface.copy()
        unsetsurface_color = pygame.Color("blue")
        unsetsurface.fill(unsetsurface_color)

        # Using the values in kwargs vs color_kwargs tests different to_surface
        # code. Should not have any impact on the resulting drawn surfaces.
        kwargs = {
            "surface": surface,
            "setsurface": setsurface,
            "unsetsurface": unsetsurface,
            "area": pygame.Rect((0, 0), size),
        }

        color_kwargs = dict(kwargs)
        color_kwargs.update((("setcolor", None), ("unsetcolor", None)))

        for fill in (True, False):
            mask = pygame.mask.Mask(size, fill=fill)
            mask_rect = mask.get_rect()
            area_rect = mask_rect.copy()
            expected_color = setsurface_color if fill else unsetsurface_color

            # Testing the area parameter at different locations on the mask.
            for pos in ((x, y) for y in range(height) for x in range(width)):
                area_rect.topleft = pos
                overlap_rect = mask_rect.clip(area_rect)
                overlap_rect.topleft = (0, 0)

                for use_color_params in (True, False):
                    surface.fill(surface_color)  # Clear for each test.
                    test_kwargs = color_kwargs if use_color_params else kwargs
                    test_kwargs["area"].topleft = pos
                    overlap_rect = mask_rect.clip(test_kwargs["area"])
                    overlap_rect.topleft = (0, 0)

                    to_surface = mask.to_surface(**test_kwargs)

                    self.assertIs(to_surface, surface)
                    self.assertEqual(to_surface.get_size(), size)
                    assertSurfaceFilled(self, to_surface, expected_color, overlap_rect)
                    assertSurfaceFilledIgnoreArea(
                        self, to_surface, surface_color, overlap_rect
                    )

    @unittest.expectedFailure
    @unittest.skipIf(IS_PYPY, "Segfaults on pypy")
    def test_to_surface__area_off_mask(self):
        """Ensures area values off the mask work correctly
        when using the defaults for setcolor and unsetcolor.
        """
        default_setcolor = pygame.Color("white")
        default_unsetcolor = pygame.Color("black")
        width, height = size = (5, 7)
        surface = pygame.Surface(size, SRCALPHA, 32)
        surface_color = pygame.Color("red")

        # Testing positions off the mask.
        positions = [(-width, -height), (-width, 0), (0, -height)]
        positions.extend(off_corners(pygame.Rect((0, 0), (width, height))))

        for fill in (True, False):
            mask = pygame.mask.Mask(size, fill=fill)
            mask_rect = mask.get_rect()
            area_rect = mask_rect.copy()
            expected_color = default_setcolor if fill else default_unsetcolor

            for pos in positions:
                surface.fill(surface_color)  # Clear for each test.
                area_rect.topleft = pos
                overlap_rect = mask_rect.clip(area_rect)
                overlap_rect.topleft = (0, 0)

                to_surface = mask.to_surface(surface, area=area_rect)

                self.assertIs(to_surface, surface)
                self.assertEqual(to_surface.get_size(), size)
                assertSurfaceFilled(self, to_surface, expected_color, overlap_rect)
                assertSurfaceFilledIgnoreArea(
                    self, to_surface, surface_color, overlap_rect
                )

    @unittest.expectedFailure
    @unittest.skipIf(IS_PYPY, "Segfaults on pypy")
    def test_to_surface__area_off_mask_with_setsurface_unsetsurface(self):
        """Ensures area values off the mask work correctly
        when using setsurface and unsetsurface.
        """
        width, height = size = (5, 7)
        surface = pygame.Surface(size, SRCALPHA, 32)
        surface_color = pygame.Color("red")

        setsurface = surface.copy()
        setsurface_color = pygame.Color("green")
        setsurface.fill(setsurface_color)

        unsetsurface = surface.copy()
        unsetsurface_color = pygame.Color("blue")
        unsetsurface.fill(unsetsurface_color)

        # Testing positions off the mask.
        positions = [(-width, -height), (-width, 0), (0, -height)]
        positions.extend(off_corners(pygame.Rect((0, 0), (width, height))))

        # Using the values in kwargs vs color_kwargs tests different to_surface
        # code. Should not have any impact on the resulting drawn surfaces.
        kwargs = {
            "surface": surface,
            "setsurface": setsurface,
            "unsetsurface": unsetsurface,
            "area": pygame.Rect((0, 0), size),
        }

        color_kwargs = dict(kwargs)
        color_kwargs.update((("setcolor", None), ("unsetcolor", None)))

        for fill in (True, False):
            mask = pygame.mask.Mask(size, fill=fill)
            mask_rect = mask.get_rect()
            expected_color = setsurface_color if fill else unsetsurface_color

            for pos in positions:
                for use_color_params in (True, False):
                    surface.fill(surface_color)  # Clear for each test.
                    test_kwargs = color_kwargs if use_color_params else kwargs
                    test_kwargs["area"].topleft = pos
                    overlap_rect = mask_rect.clip(test_kwargs["area"])
                    overlap_rect.topleft = (0, 0)

                    to_surface = mask.to_surface(**test_kwargs)

                    self.assertIs(to_surface, surface)
                    self.assertEqual(to_surface.get_size(), size)
                    assertSurfaceFilled(self, to_surface, expected_color, overlap_rect)
                    assertSurfaceFilledIgnoreArea(
                        self, to_surface, surface_color, overlap_rect
                    )

    def test_to_surface__surface_with_zero_size(self):
        """Ensures zero sized surfaces are handled correctly."""
        expected_ref_count = 3
        size = (0, 0)
        surface = pygame.Surface(size)
        mask = pygame.mask.Mask((3, 4), fill=True)

        to_surface = mask.to_surface(surface)

        self.assertIs(to_surface, surface)
        if not IS_PYPY:
            self.assertEqual(sys.getrefcount(to_surface), expected_ref_count)
        self.assertEqual(to_surface.get_size(), size)

    def test_to_surface__setsurface_with_zero_size(self):
        """Ensures zero sized setsurfaces are handled correctly."""
        expected_ref_count = 2
        expected_flag = SRCALPHA
        expected_depth = 32
        expected_color = pygame.Color("white")  # Default setcolor.
        mask_size = (2, 4)
        mask = pygame.mask.Mask(mask_size, fill=True)
        setsurface = pygame.Surface((0, 0), expected_flag, expected_depth)

        to_surface = mask.to_surface(setsurface=setsurface)

        self.assertIsInstance(to_surface, pygame.Surface)
        if not IS_PYPY:
            self.assertEqual(sys.getrefcount(to_surface), expected_ref_count)
        self.assertTrue(to_surface.get_flags() & expected_flag)
        self.assertEqual(to_surface.get_bitsize(), expected_depth)
        self.assertEqual(to_surface.get_size(), mask_size)
        assertSurfaceFilled(self, to_surface, expected_color)

    def test_to_surface__unsetsurface_with_zero_size(self):
        """Ensures zero sized unsetsurfaces are handled correctly."""
        expected_ref_count = 2
        expected_flag = SRCALPHA
        expected_depth = 32
        expected_color = pygame.Color("black")  # Default unsetcolor.
        mask_size = (4, 2)
        mask = pygame.mask.Mask(mask_size)
        unsetsurface = pygame.Surface((0, 0), expected_flag, expected_depth)

        to_surface = mask.to_surface(unsetsurface=unsetsurface)

        self.assertIsInstance(to_surface, pygame.Surface)
        if not IS_PYPY:
            self.assertEqual(sys.getrefcount(to_surface), expected_ref_count)
        self.assertTrue(to_surface.get_flags() & expected_flag)
        self.assertEqual(to_surface.get_bitsize(), expected_depth)
        self.assertEqual(to_surface.get_size(), mask_size)
        assertSurfaceFilled(self, to_surface, expected_color)

    def test_zero_mask(self):
        """Ensures masks can be created with zero sizes."""
        for size in ((100, 0), (0, 100), (0, 0)):
            for fill in (True, False):
                msg = "size={}, fill={}".format(size, fill)

                mask = pygame.mask.Mask(size, fill=fill)

                self.assertIsInstance(mask, pygame.mask.Mask, msg)
                self.assertEqual(mask.get_size(), size, msg)

    def test_zero_mask_copy(self):
        """Ensures copy correctly handles zero sized masks."""
        for expected_size in ((11, 0), (0, 11), (0, 0)):
            mask = pygame.mask.Mask(expected_size)

            mask_copy = mask.copy()

            self.assertIsInstance(mask_copy, pygame.mask.Mask)
            self.assertIsNot(mask_copy, mask)
            assertMaskEqual(self, mask_copy, mask)

    def test_zero_mask_get_size(self):
        """Ensures get_size correctly handles zero sized masks."""
        for expected_size in ((41, 0), (0, 40), (0, 0)):
            mask = pygame.mask.Mask(expected_size)

            size = mask.get_size()

            self.assertEqual(size, expected_size)

    def test_zero_mask_get_rect(self):
        """Ensures get_rect correctly handles zero sized masks."""
        for expected_size in ((4, 0), (0, 4), (0, 0)):
            expected_rect = pygame.Rect((0, 0), expected_size)
            mask = pygame.mask.Mask(expected_size)

            rect = mask.get_rect()

            self.assertEqual(rect, expected_rect)

    def test_zero_mask_get_at(self):
        """Ensures get_at correctly handles zero sized masks."""
        for size in ((51, 0), (0, 50), (0, 0)):
            mask = pygame.mask.Mask(size)

            with self.assertRaises(IndexError):
                value = mask.get_at((0, 0))

    def test_zero_mask_set_at(self):
        """Ensures set_at correctly handles zero sized masks."""
        for size in ((31, 0), (0, 30), (0, 0)):
            mask = pygame.mask.Mask(size)

            with self.assertRaises(IndexError):
                mask.set_at((0, 0))

    def test_zero_mask_overlap(self):
        """Ensures overlap correctly handles zero sized masks.

        Tests combinations of sized and zero sized masks.
        """
        offset = (0, 0)

        for size1, size2 in zero_size_pairs(51, 42):
            msg = "size1={}, size2={}".format(size1, size2)
            mask1 = pygame.mask.Mask(size1, fill=True)
            mask2 = pygame.mask.Mask(size2, fill=True)

            overlap_pos = mask1.overlap(mask2, offset)

            self.assertIsNone(overlap_pos, msg)

    def test_zero_mask_overlap_area(self):
        """Ensures overlap_area correctly handles zero sized masks.

        Tests combinations of sized and zero sized masks.
        """
        offset = (0, 0)
        expected_count = 0

        for size1, size2 in zero_size_pairs(41, 52):
            msg = "size1={}, size2={}".format(size1, size2)
            mask1 = pygame.mask.Mask(size1, fill=True)
            mask2 = pygame.mask.Mask(size2, fill=True)

            overlap_count = mask1.overlap_area(mask2, offset)

            self.assertEqual(overlap_count, expected_count, msg)

    def test_zero_mask_overlap_mask(self):
        """Ensures overlap_mask correctly handles zero sized masks.

        Tests combinations of sized and zero sized masks.
        """
        offset = (0, 0)
        expected_count = 0

        for size1, size2 in zero_size_pairs(43, 53):
            msg = "size1={}, size2={}".format(size1, size2)
            mask1 = pygame.mask.Mask(size1, fill=True)
            mask2 = pygame.mask.Mask(size2, fill=True)

            overlap_mask = mask1.overlap_mask(mask2, offset)

            self.assertIsInstance(overlap_mask, pygame.mask.Mask, msg)
            self.assertEqual(overlap_mask.count(), expected_count, msg)
            self.assertEqual(overlap_mask.get_size(), size1, msg)

    def test_zero_mask_fill(self):
        """Ensures fill correctly handles zero sized masks."""
        expected_count = 0

        for size in ((100, 0), (0, 100), (0, 0)):
            mask = pygame.mask.Mask(size)

            mask.fill()

            self.assertEqual(mask.count(), expected_count, "size={}".format(size))

    def test_zero_mask_clear(self):
        sizes = ((100, 0), (0, 100), (0, 0))

        for size in sizes:
            mask = pygame.mask.Mask(size)
            mask.clear()
            self.assertEqual(mask.count(), 0)

    def test_zero_mask_flip(self):
        sizes = ((100, 0), (0, 100), (0, 0))

        for size in sizes:
            mask = pygame.mask.Mask(size)
            mask.invert()
            self.assertEqual(mask.count(), 0)

    def test_zero_mask_scale(self):
        sizes = ((100, 0), (0, 100), (0, 0))

        for size in sizes:
            mask = pygame.mask.Mask(size)
            mask2 = mask.scale((2, 3))

            self.assertIsInstance(mask2, pygame.mask.Mask)
            self.assertEqual(mask2.get_size(), (2, 3))

    def test_zero_mask_draw(self):
        """Ensures draw correctly handles zero sized masks.

        Tests combinations of sized and zero sized masks.
        """
        offset = (0, 0)

        for size1, size2 in zero_size_pairs(31, 37):
            msg = "size1={}, size2={}".format(size1, size2)
            mask1 = pygame.mask.Mask(size1, fill=True)
            mask2 = pygame.mask.Mask(size2, fill=True)
            expected_count = mask1.count()

            mask1.draw(mask2, offset)

            self.assertEqual(mask1.count(), expected_count, msg)
            self.assertEqual(mask1.get_size(), size1, msg)

    def test_zero_mask_erase(self):
        """Ensures erase correctly handles zero sized masks.

        Tests combinations of sized and zero sized masks.
        """
        offset = (0, 0)

        for size1, size2 in zero_size_pairs(29, 23):
            msg = "size1={}, size2={}".format(size1, size2)
            mask1 = pygame.mask.Mask(size1, fill=True)
            mask2 = pygame.mask.Mask(size2, fill=True)
            expected_count = mask1.count()

            mask1.erase(mask2, offset)

            self.assertEqual(mask1.count(), expected_count, msg)
            self.assertEqual(mask1.get_size(), size1, msg)

    def test_zero_mask_count(self):
        sizes = ((100, 0), (0, 100), (0, 0))

        for size in sizes:
            mask = pygame.mask.Mask(size, fill=True)
            self.assertEqual(mask.count(), 0)

    def test_zero_mask_centroid(self):
        sizes = ((100, 0), (0, 100), (0, 0))

        for size in sizes:
            mask = pygame.mask.Mask(size)
            self.assertEqual(mask.centroid(), (0, 0))

    def test_zero_mask_angle(self):
        sizes = ((100, 0), (0, 100), (0, 0))

        for size in sizes:
            mask = pygame.mask.Mask(size)
            self.assertEqual(mask.angle(), 0.0)

    def test_zero_mask_outline(self):
        """Ensures outline correctly handles zero sized masks."""
        expected_points = []

        for size in ((61, 0), (0, 60), (0, 0)):
            mask = pygame.mask.Mask(size)

            points = mask.outline()

            self.assertListEqual(points, expected_points, "size={}".format(size))

    def test_zero_mask_outline__with_arg(self):
        """Ensures outline correctly handles zero sized masks
        when using the skip pixels argument."""
        expected_points = []

        for size in ((66, 0), (0, 65), (0, 0)):
            mask = pygame.mask.Mask(size)

            points = mask.outline(10)

            self.assertListEqual(points, expected_points, "size={}".format(size))

    def test_zero_mask_convolve(self):
        """Ensures convolve correctly handles zero sized masks.

        Tests the different combinations of sized and zero sized masks.
        """
        for size1 in ((17, 13), (71, 0), (0, 70), (0, 0)):
            mask1 = pygame.mask.Mask(size1, fill=True)

            for size2 in ((11, 7), (81, 0), (0, 60), (0, 0)):
                msg = "sizes={}, {}".format(size1, size2)
                mask2 = pygame.mask.Mask(size2, fill=True)
                expected_size = (
                    max(0, size1[0] + size2[0] - 1),
                    max(0, size1[1] + size2[1] - 1),
                )

                mask = mask1.convolve(mask2)

                self.assertIsInstance(mask, pygame.mask.Mask, msg)
                self.assertIsNot(mask, mask2, msg)
                self.assertEqual(mask.get_size(), expected_size, msg)

    def test_zero_mask_convolve__with_output_mask(self):
        """Ensures convolve correctly handles zero sized masks
        when using an output mask argument.

        Tests the different combinations of sized and zero sized masks.
        """
        for size1 in ((11, 17), (91, 0), (0, 90), (0, 0)):
            mask1 = pygame.mask.Mask(size1, fill=True)

            for size2 in ((13, 11), (83, 0), (0, 62), (0, 0)):
                mask2 = pygame.mask.Mask(size2, fill=True)

                for output_size in ((7, 5), (71, 0), (0, 70), (0, 0)):
                    msg = "sizes={}, {}, {}".format(size1, size2, output_size)
                    output_mask = pygame.mask.Mask(output_size)

                    mask = mask1.convolve(mask2, output_mask)

                    self.assertIsInstance(mask, pygame.mask.Mask, msg)
                    self.assertIs(mask, output_mask, msg)
                    self.assertEqual(mask.get_size(), output_size, msg)

    def test_zero_mask_connected_component(self):
        """Ensures connected_component correctly handles zero sized masks."""
        expected_count = 0

        for size in ((81, 0), (0, 80), (0, 0)):
            msg = "size={}".format(size)
            mask = pygame.mask.Mask(size)

            cc_mask = mask.connected_component()

            self.assertIsInstance(cc_mask, pygame.mask.Mask, msg)
            self.assertEqual(cc_mask.get_size(), size)
            self.assertEqual(cc_mask.count(), expected_count, msg)

    def test_zero_mask_connected_component__indexed(self):
        """Ensures connected_component correctly handles zero sized masks
        when using an index argument."""
        for size in ((91, 0), (0, 90), (0, 0)):
            mask = pygame.mask.Mask(size)

            with self.assertRaises(IndexError):
                cc_mask = mask.connected_component((0, 0))

    def test_zero_mask_connected_components(self):
        """Ensures connected_components correctly handles zero sized masks."""
        expected_cc_masks = []

        for size in ((11, 0), (0, 10), (0, 0)):
            mask = pygame.mask.Mask(size)

            cc_masks = mask.connected_components()

            self.assertListEqual(cc_masks, expected_cc_masks, "size={}".format(size))

    def test_zero_mask_get_bounding_rects(self):
        """Ensures get_bounding_rects correctly handles zero sized masks."""
        expected_bounding_rects = []

        for size in ((21, 0), (0, 20), (0, 0)):
            mask = pygame.mask.Mask(size)

            bounding_rects = mask.get_bounding_rects()

            self.assertListEqual(
                bounding_rects, expected_bounding_rects, "size={}".format(size)
            )

    def test_zero_mask_to_surface(self):
        """Ensures to_surface correctly handles zero sized masks and surfaces."""
        mask_color = pygame.Color("blue")
        surf_color = pygame.Color("red")

        for surf_size in ((7, 3), (7, 0), (0, 7), (0, 0)):
            surface = pygame.Surface(surf_size, SRCALPHA, 32)
            surface.fill(surf_color)

            for mask_size in ((5, 0), (0, 5), (0, 0)):
                mask = pygame.mask.Mask(mask_size, fill=True)

                to_surface = mask.to_surface(surface, setcolor=mask_color)

                self.assertIs(to_surface, surface)
                self.assertEqual(to_surface.get_size(), surf_size)

                if 0 not in surf_size:
                    assertSurfaceFilled(self, to_surface, surf_color)

    def test_zero_mask_to_surface__create_surface(self):
        """Ensures to_surface correctly handles zero sized masks and surfaces
        when it has to create a default surface.
        """
        mask_color = pygame.Color("blue")

        for mask_size in ((3, 0), (0, 3), (0, 0)):
            mask = pygame.mask.Mask(mask_size, fill=True)

            to_surface = mask.to_surface(setcolor=mask_color)

            self.assertIsInstance(to_surface, pygame.Surface)
            self.assertEqual(to_surface.get_size(), mask_size)


class SubMask(pygame.mask.Mask):
    """Subclass of the Mask class to help test subclassing."""

    def __init__(self, *args, **kwargs):
        super(SubMask, self).__init__(*args, **kwargs)
        self.test_attribute = True


class SubMaskCopy(SubMask):
    """Subclass of the Mask class to help test copying subclasses."""

    def copy(self):
        mask_copy = super(SubMaskCopy, self).copy()
        mask_copy.test_attribute = self.test_attribute
        return mask_copy


class SubMaskDunderCopy(SubMask):
    """Subclass of the Mask class to help test copying subclasses."""

    def __copy__(self):
        mask_copy = super(SubMaskDunderCopy, self).__copy__()
        mask_copy.test_attribute = self.test_attribute
        return mask_copy


class SubMaskCopyAndDunderCopy(SubMaskDunderCopy):
    """Subclass of the Mask class to help test copying subclasses."""

    def copy(self):
        return super(SubMaskCopyAndDunderCopy, self).copy()


class MaskSubclassTest(unittest.TestCase):
    """Test subclassed Masks."""

    def test_subclass_mask(self):
        """Ensures the Mask class can be subclassed."""
        mask = SubMask((5, 3), fill=True)

        self.assertIsInstance(mask, pygame.mask.Mask)
        self.assertIsInstance(mask, SubMask)
        self.assertTrue(mask.test_attribute)

    def test_subclass_copy(self):
        """Ensures copy works for subclassed Masks."""
        mask = SubMask((65, 2), fill=True)

        # Test both the copy() and __copy__() methods.
        for mask_copy in (mask.copy(), copy.copy(mask)):
            self.assertIsInstance(mask_copy, pygame.mask.Mask)
            self.assertIsInstance(mask_copy, SubMask)
            self.assertIsNot(mask_copy, mask)
            assertMaskEqual(self, mask_copy, mask)
            # No subclass attributes because copy()/__copy__() not overridden.
            self.assertFalse(hasattr(mask_copy, "test_attribute"))

    def test_subclass_copy__override_copy(self):
        """Ensures copy works for subclassed Masks overriding copy."""
        mask = SubMaskCopy((65, 2), fill=True)

        # Test both the copy() and __copy__() methods.
        for i, mask_copy in enumerate((mask.copy(), copy.copy(mask))):
            self.assertIsInstance(mask_copy, pygame.mask.Mask)
            self.assertIsInstance(mask_copy, SubMaskCopy)
            self.assertIsNot(mask_copy, mask)
            assertMaskEqual(self, mask_copy, mask)

            if 1 == i:
                # No subclass attributes because __copy__() not overridden.
                self.assertFalse(hasattr(mask_copy, "test_attribute"))
            else:
                self.assertTrue(mask_copy.test_attribute)

    def test_subclass_copy__override_dunder_copy(self):
        """Ensures copy works for subclassed Masks overriding __copy__."""
        mask = SubMaskDunderCopy((65, 2), fill=True)

        # Test both the copy() and __copy__() methods.
        for mask_copy in (mask.copy(), copy.copy(mask)):
            self.assertIsInstance(mask_copy, pygame.mask.Mask)
            self.assertIsInstance(mask_copy, SubMaskDunderCopy)
            self.assertIsNot(mask_copy, mask)
            assertMaskEqual(self, mask_copy, mask)
            # Calls to copy() eventually call __copy__() internally so the
            # attributes will be copied.
            self.assertTrue(mask_copy.test_attribute)

    def test_subclass_copy__override_both_copy_methods(self):
        """Ensures copy works for subclassed Masks overriding copy/__copy__."""
        mask = SubMaskCopyAndDunderCopy((65, 2), fill=True)

        # Test both the copy() and __copy__() methods.
        for mask_copy in (mask.copy(), copy.copy(mask)):
            self.assertIsInstance(mask_copy, pygame.mask.Mask)
            self.assertIsInstance(mask_copy, SubMaskCopyAndDunderCopy)
            self.assertIsNot(mask_copy, mask)
            assertMaskEqual(self, mask_copy, mask)
            self.assertTrue(mask_copy.test_attribute)

    def test_subclass_get_size(self):
        """Ensures get_size works for subclassed Masks."""
        expected_size = (2, 3)
        mask = SubMask(expected_size)

        size = mask.get_size()

        self.assertEqual(size, expected_size)

    def test_subclass_mask_get_rect(self):
        """Ensures get_rect works for subclassed Masks."""
        expected_rect = pygame.Rect((0, 0), (65, 33))
        mask = SubMask(expected_rect.size, fill=True)

        rect = mask.get_rect()

        self.assertEqual(rect, expected_rect)

    def test_subclass_get_at(self):
        """Ensures get_at works for subclassed Masks."""
        expected_bit = 1
        mask = SubMask((3, 2), fill=True)

        bit = mask.get_at((0, 0))

        self.assertEqual(bit, expected_bit)

    def test_subclass_set_at(self):
        """Ensures set_at works for subclassed Masks."""
        expected_bit = 1
        expected_count = 1
        pos = (0, 0)
        mask = SubMask(fill=False, size=(4, 2))

        mask.set_at(pos)

        self.assertEqual(mask.get_at(pos), expected_bit)
        self.assertEqual(mask.count(), expected_count)

    def test_subclass_overlap(self):
        """Ensures overlap works for subclassed Masks."""
        expected_pos = (0, 0)
        mask_size = (2, 3)
        masks = (pygame.mask.Mask(fill=True, size=mask_size), SubMask(mask_size, True))
        arg_masks = (
            pygame.mask.Mask(fill=True, size=mask_size),
            SubMask(mask_size, True),
        )

        # Test different combinations of subclassed and non-subclassed Masks.
        for mask in masks:
            for arg_mask in arg_masks:
                overlap_pos = mask.overlap(arg_mask, (0, 0))

                self.assertEqual(overlap_pos, expected_pos)

    def test_subclass_overlap_area(self):
        """Ensures overlap_area works for subclassed Masks."""
        mask_size = (3, 2)
        expected_count = mask_size[0] * mask_size[1]
        masks = (pygame.mask.Mask(fill=True, size=mask_size), SubMask(mask_size, True))
        arg_masks = (
            pygame.mask.Mask(fill=True, size=mask_size),
            SubMask(mask_size, True),
        )

        # Test different combinations of subclassed and non-subclassed Masks.
        for mask in masks:
            for arg_mask in arg_masks:
                overlap_count = mask.overlap_area(arg_mask, (0, 0))

                self.assertEqual(overlap_count, expected_count)

    def test_subclass_overlap_mask(self):
        """Ensures overlap_mask works for subclassed Masks."""
        expected_size = (4, 5)
        expected_count = expected_size[0] * expected_size[1]
        masks = (
            pygame.mask.Mask(fill=True, size=expected_size),
            SubMask(expected_size, True),
        )
        arg_masks = (
            pygame.mask.Mask(fill=True, size=expected_size),
            SubMask(expected_size, True),
        )

        # Test different combinations of subclassed and non-subclassed Masks.
        for mask in masks:
            for arg_mask in arg_masks:
                overlap_mask = mask.overlap_mask(arg_mask, (0, 0))

                self.assertIsInstance(overlap_mask, pygame.mask.Mask)
                self.assertNotIsInstance(overlap_mask, SubMask)
                self.assertEqual(overlap_mask.count(), expected_count)
                self.assertEqual(overlap_mask.get_size(), expected_size)

    def test_subclass_fill(self):
        """Ensures fill works for subclassed Masks."""
        mask_size = (2, 4)
        expected_count = mask_size[0] * mask_size[1]
        mask = SubMask(fill=False, size=mask_size)

        mask.fill()

        self.assertEqual(mask.count(), expected_count)

    def test_subclass_clear(self):
        """Ensures clear works for subclassed Masks."""
        mask_size = (4, 3)
        expected_count = 0
        mask = SubMask(mask_size, True)

        mask.clear()

        self.assertEqual(mask.count(), expected_count)

    def test_subclass_invert(self):
        """Ensures invert works for subclassed Masks."""
        mask_size = (1, 4)
        expected_count = mask_size[0] * mask_size[1]
        mask = SubMask(fill=False, size=mask_size)

        mask.invert()

        self.assertEqual(mask.count(), expected_count)

    def test_subclass_scale(self):
        """Ensures scale works for subclassed Masks."""
        expected_size = (5, 2)
        mask = SubMask((1, 4))

        scaled_mask = mask.scale(expected_size)

        self.assertIsInstance(scaled_mask, pygame.mask.Mask)
        self.assertNotIsInstance(scaled_mask, SubMask)
        self.assertEqual(scaled_mask.get_size(), expected_size)

    def test_subclass_draw(self):
        """Ensures draw works for subclassed Masks."""
        mask_size = (5, 4)
        expected_count = mask_size[0] * mask_size[1]
        arg_masks = (
            pygame.mask.Mask(fill=True, size=mask_size),
            SubMask(mask_size, True),
        )

        # Test different combinations of subclassed and non-subclassed Masks.
        for mask in (pygame.mask.Mask(mask_size), SubMask(mask_size)):
            for arg_mask in arg_masks:
                mask.clear()  # Clear for each test.

                mask.draw(arg_mask, (0, 0))

                self.assertEqual(mask.count(), expected_count)

    def test_subclass_erase(self):
        """Ensures erase works for subclassed Masks."""
        mask_size = (3, 4)
        expected_count = 0
        masks = (pygame.mask.Mask(mask_size, True), SubMask(mask_size, True))
        arg_masks = (pygame.mask.Mask(mask_size, True), SubMask(mask_size, True))

        # Test different combinations of subclassed and non-subclassed Masks.
        for mask in masks:
            for arg_mask in arg_masks:
                mask.fill()  # Fill for each test.

                mask.erase(arg_mask, (0, 0))

                self.assertEqual(mask.count(), expected_count)

    def test_subclass_count(self):
        """Ensures count works for subclassed Masks."""
        mask_size = (5, 2)
        expected_count = mask_size[0] * mask_size[1] - 1
        mask = SubMask(fill=True, size=mask_size)
        mask.set_at((1, 1), 0)

        count = mask.count()

        self.assertEqual(count, expected_count)

    def test_subclass_centroid(self):
        """Ensures centroid works for subclassed Masks."""
        expected_centroid = (0, 0)
        mask_size = (3, 2)
        mask = SubMask((3, 2))

        centroid = mask.centroid()

        self.assertEqual(centroid, expected_centroid)

    def test_subclass_angle(self):
        """Ensures angle works for subclassed Masks."""
        expected_angle = 0.0
        mask = SubMask(size=(5, 4))

        angle = mask.angle()

        self.assertAlmostEqual(angle, expected_angle)

    def test_subclass_outline(self):
        """Ensures outline works for subclassed Masks."""
        expected_outline = []
        mask = SubMask((3, 4))

        outline = mask.outline()

        self.assertListEqual(outline, expected_outline)

    def test_subclass_convolve(self):
        """Ensures convolve works for subclassed Masks."""
        width, height = 7, 5
        mask_size = (width, height)
        expected_count = 0
        expected_size = (max(0, width * 2 - 1), max(0, height * 2 - 1))

        arg_masks = (pygame.mask.Mask(mask_size), SubMask(mask_size))
        output_masks = (pygame.mask.Mask(mask_size), SubMask(mask_size))

        # Test different combinations of subclassed and non-subclassed Masks.
        for mask in (pygame.mask.Mask(mask_size), SubMask(mask_size)):
            for arg_mask in arg_masks:
                convolve_mask = mask.convolve(arg_mask)

                self.assertIsInstance(convolve_mask, pygame.mask.Mask)
                self.assertNotIsInstance(convolve_mask, SubMask)
                self.assertEqual(convolve_mask.count(), expected_count)
                self.assertEqual(convolve_mask.get_size(), expected_size)

                # Test subclassed masks for the output_mask as well.
                for output_mask in output_masks:
                    convolve_mask = mask.convolve(arg_mask, output_mask)

                    self.assertIsInstance(convolve_mask, pygame.mask.Mask)
                    self.assertEqual(convolve_mask.count(), expected_count)
                    self.assertEqual(convolve_mask.get_size(), mask_size)

                    if isinstance(output_mask, SubMask):
                        self.assertIsInstance(convolve_mask, SubMask)
                    else:
                        self.assertNotIsInstance(convolve_mask, SubMask)

    def test_subclass_connected_component(self):
        """Ensures connected_component works for subclassed Masks."""
        expected_count = 0
        expected_size = (3, 4)
        mask = SubMask(expected_size)

        cc_mask = mask.connected_component()

        self.assertIsInstance(cc_mask, pygame.mask.Mask)
        self.assertNotIsInstance(cc_mask, SubMask)
        self.assertEqual(cc_mask.count(), expected_count)
        self.assertEqual(cc_mask.get_size(), expected_size)

    def test_subclass_connected_components(self):
        """Ensures connected_components works for subclassed Masks."""
        expected_ccs = []
        mask = SubMask((5, 4))

        ccs = mask.connected_components()

        self.assertListEqual(ccs, expected_ccs)

    def test_subclass_get_bounding_rects(self):
        """Ensures get_bounding_rects works for subclassed Masks."""
        expected_bounding_rects = []
        mask = SubMask((3, 2))

        bounding_rects = mask.get_bounding_rects()

        self.assertListEqual(bounding_rects, expected_bounding_rects)

    def test_subclass_to_surface(self):
        """Ensures to_surface works for subclassed Masks."""
        expected_color = pygame.Color("blue")
        size = (5, 3)
        mask = SubMask(size, fill=True)
        surface = pygame.Surface(size, SRCALPHA, 32)
        surface.fill(pygame.Color("red"))

        to_surface = mask.to_surface(surface, setcolor=expected_color)

        self.assertIs(to_surface, surface)
        self.assertEqual(to_surface.get_size(), size)
        assertSurfaceFilled(self, to_surface, expected_color)


@unittest.skipIf(IS_PYPY, "pypy has lots of mask failures")  # TODO
class MaskModuleTest(unittest.TestCase):
    def test_from_surface(self):
        """Ensures from_surface creates a mask with the correct bits set.

        This test checks the masks created by the from_surface function using
        16 and 32 bit surfaces. Each alpha value (0-255) is tested against
        several different threshold values.
        Note: On 16 bit surface the requested alpha value can differ from what
              is actually set. This test uses the value read from the surface.
        """
        threshold_count = 256
        surface_color = [55, 155, 255, 0]
        expected_size = (11, 9)
        all_set_count = expected_size[0] * expected_size[1]
        none_set_count = 0

        for depth in (16, 32):
            surface = pygame.Surface(expected_size, SRCALPHA, depth)

            for alpha in range(threshold_count):
                surface_color[3] = alpha
                surface.fill(surface_color)

                if depth < 32:
                    # On surfaces with depths < 32 the requested alpha can be
                    # different than what gets set. Use the value read from the
                    # surface.
                    alpha = surface.get_at((0, 0))[3]

                # Test the mask created at threshold values low, high and
                # around alpha.
                threshold_test_values = set(
                    [-1, 0, alpha - 1, alpha, alpha + 1, 255, 256]
                )

                for threshold in threshold_test_values:
                    msg = "depth={}, alpha={}, threshold={}".format(
                        depth, alpha, threshold
                    )

                    if alpha > threshold:
                        expected_count = all_set_count
                    else:
                        expected_count = none_set_count

                    mask = pygame.mask.from_surface(
                        surface=surface, threshold=threshold
                    )

                    self.assertIsInstance(mask, pygame.mask.Mask, msg)
                    self.assertEqual(mask.get_size(), expected_size, msg)
                    self.assertEqual(mask.count(), expected_count, msg)

    def test_from_surface__different_alphas_32bit(self):
        """Ensures from_surface creates a mask with the correct bits set
        when pixels have different alpha values (32 bits surfaces).

        This test checks the masks created by the from_surface function using
        a 32 bit surface. The surface is created with each pixel having a
        different alpha value (0-255). This surface is tested over a range
        of threshold values (0-255).
        """
        offset = (0, 0)
        threshold_count = 256
        surface_color = [10, 20, 30, 0]
        expected_size = (threshold_count, 1)
        expected_mask = pygame.Mask(expected_size, fill=True)
        surface = pygame.Surface(expected_size, SRCALPHA, 32)

        # Give each pixel a different alpha.
        surface.lock()  # Lock for possible speed up.
        for a in range(threshold_count):
            surface_color[3] = a
            surface.set_at((a, 0), surface_color)
        surface.unlock()

        # Test the mask created for each different alpha threshold.
        for threshold in range(threshold_count):
            msg = "threshold={}".format(threshold)
            expected_mask.set_at((threshold, 0), 0)
            expected_count = expected_mask.count()

            mask = pygame.mask.from_surface(surface, threshold)

            self.assertIsInstance(mask, pygame.mask.Mask, msg)
            self.assertEqual(mask.get_size(), expected_size, msg)
            self.assertEqual(mask.count(), expected_count, msg)
            self.assertEqual(
                mask.overlap_area(expected_mask, offset), expected_count, msg
            )

    def test_from_surface__different_alphas_16bit(self):
        """Ensures from_surface creates a mask with the correct bits set
        when pixels have different alpha values (16 bit surfaces).

        This test checks the masks created by the from_surface function using
        a 16 bit surface. Each pixel of the surface is set with a different
        alpha value (0-255), but since this is a 16 bit surface the requested
        alpha value can differ from what is actually set. The resulting surface
        will have groups of alpha values which complicates the test as the
        alpha groups will all be set/unset at a given threshold. The setup
        calculates these groups and an expected mask for each. This test data
        is then used to test each alpha grouping over a range of threshold
        values.
        """
        threshold_count = 256
        surface_color = [110, 120, 130, 0]
        expected_size = (threshold_count, 1)
        surface = pygame.Surface(expected_size, SRCALPHA, 16)

        # Give each pixel a different alpha.
        surface.lock()  # Lock for possible speed up.
        for a in range(threshold_count):
            surface_color[3] = a
            surface.set_at((a, 0), surface_color)
        surface.unlock()

        alpha_thresholds = OrderedDict()
        special_thresholds = set()

        # Create the threshold ranges and identify any thresholds that need
        # special handling.
        for threshold in range(threshold_count):
            # On surfaces with depths < 32 the requested alpha can be different
            # than what gets set. Use the value read from the surface.
            alpha = surface.get_at((threshold, 0))[3]

            if alpha not in alpha_thresholds:
                alpha_thresholds[alpha] = [threshold]
            else:
                alpha_thresholds[alpha].append(threshold)

            if threshold < alpha:
                special_thresholds.add(threshold)

        # Use each threshold group to create an expected mask.
        test_data = []  # [(from_threshold, to_threshold, expected_mask), ...]
        offset = (0, 0)
        erase_mask = pygame.Mask(expected_size)
        exp_mask = pygame.Mask(expected_size, fill=True)

        for thresholds in alpha_thresholds.values():
            for threshold in thresholds:
                if threshold in special_thresholds:
                    # Any special thresholds just reuse previous exp_mask.
                    test_data.append((threshold, threshold + 1, exp_mask))
                else:
                    to_threshold = thresholds[-1] + 1

                    # Make the expected mask by erasing the unset bits.
                    for thres in range(to_threshold):
                        erase_mask.set_at((thres, 0), 1)

                    exp_mask = pygame.Mask(expected_size, fill=True)
                    exp_mask.erase(erase_mask, offset)
                    test_data.append((threshold, to_threshold, exp_mask))
                    break

        # All the setup is done. Now test the masks created over the threshold
        # ranges.
        for from_threshold, to_threshold, expected_mask in test_data:
            expected_count = expected_mask.count()

            for threshold in range(from_threshold, to_threshold):
                msg = "threshold={}".format(threshold)

                mask = pygame.mask.from_surface(surface, threshold)

                self.assertIsInstance(mask, pygame.mask.Mask, msg)
                self.assertEqual(mask.get_size(), expected_size, msg)
                self.assertEqual(mask.count(), expected_count, msg)
                self.assertEqual(
                    mask.overlap_area(expected_mask, offset), expected_count, msg
                )

    def test_from_surface__with_colorkey_mask_cleared(self):
        """Ensures from_surface creates a mask with the correct bits set
        when the surface uses a colorkey.

        The surface is filled with the colorkey color so the resulting masks
        are expected to have no bits set.
        """
        colorkeys = ((0, 0, 0), (1, 2, 3), (50, 100, 200), (255, 255, 255))
        expected_size = (7, 11)
        expected_count = 0

        for depth in (8, 16, 24, 32):
            msg = "depth={}".format(depth)
            surface = pygame.Surface(expected_size, 0, depth)

            for colorkey in colorkeys:
                surface.set_colorkey(colorkey)
                # With some depths (i.e. 8 and 16) the actual colorkey can be
                # different than what was requested via the set.
                surface.fill(surface.get_colorkey())

                mask = pygame.mask.from_surface(surface)

                self.assertIsInstance(mask, pygame.mask.Mask, msg)
                self.assertEqual(mask.get_size(), expected_size, msg)
                self.assertEqual(mask.count(), expected_count, msg)

    def test_from_surface__with_colorkey_mask_filled(self):
        """Ensures from_surface creates a mask with the correct bits set
        when the surface uses a colorkey.

        The surface is filled with a color that is not the colorkey color so
        the resulting masks are expected to have all bits set.
        """
        colorkeys = ((0, 0, 0), (1, 2, 3), (10, 100, 200), (255, 255, 255))
        surface_color = (50, 100, 200)
        expected_size = (11, 7)
        expected_count = expected_size[0] * expected_size[1]

        for depth in (8, 16, 24, 32):
            msg = "depth={}".format(depth)
            surface = pygame.Surface(expected_size, 0, depth)
            surface.fill(surface_color)

            for colorkey in colorkeys:
                surface.set_colorkey(colorkey)

                mask = pygame.mask.from_surface(surface)

                self.assertIsInstance(mask, pygame.mask.Mask, msg)
                self.assertEqual(mask.get_size(), expected_size, msg)
                self.assertEqual(mask.count(), expected_count, msg)

    def test_from_surface__with_colorkey_mask_pattern(self):
        """Ensures from_surface creates a mask with the correct bits set
        when the surface uses a colorkey.

        The surface is filled with alternating pixels of colorkey and
        non-colorkey colors, so the resulting masks are expected to have
        alternating bits set.
        """

        def alternate(func, set_value, unset_value, width, height):
            # Helper function to set alternating values.
            setbit = False
            for pos in ((x, y) for x in range(width) for y in range(height)):
                func(pos, set_value if setbit else unset_value)
                setbit = not setbit

        surface_color = (5, 10, 20)
        colorkey = (50, 60, 70)
        expected_size = (11, 2)
        expected_mask = pygame.mask.Mask(expected_size)
        alternate(expected_mask.set_at, 1, 0, *expected_size)
        expected_count = expected_mask.count()
        offset = (0, 0)

        for depth in (8, 16, 24, 32):
            msg = "depth={}".format(depth)
            surface = pygame.Surface(expected_size, 0, depth)
            # Fill the surface with alternating colors.
            alternate(surface.set_at, surface_color, colorkey, *expected_size)
            surface.set_colorkey(colorkey)

            mask = pygame.mask.from_surface(surface)

            self.assertIsInstance(mask, pygame.mask.Mask, msg)
            self.assertEqual(mask.get_size(), expected_size, msg)
            self.assertEqual(mask.count(), expected_count, msg)
            self.assertEqual(
                mask.overlap_area(expected_mask, offset), expected_count, msg
            )

    def test_from_threshold(self):
        """Does mask.from_threshold() work correctly?"""

        a = [16, 24, 32]

        for i in a:
            surf = pygame.surface.Surface((70, 70), 0, i)
            surf.fill((100, 50, 200), (20, 20, 20, 20))
            mask = pygame.mask.from_threshold(
                surf, (100, 50, 200, 255), (10, 10, 10, 255)
            )

            rects = mask.get_bounding_rects()

            self.assertEqual(mask.count(), 400)
            self.assertEqual(mask.get_bounding_rects(), [pygame.Rect((20, 20, 20, 20))])

        for i in a:
            surf = pygame.surface.Surface((70, 70), 0, i)
            surf2 = pygame.surface.Surface((70, 70), 0, i)
            surf.fill((100, 100, 100))
            surf2.fill((150, 150, 150))
            surf2.fill((100, 100, 100), (40, 40, 10, 10))
            mask = pygame.mask.from_threshold(
                surface=surf,
                color=(0, 0, 0, 0),
                threshold=(10, 10, 10, 255),
                othersurface=surf2,
            )

            self.assertIsInstance(mask, pygame.mask.Mask)
            self.assertEqual(mask.count(), 100)
            self.assertEqual(mask.get_bounding_rects(), [pygame.Rect((40, 40, 10, 10))])

    def test_zero_size_from_surface(self):
        """Ensures from_surface can create masks from zero sized surfaces."""
        for size in ((100, 0), (0, 100), (0, 0)):
            mask = pygame.mask.from_surface(pygame.Surface(size))

            self.assertIsInstance(mask, pygame.mask.MaskType, "size={}".format(size))
            self.assertEqual(mask.get_size(), size)

    def test_zero_size_from_threshold(self):
        a = [16, 24, 32]
        sizes = ((100, 0), (0, 100), (0, 0))

        for size in sizes:
            for i in a:
                surf = pygame.surface.Surface(size, 0, i)
                surf.fill((100, 50, 200), (20, 20, 20, 20))
                mask = pygame.mask.from_threshold(
                    surf, (100, 50, 200, 255), (10, 10, 10, 255)
                )

                self.assertEqual(mask.count(), 0)

                rects = mask.get_bounding_rects()
                self.assertEqual(rects, [])

            for i in a:
                surf = pygame.surface.Surface(size, 0, i)
                surf2 = pygame.surface.Surface(size, 0, i)
                surf.fill((100, 100, 100))
                surf2.fill((150, 150, 150))
                surf2.fill((100, 100, 100), (40, 40, 10, 10))
                mask = pygame.mask.from_threshold(
                    surf, (0, 0, 0, 0), (10, 10, 10, 255), surf2
                )

                self.assertIsInstance(mask, pygame.mask.Mask)
                self.assertEqual(mask.count(), 0)

                rects = mask.get_bounding_rects()
                self.assertEqual(rects, [])

    def test_buffer_interface(self):
        size = (1000, 100)
        pixels_set = ((0, 1), (100, 10), (173, 90))
        pixels_unset = ((0, 0), (101, 10), (173, 91))

        mask = pygame.Mask(size)
        for point in pixels_set:
            mask.set_at(point, 1)

        view = memoryview(mask)
        intwidth = 8 * view.strides[1]

        for point in pixels_set:
            x, y = point
            col = x // intwidth
            self.assertEqual(
                (view[col, y] >> (x % intwidth)) & 1,
                1,
                "the pixel at {} is not set to 1".format(point),
            )

        for point in pixels_unset:
            x, y = point
            col = x // intwidth
            self.assertEqual(
                (view[col, y] >> (x % intwidth)) & 1,
                0,
                "the pixel at {} is not set to 0".format(point),
            )


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