text: import unittest
  
  from itertools import izip
  from igraph import *
  
  class ColorTests(unittest.TestCase):
      def assertAlmostEqualMany(self, items1, items2, eps):
          for idx, (item1, item2) in enumerate(izip(items1, items2)):
              self.assertAlmostEqual(item1, item2, places=eps,
                      msg="mismatch at index %d, %r != %r with %d digits"
                      % (idx, items1, items2, eps))
  
      def setUp(self):
          columns = ["r", "g", "b", "h", "v", "l", "s_hsv", "s_hsl", "alpha"]
          # Examples taken from http://en.wikipedia.org/wiki/HSL_and_HSV
          values = [
                  (1, 1, 1, 0, 1, 1, 0, 0, 1),
                  (0.5, 0.5, 0.5, 0, 0.5, 0.5, 0, 0, 0.5),
                  (0, 0, 0, 0, 0, 0, 0, 0, 1),
                  (1, 0, 0, 0, 1, 0.5, 1, 1, 0.5),
                  (0.75, 0.75, 0, 60, 0.75, 0.375, 1, 1, 0.25),
                  (0, 0.5, 0, 120, 0.5, 0.25, 1, 1, 0.75),
                  (0.5, 1, 1, 180, 1, 0.75, 0.5, 1, 1),
                  (0.5, 0.5, 1, 240, 1, 0.75, 0.5, 1, 1),
                  (0.75, 0.25, 0.75, 300, 0.75, 0.5, 0.666666667, 0.5, 0.25),
                  (0.211, 0.149, 0.597, 248.3, 0.597, 0.373, 0.750, 0.601, 1),
                  (0.495, 0.493, 0.721, 240.5, 0.721, 0.607, 0.316, 0.290, 0.75),
          ]
          self.data = [dict(zip(columns, value)) for value in values]
          for row in self.data:
              row["h"] /= 360.
  
      def _testGeneric(self, method, args1, args2=("r", "g", "b")):
          if len(args1) == len(args2)+1:
              args2 += ("alpha", )
          for data in self.data:
              vals1 = [data.get(arg, 0.0) for arg in args1]
              vals2 = [data.get(arg, 0.0) for arg in args2]
              self.assertAlmostEqualMany(method(*vals1), vals2, 2)
  
      def testHSVtoRGB(self):
          self._testGeneric(hsv_to_rgb, "h s_hsv v".split())
  
      def testHSVAtoRGBA(self):
          self._testGeneric(hsva_to_rgba, "h s_hsv v alpha".split())
  
      def testHSLtoRGB(self):
          self._testGeneric(hsl_to_rgb, "h s_hsl l".split())
  
      def testHSLAtoRGBA(self):
          self._testGeneric(hsla_to_rgba, "h s_hsl l alpha".split())
  
      def testRGBtoHSL(self):
          self._testGeneric(rgb_to_hsl, "r g b".split(), "h s_hsl l".split())
  
      def testRGBAtoHSLA(self):
          self._testGeneric(rgba_to_hsla, "r g b alpha".split(), "h s_hsl l alpha".split())
  
      def testRGBtoHSV(self):
          self._testGeneric(rgb_to_hsv, "r g b".split(), "h s_hsv v".split())
  
      def testRGBAtoHSVA(self):
          self._testGeneric(rgba_to_hsva, "r g b alpha".split(), "h s_hsv v alpha".split())
  
  
  class PaletteTests(unittest.TestCase):
      def testGradientPalette(self):
          gp = GradientPalette("red", "blue", 3)
          self.assertTrue(gp.get(0) == (1., 0., 0., 1.))
          self.assertTrue(gp.get(1) == (0.5, 0., 0.5, 1.))
          self.assertTrue(gp.get(2) == (0., 0., 1., 1.))
  
      def testAdvancedGradientPalette(self):
          agp = AdvancedGradientPalette(["red", "black", "blue"], n=9)
          self.assertTrue(agp.get(0) == (1., 0., 0., 1.))
          self.assertTrue(agp.get(2) == (0.5, 0., 0., 1.))
          self.assertTrue(agp.get(4) == (0., 0., 0., 1.))
          self.assertTrue(agp.get(5) == (0., 0., 0.25, 1.))
          self.assertTrue(agp.get(8) == (0., 0., 1., 1.))
  
          agp = AdvancedGradientPalette(["red", "black", "blue"], [0, 8, 2], 9)
          self.assertTrue(agp.get(0) == (1., 0., 0., 1.))
          self.assertTrue(agp.get(1) == (0.5, 0., 0.5, 1.))
          self.assertTrue(agp.get(5) == (0., 0., 0.5, 1.))
  
  
  def suite():
      color_suite = unittest.makeSuite(ColorTests)
      palette_suite = unittest.makeSuite(PaletteTests)
      return unittest.TestSuite([color_suite, palette_suite])
  
  def test():
      runner = unittest.TextTestRunner()
      runner.run(suite())
      
  if __name__ == "__main__":
      test()
  
  