stripmem 0.0.1

data/lib/stripmem/public/components/d3/test/dsv/csv-test.js

@@ -0,0 +1,214 @@
+var vows = require("vows"),
+    load = require("../load"),
+    assert = require("../assert");
+
+var suite = vows.describe("d3.csv");
+
+suite.addBatch({
+  "csv": {
+    topic: load("dsv/csv").expression("d3.csv").document(),
+
+    "on a sample file": {
+      topic: function(csv) {
+        csv("test/data/sample.csv", this.callback);
+      },
+      "invokes the callback with the parsed CSV": function(csv) {
+        assert.deepEqual(csv, [{"Hello":"42","World":"\"fish\""}]);
+      },
+      "overrides the mime type to text/csv": function(csv) {
+        assert.equal(XMLHttpRequest._last._info.mimeType, "text/csv");
+      }
+    },
+
+    "when specifying a row conversion function": {
+      topic: function(csv) {
+        csv("test/data/sample.csv", function(row) {
+          row.Hello = -row.Hello;
+          return row;
+        }, this.callback);
+      },
+      "invokes the callback with the parsed CSV": function(csv) {
+        assert.strictEqual(csv[0].Hello, -42);
+      }
+    },
+
+    "when loading a file that does not exist": {
+      topic: function(csv) {
+        var callback = this.callback;
+        csv("//does/not/exist.csv", function(error, csv) {
+          callback(null, csv);
+        });
+      },
+      "invokes the callback with undefined": function(csv) {
+        assert.isUndefined(csv);
+      }
+    },
+
+    "parse": {
+      topic: function(csv) {
+        return csv.parse;
+      },
+      "returns an array of objects": function(parse) {
+        assert.deepEqual(parse("a,b,c\n1,2,3\n"), [{a: "1", b: "2", c: "3"}]);
+      },
+      "does not strip whitespace": function(parse) {
+        assert.deepEqual(parse("a,b,c\n 1, 2,3\n"), [{a: " 1", b: " 2", c: "3"}]);
+      },
+      "parses quoted values": function(parse) {
+        assert.deepEqual(parse("a,b,c\n\"1\",2,3"), [{a: "1", b: "2", c: "3"}]);
+        assert.deepEqual(parse("a,b,c\n\"1\",2,3\n"), [{a: "1", b: "2", c: "3"}]);
+      },
+      "parses quoted values with quotes": function(parse) {
+        assert.deepEqual(parse("a\n\"\"\"hello\"\"\""), [{a: "\"hello\""}]);
+      },
+      "parses quoted values with newlines": function(parse) {
+        assert.deepEqual(parse("a\n\"new\nline\""), [{a: "new\nline"}]);
+        assert.deepEqual(parse("a\n\"new\rline\""), [{a: "new\rline"}]);
+        assert.deepEqual(parse("a\n\"new\r\nline\""), [{a: "new\r\nline"}]);
+      },
+      "parses unix newlines": function(parse) {
+        assert.deepEqual(parse("a,b,c\n1,2,3\n4,5,\"6\"\n7,8,9"), [
+          {a: "1", b: "2", c: "3"},
+          {a: "4", b: "5", c: "6"},
+          {a: "7", b: "8", c: "9"}
+        ]);
+      },
+      "parses mac newlines": function(parse) {
+        assert.deepEqual(parse("a,b,c\r1,2,3\r4,5,\"6\"\r7,8,9"), [
+          {a: "1", b: "2", c: "3"},
+          {a: "4", b: "5", c: "6"},
+          {a: "7", b: "8", c: "9"}
+        ]);
+      },
+      "parses dos newlines": function(parse) {
+        assert.deepEqual(parse("a,b,c\r\n1,2,3\r\n4,5,\"6\"\r\n7,8,9"), [
+          {a: "1", b: "2", c: "3"},
+          {a: "4", b: "5", c: "6"},
+          {a: "7", b: "8", c: "9"}
+        ]);
+      }
+    },
+
+    "parse with row function": {
+      "invokes the row function for every row in order": function(csv) {
+        var rows = [];
+        csv.parse("a\n1\n2\n3\n4", function(d, i) { rows.push({d: d, i: i}); });
+        assert.deepEqual(rows, [
+          {d: {a: "1"}, i: 0},
+          {d: {a: "2"}, i: 1},
+          {d: {a: "3"}, i: 2},
+          {d: {a: "4"}, i: 3}
+        ]);
+      },
+      "returns an array of the row function return values": function(csv) {
+        assert.deepEqual(csv.parse("a,b,c\n1,2,3\n", function(row) { return row; }), [{a: "1", b: "2", c: "3"}]);
+      },
+      "skips rows if the row function returns null or undefined": function(csv) {
+        assert.deepEqual(csv.parse("a,b,c\n1,2,3\n2,3,4", function(row) { return row.a & 1 ? null : row; }), [{a: "2", b: "3", c: "4"}]);
+        assert.deepEqual(csv.parse("a,b,c\n1,2,3\n2,3,4", function(row) { return row.a & 1 ? undefined : row; }), [{a: "2", b: "3", c: "4"}]);
+      }
+    },
+
+    "parseRows": {
+      topic: function(csv) {
+        return csv.parseRows;
+      },
+      "returns an array of arrays": function(parse) {
+        assert.deepEqual(parse("a,b,c\n"), [["a", "b", "c"]]);
+      },
+      "parses quoted values": function(parse) {
+        assert.deepEqual(parse("\"1\",2,3\n"), [["1", "2", "3"]]);
+        assert.deepEqual(parse("\"hello\""), [["hello"]]);
+      },
+      "parses quoted values with quotes": function(parse) {
+        assert.deepEqual(parse("\"\"\"hello\"\"\""), [["\"hello\""]]);
+      },
+      "parses quoted values with newlines": function(parse) {
+        assert.deepEqual(parse("\"new\nline\""), [["new\nline"]]);
+        assert.deepEqual(parse("\"new\rline\""), [["new\rline"]]);
+        assert.deepEqual(parse("\"new\r\nline\""), [["new\r\nline"]]);
+      },
+      "parses unix newlines": function(parse) {
+        assert.deepEqual(parse("a,b,c\n1,2,3\n4,5,\"6\"\n7,8,9"), [
+          ["a", "b", "c"],
+          ["1", "2", "3"],
+          ["4", "5", "6"],
+          ["7", "8", "9"]
+        ]);
+      },
+      "parses mac newlines": function(parse) {
+        assert.deepEqual(parse("a,b,c\r1,2,3\r4,5,\"6\"\r7,8,9"), [
+          ["a", "b", "c"],
+          ["1", "2", "3"],
+          ["4", "5", "6"],
+          ["7", "8", "9"]
+        ]);
+      },
+      "parses dos newlines": function(parse) {
+        assert.deepEqual(parse("a,b,c\r\n1,2,3\r\n4,5,\"6\"\r\n7,8,9"), [
+          ["a", "b", "c"],
+          ["1", "2", "3"],
+          ["4", "5", "6"],
+          ["7", "8", "9"]
+        ]);
+      }
+    },
+
+    "format": {
+      topic: function(csv) {
+        return csv.format;
+      },
+      "takes an array of objects as input": function(format) {
+        assert.equal(format([{a: 1, b: 2, c: 3}]), "a,b,c\n1,2,3");
+      },
+      "escapes field names containing special characters": function(format) {
+        assert.equal(format([{"foo,bar": true}]), "\"foo,bar\"\ntrue");
+      },
+      "computes the union of all fields": function(format) {
+        assert.equal(format([
+          {a: 1},
+          {a: 1, b: 2},
+          {a: 1, b: 2, c: 3},
+          {b: 1, c: 2},
+          {c: 1}
+        ]), "a,b,c\n1,,\n1,2,\n1,2,3\n,1,2\n,,1");
+      },
+      "orders field by first-seen": function(format) {
+        assert.equal(format([
+          {a: 1, b: 2},
+          {c: 3, b: 4},
+          {c: 5, a: 1, b: 2}
+        ]), "a,b,c\n1,2,\n,4,3\n1,2,5");
+      }
+    },
+
+    "formatRows": {
+      topic: function(csv) {
+        return csv.formatRows;
+      },
+      "takes an array of arrays as input": function(format) {
+        assert.equal(format([["a", "b", "c"], ["1", "2", "3"]]), "a,b,c\n1,2,3");
+      },
+      "separates lines using unix newline": function(format) {
+        assert.equal(format([[], []]), "\n");
+      },
+      "does not strip whitespace": function(format) {
+        assert.equal(format([["a ", " b", "c"], ["1", "2", "3 "]]), "a , b,c\n1,2,3 ");
+      },
+      "does not quote simple values": function(format) {
+        assert.equal(format([["a"], [1]]), "a\n1");
+      },
+      "escapes double quotes": function(format) {
+        assert.equal(format([["\"fish\""]]), "\"\"\"fish\"\"\"");
+      },
+      "escapes unix newlines": function(format) {
+        assert.equal(format([["new\nline"]]), "\"new\nline\"");
+      },
+      "escapes commas": function(format) {
+        assert.equal(format([["oxford,comma"]]), "\"oxford,comma\"");
+      }
+    }
+  }
+});
+
+suite.export(module);

data/lib/stripmem/public/components/d3/test/dsv/tsv-test.js

@@ -0,0 +1,185 @@
+var vows = require("vows"),
+    load = require("../load"),
+    assert = require("../assert");
+
+var suite = vows.describe("d3.tsv");
+
+suite.addBatch({
+  "tsv": {
+    topic: load("dsv/tsv").expression("d3.tsv").document(),
+
+    "on a sample file": {
+      topic: function(tsv) {
+        tsv("test/data/sample.tsv", this.callback);
+      },
+      "invokes the callback with the parsed tsv": function(tsv) {
+        assert.deepEqual(tsv, [{"Hello":42,"World":"\"fish\""}]);
+      },
+      "overrides the mime type to text/tab-separated-values": function(tsv) {
+        assert.equal(XMLHttpRequest._last._info.mimeType, "text/tab-separated-values");
+      }
+    },
+
+    "on a file that does not exist": {
+      topic: function(tsv) {
+        var callback = this.callback;
+        tsv("//does/not/exist.tsv", function(error, tsv) {
+          callback(null, tsv);
+        });
+      },
+      "invokes the callback with undefined when an error occurs": function(tsv) {
+        assert.isUndefined(tsv);
+      }
+    },
+
+    "parse": {
+      topic: function(tsv) {
+        return tsv.parse;
+      },
+      "returns an array of objects": function(parse) {
+        assert.deepEqual(parse("a\tb\tc\n1\t2\t3\n"), [{a: "1", b: "2", c: "3"}]);
+      },
+      "does not strip whitespace": function(parse) {
+        assert.deepEqual(parse("a\tb\tc\n 1\t 2\t3\n"), [{a: " 1", b: " 2", c: "3"}]);
+      },
+      "parses quoted values": function(parse) {
+        assert.deepEqual(parse("a\tb\tc\n\"1\"\t2\t3"), [{a: "1", b: "2", c: "3"}]);
+        assert.deepEqual(parse("a\tb\tc\n\"1\"\t2\t3\n"), [{a: "1", b: "2", c: "3"}]);
+      },
+      "parses quoted values with quotes": function(parse) {
+        assert.deepEqual(parse("a\n\"\"\"hello\"\"\""), [{a: "\"hello\""}]);
+      },
+      "parses quoted values with newlines": function(parse) {
+        assert.deepEqual(parse("a\n\"new\nline\""), [{a: "new\nline"}]);
+        assert.deepEqual(parse("a\n\"new\rline\""), [{a: "new\rline"}]);
+        assert.deepEqual(parse("a\n\"new\r\nline\""), [{a: "new\r\nline"}]);
+      },
+      "parses unix newlines": function(parse) {
+        assert.deepEqual(parse("a\tb\tc\n1\t2\t3\n4\t5\t\"6\"\n7\t8\t9"), [
+          {a: "1", b: "2", c: "3"},
+          {a: "4", b: "5", c: "6"},
+          {a: "7", b: "8", c: "9"}
+        ]);
+      },
+      "parses mac newlines": function(parse) {
+        assert.deepEqual(parse("a\tb\tc\r1\t2\t3\r4\t5\t\"6\"\r7\t8\t9"), [
+          {a: "1", b: "2", c: "3"},
+          {a: "4", b: "5", c: "6"},
+          {a: "7", b: "8", c: "9"}
+        ]);
+      },
+      "parses dos newlines": function(parse) {
+        assert.deepEqual(parse("a\tb\tc\r\n1\t2\t3\r\n4\t5\t\"6\"\r\n7\t8\t9"), [
+          {a: "1", b: "2", c: "3"},
+          {a: "4", b: "5", c: "6"},
+          {a: "7", b: "8", c: "9"}
+        ]);
+      }
+    },
+
+    "parseRows": {
+      topic: function(tsv) {
+        return tsv.parseRows;
+      },
+      "returns an array of arrays": function(parse) {
+        assert.deepEqual(parse("a\tb\tc\n"), [["a", "b", "c"]]);
+      },
+      "parses quoted values": function(parse) {
+        assert.deepEqual(parse("\"1\"\t2\t3\n"), [["1", "2", "3"]]);
+        assert.deepEqual(parse("\"hello\""), [["hello"]]);
+      },
+      "parses quoted values with quotes": function(parse) {
+        assert.deepEqual(parse("\"\"\"hello\"\"\""), [["\"hello\""]]);
+      },
+      "parses quoted values with newlines": function(parse) {
+        assert.deepEqual(parse("\"new\nline\""), [["new\nline"]]);
+        assert.deepEqual(parse("\"new\rline\""), [["new\rline"]]);
+        assert.deepEqual(parse("\"new\r\nline\""), [["new\r\nline"]]);
+      },
+      "parses unix newlines": function(parse) {
+        assert.deepEqual(parse("a\tb\tc\n1\t2\t3\n4\t5\t\"6\"\n7\t8\t9"), [
+          ["a", "b", "c"],
+          ["1", "2", "3"],
+          ["4", "5", "6"],
+          ["7", "8", "9"]
+        ]);
+      },
+      "parses mac newlines": function(parse) {
+        assert.deepEqual(parse("a\tb\tc\r1\t2\t3\r4\t5\t\"6\"\r7\t8\t9"), [
+          ["a", "b", "c"],
+          ["1", "2", "3"],
+          ["4", "5", "6"],
+          ["7", "8", "9"]
+        ]);
+      },
+      "parses dos newlines": function(parse) {
+        assert.deepEqual(parse("a\tb\tc\r\n1\t2\t3\r\n4\t5\t\"6\"\r\n7\t8\t9"), [
+          ["a", "b", "c"],
+          ["1", "2", "3"],
+          ["4", "5", "6"],
+          ["7", "8", "9"]
+        ]);
+      }
+    },
+
+    "format": {
+      topic: function(tsv) {
+        return tsv.format;
+      },
+      "takes an array of objects as input": function(format) {
+        assert.equal(format([{a: 1, b: 2, c: 3}]), "a\tb\tc\n1\t2\t3");
+      },
+      "escapes field names containing special characters": function(format) {
+        assert.equal(format([{"foo\tbar": true}]), "\"foo\tbar\"\ntrue");
+      },
+      "computes the union of all fields": function(format) {
+        assert.equal(format([
+          {a: 1},
+          {a: 1, b: 2},
+          {a: 1, b: 2, c: 3},
+          {b: 1, c: 2},
+          {c: 1}
+        ]), "a\tb\tc\n1\t\t\n1\t2\t\n1\t2\t3\n\t1\t2\n\t\t1");
+      },
+      "orders field by first-seen": function(format) {
+        assert.equal(format([
+          {a: 1, b: 2},
+          {c: 3, b: 4},
+          {c: 5, a: 1, b: 2}
+        ]), "a\tb\tc\n1\t2\t\n\t4\t3\n1\t2\t5");
+      }
+    },
+
+    "formatRows": {
+      topic: function(tsv) {
+        return tsv.formatRows;
+      },
+      "takes an array of arrays as input": function(format) {
+        assert.equal(format([["a", "b", "c"], ["1", "2", "3"]]), "a\tb\tc\n1\t2\t3");
+      },
+      "separates lines using unix newline": function(format) {
+        assert.equal(format([[], []]), "\n");
+      },
+      "does not strip whitespace": function(format) {
+        assert.equal(format([["a ", " b", "c"], ["1", "2", "3 "]]), "a \t b\tc\n1\t2\t3 ");
+      },
+      "does not quote simple values": function(format) {
+        assert.equal(format([["a"], [1]]), "a\n1");
+      },
+      "escapes double quotes": function(format) {
+        assert.equal(format([["\"fish\""]]), "\"\"\"fish\"\"\"");
+      },
+      "escapes unix newlines": function(format) {
+        assert.equal(format([["new\nline"]]), "\"new\nline\"");
+      },
+      "escapes tabs": function(format) {
+        assert.equal(format([["oxford\tcomma"]]), "\"oxford\tcomma\"");
+      },
+      "does not escape commas": function(format) {
+        assert.equal(format([["oxford,comma"]]), "oxford,comma");
+      }
+    }
+  }
+});
+
+suite.export(module);

data/lib/stripmem/public/components/d3/test/event/dispatch-test.js

@@ -0,0 +1,163 @@
+var vows = require("vows"),
+    load = require("../load"),
+    assert = require("../assert");
+
+var suite = vows.describe("d3.dispatch");
+
+suite.addBatch({
+  "dispatch": {
+    topic: load("event/dispatch").expression("d3.dispatch"),
+    "returns a map of dispatchers for each event type": function(dispatch) {
+      assert.deepEqual(dispatch(), {});
+      var d = dispatch("foo");
+      assert.isTrue("foo" in d);
+      assert.isFalse("bar" in d);
+      var d = dispatch("foo", "bar");
+      assert.isTrue("foo" in d);
+      assert.isTrue("bar" in d);
+    },
+    "added listeners receive subsequent events": function(dispatch) {
+      var d = dispatch("foo"), events = 0;
+      d.on("foo", function() { ++events; });
+      d.foo();
+      assert.equal(events, 1);
+      d.foo();
+      d.foo();
+      assert.equal(events, 3);
+    },
+    "the listener is passed any arguments to dispatch": function(dispatch) {
+      var d = dispatch("foo"), a = {}, b = {}, aa, bb;
+      d.on("foo", function(a, b) { aa = a; bb = b; });
+      d.foo(a, b);
+      assert.equal(aa, a);
+      assert.equal(bb, b);
+      d.foo(1, "foo");
+      assert.equal(aa, 1);
+      assert.equal(bb, "foo");
+    },
+    "the listener's context is the same as dispatch's": function(dispatch) {
+      var d = dispatch("foo"), a = {}, b = {}, that;
+      d.on("foo", function() { that = this; });
+      d.foo.call(a);
+      assert.equal(that, a);
+      d.foo.call(b);
+      assert.equal(that, b);
+    },
+    "listeners are notified in the order they are added": function(dispatch) {
+      var d = dispatch("foo"), a = {}, b = {}, those = [];
+      function A() { those.push(a); }
+      function B() { those.push(b); }
+      d.on("foo.a", A).on("foo.b", B);
+      d.foo();
+      assert.deepEqual(those, [a, b]);
+      those = [];
+      d.on("foo.a", A); // move to the end
+      d.foo();
+      assert.deepEqual(those, [b, a]);
+    },
+    "notifying listeners returns the dispatch object": function(dispatch) {
+      var d = dispatch("foo");
+      assert.equal(d.foo(), d);
+    },
+    "adding a listener returns the dispatch object": function(dispatch) {
+      var d = dispatch("foo");
+      function A() {}
+      assert.equal(d.on("foo", A), d);
+    },
+    "removed listeners do not receive subsequent events": function(dispatch) {
+      var d = dispatch("foo"), a = {}, b = {}, those = [];
+      function A() { those.push(a); }
+      function B() { those.push(b); }
+      d.on("foo.a", A).on("foo.b", B);
+      d.foo();
+      those = [];
+      d.on("foo.a", null);
+      d.foo();
+      assert.deepEqual(those, [b]);
+    },
+    "removing a shared listener only affects the intended event": function(dispatch) {
+      var d = dispatch("foo", "bar"), a = 0;
+      function A() { ++a; }
+      d.on("foo", A).on("bar", A);
+      d.foo();
+      d.bar();
+      assert.equal(a, 2);
+      d.on("foo", null);
+      d.bar();
+      assert.equal(a, 3);
+    },
+    "adding an existing listener has no effect": function(dispatch) {
+      var d = dispatch("foo"), events = 0;
+      function A() { ++events; }
+      d.on("foo.a", A);
+      d.foo();
+      d.on("foo.a", A).on("foo.a", A);
+      d.foo();
+      assert.equal(events, 2);
+    },
+    "removing a missing listener has no effect": function(dispatch) {
+      var d = dispatch("foo"), events = 0;
+      function A() { ++events; }
+      d.on("foo.a", null).on("foo", A).on("foo", null).on("foo", null);
+      d.foo();
+      assert.equal(events, 0);
+    },
+    "adding a listener does not affect the current event": function(dispatch) {
+      var d = dispatch("foo"), a = {}, b = {}, those = [];
+      function A() { d.on("foo.b", B); those.push(a); }
+      function B() { those.push(b); }
+      d.on("foo.a", A);
+      d.foo();
+      assert.deepEqual(those, [a]);
+    },
+    "removing a listener does affect the current event": function(dispatch) {
+      var d = dispatch("foo"), a = {}, b = {}, those = [];
+      function A() { d.on("foo.b", null); those.push(a); }
+      function B() { those.push(b); }
+      d.on("foo.a", A).on("foo.b", B);
+      d.foo();
+      assert.deepEqual(those, [a]);
+    },
+    "getting a listener returns the correct listener": function(dispatch) {
+      var d = dispatch("foo");
+      function A() {}
+      function B() {}
+      function C() {}
+      d.on("foo.a", A).on("foo.b", B).on("foo", C);
+      assert.equal(d.on("foo.a"), A);
+      assert.equal(d.on("foo.b"), B);
+      assert.equal(d.on("foo"), C);
+    },
+    "omitting the event type": {
+      "returns undefined when retrieving a listener": function(dispatch) {
+        var d = dispatch("foo");
+        assert.isUndefined(d.on(".a"));
+      },
+      "null removes all named event listeners": function(dispatch) {
+        var d = dispatch("foo", "bar"), a = {}, b = {}, c = {}, those = [];
+        function A() { those.push(a); }
+        function B() { those.push(b); }
+        function C() { those.push(c); }
+        d.on("foo.a", A).on("bar.a", B).on("foo", C).on(".a", null);
+        d.foo();
+        d.bar();
+        assert.deepEqual(those, [c]);
+      },
+      "no-op when setting a listener": function(dispatch) {
+        var d = dispatch("foo", "bar"), a = {}, b = {}, those = [];
+        function A() { those.push(a); }
+        function B() { those.push(b); }
+        d
+            .on(".a", A)
+            .on("foo.a", B)
+            .on("bar", B);
+        d.foo();
+        d.bar();
+        assert.deepEqual(those, [b, b]);
+        assert.isUndefined(d.on(".a"));
+      }
+    }
+  }
+});
+
+suite.export(module);

data/lib/stripmem/public/components/d3/test/event/mouse-test.html

@@ -0,0 +1,22 @@
+<!DOCTYPE html>
+<meta charset="utf-8">
+<title>HTML Mouse Test</title>
+<body>
+<script src="../../d3.js"></script>
+<script>
+
+var body = d3.select("body");
+
+var div = body.append("div")
+    .style("width", "1000px")
+    .style("height", "500px")
+    .style("border", "solid black 1px")
+    .style("cursor", "crosshair");
+
+var span = body.append("span");
+
+d3.select(window).on("mousemove", function() {
+  span.text(d3.mouse(div[0][0]));
+});
+
+</script>

data/lib/stripmem/public/components/d3/test/event/timer-test.js

@@ -0,0 +1,74 @@
+var vows = require("vows"),
+    load = require("../load"),
+    assert = require("../assert");
+
+var suite = vows.describe("d3.timer");
+
+suite.addBatch({
+  "timer": {
+    topic: load("event/timer").expression("d3.timer").document(),
+
+    "with no delay": {
+      topic: delay(),
+      "first calls after 17 ms or less": function(info) {
+        assert.inDelta(info.start - info.scheduled, 17, 20);
+      },
+      "calls until the function returns true": function(info) {
+        assert.equal(info.count, 4);
+      },
+      "calls every 17 ms": function(info) {
+        assert.inDelta(info.stop - info.start, 17 * 3, 20);
+      }
+    },
+
+    "with a specified delay": {
+      topic: delay(250),
+      "first calls after the delay": function(info) {
+        assert.inDelta(info.start - info.scheduled, 250, 20);
+      },
+      "calls until the function returns true": function(info) {
+        assert.equal(info.count, 4);
+      },
+      "calls every 17 ms": function(info) {
+        assert.inDelta(info.stop - info.start, 17 * 3, 20);
+      }
+    },
+
+    "with multiple registered tasks": {
+      topic: function(timer) {
+        var callback = this.callback,
+            results = [];
+        timer(function() { results.push("A"); return true; });
+        timer(function() { results.push("B"); return true; });
+        timer(function() { results.push("C"); return true; });
+        timer(function() { callback(null, results); return true; })
+      },
+      "invokes tasks in the order they were registered": function(results) {
+        assert.deepEqual(results, ["A", "B", "C"]);
+      }
+    }
+  }
+});
+
+function delay(delay) {
+  var args = Array.prototype.slice.call(arguments);
+  return function(timer) {
+    var cb = this.callback,
+        info = {scheduled: Date.now(), count: 0};
+
+    args.unshift(function() {
+      var count = ++info.count;
+      if (count === 1) {
+        info.start = Date.now();
+      } else if (count === 4) {
+        info.stop = Date.now();
+        cb(null, info);
+        return true;
+      }
+    });
+
+    timer.apply(this, args);
+  };
+}
+
+suite.export(module);