stripchart 0.0.3

data/lib/stripchart/public/components/d3/test/selection/text-test.js

@@ -0,0 +1,115 @@
+var vows = require("vows"),
+    load = require("../load"),
+    assert = require("../assert");
+
+var suite = vows.describe("selection.text");
+
+suite.addBatch({
+  "on select(body)": {
+    topic: load("selection/text").document(),
+    "on an initially-empty page": {
+      topic: function(d3) {
+        return d3.select("body");
+      },
+      "sets the text content as a string": function(body) {
+        body.text("Hello, world!");
+        assert.equal(body.node().textContent, "Hello, world!");
+      },
+      "sets the text content as a number": function(body) {
+        body.text(42);
+        assert.equal(body.node().textContent, "42");
+      },
+      "sets the text content as a function": function(body) {
+        body.data(["Subject"]).text(function(d, i) { return "Hello, " + d + " " + i + "!"; });
+        assert.equal(body.node().textContent, "Hello, Subject 0!");
+      },
+      "escapes html content to text": function(body) {
+        body.text("<h1>Hello, world!</h1>");
+        assert.equal(body.node().textContent, "<h1>Hello, world!</h1>");
+        assert.equal(body.node().firstChild.nodeType, 3);
+      },
+      "clears the text content as null": function(body) {
+        body.text(null);
+        assert.equal(body.node().textContent, "");
+      },
+      "clears the text content as undefined": function(body) {
+        body.text(undefined);
+        assert.equal(body.node().textContent, "");
+      },
+      "clears the text content as a function returning null": function(body) {
+        body.text(function() { return null; });
+        assert.equal(body.node().textContent, "");
+      },
+      "clears the text content as a function returning undefined": function(body) {
+        body.text(function() { return undefined; });
+        assert.equal(body.node().textContent, "");
+      },
+      "returns the current selection": function(body) {
+        assert.isTrue(body.text("hello") === body);
+      },
+      "ignores null nodes": function(body) {
+        var node = body.node();
+        node.textContent = "foo";
+        body[0][0] = null;
+        body.text("bar");
+        assert.equal(node.textContent, "foo");
+      }
+    }
+  }
+});
+
+suite.addBatch({
+  "on selectAll(div)": {
+    topic: load("selection/text").document(),
+    "on a page with a few divs": {
+      topic: function(d3) {
+        return d3.select("body").selectAll("div").data([0, 1]).enter().append("div");
+      },
+      "sets the text content as a string": function(div) {
+        div.text("Hello, world!");
+        assert.equal(div[0][0].textContent, "Hello, world!");
+        assert.equal(div[0][1].textContent, "Hello, world!");
+      },
+      "sets the text content as a number": function(div) {
+        div.text(42);
+        assert.equal(div[0][0].textContent, "42");
+        assert.equal(div[0][1].textContent, "42");
+      },
+      "sets the text content as a function": function(div) {
+        div.data(["foo", "bar"]).text(function(d, i) { return "Hello, " + d + " " + i + "!"; });
+        assert.equal(div[0][0].textContent, "Hello, foo 0!");
+        assert.equal(div[0][1].textContent, "Hello, bar 1!");
+      },
+      "escapes html content to text": function(div) {
+        div.text("<h1>Hello, world!</h1>");
+        assert.equal(div[0][0].textContent, "<h1>Hello, world!</h1>");
+        assert.equal(div[0][1].textContent, "<h1>Hello, world!</h1>");
+        assert.equal(div[0][0].firstChild.nodeType, 3);
+        assert.equal(div[0][1].firstChild.nodeType, 3);
+      },
+      "clears the text content as null": function(div) {
+        div.text(null);
+        assert.equal(div[0][0].textContent, "");
+        assert.equal(div[0][1].textContent, "");
+      },
+      "clears the text content as a function": function(div) {
+        div.text(function() { return null; });
+        assert.equal(div[0][0].textContent, "");
+        assert.equal(div[0][1].textContent, "");
+      },
+      "returns the current selection": function(div) {
+        assert.isTrue(div.text("hello") === div);
+      },
+      "ignores null nodes": function(div) {
+        var node = div[0][0];
+        node.textContent = "foo";
+        div[0][0] = null;
+        div.text("bar");
+        assert.equal(node.textContent, "foo");
+        assert.equal(div[0][1].textContent, "bar");
+      }
+    }
+  }
+});
+
+suite.export(module);

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

@@ -0,0 +1,143 @@
+var vows = require("vows"),
+    load = require("../load"),
+    assert = require("../assert");
+
+var suite = vows.describe("d3.svg.arc");
+
+suite.addBatch({
+  "arc": {
+    topic: load("svg/arc").expression("d3.svg.arc"),
+
+    "innerRadius defaults to a function accessor": function(arc) {
+      var a = arc().outerRadius(100).startAngle(0).endAngle(Math.PI);
+      assert.pathEqual(a({innerRadius: 0}), "M0,-100A100,100 0 1,1 0,100L0,0Z");
+      assert.pathEqual(a({innerRadius: 50}), "M0,-100A100,100 0 1,1 0,100L0,50A50,50 0 1,0 0,-50Z");
+    },
+    "innerRadius can be defined as a constant": function(arc) {
+      var a = arc().outerRadius(100).startAngle(0).endAngle(Math.PI);
+      assert.pathEqual(a.innerRadius(0)(), "M0,-100A100,100 0 1,1 0,100L0,0Z");
+      assert.pathEqual(a.innerRadius(50)(), "M0,-100A100,100 0 1,1 0,100L0,50A50,50 0 1,0 0,-50Z");
+    },
+    "innerRadius can be defined as a function of data or index": function(arc) {
+      var a = arc().innerRadius(f).outerRadius(100).startAngle(0).endAngle(Math.PI), o = {}, t = {}, dd, ii, tt;
+      function f(d, i) { dd = d; ii = i; tt = this; return 42; }
+      assert.pathEqual(a.call(t, o, 2), "M0,-100A100,100 0 1,1 0,100L0,42A42,42 0 1,0 0,-42Z");
+      assert.equal(dd, o, "expected data, got {actual}");
+      assert.equal(ii, 2, "expected index, got {actual}");
+      assert.equal(tt, t, "expected this, got {actual}");
+    },
+
+    "outerRadius defaults to a function accessor": function(arc) {
+      var a = arc().innerRadius(0).startAngle(0).endAngle(Math.PI);
+      assert.pathEqual(a({outerRadius: 50}), "M0,-50A50,50 0 1,1 0,50L0,0Z");
+      assert.pathEqual(a({outerRadius: 100}), "M0,-100A100,100 0 1,1 0,100L0,0Z");
+    },
+    "outerRadius can be defined as a constant": function(arc) {
+      var a = arc().innerRadius(0).startAngle(0).endAngle(Math.PI);
+      assert.pathEqual(a.outerRadius(50)(), "M0,-50A50,50 0 1,1 0,50L0,0Z");
+      assert.pathEqual(a.outerRadius(100)(), "M0,-100A100,100 0 1,1 0,100L0,0Z");
+    },
+    "outerRadius can be defined as a function of data or index": function(arc) {
+      var a = arc().innerRadius(0).outerRadius(f).startAngle(0).endAngle(Math.PI), o = {}, t = {}, dd, ii, tt;
+      function f(d, i) { dd = d; ii = i; tt = this; return 42; }
+      assert.pathEqual(a.call(t, o, 2), "M0,-42A42,42 0 1,1 0,42L0,0Z");
+      assert.equal(dd, o, "expected data, got {actual}");
+      assert.equal(ii, 2, "expected index, got {actual}");
+      assert.equal(tt, t, "expected this, got {actual}");
+    },
+
+    "startAngle defaults to a function accessor": function(arc) {
+      var a = arc().innerRadius(0).outerRadius(100).endAngle(Math.PI);
+      assert.pathEqual(a({startAngle: 0}), "M0,-100A100,100 0 1,1 0,100L0,0Z");
+      assert.pathEqual(a({startAngle: Math.PI / 2}), "M100,0A100,100 0 0,1 0,100L0,0Z");
+    },
+    "startAngle can be defined as a constant": function(arc) {
+      var a = arc().innerRadius(0).outerRadius(100).endAngle(Math.PI);
+      assert.pathEqual(a.startAngle(0)(), "M0,-100A100,100 0 1,1 0,100L0,0Z");
+      assert.pathEqual(a.startAngle(Math.PI / 2)(), "M100,0A100,100 0 0,1 0,100L0,0Z");
+    },
+    "startAngle can be defined as a function of data or index": function(arc) {
+      var a = arc().innerRadius(0).outerRadius(100).startAngle(f).endAngle(Math.PI), o = {}, t = {}, dd, ii, tt;
+      function f(d, i) { dd = d; ii = i; tt = this; return Math.PI; }
+      assert.pathEqual(a.call(t, o, 2), "M0,100A100,100 0 0,1 0,100L0,0Z");
+      assert.equal(dd, o, "expected data, got {actual}");
+      assert.equal(ii, 2, "expected index, got {actual}");
+      assert.equal(tt, t, "expected this, got {actual}");
+    },
+
+    "endAngle defaults to a function accessor": function(arc) {
+      var a = arc().innerRadius(0).outerRadius(100).startAngle(0);
+      assert.pathEqual(a({endAngle: Math.PI / 2}), "M0,-100A100,100 0 0,1 100,0L0,0Z");
+      assert.pathEqual(a({endAngle: Math.PI}), "M0,-100A100,100 0 1,1 0,100L0,0Z");
+    },
+    "endAngle can be defined as a constant": function(arc) {
+      var a = arc().innerRadius(0).outerRadius(100).startAngle(0);
+      assert.pathEqual(a.endAngle(Math.PI / 2)(), "M0,-100A100,100 0 0,1 100,0L0,0Z");
+      assert.pathEqual(a.endAngle(Math.PI)(), "M0,-100A100,100 0 1,1 0,100L0,0Z");
+    },
+    "endAngle can be defined as a function of data or index": function(arc) {
+      var a = arc().innerRadius(0).outerRadius(100).startAngle(0).endAngle(f), o = {}, t = {}, dd, ii, tt;
+      function f(d, i) { dd = d; ii = i; tt = this; return Math.PI; }
+      assert.pathEqual(a.call(t, o, 2), "M0,-100A100,100 0 1,1 0,100L0,0Z");
+      assert.equal(dd, o, "expected data, got {actual}");
+      assert.equal(ii, 2, "expected index, got {actual}");
+      assert.equal(tt, t, "expected this, got {actual}");
+    },
+
+    "startAngle and endAngle are swapped if endAngle is less than startAngle": function(arc) {
+      var a = arc().innerRadius(50).outerRadius(100);
+      assert.pathEqual(a.startAngle(2 * Math.PI).endAngle(Math.PI)(), a.startAngle(Math.PI).endAngle(2 * Math.PI)());
+      assert.pathEqual(a.startAngle(-Math.PI).endAngle(Math.PI)(), a.startAngle(Math.PI).endAngle(-Math.PI)());
+    },
+
+    "angles are defined in radians, with zero at 12 o'clock": function(arc) {
+      var a = arc().innerRadius(0).outerRadius(100);
+      assert.pathEqual(a.startAngle(0).endAngle(Math.PI)(), "M0,-100A100,100 0 1,1 0,100L0,0Z");
+      assert.pathEqual(a.startAngle(Math.PI).endAngle(2 * Math.PI)(), "M0,100A100,100 0 1,1 0,-100L0,0Z");
+    },
+    "radii are defined in local coordinates (typically pixels)": function(arc) {
+      var a = arc().startAngle(0).endAngle(Math.PI);
+      assert.pathEqual(a.innerRadius(0).outerRadius(100)(), "M0,-100A100,100 0 1,1 0,100L0,0Z");
+      assert.pathEqual(a.innerRadius(100).outerRadius(200)(), "M0,-200A200,200 0 1,1 0,200L0,100A100,100 0 1,0 0,-100Z");
+    },
+    "draws a circle when inner radius is zero and angle is approximately 2π": function(arc) {
+      var a = arc().innerRadius(0).outerRadius(100);
+      assert.pathEqual(a.startAngle(0).endAngle(2 * Math.PI - 1e-9)(), "M0,100A100,100 0 1,1 0,-100A100,100 0 1,1 0,100Z");
+      assert.pathEqual(a.startAngle(Math.PI + 1e-9).endAngle(3 * Math.PI - 1e-9)(), "M0,100A100,100 0 1,1 0,-100A100,100 0 1,1 0,100Z");
+    },
+    "draws a circle when inner radius is zero and angle is greater than 2π": function(arc) {
+      var a = arc().innerRadius(0).outerRadius(100);
+      assert.pathEqual(a.startAngle(0).endAngle(7)(), "M0,100A100,100 0 1,1 0,-100A100,100 0 1,1 0,100Z");
+      assert.pathEqual(a.startAngle(1).endAngle(8)(), "M0,100A100,100 0 1,1 0,-100A100,100 0 1,1 0,100Z");
+    },
+    "draws a circular sector when inner radius is zero and angle is less than 2π": function(arc) {
+      var a = arc().innerRadius(0).outerRadius(100);
+      assert.pathEqual(a.startAngle(0).endAngle(Math.PI / 2)(), "M0,-100A100,100 0 0,1 100,0L0,0Z");
+    },
+    "draws an annulus when inner radius is non-zero and angle is approximately 2π": function(arc) {
+      var a = arc().innerRadius(100).outerRadius(200);
+      assert.pathEqual(a.startAngle(0).endAngle(2 * Math.PI - 1e-9)(), "M0,200A200,200 0 1,1 0,-200A200,200 0 1,1 0,200M0,100A100,100 0 1,0 0,-100A100,100 0 1,0 0,100Z");
+      assert.pathEqual(a.startAngle(Math.PI + 1e-9).endAngle(3 * Math.PI - 1e-9)(), "M0,200A200,200 0 1,1 0,-200A200,200 0 1,1 0,200M0,100A100,100 0 1,0 0,-100A100,100 0 1,0 0,100Z");
+    },
+    "draws an annulus when inner radius is non-zero and angle is greater than 2π": function(arc) {
+      var a = arc().innerRadius(100).outerRadius(200);
+      assert.pathEqual(a.startAngle(0).endAngle(7)(), "M0,200A200,200 0 1,1 0,-200A200,200 0 1,1 0,200M0,100A100,100 0 1,0 0,-100A100,100 0 1,0 0,100Z");
+      assert.pathEqual(a.startAngle(-1).endAngle(6)(), "M0,200A200,200 0 1,1 0,-200A200,200 0 1,1 0,200M0,100A100,100 0 1,0 0,-100A100,100 0 1,0 0,100Z");
+    },
+    "draws an annular sector when both radii are non-zero and angle is less than 2π": function(arc) {
+      var a = arc().innerRadius(100).outerRadius(200);
+      assert.pathEqual(a.startAngle(0).endAngle(Math.PI / 2)(), "M0,-200A200,200 0 0,1 200,0L100,0A100,100 0 0,0 0,-100Z");
+    },
+
+    "computes the centroid as mid-radius and mid-angle": function(arc) {
+      var c = arc().innerRadius(0).outerRadius(100).startAngle(0).endAngle(2 * Math.PI).centroid();
+      assert.inDelta(c[0], 0, 1e-6);
+      assert.inDelta(c[1], 50, 1e-6);
+      var c = arc().innerRadius(100).outerRadius(200).startAngle(Math.PI).endAngle(2 * Math.PI).centroid();
+      assert.inDelta(c[0], -150, 1e-6);
+      assert.inDelta(c[1], 0, 1e-6);
+    }
+  }
+});
+
+suite.export(module);

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

@@ -0,0 +1,199 @@
+var vows = require("vows"),
+    _ = require("../../"),
+    load = require("../load"),
+    assert = require("../assert");
+
+var suite = vows.describe("d3.svg.area.radial");
+
+suite.addBatch({
+  "area.radial": {
+    topic: load("svg/area-radial").expression("d3.svg.area.radial"),
+
+    "radius is an alias for setting innerRadius and outerRadius": function(area) {
+      var a = area().radius(f);
+      function f() {}
+      assert.equal(a.radius(), f);
+      assert.equal(a.innerRadius(), f);
+      assert.equal(a.outerRadius(), f);
+    },
+    "radius is an alias for getting outerRadius": function(area) {
+      var a = area().outerRadius(f);
+      function f() {}
+      assert.equal(a.radius(), f);
+    },
+
+    "angle is an alias for setting startAngle and endAngle": function(area) {
+      var a = area().angle(f);
+      function f() {}
+      assert.equal(a.angle(), f);
+      assert.equal(a.startAngle(), f);
+      assert.equal(a.endAngle(), f);
+    },
+    "angle is an alias for getting endAngle": function(area) {
+      var a = area().endAngle(f);
+      function f() {}
+      assert.equal(a.angle(), f);
+    },
+
+    "innerRadius defaults to a function accessor": function(area) {
+      var a = area();
+      assert.pathEqual(a([[10, 0], [20, 1], [20, 2], [10, 3]]), "M0,-10L16.829420,-10.806046L18.185949,8.322937L1.411200,9.899925L0,-10L0,-20L0,-20L0,-10Z");
+      assert.typeOf(a.innerRadius(), "function");
+    },
+    "innerRadius can be defined as a constant": function(area) {
+      var a = area().innerRadius(30);
+      assert.pathEqual(a([[10, 0], [20, 1], [20, 2], [10, 3]]), "M0,-10L16.829420,-10.806046L18.185949,8.322937L1.411200,9.899925L0,-30L0,-30L0,-30L0,-30Z");
+      assert.equal(a.innerRadius(), 30);
+    },
+    "innerRadius can be defined as a function": function(area) {
+      var a = area().innerRadius(f), t = {}, dd = [], ii = [], tt = [];
+      function f(d, i) { dd.push(d); ii.push(i); tt.push(this); return 30; }
+      assert.pathEqual(a.call(t, [[10, 0], [20, 1], [20, 2], [10, 3]]), "M0,-10L16.829420,-10.806046L18.185949,8.322937L1.411200,9.899925L0,-30L0,-30L0,-30L0,-30Z");
+      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}");
+    },
+
+    "outerRadius defaults to a function accessor": function(area) {
+      var a = area();
+      assert.pathEqual(a([[10, 0], [20, 1], [20, 2], [10, 3]]), "M0,-10L16.829420,-10.806046L18.185949,8.322937L1.411200,9.899925L0,-10L0,-20L0,-20L0,-10Z");
+      assert.typeOf(a.outerRadius(), "function");
+    },
+    "outerRadius can be defined as a constant": function(area) {
+      var a = area().outerRadius(30);
+      assert.pathEqual(a([[10, 0], [20, 1], [20, 2], [10, 3]]), "M0,-30L25.244130,-16.209069L27.278923,12.484405L4.233600,29.699775L0,-10L0,-20L0,-20L0,-10Z");
+      assert.equal(a.outerRadius(), 30);
+    },
+    "outerRadius can be defined as a function": function(area) {
+      var a = area().outerRadius(f), t = {}, dd = [], ii = [], tt = [];
+      function f(d, i) { dd.push(d); ii.push(i); tt.push(this); return 30; }
+      assert.pathEqual(a.call(t, [[10, 0], [20, 1], [20, 2], [10, 3]]), "M0,-30L25.244130,-16.209069L27.278923,12.484405L4.233600,29.699775L0,-10L0,-20L0,-20L0,-10Z");
+      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}");
+    },
+
+    "startAngle defaults to zero": function(area) {
+      var a = area();
+      assert.pathEqual(a([[10, 0], [20, 1], [20, 2], [10, 3]]), "M0,-10L16.829420,-10.806046L18.185949,8.322937L1.411200,9.899925L0,-10L0,-20L0,-20L0,-10Z");
+      assert.equal(a.startAngle(), 0);
+    },
+    "startAngle can be defined as a constant": function(area) {
+      var a = area().startAngle(Math.PI / 2);
+      assert.pathEqual(a([[10, 0], [20, 1], [20, 2], [10, 3]]), "M0,-10L16.829420,-10.806046L18.185949,8.322937L1.411200,9.899925L10,0L20,0L20,0L10,0Z");
+      assert.equal(a.startAngle(), Math.PI / 2);
+    },
+    "startAngle can be defined as a function": function(area) {
+      var a = area().startAngle(f), t = {}, dd = [], ii = [], tt = [];
+      function f(d, i) { dd.push(d); ii.push(i); tt.push(this); return Math.PI / 2; }
+      assert.pathEqual(a.call(t, [[10, 0], [20, 1], [20, 2], [10, 3]]), "M0,-10L16.829420,-10.806046L18.185949,8.322937L1.411200,9.899925L10,0L20,0L20,0L10,0Z");
+      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}");
+    },
+
+    "endAngle defaults to a function accessor": function(area) {
+      var a = area();
+      assert.pathEqual(a([[10, 0], [20, 1], [20, 2], [10, 3]]), "M0,-10L16.829420,-10.806046L18.185949,8.322937L1.411200,9.899925L0,-10L0,-20L0,-20L0,-10Z");
+      assert.typeOf(a.endAngle(), "function");
+    },
+    "endAngle can be defined as a constant": function(area) {
+      var a = area().endAngle(Math.PI / 2);
+      assert.pathEqual(a([[10, 0], [20, 1], [20, 2], [10, 3]]), "M10,0L20,0L20,0L10,0L0,-10L0,-20L0,-20L0,-10Z");
+      assert.equal(a.endAngle(), Math.PI / 2);
+    },
+    "endAngle can be defined as a function": function(area) {
+      var a = area().endAngle(f), t = {}, dd = [], ii = [], tt = [];
+      function f(d, i) { dd.push(d); ii.push(i); tt.push(this); return Math.PI / 2; }
+      assert.pathEqual(a.call(t, [[10, 0], [20, 1], [20, 2], [10, 3]]), "M10,0L20,0L20,0L10,0L0,-10L0,-20L0,-20L0,-10Z");
+      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}");
+    },
+
+    "if innerRadius === outerRadius, radius is only evaluated once per point": function(area) {
+      var a = area().radius(f), t = {}, dd = [], ii = [], tt = [];
+      function f(d, i) { dd.push(d); ii.push(i); tt.push(this); return 30; }
+      assert.pathEqual(a.call(t, [[10, 0], [20, 1], [20, 2], [10, 3]]), "M0,-30L25.244130,-16.209069L27.278923,12.484405L4.233600,29.699775L0,-30L0,-30L0,-30L0,-30Z");
+      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}");
+    },
+    "if startAngle === endAngle, angle is only evaluated once per point": function(area) {
+      var a = area().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(a.call(t, [[10, 0], [20, 1], [20, 2], [10, 3]]), "M10,0L20,0L20,0L10,0L10,0L20,0L20,0L10,0Z");
+      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}");
+    },
+
+    "interpolate defaults to linear": function(area) {
+      assert.equal(area().interpolate(), "linear");
+    },
+    "interpolate can be defined as a constant": function(area) {
+      var a = area().interpolate("step-before");
+      assert.pathEqual(a([[0, 0], [1, 1]]), "M0,0V-0.540302H0.841471L0,-1H0V0Z");
+      assert.equal(a.interpolate(), "step-before");
+    },
+
+    "tension defaults to .7": function(area) {
+      assert.equal(area().tension(), .7);
+    },
+    "tension can be specified as a constant": function(area) {
+      var a = area().tension(.5);
+      assert.equal(a.tension(), .5);
+    },
+
+    "returns null if input points array is empty": function(area) {
+      assert.isNull(area()([]));
+    },
+
+    "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(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 area is just a transformation of a Cartesian line.
+function testInterpolation(interpolate) {
+  var data = [[10, 0], [20, 1], [20, 2], [10, 3]];
+
+  var cartesian = _.svg.area()
+      .x0(function(d) { return d[0] * Math.cos(d[1] - Math.PI / 2); })
+      .x1(function(d) { return 2 * d[0] * Math.cos(d[1] - Math.PI / 2); })
+      .y0(function(d) { return d[0] * Math.sin(d[1] - Math.PI / 2); })
+      .y1(function(d) { return 2 * d[0] * Math.sin(d[1] - Math.PI / 2); });
+
+  return function(area) {
+    var radial = area()
+        .innerRadius(function(d) { return d[0]; })
+        .outerRadius(function(d) { return d[0] * 2; })
+        .angle(function(d) { return d[1]; });
+
+    assert.pathEqual(radial.interpolate(interpolate)(data), cartesian.interpolate(interpolate)(data));
+  };
+}
+
+suite.export(module);