1 var assert = require("assert");

     2 

     3 assert.inDelta = function(actual, expected, delta, message) {

     4   if (!inDelta(actual, expected, delta)) {

     5     assert.fail(actual, expected, message || "expected {actual} to be in within *" + delta + "* of {expected}", null, assert.inDelta);

     6   }

     7 };

     8 

     9 assert.domNull = function(actual, message) {

    10   if (actual !== null) {

    11     assert.fail(actual+"", null, message || "expected null, got {actual}", "===", assert.domNull);

    12   }

    13 };

    14 

    15 assert.domEqual = function(actual, expected, message) {

    16   if (actual !== expected) {

    17     assert.fail(actual+"", expected+"", message || "expected {expected}, got {actual}", "===", assert.domEqual);

    18   }

    19 };

    20 

    21 assert.rgbEqual = function(actual, r, g, b, message) {

    22   if (actual.r !== r || actual.g !== g || actual.b !== b) {

    23     assert.fail("rgb(" + actual.r + "," + actual.g + "," + actual.b + ")", "rgb(" + r + ", " + g + ", " + b + ")", message || "expected {expected}, got {actual}", "===", assert.rgbEqual);

    24   }

    25 };

    26 

    27 assert.hslEqual = function(actual, h, s, l, message) {

    28   if (Math.abs(actual.h - h) > 1e-6 || Math.abs(actual.s - s) > 1e-6 || Math.abs(actual.l - l) > 1e-6) {

    29     assert.fail("hsl(" + actual.h + "," + (actual.s * 100) + "%," + (actual.l * 100) + "%)", "hsl(" + h + "," + (s * 100) + "%," + (l * 100) + "%)", message || "expected {expected}, got {actual}", null, assert.hslEqual);

    30   }

    31 };

    32 

    33 assert.pathEqual = function(actual, expected, message) {

    34   if (!pathEqual(actual, expected)) {

    35     assert.fail(formatPath(actual), formatPath(expected), message || "expected {expected}, got {actual}", null, assert.pathEqual);

    36   }

    37 };

    38 

    39 function inDelta(actual, expected, delta) {

    40   return (Array.isArray(expected) ? inDeltaArray : inDeltaNumber)(actual, expected, delta);

    41 }

    42 

    43 function inDeltaArray(actual, expected, delta) {

    44   var n = expected.length, i = -1;

    45   if (actual.length !== n) return false;

    46   while (++i < n) if (!inDelta(actual[i], expected[i], delta)) return false;

    47   return true;

    48 }

    49 

    50 function inDeltaNumber(actual, expected, delta) {

    51   return actual >= expected - delta && actual <= expected + delta;

    52 }

    53 

    54 function pathEqual(a, b) {

    55   a = parsePath(a);

    56   b = parsePath(b);

    57   var n = a.length, i = -1, x, y;

    58   if (n !== b.length) return false;

    59   while (++i < n) {

    60     x = a[i];

    61     y = b[i];

    62     if (typeof x === "string") {

    63       if (x !== y) return false;

    64     } else if (typeof y !== "number") {

    65       return false;

    66     } else if (Math.abs(x - y) > 1e-6) {

    67       return false;

    68     }

    69   }

    70   return true;

    71 }

    72 

    73 var reNumber = /[-+]?(?:\d+\.\d+|\d+\.|\.\d+|\d+)(?:[eE][-]?\d+)?/g;

    74 

    75 function parsePath(path) {

    76   var parts = [];

    77   reNumber.lastIndex = 0;

    78   for (var i = 0, s0 = 0, s1, m; m = reNumber.exec(path); ++i) {

    79     if (m.index) {

    80       var part = path.substring(s0, s1 = m.index);

    81       if (!/^[, ]$/.test(part)) parts.push(part);

    82     }

    83     parts.push(parseFloat(m[0]));

    84     s0 = reNumber.lastIndex;

    85   }

    86   if (s0 < path.length) parts.push(path.substring(s0));

    87   return parts;

    88 }

    89 

    90 function formatPath(path) {

    91   return path.replace(reNumber, formatNumber);

    92 }

    93 

    94 function formatNumber(s) {

    95   return Math.abs((s = +s) - Math.floor(s)) < 1e-6 ? Math.floor(s) : s.toFixed(6);

    96 }