stripchart 0.0.3

data/lib/stripchart/public/components/d3/test/svg/brush-test.js

@@ -0,0 +1,96 @@
+var vows = require("vows"),
+    _ = require("../../"),
+    load = require("../load"),
+    assert = require("../assert");
+
+var suite = vows.describe("d3.svg.brush");
+
+suite.addBatch({
+  "brush": {
+    topic: load("svg/brush").expression("d3.svg.brush").document(),
+
+    "x": {
+      "defaults to null": function(brush) {
+        assert.isNull(brush().x());
+      }
+    },
+
+    "y": {
+      "defaults to null": function(brush) {
+        assert.isNull(brush().y());
+      }
+    },
+
+    "clamp": {
+      "returns null when no scales are attached": function(brush) {
+        assert.isNull(brush().clamp());
+      },
+      "returns a single boolean if only x is defined": function(brush) {
+        var b = brush().x(_.scale.linear());
+        assert.isTrue(b.clamp());
+      },
+      "returns a single boolean if only y is defined": function(brush) {
+        var b = brush().y(_.scale.linear());
+        assert.isTrue(b.clamp());
+      },
+      "returns one-dimensional array if both x and y are defined": function(brush) {
+        var b = brush().x(_.scale.linear()).y(_.scale.linear());
+        assert.deepEqual(b.clamp(), [true, true]);
+      },
+      "takes a single boolean if only x is defined": function(brush) {
+        var b = brush().x(_.scale.linear()).clamp(false);
+        assert.isFalse(b.clamp());
+      },
+      "takes a single boolean if only y is defined": function(brush) {
+        var b = brush().y(_.scale.linear()).clamp(false);
+        assert.isFalse(b.clamp());
+      },
+      "takes a one-dimensional array if both x and y are defined": function(brush) {
+        var b = brush().x(_.scale.linear()).y(_.scale.linear()).clamp([false, true]);
+        assert.deepEqual(b.clamp(), [false, true]);
+        b.clamp([true, false]);
+        assert.deepEqual(b.clamp(), [true, false]);
+      }
+    },
+
+    "extent": {
+      "returns null when no scales are attached": function(brush) {
+        assert.isNull(brush().extent());
+      },
+      "returns a one-dimensional array if only x is defined": function(brush) {
+        var b = brush().x(_.scale.linear());
+        assert.deepEqual(b.extent(), [0, 0]);
+      },
+      "takes a one-dimensional array if only x is defined": function(brush) {
+        var b = brush().x(_.scale.linear()).extent([0.1, 0.4]);
+        assert.deepEqual(b.extent(), [0.1, 0.4]);
+      },
+      "returns a one-dimensional array if only y is defined": function(brush) {
+        var b = brush().y(_.scale.linear());
+        assert.deepEqual(b.extent(), [0, 0]);
+      },
+      "takes a one-dimensional array if only y is defined": function(brush) {
+        var b = brush().y(_.scale.linear()).extent([0.1, 0.4]);
+        assert.deepEqual(b.extent(), [0.1, 0.4]);
+      },
+      "returns a two-dimensional array if x and y are defined": function(brush) {
+        var b = brush().x(_.scale.linear()).y(_.scale.linear());
+        assert.deepEqual(b.extent(), [[0, 0], [0, 0]]);
+      },
+      "takes a two-dimensional array if x and y are defined": function(brush) {
+        var b = brush().x(_.scale.linear()).y(_.scale.linear()).extent([[0.1, 0.2], [0.3, 0.4]]);
+        assert.deepEqual(b.extent(), [[0.1, 0.2], [0.3, 0.4]]);
+      },
+      "preserves the set extent exactly": function(brush) {
+        var lo = new Number(0.1),
+            hi = new Number(0.3),
+            b = brush().x(_.scale.linear()).extent([lo, hi]),
+            extent = b.extent();
+        assert.strictEqual(extent[0], lo);
+        assert.strictEqual(extent[1], hi);
+      }
+    }
+  }
+});
+
+suite.export(module);

data/lib/stripchart/public/components/d3/test/svg/diagonal-test.js

@@ -0,0 +1,62 @@
+var vows = require("vows"),
+    load = require("../load"),
+    assert = require("../assert");
+
+var suite = vows.describe("d3.svg.diagonal");
+
+suite.addBatch({
+  "diagonal": {
+    topic: load("svg/diagonal").expression("d3.svg.diagonal"),
+
+    "source defaults to a function accessor": function(diagonal) {
+      var d = diagonal().target({x:5, y:5});
+      assert.pathEqual(d({source: {x:1, y:1}}), "M1,1C1,3 5,3 5,5");
+      assert.pathEqual(d({source: {x:5, y:1}}), "M5,1C5,3 5,3 5,5");
+    },
+    "source can be defined as a constant": function(diagonal) {
+      var d = diagonal().target({x:5, y:5});
+      assert.pathEqual(d.source({x:1, y:1})(), "M1,1C1,3 5,3 5,5");
+      assert.pathEqual(d.source({x:5, y:1})(), "M5,1C5,3 5,3 5,5");
+    },
+    "source can be defined as a function of data or index": function(diagonal) {
+      var d = diagonal().source(f).target({x:5, y:5}), o = {}, t = {}, dd, ii, tt;
+      function f(d,i) { dd = d; ii = i; tt = this; return {x:42, y:42}; }
+      assert.pathEqual(d.call(t, o, 2), "M42,42C42,23.500000 5,23.500000 5,5");
+
+      assert.equal(dd, o, "expected data, got {actual}");
+      assert.equal(ii, 2, "expected data, got {actual}");
+      assert.equal(tt, t, "expected data, got {actual}");
+    },
+    "target defaults to a function accessor": function(diagonal) {
+      var d = diagonal().source({x:1, y:1});
+      assert.pathEqual(d({target: {x:5, y:5}}), "M1,1C1,3 5,3 5,5");
+      assert.pathEqual(d({target: {x:5, y:1}}), "M1,1C1,1 5,1 5,1");
+    },
+    "target can be defined as a constant": function(diagonal) {
+      var d = diagonal().source({x:1, y:1});
+      assert.pathEqual(d.target({x:5, y:5})(), "M1,1C1,3 5,3 5,5");
+      assert.pathEqual(d.target({x:5, y:1})(), "M1,1C1,1 5,1 5,1");
+    },
+    "target can be defined as a function of data or index": function(diagonal) {
+      var d = diagonal().source({x:1, y:1}).target(f), o = {}, t = {}, dd, ii, tt;
+      function f(d,i) { dd = d; ii = i; tt = this; return {x:42, y:42}; }
+      assert.pathEqual(d.call(t, o, 2), "M1,1C1,21.500000 42,21.500000 42,42");
+
+      assert.equal(dd, o, "expected data, got {actual}");
+      assert.equal(ii, 2, "expected data, got {actual}");
+      assert.equal(tt, t, "expected data, got {actual}");
+    },
+    "projection defaults to identity": function(diagonal) {
+      var d = diagonal();
+      assert.deepEqual(d.projection()({x:1, y:1}),[1, 1]);
+    },
+    "custom projection function can be set": function(diagonal) {
+      var d = diagonal().source({x:1, y:1}).target({x:5, y:5});
+      assert.pathEqual(d.projection(function(d) { 
+        return [d.x * 2, d.y * 2]; 
+      })(),"M2,2C2,6 10,6 10,10");
+    }
+  }
+});
+
+suite.export(module);

data/lib/stripchart/public/components/d3/test/svg/line-radial-test.js

@@ -0,0 +1,120 @@
+var vows = require("vows"),
+    _ = require("../../"),
+    load = require("../load"),
+    assert = require("../assert");
+
+var suite = vows.describe("d3.svg.line.radial");
+
+suite.addBatch({
+  "line.radial": {
+    topic: load("svg/line-radial").expression("d3.svg.line.radial"),
+
+    "radius defaults to a function accessor": function(line) {
+      var l = line();
+      assert.pathEqual(l([[10, 0], [20, 1], [20, 2], [10, 3]]), "M0,-10L16.82941969615793,-10.806046117362794L18.185948536513635,8.32293673094285L1.4112000805986715,9.899924966004454");
+      assert.typeOf(l.radius(), "function");
+    },
+    "radius can be defined as a constant": function(line) {
+      var l = line().radius(30);
+      assert.pathEqual(l([[10, 0], [20, 1], [20, 2], [10, 3]]), "M0,-30L25.244129544236895,-16.20906917604419L27.278922804770453,12.484405096414275L4.233600241796014,29.699774898013363");
+      assert.equal(l.radius(), 30);
+    },
+    "radius can be defined as a function": function(line) {
+      var l = line().radius(f), t = {}, dd = [], ii = [], tt = [];
+      function f(d, i) { dd.push(d); ii.push(i); tt.push(this); return 30; }
+      assert.pathEqual(l.call(t, [[10, 0], [20, 1], [20, 2], [10, 3]]), "M0,-30L25.244129544236895,-16.20906917604419L27.278922804770453,12.484405096414275L4.233600241796014,29.699774898013363");
+      assert.deepEqual(dd, [[10, 0], [20, 1], [20, 2], [10, 3]], "expected data, got {actual}");
+      assert.deepEqual(ii, [0, 1, 2, 3], "expected index, got {actual}");
+      assert.deepEqual(tt, [t, t, t, t], "expected this, got {actual}");
+    },
+
+    "angle defaults to a function accessor": function(line) {
+      var l = line();
+      assert.pathEqual(l([[10, 0], [20, 1], [20, 2], [10, 3]]), "M0,-10L16.82941969615793,-10.806046117362794L18.185948536513635,8.32293673094285L1.4112000805986715,9.899924966004454");
+      assert.typeOf(l.angle(), "function");
+    },
+    "angle can be defined as a constant": function(line) {
+      var l = line().angle(Math.PI / 2);
+      assert.pathEqual(l([[10, 0], [20, 1], [20, 2], [10, 3]]), "M10,0L20,0L20,0L10,0");
+      assert.equal(l.angle(), Math.PI / 2);
+    },
+    "angle can be defined as a function": function(line) {
+      var l = line().angle(f), t = {}, dd = [], ii = [], tt = [];
+      function f(d, i) { dd.push(d); ii.push(i); tt.push(this); return Math.PI / 2; }
+      assert.pathEqual(l.call(t, [[10, 0], [20, 1], [20, 2], [10, 3]]), "M10,0L20,0L20,0L10,0");
+      assert.deepEqual(dd, [[10, 0], [20, 1], [20, 2], [10, 3]], "expected data, got {actual}");
+      assert.deepEqual(ii, [0, 1, 2, 3], "expected index, got {actual}");
+      assert.deepEqual(tt, [t, t, t, t], "expected this, got {actual}");
+    },
+    "angle is defined in radians, with zero at 12 o'clock": function(line) {
+      var l = line().angle(0);
+      assert.pathEqual(l([[10, Math.PI], [20, Math.PI / 3]]), "M0,-10L0,-20");
+      assert.equal(l.angle(), 0);
+    },
+
+    "interpolate defaults to linear": function(line) {
+      assert.equal(line().interpolate(), "linear");
+    },
+    "interpolate can be defined as a constant": function(line) {
+      var l = line().interpolate("cardinal");
+      assert.pathEqual(l([[10, 0], [20, 1], [20, 2], [10, 3]]), "M0,-10Q15.010824842506567,-12.638339790457078,16.82941969615793,-10.806046117362794C19.557311976634978,-8.057605607721365,20.498681478847523,5.217041068437762,18.185948536513635,8.32293673094285Q16.64412657495771,10.393533839279574,1.4112000805986715,9.899924966004454");
+      assert.equal(l.interpolate(), "cardinal");
+    },
+
+    "tension defaults to .7": function(line) {
+      assert.equal(line().tension(), .7);
+    },
+    "tension can be specified as a constant": function(line) {
+      var l = line().tension(.5);
+      assert.equal(l.tension(), .5);
+    },
+
+    "returns null if input points array is empty": function(line) {
+      assert.isNull(line()([]));
+    },
+
+    "interpolate(linear)": {
+      "supports linear interpolation": testInterpolation("linear")
+    },
+
+    "interpolate(step)": {
+      "supports step-before interpolation": testInterpolation("step-before"),
+      "supports step-after interpolation": testInterpolation("step-after")
+    },
+
+    "interpolate(basis)": {
+      "supports basis interpolation": testInterpolation("basis"),
+      "supports basis-open interpolation": testInterpolation("basis-open"),
+      "supports basis-closed interpolation": testInterpolation("basis-closed")
+    },
+
+    "interpolate(bundle)": {
+      "supports bundle interpolation": testInterpolation("bundle")
+    },
+
+    "interpolate(cardinal)": {
+      "supports cardinal interpolation": testInterpolation("cardinal"),
+      "supports cardinal-open interpolation": testInterpolation("cardinal-open"),
+      "supports cardinal-closed interpolation": testInterpolation("cardinal-closed")
+    },
+
+    "interpolate(monotone)": {
+      "supports monotone interpolation": testInterpolation("monotone")
+    }
+  }
+});
+
+// A radial line is just a transformation of a Cartesian line.
+function testInterpolation(interpolate) {
+  var data = [[10, 0], [20, 1], [20, 2], [10, 3]];
+
+  var cartesian = _.svg.line()
+      .x(function(d) { return d[0] * Math.cos(d[1] - Math.PI / 2); })
+      .y(function(d) { return d[0] * Math.sin(d[1] - Math.PI / 2); });
+
+  return function(radial) {
+    assert.pathEqual(radial().interpolate(interpolate)(data), cartesian.interpolate(interpolate)(data));
+  };
+}
+
+suite.export(module);

data/lib/stripchart/public/components/d3/test/svg/line-test.js

@@ -0,0 +1,207 @@
+var vows = require("vows"),
+    load = require("../load"),
+    assert = require("../assert");
+
+var suite = vows.describe("d3.svg.line");
+
+suite.addBatch({
+  "line": {
+    topic: load("svg/line").expression("d3.svg.line"),
+
+    "x defaults to a function accessor": function(line) {
+      var l = line();
+      assert.pathEqual(l([[1, 2], [4, 3]]), "M1,2L4,3");
+      assert.typeOf(l.x(), "function");
+    },
+    "x can be defined as a constant": function(line) {
+      var l = line().x(0);
+      assert.pathEqual(l([[1, 2], [4, 3]]), "M0,2L0,3");
+      assert.equal(l.x(), 0);
+    },
+    "x can be defined as a function": function(line) {
+      var l = line().x(f), t = {}, dd = [], ii = [], tt = [];
+      function f(d, i) { dd.push(d); ii.push(i); tt.push(this); return 0; }
+      assert.pathEqual(l.call(t, [[1, 2], [4, 3]]), "M0,2L0,3");
+      assert.deepEqual(dd, [[1, 2], [4, 3]], "expected data, got {actual}");
+      assert.deepEqual(ii, [0, 1], "expected index, got {actual}");
+      assert.deepEqual(tt, [t, t], "expected this, got {actual}");
+    },
+
+    "y defaults to a function accessor": function(line) {
+      var l = line();
+      assert.pathEqual(l([[1, 2], [4, 3]]), "M1,2L4,3");
+      assert.typeOf(l.y(), "function");
+    },
+    "y can be defined as a constant": function(line) {
+      var l = line().y(0);
+      assert.pathEqual(l([[1, 2], [4, 3]]), "M1,0L4,0");
+      assert.equal(l.y(), 0);
+    },
+    "y can be defined as a function": function(line) {
+      var l = line().y(f), t = {}, dd = [], ii = [], tt = [];
+      function f(d, i) { dd.push(d); ii.push(i); tt.push(this); return 0; }
+      assert.pathEqual(l.call(t, [[1, 2], [4, 3]]), "M1,0L4,0");
+      assert.deepEqual(dd, [[1, 2], [4, 3]], "expected data, got {actual}");
+      assert.deepEqual(ii, [0, 1], "expected index, got {actual}");
+      assert.deepEqual(tt, [t, t], "expected this, got {actual}");
+    },
+
+    "interpolate defaults to linear": function(line) {
+      assert.equal(line().interpolate(), "linear");
+    },
+    "interpolate can be defined as a constant": function(line) {
+      var l = line().interpolate("step-before");
+      assert.pathEqual(l([[0, 0], [1, 1]]), "M0,0V1H1");
+      assert.equal(l.interpolate(), "step-before");
+    },
+    "interpolate can be defined as a function": function(line) {
+      var l = line().interpolate(interpolate);
+      assert.pathEqual(l([[0, 0], [1, 1]]), "M0,0T1,1");
+      assert.equal(l.interpolate(), interpolate);
+
+      function interpolate(points) {
+        return points.join("T");
+      }
+    },
+    "invalid interpolates fallback to linear": function(line) {
+      assert.equal(line().interpolate("__proto__").interpolate(), "linear");
+    },
+
+    "tension defaults to .7": function(line) {
+      assert.equal(line().tension(), .7);
+    },
+    "tension can be specified as a constant": function(line) {
+      var l = line().tension(.5);
+      assert.equal(l.tension(), .5);
+    },
+
+    "returns null if input points array is empty": function(line) {
+      assert.isNull(line()([]));
+    },
+
+    "interpolate(linear)": {
+      "supports linear interpolation": function(line) {
+        var l = line().interpolate("linear");
+        assert.pathEqual(l([[0, 0], [1, 1], [2, 0], [3, 1], [4, 0]]), "M0,0L1,1L2,0L3,1L4,0");
+      }
+    },
+
+    "interpolate(step)": {
+      "supports step-before interpolation": function(line) {
+        var l = line().interpolate("step-before");
+        assert.pathEqual(l([[0, 0]]), "M0,0");
+        assert.pathEqual(l([[0, 0], [1, 1]]), "M0,0V1H1");
+        assert.pathEqual(l([[0, 0], [1, 1], [2, 0]]), "M0,0V1H1V0H2");
+      },
+      "supports step interpolation": function(line) {
+        var l = line().interpolate("step");
+        assert.pathEqual(l([[0, 0]]), "M0,0");
+        assert.pathEqual(l([[0, 0], [1, 1]]), "M0,0H0.5V1H1");
+        assert.pathEqual(l([[0, 0], [1, 1], [2, 0]]), "M0,0H0.5V1H1.5V0H2");
+      },
+      "supports step-after interpolation": function(line) {
+        var l = line().interpolate("step-after");
+        assert.pathEqual(l([[0, 0]]), "M0,0");
+        assert.pathEqual(l([[0, 0], [1, 1]]), "M0,0H1V1");
+        assert.pathEqual(l([[0, 0], [1, 1], [2, 0]]), "M0,0H1V1H2V0");
+      }
+    },
+
+    "interpolate(basis)": {
+      "supports basis interpolation": function(line) {
+        var l = line().interpolate("basis");
+        assert.pathEqual(l([[0, 0], [1, 1], [2, 0], [3, 1], [4, 0]]), "M0,0L0.16666666666666666,0.16666666666666666C0.3333333333333333,0.3333333333333333,0.6666666666666666,0.6666666666666666,1,0.6666666666666666C1.3333333333333333,0.6666666666666666,1.6666666666666665,0.3333333333333333,2,0.3333333333333333C2.333333333333333,0.3333333333333333,2.6666666666666665,0.6666666666666666,3,0.6666666666666666C3.333333333333333,0.6666666666666666,3.6666666666666665,0.3333333333333333,3.833333333333333,0.16666666666666666L4,0");
+      },
+      "supports basis-open interpolation": function(line) {
+        var l = line().interpolate("basis-open");
+        assert.pathEqual(l([[0, 0], [1, 1], [2, 0], [3, 1], [4, 0]]), "M1,0.6666666666666666C1.3333333333333333,0.6666666666666666,1.6666666666666665,0.3333333333333333,2,0.3333333333333333C2.333333333333333,0.3333333333333333,2.6666666666666665,0.6666666666666666,3,0.6666666666666666");
+      },
+      "supports basis-closed interpolation": function(line) {
+        var l = line().interpolate("basis-closed");
+        assert.pathEqual(l([[0, 0], [1, 1], [2, 0], [3, 1], [4, 0]]), "M2,0.3333333333333333C2.333333333333333,0.3333333333333333,2.6666666666666665,0.6666666666666666,3,0.6666666666666666C3.333333333333333,0.6666666666666666,3.6666666666666665,0.3333333333333333,3.1666666666666665,0.16666666666666666C2.6666666666666665,0,1.3333333333333333,0,0.8333333333333333,0.16666666666666666C0.3333333333333333,0.3333333333333333,0.6666666666666666,0.6666666666666666,1,0.6666666666666666C1.3333333333333333,0.6666666666666666,1.6666666666666665,0.3333333333333333,2,0.3333333333333333");
+      },
+      "basis interpolation reverts to linear with fewer than three points": function(line) {
+        var l = line().interpolate("basis"), d = line();
+        assert.pathEqual(l([[0, 0]]), d([[0, 0]]));
+        assert.pathEqual(l([[0, 0], [1, 1]]), d([[0, 0], [1, 1]]));
+      },
+      "basis-open interpolation reverts to linear with fewer than four points": function(line) {
+        var l = line().interpolate("basis-open"), d = line();
+        assert.pathEqual(l([[0, 0]]), d([[0, 0]]));
+        assert.pathEqual(l([[0, 0], [1, 1]]), d([[0, 0], [1, 1]]));
+        assert.pathEqual(l([[0, 0], [1, 1], [2, 0]]), d([[0, 0], [1, 1], [2, 0]]));
+      },
+      "basis-closed interpolation reverts to linear with fewer than three points": function(line) {
+        var l = line().interpolate("basis-open"), d = line();
+        assert.pathEqual(l([[0, 0]]), d([[0, 0]]));
+        assert.pathEqual(l([[0, 0], [1, 1]]), d([[0, 0], [1, 1]]));
+      }
+    },
+
+    "interpolate(bundle)": {
+      "supports bundle interpolation": function(line) {
+        var l = line().interpolate("bundle");
+        assert.pathEqual(l([[0, 0], [1, 1], [2, 0], [3, 1], [4, 0]]), "M0,0L0.16666666666666666,0.11666666666666665C0.3333333333333333,0.2333333333333333,0.6666666666666666,0.4666666666666666,1,0.4666666666666666C1.3333333333333333,0.4666666666666666,1.6666666666666665,0.2333333333333333,2,0.2333333333333333C2.333333333333333,0.2333333333333333,2.6666666666666665,0.4666666666666666,3,0.4666666666666666C3.333333333333333,0.4666666666666666,3.6666666666666665,0.2333333333333333,3.833333333333333,0.11666666666666665L4,0");
+      },
+      "observes the specified tension": function(line) {
+        var l = line().interpolate("bundle").tension(1);
+        assert.pathEqual(l([[0, 0], [1, 1], [2, 0], [3, 1], [4, 0]]), line().interpolate("basis")([[0, 0], [1, 1], [2, 0], [3, 1], [4, 0]]));
+      },
+      "supports a single-element array": function(line) {
+        var l = line().interpolate("bundle").tension(1);
+        assert.pathEqual(l([[0, 0]]), "M0,0");
+      }
+    },
+
+    "interpolate(cardinal)": {
+      "supports cardinal interpolation": function(line) {
+        var l = line().interpolate("cardinal");
+        assert.pathEqual(l([[0, 0], [1, 1], [2, 0], [3, 1], [4, 0]]), "M0,0Q0.8,1,1,1C1.3,1,1.7,0,2,0S2.7,1,3,1Q3.2,1,4,0");
+      },
+      "supports cardinal-open interpolation": function(line) {
+        var l = line().interpolate("cardinal-open");
+        assert.pathEqual(l([[0, 0], [1, 1], [2, 0], [3, 1], [4, 0]]), "M1,1C1.3,1,1.7,0,2,0S2.7,1,3,1");
+      },
+      "supports cardinal-closed interpolation": function(line) {
+        var l = line().interpolate("cardinal-closed");
+        assert.pathEqual(l([[0, 0], [1, 1], [2, 0], [3, 1], [4, 0]]), "M0,0C-0.45,0.15,0.7,1,1,1S1.7,0,2,0S2.7,1,3,1S4.45,0.15,4,0S0.45,-0.15,0,0");
+      },
+      "cardinal interpolation reverts to linear with fewer than three points": function(line) {
+        var l = line().interpolate("cardinal"), d = line();
+        assert.pathEqual(l([[0, 0]]), d([[0, 0]]));
+        assert.pathEqual(l([[0, 0], [1, 1]]), d([[0, 0], [1, 1]]));
+      },
+      "cardinal-open interpolation reverts to linear with fewer than four points": function(line) {
+        var l = line().interpolate("cardinal-open"), d = line();
+        assert.pathEqual(l([[0, 0]]), d([[0, 0]]));
+        assert.pathEqual(l([[0, 0], [1, 1]]), d([[0, 0], [1, 1]]));
+        assert.pathEqual(l([[0, 0], [1, 1], [2, 0]]), d([[0, 0], [1, 1], [2, 0]]));
+      },
+      "cardinal-closed interpolation reverts to linear with fewer than three points": function(line) {
+        var l = line().interpolate("cardinal-open"), d = line();
+        assert.pathEqual(l([[0, 0]]), d([[0, 0]]));
+        assert.pathEqual(l([[0, 0], [1, 1]]), d([[0, 0], [1, 1]]));
+      },
+      "observes the specified tension": function(line) {
+        var l = line().tension(.5);
+        assert.pathEqual(l.interpolate("cardinal")([[0, 0], [1, 1], [2, 0], [3, 1], [4, 0]]), "M0,0Q0.6666666666666667,1,1,1C1.5,1,1.5,0,2,0S2.5,1,3,1Q3.3333333333333335,1,4,0");
+        assert.pathEqual(l.interpolate("cardinal-open")([[0, 0], [1, 1], [2, 0], [3, 1], [4, 0]]), "M1,1C1.5,1,1.5,0,2,0S2.5,1,3,1");
+        assert.pathEqual(l.interpolate("cardinal-closed")([[0, 0], [1, 1], [2, 0], [3, 1], [4, 0]]), "M0,0C-0.75,0.25,0.5,1,1,1S1.5,0,2,0S2.5,1,3,1S4.75,0.25,4,0S0.75,-0.25,0,0");
+      }
+    },
+
+    "interpolate(monotone)": {
+      "supports monotone interpolation": function(line) {
+        var l = line().interpolate("monotone");
+        assert.pathEqual(l([[0, 0], [1, 1], [2, 1], [3, 0], [4, 0]]), "M0,0C0.08333333333333333,0.08333333333333333,0.6666666666666667,1,1,1S1.6666666666666667,1,2,1S2.6666666666666665,0,3,0S3.8333333333333335,0,4,0");
+      },
+      "monotone interpolation reverts to linear with fewer than three points": function(line) {
+        var l = line().interpolate("monotone"), d = line();
+        assert.pathEqual(l([[0, 0]]), d([[0, 0]]));
+        assert.pathEqual(l([[0, 0], [1, 1]]), d([[0, 0], [1, 1]]));
+      }
+    }
+  }
+});
+
+suite.export(module);