stripmem 0.0.1

data/lib/stripmem/public/components/d3/test/scale/quantize-test.js

@@ -0,0 +1,92 @@
+var vows = require("vows"),
+    _ = require("../../"),
+    load = require("../load"),
+    assert = require("../assert");
+
+var suite = vows.describe("d3.scale.quantize");
+
+suite.addBatch({
+  "quantize": {
+    topic: load("scale/quantize").expression("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(_.range(0, 1.001, .001))(1/3), .333, 1e-6);
+      assert.inDelta(x.range(_.range(0, 1.01, .01))(1/3), .33, 1e-6);
+      assert.inDelta(x.range(_.range(0, 1.1, .1))(1/3), .3, 1e-6);
+      assert.inDelta(x.range(_.range(0, 1.2, .2))(1/3), .4, 1e-6);
+      assert.inDelta(x.range(_.range(0, 1.25, .25))(1/3), .25, 1e-6);
+      assert.inDelta(x.range(_.range(0, 1.5, .5))(1/3), .5, 1e-6);
+      assert.inDelta(x.range(_.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);
+    },
+    "invertExtent": {
+      "maps a value in the range to a domain extent": function(quantize) {
+        var x = quantize().range([0, 1, 2, 3]);
+        assert.deepEqual(x.invertExtent(0), [0, .25]);
+        assert.deepEqual(x.invertExtent(1), [.25, .5]);
+        assert.deepEqual(x.invertExtent(2), [.5, .75]);
+        assert.deepEqual(x.invertExtent(3), [.75, 1]);
+      },
+      "allows arbitrary range values": function(quantize) {
+        var a = {}, b = {}, x = quantize().range([a, b]);
+        assert.deepEqual(x.invertExtent(a), [0, .5]);
+        assert.deepEqual(x.invertExtent(b), [.5, 1]);
+      },
+      "returns [NaN, NaN] when the given value is not in the range": function(quantize) {
+        var x = quantize();
+        assert.ok(x.invertExtent(-1).every(isNaN));
+        assert.ok(x.invertExtent(.5).every(isNaN));
+        assert.ok(x.invertExtent(2).every(isNaN));
+        assert.ok(x.invertExtent('a').every(isNaN));
+      },
+      "returns the first match if duplicate values exist in the range": function(quantize) {
+        var x = quantize().range([0, 1, 2, 0]);
+        assert.deepEqual(x.invertExtent(0), [0, .25]);
+        assert.deepEqual(x.invertExtent(1), [.25, .5]);
+      }
+    }
+  }
+});
+
+suite.export(module);

data/lib/stripmem/public/components/d3/test/scale/sqrt-test.js

@@ -0,0 +1,260 @@
+var vows = require("vows"),
+    load = require("../load"),
+    assert = require("../assert");
+
+var suite = vows.describe("d3.scale.sqrt");
+
+suite.addBatch({
+  "sqrt": {
+    topic: load("scale/sqrt", "interpolate/hsl"), // beware instanceof d3_Color
+
+    "domain": {
+      "defaults to [0, 1]": function(d3) {
+        var x = d3.scale.sqrt();
+        assert.deepEqual(x.domain(), [0, 1]);
+        assert.inDelta(x(.5), 0.7071068, 1e-6);
+      },
+      "coerces domain to numbers": function(d3) {
+        var x = d3.scale.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 = d3.scale.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 = d3.scale.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(d3) {
+        var x = d3.scale.sqrt().domain([-10, 0, 100]).range(["red", "white", "green"]);
+        assert.equal(x(-5), "#ff4b4b");
+        assert.equal(x(50), "#4ba54b");
+        assert.equal(x(75), "#229122");
+      },
+      "preserves specified domain exactly, with no floating point error": function(d3) {
+        var x = d3.scale.sqrt().domain([0, 5]);
+        assert.deepEqual(x.domain(), [0, 5]);
+      }
+    },
+
+    "range": {
+      "defaults to [0, 1]": function(d3) {
+        var x = d3.scale.sqrt();
+        assert.deepEqual(x.range(), [0, 1]);
+        assert.inDelta(x.invert(.5), .25, 1e-6);
+      },
+      "does not coerce range to numbers": function(d3) {
+        var x = d3.scale.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(d3) {
+        var x = d3.scale.sqrt().range(["0", "2"]);
+        assert.inDelta(x.invert("1"), .25, 1e-6);
+        var x = d3.scale.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 = d3.scale.sqrt().range(["#000", "#fff"]);
+        assert.isNaN(x.invert("#999"));
+      },
+      "can specify range values as colors": function(d3) {
+        var x = d3.scale.sqrt().range(["red", "blue"]);
+        assert.equal(x(.25), "#800080");
+        var x = d3.scale.sqrt().range(["#ff0000", "#0000ff"]);
+        assert.equal(x(.25), "#800080");
+        var x = d3.scale.sqrt().range(["#f00", "#00f"]);
+        assert.equal(x(.25), "#800080");
+        var x = d3.scale.sqrt().range([d3.rgb(255,0,0), d3.hsl(240,1,.5)]);
+        assert.equal(x(.25), "#800080");
+        var x = d3.scale.sqrt().range(["hsl(0,100%,50%)", "hsl(240,100%,50%)"]);
+        assert.equal(x(.25), "#800080");
+      },
+      "can specify range values as arrays or objects": function(d3) {
+        var x = d3.scale.sqrt().range([{color: "red"}, {color: "blue"}]);
+        assert.deepEqual(x(.25), {color: d3.rgb(128, 0, 128)});
+        var x = d3.scale.sqrt().range([["red"], ["blue"]]);
+        assert.deepEqual(x(.25), [d3.rgb(128, 0, 128)]);
+      }
+    },
+
+    "exponent": {
+      "defaults to .5": function(d3) {
+        var x = d3.scale.sqrt();
+        assert.equal(x.exponent(), .5);
+      },
+      "observes the specified exponent": function(d3) {
+        var x = d3.scale.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 = d3.scale.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 = d3.scale.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(d3) {
+        var x = d3.scale.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(d3) {
+        var x = d3.scale.sqrt().range(["red", "blue"]);
+        assert.equal(x.interpolate(), d3.interpolate);
+        assert.rgbEqual(x(.5), 75, 0, 180);
+      },
+      "can specify a custom interpolator": function(d3) {
+        var x = d3.scale.sqrt().range(["red", "blue"]).interpolate(d3.interpolateHsl);
+        assert.hslEqual(x(.25), -60, 1, .5);
+      }
+    },
+
+    "clamp": {
+      "defaults to false": function(d3) {
+        var x = d3.scale.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(d3) {
+        var x = d3.scale.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 = d3.scale.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(d3) {
+      var x = d3.scale.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(d3) {
+        var x = d3.scale.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 = d3.scale.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(d3) {
+        var x = d3.scale.sqrt().domain([1.1, 10.9]).nice(), f = d3.format(".6f");
+        assert.deepEqual(x.domain().map(f), [1, 11]);
+        var x = d3.scale.sqrt().domain([10.9, 1.1]).nice();
+        assert.deepEqual(x.domain().map(f), [11, 1]);
+        var x = d3.scale.sqrt().domain([.7, 11.001]).nice();
+        assert.deepEqual(x.domain().map(f), [0, 12]);
+        var x = d3.scale.sqrt().domain([123.1, 6.7]).nice();
+        assert.deepEqual(x.domain().map(f), [130, 0]);
+        var x = d3.scale.sqrt().domain([0, .49]).nice();
+        assert.deepEqual(x.domain().map(f), [0, .5]);
+      },
+      "nicing a polypower domain only affects the extent": function(d3) {
+        var x = d3.scale.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 = d3.scale.sqrt().domain([123.1, 1, 2, 3, -.9]).nice();
+        assert.deepEqual(x.domain().map(f), [130, 1, 2, 3, "-10.000000"]);
+      },
+      "preserves specified domain exactly, with no floating point error": function(d3) {
+        var x = d3.scale.sqrt().domain([0, 5]).nice();
+        assert.deepEqual(x.domain(), [0, 5]);
+      }
+    },
+
+    "copy": {
+      "changes to the domain are isolated": function(d3) {
+        var x = d3.scale.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(d3) {
+        var x = d3.scale.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(d3) {
+        var x = d3.scale.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(d3) {
+        var x = d3.scale.sqrt().range(["red", "blue"]), y = x.copy();
+        x.interpolate(d3.interpolateHsl);
+        assert.equal(x(0.5), "#9500ff");
+        assert.equal(y(0.5), "#4b00b4");
+        assert.equal(y.interpolate(), d3.interpolate);
+      },
+      "changes to clamping are isolated": function(d3) {
+        var x = d3.scale.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/lib/stripmem/public/components/d3/test/scale/threshold-test.js

@@ -0,0 +1,64 @@
+var vows = require("vows"),
+    load = require("../load"),
+    assert = require("../assert");
+
+var suite = vows.describe("d3.scale.threshold");
+
+suite.addBatch({
+  "threshold": {
+    topic: load("scale/threshold").expression("d3.scale.threshold"),
+    "has the default domain [.5]": function(threshold) {
+      var x = threshold();
+      assert.deepEqual(x.domain(), [.5]);
+      assert.equal(x(.49), 0);
+    },
+    "has the default range [0, 1]": function(threshold) {
+      var x = threshold();
+      assert.deepEqual(x.range(), [0, 1]);
+      assert.equal(x(.50), 1);
+    },
+    "maps a number to a discrete value in the range": function(threshold) {
+      var x = threshold().domain([1/3, 2/3]).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");
+    },
+    "returns undefined if the specified value is not orderable": function(threshold) {
+      var x = threshold().domain([1/3, 2/3]).range(["a", "b", "c"]);
+      assert.isUndefined(x());
+      assert.isUndefined(x(undefined));
+      assert.isUndefined(x(NaN));
+      assert.equal(x(null), "a"); // null < 1/3
+    },
+    "domain values are arbitrary": function(threshold) {
+      var x = threshold().domain(["10", "2"]).range([0, 1, 2]);
+      assert.strictEqual(x.domain()[0], "10");
+      assert.strictEqual(x.domain()[1], "2");
+      assert.equal(x("0"), 0);
+      assert.equal(x("12"), 1);
+      assert.equal(x("3"), 2);
+    },
+    "range values are arbitrary": function(threshold) {
+      var a = {}, b = {}, c = {}, x = threshold().domain([1/3, 2/3]).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);
+    },
+    "invertExtent": {
+      "returns the domain extent for the specified range value": function(threshold) {
+        var a = {}, b = {}, c = {}, x = threshold().domain([1/3, 2/3]).range([a, b, c]);
+        assert.deepEqual(x.invertExtent(a), [undefined, 1/3]);
+        assert.deepEqual(x.invertExtent(b), [1/3, 2/3]);
+        assert.deepEqual(x.invertExtent(c), [2/3, undefined]);
+      }
+    }
+  }
+});
+
+suite.export(module);

data/lib/stripmem/public/components/d3/test/selection/append-test.js

@@ -0,0 +1,153 @@
+var vows = require("vows"),
+    load = require("../load"),
+    assert = require("../assert");
+
+var suite = vows.describe("selection.append");
+
+suite.addBatch({
+  "select(body)": {
+    topic: load("selection/append").document(),
+    "on a simple page": {
+      topic: function(d3) {
+        return d3.select("body");
+      },
+      "appends an HTML element": function(body) {
+        var div = body.append("div");
+        assert.equal(div[0][0].tagName, "DIV");
+        assert.isNull(div[0][0].namespaceURI);
+        assert.isTrue(div[0][0].parentNode === body.node());
+        assert.isTrue(div[0][0] === body.node().lastChild);
+      },
+      "appends an SVG element": function(body) {
+        var svg = body.append("svg:svg");
+        assert.equal(svg[0][0].tagName, "SVG");
+        assert.equal(svg[0][0].namespaceURI, "http://www.w3.org/2000/svg");
+        assert.isTrue(svg[0][0].parentNode === body.node());
+        assert.isTrue(svg[0][0] === body.node().lastChild);
+      },
+      "appends an element specified as a function": function(body) {
+        var svg = body.select("svg").remove().node();
+        assert.isFalse(svg === body.node().lastChild);
+        body.append(function() { return svg; });
+        assert.isTrue(svg === body.node().lastChild);
+      },
+      "propagates data to new element": function(body) {
+        var data = new Object(), div = body.data([data]).append("div");
+        assert.strictEqual(div[0][0].__data__, data);
+      },
+      "returns a new selection": function(body) {
+        assert.isFalse(body.append("div") === body);
+      },
+      "inherits namespace from parent node": function(body) {
+        var g = body.append("svg:svg").append("g");
+        assert.equal(g[0][0].namespaceURI, "http://www.w3.org/2000/svg");
+      }
+    }
+  }
+});
+
+suite.addBatch({
+  "selectAll(div)": {
+    topic: load("selection/selection").document(),
+    "on a simple page": {
+      topic: function(d3) {
+        return d3.select("body").selectAll("div").data([0, 1]).enter().append("div");
+      },
+      "appends an HTML element": function(div) {
+        var span = div.append("span");
+        assert.equal(span[0].length, 2);
+        assert.equal(span[0][0].tagName, "SPAN");
+        assert.equal(span[0][1].tagName, "SPAN");
+        assert.isNull(span[0][0].namespaceURI);
+        assert.isNull(span[0][1].namespaceURI);
+        assert.isTrue(span[0][0].parentNode === div[0][0]);
+        assert.isTrue(span[0][1].parentNode === div[0][1]);
+        assert.isTrue(div[0][0].lastChild === span[0][0]);
+        assert.isTrue(div[0][1].lastChild === span[0][1]);
+      },
+      "appends an SVG element": function(div) {
+        var svg = div.append("svg:svg");
+        assert.equal(svg[0].length, 2);
+        assert.equal(svg[0][0].tagName, "SVG");
+        assert.equal(svg[0][1].tagName, "SVG");
+        assert.equal(svg[0][0].namespaceURI, "http://www.w3.org/2000/svg");
+        assert.equal(svg[0][1].namespaceURI, "http://www.w3.org/2000/svg");
+        assert.isTrue(svg[0][0].parentNode === div[0][0]);
+        assert.isTrue(svg[0][1].parentNode === div[0][1]);
+        assert.isTrue(div[0][0].lastChild === svg[0][0]);
+        assert.isTrue(div[0][1].lastChild === svg[0][1]);
+      },
+      "propagates data to new elements": function(div) {
+        var a = new Object(), b = new Object(), span = div.data([a, b]).append("span");
+        assert.strictEqual(span[0][0].__data__, a);
+        assert.strictEqual(span[0][1].__data__, b);
+      },
+      "returns a new selection": function(div) {
+        assert.isFalse(div.append("div") === div);
+      },
+      "ignores null nodes": function(div) {
+        var node = div.html("")[0][1];
+        div[0][1] = null;
+        var span = div.append("span");
+        assert.equal(span[0].length, 2);
+        assert.equal(span[0][0].tagName, "SPAN");
+        assert.isNull(span[0][1]);
+        assert.isTrue(span[0][0].parentNode === div[0][0]);
+        assert.isTrue(div[0][0].lastChild === span[0][0]);
+        assert.isNull(node.lastChild);
+      }
+    }
+  }
+});
+
+suite.addBatch({
+  "enter-append": {
+    topic: load("selection/selection").document(),
+    "on a page with existing elements": {
+      topic: function(d3) {
+        var body = d3.select("body");
+        body.selectAll("div").data(["apple", "orange"]).enter().append("div");
+        return body;
+      },
+      "appends to the end of the parent": function(body) {
+        var data = ["peach", "apple", "banana", "orange", "apricot"];
+        body.selectAll("div").data(data, String).enter().append("div");
+        assert.deepEqual(body.selectAll("div").data(), ["apple", "orange", "peach", "banana", "apricot"]);
+      }
+    }
+  }
+});
+
+suite.addBatch({
+  "selectAll(div).data(…).enter()": {
+    topic: load("selection/selection").document(),
+    "on a simple page": {
+      topic: function(d3) {
+        return d3.select("body");
+      },
+      "appends to the parent node": function(body) {
+        var div = body.selectAll("div").data([0, 1]).enter().append("div");
+        assert.equal(div.length, 1);
+        assert.equal(div[0].length, 2);
+        assert.domEqual(div[0][0].parentNode, body.node());
+        assert.domEqual(div[0][1].parentNode, body.node());
+      },
+      "propagates data to new elements": function(body) {
+        var a = new Object(), b = new Object(), div = body.html("").selectAll("div").data([a, b]).enter().append("div");
+        assert.strictEqual(div[0][0].__data__, a);
+        assert.strictEqual(div[0][1].__data__, b);
+      },
+      "ignores null nodes": function(body) {
+        body.html("").append("div");
+        var div = body.selectAll("div").data([0, 1, 2]).enter().append("div");
+        assert.equal(div.length, 1);
+        assert.equal(div[0].length, 3);
+        assert.domNull(div[0][0]);
+        assert.domEqual(div[0][1].parentNode, body.node());
+        assert.domEqual(div[0][2].parentNode, body.node());
+      }
+    }
+  }
+});
+
+suite.export(module);