bum 0.0.4 → 0.0.12

data/public/d3/test/scale/quantile-test.js

@@ -0,0 +1,64 @@
+require("../env");
+require("../../d3");
+
+var vows = require("vows"),
+    assert = require("assert");
+
+var suite = vows.describe("d3.scale.quantile");
+
+suite.addBatch({
+  "quantile": {
+    topic: function() {
+      return d3.scale.quantile;
+    },
+    "has the empty domain by default": function(quantile) {
+      assert.isEmpty(quantile().domain());
+    },
+    "has the empty range by default": function(quantile) {
+      assert.isEmpty(quantile().range());
+    },
+    "uses the R-7 algorithm to compute quantiles": function(quantile) {
+      var x = d3.scale.quantile().domain([3, 6, 7, 8, 8, 10, 13, 15, 16, 20]).range([0, 1, 2, 3]);
+      assert.deepEqual([3, 6, 6.9, 7, 7.1].map(x), [0, 0, 0, 0, 0]);
+      assert.deepEqual([8, 8.9].map(x), [1, 1]);
+      assert.deepEqual([9, 9.1, 10, 13].map(x), [2, 2, 2, 2]);
+      assert.deepEqual([14.9, 15, 15.1, 16, 20].map(x), [3, 3, 3, 3, 3]);
+      var x = d3.scale.quantile().domain([3, 6, 7, 8, 8, 9, 10, 13, 15, 16, 20]).range([0, 1, 2, 3]);
+      assert.deepEqual([3, 6, 6.9, 7, 7.1].map(x), [0, 0, 0, 0, 0]);
+      assert.deepEqual([8, 8.9].map(x), [1, 1]);
+      assert.deepEqual([9, 9.1, 10, 13].map(x), [2, 2, 2, 2]);
+      assert.deepEqual([14.9, 15, 15.1, 16, 20].map(x), [3, 3, 3, 3, 3]);
+    },
+    "domain values are sorted in ascending order": function(quantile) {
+      var x = d3.scale.quantile().domain([6, 3, 7, 8, 8, 13, 20, 15, 16, 10]);
+      assert.deepEqual(x.domain(), [3, 6, 7, 8, 8, 10, 13, 15, 16, 20]);
+    },
+    "non-numeric domain values are ignored": function(quantile) {
+      var x = d3.scale.quantile().domain([6, 3, NaN, undefined, 7, 8, 8, 13, 20, 15, 16, 10, NaN]);
+      assert.deepEqual(x.domain(), [3, 6, 7, 8, 8, 10, 13, 15, 16, 20]);
+    },
+    "quantiles returns the inner thresholds": function(quantile) {
+      var x = d3.scale.quantile().domain([3, 6, 7, 8, 8, 10, 13, 15, 16, 20]).range([0, 1, 2, 3]);
+      assert.deepEqual(x.quantiles(), [7.25, 9, 14.5]);
+      var x = d3.scale.quantile().domain([3, 6, 7, 8, 8, 9, 10, 13, 15, 16, 20]).range([0, 1, 2, 3]);
+      assert.deepEqual(x.quantiles(), [7.5, 9, 14]);
+    },
+    "range cardinality determines the number of quantiles": function(quantile) {
+      var x = d3.scale.quantile().domain([3, 6, 7, 8, 8, 10, 13, 15, 16, 20]);;
+      assert.deepEqual(x.range([0, 1, 2, 3]).quantiles(), [7.25, 9, 14.5]);
+      assert.deepEqual(x.range([0, 1]).quantiles(), [9]);
+      assert.deepEqual(x.range([,,,,,]).quantiles(), [6.8, 8, 11.2, 15.2]);
+      assert.deepEqual(x.range([,,,,,,]).quantiles(), [6.5, 8, 9, 13, 15.5]);
+    },
+    "range values are arbitrary": function(quantile) {
+      var a = new Object(), b = new Object(), c = new Object();
+      var x = d3.scale.quantile().domain([3, 6, 7, 8, 8, 10, 13, 15, 16, 20]).range([a, b, c, a]);
+      assert.deepEqual([3, 6, 6.9, 7, 7.1].map(x), [a, a, a, a, a]);
+      assert.deepEqual([8, 8.9].map(x), [b, b]);
+      assert.deepEqual([9, 9.1, 10, 13].map(x), [c, c, c, c]);
+      assert.deepEqual([14.9, 15, 15.1, 16, 20].map(x), [a, a, a, a, a]);
+    }
+  }
+});
+
+suite.export(module);

data/public/d3/test/scale/quantize-test.js

@@ -0,0 +1,69 @@
+require("../env");
+require("../../d3");
+
+var vows = require("vows"),
+    assert = require("assert");
+
+var suite = vows.describe("d3.scale.quantize");
+
+suite.addBatch({
+  "quantize": {
+    topic: function() {
+      return d3.scale.quantize;
+    },
+    "has the default domain [0, 1]": function(quantize) {
+      var x = quantize();
+      assert.deepEqual(x.domain(), [0, 1]);
+      assert.equal(x(.25), 0);
+    },
+    "has the default range [0, 1]": function(quantize) {
+      var x = quantize();
+      assert.deepEqual(x.range(), [0, 1]);
+      assert.equal(x(.75), 1);
+    },
+    "maps a number to a discrete value in the range": function(quantize) {
+      var x = quantize().range([0, 1, 2]);
+      assert.equal(x(0), 0);
+      assert.equal(x(.2), 0);
+      assert.equal(x(.4), 1);
+      assert.equal(x(.6), 1);
+      assert.equal(x(.8), 2);
+      assert.equal(x(1), 2);
+    },
+    "coerces domain to numbers": function(quantize) {
+      var x = quantize().domain(["0", "100"]);
+      assert.strictEqual(x.domain()[0], 0);
+      assert.strictEqual(x.domain()[1], 100);
+    },
+    "only considers the extent of the domain": function(quantize) {
+      var x = quantize().domain([-1, 0, 100]);
+      assert.deepEqual(x.domain(), [-1, 100]);
+    },
+    "clamps input values to the domain": function(quantize) {
+      var a = {}, b = {}, c = {}, x = quantize().range([a, b, c]);
+      assert.equal(x(-.5), a);
+      assert.equal(x(1.5), c);
+    },
+    "range cardinality determines the degree of quantization": function(quantize) {
+      var x = quantize();
+      assert.inDelta(x.range(d3.range(0, 1.001, .001))(1/3), .333, 1e-6);
+      assert.inDelta(x.range(d3.range(0, 1.01, .01))(1/3), .33, 1e-6);
+      assert.inDelta(x.range(d3.range(0, 1.1, .1))(1/3), .3, 1e-6);
+      assert.inDelta(x.range(d3.range(0, 1.2, .2))(1/3), .4, 1e-6);
+      assert.inDelta(x.range(d3.range(0, 1.25, .25))(1/3), .25, 1e-6);
+      assert.inDelta(x.range(d3.range(0, 1.5, .5))(1/3), .5, 1e-6);
+      assert.inDelta(x.range(d3.range(1))(1/3), 0, 1e-6);
+    },
+    "range values are arbitrary": function(quantize) {
+      var a = {}, b = {}, c = {}, x = quantize().range([a, b, c]);
+      assert.equal(x(0), a);
+      assert.equal(x(.2), a);
+      assert.equal(x(.4), b);
+      assert.equal(x(.6), b);
+      assert.equal(x(.8), c);
+      assert.equal(x(1), c);
+    }
+  }
+});
+
+suite.export(module);

data/public/d3/test/scale/sqrt-test.js

@@ -0,0 +1,256 @@
+require("../env");
+require("../../d3");
+
+var vows = require("vows"),
+    assert = require("assert");
+
+var suite = vows.describe("d3.scale.sqrt");
+
+suite.addBatch({
+  "sqrt": {
+    topic: function() {
+      return d3.scale.sqrt;
+    },
+
+    "domain": {
+      "defaults to [0, 1]": function(sqrt) {
+        var x = sqrt();
+        assert.deepEqual(x.domain(), [0, 1]);
+        assert.inDelta(x(.5), 0.7071068, 1e-6);
+      },
+      "coerces domain to numbers": function(sqrt) {
+        var x = sqrt().domain([new Date(1990, 0, 1), new Date(1991, 0, 1)]);
+        assert.equal(typeof x.domain()[0], "number");
+        assert.equal(typeof x.domain()[1], "number");
+        assert.inDelta(x(new Date(1989, 09, 20)), -.2, 1e-2);
+        assert.inDelta(x(new Date(1990, 00, 01)), 0, 1e-2);
+        assert.inDelta(x(new Date(1990, 02, 15)), .2, 1e-2);
+        assert.inDelta(x(new Date(1990, 04, 27)), .4, 1e-2);
+        assert.inDelta(x(new Date(1991, 00, 01)), 1, 1e-2);
+        assert.inDelta(x(new Date(1991, 02, 15)), 1.2, 1e-2);
+        var x = sqrt().domain(["0", "1"]);
+        assert.equal(typeof x.domain()[0], "number");
+        assert.equal(typeof x.domain()[1], "number");
+        assert.inDelta(x(.5), 0.7071068, 1e-6);
+        var x = sqrt().domain([new Number(0), new Number(1)]);
+        assert.equal(typeof x.domain()[0], "number");
+        assert.equal(typeof x.domain()[1], "number");
+        assert.inDelta(x(.5), 0.7071068, 1e-6);
+      },
+      "can specify a polypower domain and range": function(sqrt) {
+        var x = sqrt().domain([-10, 0, 100]).range(["red", "white", "green"]);
+        assert.equal(x(-5), "rgb(255,75,75)");
+        assert.equal(x(50), "rgb(75,165,75)");
+        assert.equal(x(75), "rgb(34,145,34)");
+      }
+    },
+
+    "range": {
+      "defaults to [0, 1]": function(sqrt) {
+        var x = sqrt();
+        assert.deepEqual(x.range(), [0, 1]);
+        assert.inDelta(x.invert(.5), .25, 1e-6);
+      },
+      "does not coerce range to numbers": function(sqrt) {
+        var x = sqrt().range(["0", "2"]);
+        assert.equal(typeof x.range()[0], "string");
+        assert.equal(typeof x.range()[1], "string");
+      },
+      "coerces range value to number on invert": function(sqrt) {
+        var x = sqrt().range(["0", "2"]);
+        assert.inDelta(x.invert("1"), .25, 1e-6);
+        var x = sqrt().range([new Date(1990, 0, 1), new Date(1991, 0, 1)]);
+        assert.inDelta(x.invert(new Date(1990, 6, 2, 13)), .25, 1e-6);
+        var x = sqrt().range(["#000", "#fff"]);
+        assert.isNaN(x.invert("#999"));
+      },
+      "can specify range values as colors": function(sqrt) {
+        var x = sqrt().range(["red", "blue"]);
+        assert.equal(x(.25), "rgb(128,0,128)");
+        var x = sqrt().range(["#ff0000", "#0000ff"]);
+        assert.equal(x(.25), "rgb(128,0,128)");
+        var x = sqrt().range(["#f00", "#00f"]);
+        assert.equal(x(.25), "rgb(128,0,128)");
+        var x = sqrt().range([d3.rgb(255,0,0), d3.hsl(240,1,.5)]);
+        assert.equal(x(.25), "rgb(128,0,128)");
+        var x = sqrt().range(["hsl(0,100%,50%)", "hsl(240,100%,50%)"]);
+        assert.equal(x(.25), "rgb(128,0,128)");
+      },
+      "can specify range values as arrays or objects": function(sqrt) {
+        var x = sqrt().range([{color: "red"}, {color: "blue"}]);
+        assert.deepEqual(x(.25), {color: "rgb(128,0,128)"});
+        var x = sqrt().range([["red"], ["blue"]]);
+        assert.deepEqual(x(.25), ["rgb(128,0,128)"]);
+      }
+    },
+
+    "exponent": {
+      "defaults to .5": function(sqrt) {
+        var x = sqrt();
+        assert.equal(x.exponent(), .5);
+      },
+      "observes the specified exponent": function(sqrt) {
+        var x = sqrt().exponent(.5).domain([1, 2]);
+        assert.inDelta(x(1), 0, 1e-6);
+        assert.inDelta(x(1.5), 0.5425821, 1e-6);
+        assert.inDelta(x(2), 1, 1e-6);
+        var x = sqrt().exponent(2).domain([1, 2]);
+        assert.inDelta(x(1), 0, 1e-6);
+        assert.inDelta(x(1.5), .41666667, 1e-6);
+        assert.inDelta(x(2), 1, 1e-6);
+        var x = sqrt().exponent(-1).domain([1, 2]);
+        assert.inDelta(x(1), 0, 1e-6);
+        assert.inDelta(x(1.5), .6666667, 1e-6);
+        assert.inDelta(x(2), 1, 1e-6);
+      },
+      "changing the exponent does not change the domain or range": function(sqrt) {
+        var x = sqrt().domain([1, 2]).range([3, 4]), f = d3.format(".6f");
+        x.exponent(.5);
+        assert.deepEqual(x.domain().map(f), [1, 2]);
+        assert.deepEqual(x.range(), [3, 4]);
+        x.exponent(2);
+        assert.deepEqual(x.domain().map(f), [1, 2]);
+        assert.deepEqual(x.range(), [3, 4]);
+        x.exponent(-1);
+        assert.deepEqual(x.domain().map(f), [1, 2]);
+        assert.deepEqual(x.range(), [3, 4]);
+      }
+    },
+
+    "interpolate": {
+      "defaults to d3.interpolate": function(sqrt) {
+        var x = sqrt().range(["red", "blue"]);
+        assert.equal(x.interpolate(), d3.interpolate);
+        assert.equal(x(.5), "rgb(75,0,180)");
+      },
+      "can specify a custom interpolator": function(sqrt) {
+        var x = sqrt().range(["red", "blue"]).interpolate(d3.interpolateHsl);
+        assert.equal(x(.25), "#00ff00");
+      }
+    },
+
+    "clamp": {
+      "defaults to false": function(sqrt) {
+        var x = sqrt();
+        assert.isFalse(x.clamp());
+        assert.inDelta(x(-.5), -0.7071068, 1e-6);
+        assert.inDelta(x(1.5), 1.22474487, 1e-6);
+      },
+      "can clamp to the domain": function(sqrt) {
+        var x = sqrt().clamp(true);
+        assert.inDelta(x(-.5), 0, 1e-6);
+        assert.inDelta(x(.25), .5, 1e-6);
+        assert.inDelta(x(1.5), 1, 1e-6);
+        var x = sqrt().domain([1, 0]).clamp(true);
+        assert.inDelta(x(-.5), 1, 1e-6);
+        assert.inDelta(x(.25), .5, 1e-6);
+        assert.inDelta(x(1.5), 0, 1e-6);
+      }
+    },
+
+    "maps a number to a number": function(sqrt) {
+      var x = sqrt().domain([1, 2]);
+      assert.inDelta(x(.5), -0.7071068, 1e-6);
+      assert.inDelta(x(1), 0, 1e-6);
+      assert.inDelta(x(1.5), 0.5425821, 1e-6);
+      assert.inDelta(x(2), 1, 1e-6);
+      assert.inDelta(x(2.5), 1.4029932, 1e-6);
+    },
+
+    "ticks": {
+      "can generate ticks of varying degree": function(sqrt) {
+        var x = sqrt();
+        assert.deepEqual(x.ticks(1).map(x.tickFormat(1)), [0, 1]);
+        assert.deepEqual(x.ticks(2).map(x.tickFormat(2)), [0, .5, 1]);
+        assert.deepEqual(x.ticks(5).map(x.tickFormat(5)), [0, .2, .4, .6, .8, 1]);
+        assert.deepEqual(x.ticks(10).map(x.tickFormat(10)), [0, .1, .2, .3, .4, .5, .6, .7, .8, .9, 1]);
+        var x = sqrt().domain([1, 0]);
+        assert.deepEqual(x.ticks(1).map(x.tickFormat(1)), [0, 1]);
+        assert.deepEqual(x.ticks(2).map(x.tickFormat(2)), [0, .5, 1]);
+        assert.deepEqual(x.ticks(5).map(x.tickFormat(5)), [0, .2, .4, .6, .8, 1]);
+        assert.deepEqual(x.ticks(10).map(x.tickFormat(10)), [0, .1, .2, .3, .4, .5, .6, .7, .8, .9, 1]);
+      }
+    },
+
+    "nice": {
+      "can nice the domain, extending it to round numbers": function(sqrt) {
+        var x = sqrt().domain([1.1, 10.9]).nice(), f = d3.format(".6f");
+        assert.deepEqual(x.domain().map(f), [1, 11]);
+        var x = sqrt().domain([10.9, 1.1]).nice();
+        assert.deepEqual(x.domain().map(f), [11, 1]);
+        var x = sqrt().domain([.7, 11.001]).nice();
+        assert.deepEqual(x.domain().map(f), [0, 12]);
+        var x = sqrt().domain([123.1, 6.7]).nice();
+        assert.deepEqual(x.domain().map(f), [130, 0]);
+        var x = sqrt().domain([0, .49]).nice();
+        assert.deepEqual(x.domain().map(f), [0, .5]);
+      },
+      "nicing a polypower domain only affects the extent": function(sqrt) {
+        var x = sqrt().domain([1.1, 1, 2, 3, 10.9]).nice(), f = d3.format(".6f");
+        assert.deepEqual(x.domain().map(f), [1, 1, 2, 3, 11]);
+        var x = sqrt().domain([123.1, 1, 2, 3, -.9]).nice();
+        assert.deepEqual(x.domain().map(f), [130, 1, 2, 3, "−10.000000"]);
+      }
+    },
+
+    "copy": {
+      "changes to the domain are isolated": function(sqrt) {
+        var x = sqrt(), y = x.copy();
+        x.domain([1, 2]);
+        assert.deepEqual(y.domain(), [0, 1]);
+        assert.equal(x(1), 0);
+        assert.equal(y(1), 1);
+        y.domain([2, 3]);
+        assert.equal(x(2), 1);
+        assert.equal(y(2), 0);
+        assert.inDelta(x.domain(), [1, 2], 1e-6);
+        assert.inDelta(y.domain(), [2, 3], 1e-6);
+      },
+      "changes to the range are isolated": function(sqrt) {
+        var x = sqrt(), y = x.copy();
+        x.range([1, 2]);
+        assert.equal(x.invert(1), 0);
+        assert.equal(y.invert(1), 1);
+        assert.deepEqual(y.range(), [0, 1]);
+        y.range([2, 3]);
+        assert.equal(x.invert(2), 1);
+        assert.equal(y.invert(2), 0);
+        assert.deepEqual(x.range(), [1, 2]);
+        assert.deepEqual(y.range(), [2, 3]);
+      },
+      "changes to the exponent are isolated": function(sqrt) {
+        var x = sqrt().exponent(2), y = x.copy();
+        x.exponent(.5);
+        assert.inDelta(x(.5), Math.SQRT1_2, 1e-6);
+        assert.inDelta(y(.5), 0.25, 1e-6);
+        assert.equal(x.exponent(), .5);
+        assert.equal(y.exponent(), 2);
+        y.exponent(3);
+        assert.inDelta(x(.5), Math.SQRT1_2, 1e-6);
+        assert.inDelta(y(.5), 0.125, 1e-6);
+        assert.equal(x.exponent(), .5);
+        assert.equal(y.exponent(), 3);
+      },
+      "changes to the interpolator are isolated": function(sqrt) {
+        var x = sqrt().range(["red", "blue"]), y = x.copy();
+        x.interpolate(d3.interpolateHsl);
+        assert.equal(x(0.5), "#00ffd3");
+        assert.equal(y(0.5), "rgb(75,0,180)");
+        assert.equal(y.interpolate(), d3.interpolate);
+      },
+      "changes to clamping are isolated": function(sqrt) {
+        var x = sqrt().clamp(true), y = x.copy();
+        x.clamp(false);
+        assert.equal(x(2), Math.SQRT2);
+        assert.equal(y(2), 1);
+        assert.isTrue(y.clamp());
+        y.clamp(false);
+        assert.equal(x(2), Math.SQRT2);
+        assert.equal(y(2), Math.SQRT2);
+        assert.isFalse(x.clamp());
+      }
+    }
+  }
+});
+
+suite.export(module);

data/public/d3/test/svg/arc-test.js

@@ -0,0 +1,147 @@
+require("../env");
+require("../../d3");
+
+var vows = require("vows"),
+    assert = require("assert");
+
+var suite = vows.describe("d3.svg.arc");
+
+suite.addBatch({
+  "arc": {
+    topic: function() {
+      return 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);