stripmem 0.0.1

data/lib/stripmem/public/components/d3/test/arrays/map-test.js

@@ -0,0 +1,214 @@
+var vows = require("vows"),
+    load = require("../load"),
+    assert = require("../assert");
+
+var suite = vows.describe("d3.map");
+
+suite.addBatch({
+  "map": {
+    topic: load("arrays/map").expression("d3.map"),
+    "constructor": {
+      "map() returns an empty map": function(map) {
+        var m = map();
+        assert.deepEqual(m.keys(), []);
+      },
+      "map(null) returns an empty map": function(map) {
+        var m = map(null);
+        assert.deepEqual(m.keys(), []);
+      },
+      "map(object) copies enumerable keys": function(map) {
+        var m = map({foo: 42});
+        assert.isTrue(m.has("foo"));
+        assert.equal(m.get("foo"), 42);
+        var m = map(Object.create(null, {foo: {value: 42, enumerable: true}}));
+        assert.isTrue(m.has("foo"));
+        assert.equal(m.get("foo"), 42);
+      },
+      "map(object) copies inherited keys": function(map) {
+        function Foo() {}
+        Foo.prototype.foo = 42;
+        var m = map(Object.create({foo: 42}));
+        assert.isTrue(m.has("foo"));
+        assert.equal(m.get("foo"), 42);
+        var m = map(new Foo());
+        assert.isTrue(m.has("foo"));
+        assert.equal(m.get("foo"), 42);
+      },
+      "map(object) does not copy non-enumerable keys": function(map) {
+        var m = map({__proto__: 42}); // because __proto__ isn't enumerable
+        assert.isFalse(m.has("__proto__"));
+        assert.isUndefined(m.get("__proto__"));
+        var m = map(Object.create(null, {foo: {value: 42, enumerable: false}}));
+        assert.isFalse(m.has("foo"));
+        assert.isUndefined(m.get("foo"));
+      }
+    },
+    "forEach": {
+      "empty maps have an empty keys array": function(map) {
+        var m = map();
+        assert.deepEqual(m.entries(), []);
+        m.set("foo", "bar");
+        assert.deepEqual(m.entries(), [{key: "foo", value: "bar"}]);
+        m.remove("foo");
+        assert.deepEqual(m.entries(), []);
+      },
+      "keys are returned in arbitrary order": function(map) {
+        var m = map({foo: 1, bar: "42"});
+        assert.deepEqual(m.entries().sort(ascendingByKey), [{key: "bar", value: "42"}, {key: "foo", value: 1}]);
+        var m = map({bar: "42", foo: 1});
+        assert.deepEqual(m.entries().sort(ascendingByKey), [{key: "bar", value: "42"}, {key: "foo", value: 1}]);
+      },
+      "observes changes via set and remove": function(map) {
+        var m = map({foo: 1, bar: "42"});
+        assert.deepEqual(m.entries().sort(ascendingByKey), [{key: "bar", value: "42"}, {key: "foo", value: 1}]);
+        m.remove("foo");
+        assert.deepEqual(m.entries(), [{key: "bar", value: "42"}]);
+        m.set("bar", "bar");
+        assert.deepEqual(m.entries(), [{key: "bar", value: "bar"}]);
+        m.set("foo", "foo");
+        assert.deepEqual(m.entries().sort(ascendingByKey), [{key: "bar", value: "bar"}, {key: "foo", value: "foo"}]);
+        m.remove("bar");
+        assert.deepEqual(m.entries(), [{key: "foo", value: "foo"}]);
+        m.remove("foo");
+        assert.deepEqual(m.entries(), []);
+        m.remove("foo");
+        assert.deepEqual(m.entries(), []);
+      }
+    },
+    "keys": {
+      "returns an array of string keys": function(map) {
+        var m = map({foo: 1, bar: "42"});
+        assert.deepEqual(m.keys().sort(), ["bar", "foo"]);
+      }
+    },
+    "values": {
+      "returns an array of arbitrary values": function(map) {
+        var m = map({foo: 1, bar: "42"});
+        assert.deepEqual(m.values().sort(), [1, "42"]);
+      }
+    },
+    "entries": {
+      "returns an array of key-value objects": function(map) {
+        var m = map({foo: 1, bar: "42"});
+        assert.deepEqual(m.entries().sort(ascendingByKey), [{key: "bar", value: "42"}, {key: "foo", value: 1}]);
+      }
+    },
+    "has": {
+      "empty maps do not have object built-ins": function(map) {
+        var m = map();
+        assert.isFalse(m.has("__proto__"));
+        assert.isFalse(m.has("hasOwnProperty"));
+      },
+      "can has keys using built-in names": function(map) {
+        var m = map();
+        m.set("__proto__", 42);
+        assert.isTrue(m.has("__proto__"));
+      },
+      "can has keys with null or undefined properties": function(map) {
+        var m = map();
+        m.set("", "");
+        m.set("null", null);
+        m.set("undefined", undefined);
+        assert.isTrue(m.has(""));
+        assert.isTrue(m.has("null"));
+        assert.isTrue(m.has("undefined"));
+      },
+      "coerces keys to strings": function(map) {
+        var m = map({"42": "foo", "null": 1, "undefined": 2});
+        assert.isTrue(m.has(42));
+        assert.isTrue(m.has(null));
+        assert.isTrue(m.has(undefined));
+      },
+      "returns the latest value": function(map) {
+        var m = map({foo: 42});
+        assert.isTrue(m.has("foo"));
+        m.set("foo", 43);
+        assert.isTrue(m.has("foo"));
+        m.remove("foo");
+        assert.isFalse(m.has("foo"));
+        m.set("foo", "bar");
+        assert.isTrue(m.has("foo"));
+      },
+      "returns undefined for missing keys": function(map) {
+        var m = map({foo: 42});
+        assert.isFalse(m.has("bar"));
+      }
+    },
+    "get": {
+      "empty maps do not have object built-ins": function(map) {
+        var m = map();
+        assert.isUndefined(m.get("__proto__"));
+        assert.isUndefined(m.get("hasOwnProperty"));
+      },
+      "can get keys using built-in names": function(map) {
+        var m = map();
+        m.set("__proto__", 42);
+        assert.equal(m.get("__proto__"), 42);
+      },
+      "coerces keys to strings": function(map) {
+        var m = map({"42": 1, "null": 2, "undefined": 3});
+        assert.equal(m.get(42), 1);
+        assert.equal(m.get(null), 2);
+        assert.equal(m.get(undefined), 3);
+      },
+      "returns the latest value": function(map) {
+        var m = map({foo: 42});
+        assert.equal(m.get("foo"), 42);
+        m.set("foo", 43);
+        assert.equal(m.get("foo"), 43);
+        m.remove("foo");
+        assert.isUndefined(m.get("foo"));
+        m.set("foo", "bar");
+        assert.equal(m.get("foo"), "bar");
+      },
+      "returns undefined for missing keys": function(map) {
+        var m = map({foo: 42});
+        assert.isUndefined(m.get("bar"));
+      }
+    },
+    "set": {
+      "returns the set value": function(map) {
+        var m = map();
+        assert.equal(m.set("foo", 42), 42);
+      },
+      "can set keys using built-in names": function(map) {
+        var m = map();
+        m.set("__proto__", 42);
+        assert.equal(m.get("__proto__"), 42);
+      },
+      "coerces keys to strings": function(map) {
+        var m = map();
+        m.set(42, 1);
+        assert.equal(m.get(42), 1);
+        m.set(null, 2);
+        assert.equal(m.get(null), 2);
+        m.set(undefined, 3);
+        assert.equal(m.get(undefined), 3);
+        assert.deepEqual(m.keys().sort(), ["42", "null", "undefined"]);
+      },
+      "can replace values": function(map) {
+        var m = map({foo: 42});
+        assert.equal(m.get("foo"), 42);
+        m.set("foo", 43);
+        assert.equal(m.get("foo"), 43);
+        m.set("foo", "bar");
+        assert.equal(m.get("foo"), "bar");
+      },
+      "can set null, undefined or empty string values": function(map) {
+        var m = map();
+        m.set("", "");
+        m.set("null", null);
+        m.set("undefined", undefined);
+        assert.equal(m.get(""), "");
+        assert.isNull(m.get("null"));
+        assert.isUndefined(m.get("undefined"));
+      }
+    }
+  }
+});
+
+function ascendingByKey(a, b) {
+  return a.key.localeCompare(b.key);
+}
+
+suite.export(module);

data/lib/stripmem/public/components/d3/test/arrays/max-test.js

@@ -0,0 +1,51 @@
+var vows = require("vows"),
+    _ = require("../../"),
+    load = require("../load"),
+    assert = require("../assert");
+
+var suite = vows.describe("d3.max");
+
+suite.addBatch({
+  "max": {
+    topic: load("arrays/max").expression("d3.max"),
+    "returns the greatest numeric value for numbers": function(max) {
+      assert.equal(max([1]), 1);
+      assert.equal(max([5, 1, 2, 3, 4]), 5);
+      assert.equal(max([20, 3]), 20);
+      assert.equal(max([3, 20]), 20);
+    },
+    "returns the greatest lexicographic value for strings": function(max) {
+      assert.equal(max(["c", "a", "b"]), "c");
+      assert.equal(max(["20", "3"]), "3");
+      assert.equal(max(["3", "20"]), "3");
+    },
+    "ignores null, undefined and NaN": function(max) {
+      var o = {valueOf: function() { return NaN; }};
+      assert.equal(max([NaN, 1, 2, 3, 4, 5]), 5);
+      assert.equal(max([o, 1, 2, 3, 4, 5]), 5);
+      assert.equal(max([1, 2, 3, 4, 5, NaN]), 5);
+      assert.equal(max([1, 2, 3, 4, 5, o]), 5);
+      assert.equal(max([10, null, 3, undefined, 5, NaN]), 10);
+      assert.equal(max([-1, null, -3, undefined, -5, NaN]), -1);
+    },
+    "compares heterogenous types as numbers": function(max) {
+      assert.strictEqual(max([20, "3"]), 20);
+      assert.strictEqual(max(["20", 3]), "20");
+      assert.strictEqual(max([3, "20"]), "20");
+      assert.strictEqual(max(["3", 20]), 20);
+    },
+    "returns undefined for empty array": function(max) {
+      assert.isUndefined(max([]));
+      assert.isUndefined(max([null]));
+      assert.isUndefined(max([undefined]));
+      assert.isUndefined(max([NaN]));
+      assert.isUndefined(max([NaN, NaN]));
+    },
+    "applies the optional accessor function": function(max) {
+      assert.equal(max([[1, 2, 3, 4, 5], [2, 4, 6, 8, 10]], function(d) { return _.min(d); }), 2);
+      assert.equal(max([1, 2, 3, 4, 5], function(d, i) { return i; }), 4);
+    }
+  }
+});
+
+suite.export(module);

data/lib/stripmem/public/components/d3/test/arrays/mean-test.js

@@ -0,0 +1,39 @@
+var vows = require("vows"),
+    load = require("../load"),
+    assert = require("../assert");
+
+var suite = vows.describe("d3.mean");
+
+suite.addBatch({
+  "mean": {
+    topic: load("arrays/mean").expression("d3.mean"),
+    "returns the mean value for numbers": function(mean) {
+      assert.equal(mean([1]), 1);
+      assert.equal(mean([5, 1, 2, 3, 4]), 3);
+      assert.equal(mean([20, 3]), 11.5);
+      assert.equal(mean([3, 20]), 11.5);
+    },
+    "ignores null, undefined and NaN": function(mean) {
+      assert.equal(mean([NaN, 1, 2, 3, 4, 5]), 3);
+      assert.equal(mean([1, 2, 3, 4, 5, NaN]), 3);
+      assert.equal(mean([10, null, 3, undefined, 5, NaN]), 6);
+    },
+    "can handle large numbers without overflowing": function(mean) {
+      assert.equal(mean([Number.MAX_VALUE, Number.MAX_VALUE]), Number.MAX_VALUE);
+      assert.equal(mean([-Number.MAX_VALUE, -Number.MAX_VALUE]), -Number.MAX_VALUE);
+    },
+    "returns undefined for empty array": function(mean) {
+      assert.isUndefined(mean([]));
+      assert.isUndefined(mean([null]));
+      assert.isUndefined(mean([undefined]));
+      assert.isUndefined(mean([NaN]));
+      assert.isUndefined(mean([NaN, NaN]));
+    },
+    "applies the optional accessor function": function(mean) {
+      assert.equal(mean([[1, 2, 3, 4, 5], [2, 4, 6, 8, 10]], function(d) { return mean(d); }), 4.5);
+      assert.equal(mean([1, 2, 3, 4, 5], function(d, i) { return i; }), 2);
+    }
+  }
+});
+
+suite.export(module);

data/lib/stripmem/public/components/d3/test/arrays/median-test.js

@@ -0,0 +1,39 @@
+var vows = require("vows"),
+    load = require("../load"),
+    assert = require("../assert");
+
+var suite = vows.describe("d3.median");
+
+suite.addBatch({
+  "median": {
+    topic: load("arrays/median").expression("d3.median"),
+    "returns the median value for numbers": function(median) {
+      assert.equal(median([1]), 1);
+      assert.equal(median([5, 1, 2, 3, 4]), 3);
+      assert.equal(median([20, 3]), 11.5);
+      assert.equal(median([3, 20]), 11.5);
+    },
+    "ignores null, undefined and NaN": function(median) {
+      assert.equal(median([NaN, 1, 2, 3, 4, 5]), 3);
+      assert.equal(median([1, 2, 3, 4, 5, NaN]), 3);
+      assert.equal(median([10, null, 3, undefined, 5, NaN]), 5);
+    },
+    "can handle large numbers without overflowing": function(median) {
+      assert.equal(median([Number.MAX_VALUE, Number.MAX_VALUE]), Number.MAX_VALUE);
+      assert.equal(median([-Number.MAX_VALUE, -Number.MAX_VALUE]), -Number.MAX_VALUE);
+    },
+    "returns undefined for empty array": function(median) {
+      assert.isUndefined(median([]));
+      assert.isUndefined(median([null]));
+      assert.isUndefined(median([undefined]));
+      assert.isUndefined(median([NaN]));
+      assert.isUndefined(median([NaN, NaN]));
+    },
+    "applies the optional accessor function": function(median) {
+      assert.equal(median([[1, 2, 3, 4, 5], [2, 4, 6, 8, 10]], function(d) { return median(d); }), 4.5);
+      assert.equal(median([1, 2, 3, 4, 5], function(d, i) { return i; }), 2);
+    }
+  }
+});
+
+suite.export(module);

data/lib/stripmem/public/components/d3/test/arrays/merge-test.js

@@ -0,0 +1,26 @@
+var vows = require("vows"),
+    load = require("../load"),
+    assert = require("../assert");
+
+var suite = vows.describe("d3.merge");
+
+suite.addBatch({
+  "merge": {
+    topic: load("arrays/merge").expression("d3.merge"),
+    "merges an array of arrays": function(merge) {
+      var a = {}, b = {}, c = {}, d = {}, e = {}, f = {};
+      assert.deepEqual(merge([[a], [b, c], [d, e, f]]), [a, b, c, d, e, f]);
+    },
+    "returns a new array": function(merge) {
+      var input = [[1, 2, 3], [4, 5], [6]];
+      assert.isFalse(merge(input) === input);
+    },
+    "does not modify the input arrays": function(merge) {
+      var input = [[1, 2, 3], [4, 5], [6]];
+      merge(input);
+      assert.deepEqual(input, [[1, 2, 3], [4, 5], [6]]);
+    }
+  }
+});
+
+suite.export(module);

data/lib/stripmem/public/components/d3/test/arrays/min-test.js

@@ -0,0 +1,51 @@
+var vows = require("vows"),
+    _ = require("../../"),
+    load = require("../load"),
+    assert = require("../assert");
+
+var suite = vows.describe("d3.min");
+
+suite.addBatch({
+  "min": {
+    topic: load("arrays/min").expression("d3.min"),
+    "returns the least numeric value for numbers": function(min) {
+      assert.equal(min([1]), 1);
+      assert.equal(min([5, 1, 2, 3, 4]), 1);
+      assert.equal(min([20, 3]), 3);
+      assert.equal(min([3, 20]), 3);
+    },
+    "returns the least lexicographic value for strings": function(min) {
+      assert.equal(min(["c", "a", "b"]), "a");
+      assert.equal(min(["20", "3"]), "20");
+      assert.equal(min(["3", "20"]), "20");
+    },
+    "ignores null, undefined and NaN": function(min) {
+      var o = {valueOf: function() { return NaN; }};
+      assert.equal(min([NaN, 1, 2, 3, 4, 5]), 1);
+      assert.equal(min([o, 1, 2, 3, 4, 5]), 1);
+      assert.equal(min([1, 2, 3, 4, 5, NaN]), 1);
+      assert.equal(min([1, 2, 3, 4, 5, o]), 1);
+      assert.equal(min([10, null, 3, undefined, 5, NaN]), 3);
+      assert.equal(min([-1, null, -3, undefined, -5, NaN]), -5);
+    },
+    "compares heterogenous types as numbers": function(min) {
+      assert.strictEqual(min([20, "3"]), "3");
+      assert.strictEqual(min(["20", 3]), 3);
+      assert.strictEqual(min([3, "20"]), 3);
+      assert.strictEqual(min(["3", 20]), "3");
+    },
+    "returns undefined for empty array": function(min) {
+      assert.isUndefined(min([]));
+      assert.isUndefined(min([null]));
+      assert.isUndefined(min([undefined]));
+      assert.isUndefined(min([NaN]));
+      assert.isUndefined(min([NaN, NaN]));
+    },
+    "applies the optional accessor function": function(min) {
+      assert.equal(min([[1, 2, 3, 4, 5], [2, 4, 6, 8, 10]], function(d) { return _.max(d); }), 5);
+      assert.equal(min([1, 2, 3, 4, 5], function(d, i) { return i; }), 0);
+    }
+  }
+});
+
+suite.export(module);

data/lib/stripmem/public/components/d3/test/arrays/nest-test.js

@@ -0,0 +1,256 @@
+var vows = require("vows"),
+    _ = require("../../"),
+    load = require("../load"),
+    assert = require("../assert");
+
+var suite = vows.describe("d3.nest");
+
+suite.addBatch({
+  "entries": {
+    topic: load("arrays/nest").expression("d3.nest"),
+    "returns an array of each distinct key in arbitrary order": function(nest) {
+      var keys = nest()
+          .key(function(d) { return d.foo; })
+          .entries([{foo: 1}, {foo: 1}, {foo: 2}])
+          .map(function(d) { return d.key; })
+          .sort(_.ascending);
+      assert.deepEqual(keys, ["1", "2"]);
+    },
+    "each entry is a key-values object, with values in input order": function(nest) {
+      var entries = nest()
+          .key(function(d) { return d.foo; })
+          .entries([{foo: 1, bar: 0}, {foo: 2}, {foo: 1, bar: 1}]);
+      assert.deepEqual(entries, [
+        {key: "1", values: [{foo: 1, bar: 0}, {foo: 1, bar: 1}]},
+        {key: "2", values: [{foo: 2}]}
+      ]);
+    },
+    "keys can be sorted using an optional comparator": function(nest) {
+      var keys = nest()
+          .key(function(d) { return d.foo; }).sortKeys(_.descending)
+          .entries([{foo: 1}, {foo: 1}, {foo: 2}])
+          .map(function(d) { return d.key; });
+      assert.deepEqual(keys, ["2", "1"]);
+    },
+    "values can be sorted using an optional comparator": function(nest) {
+      var entries = nest()
+          .key(function(d) { return d.foo; })
+          .sortValues(function(a, b) { return a.bar - b.bar; })
+          .entries([{foo: 1, bar: 2}, {foo: 1, bar: 0}, {foo: 1, bar: 1}, {foo: 2}]);
+      assert.deepEqual(entries, [
+        {key: "1", values: [{foo: 1, bar: 0}, {foo: 1, bar: 1}, {foo: 1, bar: 2}]},
+        {key: "2", values: [{foo: 2}]}
+      ]);
+    },
+    "values can be aggregated using an optional rollup": function(nest) {
+      var entries = nest()
+          .key(function(d) { return d.foo; })
+          .rollup(function(values) { return _.sum(values, function(d) { return d.bar; }); })
+          .entries([{foo: 1, bar: 2}, {foo: 1, bar: 0}, {foo: 1, bar: 1}, {foo: 2}]);
+      assert.deepEqual(entries, [
+        {key: "1", values: 3},
+        {key: "2", values: 0}
+      ]);
+    },
+    "multiple key functions can be specified": function(nest) {
+      var entries = nest()
+          .key(function(d) { return d[0]; }).sortKeys(_.ascending)
+          .key(function(d) { return d[1]; }).sortKeys(_.ascending)
+          .entries([[0, 1], [0, 2], [1, 1], [1, 2], [0, 2]]);
+      assert.deepEqual(entries, [
+        {key: "0", values: [
+          {key: "1", values: [[0, 1]]},
+          {key: "2", values: [[0, 2], [0, 2]]}
+        ]},
+        {key: "1", values: [
+          {key: "1", values: [[1, 1]]},
+          {key: "2", values: [[1, 2]]}
+        ]}
+      ]);
+    },
+    "the rollup function only applies to leaf values": function(nest) {
+      var entries = nest()
+          .key(function(d) { return d[0]; }).sortKeys(_.ascending)
+          .key(function(d) { return d[1]; }).sortKeys(_.ascending)
+          .rollup(function(values) { return values.length; })
+          .entries([[0, 1], [0, 2], [1, 1], [1, 2], [0, 2]]);
+      assert.deepEqual(entries, [
+        {key: "0", values: [
+          {key: "1", values: 1},
+          {key: "2", values: 2}
+        ]},
+        {key: "1", values: [
+          {key: "1", values: 1},
+          {key: "2", values: 1}
+        ]}
+      ]);
+    },
+    "the value comparator only applies to leaf values": function(nest) {
+      var entries = nest()
+          .key(function(d) { return d[0]; }).sortKeys(_.ascending)
+          .key(function(d) { return d[1]; }).sortKeys(_.ascending)
+          .sortValues(function(a, b) { return a[2] - b[2]; })
+          .entries([[0, 1], [0, 2, 1], [1, 1], [1, 2], [0, 2, 0]]);
+      assert.deepEqual(entries, [
+        {key: "0", values: [
+          {key: "1", values: [[0, 1]]},
+          {key: "2", values: [[0, 2, 0], [0, 2, 1]]}
+        ]},
+        {key: "1", values: [
+          {key: "1", values: [[1, 1]]},
+          {key: "2", values: [[1, 2]]}
+        ]}
+      ]);
+    },
+    "the key comparator only applies to the last-specified key": function(nest) {
+      var entries = nest()
+          .key(function(d) { return d[0]; }).sortKeys(_.ascending)
+          .key(function(d) { return d[1]; }).sortKeys(_.descending)
+          .entries([[0, 1], [0, 2], [1, 1], [1, 2], [0, 2]]);
+      assert.deepEqual(entries, [
+        {key: "0", values: [
+          {key: "2", values: [[0, 2], [0, 2]]},
+          {key: "1", values: [[0, 1]]}
+        ]},
+        {key: "1", values: [
+          {key: "2", values: [[1, 2]]},
+          {key: "1", values: [[1, 1]]}
+        ]}
+      ]);
+      var entries = nest()
+          .key(function(d) { return d[0]; }).sortKeys(_.descending)
+          .key(function(d) { return d[1]; }).sortKeys(_.ascending)
+          .entries([[0, 1], [0, 2], [1, 1], [1, 2], [0, 2]]);
+      assert.deepEqual(entries, [
+        {key: "1", values: [
+          {key: "1", values: [[1, 1]]},
+          {key: "2", values: [[1, 2]]}
+        ]},
+        {key: "0", values: [
+          {key: "1", values: [[0, 1]]},
+          {key: "2", values: [[0, 2], [0, 2]]}
+        ]}
+      ]);
+    },
+    "if no keys are specified, the input array is returned": function(nest) {
+      var array = [new Object()];
+      assert.strictEqual(nest().entries(array), array);
+    }
+  }
+});
+
+suite.addBatch({
+  "map": {
+    topic: load("arrays/nest").expression("d3.nest"),
+    "returns a map of each distinct key": function(nest) {
+      var map = nest()
+          .key(function(d) { return d.foo; })
+          .map([{foo: 1, bar: 0}, {foo: 2}, {foo: 1, bar: 1}]);
+      assert.deepEqual(map, {
+        "1": [{foo: 1, bar: 0}, {foo: 1, bar: 1}],
+        "2": [{foo: 2}]
+      });
+    },
+    "values can be sorted using an optional comparator": function(nest) {
+      var map = nest()
+          .key(function(d) { return d.foo; })
+          .sortValues(function(a, b) { return a.bar - b.bar; })
+          .map([{foo: 1, bar: 2}, {foo: 1, bar: 0}, {foo: 1, bar: 1}, {foo: 2}]);
+      assert.deepEqual(map, {
+        "1": [{foo: 1, bar: 0}, {foo: 1, bar: 1}, {foo: 1, bar: 2}],
+        "2": [{foo: 2}]
+      });
+    },
+    "values can be aggregated using an optional rollup": function(nest) {
+      var map = nest()
+          .key(function(d) { return d.foo; })
+          .rollup(function(values) { return _.sum(values, function(d) { return d.bar; }); })
+          .map([{foo: 1, bar: 2}, {foo: 1, bar: 0}, {foo: 1, bar: 1}, {foo: 2}]);
+      assert.deepEqual(map, {
+        "1": 3,
+        "2": 0
+      });
+    },
+    "multiple key functions can be specified": function(nest) {
+      var map = nest()
+          .key(function(d) { return d[0]; }).sortKeys(_.ascending)
+          .key(function(d) { return d[1]; }).sortKeys(_.ascending)
+          .map([[0, 1], [0, 2], [1, 1], [1, 2], [0, 2]]);
+      assert.deepEqual(map, {
+        "0": {
+          "1": [[0, 1]],
+          "2": [[0, 2], [0, 2]]
+        },
+        "1": {
+          "1": [[1, 1]],
+          "2": [[1, 2]]
+        }
+      });
+    },
+    "the rollup function only applies to leaf values": function(nest) {
+      var map = nest()
+          .key(function(d) { return d[0]; }).sortKeys(_.ascending)
+          .key(function(d) { return d[1]; }).sortKeys(_.ascending)
+          .rollup(function(values) { return values.length; })
+          .map([[0, 1], [0, 2], [1, 1], [1, 2], [0, 2]]);
+      assert.deepEqual(map, {
+        "0": {
+          "1": 1,
+          "2": 2
+        },
+        "1": {
+          "1": 1,
+          "2": 1
+        }
+      });
+    },
+    "the value comparator only applies to leaf values": function(nest) {
+      var map = nest()
+          .key(function(d) { return d[0]; }).sortKeys(_.ascending)
+          .key(function(d) { return d[1]; }).sortKeys(_.ascending)
+          .sortValues(function(a, b) { return a[2] - b[2]; })
+          .map([[0, 1], [0, 2, 1], [1, 1], [1, 2], [0, 2, 0]]);
+      assert.deepEqual(map, {
+        "0": {
+          "1": [[0, 1]],
+          "2": [[0, 2, 0], [0, 2, 1]]
+        },
+        "1": {
+          "1": [[1, 1]],
+          "2": [[1, 2]]
+        }
+      });
+    },
+    "if no keys are specified, the input array is returned": function(nest) {
+      var array = [new Object()];
+      assert.strictEqual(nest().map(array), array);
+    },
+    "handles keys that are built-in prototype properties": function(nest) {
+      var map = nest()
+          .key(String)
+          .map(["hasOwnProperty"]); // but note __proto__ wouldn’t work!
+      assert.deepEqual(map, {hasOwnProperty: ["hasOwnProperty"]});
+    },
+    "a custom map implementation can be specified": function(nest) {
+      var map = nest()
+          .key(String)
+          .map(["hasOwnProperty", "__proto__"], _.map);
+      assert.deepEqual(map.entries(), [
+        {key: "hasOwnProperty", value: ["hasOwnProperty"]},
+        {key: "__proto__", value: ["__proto__"]}
+      ]);
+    },
+    "the custom map implementation works on multiple levels of nesting": function(nest) {
+      var map = nest()
+          .key(function(d) { return d.foo; })
+          .key(function(d) { return d.bar; })
+          .map([{foo: 42, bar: "red"}], _.map);
+      assert.deepEqual(map.keys(), ["42"]);
+      assert.deepEqual(map.get("42").keys(), ["red"]);
+      assert.deepEqual(map.get("42").values(), [[{foo: 42, bar: "red"}]]);
+      assert.deepEqual(map.get("42").entries(), [{key: "red", value: [{foo: 42, bar: "red"}]}]);
+    }
+  }
+});
+
+suite.export(module);