stripmem 0.0.1

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

@@ -0,0 +1,134 @@
+var vows = require("vows"),
+    load = require("../load"),
+    assert = require("../assert");
+
+var suite = vows.describe("selection.html");
+
+suite.addBatch({
+  "select(body)": {
+    topic: load("selection/selection").document(),
+    "on a simple page": {
+      topic: function(d3) {
+        return d3.select("body");
+      },
+      "sets the inner HTML as a string": function(body) {
+        body.html("<h1>Hello, world!</h1>");
+        assert.equal(body.node().firstChild.tagName, "H1");
+        assert.equal(body.node().firstChild.textContent, "Hello, world!");
+      },
+      "sets the inner HTML as a number": function(body) {
+        body.html(42);
+        assert.equal(body.node().innerHTML, "42");
+        assert.equal(body.node().firstChild.nodeType, 3);
+      },
+      "sets the inner HTML as a function": function(body) {
+        body.data(["Subject"]).html(function(d, i) { return "<b>" + d + "</b><i>" + i + "</i>"; });
+        assert.equal(body.node().firstChild.tagName, "B");
+        assert.equal(body.node().firstChild.textContent, "Subject");
+        assert.equal(body.node().lastChild.tagName, "I");
+        assert.equal(body.node().lastChild.textContent, "0");
+      },
+      "clears the inner HTML as null": function(body) {
+        body.html(null);
+        assert.equal(body.node().innerHTML, "");
+        assert.isNull(body.node().firstChild);
+      },
+      "clears the inner HTML as undefined": function(body) {
+        body.html(undefined);
+        assert.equal(body.node().innerHTML, "");
+        assert.isNull(body.node().firstChild);
+      },
+      "clears the inner HTML as the empty string": function(body) {
+        body.html("");
+        assert.equal(body.node().innerHTML, "");
+        assert.isNull(body.node().firstChild);
+      },
+      "clears the inner HTML as a function returning the empty string": function(body) {
+        body.text(function() { return ""; });
+        assert.equal(body.node().innerHTML, "");
+        assert.isNull(body.node().firstChild);
+      },
+      "clears the inner HTML as a function returning null": function(body) {
+        body.text(function() { return null; });
+        assert.equal(body.node().innerHTML, "");
+        assert.isNull(body.node().firstChild);
+      },
+      "clears the inner HTML as a function returning undefined": function(body) {
+        body.text(function() { return undefined; });
+        assert.equal(body.node().innerHTML, "");
+        assert.isNull(body.node().firstChild);
+      },
+      "returns the current selection": function(body) {
+        assert.isTrue(body.html("foo") === body);
+      },
+      "ignores null nodes": function(body) {
+        var node = body.node();
+        body[0][0] = null;
+        node.innerHTML = "<h1>foo</h1>";
+        body.html("bar");
+        assert.equal(node.textContent, "foo");
+      }
+    }
+  }
+});
+
+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");
+      },
+      "sets the inner HTML as a string": function(div) {
+        div.html("<h1>Hello, world!</h1>");
+        assert.equal(div[0][0].firstChild.tagName, "H1");
+        assert.equal(div[0][0].firstChild.textContent, "Hello, world!");
+        assert.equal(div[0][1].firstChild.tagName, "H1");
+        assert.equal(div[0][1].firstChild.textContent, "Hello, world!");
+      },
+      "sets the inner HTML as a number": function(div) {
+        div.html(42);
+        assert.equal(div[0][0].innerHTML, "42");
+        assert.equal(div[0][0].firstChild.nodeType, 3);
+      },
+      "sets the inner HTML as a function": function(div) {
+        div.data(["foo", "bar"]).html(function(d, i) { return "<b>" + d + "</b><i>" + i + "</i>"; });
+        assert.equal(div[0][0].firstChild.tagName, "B");
+        assert.equal(div[0][0].firstChild.textContent, "foo");
+        assert.equal(div[0][0].lastChild.tagName, "I");
+        assert.equal(div[0][0].lastChild.textContent, "0");
+        assert.equal(div[0][1].firstChild.tagName, "B");
+        assert.equal(div[0][1].firstChild.textContent, "bar");
+        assert.equal(div[0][1].lastChild.tagName, "I");
+        assert.equal(div[0][1].lastChild.textContent, "1");
+      },
+      "clears the inner HTML as null": function(div) {
+        div.html(null);
+        assert.equal(div[0][0].innerHTML, "");
+        assert.isNull(div[0][0].firstChild);
+        assert.equal(div[0][1].innerHTML, "");
+        assert.isNull(div[0][1].firstChild);
+      },
+      "clears the inner HTML as a function": function(div) {
+        div.html(function() { return ""; });
+        assert.equal(div[0][0].innerHTML, "");
+        assert.isNull(div[0][0].firstChild);
+        assert.equal(div[0][1].innerHTML, "");
+        assert.isNull(div[0][1].firstChild);
+      },
+      "returns the current selection": function(div) {
+        assert.isTrue(div.html("foo") === div);
+      },
+      "ignores null nodes": function(div) {
+        var node = div[0][0];
+        div[0][0] = null;
+        node.innerHTML = "<h1>foo</h1>";
+        div.html("bar");
+        assert.equal(node.textContent, "foo");
+        assert.equal(div[0][1].textContent, "bar");
+      }
+    }
+  }
+});
+
+suite.export(module);

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

@@ -0,0 +1,169 @@
+var vows = require("vows"),
+    load = require("../load"),
+    assert = require("../assert");
+
+var suite = vows.describe("selection.insert");
+
+suite.addBatch({
+  "select(body)": {
+    topic: load("selection/insert").document(),
+    "on a simple page": {
+      topic: function(d3) {
+        return d3.select("body");
+      },
+      "inserts before the specified selector": function(body) {
+        var span = body.html("").append("span");
+        var div = body.insert("div", "span");
+        assert.equal(div[0][0].tagName, "DIV");
+        assert.isNull(div[0][0].namespaceURI);
+        assert.domEqual(div[0][0], body.node().firstChild);
+        assert.domEqual(div[0][0].nextSibling, span[0][0]);
+      },
+      "inserts before the specified node": function(body) {
+        var span = body.html("").append("span");
+        var div = body.insert("div", function() { return span.node(); });
+        assert.equal(div[0][0].tagName, "DIV");
+        assert.isNull(div[0][0].namespaceURI);
+        assert.domEqual(div[0][0], body.node().firstChild);
+        assert.domEqual(div[0][0].nextSibling, span[0][0]);
+      },
+      "appends an HTML element": function(body) {
+        var div = body.insert("div");
+        assert.equal(div[0][0].tagName, "DIV");
+        assert.isNull(div[0][0].namespaceURI);
+        assert.domEqual(div[0][0], body.node().lastChild);
+      },
+      "appends an SVG element": function(body) {
+        var svg = body.insert("svg:svg");
+        assert.equal(svg[0][0].tagName, "SVG");
+        assert.equal(svg[0][0].namespaceURI, "http://www.w3.org/2000/svg");
+        assert.domEqual(svg[0][0].parentNode, body.node());
+        assert.domEqual(svg[0][0], body.node().lastChild);
+      },
+      "propagates data to new element": function(body) {
+        var data = new Object(), div = body.data([data]).insert("div");
+        assert.strictEqual(div[0][0].__data__, data);
+      },
+      "returns a new selection": function(body) {
+        assert.isFalse(body.insert("div") === body);
+      },
+      "inherits namespace from parent node": function(body) {
+        var g = body.insert("svg:svg").insert("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().insert("div");
+      },
+      "appends an HTML element": function(div) {
+        var span = div.insert("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.domEqual(span[0][0].parentNode, div[0][0]);
+        assert.domEqual(span[0][1].parentNode, div[0][1]);
+        assert.domEqual(div[0][0].lastChild, span[0][0]);
+        assert.domEqual(div[0][1].lastChild, span[0][1]);
+      },
+      "appends an SVG element": function(div) {
+        var svg = div.insert("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.domEqual(svg[0][0].parentNode, div[0][0]);
+        assert.domEqual(svg[0][1].parentNode, div[0][1]);
+        assert.domEqual(div[0][0].lastChild, svg[0][0]);
+        assert.domEqual(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]).insert("span");
+        assert.strictEqual(span[0][0].__data__, a);
+        assert.strictEqual(span[0][1].__data__, b);
+      },
+      "returns a new selection": function(div) {
+        assert.isFalse(div.insert("div") === div);
+      },
+      "ignores null nodes": function(div) {
+        div.html("");
+        var node = div[0][1];
+        div[0][1] = null;
+        var span = div.insert("span");
+        assert.equal(span[0].length, 2);
+        assert.equal(span[0][0].tagName, "SPAN");
+        assert.domNull(span[0][1]);
+        assert.domEqual(span[0][0].parentNode, div[0][0]);
+        assert.domEqual(div[0][0].lastChild, span[0][0]);
+        assert.domNull(node.lastChild);
+      }
+    }
+  }
+});
+
+suite.addBatch({
+  "enter-insert": {
+    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;
+      },
+      "inserts before the following updating sibling": function(body) {
+        var data = ["peach", "apple", "apple2", "apple3", "banana", "orange", "apricot"];
+        body.selectAll("div").data(data, String).enter().insert("div");
+        assert.deepEqual(body.selectAll("div").data(), data);
+      }
+    }
+  }
+});
+
+suite.addBatch({
+  "selectAll(div).data(…).enter()": {
+    topic: load("selection/selection").document(),
+    "on a simple page": {
+      topic: function(d3) {
+        return d3.select("body");
+      },
+      "inserts before the specified selector": function(body) {
+        var span = body.append("span");
+        var div = body.selectAll("div").data([0, 1]).enter().insert("div", "span");
+        assert.equal(div.length, 1);
+        assert.equal(div[0].length, 2);
+        assert.domEqual(div[0][0], body.node().firstChild);
+        assert.domEqual(div[0][1].previousSibling, div[0][0]);
+        assert.domEqual(div[0][1].nextSibling, span[0][0]);
+      },
+      "propagates data to new elements": function(body) {
+        var a = new Object(), b = new Object(), div = body.html("").selectAll("div").data([a, b]).enter().insert("div");
+        assert.strictEqual(div[0][0].__data__, a);
+        assert.strictEqual(div[0][1].__data__, b);
+      },
+      "ignores null nodes": function(body) {
+        body.html("").insert("div");
+        var div = body.selectAll("div").data([0, 1, 2]).enter().insert("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());
+      },
+      "returns a new selection": function(body) {
+        var enter = body.html("").selectAll("div").data([0, 1]).enter();
+        assert.isFalse(enter.insert("div") === enter);
+      }
+    }
+  }
+});
+
+suite.export(module);

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

@@ -0,0 +1,55 @@
+var vows = require("vows"),
+    load = require("../load"),
+    assert = require("../assert");
+
+var suite = vows.describe("selection.node");
+
+suite.addBatch({
+  "select(body)": {
+    topic: load("selection/node").document(),
+    "on a simple page": {
+      topic: function(d3) {
+        return d3.select("body");
+      },
+      "returns null for empty selections": function(body) {
+        assert.isNull(body.select("foo").node());
+      },
+      "returns the first element for non-empty selections": function(body) {
+        assert.isTrue(body.node() === body[0][0]);
+        assert.equal(body.node().tagName, "BODY");
+      },
+      "ignores null nodes": function(body) {
+        body[0][0] = null;
+        assert.isNull(body.node());
+      }
+    }
+  }
+});
+
+suite.addBatch({
+  "selectAll(div)": {
+    topic: load("selection/node").document(),
+    "on a simple page": {
+      topic: function(d3) {
+        var body = d3.select("body");
+        body.append("div").append("span");
+        body.append("div");
+        return body.selectAll("div");
+      },
+      "returns null for empty selections": function(div) {
+        assert.isNull(div.select("foo").node());
+      },
+      "returns the first element for non-empty selections": function(div) {
+        assert.isTrue(div.node() === div[0][0]);
+        assert.equal(div.node().tagName, "DIV");
+      },
+      "ignores null nodes": function(div) {
+        div[0][0] = null;
+        assert.isTrue(div.node() === div[0][1]);
+        assert.equal(div.node().tagName, "DIV");
+      }
+    }
+  }
+});
+
+suite.export(module);

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

@@ -0,0 +1,135 @@
+var vows = require("vows"),
+    load = require("../load"),
+    assert = require("../assert");
+
+var suite = vows.describe("selection.on");
+
+suite.addBatch({
+  "select(body)": {
+    topic: load("selection/on").document(),
+    "on a simple page": {
+      topic: function(d3) {
+        return d3.select("body");
+      },
+      "registers an event listener for the specified type": function(body) {
+        var form = body.append("form"), count = 0;
+        form.on("submit", function() { ++count; }); // jsdom has spotty event support
+        form.append("input").attr("type", "submit").node().click();
+        assert.equal(count, 1);
+      },
+      "replaces an existing event listener for the same type": function(body) {
+        var form = body.append("form"), count = 0, fail = 0;
+        form.on("submit", function() { ++fail; });
+        form.on("submit", function() { ++count; });
+        form.append("input").attr("type", "submit").node().click();
+        assert.equal(count, 1);
+        assert.equal(fail, 0);
+      },
+      "removes an existing event listener": function(body) {
+        var form = body.append("form"), fail = 0;
+        form.on("submit", function() { ++fail; });
+        form.on("submit", null);
+        form.append("input").attr("type", "submit").node().click();
+        assert.equal(fail, 0);
+        assert.isUndefined(form.on("submit"));
+      },
+      /* Regrettably, JSDOM ignores the capture flag, so we can't test this yet…
+      "removing a listener doesn't require the capture flag": function(body) {
+        var form = body.append("form"), fail = 0;
+        form.on("submit", function() { ++fail; }, true);
+        form.on("submit", null);
+        form.append("input").attr("type", "submit").node().click();
+        assert.equal(fail, 0);
+        assert.isUndefined(form.on("submit"));
+      },
+      */
+      "ignores removal of non-matching event listener": function(body) {
+        body.append("form").on("submit", null);
+      },
+      "observes the specified namespace": function(body) {
+        var form = body.append("form"), foo = 0, bar = 0;
+        form.on("submit.foo", function() { ++foo; });
+        form.on({"submit.bar": function() { ++bar; }});
+        form.append("input").attr("type", "submit").node().click();
+        assert.equal(foo, 1);
+        assert.equal(bar, 1);
+      },
+      "can register listeners as a map": function(body) {
+        var form = body.append("form"), count = 0, fail = 0;
+        form.on({submit: function() { ++fail; }});
+        form.on({submit: function() { ++count; }});
+        form.append("input").attr("type", "submit").node().click();
+        assert.equal(count, 1);
+        assert.equal(fail, 0);
+        form.on({submit: null});
+        assert.isUndefined(form.on("submit"));
+      },
+      /* Not really sure how to test this one…
+      "observes the specified capture flag": function(body) {
+      },
+      */
+      "passes the current data and index to the event listener": function(body) {
+        var forms = body.html("").selectAll("form").data(["a", "b"]).enter().append("form"), dd, ii, data = new Object();
+        forms.on("submit", function(d, i) { dd = d; ii = i; });
+        forms.append("input").attr("type", "submit")[0][1].click();
+        assert.equal(dd, "b");
+        assert.equal(ii, 1);
+        forms[0][1].__data__ = data;
+        forms.append("input").attr("type", "submit")[0][1].click();
+        assert.equal(dd, data);
+        assert.equal(ii, 1);
+      },
+      "uses the current element as the context": function(body) {
+        var forms = body.html("").selectAll("form").data(["a", "b"]).enter().append("form"), context;
+        forms.on("submit", function() { context = this; });
+        forms.append("input").attr("type", "submit")[0][1].click();
+        assert.domEqual(context, forms[0][1]);
+      },
+      "returns the current selection": function(body) {
+        assert.isTrue(body.on("submit", function() {}) === body);
+      },
+      "returns the assigned listener if called with one argument": function(body) {
+        body.on("mouseover", f).on("click.foo", f);
+        function f() {}
+        assert.equal(body.on("mouseover"), f);
+        assert.equal(body.on("click.foo"), f);
+        assert.isUndefined(body.on("click"));
+        assert.isUndefined(body.on("mouseover.foo"));
+      },
+      "omitting the event type": {
+        "returns undefined when retrieving a listener": function(body) {
+          assert.isUndefined(body.on(".foo"));
+        },
+        "null removes all named event listeners": function(body) {
+          body.on("mouseover.foo", f)
+              .on("click.foo", f)
+              .on("click.foobar", f)
+              .on(".foo", null);
+          function f() {}
+          assert.isUndefined(body.on("mouseover.foo"));
+          assert.isUndefined(body.on("click.foo"));
+          assert.equal(body.on("click.foobar"), f);
+        },
+        "no-op when setting a listener": function(body) {
+          assert.isTrue(body.on(".foo", function() {}) === body);
+          assert.isUndefined(body.on(".foo"));
+        }
+      }
+    },
+    "sets the current event as d3.event": function(d3) {
+      var form = d3.select("body").append("form"), event;
+      form.on("submit", function() { event = d3.event; });
+      form.append("input").attr("type", "submit").node().click();
+      assert.equal(event.type, "submit");
+      assert.domEqual(event.target, form[0][0]);
+    },
+    "restores the original event after notifying listeners": function(d3) {
+      var form = d3.select("body").append("form"), event = d3.event = new Object();
+      form.on("submit", function() {});
+      form.append("input").attr("type", "submit").node().click();
+      assert.equal(d3.event, event);
+    }
+  }
+});
+
+suite.export(module);

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

@@ -0,0 +1,32 @@
+var vows = require("vows"),
+    load = require("../load"),
+    assert = require("../assert");
+
+var suite = vows.describe("selection.order");
+
+suite.addBatch({
+  "selectAll(div)": {
+    topic: load("selection/call").document(),
+    "on a simple page": {
+      topic: function(d3) {
+        return d3.select("body").selectAll("div")
+            .data([1, 2, 10, 20])
+          .enter().append("div")
+            .attr("id", String);
+      },
+      "orders elements by data": function(div) {
+        div = div.data([1, 10, 20, 2], String).order();
+        assert.domNull(div[0][0].previousSibling);
+        assert.domEqual(div[0][1].previousSibling, div[0][0]);
+        assert.domEqual(div[0][2].previousSibling, div[0][1]);
+        assert.domEqual(div[0][3].previousSibling, div[0][2]);
+        assert.domNull(div[0][3].nextSibling);
+      },
+      "returns the current selection": function(span) {
+        assert.isTrue(span.order() === span);
+      }
+    }
+  }
+});
+
+suite.export(module);

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

@@ -0,0 +1,118 @@
+var vows = require("vows"),
+    _ = require("../../"),
+    load = require("../load"),
+    assert = require("../assert");
+
+var suite = vows.describe("selection.property");
+
+suite.addBatch({
+  "select(body)": {
+    topic: load("selection/property").document(),
+    "on a simple page": {
+      topic: function(d3) {
+        return d3.select("body");
+      },
+      "sets a property as a string": function(body) {
+        body.property("bgcolor", "red");
+        assert.equal(body.node().bgcolor, "red");
+      },
+      "sets a property as a number": function(body) {
+        body.property("opacity", 1);
+        assert.equal(body.node().opacity, "1");
+      },
+      "sets a property as a function": function(body) {
+        body.property("bgcolor", function() { return "orange"; });
+        assert.equal(body.node().bgcolor, "orange");
+      },
+      "sets properties as a map of constants": function(body) {
+        body.property({bgcolor: "purple", opacity: .41});
+        assert.equal(body.node().bgcolor, "purple");
+        assert.equal(body.node().opacity, .41);
+      },
+      "sets properties as a map of functions": function(body) {
+        body.data(["cyan"]).property({bgcolor: String, opacity: function(d, i) { return i; }});
+        assert.equal(body.node().bgcolor, "cyan");
+        assert.equal(body.node().opacity, 0);
+      },
+      "gets a property value": function(body) {
+        body.node().bgcolor = "yellow";
+        assert.equal(body.property("bgcolor"), "yellow");
+      },
+      "removes a property as null": function(body) {
+        body.property("bgcolor", "yellow").property("bgcolor", null);
+        assert.isFalse("bgcolor" in body.node());
+      },
+      "removes a property as a function": function(body) {
+        body.property("bgcolor", "yellow").property("bgcolor", function() { return null });
+        assert.isFalse("bgcolor" in body.node());
+      },
+      "removes properties as a map of nulls": function(body) {
+        body.node().bgcolor = "red";
+        body.property({bgcolor: null});
+        assert.isFalse("bgcolor" in body.node());
+      },
+      "removes properties as a map of functions that return null": function(body) {
+        body.node().bgcolor = "red";
+        body.property({bgcolor: function() {}});
+        assert.isFalse("bgcolor" in body.node());
+      },
+      "returns the current selection": function(body) {
+        assert.isTrue(body.property("bgcolor", "yellow") === body);
+      }
+    }
+  }
+});
+
+suite.addBatch({
+  "selectAll(div)": {
+    topic: load("selection/property").document(),
+    "on a simple page": {
+      topic: function(d3) {
+        return d3.select("body").html("").selectAll("div").data([0, 1]).enter().append("div");
+      },
+      "sets a property as a string": function(div) {
+        div.property("bgcolor", "red");
+        assert.equal(div[0][0].bgcolor, "red");
+        assert.equal(div[0][1].bgcolor, "red");
+      },
+      "sets a property as a number": function(div) {
+        div.property("opacity", 0.4);
+        assert.strictEqual(div[0][0].opacity, 0.4);
+        assert.strictEqual(div[0][1].opacity, 0.4);
+      },
+      "sets a property as a function": function(div) {
+        var i = _.interpolateRgb("brown", "steelblue");
+        div.property("_color", function(d) { return d3.rgb(i(d)); }); // make a copy
+        assert.rgbEqual(div[0][0]._color, 165, 42, 42);
+        assert.rgbEqual(div[0][1]._color, 70, 130, 180);
+      },
+      "gets a property value": function(div) {
+        div[0][0].bgcolor = "purple";
+        assert.equal(div.property("bgcolor"), "purple");
+      },
+      "removes a property as null": function(div) {
+        div.property("bgcolor", "yellow").property("bgcolor", null);
+        assert.isFalse("bgcolor" in div[0][0]);
+        assert.isFalse("bgcolor" in div[0][1]);
+      },
+      "removes a property as a function": function(div) {
+        div.property("bgcolor", "yellow").property("bgcolor", function() { return null });
+        assert.isFalse("bgcolor" in div[0][0]);
+        assert.isFalse("bgcolor" in div[0][1]);
+      },
+      "returns the current selection": function(div) {
+        assert.isTrue(div.property("bgcolor", "yellow") === div);
+      },
+      "ignores null nodes": function(div) {
+        var node = div[0][1];
+        div.property("bgcolor", null);
+        div[0][1] = null;
+        div.property("bgcolor", "red");
+        assert.equal(div[0][0].bgcolor, "red");
+        assert.isFalse("bgcolor" in node);
+      }
+    }
+  }
+});
+
+suite.export(module);

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

@@ -0,0 +1,38 @@
+var vows = require("vows"),
+    load = require("../load"),
+    assert = require("../assert");
+
+var suite = vows.describe("selection.remove");
+
+suite.addBatch({
+  "select(body)": {
+    topic: load("selection/remove").document(),
+    "removes the matching elements": function(d3) {
+      var div = d3.select("body").append("div");
+      div.remove();
+      assert.domNull(div[0][0].parentNode);
+    },
+    "does not remove non-matching elements": function(d3) {
+      var body = d3.select("body"),
+          div1 = body.append("div"),
+          div2 = body.append("div");
+      div1.remove();
+      assert.domEqual(div2[0][0].parentNode, body.node());
+    },
+    "ignores null nodes": function(d3) {
+      var div1 = d3.select("body").append("div"),
+          div2 = div1.selectAll("div").data([0, 1]).enter().append("div"),
+          node = div2[0][0];
+      div2[0][0] = null;
+      div2.remove();
+      assert.domEqual(node.parentNode, div1.node());
+      assert.domNull(div2[0][1].parentNode);
+    },
+    "returns the current selection": function(d3) {
+      var div = d3.select("body").append("div");
+      assert.isTrue(div.remove() === div);
+    }
+  }
+});
+
+suite.export(module);