import math
import operator
import platform
import unittest
from collections.abc import Collection, Sequence

import pygame
from pygame.colordict import THECOLORS

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

rgba_vals = [0, 1, 62, 63, 126, 127, 255]

rgba_combinations = [
    (r, g, b, a)
    for r in rgba_vals
    for g in rgba_vals
    for b in rgba_vals
    for a in rgba_vals
]

################################################################################


def rgba_combos_Color_generator():
    for rgba in rgba_combinations:
        yield pygame.Color(*rgba)


# Python gamma correct
def gamma_correct(rgba_0_255, gamma):
    corrected = round(255.0 * math.pow(rgba_0_255 / 255.0, gamma))
    return max(min(int(corrected), 255), 0)


################################################################################

# TODO: add tests for
# correct_gamma()  -- test against statically defined verified correct values
# coerce ()        --  ??


def _assignr(x, y):
    x.r = y


def _assigng(x, y):
    x.g = y


def _assignb(x, y):
    x.b = y


def _assigna(x, y):
    x.a = y


def _assign_item(x, p, y):
    x[p] = y


class ColorTypeTest(unittest.TestCase):
    def test_new(self):
        c = pygame.Color.__new__(pygame.Color)
        self.assertEqual(c, pygame.Color(0, 0, 0, 255))
        self.assertEqual(len(c), 4)

    def test_init(self):
        c = pygame.Color(10, 20, 30, 200)
        self.assertEqual(c, (10, 20, 30, 200))
        c.set_length(3)
        self.assertEqual(len(c), 3)
        c.__init__(100, 110, 120, 128)
        self.assertEqual(len(c), 4)
        self.assertEqual(c, (100, 110, 120, 128))

    def test_invalid_html_hex_codes(self):
        # This was a problem with the way 2 digit hex numbers were
        # calculated. The test_hex_digits test is related to the fix.
        Color = pygame.color.Color
        self.assertRaises(ValueError, lambda: Color("# f000000"))
        self.assertRaises(ValueError, lambda: Color("#f 000000"))
        self.assertRaises(ValueError, lambda: Color("#-f000000"))

    def test_hex_digits(self):
        # This is an implementation specific test.
        # Two digit hex numbers are calculated using table lookups
        # for the upper and lower digits.
        Color = pygame.color.Color
        self.assertEqual(Color("#00000000").r, 0x00)
        self.assertEqual(Color("#10000000").r, 0x10)
        self.assertEqual(Color("#20000000").r, 0x20)
        self.assertEqual(Color("#30000000").r, 0x30)
        self.assertEqual(Color("#40000000").r, 0x40)
        self.assertEqual(Color("#50000000").r, 0x50)
        self.assertEqual(Color("#60000000").r, 0x60)
        self.assertEqual(Color("#70000000").r, 0x70)
        self.assertEqual(Color("#80000000").r, 0x80)
        self.assertEqual(Color("#90000000").r, 0x90)
        self.assertEqual(Color("#A0000000").r, 0xA0)
        self.assertEqual(Color("#B0000000").r, 0xB0)
        self.assertEqual(Color("#C0000000").r, 0xC0)
        self.assertEqual(Color("#D0000000").r, 0xD0)
        self.assertEqual(Color("#E0000000").r, 0xE0)
        self.assertEqual(Color("#F0000000").r, 0xF0)
        self.assertEqual(Color("#01000000").r, 0x01)
        self.assertEqual(Color("#02000000").r, 0x02)
        self.assertEqual(Color("#03000000").r, 0x03)
        self.assertEqual(Color("#04000000").r, 0x04)
        self.assertEqual(Color("#05000000").r, 0x05)
        self.assertEqual(Color("#06000000").r, 0x06)
        self.assertEqual(Color("#07000000").r, 0x07)
        self.assertEqual(Color("#08000000").r, 0x08)
        self.assertEqual(Color("#09000000").r, 0x09)
        self.assertEqual(Color("#0A000000").r, 0x0A)
        self.assertEqual(Color("#0B000000").r, 0x0B)
        self.assertEqual(Color("#0C000000").r, 0x0C)
        self.assertEqual(Color("#0D000000").r, 0x0D)
        self.assertEqual(Color("#0E000000").r, 0x0E)
        self.assertEqual(Color("#0F000000").r, 0x0F)

    def test_comparison(self):
        Color = pygame.color.Color

        # Check valid comparisons
        self.assertTrue(Color(255, 0, 0, 0) == Color(255, 0, 0, 0))
        self.assertTrue(Color(0, 255, 0, 0) == Color(0, 255, 0, 0))
        self.assertTrue(Color(0, 0, 255, 0) == Color(0, 0, 255, 0))
        self.assertTrue(Color(0, 0, 0, 255) == Color(0, 0, 0, 255))
        self.assertFalse(Color(0, 0, 0, 0) == Color(255, 0, 0, 0))
        self.assertFalse(Color(0, 0, 0, 0) == Color(0, 255, 0, 0))
        self.assertFalse(Color(0, 0, 0, 0) == Color(0, 0, 255, 0))
        self.assertFalse(Color(0, 0, 0, 0) == Color(0, 0, 0, 255))
        self.assertTrue(Color(0, 0, 0, 0) != Color(255, 0, 0, 0))
        self.assertTrue(Color(0, 0, 0, 0) != Color(0, 255, 0, 0))
        self.assertTrue(Color(0, 0, 0, 0) != Color(0, 0, 255, 0))
        self.assertTrue(Color(0, 0, 0, 0) != Color(0, 0, 0, 255))
        self.assertFalse(Color(255, 0, 0, 0) != Color(255, 0, 0, 0))
        self.assertFalse(Color(0, 255, 0, 0) != Color(0, 255, 0, 0))
        self.assertFalse(Color(0, 0, 255, 0) != Color(0, 0, 255, 0))
        self.assertFalse(Color(0, 0, 0, 255) != Color(0, 0, 0, 255))

        self.assertTrue(Color(255, 0, 0, 0) == (255, 0, 0, 0))
        self.assertTrue(Color(0, 255, 0, 0) == (0, 255, 0, 0))
        self.assertTrue(Color(0, 0, 255, 0) == (0, 0, 255, 0))
        self.assertTrue(Color(0, 0, 0, 255) == (0, 0, 0, 255))
        self.assertFalse(Color(0, 0, 0, 0) == (255, 0, 0, 0))
        self.assertFalse(Color(0, 0, 0, 0) == (0, 255, 0, 0))
        self.assertFalse(Color(0, 0, 0, 0) == (0, 0, 255, 0))
        self.assertFalse(Color(0, 0, 0, 0) == (0, 0, 0, 255))
        self.assertTrue(Color(0, 0, 0, 0) != (255, 0, 0, 0))
        self.assertTrue(Color(0, 0, 0, 0) != (0, 255, 0, 0))
        self.assertTrue(Color(0, 0, 0, 0) != (0, 0, 255, 0))
        self.assertTrue(Color(0, 0, 0, 0) != (0, 0, 0, 255))
        self.assertFalse(Color(255, 0, 0, 0) != (255, 0, 0, 0))
        self.assertFalse(Color(0, 255, 0, 0) != (0, 255, 0, 0))
        self.assertFalse(Color(0, 0, 255, 0) != (0, 0, 255, 0))
        self.assertFalse(Color(0, 0, 0, 255) != (0, 0, 0, 255))

        self.assertTrue((255, 0, 0, 0) == Color(255, 0, 0, 0))
        self.assertTrue((0, 255, 0, 0) == Color(0, 255, 0, 0))
        self.assertTrue((0, 0, 255, 0) == Color(0, 0, 255, 0))
        self.assertTrue((0, 0, 0, 255) == Color(0, 0, 0, 255))
        self.assertFalse((0, 0, 0, 0) == Color(255, 0, 0, 0))
        self.assertFalse((0, 0, 0, 0) == Color(0, 255, 0, 0))
        self.assertFalse((0, 0, 0, 0) == Color(0, 0, 255, 0))
        self.assertFalse((0, 0, 0, 0) == Color(0, 0, 0, 255))
        self.assertTrue((0, 0, 0, 0) != Color(255, 0, 0, 0))
        self.assertTrue((0, 0, 0, 0) != Color(0, 255, 0, 0))
        self.assertTrue((0, 0, 0, 0) != Color(0, 0, 255, 0))
        self.assertTrue((0, 0, 0, 0) != Color(0, 0, 0, 255))
        self.assertFalse((255, 0, 0, 0) != Color(255, 0, 0, 0))
        self.assertFalse((0, 255, 0, 0) != Color(0, 255, 0, 0))
        self.assertFalse((0, 0, 255, 0) != Color(0, 0, 255, 0))
        self.assertFalse((0, 0, 0, 255) != Color(0, 0, 0, 255))

        class TupleSubclass(tuple):
            pass

        self.assertTrue(Color(255, 0, 0, 0) == TupleSubclass((255, 0, 0, 0)))
        self.assertTrue(TupleSubclass((255, 0, 0, 0)) == Color(255, 0, 0, 0))
        self.assertFalse(Color(255, 0, 0, 0) != TupleSubclass((255, 0, 0, 0)))
        self.assertFalse(TupleSubclass((255, 0, 0, 0)) != Color(255, 0, 0, 0))

        # These are not supported so will be unequal.
        self.assertFalse(Color(255, 0, 0, 0) == "#ff000000")
        self.assertTrue(Color(255, 0, 0, 0) != "#ff000000")

        self.assertFalse("#ff000000" == Color(255, 0, 0, 0))
        self.assertTrue("#ff000000" != Color(255, 0, 0, 0))

        self.assertFalse(Color(255, 0, 0, 0) == 0xFF000000)
        self.assertTrue(Color(255, 0, 0, 0) != 0xFF000000)

        self.assertFalse(0xFF000000 == Color(255, 0, 0, 0))
        self.assertTrue(0xFF000000 != Color(255, 0, 0, 0))

        self.assertFalse(Color(255, 0, 0, 0) == [255, 0, 0, 0])
        self.assertTrue(Color(255, 0, 0, 0) != [255, 0, 0, 0])

        self.assertFalse([255, 0, 0, 0] == Color(255, 0, 0, 0))
        self.assertTrue([255, 0, 0, 0] != Color(255, 0, 0, 0))

        # Comparison is not implemented for invalid color values.
        class Test:
            def __eq__(self, other):
                return -1

            def __ne__(self, other):
                return -2

        class TestTuple(tuple):
            def __eq__(self, other):
                return -1

            def __ne__(self, other):
                return -2

        t = Test()
        t_tuple = TestTuple(("a", 0, 0, 0))
        black = Color("black")
        self.assertEqual(black == t, -1)
        self.assertEqual(t == black, -1)
        self.assertEqual(black != t, -2)
        self.assertEqual(t != black, -2)
        self.assertEqual(black == t_tuple, -1)
        self.assertEqual(black != t_tuple, -2)
        self.assertEqual(t_tuple == black, -1)
        self.assertEqual(t_tuple != black, -2)

    def test_ignore_whitespace(self):
        self.assertEqual(pygame.color.Color("red"), pygame.color.Color(" r e d "))

    def test_slice(self):
        # """|tags: python3_ignore|"""

        # slicing a color gives you back a tuple.
        # do all sorts of slice combinations.
        c = pygame.Color(1, 2, 3, 4)

        self.assertEqual((1, 2, 3, 4), c[:])
        self.assertEqual((1, 2, 3), c[:-1])

        self.assertEqual((), c[:-5])

        self.assertEqual((1, 2, 3, 4), c[:4])
        self.assertEqual((1, 2, 3, 4), c[:5])
        self.assertEqual((1, 2), c[:2])
        self.assertEqual((1,), c[:1])
        self.assertEqual((), c[:0])

        self.assertEqual((2,), c[1:-2])
        self.assertEqual((3, 4), c[-2:])
        self.assertEqual((4,), c[-1:])

        # NOTE: assigning to a slice is currently unsupported.

    def test_unpack(self):
        # should be able to unpack to r,g,b,a and r,g,b
        c = pygame.Color(1, 2, 3, 4)
        r, g, b, a = c
        self.assertEqual((1, 2, 3, 4), (r, g, b, a))
        self.assertEqual(c, (r, g, b, a))

        c.set_length(3)
        r, g, b = c
        self.assertEqual((1, 2, 3), (r, g, b))

        # Checking if DeprecationWarning is triggered
        # when function is called
        for i in range(1, 5):
            with self.assertWarns(DeprecationWarning):
                c.set_length(i)

    def test_length(self):
        # should be able to unpack to r,g,b,a and r,g,b
        c = pygame.Color(1, 2, 3, 4)
        self.assertEqual(len(c), 4)

        c.set_length(3)
        self.assertEqual(len(c), 3)

        # it keeps the old alpha anyway...
        self.assertEqual(c.a, 4)

        # however you can't get the alpha in this way:
        self.assertRaises(IndexError, lambda x: c[x], 4)

        c.set_length(4)
        self.assertEqual(len(c), 4)
        self.assertEqual(len(c), 4)

        self.assertRaises(ValueError, c.set_length, 5)
        self.assertRaises(ValueError, c.set_length, -1)
        self.assertRaises(ValueError, c.set_length, 0)
        self.assertRaises(ValueError, c.set_length, pow(2, 33))

    def test_case_insensitivity_of_string_args(self):
        self.assertEqual(pygame.color.Color("red"), pygame.color.Color("Red"))

    def test_color(self):
        """Ensures Color objects can be created."""
        color = pygame.Color(0, 0, 0, 0)

        self.assertIsInstance(color, pygame.Color)

    def test_color__rgba_int_args(self):
        """Ensures Color objects can be created using ints."""
        color = pygame.Color(10, 20, 30, 40)

        self.assertEqual(color.r, 10)
        self.assertEqual(color.g, 20)
        self.assertEqual(color.b, 30)
        self.assertEqual(color.a, 40)

    def test_color__rgba_int_args_without_alpha(self):
        """Ensures Color objects can be created without providing alpha."""
        color = pygame.Color(10, 20, 30)

        self.assertEqual(color.r, 10)
        self.assertEqual(color.g, 20)
        self.assertEqual(color.b, 30)
        self.assertEqual(color.a, 255)

    def test_color__rgba_int_args_invalid_value(self):
        """Ensures invalid values are detected when creating Color objects."""
        self.assertRaises(ValueError, pygame.Color, 257, 10, 105, 44)
        self.assertRaises(ValueError, pygame.Color, 10, 257, 105, 44)
        self.assertRaises(ValueError, pygame.Color, 10, 105, 257, 44)
        self.assertRaises(ValueError, pygame.Color, 10, 105, 44, 257)

    def test_color__rgba_int_args_invalid_value_without_alpha(self):
        """Ensures invalid values are detected when creating Color objects
        without providing an alpha.
        """
        self.assertRaises(ValueError, pygame.Color, 256, 10, 105)
        self.assertRaises(ValueError, pygame.Color, 10, 256, 105)
        self.assertRaises(ValueError, pygame.Color, 10, 105, 256)

    def test_color__color_object_arg(self):
        """Ensures Color objects can be created using Color objects."""
        color_args = (10, 20, 30, 40)
        color_obj = pygame.Color(*color_args)

        new_color_obj = pygame.Color(color_obj)

        self.assertIsInstance(new_color_obj, pygame.Color)
        self.assertEqual(new_color_obj, color_obj)
        self.assertEqual(new_color_obj.r, color_args[0])
        self.assertEqual(new_color_obj.g, color_args[1])
        self.assertEqual(new_color_obj.b, color_args[2])
        self.assertEqual(new_color_obj.a, color_args[3])

    def test_color__name_str_arg(self):
        """Ensures Color objects can be created using str names."""
        for name in ("aquamarine3", "AQUAMARINE3", "AqUAmArIne3"):
            color = pygame.Color(name)

            self.assertEqual(color.r, 102)
            self.assertEqual(color.g, 205)
            self.assertEqual(color.b, 170)
            self.assertEqual(color.a, 255)

    def test_color__name_str_arg_from_colordict(self):
        """Ensures Color objects can be created using str names
        from the THECOLORS dict."""
        for name, values in THECOLORS.items():
            color = pygame.Color(name)

            self.assertEqual(color.r, values[0])
            self.assertEqual(color.g, values[1])
            self.assertEqual(color.b, values[2])
            self.assertEqual(color.a, values[3])

    def test_color__html_str_arg(self):
        """Ensures Color objects can be created using html strings."""
        # See test_webstyle() for related tests.
        color = pygame.Color("#a1B2c3D4")

        self.assertEqual(color.r, 0xA1)
        self.assertEqual(color.g, 0xB2)
        self.assertEqual(color.b, 0xC3)
        self.assertEqual(color.a, 0xD4)

    def test_color__hex_str_arg(self):
        """Ensures Color objects can be created using hex strings."""
        # See test_webstyle() for related tests.
        color = pygame.Color("0x1a2B3c4D")

        self.assertEqual(color.r, 0x1A)
        self.assertEqual(color.g, 0x2B)
        self.assertEqual(color.b, 0x3C)
        self.assertEqual(color.a, 0x4D)

    def test_color__int_arg(self):
        """Ensures Color objects can be created using one int value."""
        for value in (0x0, 0xFFFFFFFF, 0xAABBCCDD):
            color = pygame.Color(value)

            self.assertEqual(color.r, (value >> 24) & 0xFF)
            self.assertEqual(color.g, (value >> 16) & 0xFF)
            self.assertEqual(color.b, (value >> 8) & 0xFF)
            self.assertEqual(color.a, value & 0xFF)

    def test_color__int_arg_invalid(self):
        """Ensures invalid int values are detected when creating Color objects."""
        with self.assertRaises(ValueError):
            color = pygame.Color(0x1FFFFFFFF)

    def test_color__sequence_arg(self):
        """Ensures Color objects can be created using tuples/lists."""
        color_values = (33, 44, 55, 66)
        for seq_type in (tuple, list):
            color = pygame.Color(seq_type(color_values))

            self.assertEqual(color.r, color_values[0])
            self.assertEqual(color.g, color_values[1])
            self.assertEqual(color.b, color_values[2])
            self.assertEqual(color.a, color_values[3])

    def test_color__sequence_arg_without_alpha(self):
        """Ensures Color objects can be created using tuples/lists
        without providing an alpha value.
        """
        color_values = (33, 44, 55)
        for seq_type in (tuple, list):
            color = pygame.Color(seq_type(color_values))

            self.assertEqual(color.r, color_values[0])
            self.assertEqual(color.g, color_values[1])
            self.assertEqual(color.b, color_values[2])
            self.assertEqual(color.a, 255)

    def test_color__sequence_arg_invalid_value(self):
        """Ensures invalid sequences are detected when creating Color objects."""
        cls = pygame.Color
        for seq_type in (tuple, list):
            self.assertRaises(ValueError, cls, seq_type((256, 90, 80, 70)))
            self.assertRaises(ValueError, cls, seq_type((100, 256, 80, 70)))
            self.assertRaises(ValueError, cls, seq_type((100, 90, 256, 70)))
            self.assertRaises(ValueError, cls, seq_type((100, 90, 80, 256)))

    def test_color__sequence_arg_invalid_value_without_alpha(self):
        """Ensures invalid sequences are detected when creating Color objects
        without providing an alpha.
        """
        cls = pygame.Color
        for seq_type in (tuple, list):
            self.assertRaises(ValueError, cls, seq_type((256, 90, 80)))
            self.assertRaises(ValueError, cls, seq_type((100, 256, 80)))
            self.assertRaises(ValueError, cls, seq_type((100, 90, 256)))

    def test_color__sequence_arg_invalid_format(self):
        """Ensures invalid sequences are detected when creating Color objects
        with the wrong number of values.
        """
        cls = pygame.Color
        for seq_type in (tuple, list):
            self.assertRaises(ValueError, cls, seq_type((100,)))
            self.assertRaises(ValueError, cls, seq_type((100, 90)))
            self.assertRaises(ValueError, cls, seq_type((100, 90, 80, 70, 60)))

    def test_rgba(self):
        c = pygame.Color(0)
        self.assertEqual(c.r, 0)
        self.assertEqual(c.g, 0)
        self.assertEqual(c.b, 0)
        self.assertEqual(c.a, 0)

        # Test simple assignments
        c.r = 123
        self.assertEqual(c.r, 123)
        self.assertRaises(ValueError, _assignr, c, 537)
        self.assertEqual(c.r, 123)
        self.assertRaises(ValueError, _assignr, c, -3)
        self.assertEqual(c.r, 123)

        c.g = 55
        self.assertEqual(c.g, 55)
        self.assertRaises(ValueError, _assigng, c, 348)
        self.assertEqual(c.g, 55)
        self.assertRaises(ValueError, _assigng, c, -44)
        self.assertEqual(c.g, 55)

        c.b = 77
        self.assertEqual(c.b, 77)
        self.assertRaises(ValueError, _assignb, c, 256)
        self.assertEqual(c.b, 77)
        self.assertRaises(ValueError, _assignb, c, -12)
        self.assertEqual(c.b, 77)

        c.a = 255
        self.assertEqual(c.a, 255)
        self.assertRaises(ValueError, _assigna, c, 312)
        self.assertEqual(c.a, 255)
        self.assertRaises(ValueError, _assigna, c, -10)
        self.assertEqual(c.a, 255)

    def test_repr(self):
        c = pygame.Color(68, 38, 26, 69)
        t = "(68, 38, 26, 69)"
        self.assertEqual(repr(c), t)

    def test_add(self):
        c1 = pygame.Color(0)
        self.assertEqual(c1.r, 0)
        self.assertEqual(c1.g, 0)
        self.assertEqual(c1.b, 0)
        self.assertEqual(c1.a, 0)

        c2 = pygame.Color(20, 33, 82, 193)
        self.assertEqual(c2.r, 20)
        self.assertEqual(c2.g, 33)
        self.assertEqual(c2.b, 82)
        self.assertEqual(c2.a, 193)

        c3 = c1 + c2
        self.assertEqual(c3.r, 20)
        self.assertEqual(c3.g, 33)
        self.assertEqual(c3.b, 82)
        self.assertEqual(c3.a, 193)

        c3 = c3 + c2
        self.assertEqual(c3.r, 40)
        self.assertEqual(c3.g, 66)
        self.assertEqual(c3.b, 164)
        self.assertEqual(c3.a, 255)

        # Issue #286: Is type checking done for Python 3.x?
        self.assertRaises(TypeError, operator.add, c1, None)
        self.assertRaises(TypeError, operator.add, None, c1)

    def test_sub(self):
        c1 = pygame.Color(0xFFFFFFFF)
        self.assertEqual(c1.r, 255)
        self.assertEqual(c1.g, 255)
        self.assertEqual(c1.b, 255)
        self.assertEqual(c1.a, 255)

        c2 = pygame.Color(20, 33, 82, 193)
        self.assertEqual(c2.r, 20)
        self.assertEqual(c2.g, 33)
        self.assertEqual(c2.b, 82)
        self.assertEqual(c2.a, 193)

        c3 = c1 - c2
        self.assertEqual(c3.r, 235)
        self.assertEqual(c3.g, 222)
        self.assertEqual(c3.b, 173)
        self.assertEqual(c3.a, 62)

        c3 = c3 - c2
        self.assertEqual(c3.r, 215)
        self.assertEqual(c3.g, 189)
        self.assertEqual(c3.b, 91)
        self.assertEqual(c3.a, 0)

        # Issue #286: Is type checking done for Python 3.x?
        self.assertRaises(TypeError, operator.sub, c1, None)
        self.assertRaises(TypeError, operator.sub, None, c1)

    def test_mul(self):
        c1 = pygame.Color(0x01010101)
        self.assertEqual(c1.r, 1)
        self.assertEqual(c1.g, 1)
        self.assertEqual(c1.b, 1)
        self.assertEqual(c1.a, 1)

        c2 = pygame.Color(2, 5, 3, 22)
        self.assertEqual(c2.r, 2)
        self.assertEqual(c2.g, 5)
        self.assertEqual(c2.b, 3)
        self.assertEqual(c2.a, 22)

        c3 = c1 * c2
        self.assertEqual(c3.r, 2)
        self.assertEqual(c3.g, 5)
        self.assertEqual(c3.b, 3)
        self.assertEqual(c3.a, 22)

        c3 = c3 * c2
        self.assertEqual(c3.r, 4)
        self.assertEqual(c3.g, 25)
        self.assertEqual(c3.b, 9)
        self.assertEqual(c3.a, 255)

        # Issue #286: Is type checking done for Python 3.x?
        self.assertRaises(TypeError, operator.mul, c1, None)
        self.assertRaises(TypeError, operator.mul, None, c1)

    def test_div(self):
        c1 = pygame.Color(0x80808080)
        self.assertEqual(c1.r, 128)
        self.assertEqual(c1.g, 128)
        self.assertEqual(c1.b, 128)
        self.assertEqual(c1.a, 128)

        c2 = pygame.Color(2, 4, 8, 16)
        self.assertEqual(c2.r, 2)
        self.assertEqual(c2.g, 4)
        self.assertEqual(c2.b, 8)
        self.assertEqual(c2.a, 16)

        c3 = c1 // c2
        self.assertEqual(c3.r, 64)
        self.assertEqual(c3.g, 32)
        self.assertEqual(c3.b, 16)
        self.assertEqual(c3.a, 8)

        c3 = c3 // c2
        self.assertEqual(c3.r, 32)
        self.assertEqual(c3.g, 8)
        self.assertEqual(c3.b, 2)
        self.assertEqual(c3.a, 0)

        # Issue #286: Is type checking done for Python 3.x?
        self.assertRaises(TypeError, operator.floordiv, c1, None)
        self.assertRaises(TypeError, operator.floordiv, None, c1)

        # Division by zero check
        dividend = pygame.Color(255, 255, 255, 255)
        for i in range(4):
            divisor = pygame.Color(64, 64, 64, 64)
            divisor[i] = 0
            quotient = pygame.Color(3, 3, 3, 3)
            quotient[i] = 0
            self.assertEqual(dividend // divisor, quotient)

    def test_mod(self):
        c1 = pygame.Color(0xFFFFFFFF)
        self.assertEqual(c1.r, 255)
        self.assertEqual(c1.g, 255)
        self.assertEqual(c1.b, 255)
        self.assertEqual(c1.a, 255)

        c2 = pygame.Color(2, 4, 8, 16)
        self.assertEqual(c2.r, 2)
        self.assertEqual(c2.g, 4)
        self.assertEqual(c2.b, 8)
        self.assertEqual(c2.a, 16)

        c3 = c1 % c2
        self.assertEqual(c3.r, 1)
        self.assertEqual(c3.g, 3)
        self.assertEqual(c3.b, 7)
        self.assertEqual(c3.a, 15)

        # Issue #286: Is type checking done for Python 3.x?
        self.assertRaises(TypeError, operator.mod, c1, None)
        self.assertRaises(TypeError, operator.mod, None, c1)

        # Division by zero check
        dividend = pygame.Color(255, 255, 255, 255)
        for i in range(4):
            divisor = pygame.Color(64, 64, 64, 64)
            divisor[i] = 0
            quotient = pygame.Color(63, 63, 63, 63)
            quotient[i] = 0
            self.assertEqual(dividend % divisor, quotient)

    def test_float(self):
        c = pygame.Color(0xCC00CC00)
        self.assertEqual(c.r, 204)
        self.assertEqual(c.g, 0)
        self.assertEqual(c.b, 204)
        self.assertEqual(c.a, 0)
        self.assertEqual(float(c), float(0xCC00CC00))

        c = pygame.Color(0x33727592)
        self.assertEqual(c.r, 51)
        self.assertEqual(c.g, 114)
        self.assertEqual(c.b, 117)
        self.assertEqual(c.a, 146)
        self.assertEqual(float(c), float(0x33727592))

    def test_oct(self):
        c = pygame.Color(0xCC00CC00)
        self.assertEqual(c.r, 204)
        self.assertEqual(c.g, 0)
        self.assertEqual(c.b, 204)
        self.assertEqual(c.a, 0)
        self.assertEqual(oct(c), oct(0xCC00CC00))

        c = pygame.Color(0x33727592)
        self.assertEqual(c.r, 51)
        self.assertEqual(c.g, 114)
        self.assertEqual(c.b, 117)
        self.assertEqual(c.a, 146)
        self.assertEqual(oct(c), oct(0x33727592))

    def test_hex(self):
        c = pygame.Color(0xCC00CC00)
        self.assertEqual(c.r, 204)
        self.assertEqual(c.g, 0)
        self.assertEqual(c.b, 204)
        self.assertEqual(c.a, 0)
        self.assertEqual(hex(c), hex(0xCC00CC00))

        c = pygame.Color(0x33727592)
        self.assertEqual(c.r, 51)
        self.assertEqual(c.g, 114)
        self.assertEqual(c.b, 117)
        self.assertEqual(c.a, 146)
        self.assertEqual(hex(c), hex(0x33727592))

    def test_webstyle(self):
        c = pygame.Color("#CC00CC11")
        self.assertEqual(c.r, 204)
        self.assertEqual(c.g, 0)
        self.assertEqual(c.b, 204)
        self.assertEqual(c.a, 17)
        self.assertEqual(hex(c), hex(0xCC00CC11))

        c = pygame.Color("#CC00CC")
        self.assertEqual(c.r, 204)
        self.assertEqual(c.g, 0)
        self.assertEqual(c.b, 204)
        self.assertEqual(c.a, 255)
        self.assertEqual(hex(c), hex(0xCC00CCFF))

        c = pygame.Color("0xCC00CC11")
        self.assertEqual(c.r, 204)
        self.assertEqual(c.g, 0)
        self.assertEqual(c.b, 204)
        self.assertEqual(c.a, 17)
        self.assertEqual(hex(c), hex(0xCC00CC11))

        c = pygame.Color("0xCC00CC")
        self.assertEqual(c.r, 204)
        self.assertEqual(c.g, 0)
        self.assertEqual(c.b, 204)
        self.assertEqual(c.a, 255)
        self.assertEqual(hex(c), hex(0xCC00CCFF))

        self.assertRaises(ValueError, pygame.Color, "#cc00qq")
        self.assertRaises(ValueError, pygame.Color, "0xcc00qq")
        self.assertRaises(ValueError, pygame.Color, "09abcdef")
        self.assertRaises(ValueError, pygame.Color, "09abcde")
        self.assertRaises(ValueError, pygame.Color, "quarky")

    def test_int(self):
        # This will be a long
        c = pygame.Color(0xCC00CC00)
        self.assertEqual(c.r, 204)
        self.assertEqual(c.g, 0)
        self.assertEqual(c.b, 204)
        self.assertEqual(c.a, 0)
        self.assertEqual(int(c), int(0xCC00CC00))

        # This will be an int
        c = pygame.Color(0x33727592)
        self.assertEqual(c.r, 51)
        self.assertEqual(c.g, 114)
        self.assertEqual(c.b, 117)
        self.assertEqual(c.a, 146)
        self.assertEqual(int(c), int(0x33727592))

    def test_long(self):
        # This will be a long
        c = pygame.Color(0xCC00CC00)
        self.assertEqual(c.r, 204)
        self.assertEqual(c.g, 0)
        self.assertEqual(c.b, 204)
        self.assertEqual(c.a, 0)
        self.assertEqual(int(c), int(0xCC00CC00))

        # This will be an int
        c = pygame.Color(0x33727592)
        self.assertEqual(c.r, 51)
        self.assertEqual(c.g, 114)
        self.assertEqual(c.b, 117)
        self.assertEqual(c.a, 146)
        self.assertEqual(int(c), int(0x33727592))

    def test_normalize(self):
        c = pygame.Color(204, 38, 194, 55)
        self.assertEqual(c.r, 204)
        self.assertEqual(c.g, 38)
        self.assertEqual(c.b, 194)
        self.assertEqual(c.a, 55)

        t = c.normalize()

        self.assertAlmostEqual(t[0], 0.800000, 5)
        self.assertAlmostEqual(t[1], 0.149016, 5)
        self.assertAlmostEqual(t[2], 0.760784, 5)
        self.assertAlmostEqual(t[3], 0.215686, 5)

    def test_len(self):
        c = pygame.Color(204, 38, 194, 55)
        self.assertEqual(len(c), 4)

    def test_get_item(self):
        c = pygame.Color(204, 38, 194, 55)
        self.assertEqual(c[0], 204)
        self.assertEqual(c[1], 38)
        self.assertEqual(c[2], 194)
        self.assertEqual(c[3], 55)

    def test_set_item(self):
        c = pygame.Color(204, 38, 194, 55)
        self.assertEqual(c[0], 204)
        self.assertEqual(c[1], 38)
        self.assertEqual(c[2], 194)
        self.assertEqual(c[3], 55)

        c[0] = 33
        self.assertEqual(c[0], 33)
        c[1] = 48
        self.assertEqual(c[1], 48)
        c[2] = 173
        self.assertEqual(c[2], 173)
        c[3] = 213
        self.assertEqual(c[3], 213)

        # Now try some 'invalid' ones
        self.assertRaises(TypeError, _assign_item, c, 0, 95.485)
        self.assertEqual(c[0], 33)
        self.assertRaises(ValueError, _assign_item, c, 1, -83)
        self.assertEqual(c[1], 48)
        self.assertRaises(TypeError, _assign_item, c, 2, "Hello")
        self.assertEqual(c[2], 173)

    def test_Color_type_works_for_Surface_get_and_set_colorkey(self):
        s = pygame.Surface((32, 32))

        c = pygame.Color(33, 22, 11, 255)
        s.set_colorkey(c)

        get_r, get_g, get_b, get_a = s.get_colorkey()

        self.assertTrue(get_r == c.r)
        self.assertTrue(get_g == c.g)
        self.assertTrue(get_b == c.b)
        self.assertTrue(get_a == c.a)

    ########## HSLA, HSVA, CMY, I1I2I3 ALL ELEMENTS WITHIN SPECIFIED RANGE #########

    def test_hsla__all_elements_within_limits(self):
        for c in rgba_combos_Color_generator():
            h, s, l, a = c.hsla
            self.assertTrue(0 <= h <= 360)
            self.assertTrue(0 <= s <= 100)
            self.assertTrue(0 <= l <= 100)
            self.assertTrue(0 <= a <= 100)

    def test_hsva__all_elements_within_limits(self):
        for c in rgba_combos_Color_generator():
            h, s, v, a = c.hsva
            self.assertTrue(0 <= h <= 360)
            self.assertTrue(0 <= s <= 100)
            self.assertTrue(0 <= v <= 100)
            self.assertTrue(0 <= a <= 100)

    def test_cmy__all_elements_within_limits(self):
        for c in rgba_combos_Color_generator():
            c, m, y = c.cmy
            self.assertTrue(0 <= c <= 1)
            self.assertTrue(0 <= m <= 1)
            self.assertTrue(0 <= y <= 1)

    def test_i1i2i3__all_elements_within_limits(self):
        for c in rgba_combos_Color_generator():
            i1, i2, i3 = c.i1i2i3
            self.assertTrue(0 <= i1 <= 1)
            self.assertTrue(-0.5 <= i2 <= 0.5)
            self.assertTrue(-0.5 <= i3 <= 0.5)

    def test_issue_269(self):
        """PyColor OverflowError on HSVA with hue value of 360

        >>> c = pygame.Color(0)
        >>> c.hsva = (360,0,0,0)
        Traceback (most recent call last):
          File "<stdin>", line 1, in <module>
        OverflowError: this is not allowed to happen ever
        >>> pygame.ver
        '1.9.1release'
        >>>

        """

        c = pygame.Color(0)
        c.hsva = 360, 0, 0, 0
        self.assertEqual(c.hsva, (0, 0, 0, 0))
        c.hsva = 360, 100, 100, 100
        self.assertEqual(c.hsva, (0, 100, 100, 100))
        self.assertEqual(c, (255, 0, 0, 255))

    ####################### COLORSPACE PROPERTY SANITY TESTS #######################

    def colorspaces_converted_should_not_raise(self, prop):
        fails = 0

        x = 0
        for c in rgba_combos_Color_generator():
            x += 1

            other = pygame.Color(0)

            try:
                setattr(other, prop, getattr(c, prop))
                # eg other.hsla = c.hsla

            except ValueError:
                fails += 1

        self.assertTrue(x > 0, "x is combination counter, 0 means no tests!")
        self.assertTrue((fails, x) == (0, x))

    def test_hsla__sanity_testing_converted_should_not_raise(self):
        self.colorspaces_converted_should_not_raise("hsla")

    def test_hsva__sanity_testing_converted_should_not_raise(self):
        self.colorspaces_converted_should_not_raise("hsva")

    def test_cmy__sanity_testing_converted_should_not_raise(self):
        self.colorspaces_converted_should_not_raise("cmy")

    def test_i1i2i3__sanity_testing_converted_should_not_raise(self):
        self.colorspaces_converted_should_not_raise("i1i2i3")

    ################################################################################

    def colorspaces_converted_should_equate_bar_rounding(self, prop):
        for c in rgba_combos_Color_generator():
            other = pygame.Color(0)

            try:
                setattr(other, prop, getattr(c, prop))
                # eg other.hsla = c.hsla

                self.assertTrue(abs(other.r - c.r) <= 1)
                self.assertTrue(abs(other.b - c.b) <= 1)
                self.assertTrue(abs(other.g - c.g) <= 1)
                # CMY and I1I2I3 do not care about the alpha
                if not prop in ("cmy", "i1i2i3"):
                    self.assertTrue(abs(other.a - c.a) <= 1)

            except ValueError:
                pass  # other tests will notify, this tests equation

    def test_hsla__sanity_testing_converted_should_equate_bar_rounding(self):
        self.colorspaces_converted_should_equate_bar_rounding("hsla")

    def test_hsva__sanity_testing_converted_should_equate_bar_rounding(self):
        self.colorspaces_converted_should_equate_bar_rounding("hsva")

    def test_cmy__sanity_testing_converted_should_equate_bar_rounding(self):
        self.colorspaces_converted_should_equate_bar_rounding("cmy")

    def test_i1i2i3__sanity_testing_converted_should_equate_bar_rounding(self):
        self.colorspaces_converted_should_equate_bar_rounding("i1i2i3")

    ################################################################################

    def test_correct_gamma__verified_against_python_implementation(self):
        "|tags:slow|"
        # gamma_correct defined at top of page

        gammas = [i / 10.0 for i in range(1, 31)]  # [0.1 ... 3.0]
        gammas_len = len(gammas)

        for i, c in enumerate(rgba_combos_Color_generator()):
            gamma = gammas[i % gammas_len]

            corrected = pygame.Color(*[gamma_correct(x, gamma) for x in tuple(c)])
            lib_corrected = c.correct_gamma(gamma)

            self.assertTrue(corrected.r == lib_corrected.r)
            self.assertTrue(corrected.g == lib_corrected.g)
            self.assertTrue(corrected.b == lib_corrected.b)
            self.assertTrue(corrected.a == lib_corrected.a)

        # TODO: test against statically defined verified _correct_ values
        # assert corrected.r == 125 etc.

    def test_pickle(self):
        import pickle

        c1 = pygame.Color(1, 2, 3, 4)
        # c2 = pygame.Color(255,254,253,252)
        pickle_string = pickle.dumps(c1)
        c1_frompickle = pickle.loads(pickle_string)
        self.assertEqual(c1, c1_frompickle)

    ################################################################################
    # only available if ctypes module is also available

    @unittest.skipIf(IS_PYPY, "PyPy has no ctypes")
    def test_arraystruct(self):
        import pygame.tests.test_utils.arrinter as ai
        import ctypes as ct

        c_byte_p = ct.POINTER(ct.c_byte)
        c = pygame.Color(5, 7, 13, 23)
        flags = ai.PAI_CONTIGUOUS | ai.PAI_FORTRAN | ai.PAI_ALIGNED | ai.PAI_NOTSWAPPED
        for i in range(1, 5):
            c.set_length(i)
            inter = ai.ArrayInterface(c)
            self.assertEqual(inter.two, 2)
            self.assertEqual(inter.nd, 1)
            self.assertEqual(inter.typekind, "u")
            self.assertEqual(inter.itemsize, 1)
            self.assertEqual(inter.flags, flags)
            self.assertEqual(inter.shape[0], i)
            self.assertEqual(inter.strides[0], 1)
            data = ct.cast(inter.data, c_byte_p)
            for j in range(i):
                self.assertEqual(data[j], c[j])

    @unittest.skipIf(not pygame.HAVE_NEWBUF, "newbuf not implemented")
    def test_newbuf(self):
        from pygame.tests.test_utils import buftools
        from ctypes import cast, POINTER, c_uint8

        class ColorImporter(buftools.Importer):
            def __init__(self, color, flags):
                super().__init__(color, flags)
                self.items = cast(self.buf, POINTER(c_uint8))

            def __getitem__(self, index):
                if 0 <= index < 4:
                    return self.items[index]
                raise IndexError(f"valid index values are between 0 and 3: got {index}")

            def __setitem__(self, index, value):
                if 0 <= index < 4:
                    self.items[index] = value
                else:
                    raise IndexError(
                        f"valid index values are between 0 and 3: got {index}"
                    )

        c = pygame.Color(50, 100, 150, 200)
        imp = ColorImporter(c, buftools.PyBUF_SIMPLE)
        self.assertTrue(imp.obj is c)
        self.assertEqual(imp.ndim, 0)
        self.assertEqual(imp.itemsize, 1)
        self.assertEqual(imp.len, 4)
        self.assertTrue(imp.readonly)
        self.assertTrue(imp.format is None)
        self.assertTrue(imp.shape is None)
        self.assertTrue(imp.strides is None)
        self.assertTrue(imp.suboffsets is None)
        for i in range(4):
            self.assertEqual(c[i], imp[i])
        imp[0] = 60
        self.assertEqual(c.r, 60)
        imp[1] = 110
        self.assertEqual(c.g, 110)
        imp[2] = 160
        self.assertEqual(c.b, 160)
        imp[3] = 210
        self.assertEqual(c.a, 210)
        imp = ColorImporter(c, buftools.PyBUF_FORMAT)
        self.assertEqual(imp.ndim, 0)
        self.assertEqual(imp.itemsize, 1)
        self.assertEqual(imp.len, 4)
        self.assertEqual(imp.format, "B")
        self.assertEqual(imp.ndim, 0)
        self.assertEqual(imp.itemsize, 1)
        self.assertEqual(imp.len, 4)
        imp = ColorImporter(c, buftools.PyBUF_ND)
        self.assertEqual(imp.ndim, 1)
        self.assertEqual(imp.itemsize, 1)
        self.assertEqual(imp.len, 4)
        self.assertTrue(imp.format is None)
        self.assertEqual(imp.shape, (4,))
        self.assertEqual(imp.strides, None)
        imp = ColorImporter(c, buftools.PyBUF_STRIDES)
        self.assertEqual(imp.ndim, 1)
        self.assertTrue(imp.format is None)
        self.assertEqual(imp.shape, (4,))
        self.assertEqual(imp.strides, (1,))
        imp = ColorImporter(c, buftools.PyBUF_C_CONTIGUOUS)
        self.assertEqual(imp.ndim, 1)
        imp = ColorImporter(c, buftools.PyBUF_F_CONTIGUOUS)
        self.assertEqual(imp.ndim, 1)
        imp = ColorImporter(c, buftools.PyBUF_ANY_CONTIGUOUS)
        self.assertEqual(imp.ndim, 1)
        for i in range(1, 5):
            c.set_length(i)
            imp = ColorImporter(c, buftools.PyBUF_ND)
            self.assertEqual(imp.ndim, 1)
            self.assertEqual(imp.len, i)
            self.assertEqual(imp.shape, (i,))
        self.assertRaises(BufferError, ColorImporter, c, buftools.PyBUF_WRITABLE)

    def test_color_iter(self):
        c = pygame.Color(50, 100, 150, 200)

        # call __iter__ explicitly to test that it is defined
        color_iterator = c.__iter__()
        for i, val in enumerate(color_iterator):
            self.assertEqual(c[i], val)

    def test_color_contains(self):
        c = pygame.Color(50, 60, 70)

        # call __contains__ explicitly to test that it is defined
        self.assertTrue(c.__contains__(50))
        self.assertTrue(60 in c)
        self.assertTrue(70 in c)
        self.assertFalse(100 in c)
        self.assertFalse(c.__contains__(10))

        self.assertRaises(TypeError, lambda: "string" in c)
        self.assertRaises(TypeError, lambda: 3.14159 in c)

    def test_grayscale(self):
        Color = pygame.color.Color

        color = Color(255, 0, 0, 255)
        self.assertEqual(color.grayscale(), Color(76, 76, 76, 255))
        color = Color(3, 5, 7, 255)
        self.assertEqual(color.grayscale(), Color(4, 4, 4, 255))
        color = Color(3, 5, 70, 255)
        self.assertEqual(color.grayscale(), Color(11, 11, 11, 255))
        color = Color(3, 50, 70, 255)
        self.assertEqual(color.grayscale(), Color(38, 38, 38, 255))
        color = Color(30, 50, 70, 255)
        self.assertEqual(color.grayscale(), Color(46, 46, 46, 255))

        color = Color(255, 0, 0, 144)
        self.assertEqual(color.grayscale(), Color(76, 76, 76, 144))
        color = Color(3, 5, 7, 144)
        self.assertEqual(color.grayscale(), Color(4, 4, 4, 144))
        color = Color(3, 5, 70, 144)
        self.assertEqual(color.grayscale(), Color(11, 11, 11, 144))
        color = Color(3, 50, 70, 144)
        self.assertEqual(color.grayscale(), Color(38, 38, 38, 144))
        color = Color(30, 50, 70, 144)
        self.assertEqual(color.grayscale(), Color(46, 46, 46, 144))

    def test_lerp(self):
        # setup
        Color = pygame.color.Color

        color0 = Color(0, 0, 0, 0)
        color128 = Color(128, 128, 128, 128)
        color255 = Color(255, 255, 255, 255)
        color100 = Color(100, 100, 100, 100)

        # type checking
        self.assertTrue(isinstance(color0.lerp(color128, 0.5), Color))

        # common value testing
        self.assertEqual(color0.lerp(color128, 0.5), Color(64, 64, 64, 64))
        self.assertEqual(color0.lerp(color128, 0.5), Color(64, 64, 64, 64))
        self.assertEqual(color128.lerp(color255, 0.5), Color(192, 192, 192, 192))
        self.assertEqual(color0.lerp(color255, 0.5), Color(128, 128, 128, 128))

        # testing extremes
        self.assertEqual(color0.lerp(color100, 0), color0)
        self.assertEqual(color0.lerp(color100, 0.01), Color(1, 1, 1, 1))
        self.assertEqual(color0.lerp(color100, 0.99), Color(99, 99, 99, 99))
        self.assertEqual(color0.lerp(color100, 1), color100)

        # kwarg testing
        self.assertEqual(color0.lerp(color=color100, amount=0.5), Color(50, 50, 50, 50))
        self.assertEqual(color0.lerp(amount=0.5, color=color100), Color(50, 50, 50, 50))

        # invalid input testing
        self.assertRaises(ValueError, lambda: color0.lerp(color128, 2.5))
        self.assertRaises(ValueError, lambda: color0.lerp(color128, -0.5))
        self.assertRaises(ValueError, lambda: color0.lerp((256, 0, 0, 0), 0.5))
        self.assertRaises(ValueError, lambda: color0.lerp((0, 256, 0, 0), 0.5))
        self.assertRaises(ValueError, lambda: color0.lerp((0, 0, 256, 0), 0.5))
        self.assertRaises(ValueError, lambda: color0.lerp((0, 0, 0, 256), 0.5))
        self.assertRaises(TypeError, lambda: color0.lerp(0.2, 0.5))

    def test_premul_alpha(self):
        # setup
        Color = pygame.color.Color

        color0 = Color(0, 0, 0, 0)
        alpha0 = Color(255, 255, 255, 0)
        alpha49 = Color(255, 0, 0, 49)
        alpha67 = Color(0, 255, 0, 67)
        alpha73 = Color(0, 0, 255, 73)
        alpha128 = Color(255, 255, 255, 128)
        alpha199 = Color(255, 255, 255, 199)
        alpha255 = Color(128, 128, 128, 255)

        # type checking
        self.assertTrue(isinstance(color0.premul_alpha(), Color))

        # hand crafted value testing
        self.assertEqual(alpha0.premul_alpha(), Color(0, 0, 0, 0))
        self.assertEqual(alpha49.premul_alpha(), Color(49, 0, 0, 49))
        self.assertEqual(alpha67.premul_alpha(), Color(0, 67, 0, 67))
        self.assertEqual(alpha73.premul_alpha(), Color(0, 0, 73, 73))
        self.assertEqual(alpha128.premul_alpha(), Color(128, 128, 128, 128))
        self.assertEqual(alpha199.premul_alpha(), Color(199, 199, 199, 199))
        self.assertEqual(alpha255.premul_alpha(), Color(128, 128, 128, 255))

        # full range of alpha auto sub-testing
        test_colors = [
            (200, 30, 74),
            (76, 83, 24),
            (184, 21, 6),
            (74, 4, 74),
            (76, 83, 24),
            (184, 21, 234),
            (160, 30, 74),
            (96, 147, 204),
            (198, 201, 60),
            (132, 89, 74),
            (245, 9, 224),
            (184, 112, 6),
        ]

        for r, g, b in test_colors:
            for a in range(255):
                with self.subTest(r=r, g=g, b=b, a=a):
                    alpha = a / 255.0
                    self.assertEqual(
                        Color(r, g, b, a).premul_alpha(),
                        Color(
                            ((r + 1) * a) >> 8,
                            ((g + 1) * a) >> 8,
                            ((b + 1) * a) >> 8,
                            a,
                        ),
                    )

    def test_update(self):
        c = pygame.color.Color(0, 0, 0)
        c.update(1, 2, 3, 4)

        self.assertEqual(c.r, 1)
        self.assertEqual(c.g, 2)
        self.assertEqual(c.b, 3)
        self.assertEqual(c.a, 4)

        c = pygame.color.Color(0, 0, 0)
        c.update([1, 2, 3, 4])

        self.assertEqual(c.r, 1)
        self.assertEqual(c.g, 2)
        self.assertEqual(c.b, 3)
        self.assertEqual(c.a, 4)

        c = pygame.color.Color(0, 0, 0)
        c2 = pygame.color.Color(1, 2, 3, 4)
        c.update(c2)

        self.assertEqual(c.r, 1)
        self.assertEqual(c.g, 2)
        self.assertEqual(c.b, 3)
        self.assertEqual(c.a, 4)

        c = pygame.color.Color(1, 1, 1)
        c.update("black")

        self.assertEqual(c.r, 0)
        self.assertEqual(c.g, 0)
        self.assertEqual(c.b, 0)
        self.assertEqual(c.a, 255)

        c = pygame.color.Color(0, 0, 0, 120)
        c.set_length(3)
        c.update(1, 2, 3)
        self.assertEqual(len(c), 3)
        c.set_length(4)
        self.assertEqual(c[3], 120)

        c.set_length(3)
        c.update(1, 2, 3, 4)
        self.assertEqual(len(c), 4)

    def test_collection_abc(self):
        c = pygame.Color(64, 70, 75, 255)
        self.assertTrue(isinstance(c, Collection))
        self.assertFalse(isinstance(c, Sequence))


class SubclassTest(unittest.TestCase):
    class MyColor(pygame.Color):
        def __init__(self, *args, **kwds):
            super(SubclassTest.MyColor, self).__init__(*args, **kwds)
            self.an_attribute = True

    def test_add(self):
        mc1 = self.MyColor(128, 128, 128, 255)
        self.assertTrue(mc1.an_attribute)
        c2 = pygame.Color(64, 64, 64, 255)
        mc2 = mc1 + c2
        self.assertTrue(isinstance(mc2, self.MyColor))
        self.assertRaises(AttributeError, getattr, mc2, "an_attribute")
        c3 = c2 + mc1
        self.assertTrue(type(c3) is pygame.Color)

    def test_sub(self):
        mc1 = self.MyColor(128, 128, 128, 255)
        self.assertTrue(mc1.an_attribute)
        c2 = pygame.Color(64, 64, 64, 255)
        mc2 = mc1 - c2
        self.assertTrue(isinstance(mc2, self.MyColor))
        self.assertRaises(AttributeError, getattr, mc2, "an_attribute")
        c3 = c2 - mc1
        self.assertTrue(type(c3) is pygame.Color)

    def test_mul(self):
        mc1 = self.MyColor(128, 128, 128, 255)
        self.assertTrue(mc1.an_attribute)
        c2 = pygame.Color(64, 64, 64, 255)
        mc2 = mc1 * c2
        self.assertTrue(isinstance(mc2, self.MyColor))
        self.assertRaises(AttributeError, getattr, mc2, "an_attribute")
        c3 = c2 * mc1
        self.assertTrue(type(c3) is pygame.Color)

    def test_div(self):
        mc1 = self.MyColor(128, 128, 128, 255)
        self.assertTrue(mc1.an_attribute)
        c2 = pygame.Color(64, 64, 64, 255)
        mc2 = mc1 // c2
        self.assertTrue(isinstance(mc2, self.MyColor))
        self.assertRaises(AttributeError, getattr, mc2, "an_attribute")
        c3 = c2 // mc1
        self.assertTrue(type(c3) is pygame.Color)

    def test_mod(self):
        mc1 = self.MyColor(128, 128, 128, 255)
        self.assertTrue(mc1.an_attribute)
        c2 = pygame.Color(64, 64, 64, 255)
        mc2 = mc1 % c2
        self.assertTrue(isinstance(mc2, self.MyColor))
        self.assertRaises(AttributeError, getattr, mc2, "an_attribute")
        c3 = c2 % mc1
        self.assertTrue(type(c3) is pygame.Color)

    def test_inv(self):
        mc1 = self.MyColor(64, 64, 64, 64)
        self.assertTrue(mc1.an_attribute)
        mc2 = ~mc1
        self.assertTrue(isinstance(mc2, self.MyColor))
        self.assertRaises(AttributeError, getattr, mc2, "an_attribute")

    def test_correct_gamma(self):
        mc1 = self.MyColor(64, 70, 75, 255)
        self.assertTrue(mc1.an_attribute)
        mc2 = mc1.correct_gamma(0.03)
        self.assertTrue(isinstance(mc2, self.MyColor))
        self.assertRaises(AttributeError, getattr, mc2, "an_attribute")

    def test_collection_abc(self):
        mc1 = self.MyColor(64, 70, 75, 255)
        self.assertTrue(isinstance(mc1, Collection))
        self.assertFalse(isinstance(mc1, Sequence))


################################################################################

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