text: import unittest
  import math
  import operator
  import platform
  
  import pygame
  from pygame.compat import long_
  
  
  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(object):
              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))
  
      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, long_(33)))
  
      def test_case_insensitivity_of_string_args(self):
          self.assertEqual(pygame.color.Color('red'), pygame.color.Color('Red'))
  
      def test_color(self):
          c = pygame.Color(10, 20, 30, 40)
          self.assertEqual(c.r, 10)
          self.assertEqual(c.g, 20)
          self.assertEqual(c.b, 30)
          self.assertEqual(c.a, 40)
  
          c = pygame.Color("indianred3")
          self.assertEqual(c.r, 205)
          self.assertEqual(c.g, 85)
          self.assertEqual(c.b, 85)
          self.assertEqual(c.a, 255)
  
          c = pygame.Color(0xAABBCCDD)
          self.assertEqual(c.r, 0xAA)
          self.assertEqual(c.g, 0xBB)
          self.assertEqual(c.b, 0xCC)
          self.assertEqual(c.a, 0xDD)
  
          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_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(long_ (c), long_ (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(long_ (c), long_ (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(ValueError, _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(ValueError, _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(ColorImporter, self).__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("valid index values are between 0 and 3: "
                                   "got {}".format(index))
              def __setitem__(self, index, value):
                  if 0 <= index < 4:
                      self.items[index] = value
                  else:
                      raise IndexError("valid index values are between 0 and 3: "
                                       "got {}".format(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)
  
  
  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(.03)
          self.assertTrue(isinstance(mc2, self.MyColor))
          self.assertRaises(AttributeError, getattr, mc2, 'an_attribute')
  
  
  ################################################################################
  
  if __name__ == '__main__':
      unittest.main()
  