--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/toolkit/javascript/d3/test/core/nest-test.js Thu Apr 10 14:20:23 2014 +0200
@@ -0,0 +1,236 @@
+require("../env");
+require("../../d3");
+
+var vows = require("vows"),
+ assert = require("assert");
+
+var suite = vows.describe("d3.nest");
+
+suite.addBatch({
+ "entries": {
+ topic: function() {
+ return 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(d3.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(d3.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 d3.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(d3.ascending)
+ .key(function(d) { return d[1]; }).sortKeys(d3.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(d3.ascending)
+ .key(function(d) { return d[1]; }).sortKeys(d3.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(d3.ascending)
+ .key(function(d) { return d[1]; }).sortKeys(d3.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(d3.ascending)
+ .key(function(d) { return d[1]; }).sortKeys(d3.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(d3.descending)
+ .key(function(d) { return d[1]; }).sortKeys(d3.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: function() {
+ return 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 d3.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(d3.ascending)
+ .key(function(d) { return d[1]; }).sortKeys(d3.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(d3.ascending)
+ .key(function(d) { return d[1]; }).sortKeys(d3.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(d3.ascending)
+ .key(function(d) { return d[1]; }).sortKeys(d3.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);
+ }
+ }
+});
+
+suite.export(module);