RubyGems - closure - Versions diffs - 1.2.701 → 1.3.0 - Mend

closure 1.2.701 → 1.3.0

Files changed (1566) hide show

data/closure-library/closure/goog/color/color_test.html DELETED Viewed

@@ -1,645 +0,0 @@
-<!DOCTYPE html>
-<html>
-<!--
-Copyright 2006 The Closure Library Authors. All Rights Reserved.
-Use of this source code is governed by the Apache License, Version 2.0.
-See the COPYING file for details.
--->
-<head>
-<meta http-equiv="X-UA-Compatible" content="IE=edge">
-<title>Closure Unit Tests - goog.color</title>
-<script src="../base.js"></script>
-<script>
-  goog.require('goog.array');
-  goog.require('goog.color');
-  goog.require('goog.color.names');
-  goog.require('goog.testing.jsunit');
-</script>
-</head>
-<body>
-<script>
-function testIsValidHexColor() {
-  var goodHexColors = ['#ffffff', '#ff7812', '#012345', '#Ff003D', '#3CA'];
-  var badHexColors = ['#xxxxxx', '889900', 'not_color', '#1234567', 'fffffg'];
-  for (var i = 0; i < goodHexColors.length; i++) {
-    assertTrue(goodHexColors[i], goog.color.isValidHexColor_(goodHexColors[i]));
-  }
-  for (var i = 0; i < badHexColors.length; i++) {
-    assertFalse(badHexColors[i], goog.color.isValidHexColor_(badHexColors[i]));
-  }
-}
-function testIsValidRgbColor() {
-  var goodRgbColors = ['(255, 26, 75)', 'RGB(2, 3, 4)', '(0,0,0)',
-                       'rgb(255,255,255)'];
-  var badRgbColors = ['(2555,0,0)', '(1,2,3,4)', 'rgb(1,20,)',
-                      'RGB(20,20,20,)'];
-  for (var i = 0; i < goodRgbColors.length; i++) {
-    assertEquals(goodRgbColors[i],
-                 goog.color.isValidRgbColor_(goodRgbColors[i]).length, 3);
-  }
-  for (var i = 0; i < badRgbColors.length; i++) {
-    assertEquals(badRgbColors[i],
-                 goog.color.isValidRgbColor_(badRgbColors[i]).length, 0);
-  }
-}
-function testParse() {
-  var colors = ['rgb(15, 250, 77)', '(127, 127, 127)', '#ffeedd', '123456',
-                'magenta'];
-  var parsed = goog.array.map(colors, goog.color.parse);
-  assertEquals('rgb', parsed[0].type);
-  assertEquals(goog.color.rgbToHex(15, 250, 77), parsed[0].hex);
-  assertEquals('rgb', parsed[1].type);
-  assertEquals(goog.color.rgbToHex(127, 127, 127), parsed[1].hex);
-  assertEquals('hex', parsed[2].type);
-  assertEquals('#ffeedd', parsed[2].hex);
-  assertEquals('hex', parsed[3].type);
-  assertEquals('#123456', parsed[3].hex);
-  assertEquals('named', parsed[4].type);
-  assertEquals('#ff00ff', parsed[4].hex);
-  var badColors = ['rgb(01, 1, 23)', '(256, 256, 256)', '#ffeeddaa'];
-  for (var i = 0; i < badColors.length; i++) {
-    var e = assertThrows(goog.partial(goog.color.parse, badColors[i]));
-    assertContains('is not a valid color string', e.message);
-  }
-}
-function testHexToRgb() {
-  var testColors = [['#B0FF2D', [176, 255, 45]],
-                    ['#b26e5f', [178, 110, 95]],
-                    ['#66f', [102, 102, 255]]];
-  for (var i = 0; i < testColors.length; i++) {
-    var r = goog.color.hexToRgb(testColors[i][0]);
-    var t = testColors[i][1];
-    assertEquals('Red channel should match.', t[0], r[0]);
-    assertEquals('Green channel should match.', t[1], r[1]);
-    assertEquals('Blue channel should match.', t[2], r[2]);
-  }
-  var badColors = ['', '#g00', 'some words'];
-  for (var i = 0; i < badColors.length; i++) {
-    var e = assertThrows(goog.partial(goog.color.hexToRgb, badColors[i]));
-    assertEquals("'" + badColors[i] + "' is not a valid hex color", e.message);
-  }
-}
-function testHexToRgbStyle() {
-  assertEquals('rgb(255,0,0)', goog.color.hexToRgbStyle(goog.color.names.red));
-  assertEquals('rgb(206,206,206)', goog.color.hexToRgbStyle('#cecece'));
-  assertEquals('rgb(51,204,170)', goog.color.hexToRgbStyle('#3CA'));
-  var badHexColors = ['#1234', null, undefined, '#.1234567890'];
-  for (var i = 0; i < badHexColors.length; ++i) {
-    var badHexColor = badHexColors[i];
-    var e = assertThrows(goog.partial(goog.color.hexToRgbStyle, badHexColor));
-    assertEquals("'" + badHexColor + "' is not a valid hex color", e.message);
-  }
-}
-function testRgbToHex() {
-  assertEquals(goog.color.names.red, goog.color.rgbToHex(255, 0, 0));
-  assertEquals('#af13ff', goog.color.rgbToHex(175, 19, 255));
-  var badRgb = [[-1, -1, -1], [256, 0, 0], ['a', 'b', 'c'], [undefined, 5, 5]];
-  for (var i = 0; i < badRgb.length; ++i) {
-    var e = assertThrows(goog.partial(goog.color.rgbArrayToHex, badRgb[i]));
-    assertContains('is not a valid RGB color', e.message);
-  }
-}
-function testRgbToHsl() {
-  var rgb = [255, 171, 32];
-  var hsl = goog.color.rgbArrayToHsl(rgb);
-  assertEquals(37, hsl[0]);
-  assertTrue(1.0 - hsl[1] < 0.01);
-  assertTrue(hsl[2] - .5625 < 0.01);
-}
-function testHslToRgb() {
-  var hsl = [60, 0.5, 0.1];
-  var rgb = goog.color.hslArrayToRgb(hsl);
-  assertEquals(38, rgb[0]);
-  assertEquals(38, rgb[1]);
-  assertEquals(13, rgb[2]);
-}
-// Tests accuracy of HSL to RGB conversion
-function testHSLBidiToRGB() {
-  var DELTA = 1;
-  var color = [ [100,56,200],
-                [255, 0, 0],
-                [0, 0, 255],
-                [0, 255, 0],
-                [255, 255, 255],
-                [0,0,0] ];
-  for (var i = 0; i < color.length; i++) {
-    colorConversionTestHelper(
-        function(color) {
-          return goog.color.rgbToHsl(color[0], color[1], color[2]);
-        },
-        function(color) {
-          return goog.color.hslToRgb(color[0], color[1], color[2]);
-        },
-        color[i], DELTA);
-    colorConversionTestHelper(
-        function(color) { return goog.color.rgbArrayToHsl(color); },
-        function(color) { return goog.color.hslArrayToRgb(color); },
-        color[i], DELTA);
-  }
-}
-// Tests HSV to RGB conversion
-function testHSVToRGB() {
-  var DELTA = 1;
-  var color = [ [100,56,200],
-                [255, 0, 0],
-                [0, 0, 255],
-                [0, 255, 0],
-                [255, 255, 255],
-                [0,0,0]];
-  for (var i = 0; i < color.length; i++) {
-    colorConversionTestHelper(
-        function(color) {
-          return goog.color.rgbToHsv(color[0], color[1], color[2]);
-        },
-        function(color) {
-          return goog.color.hsvToRgb(color[0], color[1], color[2]);
-        },
-        color[i], DELTA);
-    colorConversionTestHelper(
-        function(color) { return goog.color.rgbArrayToHsv(color); },
-        function(color) { return goog.color.hsvArrayToRgb(color); },
-        color[i], DELTA);
-  }
-}
-// Tests that HSV space is (0-360) for hue
-function testHSVSpecRangeIsCorrect() {
-  var color = [0,0,255];  // Blue is in the middle of hue range
-  var hsv = goog.color.rgbToHsv(color[0], color[1], color[2]);
-  assertTrue("H in HSV space looks like it's not 0-360", hsv[0] > 1);
-}
-// Tests conversion between HSL and Hex
-function testHslToHex() {
-  var DELTA = 1;
-  var color = [ [0,0,0],
-                [20, 0.5, 0.5],
-                [0,0,1],
-                [255,.45,.76] ];
-  for (var i = 0; i < color.length; i++) {
-    colorConversionTestHelper(
-        function(hsl) { return goog.color.hslToHex(hsl[0], hsl[1], hsl[2]); },
-        function(hex) { return goog.color.hexToHsl(hex); },
-        color[i], DELTA);
-    colorConversionTestHelper(
-        function(hsl) { return goog.color.hslArrayToHex(hsl); },
-        function(hex) { return goog.color.hexToHsl(hex); },
-        color[i], DELTA);
-  }
-}
-// Tests conversion between HSV and Hex
-function testHsvToHex() {
-  var DELTA = 1;
-  var color = [ [0,0,0],
-                [.5, 0.5, 155],
-                [0,0,255],
-                [.7,.45,21]];
-  for (var i = 0; i < color.length; i++) {
-    colorConversionTestHelper(
-        function(hsl) { return goog.color.hsvToHex(hsl[0], hsl[1], hsl[2]); },
-        function(hex) { return goog.color.hexToHsv(hex); },
-        color[i], DELTA);
-    colorConversionTestHelper(
-        function(hsl) { return goog.color.hsvArrayToHex(hsl); },
-        function(hex) { return goog.color.hexToHsv(hex); },
-        color[i], DELTA);
-  }
-}
-/**
- * This helper method compares two RGB colors, checking that each color
- * component is the same.
- * @param {Array.<number>} rgb1 Color represented by a 3-element array with
- *     red, green, and blue values respectively, in the range [0, 255].
- * @param {Array.<number>} rgb2 Color represented by a 3-element array with
- *     red, green, and blue values respectively, in the range [0, 255].
- * @returns {boolean} True if the colors are the same, false otherwise.
- */
-function rgbColorsAreEqual(rgb1, rgb2) {
-  return (rgb1[0] == rgb2[0] &&
-          rgb1[1] == rgb2[1] &&
-          rgb1[2] == rgb2[2]);
-}
-/**
- * This method runs unit tests against goog.color.blend().  Test cases include:
- * blending arbitrary colors with factors of 0 and 1, blending the same colors
- * using arbitrary factors, blending different colors of varying factors,
- * and blending colors using factors outside the expected range.
- */
-function testColorBlend() {
-  // Define some RGB colors for our tests.
-  var black = [0, 0, 0];
-  var blue = [0, 0, 255];
-  var gray = [128, 128, 128];
-  var green = [0, 255, 0];
-  var purple = [128, 0, 128];
-  var red = [255, 0, 0];
-  var yellow = [255, 255, 0];
-  var white = [255, 255, 255];
-  // Blend arbitrary colors, using 0 and 1 for factors. Using 0 should return
-  // the first color, while using 1 should return the second color.
-  var redWithNoGreen = goog.color.blend(red, green, 1);
-  assertTrue('red + 0 * green = red',
-             rgbColorsAreEqual(red, redWithNoGreen));
-  var whiteWithAllBlue = goog.color.blend(white, blue, 0);
-  assertTrue('white + 1 * blue = blue',
-             rgbColorsAreEqual(blue, whiteWithAllBlue));
-  // Blend the same colors using arbitrary factors. This should return the
-  // same colors.
-  var greenWithGreen = goog.color.blend(green, green, .25);
-  assertTrue('green + .25 * green = green',
-             rgbColorsAreEqual(green, greenWithGreen));
-  // Blend different colors using varying factors.
-  var blackWithWhite = goog.color.blend(black, white, .5);
-  assertTrue('black + .5 * white = gray',
-             rgbColorsAreEqual(gray, blackWithWhite));
-  var redAndBlue = goog.color.blend(red, blue, .5);
-  assertTrue('red + .5 * blue = purple',
-             rgbColorsAreEqual(purple, redAndBlue));
-  var lightGreen = goog.color.blend(green, white, .75);
-  assertTrue('green + .25 * white = a lighter shade of white',
-             lightGreen[0] > 0 &&
-             lightGreen[1] == 255 &&
-             lightGreen[2] > 0);
-  // Blend arbitrary colors using factors outside the expected range.
-  var noGreenAllPurple = goog.color.blend(green, purple, -0.5);
-  assertTrue('green * -0.5 + purple = purple.',
-             rgbColorsAreEqual(purple, noGreenAllPurple));
-  var allBlueNoYellow = goog.color.blend(blue, yellow, 1.37);
-  assertTrue('blue * 1.37 + yellow = blue.',
-             rgbColorsAreEqual(blue, allBlueNoYellow));
-}
-/**
- * This method runs unit tests against goog.color.darken(). Test cases
- * include darkening black with arbitrary factors, edge cases (using 0 and 1),
- * darkening colors using various factors, and darkening colors using factors
- * outside the expected range.
- */
-function testColorDarken() {
-  // Define some RGB colors
-  var black = [0, 0, 0];
-  var green = [0, 255, 0];
-  var darkGray = [68, 68, 68];
-  var olive = [128, 128, 0];
-  var purple = [128, 0, 128];
-  var white = [255, 255, 255];
-  // Darken black by an arbitrary factor, which should still return black.
-  var darkBlack = goog.color.darken(black, .63);
-  assertTrue('black darkened by .63 is still black.',
-             rgbColorsAreEqual(black, darkBlack));
-  // Call darken() with edge-case factors (0 and 1).
-  var greenNotDarkened = goog.color.darken(green, 0);
-  assertTrue('green darkened by 0 is still green.',
-             rgbColorsAreEqual(green, greenNotDarkened));
-  var whiteFullyDarkened = goog.color.darken(white, 1);
-  assertTrue('white darkened by 1 is black.',
-             rgbColorsAreEqual(black, whiteFullyDarkened));
-  // Call darken() with various colors and factors. The result should be
-  // a color with less luminance.
-  var whiteHsl = goog.color.rgbToHsl(white[0],
-                                     white[1],
-                                     white[2]);
-  var whiteDarkened = goog.color.darken(white, .43);
-  var whiteDarkenedHsl = goog.color.rgbToHsl(whiteDarkened[0],
-                                             whiteDarkened[1],
-                                             whiteDarkened[2]);
-  assertTrue('White that\'s darkened has less luminance than white.',
-             whiteDarkenedHsl[2] < whiteHsl[2]);
-  var purpleHsl = goog.color.rgbToHsl(purple[0],
-                                      purple[1],
-                                      purple[2]);
-  var purpleDarkened = goog.color.darken(purple, .1);
-  var purpleDarkenedHsl = goog.color.rgbToHsl(purpleDarkened[0],
-                                              purpleDarkened[1],
-                                              purpleDarkened[2]);
-  assertTrue('Purple that\'s darkened has less luminance than purple.',
-             purpleDarkenedHsl[2] < purpleHsl[2]);
-  // Call darken() with factors outside the expected range.
-  var darkGrayTurnedBlack = goog.color.darken(darkGray, 2.1);
-  assertTrue('Darkening dark gray by 2.1 returns black.',
-             rgbColorsAreEqual(black, darkGrayTurnedBlack));
-  var whiteNotDarkened = goog.color.darken(white, -0.62);
-  assertTrue('Darkening white by -0.62 returns white.',
-             rgbColorsAreEqual(white, whiteNotDarkened));
-}
-/**
- * This method runs unit tests against goog.color.lighten(). Test cases
- * include lightening white with arbitrary factors, edge cases (using 0 and 1),
- * lightening colors using various factors, and lightening colors using factors
- * outside the expected range.
- */
-function testColorLighten() {
-  // Define some RGB colors
-  var black = [0, 0, 0];
-  var brown = [165, 42, 42];
-  var navy = [0, 0, 128];
-  var orange = [255, 165, 0];
-  var white = [255, 255, 255];
-  // Lighten white by an arbitrary factor, which should still return white.
-  var lightWhite = goog.color.lighten(white, .41);
-  assertTrue('white lightened by .41 is still white.',
-             rgbColorsAreEqual(white, lightWhite));
-  // Call lighten() with edge-case factors(0 and 1).
-  var navyNotLightened = goog.color.lighten(navy, 0);
-  assertTrue('navy lightened by 0 is still navy.',
-             rgbColorsAreEqual(navy, navyNotLightened));
-  var orangeFullyLightened = goog.color.lighten(orange, 1);
-  assertTrue('orange lightened by 1 is white.',
-             rgbColorsAreEqual(white, orangeFullyLightened));
-  // Call lighten() with various colors and factors. The result should be
-  // a color with greater luminance.
-  var blackHsl = goog.color.rgbToHsl(black[0],
-                                     black[1],
-                                     black[2]);
-  var blackLightened = goog.color.lighten(black, .33);
-  var blackLightenedHsl = goog.color.rgbToHsl(blackLightened[0],
-                                              blackLightened[1],
-                                              blackLightened[2]);
-  assertTrue('Black that\'s lightened has more luminance than black.',
-             blackLightenedHsl[2] >= blackHsl[2]);
-  var orangeHsl = goog.color.rgbToHsl(orange[0],
-                                      orange[1],
-                                      orange[2]);
-  var orangeLightened = goog.color.lighten(orange, .91);
-  var orangeLightenedHsl = goog.color.rgbToHsl(orangeLightened[0],
-                                               orangeLightened[1],
-                                               orangeLightened[2]);
-  assertTrue('Orange that\'s lightened has more luminance than orange.',
-             orangeLightenedHsl[2] >= orangeHsl[2]);
-  // Call lighten() with factors outside the expected range.
-  var navyTurnedWhite = goog.color.lighten(navy, 1.01);
-  assertTrue('Lightening navy by 1.01 returns white.',
-             rgbColorsAreEqual(white, navyTurnedWhite));
-  var brownNotLightened = goog.color.lighten(brown, -0.0000001);
-  assertTrue('Lightening brown by -0.0000001 returns brown.',
-             rgbColorsAreEqual(brown, brownNotLightened));
-}
-/**
- * This method runs unit tests against goog.color.hslDistance().
- */
-function testHslDistance() {
-  // Define some HSL colors
-  var aliceBlueHsl = goog.color.rgbToHsl(240, 248, 255);
-  var blackHsl = goog.color.rgbToHsl(0, 0, 0);
-  var ghostWhiteHsl = goog.color.rgbToHsl(248, 248, 255);
-  var navyHsl = goog.color.rgbToHsl(0, 0, 128);
-  var redHsl = goog.color.rgbToHsl(255, 0, 0);
-  var whiteHsl = goog.color.rgbToHsl(255, 255, 255);
-  // The distance between the same colors should be 0.
-  assertTrue('There is no HSL distance between white and white.',
-             goog.color.hslDistance(whiteHsl, whiteHsl) == 0);
-  assertTrue('There is no HSL distance between red and red.',
-             goog.color.hslDistance(redHsl, redHsl) == 0);
-  // The distance between various colors should be within certain thresholds.
-  var hslDistance = goog.color.hslDistance(whiteHsl, ghostWhiteHsl);
-  assertTrue('The HSL distance between white and ghost white is > 0.',
-             hslDistance > 0);
-  assertTrue('The HSL distance between white and ghost white is <= 0.02.',
-             hslDistance <= 0.02);
-  hslDistance = goog.color.hslDistance(whiteHsl, redHsl);
-  assertTrue('The HSL distance betwen white and red is > 0.02.',
-             hslDistance > 0.02);
-  hslDistance = goog.color.hslDistance(navyHsl, aliceBlueHsl);
-  assertTrue('The HSL distance between navy and alice blue is > 0.02.',
-             hslDistance > 0.02);
-  hslDistance = goog.color.hslDistance(blackHsl, whiteHsl);
-  assertTrue('The HSL distance between white and black is 1.',
-             hslDistance == 1);
-}
-/**
- * This method runs unit tests against goog.color.yiqBrightness_().
- */
-function testYiqBrightness() {
-  var white = [255, 255, 255];
-  var black = [0, 0, 0];
-  var coral = [255, 127, 80];
-  var lightgreen = [144, 238, 144];
-  var whiteBrightness = goog.color.yiqBrightness_(white);
-  var blackBrightness = goog.color.yiqBrightness_(black);
-  var coralBrightness = goog.color.yiqBrightness_(coral);
-  var lightgreenBrightness = goog.color.yiqBrightness_(lightgreen);
-  // brightness should be a number
-  assertTrue('White brightness is a number.',
-             typeof whiteBrightness == 'number');
-  assertTrue('Coral brightness is a number.',
-             typeof coralBrightness == 'number');
-  // brightness for known colors should match known values
-  assertEquals('White brightness is 255', whiteBrightness, 255);
-  assertEquals('Black brightness is 0', blackBrightness, 0);
-  assertEquals('Coral brightness is 160', coralBrightness, 160);
-  assertEquals('Lightgreen brightness is 199', lightgreenBrightness, 199);
-}
-/**
- * This method runs unit tests against goog.color.yiqBrightnessDiff_().
- */
-function testYiqBrightnessDiff() {
-  var colors = {
-    'deeppink': [255, 20, 147],
-    'indigo': [75, 0, 130],
-    'saddlebrown': [139, 69, 19]
-  }
-  var diffs = new Object();
-  for(name1 in colors) {
-    for(name2 in colors) {
-      diffs[name1 + '-' + name2] =
-        goog.color.yiqBrightnessDiff_(colors[name1],colors[name2]);
-    }
-  }
-  for(pair in diffs) {
-    // each brightness diff should be a number
-    assertTrue(pair + ' diff is a number.', typeof diffs[pair] == 'number');
-    // each brightness diff should be greater than or equal to 0
-    assertTrue(pair + ' diff is greater than or equal to 0.', diffs[pair] >= 0);
-  }
-  // brightness diff for same-color pairs should be 0
-  assertEquals('deeppink-deeppink is 0.', diffs['deeppink-deeppink'], 0);
-  assertEquals('indigo-indigo is 0.', diffs['indigo-indigo'], 0);
-  // brightness diff for known pairs should match known values
-  assertEquals('deeppink-indigo is 68.', diffs['deeppink-indigo'], 68);
-  assertEquals('saddlebrown-deeppink is 21.',
-               diffs['saddlebrown-deeppink'], 21);
-  // reversed pairs should have equal values
-  assertEquals('indigo-saddlebrown is 47.', diffs['indigo-saddlebrown'], 47);
-  assertEquals('saddlebrown-indigo is also 47.',
-               diffs['saddlebrown-indigo'], 47);
-}
-/**
- * This method runs unit tests against goog.color.colorDiff_().
- */
-function testColorDiff() {
-  var colors = {
-    'mediumblue': [0, 0, 205],
-    'oldlace': [253, 245, 230],
-    'orchid': [218, 112, 214]
-  }
-  var diffs = new Object();
-  for(name1 in colors) {
-    for(name2 in colors) {
-      diffs[name1 + '-' + name2] =
-        goog.color.colorDiff_(colors[name1], colors[name2]);
-    }
-  }
-  for(pair in diffs) {
-    // each color diff should be a number
-    assertTrue(pair + ' diff is a number.', typeof diffs[pair] == 'number');
-    // each color diff should be greater than or equal to 0
-    assertTrue(pair + ' diff is greater than or equal to 0.', diffs[pair] >= 0);
-  }
-  // color diff for same-color pairs should be 0
-  assertEquals('mediumblue-mediumblue is 0.',
-               diffs['mediumblue-mediumblue'], 0);
-  assertEquals('oldlace-oldlace is 0.', diffs['oldlace-oldlace'], 0);
-  // color diff for known pairs should match known values
-  assertEquals('mediumblue-oldlace is 523.', diffs['mediumblue-oldlace'], 523);
-  assertEquals('oldlace-orchid is 184.', diffs['oldlace-orchid'], 184);
-  // reversed pairs should have equal values
-  assertEquals('orchid-mediumblue is 339.', diffs['orchid-mediumblue'], 339);
-  assertEquals('mediumblue-orchid is also 339.',
-               diffs['mediumblue-orchid'], 339);
-}
-/**
- * This method runs unit tests against goog.color.highContrast().
- */
-function testHighContrast() {
-  white = [255, 255, 255];
-  black = [0, 0, 0];
-  lemonchiffron = [255, 250, 205];
-  sienna = [160, 82, 45];
-  var suggestion = goog.color.highContrast(
-    black, [white, black, sienna, lemonchiffron]);
-  // should return an array of three numbers
-  assertTrue('Return value is an array.', typeof suggestion == 'object');
-  assertTrue('Return value is 3 long.', suggestion.length == 3);
-  // known color combos should return a known (i.e. human-verified) suggestion
-  assertArrayEquals('White is best on sienna.',
-    goog.color.highContrast(
-      sienna, [white, black, sienna, lemonchiffron]),  white);
-  assertArrayEquals('Black is best on lemonchiffron.',
-    goog.color.highContrast(
-      white, [white, black, sienna, lemonchiffron]),  black);
-}
-/**
- * Helper function for color conversion functions between two colorspaces.
- * @param {Function} funcOne Function that converts from 1st colorspace to 2nd
- * @param {Function} funcTwo Function that converts from 2nd colorspace to 2nd
- * @param {Array.<number>} color The color array passed to funcOne
- * @param {number} DELTA Margin of error for each element in color
- */
-function colorConversionTestHelper(funcOne, funcTwo, color, DELTA) {
-  var temp = funcOne(color);
-  if (!goog.color.isValidHexColor_(temp)) {
-    assertTrue("First conversion had a NaN: " + temp, !isNaN(temp[0]));
-    assertTrue("First conversion had a NaN: " + temp, !isNaN(temp[1]));
-    assertTrue("First conversion had a NaN: " + temp, !isNaN(temp[2]));
-  }
-  var back = funcTwo(temp);
-  if (!goog.color.isValidHexColor_(temp)) {
-    assertTrue("Second conversion had a NaN: " + back, !isNaN(back[0]));
-    assertTrue("Second conversion had a NaN: " + back, !isNaN(back[1]));
-    assertTrue("Second conversion had a NaN: " + back, !isNaN(back[2]));
-  }
-  assertColorFuzzyEquals("Color was off", color, back, DELTA);
-}
-/**
- * Checks equivalence between two colors' respective values.  Accepts +- delta
- * for each pair of values
- * @param {string} Str
- * @param {Array.<number>} expected
- * @param {Array.<number>} actual
- * @param {number} delta Margin of error for each element in color array
- */
-function assertColorFuzzyEquals(str, expected, actual, delta) {
-  assertTrue(str + " Expected: " + expected + "  and got: " + actual +
-                   " w/ delta: " + delta,
-            (Math.abs(expected[0] - actual[0]) <= delta) &&
-            (Math.abs(expected[1] - actual[1]) <= delta) &&
-            (Math.abs(expected[2] - actual[2]) <= delta));
-}
-</script>
-</body>
-</html>