stripmem 0.0.1

data/lib/stripmem/public/components/d3/test/geom/voronoi-test.js

@@ -0,0 +1,230 @@
+var vows = require("vows"),
+    load = require("../load"),
+    assert = require("../assert");
+
+var suite = vows.describe("d3.geom.voronoi");
+
+suite.addBatch({
+  "voronoi": {
+    topic: load("geom/voronoi").expression("d3.geom.voronoi"),
+
+    "the default voronoi layout": {
+      topic: function(voronoi) {
+        return voronoi();
+      },
+      "has no defined clip extent": function(v) {
+        assert.isNull(v.clipExtent());
+      },
+      "has no defined size": function(v) {
+        assert.isNull(v.size());
+      },
+      "returns the configured clip extent": function(v) {
+        try {
+          assert.deepEqual(v.clipExtent([[1, 2], [3, 4]]).clipExtent(), [[1, 2], [3, 4]]);
+        } finally {
+          v.clipExtent(null);
+        }
+      },
+      "returns the configured size": function(v) {
+        try {
+          assert.deepEqual(v.size([1, 2]).size(), [1, 2]);
+        } finally {
+          v.size(null);
+        }
+      },
+      "size implies a clip extent from [0, 0]": function(v) {
+        try {
+          assert.deepEqual(v.size([1, 2]).clipExtent(), [[0, 0], [1, 2]]);
+        } finally {
+          v.size(null);
+        }
+      },
+      "clip extent implies a size, assuming [0, 0]": function(v) {
+        try {
+          assert.deepEqual(v.clipExtent([[1, 2], [3, 4]]).size(), [3, 4]);
+        } finally {
+          v.clipExtent(null);
+        }
+      },
+      "has the default x-accessor, d[0]": function(v) {
+        assert.strictEqual(v.x()([42, 43]), 42);
+      },
+      "has the default y-accessor, d[1]": function(v) {
+        assert.strictEqual(v.y()([42, 43]), 43);
+      },
+      "of two points": {
+        topic: function(v) {
+          return v([[200, 200], [760, 300]]);
+        },
+        "returns two cells with the expected geometry": function(cells) {
+          assert.inDelta(cells, [
+            [[-178046.7857142857, 1e6], [179096.07142857145, -1e6], [-1e6, 1e6], [1e6, 1e6]],
+            [[-178046.7857142857, 1e6], [179096.07142857145, -1e6], [-1e6, -1e6], [1e6, -1e6]]
+          ], 1e-6);
+        },
+        "the returned cells are open polygons": function(cells) {
+          cells.forEach(function(cell) {
+            assert.greater(cell.length, 2);
+            cell.forEach(function(point) {
+              assert.equal(point.length, 2);
+              assert.isNumber(point[0]);
+              assert.isNumber(point[1]);
+            });
+            assert.notDeepEqual(cell[0], cell[cell.length - 1]);
+          });
+        },
+        "the returned cells are not clipped to the layout size": function(cells) {
+          var x0 = Infinity, x1 = -Infinity, y0 = Infinity, y1 = -Infinity;
+          cells.forEach(function(cell) {
+            cell.forEach(function(point) {
+              if (point[0] < x0) x0 = point[0];
+              if (point[0] > x1) x1 = point[0];
+              if (point[1] < y0) y0 = point[1];
+              if (point[1] > y1) y1 = point[1];
+            });
+          });
+          assert.strictEqual(x0, -1e6);
+          assert.strictEqual(x1, 1e6);
+          assert.strictEqual(y0, -1e6);
+          assert.strictEqual(y1, 1e6);
+        },
+        "the returned cells' point property points back to the input point": function(cells) {
+          assert.deepEqual(cells.map(function(cell) { return cell.point; }), [[200, 200], [760, 300]]);
+        }
+      },
+      "links": {
+        "for two points": function(v) {
+          assert.deepEqual(v.links([[200, 200], [760, 300]]), [
+            {source: [200, 200], target: [760, 300]}
+          ]);
+        },
+        "for three points": function(v) {
+          assert.deepEqual(v.links([[200, 200], [500, 250], [760, 300]]), [
+            {source: [200, 200], target: [760, 300]},
+            {source: [500, 250], target: [760, 300]},
+            {source: [200, 200], target: [500, 250]}
+          ]);
+        }
+      },
+      "triangles": {
+        "for three points": function(v) {
+          assert.deepEqual(asArray(v.triangles([[200, 200], [500, 250], [760, 300]])), [
+            [[200, 200], [760, 300], [500, 250]]
+          ]);
+        }
+      }
+    },
+
+    "a voronoi layout with custom x- and y-accessors": {
+      topic: function(voronoi) {
+        return voronoi()
+            .x(function(d) { return d.x; })
+            .y(43);
+      },
+      "observes the specified x-accessor, a function": function(v) {
+        assert.strictEqual(v.x()({x: 42, y: 43}), 42);
+      },
+      "observes the specified y-accessor, a constant": function(v) {
+        assert.strictEqual(v.y(), 43);
+      },
+      "of two points": {
+        topic: function(v) {
+          return v([{x: 200}, {x: 760}]);
+        },
+        "returns two cells with the expected geometry": function(cells) {
+          assert.inDelta(cells, [
+            [[480, 1e6], [480, -1e6], [-1e6, -1e6], [-1e6, 1e6]],
+            [[480, -1e6], [480, 1e6], [1e6, -1e6], [1e6, 1e6]]
+          ], 1e-6);
+        }
+      },
+      "links": {
+        topic: function(v) {
+          return v.y(function(d) { return d.y; });
+        },
+        "for two points": function(v) {
+          assert.deepEqual(v.links([{x: 200, y: 200}, {x: 760, y: 300}]), [
+            {source: {x: 200, y: 200}, target: {x: 760, y: 300}}
+          ]);
+        },
+        "for three points": function(v) {
+          assert.deepEqual(v.links([{x: 200, y: 200}, {x: 500, y: 250}, {x: 760, y: 300}]), [
+            {source: {x: 200, y: 200}, target: {x: 760, y: 300}},
+            {source: {x: 500, y: 250}, target: {x: 760, y: 300}},
+            {source: {x: 200, y: 200}, target: {x: 500, y: 250}}
+          ]);
+        }
+      }
+    },
+
+    "a voronoi layout with clip extent [[0, 0], [960, 500]]": {
+      topic: function(voronoi) {
+        return voronoi()
+            .x(function(d) { return d.x; })
+            .y(function(d) { return d.y; })
+            .clipExtent([[0, 0], [960, 500]]);
+      },
+      "of two points": {
+        topic: function(v) {
+          return v([{x: 200, y: 200}, {x: 760, y: 300}]);
+        },
+        "returns two cells with the expected geometry": function(cells) {
+          assert.inDelta(cells, [
+            [[435.35714285715324, 500], [524.6428571428696, 0], [0, 0], [0, 500]],
+            [[960, 0], [960, 500], [435.35714285715324, 500], [524.6428571428696, 0]]
+          ], 1e-6);
+        },
+        "the returned cells are clipped to the layout size": function(cells) {
+          assert.isTrue(cells.every(function(cell) {
+            return cell.every(function(point) {
+              return point[0] >= 0 && point[0] <= 960
+                  && point[1] >= 0 && point[1] <= 500;
+            });
+          }));
+        }
+      }
+    },
+
+    "the default voronoi layout applied directly": {
+      "with zero points": {
+        "returns the empty array": function(voronoi) {
+          assert.deepEqual(voronoi([]), []);
+        }
+      },
+      "with one point": {
+        "returns the semi-infinite bounding box": function(voronoi) {
+          assert.deepEqual(asArray(voronoi([[50, 50]], 100, 100)), [[[-1000000,-1000000],[-1000000,1000000],[1000000,1000000],[1000000,-1000000]]]);
+        }
+      },
+      "with two points": {
+        "separated by a line at 90° (vertical)": function(voronoi) {
+          assert.deepEqual(asArray(voronoi([[50, 25], [50, 75]], 100, 100)), [[[-1000000,50],[1000000,50],[-1000000,-1000000],[1000000,-1000000]],[[-1000000,50],[1000000,50],[-1000000,1000000],[1000000,1000000]]]);
+          assert.deepEqual(asArray(voronoi([[50, 75], [50, 25]], 100, 100)), [[[-1000000,50],[1000000,50],[-1000000,1000000],[1000000,1000000]],[[-1000000,50],[1000000,50],[-1000000,-1000000],[1000000,-1000000]]]);
+        },
+        "separated by a line at 0° (horizontal)": function(voronoi) {
+          assert.deepEqual(asArray(voronoi([[25, 50], [75, 50]], 100, 100)), [[[50,1000000],[50,-1000000],[-1000000,-1000000],[-1000000,1000000]],[[50,-1000000],[50,1000000],[1000000,-1000000],[1000000,1000000]]]);
+          assert.deepEqual(asArray(voronoi([[75, 50], [25, 50]], 100, 100)), [[[50,-1000000],[50,1000000],[1000000,-1000000],[1000000,1000000]],[[50,1000000],[50,-1000000],[-1000000,-1000000],[-1000000,1000000]]]);
+        },
+        "separated by a line at 45° (diagonal)": function(voronoi) {
+          assert.deepEqual(asArray(voronoi([[25, 25], [75, 75]], 100, 100)), [[[-999900,1000000],[1000100,-1000000],[-1000000,-1000000]],[[-999900,1000000],[1000100,-1000000],[1000000,1000000]]]);
+          assert.deepEqual(asArray(voronoi([[75, 25], [25, 75]], 100, 100)), [[[-1000000,-1000000],[1000000,1000000],[1000000,-1000000]],[[-1000000,-1000000],[1000000,1000000],[-1000000,1000000]]]);
+        },
+        "separated by an arbitrary diagonal": function(voronoi) {
+          assert.deepEqual(asArray(voronoi([[25, 25], [50, 75]], 100, 100)), [[[-1000000,500068.75],[1000000,-499931.25],[-1000000,-1000000],[1000000,-1000000]],[[-1000000,500068.75],[1000000,-499931.25],[-1000000,1000000],[1000000,1000000]]]);
+          assert.deepEqual(asArray(voronoi([[25, 25], [75, 50]], 100, 100)), [[[-499931.25,1000000],[500068.75,-1000000],[-1000000,1000000],[1000000,1000000]], [[-499931.25,1000000],[500068.75,-1000000],[-1000000,-1000000],[1000000,-1000000]]]);
+        }
+      },
+      "with three points": {
+        "collinear": function(voronoi) {
+          assert.deepEqual(asArray(voronoi([[25, 25], [50, 50], [75, 75]], 100, 100)), [[[-999925,1000000],[1000075,-1000000],[-1000000,-1000000]],[[-999925,1000000],[-999875,1000000],[1000125,-1000000],[1000075,-1000000]],[[-999875,1000000],[1000125,-1000000],[1000000,1000000]]]);
+        }
+      }
+    }
+  }
+});
+
+suite.export(module);
+
+function asArray(array) {
+  return Array.isArray(array) ? array.map(asArray) : array;
+}

data/lib/stripmem/public/components/d3/test/interpolate/array-test.js

@@ -0,0 +1,24 @@
+var vows = require("vows"),
+    load = require("../load"),
+    assert = require("../assert");
+
+var suite = vows.describe("d3.interpolateArray");
+
+suite.addBatch({
+  "interpolateArray": {
+    topic: load("interpolate/array").expression("d3.interpolateArray"),
+    "interpolates defined elements": function(interpolate) {
+      assert.deepEqual(interpolate([2, 12], [4, 24])(.5), [3, 18]);
+    },
+    "interpolates nested objects and arrays": function(interpolate) {
+      assert.deepEqual(interpolate([[2, 12]], [[4, 24]])(.5), [[3, 18]]);
+      assert.deepEqual(interpolate([{foo: [2, 12]}], [{foo: [4, 24]}])(.5), [{foo: [3, 18]}]);
+    },
+    "merges non-shared elements": function(interpolate) {
+      assert.deepEqual(interpolate([2, 12], [4, 24, 12])(.5), [3, 18, 12]);
+      assert.deepEqual(interpolate([2, 12, 12], [4, 24])(.5), [3, 18, 12]);
+    }
+  }
+});
+
+suite.export(module);

data/lib/stripmem/public/components/d3/test/interpolate/ease-test.js

@@ -0,0 +1,135 @@
+var vows = require("vows"),
+    load = require("../load"),
+    assert = require("../assert");
+
+var suite = vows.describe("d3.ease");
+
+suite.addBatch({
+  "ease": {
+    topic: load("interpolate/ease").expression("d3.ease"),
+    "supports linear easing": function(ease) {
+      var e = ease("linear");
+      assert.inDelta(e(.5), .5, 1e-6);
+    },
+    "supports polynomial easing": function(ease) {
+      var e = ease("poly", 2);
+      assert.inDelta(e(.5), .25, 1e-6);
+    },
+    "supports quadratic easing": function(ease) {
+      var e = ease("quad");
+      assert.inDelta(e(.5), .25, 1e-6);
+    },
+    "supports cubic easing": function(ease) {
+      var e = ease("cubic");
+      assert.inDelta(e(.5), .125, 1e-6);
+    },
+    "supports sinusoidal easing": function(ease) {
+      var e = ease("sin");
+      assert.inDelta(e(.5), 1 - Math.cos(Math.PI / 4), 1e-6);
+    },
+    "supports exponential easing": function(ease) {
+      var e = ease("exp");
+      assert.inDelta(e(.5), 0.03125, 1e-6);
+    },
+    "supports circular easing": function(ease) {
+      var e = ease("circle");
+      assert.inDelta(e(.5), 0.133975, 1e-6);
+    },
+    "supports elastic easing": function(ease) {
+      var e = ease("elastic");
+      assert.inDelta(e(.5), 0.976061, 1e-6);
+    },
+    "supports back easing": function(ease) {
+      var e = ease("back");
+      assert.inDelta(e(.5), -0.0876975, 1e-6);
+    },
+    "supports bounce easing": function(ease) {
+      var e = ease("bounce");
+      assert.inDelta(e(.5), 0.765625, 1e-6);
+    },
+    "invalid eases and modes default to linear-in": function(ease) {
+      var e = ease("__proto__-__proto__");
+      assert.strictEqual(e(0), 0);
+      assert.strictEqual(e(.5), .5);
+      assert.strictEqual(e(1), 1);
+      var e = ease("hasOwnProperty-constructor");
+      assert.strictEqual(e(0), 0);
+      assert.strictEqual(e(.5), .5);
+      assert.strictEqual(e(1), 1);
+    },
+    "all easing functions return exactly 0 for t = 0": function(ease) {
+      assert.strictEqual(ease("linear")(0), 0);
+      assert.strictEqual(ease("poly", 2)(0), 0);
+      assert.strictEqual(ease("quad")(0), 0);
+      assert.strictEqual(ease("cubic")(0), 0);
+      assert.strictEqual(ease("sin")(0), 0);
+      assert.strictEqual(ease("exp")(0), 0);
+      assert.strictEqual(ease("circle")(0), 0);
+      assert.strictEqual(ease("elastic")(0), 0);
+      assert.strictEqual(ease("back")(0), 0);
+      assert.strictEqual(ease("bounce")(0), 0);
+    },
+    "all easing functions return exactly 1 for t = 1": function(ease) {
+      assert.strictEqual(ease("linear")(1), 1);
+      assert.strictEqual(ease("poly", 2)(1), 1);
+      assert.strictEqual(ease("quad")(1), 1);
+      assert.strictEqual(ease("cubic")(1), 1);
+      assert.strictEqual(ease("sin")(1), 1);
+      assert.strictEqual(ease("exp")(1), 1);
+      assert.strictEqual(ease("circle")(1), 1);
+      assert.strictEqual(ease("elastic")(1), 1);
+      assert.strictEqual(ease("back")(1), 1);
+      assert.strictEqual(ease("bounce")(1), 1);
+    },
+    "the -in suffix returns the identity": function(ease) {
+      assert.inDelta(ease("linear-in")(.25), ease("linear")(.25), 1e-6);
+      assert.inDelta(ease("quad-in")(.75), ease("quad")(.75), 1e-6);
+    },
+    "the -out suffix returns the reverse": function(ease) {
+      assert.inDelta(ease("sin-out")(.25), 1 - ease("sin-in")(.75), 1e-6);
+      assert.inDelta(ease("bounce-out")(.25), 1 - ease("bounce-in")(.75), 1e-6);
+      assert.inDelta(ease("elastic-out")(.25), 1 - ease("elastic-in")(.75), 1e-6);
+    },
+    "the -in-out suffix returns the reflection": function(ease) {
+      assert.inDelta(ease("sin-in-out")(.25), .5 * ease("sin-in")(.5), 1e-6);
+      assert.inDelta(ease("bounce-in-out")(.25), .5 * ease("bounce-in")(.5), 1e-6);
+      assert.inDelta(ease("elastic-in-out")(.25), .5 * ease("elastic-in")(.5), 1e-6);
+    },
+    "the -out-in suffix returns the reverse reflection": function(ease) {
+      assert.inDelta(ease("sin-out-in")(.25), .5 * ease("sin-out")(.5), 1e-6);
+      assert.inDelta(ease("bounce-out-in")(.25), .5 * ease("bounce-out")(.5), 1e-6);
+      assert.inDelta(ease("elastic-out-in")(.25), .5 * ease("elastic-out")(.5), 1e-6);
+    },
+    "clamps input time": function(ease) {
+      var e = ease("linear");
+      assert.inDelta(e(-1), 0, 1e-6);
+      assert.inDelta(e(2), 1, 1e-6);
+    },
+    "poly": {
+      "supports an optional polynomial": function(ease) {
+        var e = ease("poly", 1);
+        assert.inDelta(e(.5), .5, 1e-6);
+        var e = ease("poly", .5);
+        assert.inDelta(e(.5), Math.SQRT1_2, 1e-6);
+      }
+    },
+    "elastic": {
+      "supports an optional amplifier (>1)": function(ease) {
+        var e = ease("elastic", 1.5);
+        assert.inDelta(e(.5), 0.998519, 1e-6);
+      },
+      "supports an optional amplifier (>1) and period (>0)": function(ease) {
+        var e = ease("elastic", 1.5, .5);
+        assert.inDelta(e(.5), 0.96875, 1e-6);
+      }
+    },
+    "back": {
+      "supports an optional speed": function(ease) {
+        var e = ease("back", 2);
+        assert.inDelta(e(.5), -0.125, 1e-6);
+      }
+    }
+  }
+});
+
+suite.export(module);

data/lib/stripmem/public/components/d3/test/interpolate/hcl-test.js

@@ -0,0 +1,47 @@
+var vows = require("vows"),
+    load = require("../load"),
+    assert = require("../assert");
+
+var suite = vows.describe("d3.interpolateHcl");
+
+suite.addBatch({
+  "interpolateHcl": {
+    topic: load("interpolate/hcl"), // beware instanceof d3_Color
+    "parses string input": function(d3) {
+      assert.hclEqual(d3.interpolateHcl("steelblue", "#f00")(.2), -69.78, 46.87, 52.62);
+      assert.hclEqual(d3.interpolateHcl("steelblue", "#f00")(.6), -14.89, 75.71, 52.93);
+    },
+    "parses d3.hsl input": function(d3) {
+      assert.hclEqual(d3.interpolateHcl(d3.hsl("steelblue"), "#f00")(.2), -69.78, 46.87, 52.62);
+      assert.hclEqual(d3.interpolateHcl("steelblue", d3.hsl(0, 1, .5))(.6), -14.89, 75.71, 52.93);
+    },
+    "parses d3.rgb input": function(d3) {
+      assert.hclEqual(d3.interpolateHcl(d3.rgb("steelblue"), "#f00")(.2), -69.78, 46.87, 52.62);
+      assert.hclEqual(d3.interpolateHcl("steelblue", d3.rgb(255, 0, 0))(.6), -14.89, 75.71, 52.93);
+    },
+    "interpolates in HSL color space": function(d3) {
+      assert.hclEqual(d3.interpolateHcl("steelblue", "#f00")(.2), -69.78, 46.87, 52.62);
+    },
+    "uses source hue when destination hue is undefined": function(d3) {
+      assert.hclEqual(d3.interpolateHcl("#f60", "#000")(.5), 52.36, 90.07, 31.16);
+      assert.hclEqual(d3.interpolateHcl("#6f0", "#000")(.5), 131.26, 112.84, 44.54);
+    },
+    "uses destination hue when source hue is undefined": function(d3) {
+      assert.hclEqual(d3.interpolateHcl("#000", "#f60")(.5), 52.36, 90.07, 31.16);
+      assert.hclEqual(d3.interpolateHcl("#000", "#6f0")(.5), 131.26, 112.84, 44.54);
+    },
+    "uses source chroma when destination chroma is undefined": function(d3) {
+      assert.hclEqual(d3.interpolateHcl("#ccc", "#000")(.5), 158.20, 0.00, 41.02);
+      assert.hclEqual(d3.interpolateHcl("#f00", "#000")(.5), 40.00, 104.55, 26.62);
+    },
+    "uses destination chroma when source chroma is undefined": function(d3) {
+      assert.hclEqual(d3.interpolateHcl("#000", "#ccc")(.5), 158.20, 0.00, 41.02);
+      assert.hclEqual(d3.interpolateHcl("#000", "#f00")(.5), 40.00, 104.55, 26.62);
+    },
+    "returns an instanceof d3.hcl": function(d3) {
+      assert.hclEqual(d3.interpolateHcl("steelblue", "#f00")(.2), -69.78, 46.87, 52.62);
+    }
+  }
+});
+
+suite.export(module);

data/lib/stripmem/public/components/d3/test/interpolate/hsl-test.js

@@ -0,0 +1,47 @@
+var vows = require("vows"),
+    load = require("../load"),
+    assert = require("../assert");
+
+var suite = vows.describe("d3.interpolateHsl");
+
+suite.addBatch({
+  "interpolateHsl": {
+    topic: load("interpolate/hsl"), // beware instanceof d3_Color
+    "parses string input": function(d3) {
+      assert.hslEqual(d3.interpolateHsl("steelblue", "#f00")(.2), 237.82, 0.5538, 0.4922);
+      assert.hslEqual(d3.interpolateHsl("steelblue", "#f00")(.6), 298.91, 0.7787, 0.4961);
+    },
+    "parses d3.hsl input": function(d3) {
+      assert.hslEqual(d3.interpolateHsl(d3.hsl("steelblue"), "#f00")(.2), 237.82, 0.5538, 0.4922);
+      assert.hslEqual(d3.interpolateHsl("steelblue", d3.hsl(0, 1, .5))(.6), 298.91, 0.7787, 0.4961);
+    },
+    "parses d3.rgb input": function(d3) {
+      assert.hslEqual(d3.interpolateHsl(d3.rgb("steelblue"), "#f00")(.2), 237.82, 0.5538, 0.4922);
+      assert.hslEqual(d3.interpolateHsl("steelblue", d3.rgb(255, 0, 0))(.6), 298.91, 0.7787, 0.4961);
+    },
+    "interpolates in HSL color space": function(d3) {
+      assert.hslEqual(d3.interpolateHsl("steelblue", "#f00")(.2), 237.82, 0.5538, 0.4922);
+    },
+    "uses source hue when destination hue is undefined": function(d3) {
+      assert.hslEqual(d3.interpolateHsl("#f60", "#000")(.5), 24, 1, 0.2510);
+      assert.hslEqual(d3.interpolateHsl("#6f0", "#fff")(.5), 96, 1, 0.7510);
+    },
+    "uses destination hue when source hue is undefined": function(d3) {
+      assert.hslEqual(d3.interpolateHsl("#000", "#f60")(.5), 24, 1, 0.2510);
+      assert.hslEqual(d3.interpolateHsl("#fff", "#6f0")(.5), 96, 1, 0.7510);
+    },
+    "uses source saturation when destination saturation is undefined": function(d3) {
+      assert.hslEqual(d3.interpolateHsl("#ccc", "#000")(.5), NaN, 0, 0.4);
+      assert.hslEqual(d3.interpolateHsl("#f00", "#000")(.5), 0, 1, 0.2510);
+    },
+    "uses destination saturation when source saturation is undefined": function(d3) {
+      assert.hslEqual(d3.interpolateHsl("#000", "#ccc")(.5), NaN, 0, 0.4);
+      assert.hslEqual(d3.interpolateHsl("#000", "#f00")(.5), 0, 1, 0.2510);
+    },
+    "returns an instanceof d3.hsl": function(d3) {
+      assert.hslEqual(d3.interpolateHsl("steelblue", "#f00")(.6), 298.91, 0.7787, 0.4961);
+    }
+  }
+});
+
+suite.export(module);

data/lib/stripmem/public/components/d3/test/interpolate/interpolate-test.js

@@ -0,0 +1,157 @@
+var vows = require("vows"),
+    load = require("../load"),
+    assert = require("../assert");
+
+var suite = vows.describe("d3.interpolate");
+
+suite.addBatch({
+  "interpolate": {
+    topic: load("interpolate/interpolate"),
+
+    "when b is a number": {
+      "interpolates numbers": function(d3) {
+        assert.strictEqual(d3.interpolate(2, 12)(.4), 6);
+      },
+      "coerces a to a number": function(d3) {
+        assert.strictEqual(d3.interpolate("", 1)(.5), .5);
+        assert.strictEqual(d3.interpolate("2", 12)(.4), 6);
+        assert.strictEqual(d3.interpolate([2], 12)(.4), 6);
+      }
+    },
+
+    "when b is a color string": {
+      "interpolates RGB values": function(d3) {
+        assert.rgbEqual(d3.interpolate("#ff0000", "#008000")(.4), 153, 51, 0);
+      },
+      "interpolates named colors in RGB": function(d3) {
+        assert.rgbEqual(d3.interpolate("red", "green")(.4), 153, 51, 0);
+      },
+      "interpolates decimal RGB colors in RGB": function(d3) {
+        assert.rgbEqual(d3.interpolate("rgb(255,0,0)", "rgb(0,128,0)")(.4), 153, 51, 0);
+      },
+      "interpolates decimal HSL colors in RGB": function(d3) {
+        assert.rgbEqual(d3.interpolate("hsl(0,100%,50%)", "hsl(120,100%,25%)")(.4), 153, 51, 0);
+      },
+      "coerces a to a color": function(d3) {
+        assert.rgbEqual(d3.interpolate({toString: function() { return "red"; }}, "green")(.4), 153, 51, 0);
+      },
+      "returns an instanceof d3.rgb": function(d3) {
+        assert.rgbEqual(d3.interpolate("steelblue", "#f00")(.2), 107, 104, 144);
+      }
+    },
+
+    "when b is a color object": {
+      "interpolates RGB values and returns a hexadecimal string": function(d3) {
+        assert.rgbEqual(d3.interpolate(d3.rgb(255, 0, 0), d3.rgb(0, 128, 0))(.4), 153, 51, 0);
+      },
+      "interpolates d3.hsl in RGB": function(d3) {
+        assert.rgbEqual(d3.interpolate(d3.hsl("red"), d3.hsl("green"))(.4), 153, 51, 0);
+      },
+      "interpolates d3.lab in RGB": function(d3) {
+        assert.rgbEqual(d3.interpolate(d3.lab("red"), d3.lab("green"))(.4), 153, 51, 0);
+      },
+      "interpolates d3.hcl in RGB": function(d3) {
+        assert.rgbEqual(d3.interpolate(d3.hcl("red"), d3.hcl("green"))(.4), 153, 51, 0);
+      },
+      "coerces a to a color": function(d3) {
+        assert.rgbEqual(d3.interpolate({toString: function() { return "red"; }}, "green")(.4), 153, 51, 0);
+      },
+      "returns an instanceof d3.rgb": function(d3) {
+        assert.rgbEqual(d3.interpolate(d3.rgb("steelblue"), d3.rgb("#f00"))(.2), 107, 104, 144);
+      }
+    },
+
+    "when b is a string": {
+      "interpolates matching numbers in both strings": function(d3) {
+        assert.strictEqual(d3.interpolate(" 10/20 30", "50/10 100 ")(.4), "26/16 58 ");
+      },
+      "if b is coercible to a number, still returns a string": function(d3) {
+        assert.strictEqual(d3.interpolate("1.", "2.")(.5), "1.5");
+        assert.strictEqual(d3.interpolate("1e+3", "1e+4")(.5), "5500");
+      },
+      "preserves non-numbers in string b": function(d3) {
+        assert.strictEqual(d3.interpolate(" 10/20 30", "50/10 foo ")(.4), "26/16 foo ");
+      },
+      "preserves non-matching numbers in string b": function(d3) {
+        assert.strictEqual(d3.interpolate(" 10/20 bar", "50/10 100 ")(.4), "26/16 100 ");
+      },
+      "preserves equal-value numbers in both strings": function(d3) {
+        assert.strictEqual(d3.interpolate(" 10/20 100 20", "50/10 100, 20 ")(.4), "26/16 100, 20 ");
+      },
+      "coerces a to a string": function(d3) {
+        assert.strictEqual(d3.interpolate({toString: function() { return "1."; }}, "2.")(.5), "1.5");
+      }
+    },
+
+    "when b is an array": {
+      "interpolates each element in b": function(d3) {
+        assert.strictEqual(JSON.stringify(d3.interpolate([2, 4], [12, 24])(.4)), "[6,12]");
+      },
+      "interpolates arrays, even when both a and b are coercible to numbers": function(d3) {
+        assert.strictEqual(JSON.stringify(d3.interpolate([2], [12])(.4)), "[6]");
+        assert.strictEqual(JSON.stringify(d3.interpolate([[2]], [[12]])(.4)), "[[6]]");
+      },
+      "reuses the returned array during interpolation": function(d3) {
+        var i = d3.interpolate([2], [12]);
+        assert.strictEqual(i(.2), i(.4));
+      }
+    },
+
+    "when b is an object": {
+      "interpolates each property in b": function(d3) {
+        assert.deepEqual(d3.interpolate({foo: 2, bar: 4}, {foo: 12, bar: 24})(.4), {foo: 6, bar: 12});
+      },
+      "interpolates arrays, even when both a and b are coercible to numbers": function(d3) {
+        var two = new Number(2), twelve = new Number(12);
+        two.foo = "2px";
+        twelve.foo = "12px";
+        assert.deepEqual(d3.interpolate(two, twelve)(.4), {foo: "6px"});
+      },
+      "reuses the returned object during interpolation": function(d3) {
+        var i = d3.interpolate({foo: 2, bar: 4}, {foo: 12, bar: 24});
+        assert.strictEqual(i(.2), i(.4));
+      }
+    },
+
+    "may or may not interpolate between enumerable and non-enumerable properties": function(d3) {
+      var a = Object.create({}, {foo: {value: 1, enumerable: true}}),
+          b = Object.create({}, {foo: {value: 2, enumerable: false}});
+      try {
+        assert.deepEqual(d3.interpolate(a, b)(1), {});
+      } catch (e) {
+        assert.deepEqual(d3.interpolate(a, b)(1), {foo: 2});
+      }
+      try {
+        assert.deepEqual(d3.interpolate(b, a)(1), {});
+      } catch (e) {
+        assert.deepEqual(d3.interpolate(b, a)(1), {foo: 1});
+      }
+    },
+    "interpolates inherited properties of objects": function(d3) {
+      var a = Object.create({foo: 0}),
+          b = Object.create({foo: 2});
+      assert.deepEqual(d3.interpolate(a, b)(.5), {foo: 1});
+    },
+    "doesn't interpret properties in the default object's prototype chain as RGB": function(d3) {
+      assert.equal(d3.interpolate("hasOwnProperty", "hasOwnProperty")(0), "hasOwnProperty");
+    }
+  },
+
+  "interpolators": {
+    topic: load("interpolate/interpolate").document(),
+    "can register a custom interpolator": function(d3) {
+      d3.interpolators.push(function(a, b) { return a == "one" && b == "two" && d3.interpolateNumber(1, 2); });
+      try {
+        assert.equal(d3.interpolate("one", "two")(-.5), .5);
+        assert.equal(d3.interpolate("one", "two")(0), 1);
+        assert.equal(d3.interpolate("one", "two")(.5), 1.5);
+        assert.equal(d3.interpolate("one", "two")(1), 2);
+        assert.equal(d3.interpolate("one", "two")(1.5), 2.5);
+      } finally {
+        d3.interpolators.pop();
+      }
+    }
+  }
+});
+
+suite.export(module);