stripmem 0.0.1

data/lib/stripmem/public/components/d3/test/time/years-test.js

@@ -0,0 +1,74 @@
+var vows = require("vows"),
+    load = require("../load"),
+    assert = require("../assert");
+
+var suite = vows.describe("d3.time.years");
+
+suite.addBatch({
+  "years": {
+    topic: load("time/year").expression("d3.time.years"),
+    "returns years": function(range) {
+      assert.deepEqual(range(local(2010, 0, 1), local(2013, 0, 1)), [
+        local(2010, 0, 1),
+        local(2011, 0, 1),
+        local(2012, 0, 1)
+      ]);
+    },
+    "has an inclusive lower bound": function(range) {
+      assert.deepEqual(range(local(2010, 0, 1), local(2013, 0, 1))[0], local(2010, 0, 1));
+    },
+    "has an exclusive upper bound": function(range) {
+      assert.deepEqual(range(local(2010, 0, 1), local(2013, 0, 1))[2], local(2012, 0, 1));
+    },
+    "can skip years": function(range) {
+      assert.deepEqual(range(local(2009, 0, 1), local(2029, 0, 1), 5), [
+        local(2010, 0, 1),
+        local(2015, 0, 1),
+        local(2020, 0, 1),
+        local(2025, 0, 1)
+      ]);
+    },
+    "UTC": {
+      topic: function(range) {
+        return range.utc;
+      },
+      "returns years": function(range) {
+        assert.deepEqual(range(utc(2010, 0, 1), utc(2013, 0, 1)), [
+          utc(2010, 0, 1),
+          utc(2011, 0, 1),
+          utc(2012, 0, 1)
+        ]);
+      },
+      "has an inclusive lower bound": function(range) {
+        assert.deepEqual(range(utc(2010, 0, 1), utc(2013, 0, 1))[0], utc(2010, 0, 1));
+      },
+      "has an exclusive upper bound": function(range) {
+        assert.deepEqual(range(utc(2010, 0, 1), utc(2013, 0, 1))[2], utc(2012, 0, 1));
+      },
+      "can skip years": function(range) {
+        assert.deepEqual(range(utc(2009, 0, 1), utc(2029, 0, 1), 5), [
+          utc(2010, 0, 1),
+          utc(2015, 0, 1),
+          utc(2020, 0, 1),
+          utc(2025, 0, 1)
+        ]);
+      }
+    }
+  }
+});
+
+function local(year, month, day, hours, minutes, seconds, milliseconds) {
+  var date = new Date();
+  date.setFullYear(year, month, day);
+  date.setHours(hours || 0, minutes || 0, seconds || 0, milliseconds || 0);
+  return date;
+}
+
+function utc(year, month, day, hours, minutes, seconds, milliseconds) {
+  var date = new Date();
+  date.setUTCFullYear(year, month, day);
+  date.setUTCHours(hours || 0, minutes || 0, seconds || 0, milliseconds || 0);
+  return date;
+}
+
+suite.export(module);

data/lib/stripmem/public/components/d3/test/transition/transition-test-attr.js

@@ -0,0 +1,56 @@
+var assert = require("../assert");
+
+module.exports = {
+  topic: function(d3) {
+    var s = d3.select("body").append("div")
+        .attr("display", "none")
+        .attr("font-size", "20px")
+        .attr("width", 20)
+        .attr("color", "red")
+        .attr("xlink:type", "simple")
+        .attr("xlink:href", "http://mbostock.github.com/d3/");
+
+    var t = s.transition()
+        .attr("display", null)
+        .attr("font-size", function() { return null; })
+        .attr("display", null)
+        .attr("width", 100)
+        .attr("width", 200)
+        .attr("color", function() { return "green"; })
+        .attr("xlink:href", null)
+        .attr("xlink:type", function() { return null; });
+
+    return {selection: s, transition: t};
+  },
+  "defines the corresponding attr tween": function(result) {
+    assert.typeOf(result.transition.tween("attr.width"), "function");
+    assert.typeOf(result.transition.tween("attr.color"), "function");
+  },
+  "on end": {
+    topic: function(result) {
+      var cb = this.callback;
+      result.transition.each("end", function() { cb(null, result); });
+    },
+    "the last attr operator takes precedence": function(result) {
+      assert.equal(result.selection.attr("width"), "200");
+    },
+    "sets an attribute as a number": function(result) {
+      assert.equal(result.selection.attr("width"), "200");
+    },
+    "sets an attribute as a function": function(result) {
+      assert.equal(result.selection.attr("color"), "#008000");
+    },
+    "removes an attribute using a constant null": function(result) {
+      assert.isNull(result.selection.attr("display"));
+    },
+    "removes an attribute using a function null": function(result) {
+      assert.isNull(result.selection.attr("font-size"));
+    },
+    "removes a namespaced attribute using a constant null": function(result) {
+      assert.isNull(result.selection.attr("xlink:href"));
+    },
+    "removes a namespaced attribute using a function null": function(result) {
+      assert.isNull(result.selection.attr("xlink:type"));
+    }
+  }
+};

data/lib/stripmem/public/components/d3/test/transition/transition-test-attrTween.js

@@ -0,0 +1,59 @@
+var assert = require("../assert"),
+    _ = require("../../");
+
+module.exports = {
+  topic: function(d3) {
+    var callback = this.callback,
+        dd = [],
+        ii = [],
+        tt = [],
+        vv = [];
+
+    var s = d3.select("body").html("").append("div").selectAll("div")
+        .data(["red", "green"])
+      .enter().append("div")
+        .attr("color", function(d, i) { return i ? "#008000" : "#ff0000"; });
+
+    var t = s.transition()
+        .attrTween("color", tween);
+
+    function tween(d, i, v) {
+      dd.push(d);
+      ii.push(i);
+      vv.push(v);
+      if (tt.push(this) >= 2) callback(null, {
+        selection: s,
+        transition: t,
+        data: dd,
+        index: ii,
+        value: vv,
+        context: tt
+      });
+      return i && _.interpolateHsl(v, "blue");
+    }
+  },
+
+  "defines the corresponding attr tween": function(result) {
+    assert.typeOf(result.transition.tween("attr.color"), "function");
+  },
+  "invokes the tween function": function(result) {
+    assert.deepEqual(result.data, ["red", "green"], "expected data, got {actual}");
+    assert.deepEqual(result.index, [0, 1], "expected data, got {actual}");
+    assert.deepEqual(result.value, ["#ff0000", "#008000"], "expected value, got {actual}");
+    assert.domEqual(result.context[0], result.selection[0][0], "expected this, got {actual}");
+    assert.domEqual(result.context[1], result.selection[0][1], "expected this, got {actual}");
+  },
+
+  "end": {
+    topic: function(result) {
+      var callback = this.callback;
+      result.transition.each("end", function(d, i) { if (i >= 1) callback(null, result); });
+    },
+    "uses the returned interpolator": function(result) {
+      assert.equal(result.selection[0][1].getAttribute("color"), "#0000ff");
+    },
+    "does nothing if the interpolator is falsey": function(result) {
+      assert.equal(result.selection[0][0].getAttribute("color"), "#ff0000");
+    }
+  }
+};

data/lib/stripmem/public/components/d3/test/transition/transition-test-call.js

@@ -0,0 +1,30 @@
+var assert = require("../assert");
+
+module.exports = {
+  topic: function(d3) {
+    return d3.select("body").append("div").transition();
+  },
+  "calls the function once": function(transition) {
+    var count = 0;
+    transition.call(function() { ++count; });
+    assert.equal(count, 1);
+  },
+  "passes any optional arguments": function(transition) {
+    var abc;
+    transition.call(function(selection, a, b, c) { abc = [a, b, c]; }, "a", "b", "c");
+    assert.deepEqual(abc, ["a", "b", "c"]);
+  },
+  "passes the transition as the first argument": function(transition) {
+    var t;
+    transition.call(function(x) { t = x; });
+    assert.isTrue(t === transition);
+  },
+  "uses the transition as the context": function(transition) {
+    var t;
+    transition.call(function() { t = this; });
+    assert.isTrue(t === transition);
+  },
+  "returns the current transition": function(transition) {
+    assert.isTrue(transition.call(function() {}) === transition);
+  }
+};

data/lib/stripmem/public/components/d3/test/transition/transition-test-delay.js

@@ -0,0 +1,56 @@
+var assert = require("../assert");
+
+module.exports = {
+  topic: function(d3) {
+    return d3.select("body").html("").selectAll()
+        .data(["foo", "bar"])
+      .enter().append("div")
+        .attr("class", String);
+  },
+  "defaults to zero": function(selection) {
+    var t = selection.transition();
+    assert.strictEqual(t[0][0].__transition__[t.id].delay, 0);
+    assert.strictEqual(t[0][1].__transition__[t.id].delay, 0);
+  },
+  "can specify delay as a number": function(selection) {
+    var t = selection.transition().delay(150);
+    assert.strictEqual(t[0][0].__transition__[t.id].delay, 150);
+    assert.strictEqual(t[0][1].__transition__[t.id].delay, 150);
+    t.delay(250);
+    assert.strictEqual(t[0][0].__transition__[t.id].delay, 250);
+    assert.strictEqual(t[0][1].__transition__[t.id].delay, 250);
+  },
+  "can specify delay as a negative number": function(selection) {
+    var t = selection.transition().delay(-250);
+    assert.strictEqual(t[0][0].__transition__[t.id].delay, -250);
+    assert.strictEqual(t[0][1].__transition__[t.id].delay, -250);
+  },
+  "NaN delays are treated as 0ms": function(selection) {
+    var t = selection.transition().delay(NaN);
+    assert.strictEqual(t[0][0].__transition__[t.id].delay, 0);
+    assert.strictEqual(t[0][1].__transition__[t.id].delay, 0);
+  },
+  "floating-point durations are floored to integers": function(selection) {
+    var t = selection.transition().delay(14.6);
+    assert.strictEqual(t[0][0].__transition__[t.id].delay, 14);
+    assert.strictEqual(t[0][1].__transition__[t.id].delay, 14);
+    var t = selection.transition().delay("16.99");
+    assert.strictEqual(t[0][0].__transition__[t.id].delay, 16);
+    assert.strictEqual(t[0][1].__transition__[t.id].delay, 16);
+  },
+  "can specify delay as a function": function(selection) {
+    var dd = [], ii = [], tt = [], t = selection.transition().delay(f);
+    function f(d, i) { dd.push(d); ii.push(i); tt.push(this); return i * 20; }
+    assert.strictEqual(t[0][0].__transition__[t.id].delay, 0);
+    assert.strictEqual(t[0][1].__transition__[t.id].delay, 20);
+    assert.deepEqual(dd, ["foo", "bar"], "expected data, got {actual}");
+    assert.deepEqual(ii, [0, 1], "expected index, got {actual}");
+    assert.domEqual(tt[0], t[0][0], "expected this, got {actual}");
+    assert.domEqual(tt[1], t[0][1], "expected this, got {actual}");
+  },
+  "coerces delay to a number": function(selection) {
+    var t = selection.transition().delay("150");
+    assert.strictEqual(t[0][0].__transition__[t.id].delay, 150);
+    assert.strictEqual(t[0][1].__transition__[t.id].delay, 150);
+  }
+};

data/lib/stripmem/public/components/d3/test/transition/transition-test-duration.js

@@ -0,0 +1,60 @@
+var assert = require("../assert");
+
+module.exports = {
+  topic: function(d3) {
+    return d3.select("body").html("").selectAll()
+        .data(["foo", "bar"])
+      .enter().append("div")
+        .attr("class", String);
+  },
+  "defaults to 250 milliseconds": function(selection) {
+    var t = selection.transition();
+    assert.strictEqual(t[0][0].__transition__[t.id].duration, 250);
+    assert.strictEqual(t[0][1].__transition__[t.id].duration, 250);
+  },
+  "can specify duration as a number": function(selection) {
+    var t = selection.transition().duration(150);
+    assert.strictEqual(t[0][0].__transition__[t.id].duration, 150);
+    assert.strictEqual(t[0][1].__transition__[t.id].duration, 150);
+    t.duration(50);
+    assert.strictEqual(t[0][0].__transition__[t.id].duration, 50);
+    assert.strictEqual(t[0][1].__transition__[t.id].duration, 50);
+  },
+  "NaN, zero, or negative durations are treated as 1ms": function(selection) {
+    var t = selection.transition().duration(NaN);
+    assert.strictEqual(t[0][0].__transition__[t.id].duration, 1);
+    assert.strictEqual(t[0][1].__transition__[t.id].duration, 1);
+    t.duration(0);
+    assert.strictEqual(t[0][0].__transition__[t.id].duration, 1);
+    assert.strictEqual(t[0][1].__transition__[t.id].duration, 1);
+    t.duration(-10);
+    assert.strictEqual(t[0][0].__transition__[t.id].duration, 1);
+    assert.strictEqual(t[0][1].__transition__[t.id].duration, 1);
+    t.duration(-Infinity);
+    assert.strictEqual(t[0][0].__transition__[t.id].duration, 1);
+    assert.strictEqual(t[0][1].__transition__[t.id].duration, 1);
+  },
+  "floating-point durations are floored to integers": function(selection) {
+    var t = selection.transition().duration(14.6);
+    assert.strictEqual(t[0][0].__transition__[t.id].duration, 14);
+    assert.strictEqual(t[0][1].__transition__[t.id].duration, 14);
+    var t = selection.transition().duration("16.99");
+    assert.strictEqual(t[0][0].__transition__[t.id].duration, 16);
+    assert.strictEqual(t[0][1].__transition__[t.id].duration, 16);
+  },
+  "can specify duration as a function": function(selection) {
+    var dd = [], ii = [], tt = [], t = selection.transition().duration(f);
+    function f(d, i) { dd.push(d); ii.push(i); tt.push(this); return i * 20 + 10; }
+    assert.strictEqual(t[0][0].__transition__[t.id].duration, 10);
+    assert.strictEqual(t[0][1].__transition__[t.id].duration, 30);
+    assert.deepEqual(dd, ["foo", "bar"], "expected data, got {actual}");
+    assert.deepEqual(ii, [0, 1], "expected index, got {actual}");
+    assert.domEqual(tt[0], t[0][0], "expected this, got {actual}");
+    assert.domEqual(tt[1], t[0][1], "expected this, got {actual}");
+  },
+  "coerces duration to a number": function(selection) {
+    var t = selection.transition().duration("150");
+    assert.strictEqual(t[0][0].__transition__[t.id].duration, 150);
+    assert.strictEqual(t[0][1].__transition__[t.id].duration, 150);
+  }
+};

data/lib/stripmem/public/components/d3/test/transition/transition-test-each.js

@@ -0,0 +1,163 @@
+var assert = require("../assert");
+
+module.exports = {
+  "start": {
+    topic: function(d3) {
+      var cb = this.callback,
+          div = d3.select("body").html("").selectAll().data(["foo", "bar"]).enter().append("div").attr("class", String),
+          transition = div.transition().delay(350),
+          then = Date.now(),
+          n = 0,
+          calls = [],
+          context = [],
+          data = [],
+          index = [],
+          count = [],
+          delay = [];
+
+      // A callback to verify that multiple callbacks are allowed.
+      transition.each("start.other", function() {
+        ++n;
+      });
+
+      // A callback which captures arguments and context.
+      transition.each("start", function(d, i) {
+        context.push(this);
+        data.push(d);
+        index.push(i);
+        count.push(++n);
+        delay.push(Date.now() - then);
+        if (n >= 4) cb(null, {
+          selection: div,
+          delay: delay,
+          context: context,
+          data: data,
+          index: index,
+          count: count,
+          id: transition.id
+        });
+      });
+    },
+
+    "invokes the listener after the specified delay": function(result) {
+      assert.inDelta(result.delay, [350, 350], 20);
+    },
+    "invokes each listener exactly once, in order": function(result) {
+      assert.deepEqual(result.count, [2, 4]);
+    },
+
+    // For the same node, listeners will be called back in order, according to
+    // the implementation of d3.dispatch. However, the order of callbacks across
+    // nodes is not guaranteed; currently, callbacks are in reverse order if
+    // they share the same delay, because of the timer queue. I suppose it'd be
+    // slightly better if the callbacks were invoked in node order (consistent
+    // with selections), but since these callbacks happen asynchronously I don't
+    // think the API needs to guarantee the order of callbacks.
+
+    "uses the node as the context": function(result) {
+      assert.domEqual(result.context[0], result.selection[0][0]);
+      assert.domEqual(result.context[1], result.selection[0][1]);
+    },
+    "passes the data and index to the function": function(result) {
+      assert.deepEqual(result.data, ["foo", "bar"], "expected data, got {actual}");
+      assert.deepEqual(result.index, [0, 1], "expected index, got {actual}");
+    },
+
+    "sets an exclusive lock on transitioning nodes": function(result) {
+      var id = result.id;
+      assert.isTrue(id > 0);
+      assert.equal(result.selection[0][0].__transition__.count, 1);
+      assert.equal(result.selection[0][1].__transition__.count, 1);
+      assert.equal(result.selection[0][0].__transition__.active, id);
+      assert.equal(result.selection[0][1].__transition__.active, id);
+    }
+  },
+
+  "end": {
+    topic: function(d3) {
+      var cb = this.callback,
+          div = d3.select("body").html("").selectAll().data(["foo", "bar"]).enter().append("div").attr("class", String),
+          transition = div.transition().duration(350),
+          then = Date.now(),
+          n = 0,
+          calls = [],
+          context = [],
+          data = [],
+          index = [],
+          count = [],
+          delay = [];
+
+      // A callback to verify that multiple callbacks are allowed.
+      transition.each("end.other", function() {
+        ++n;
+      });
+
+      // A callback which captures arguments and context.
+      transition.each("end", function(d, i) {
+        context.push(this);
+        data.push(d);
+        index.push(i);
+        count.push(++n);
+        delay.push(Date.now() - then);
+        if (n >= 4) cb(null, {
+          selection: div,
+          delay: delay,
+          context: context,
+          data: data,
+          index: index,
+          count: count,
+          id: transition.id
+        });
+      });
+    },
+
+    "invokes the listener after the specified delay": function(result) {
+      assert.inDelta(result.delay, [350, 350], 20);
+    },
+    "invokes each listener exactly once, in order": function(result) {
+      assert.deepEqual(result.count, [2, 4]);
+    },
+
+    // For the same node, listeners will be called back in order, according to
+    // the implementation of d3.dispatch. However, the order of callbacks across
+    // nodes is not guaranteed; currently, callbacks are in reverse order if
+    // they share the same delay, because of the timer queue. I suppose it'd be
+    // slightly better if the callbacks were invoked in node order (consistent
+    // with selections), but since these callbacks happen asynchronously I don't
+    // think the API needs to guarantee the order of callbacks.
+
+    "uses the node as the context": function(result) {
+      assert.domEqual(result.context[0], result.selection[0][0]);
+      assert.domEqual(result.context[1], result.selection[0][1]);
+    },
+    "passes the data and index to the function": function(result) {
+      assert.deepEqual(result.data, ["foo", "bar"], "expected data, got {actual}");
+      assert.deepEqual(result.index, [0, 1], "expected index, got {actual}");
+    },
+
+    "deletes the transition lock after end": function(result) {
+      assert.isFalse("__transition__" in result.selection[0][0]);
+      assert.isFalse("__transition__" in result.selection[0][1]);
+    },
+
+    // I'd like to test d3.timer.flush here, but unfortunately there's a bug in
+    // Vows where it really doesn't like to receive multiple callbacks from
+    // different tests at the same time!
+
+    "sequenced": {
+      topic: function(result, d3) {
+        var cb = this.callback,
+            node = result.selection[0][0],
+            id = result.id;
+        d3.select(node).transition().delay(150).each("start", function() {
+          cb(null, {id: id, node: this});
+        });
+      },
+      "does not inherit the transition id": function(result) {
+        assert.isTrue(result.id > 0);
+        assert.equal(result.node.__transition__.count, 1);
+        assert.isTrue(result.node.__transition__.active > result.id);
+      }
+    }
+  }
+};

data/lib/stripmem/public/components/d3/test/transition/transition-test-filter.js

@@ -0,0 +1,84 @@
+var assert = require("../assert"),
+    _ = require("../../");
+
+var datum = {};
+
+module.exports = {
+  topic: function(d3) {
+    return d3.select("body").html("").selectAll("div")
+        .data([0, 1])
+      .enter().append("div")
+      .selectAll("span")
+        .data(function(d) { d <<= 1; return [d, d + 1]; })
+      .enter().append("span")
+        .classed("foo", function(d, i) { return d & 1; })
+      .transition()
+        .delay(100)
+        .duration(150)
+        .ease("bounce");
+  },
+
+  "preserves matching elements": function(span) {
+    var some = span.filter(function(d, i) { return i === 0; });
+    assert.isTrue(some[0][0] === span[0][0]);
+    assert.isTrue(some[1][0] === span[1][0]);
+  },
+  "removes non-matching elements": function(span) {
+    var some = _.merge(span.filter(function(d, i) { return d & 1; }));
+    assert.equal(some.indexOf(span[0][0]), -1);
+    assert.equal(some.indexOf(span[1][0]), -1);
+  },
+  "preserves data": function(span) {
+    var some = span.filter(function(d, i) { return d & 1; });
+    assert.equal(some[0][0].__data__, 1);
+    assert.equal(some[1][0].__data__, 3);
+  },
+  "preserves grouping": function(span) {
+    var some = span.filter(function(d, i) { return d & 1; });
+    assert.equal(some.length, 2);
+    assert.equal(some[0].length, 1);
+    assert.equal(some[1].length, 1);
+  },
+  "preserves parent node": function(span) {
+    var some = span.filter(function(d, i) { return d & 1; });
+    assert.isTrue(some[0].parentNode === span[0].parentNode);
+    assert.isTrue(some[1].parentNode === span[1].parentNode);
+  },
+  "does not preserve index": function(span) {
+    var indexes = [];
+    span.filter(function(d, i) { return d & 1; }).each(function(d, i) { indexes.push(i); });
+    assert.deepEqual(indexes, [0, 0]);
+  },
+  "ignores null nodes": function(span) {
+    var node = span[0][1];
+    span[0][1] = null;
+    var some = span.filter(function(d, i) { return d & 1; });
+    assert.isTrue(some[0][0] === span[0][3]);
+    assert.equal(some.length, 2);
+    span[0][1] = node;
+  },
+  "can be specified as a selector": function(span) {
+    var some = span.filter(".foo");
+    assert.equal(some.length, 2);
+    assert.equal(some[0].length, 1);
+    assert.equal(some[1].length, 1);
+  },
+  "returns a new selection": function(span) {
+    assert.isFalse(span.filter(function() { return 1; }) === span);
+  },
+  "inherits the delay": function(t1) {
+    var t2 = t1.filter(function() { return 1; });
+    assert.equal(t2[0][0].__transition__[t2.id].delay, 100); // TODO should inherit the whole transition object
+  },
+  "inherits the duration": function(t1) {
+    var t2 = t1.filter(function() { return 1; });
+    assert.equal(t2[0][0].__transition__[t2.id].duration, 150);
+  },
+  "inherits easing": function(t1) {
+    // TODO how to test this?
+  },
+  "inherits the transition id": function(t1) {
+    var t2 = t1.filter(function() { return 1; });
+    assert.equal(t2.id, t1.id);
+  }
+};

data/lib/stripmem/public/components/d3/test/transition/transition-test-id.js

@@ -0,0 +1,22 @@
+var assert = require("../assert");
+
+module.exports = {
+  topic: function(d3) {
+    return d3; // bug in vows where topic is not propagated automatically
+  },
+  "on a new transition": {
+    topic: function(d3) {
+      return d3.select("body").append("div").transition();
+    },
+    "has a positive integer id": function(transition) {
+      var id = transition.id;
+      assert.isTrue(id > 0);
+      assert.equal(~~id, id);
+    }
+  },
+  "increases monotonically across transitions": function(d3) {
+    var t0 = d3.select("body").append("div").transition(),
+        t1 = d3.select("body").append("div").transition();
+    assert.isTrue(t1.id > t0.id);
+  }
+};

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

@@ -0,0 +1,39 @@
+var assert = require("../assert");
+
+module.exports = {
+  "with a single element selected": {
+    topic: function(d3) {
+      return d3.select("body").transition();
+    },
+    "returns null for empty subselections": function(body) {
+      assert.isNull(body.select("foo").node());
+    },
+    "returns the selected element": function(body) {
+      assert.equal(body.node().tagName, "BODY");
+    },
+    "returns null if no elements are slected": function(body) {
+      body[0][0] = null;
+      assert.isNull(body.node());
+    }
+  },
+  "with multiple elements selected": {
+    topic: function(d3) {
+      var body = d3.select("body").html(null);
+      body.append("div").attr("class", "first").append("span");
+      body.append("div").attr("class", "second");
+      return body.selectAll("div").transition();
+    },
+    "returns null for empty subselections": function(div) {
+      assert.isNull(div.select("foo").node());
+    },
+    "returns the first selected element": function(div) {
+      assert.equal(div.node().className, "first");
+      assert.equal(div.node().tagName, "DIV");
+    },
+    "does not count null nodes": function(div) {
+      div[0][0] = null;
+      assert.equal(div.node().className, "second");
+      assert.equal(div.node().tagName, "DIV");
+    }
+  }
+};