Refactor array tests for minimal loading.
This commit is contained in:
Mike Bostock
Родитель
0f2b61ae93
Коммит
f37405d1b8
|
|
@ -6,37 +6,37 @@ var suite = vows.describe("d3.ascending");
|
||||||
|
|
||||||
suite.addBatch({
|
suite.addBatch({
|
||||||
"d3.ascending": {
|
"d3.ascending": {
|
||||||
topic: load("arrays/ascending"),
|
topic: load("arrays/ascending").expression("d3.ascending"),
|
||||||
"numbers": {
|
"numbers": {
|
||||||
"returns a negative number if a < b": function(d3) {
|
"returns a negative number if a < b": function(ascending) {
|
||||||
assert.isTrue(d3.ascending(0, 1) < 0);
|
assert.isTrue(ascending(0, 1) < 0);
|
||||||
},
|
},
|
||||||
"returns a positive number if a > b": function(d3) {
|
"returns a positive number if a > b": function(ascending) {
|
||||||
assert.isTrue(d3.ascending(1, 0) > 0);
|
assert.isTrue(ascending(1, 0) > 0);
|
||||||
},
|
},
|
||||||
"returns zero if a == b": function(d3) {
|
"returns zero if a == b": function(ascending) {
|
||||||
assert.equal(d3.ascending(0, 0), 0);
|
assert.equal(ascending(0, 0), 0);
|
||||||
},
|
},
|
||||||
"returns NaN if a or b is undefined": function(d3) {
|
"returns NaN if a or b is undefined": function(ascending) {
|
||||||
assert.isNaN(d3.ascending(0, undefined));
|
assert.isNaN(ascending(0, undefined));
|
||||||
assert.isNaN(d3.ascending(undefined, 0));
|
assert.isNaN(ascending(undefined, 0));
|
||||||
assert.isNaN(d3.ascending(undefined, undefined));
|
assert.isNaN(ascending(undefined, undefined));
|
||||||
},
|
},
|
||||||
"returns NaN if a or b is NaN": function(d3) {
|
"returns NaN if a or b is NaN": function(ascending) {
|
||||||
assert.isNaN(d3.ascending(0, NaN));
|
assert.isNaN(ascending(0, NaN));
|
||||||
assert.isNaN(d3.ascending(NaN, 0));
|
assert.isNaN(ascending(NaN, 0));
|
||||||
assert.isNaN(d3.ascending(NaN, NaN));
|
assert.isNaN(ascending(NaN, NaN));
|
||||||
}
|
}
|
||||||
},
|
},
|
||||||
"strings": {
|
"strings": {
|
||||||
"returns a negative number if a < b": function(d3) {
|
"returns a negative number if a < b": function(ascending) {
|
||||||
assert.isTrue(d3.ascending("a", "b") < 0);
|
assert.isTrue(ascending("a", "b") < 0);
|
||||||
},
|
},
|
||||||
"returns a positive number if a > b": function(d3) {
|
"returns a positive number if a > b": function(ascending) {
|
||||||
assert.isTrue(d3.ascending("b", "a") > 0);
|
assert.isTrue(ascending("b", "a") > 0);
|
||||||
},
|
},
|
||||||
"returns zero if a == b": function(d3) {
|
"returns zero if a == b": function(ascending) {
|
||||||
assert.equal(d3.ascending("a", "a"), 0);
|
assert.equal(ascending("a", "a"), 0);
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
|
||||||
|
|
@ -8,47 +8,47 @@ var i30 = 1 << 30;
|
||||||
|
|
||||||
suite.addBatch({
|
suite.addBatch({
|
||||||
"bisectLeft": {
|
"bisectLeft": {
|
||||||
topic: load("arrays/bisect"),
|
topic: load("arrays/bisect").expression("d3.bisectLeft"),
|
||||||
"finds the index of an exact match": function(d3) {
|
"finds the index of an exact match": function(bisect) {
|
||||||
var array = [1, 2, 3];
|
var array = [1, 2, 3];
|
||||||
assert.equal(d3.bisectLeft(array, 1), 0);
|
assert.equal(bisect(array, 1), 0);
|
||||||
assert.equal(d3.bisectLeft(array, 2), 1);
|
assert.equal(bisect(array, 2), 1);
|
||||||
assert.equal(d3.bisectLeft(array, 3), 2);
|
assert.equal(bisect(array, 3), 2);
|
||||||
},
|
},
|
||||||
"finds the index of the first match": function(d3) {
|
"finds the index of the first match": function(bisect) {
|
||||||
var array = [1, 2, 2, 3];
|
var array = [1, 2, 2, 3];
|
||||||
assert.equal(d3.bisectLeft(array, 1), 0);
|
assert.equal(bisect(array, 1), 0);
|
||||||
assert.equal(d3.bisectLeft(array, 2), 1);
|
assert.equal(bisect(array, 2), 1);
|
||||||
assert.equal(d3.bisectLeft(array, 3), 3);
|
assert.equal(bisect(array, 3), 3);
|
||||||
},
|
},
|
||||||
"finds the insertion point of a non-exact match": function(d3) {
|
"finds the insertion point of a non-exact match": function(bisect) {
|
||||||
var array = [1, 2, 3];
|
var array = [1, 2, 3];
|
||||||
assert.equal(d3.bisectLeft(array, 0.5), 0);
|
assert.equal(bisect(array, 0.5), 0);
|
||||||
assert.equal(d3.bisectLeft(array, 1.5), 1);
|
assert.equal(bisect(array, 1.5), 1);
|
||||||
assert.equal(d3.bisectLeft(array, 2.5), 2);
|
assert.equal(bisect(array, 2.5), 2);
|
||||||
assert.equal(d3.bisectLeft(array, 3.5), 3);
|
assert.equal(bisect(array, 3.5), 3);
|
||||||
},
|
},
|
||||||
"observes the optional lower bound": function(d3) {
|
"observes the optional lower bound": function(bisect) {
|
||||||
var array = [1, 2, 3, 4, 5];
|
var array = [1, 2, 3, 4, 5];
|
||||||
assert.equal(d3.bisectLeft(array, 0, 2), 2);
|
assert.equal(bisect(array, 0, 2), 2);
|
||||||
assert.equal(d3.bisectLeft(array, 1, 2), 2);
|
assert.equal(bisect(array, 1, 2), 2);
|
||||||
assert.equal(d3.bisectLeft(array, 2, 2), 2);
|
assert.equal(bisect(array, 2, 2), 2);
|
||||||
assert.equal(d3.bisectLeft(array, 3, 2), 2);
|
assert.equal(bisect(array, 3, 2), 2);
|
||||||
assert.equal(d3.bisectLeft(array, 4, 2), 3);
|
assert.equal(bisect(array, 4, 2), 3);
|
||||||
assert.equal(d3.bisectLeft(array, 5, 2), 4);
|
assert.equal(bisect(array, 5, 2), 4);
|
||||||
assert.equal(d3.bisectLeft(array, 6, 2), 5);
|
assert.equal(bisect(array, 6, 2), 5);
|
||||||
},
|
},
|
||||||
"observes the optional bounds": function(d3) {
|
"observes the optional bounds": function(bisect) {
|
||||||
var array = [1, 2, 3, 4, 5];
|
var array = [1, 2, 3, 4, 5];
|
||||||
assert.equal(d3.bisectLeft(array, 0, 2, 3), 2);
|
assert.equal(bisect(array, 0, 2, 3), 2);
|
||||||
assert.equal(d3.bisectLeft(array, 1, 2, 3), 2);
|
assert.equal(bisect(array, 1, 2, 3), 2);
|
||||||
assert.equal(d3.bisectLeft(array, 2, 2, 3), 2);
|
assert.equal(bisect(array, 2, 2, 3), 2);
|
||||||
assert.equal(d3.bisectLeft(array, 3, 2, 3), 2);
|
assert.equal(bisect(array, 3, 2, 3), 2);
|
||||||
assert.equal(d3.bisectLeft(array, 4, 2, 3), 3);
|
assert.equal(bisect(array, 4, 2, 3), 3);
|
||||||
assert.equal(d3.bisectLeft(array, 5, 2, 3), 3);
|
assert.equal(bisect(array, 5, 2, 3), 3);
|
||||||
assert.equal(d3.bisectLeft(array, 6, 2, 3), 3);
|
assert.equal(bisect(array, 6, 2, 3), 3);
|
||||||
},
|
},
|
||||||
"large arrays": function(d3) {
|
"large arrays": function(bisect) {
|
||||||
var array = [],
|
var array = [],
|
||||||
i = i30;
|
i = i30;
|
||||||
array[i++] = 1;
|
array[i++] = 1;
|
||||||
|
|
@ -56,57 +56,57 @@ suite.addBatch({
|
||||||
array[i++] = 3;
|
array[i++] = 3;
|
||||||
array[i++] = 4;
|
array[i++] = 4;
|
||||||
array[i++] = 5;
|
array[i++] = 5;
|
||||||
assert.equal(d3.bisectLeft(array, 0, i - 5, i), i - 5);
|
assert.equal(bisect(array, 0, i - 5, i), i - 5);
|
||||||
assert.equal(d3.bisectLeft(array, 1, i - 5, i), i - 5);
|
assert.equal(bisect(array, 1, i - 5, i), i - 5);
|
||||||
assert.equal(d3.bisectLeft(array, 2, i - 5, i), i - 4);
|
assert.equal(bisect(array, 2, i - 5, i), i - 4);
|
||||||
assert.equal(d3.bisectLeft(array, 3, i - 5, i), i - 3);
|
assert.equal(bisect(array, 3, i - 5, i), i - 3);
|
||||||
assert.equal(d3.bisectLeft(array, 4, i - 5, i), i - 2);
|
assert.equal(bisect(array, 4, i - 5, i), i - 2);
|
||||||
assert.equal(d3.bisectLeft(array, 5, i - 5, i), i - 1);
|
assert.equal(bisect(array, 5, i - 5, i), i - 1);
|
||||||
assert.equal(d3.bisectLeft(array, 6, i - 5, i), i - 0);
|
assert.equal(bisect(array, 6, i - 5, i), i - 0);
|
||||||
}
|
}
|
||||||
},
|
},
|
||||||
"bisectRight": {
|
"bisectRight": {
|
||||||
topic: load("arrays/bisect"),
|
topic: load("arrays/bisect").expression("d3.bisectRight"),
|
||||||
"finds the index after an exact match": function(d3) {
|
"finds the index after an exact match": function(bisect) {
|
||||||
var array = [1, 2, 3];
|
var array = [1, 2, 3];
|
||||||
assert.equal(d3.bisectRight(array, 1), 1);
|
assert.equal(bisect(array, 1), 1);
|
||||||
assert.equal(d3.bisectRight(array, 2), 2);
|
assert.equal(bisect(array, 2), 2);
|
||||||
assert.equal(d3.bisectRight(array, 3), 3);
|
assert.equal(bisect(array, 3), 3);
|
||||||
},
|
},
|
||||||
"finds the index after the last match": function(d3) {
|
"finds the index after the last match": function(bisect) {
|
||||||
var array = [1, 2, 2, 3];
|
var array = [1, 2, 2, 3];
|
||||||
assert.equal(d3.bisectRight(array, 1), 1);
|
assert.equal(bisect(array, 1), 1);
|
||||||
assert.equal(d3.bisectRight(array, 2), 3);
|
assert.equal(bisect(array, 2), 3);
|
||||||
assert.equal(d3.bisectRight(array, 3), 4);
|
assert.equal(bisect(array, 3), 4);
|
||||||
},
|
},
|
||||||
"finds the insertion point of a non-exact match": function(d3) {
|
"finds the insertion point of a non-exact match": function(bisect) {
|
||||||
var array = [1, 2, 3];
|
var array = [1, 2, 3];
|
||||||
assert.equal(d3.bisectRight(array, 0.5), 0);
|
assert.equal(bisect(array, 0.5), 0);
|
||||||
assert.equal(d3.bisectRight(array, 1.5), 1);
|
assert.equal(bisect(array, 1.5), 1);
|
||||||
assert.equal(d3.bisectRight(array, 2.5), 2);
|
assert.equal(bisect(array, 2.5), 2);
|
||||||
assert.equal(d3.bisectRight(array, 3.5), 3);
|
assert.equal(bisect(array, 3.5), 3);
|
||||||
},
|
},
|
||||||
"observes the optional lower bound": function(d3) {
|
"observes the optional lower bound": function(bisect) {
|
||||||
var array = [1, 2, 3, 4, 5];
|
var array = [1, 2, 3, 4, 5];
|
||||||
assert.equal(d3.bisectRight(array, 0, 2), 2);
|
assert.equal(bisect(array, 0, 2), 2);
|
||||||
assert.equal(d3.bisectRight(array, 1, 2), 2);
|
assert.equal(bisect(array, 1, 2), 2);
|
||||||
assert.equal(d3.bisectRight(array, 2, 2), 2);
|
assert.equal(bisect(array, 2, 2), 2);
|
||||||
assert.equal(d3.bisectRight(array, 3, 2), 3);
|
assert.equal(bisect(array, 3, 2), 3);
|
||||||
assert.equal(d3.bisectRight(array, 4, 2), 4);
|
assert.equal(bisect(array, 4, 2), 4);
|
||||||
assert.equal(d3.bisectRight(array, 5, 2), 5);
|
assert.equal(bisect(array, 5, 2), 5);
|
||||||
assert.equal(d3.bisectRight(array, 6, 2), 5);
|
assert.equal(bisect(array, 6, 2), 5);
|
||||||
},
|
},
|
||||||
"observes the optional bounds": function(d3) {
|
"observes the optional bounds": function(bisect) {
|
||||||
var array = [1, 2, 3, 4, 5];
|
var array = [1, 2, 3, 4, 5];
|
||||||
assert.equal(d3.bisectRight(array, 0, 2, 3), 2);
|
assert.equal(bisect(array, 0, 2, 3), 2);
|
||||||
assert.equal(d3.bisectRight(array, 1, 2, 3), 2);
|
assert.equal(bisect(array, 1, 2, 3), 2);
|
||||||
assert.equal(d3.bisectRight(array, 2, 2, 3), 2);
|
assert.equal(bisect(array, 2, 2, 3), 2);
|
||||||
assert.equal(d3.bisectRight(array, 3, 2, 3), 3);
|
assert.equal(bisect(array, 3, 2, 3), 3);
|
||||||
assert.equal(d3.bisectRight(array, 4, 2, 3), 3);
|
assert.equal(bisect(array, 4, 2, 3), 3);
|
||||||
assert.equal(d3.bisectRight(array, 5, 2, 3), 3);
|
assert.equal(bisect(array, 5, 2, 3), 3);
|
||||||
assert.equal(d3.bisectRight(array, 6, 2, 3), 3);
|
assert.equal(bisect(array, 6, 2, 3), 3);
|
||||||
},
|
},
|
||||||
"large arrays": function(d3) {
|
"large arrays": function(bisect) {
|
||||||
var array = [],
|
var array = [],
|
||||||
i = i30;
|
i = i30;
|
||||||
array[i++] = 1;
|
array[i++] = 1;
|
||||||
|
|
@ -114,20 +114,20 @@ suite.addBatch({
|
||||||
array[i++] = 3;
|
array[i++] = 3;
|
||||||
array[i++] = 4;
|
array[i++] = 4;
|
||||||
array[i++] = 5;
|
array[i++] = 5;
|
||||||
assert.equal(d3.bisectRight(array, 0, i - 5, i), i - 5);
|
assert.equal(bisect(array, 0, i - 5, i), i - 5);
|
||||||
assert.equal(d3.bisectRight(array, 1, i - 5, i), i - 4);
|
assert.equal(bisect(array, 1, i - 5, i), i - 4);
|
||||||
assert.equal(d3.bisectRight(array, 2, i - 5, i), i - 3);
|
assert.equal(bisect(array, 2, i - 5, i), i - 3);
|
||||||
assert.equal(d3.bisectRight(array, 3, i - 5, i), i - 2);
|
assert.equal(bisect(array, 3, i - 5, i), i - 2);
|
||||||
assert.equal(d3.bisectRight(array, 4, i - 5, i), i - 1);
|
assert.equal(bisect(array, 4, i - 5, i), i - 1);
|
||||||
assert.equal(d3.bisectRight(array, 5, i - 5, i), i - 0);
|
assert.equal(bisect(array, 5, i - 5, i), i - 0);
|
||||||
assert.equal(d3.bisectRight(array, 6, i - 5, i), i - 0);
|
assert.equal(bisect(array, 6, i - 5, i), i - 0);
|
||||||
}
|
}
|
||||||
},
|
},
|
||||||
"bisector(key)": {
|
"bisector(key)": {
|
||||||
topic: load("arrays/bisect"),
|
topic: load("arrays/bisect").expression("d3.bisector"),
|
||||||
"left": {
|
"left": {
|
||||||
topic: function(d3) {
|
topic: function(bisector) {
|
||||||
return d3.bisector(function(d) { return d.key; }).left;
|
return bisector(function(d) { return d.key; }).left;
|
||||||
},
|
},
|
||||||
"finds the index of an exact match": function(bisect) {
|
"finds the index of an exact match": function(bisect) {
|
||||||
var array = [{key: 1}, {key: 2}, {key: 3}];
|
var array = [{key: 1}, {key: 2}, {key: 3}];
|
||||||
|
|
@ -186,8 +186,8 @@ suite.addBatch({
|
||||||
}
|
}
|
||||||
},
|
},
|
||||||
"right": {
|
"right": {
|
||||||
topic: function(d3) {
|
topic: function(bisector) {
|
||||||
return d3.bisector(function(d) { return d.key; }).right;
|
return bisector(function(d) { return d.key; }).right;
|
||||||
},
|
},
|
||||||
"finds the index after an exact match": function(bisect) {
|
"finds the index after an exact match": function(bisect) {
|
||||||
var array = [{key: 1}, {key: 2}, {key: 3}];
|
var array = [{key: 1}, {key: 2}, {key: 3}];
|
||||||
|
|
|
||||||
|
|
@ -6,37 +6,37 @@ var suite = vows.describe("d3.descending");
|
||||||
|
|
||||||
suite.addBatch({
|
suite.addBatch({
|
||||||
"descending": {
|
"descending": {
|
||||||
topic: load("arrays/descending"),
|
topic: load("arrays/descending").expression("d3.descending"),
|
||||||
"numbers": {
|
"numbers": {
|
||||||
"returns a negative number if a > b": function(d3) {
|
"returns a negative number if a > b": function(descending) {
|
||||||
assert.isTrue(d3.descending(1, 0) < 0);
|
assert.isTrue(descending(1, 0) < 0);
|
||||||
},
|
},
|
||||||
"returns a positive number if a < b": function(d3) {
|
"returns a positive number if a < b": function(descending) {
|
||||||
assert.isTrue(d3.descending(0, 1) > 0);
|
assert.isTrue(descending(0, 1) > 0);
|
||||||
},
|
},
|
||||||
"returns zero if a == b": function(d3) {
|
"returns zero if a == b": function(descending) {
|
||||||
assert.equal(d3.descending(0, 0), 0);
|
assert.equal(descending(0, 0), 0);
|
||||||
},
|
},
|
||||||
"returns NaN if a or b is undefined": function(d3) {
|
"returns NaN if a or b is undefined": function(descending) {
|
||||||
assert.isNaN(d3.descending(0, undefined));
|
assert.isNaN(descending(0, undefined));
|
||||||
assert.isNaN(d3.descending(undefined, 0));
|
assert.isNaN(descending(undefined, 0));
|
||||||
assert.isNaN(d3.descending(undefined, undefined));
|
assert.isNaN(descending(undefined, undefined));
|
||||||
},
|
},
|
||||||
"returns NaN if a or b is NaN": function(d3) {
|
"returns NaN if a or b is NaN": function(descending) {
|
||||||
assert.isNaN(d3.descending(0, NaN));
|
assert.isNaN(descending(0, NaN));
|
||||||
assert.isNaN(d3.descending(NaN, 0));
|
assert.isNaN(descending(NaN, 0));
|
||||||
assert.isNaN(d3.descending(NaN, NaN));
|
assert.isNaN(descending(NaN, NaN));
|
||||||
}
|
}
|
||||||
},
|
},
|
||||||
"strings": {
|
"strings": {
|
||||||
"returns a negative number if a > b": function(d3) {
|
"returns a negative number if a > b": function(descending) {
|
||||||
assert.isTrue(d3.descending("b", "a") < 0);
|
assert.isTrue(descending("b", "a") < 0);
|
||||||
},
|
},
|
||||||
"returns a positive number if a < b": function(d3) {
|
"returns a positive number if a < b": function(descending) {
|
||||||
assert.isTrue(d3.descending("a", "b") > 0);
|
assert.isTrue(descending("a", "b") > 0);
|
||||||
},
|
},
|
||||||
"returns zero if a == b": function(d3) {
|
"returns zero if a == b": function(descending) {
|
||||||
assert.equal(d3.descending("a", "a"), 0);
|
assert.equal(descending("a", "a"), 0);
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
|
||||||
|
|
@ -6,27 +6,27 @@ var suite = vows.describe("d3.entries");
|
||||||
|
|
||||||
suite.addBatch({
|
suite.addBatch({
|
||||||
"entries": {
|
"entries": {
|
||||||
topic: load("arrays/entries"),
|
topic: load("arrays/entries").expression("d3.entries"),
|
||||||
"enumerates every entry": function(d3) {
|
"enumerates every entry": function(entries) {
|
||||||
assert.deepEqual(d3.entries({a: 1, b: 2}), [
|
assert.deepEqual(entries({a: 1, b: 2}), [
|
||||||
{key: "a", value: 1},
|
{key: "a", value: 1},
|
||||||
{key: "b", value: 2}
|
{key: "b", value: 2}
|
||||||
]);
|
]);
|
||||||
},
|
},
|
||||||
"includes entries defined on prototypes": function(d3) {
|
"includes entries defined on prototypes": function(entries) {
|
||||||
function abc() {
|
function abc() {
|
||||||
this.a = 1;
|
this.a = 1;
|
||||||
this.b = 2;
|
this.b = 2;
|
||||||
}
|
}
|
||||||
abc.prototype.c = 3;
|
abc.prototype.c = 3;
|
||||||
assert.deepEqual(d3.entries(new abc()), [
|
assert.deepEqual(entries(new abc()), [
|
||||||
{key: "a", value: 1},
|
{key: "a", value: 1},
|
||||||
{key: "b", value: 2},
|
{key: "b", value: 2},
|
||||||
{key: "c", value: 3}
|
{key: "c", value: 3}
|
||||||
]);
|
]);
|
||||||
},
|
},
|
||||||
"includes null or undefined values": function(d3) {
|
"includes null or undefined values": function(entries) {
|
||||||
var v = d3.entries({a: undefined, b: null, c: NaN});
|
var v = entries({a: undefined, b: null, c: NaN});
|
||||||
assert.equal(v.length, 3);
|
assert.equal(v.length, 3);
|
||||||
assert.deepEqual(v[0], {key: "a", value: undefined});
|
assert.deepEqual(v[0], {key: "a", value: undefined});
|
||||||
assert.deepEqual(v[1], {key: "b", value: null});
|
assert.deepEqual(v[1], {key: "b", value: null});
|
||||||
|
|
|
||||||
|
|
@ -6,40 +6,40 @@ var suite = vows.describe("d3.extent");
|
||||||
|
|
||||||
suite.addBatch({
|
suite.addBatch({
|
||||||
"extent": {
|
"extent": {
|
||||||
topic: load("arrays/extent"),
|
topic: load("arrays/extent").expression("d3.extent"),
|
||||||
"returns the numeric extent for numbers": function(d3) {
|
"returns the numeric extent for numbers": function(extent) {
|
||||||
assert.deepEqual(d3.extent([1]), [1, 1]);
|
assert.deepEqual(extent([1]), [1, 1]);
|
||||||
assert.deepEqual(d3.extent([5, 1, 2, 3, 4]), [1, 5]);
|
assert.deepEqual(extent([5, 1, 2, 3, 4]), [1, 5]);
|
||||||
assert.deepEqual(d3.extent([20, 3]), [3, 20]);
|
assert.deepEqual(extent([20, 3]), [3, 20]);
|
||||||
assert.deepEqual(d3.extent([3, 20]), [3, 20]);
|
assert.deepEqual(extent([3, 20]), [3, 20]);
|
||||||
},
|
},
|
||||||
"returns the lexicographic extent for strings": function(d3) {
|
"returns the lexicographic extent for strings": function(extent) {
|
||||||
assert.deepEqual(d3.extent(["c", "a", "b"]), ["a", "c"]);
|
assert.deepEqual(extent(["c", "a", "b"]), ["a", "c"]);
|
||||||
assert.deepEqual(d3.extent(["20", "3"]), ["20", "3"]);
|
assert.deepEqual(extent(["20", "3"]), ["20", "3"]);
|
||||||
assert.deepEqual(d3.extent(["3", "20"]), ["20", "3"]);
|
assert.deepEqual(extent(["3", "20"]), ["20", "3"]);
|
||||||
},
|
},
|
||||||
"ignores null, undefined and NaN": function(d3) {
|
"ignores null, undefined and NaN": function(extent) {
|
||||||
assert.deepEqual(d3.extent([NaN, 1, 2, 3, 4, 5]), [1, 5]);
|
assert.deepEqual(extent([NaN, 1, 2, 3, 4, 5]), [1, 5]);
|
||||||
assert.deepEqual(d3.extent([1, 2, 3, 4, 5, NaN]), [1, 5]);
|
assert.deepEqual(extent([1, 2, 3, 4, 5, NaN]), [1, 5]);
|
||||||
assert.deepEqual(d3.extent([10, null, 3, undefined, 5, NaN]), [3, 10]);
|
assert.deepEqual(extent([10, null, 3, undefined, 5, NaN]), [3, 10]);
|
||||||
assert.deepEqual(d3.extent([-1, null, -3, undefined, -5, NaN]), [-5, -1]);
|
assert.deepEqual(extent([-1, null, -3, undefined, -5, NaN]), [-5, -1]);
|
||||||
},
|
},
|
||||||
"compares heterogenous types as numbers": function(d3) {
|
"compares heterogenous types as numbers": function(extent) {
|
||||||
assert.deepEqual(d3.extent([20, "3"]), ["3", 20]);
|
assert.deepEqual(extent([20, "3"]), ["3", 20]);
|
||||||
assert.deepEqual(d3.extent(["20", 3]), [3, "20"]);
|
assert.deepEqual(extent(["20", 3]), [3, "20"]);
|
||||||
assert.deepEqual(d3.extent([3, "20"]), [3, "20"]);
|
assert.deepEqual(extent([3, "20"]), [3, "20"]);
|
||||||
assert.deepEqual(d3.extent(["3", 20]), ["3", 20]);
|
assert.deepEqual(extent(["3", 20]), ["3", 20]);
|
||||||
},
|
},
|
||||||
"returns undefined for empty array": function(d3) {
|
"returns undefined for empty array": function(extent) {
|
||||||
assert.deepEqual(d3.extent([]), [undefined, undefined]);
|
assert.deepEqual(extent([]), [undefined, undefined]);
|
||||||
assert.deepEqual(d3.extent([null]), [undefined, undefined]);
|
assert.deepEqual(extent([null]), [undefined, undefined]);
|
||||||
assert.deepEqual(d3.extent([undefined]), [undefined, undefined]);
|
assert.deepEqual(extent([undefined]), [undefined, undefined]);
|
||||||
assert.deepEqual(d3.extent([NaN]), [undefined, undefined]);
|
assert.deepEqual(extent([NaN]), [undefined, undefined]);
|
||||||
assert.deepEqual(d3.extent([NaN, NaN]), [undefined, undefined]);
|
assert.deepEqual(extent([NaN, NaN]), [undefined, undefined]);
|
||||||
},
|
},
|
||||||
"applies the optional accessor function exactly once": function(d3) {
|
"applies the optional accessor function exactly once": function(extent) {
|
||||||
var i = 10;
|
var i = 10;
|
||||||
assert.deepEqual(d3.extent([0,1,2,3], function() { return ++i; }), [11, 14]);
|
assert.deepEqual(extent([0,1,2,3], function() { return ++i; }), [11, 14]);
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
});
|
});
|
||||||
|
|
|
||||||
|
|
@ -6,20 +6,20 @@ var suite = vows.describe("d3.keys");
|
||||||
|
|
||||||
suite.addBatch({
|
suite.addBatch({
|
||||||
"keys": {
|
"keys": {
|
||||||
topic: load("arrays/keys"),
|
topic: load("arrays/keys").expression("d3.keys"),
|
||||||
"enumerates every defined key": function(d3) {
|
"enumerates every defined key": function(keys) {
|
||||||
assert.deepEqual(d3.keys({a: 1, b: 1}), ["a", "b"]);
|
assert.deepEqual(keys({a: 1, b: 1}), ["a", "b"]);
|
||||||
},
|
},
|
||||||
"includes keys defined on prototypes": function(d3) {
|
"includes keys defined on prototypes": function(keys) {
|
||||||
function abc() {
|
function abc() {
|
||||||
this.a = 1;
|
this.a = 1;
|
||||||
this.b = 2;
|
this.b = 2;
|
||||||
}
|
}
|
||||||
abc.prototype.c = 3;
|
abc.prototype.c = 3;
|
||||||
assert.deepEqual(d3.keys(new abc()), ["a", "b", "c"]);
|
assert.deepEqual(keys(new abc()), ["a", "b", "c"]);
|
||||||
},
|
},
|
||||||
"includes keys with null or undefined values": function(d3) {
|
"includes keys with null or undefined values": function(keys) {
|
||||||
assert.deepEqual(d3.keys({a: undefined, b: null, c: NaN}), ["a", "b", "c"]);
|
assert.deepEqual(keys({a: undefined, b: null, c: NaN}), ["a", "b", "c"]);
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
});
|
});
|
||||||
|
|
|
||||||
|
|
@ -6,202 +6,202 @@ var suite = vows.describe("d3.map");
|
||||||
|
|
||||||
suite.addBatch({
|
suite.addBatch({
|
||||||
"map": {
|
"map": {
|
||||||
topic: load("arrays/map"),
|
topic: load("arrays/map").expression("d3.map"),
|
||||||
"constructor": {
|
"constructor": {
|
||||||
"map() returns an empty map": function(d3) {
|
"map() returns an empty map": function(map) {
|
||||||
var map = d3.map();
|
var m = map();
|
||||||
assert.deepEqual(map.keys(), []);
|
assert.deepEqual(m.keys(), []);
|
||||||
},
|
},
|
||||||
"map(null) returns an empty map": function(d3) {
|
"map(null) returns an empty map": function(map) {
|
||||||
var map = d3.map(null);
|
var m = map(null);
|
||||||
assert.deepEqual(map.keys(), []);
|
assert.deepEqual(m.keys(), []);
|
||||||
},
|
},
|
||||||
"map(object) copies enumerable keys": function(d3) {
|
"map(object) copies enumerable keys": function(map) {
|
||||||
var map = d3.map({foo: 42});
|
var m = map({foo: 42});
|
||||||
assert.isTrue(map.has("foo"));
|
assert.isTrue(m.has("foo"));
|
||||||
assert.equal(map.get("foo"), 42);
|
assert.equal(m.get("foo"), 42);
|
||||||
var map = d3.map(Object.create(null, {foo: {value: 42, enumerable: true}}));
|
var m = map(Object.create(null, {foo: {value: 42, enumerable: true}}));
|
||||||
assert.isTrue(map.has("foo"));
|
assert.isTrue(m.has("foo"));
|
||||||
assert.equal(map.get("foo"), 42);
|
assert.equal(m.get("foo"), 42);
|
||||||
},
|
},
|
||||||
"map(object) copies inherited keys": function(d3) {
|
"map(object) copies inherited keys": function(map) {
|
||||||
function Foo() {}
|
function Foo() {}
|
||||||
Foo.prototype.foo = 42;
|
Foo.prototype.foo = 42;
|
||||||
var map = d3.map(Object.create({foo: 42}));
|
var m = map(Object.create({foo: 42}));
|
||||||
assert.isTrue(map.has("foo"));
|
assert.isTrue(m.has("foo"));
|
||||||
assert.equal(map.get("foo"), 42);
|
assert.equal(m.get("foo"), 42);
|
||||||
var map = d3.map(new Foo());
|
var m = map(new Foo());
|
||||||
assert.isTrue(map.has("foo"));
|
assert.isTrue(m.has("foo"));
|
||||||
assert.equal(map.get("foo"), 42);
|
assert.equal(m.get("foo"), 42);
|
||||||
},
|
},
|
||||||
"map(object) does not copy non-enumerable keys": function(d3) {
|
"map(object) does not copy non-enumerable keys": function(map) {
|
||||||
var map = d3.map({__proto__: 42}); // because __proto__ isn't enumerable
|
var m = map({__proto__: 42}); // because __proto__ isn't enumerable
|
||||||
assert.isFalse(map.has("__proto__"));
|
assert.isFalse(m.has("__proto__"));
|
||||||
assert.isUndefined(map.get("__proto__"));
|
assert.isUndefined(m.get("__proto__"));
|
||||||
var map = d3.map(Object.create(null, {foo: {value: 42, enumerable: false}}));
|
var m = map(Object.create(null, {foo: {value: 42, enumerable: false}}));
|
||||||
assert.isFalse(map.has("foo"));
|
assert.isFalse(m.has("foo"));
|
||||||
assert.isUndefined(map.get("foo"));
|
assert.isUndefined(m.get("foo"));
|
||||||
}
|
}
|
||||||
},
|
},
|
||||||
"forEach": {
|
"forEach": {
|
||||||
"empty maps have an empty keys array": function(d3) {
|
"empty maps have an empty keys array": function(map) {
|
||||||
var map = d3.map();
|
var m = map();
|
||||||
assert.deepEqual(map.entries(), []);
|
assert.deepEqual(m.entries(), []);
|
||||||
map.set("foo", "bar");
|
m.set("foo", "bar");
|
||||||
assert.deepEqual(map.entries(), [{key: "foo", value: "bar"}]);
|
assert.deepEqual(m.entries(), [{key: "foo", value: "bar"}]);
|
||||||
map.remove("foo");
|
m.remove("foo");
|
||||||
assert.deepEqual(map.entries(), []);
|
assert.deepEqual(m.entries(), []);
|
||||||
},
|
},
|
||||||
"keys are returned in arbitrary order": function(d3) {
|
"keys are returned in arbitrary order": function(map) {
|
||||||
var map = d3.map({foo: 1, bar: "42"});
|
var m = map({foo: 1, bar: "42"});
|
||||||
assert.deepEqual(map.entries().sort(ascendingByKey), [{key: "bar", value: "42"}, {key: "foo", value: 1}]);
|
assert.deepEqual(m.entries().sort(ascendingByKey), [{key: "bar", value: "42"}, {key: "foo", value: 1}]);
|
||||||
var map = d3.map({bar: "42", foo: 1});
|
var m = map({bar: "42", foo: 1});
|
||||||
assert.deepEqual(map.entries().sort(ascendingByKey), [{key: "bar", value: "42"}, {key: "foo", value: 1}]);
|
assert.deepEqual(m.entries().sort(ascendingByKey), [{key: "bar", value: "42"}, {key: "foo", value: 1}]);
|
||||||
},
|
},
|
||||||
"observes changes via set and remove": function(d3) {
|
"observes changes via set and remove": function(map) {
|
||||||
var map = d3.map({foo: 1, bar: "42"});
|
var m = map({foo: 1, bar: "42"});
|
||||||
assert.deepEqual(map.entries().sort(ascendingByKey), [{key: "bar", value: "42"}, {key: "foo", value: 1}]);
|
assert.deepEqual(m.entries().sort(ascendingByKey), [{key: "bar", value: "42"}, {key: "foo", value: 1}]);
|
||||||
map.remove("foo");
|
m.remove("foo");
|
||||||
assert.deepEqual(map.entries(), [{key: "bar", value: "42"}]);
|
assert.deepEqual(m.entries(), [{key: "bar", value: "42"}]);
|
||||||
map.set("bar", "bar");
|
m.set("bar", "bar");
|
||||||
assert.deepEqual(map.entries(), [{key: "bar", value: "bar"}]);
|
assert.deepEqual(m.entries(), [{key: "bar", value: "bar"}]);
|
||||||
map.set("foo", "foo");
|
m.set("foo", "foo");
|
||||||
assert.deepEqual(map.entries().sort(ascendingByKey), [{key: "bar", value: "bar"}, {key: "foo", value: "foo"}]);
|
assert.deepEqual(m.entries().sort(ascendingByKey), [{key: "bar", value: "bar"}, {key: "foo", value: "foo"}]);
|
||||||
map.remove("bar");
|
m.remove("bar");
|
||||||
assert.deepEqual(map.entries(), [{key: "foo", value: "foo"}]);
|
assert.deepEqual(m.entries(), [{key: "foo", value: "foo"}]);
|
||||||
map.remove("foo");
|
m.remove("foo");
|
||||||
assert.deepEqual(map.entries(), []);
|
assert.deepEqual(m.entries(), []);
|
||||||
map.remove("foo");
|
m.remove("foo");
|
||||||
assert.deepEqual(map.entries(), []);
|
assert.deepEqual(m.entries(), []);
|
||||||
}
|
}
|
||||||
},
|
},
|
||||||
"keys": {
|
"keys": {
|
||||||
"returns an array of string keys": function(d3) {
|
"returns an array of string keys": function(map) {
|
||||||
var map = d3.map({foo: 1, bar: "42"});
|
var m = map({foo: 1, bar: "42"});
|
||||||
assert.deepEqual(map.keys().sort(), ["bar", "foo"]);
|
assert.deepEqual(m.keys().sort(), ["bar", "foo"]);
|
||||||
}
|
}
|
||||||
},
|
},
|
||||||
"values": {
|
"values": {
|
||||||
"returns an array of arbitrary values": function(d3) {
|
"returns an array of arbitrary values": function(map) {
|
||||||
var map = d3.map({foo: 1, bar: "42"});
|
var m = map({foo: 1, bar: "42"});
|
||||||
assert.deepEqual(map.values().sort(), [1, "42"]);
|
assert.deepEqual(m.values().sort(), [1, "42"]);
|
||||||
}
|
}
|
||||||
},
|
},
|
||||||
"entries": {
|
"entries": {
|
||||||
"returns an array of key-value objects": function(d3) {
|
"returns an array of key-value objects": function(map) {
|
||||||
var map = d3.map({foo: 1, bar: "42"});
|
var m = map({foo: 1, bar: "42"});
|
||||||
assert.deepEqual(map.entries().sort(ascendingByKey), [{key: "bar", value: "42"}, {key: "foo", value: 1}]);
|
assert.deepEqual(m.entries().sort(ascendingByKey), [{key: "bar", value: "42"}, {key: "foo", value: 1}]);
|
||||||
}
|
}
|
||||||
},
|
},
|
||||||
"has": {
|
"has": {
|
||||||
"empty maps do not have object built-ins": function(d3) {
|
"empty maps do not have object built-ins": function(map) {
|
||||||
var map = d3.map();
|
var m = map();
|
||||||
assert.isFalse(map.has("__proto__"));
|
assert.isFalse(m.has("__proto__"));
|
||||||
assert.isFalse(map.has("hasOwnProperty"));
|
assert.isFalse(m.has("hasOwnProperty"));
|
||||||
},
|
},
|
||||||
"can has keys using built-in names": function(d3) {
|
"can has keys using built-in names": function(map) {
|
||||||
var map = d3.map();
|
var m = map();
|
||||||
map.set("__proto__", 42);
|
m.set("__proto__", 42);
|
||||||
assert.isTrue(map.has("__proto__"));
|
assert.isTrue(m.has("__proto__"));
|
||||||
},
|
},
|
||||||
"can has keys with null or undefined properties": function(d3) {
|
"can has keys with null or undefined properties": function(map) {
|
||||||
var map = d3.map();
|
var m = map();
|
||||||
map.set("", "");
|
m.set("", "");
|
||||||
map.set("null", null);
|
m.set("null", null);
|
||||||
map.set("undefined", undefined);
|
m.set("undefined", undefined);
|
||||||
assert.isTrue(map.has(""));
|
assert.isTrue(m.has(""));
|
||||||
assert.isTrue(map.has("null"));
|
assert.isTrue(m.has("null"));
|
||||||
assert.isTrue(map.has("undefined"));
|
assert.isTrue(m.has("undefined"));
|
||||||
},
|
},
|
||||||
"coerces keys to strings": function(d3) {
|
"coerces keys to strings": function(map) {
|
||||||
var map = d3.map({"42": "foo", "null": 1, "undefined": 2});
|
var m = map({"42": "foo", "null": 1, "undefined": 2});
|
||||||
assert.isTrue(map.has(42));
|
assert.isTrue(m.has(42));
|
||||||
assert.isTrue(map.has(null));
|
assert.isTrue(m.has(null));
|
||||||
assert.isTrue(map.has(undefined));
|
assert.isTrue(m.has(undefined));
|
||||||
},
|
},
|
||||||
"returns the latest value": function(d3) {
|
"returns the latest value": function(map) {
|
||||||
var map = d3.map({foo: 42});
|
var m = map({foo: 42});
|
||||||
assert.isTrue(map.has("foo"));
|
assert.isTrue(m.has("foo"));
|
||||||
map.set("foo", 43);
|
m.set("foo", 43);
|
||||||
assert.isTrue(map.has("foo"));
|
assert.isTrue(m.has("foo"));
|
||||||
map.remove("foo");
|
m.remove("foo");
|
||||||
assert.isFalse(map.has("foo"));
|
assert.isFalse(m.has("foo"));
|
||||||
map.set("foo", "bar");
|
m.set("foo", "bar");
|
||||||
assert.isTrue(map.has("foo"));
|
assert.isTrue(m.has("foo"));
|
||||||
},
|
},
|
||||||
"returns undefined for missing keys": function(d3) {
|
"returns undefined for missing keys": function(map) {
|
||||||
var map = d3.map({foo: 42});
|
var m = map({foo: 42});
|
||||||
assert.isFalse(map.has("bar"));
|
assert.isFalse(m.has("bar"));
|
||||||
}
|
}
|
||||||
},
|
},
|
||||||
"get": {
|
"get": {
|
||||||
"empty maps do not have object built-ins": function(d3) {
|
"empty maps do not have object built-ins": function(map) {
|
||||||
var map = d3.map();
|
var m = map();
|
||||||
assert.isUndefined(map.get("__proto__"));
|
assert.isUndefined(m.get("__proto__"));
|
||||||
assert.isUndefined(map.get("hasOwnProperty"));
|
assert.isUndefined(m.get("hasOwnProperty"));
|
||||||
},
|
},
|
||||||
"can get keys using built-in names": function(d3) {
|
"can get keys using built-in names": function(map) {
|
||||||
var map = d3.map();
|
var m = map();
|
||||||
map.set("__proto__", 42);
|
m.set("__proto__", 42);
|
||||||
assert.equal(map.get("__proto__"), 42);
|
assert.equal(m.get("__proto__"), 42);
|
||||||
},
|
},
|
||||||
"coerces keys to strings": function(d3) {
|
"coerces keys to strings": function(map) {
|
||||||
var map = d3.map({"42": 1, "null": 2, "undefined": 3});
|
var m = map({"42": 1, "null": 2, "undefined": 3});
|
||||||
assert.equal(map.get(42), 1);
|
assert.equal(m.get(42), 1);
|
||||||
assert.equal(map.get(null), 2);
|
assert.equal(m.get(null), 2);
|
||||||
assert.equal(map.get(undefined), 3);
|
assert.equal(m.get(undefined), 3);
|
||||||
},
|
},
|
||||||
"returns the latest value": function(d3) {
|
"returns the latest value": function(map) {
|
||||||
var map = d3.map({foo: 42});
|
var m = map({foo: 42});
|
||||||
assert.equal(map.get("foo"), 42);
|
assert.equal(m.get("foo"), 42);
|
||||||
map.set("foo", 43);
|
m.set("foo", 43);
|
||||||
assert.equal(map.get("foo"), 43);
|
assert.equal(m.get("foo"), 43);
|
||||||
map.remove("foo");
|
m.remove("foo");
|
||||||
assert.isUndefined(map.get("foo"));
|
assert.isUndefined(m.get("foo"));
|
||||||
map.set("foo", "bar");
|
m.set("foo", "bar");
|
||||||
assert.equal(map.get("foo"), "bar");
|
assert.equal(m.get("foo"), "bar");
|
||||||
},
|
},
|
||||||
"returns undefined for missing keys": function(d3) {
|
"returns undefined for missing keys": function(map) {
|
||||||
var map = d3.map({foo: 42});
|
var m = map({foo: 42});
|
||||||
assert.isUndefined(map.get("bar"));
|
assert.isUndefined(m.get("bar"));
|
||||||
}
|
}
|
||||||
},
|
},
|
||||||
"set": {
|
"set": {
|
||||||
"returns the set value": function(d3) {
|
"returns the set value": function(map) {
|
||||||
var map = d3.map();
|
var m = map();
|
||||||
assert.equal(map.set("foo", 42), 42);
|
assert.equal(m.set("foo", 42), 42);
|
||||||
},
|
},
|
||||||
"can set keys using built-in names": function(d3) {
|
"can set keys using built-in names": function(map) {
|
||||||
var map = d3.map();
|
var m = map();
|
||||||
map.set("__proto__", 42);
|
m.set("__proto__", 42);
|
||||||
assert.equal(map.get("__proto__"), 42);
|
assert.equal(m.get("__proto__"), 42);
|
||||||
},
|
},
|
||||||
"coerces keys to strings": function(d3) {
|
"coerces keys to strings": function(map) {
|
||||||
var map = d3.map();
|
var m = map();
|
||||||
map.set(42, 1);
|
m.set(42, 1);
|
||||||
assert.equal(map.get(42), 1);
|
assert.equal(m.get(42), 1);
|
||||||
map.set(null, 2);
|
m.set(null, 2);
|
||||||
assert.equal(map.get(null), 2);
|
assert.equal(m.get(null), 2);
|
||||||
map.set(undefined, 3);
|
m.set(undefined, 3);
|
||||||
assert.equal(map.get(undefined), 3);
|
assert.equal(m.get(undefined), 3);
|
||||||
assert.deepEqual(map.keys().sort(), ["42", "null", "undefined"]);
|
assert.deepEqual(m.keys().sort(), ["42", "null", "undefined"]);
|
||||||
},
|
},
|
||||||
"can replace values": function(d3) {
|
"can replace values": function(map) {
|
||||||
var map = d3.map({foo: 42});
|
var m = map({foo: 42});
|
||||||
assert.equal(map.get("foo"), 42);
|
assert.equal(m.get("foo"), 42);
|
||||||
map.set("foo", 43);
|
m.set("foo", 43);
|
||||||
assert.equal(map.get("foo"), 43);
|
assert.equal(m.get("foo"), 43);
|
||||||
map.set("foo", "bar");
|
m.set("foo", "bar");
|
||||||
assert.equal(map.get("foo"), "bar");
|
assert.equal(m.get("foo"), "bar");
|
||||||
},
|
},
|
||||||
"can set null, undefined or empty string values": function(d3) {
|
"can set null, undefined or empty string values": function(map) {
|
||||||
var map = d3.map();
|
var m = map();
|
||||||
map.set("", "");
|
m.set("", "");
|
||||||
map.set("null", null);
|
m.set("null", null);
|
||||||
map.set("undefined", undefined);
|
m.set("undefined", undefined);
|
||||||
assert.equal(map.get(""), "");
|
assert.equal(m.get(""), "");
|
||||||
assert.isNull(map.get("null"));
|
assert.isNull(m.get("null"));
|
||||||
assert.isUndefined(map.get("undefined"));
|
assert.isUndefined(m.get("undefined"));
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
|
||||||
|
|
@ -1,4 +1,5 @@
|
||||||
var vows = require("vows"),
|
var vows = require("vows"),
|
||||||
|
d3 = require("../../"),
|
||||||
load = require("../load"),
|
load = require("../load"),
|
||||||
assert = require("../env-assert");
|
assert = require("../env-assert");
|
||||||
|
|
||||||
|
|
@ -6,40 +7,40 @@ var suite = vows.describe("d3.max");
|
||||||
|
|
||||||
suite.addBatch({
|
suite.addBatch({
|
||||||
"max": {
|
"max": {
|
||||||
topic: load("arrays/max", "arrays/min"),
|
topic: load("arrays/max").expression("d3.max"),
|
||||||
"returns the greatest numeric value for numbers": function(d3) {
|
"returns the greatest numeric value for numbers": function(max) {
|
||||||
assert.equal(d3.max([1]), 1);
|
assert.equal(max([1]), 1);
|
||||||
assert.equal(d3.max([5, 1, 2, 3, 4]), 5);
|
assert.equal(max([5, 1, 2, 3, 4]), 5);
|
||||||
assert.equal(d3.max([20, 3]), 20);
|
assert.equal(max([20, 3]), 20);
|
||||||
assert.equal(d3.max([3, 20]), 20);
|
assert.equal(max([3, 20]), 20);
|
||||||
},
|
},
|
||||||
"returns the greatest lexicographic value for strings": function(d3) {
|
"returns the greatest lexicographic value for strings": function(max) {
|
||||||
assert.equal(d3.max(["c", "a", "b"]), "c");
|
assert.equal(max(["c", "a", "b"]), "c");
|
||||||
assert.equal(d3.max(["20", "3"]), "3");
|
assert.equal(max(["20", "3"]), "3");
|
||||||
assert.equal(d3.max(["3", "20"]), "3");
|
assert.equal(max(["3", "20"]), "3");
|
||||||
},
|
},
|
||||||
"ignores null, undefined and NaN": function(d3) {
|
"ignores null, undefined and NaN": function(max) {
|
||||||
assert.equal(d3.max([NaN, 1, 2, 3, 4, 5]), 5);
|
assert.equal(max([NaN, 1, 2, 3, 4, 5]), 5);
|
||||||
assert.equal(d3.max([1, 2, 3, 4, 5, NaN]), 5);
|
assert.equal(max([1, 2, 3, 4, 5, NaN]), 5);
|
||||||
assert.equal(d3.max([10, null, 3, undefined, 5, NaN]), 10);
|
assert.equal(max([10, null, 3, undefined, 5, NaN]), 10);
|
||||||
assert.equal(d3.max([-1, null, -3, undefined, -5, NaN]), -1);
|
assert.equal(max([-1, null, -3, undefined, -5, NaN]), -1);
|
||||||
},
|
},
|
||||||
"compares heterogenous types as numbers": function(d3) {
|
"compares heterogenous types as numbers": function(max) {
|
||||||
assert.strictEqual(d3.max([20, "3"]), 20);
|
assert.strictEqual(max([20, "3"]), 20);
|
||||||
assert.strictEqual(d3.max(["20", 3]), "20");
|
assert.strictEqual(max(["20", 3]), "20");
|
||||||
assert.strictEqual(d3.max([3, "20"]), "20");
|
assert.strictEqual(max([3, "20"]), "20");
|
||||||
assert.strictEqual(d3.max(["3", 20]), 20);
|
assert.strictEqual(max(["3", 20]), 20);
|
||||||
},
|
},
|
||||||
"returns undefined for empty array": function(d3) {
|
"returns undefined for empty array": function(max) {
|
||||||
assert.isUndefined(d3.max([]));
|
assert.isUndefined(max([]));
|
||||||
assert.isUndefined(d3.max([null]));
|
assert.isUndefined(max([null]));
|
||||||
assert.isUndefined(d3.max([undefined]));
|
assert.isUndefined(max([undefined]));
|
||||||
assert.isUndefined(d3.max([NaN]));
|
assert.isUndefined(max([NaN]));
|
||||||
assert.isUndefined(d3.max([NaN, NaN]));
|
assert.isUndefined(max([NaN, NaN]));
|
||||||
},
|
},
|
||||||
"applies the optional accessor function": function(d3) {
|
"applies the optional accessor function": function(max) {
|
||||||
assert.equal(d3.max([[1, 2, 3, 4, 5], [2, 4, 6, 8, 10]], function(d) { return d3.min(d); }), 2);
|
assert.equal(max([[1, 2, 3, 4, 5], [2, 4, 6, 8, 10]], function(d) { return d3.min(d); }), 2);
|
||||||
assert.equal(d3.max([1, 2, 3, 4, 5], function(d, i) { return i; }), 4);
|
assert.equal(max([1, 2, 3, 4, 5], function(d, i) { return i; }), 4);
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
});
|
});
|
||||||
|
|
|
||||||
|
|
@ -6,32 +6,32 @@ var suite = vows.describe("d3.mean");
|
||||||
|
|
||||||
suite.addBatch({
|
suite.addBatch({
|
||||||
"mean": {
|
"mean": {
|
||||||
topic: load("arrays/mean"),
|
topic: load("arrays/mean").expression("d3.mean"),
|
||||||
"returns the mean value for numbers": function(d3) {
|
"returns the mean value for numbers": function(mean) {
|
||||||
assert.equal(d3.mean([1]), 1);
|
assert.equal(mean([1]), 1);
|
||||||
assert.equal(d3.mean([5, 1, 2, 3, 4]), 3);
|
assert.equal(mean([5, 1, 2, 3, 4]), 3);
|
||||||
assert.equal(d3.mean([20, 3]), 11.5);
|
assert.equal(mean([20, 3]), 11.5);
|
||||||
assert.equal(d3.mean([3, 20]), 11.5);
|
assert.equal(mean([3, 20]), 11.5);
|
||||||
},
|
},
|
||||||
"ignores null, undefined and NaN": function(d3) {
|
"ignores null, undefined and NaN": function(mean) {
|
||||||
assert.equal(d3.mean([NaN, 1, 2, 3, 4, 5]), 3);
|
assert.equal(mean([NaN, 1, 2, 3, 4, 5]), 3);
|
||||||
assert.equal(d3.mean([1, 2, 3, 4, 5, NaN]), 3);
|
assert.equal(mean([1, 2, 3, 4, 5, NaN]), 3);
|
||||||
assert.equal(d3.mean([10, null, 3, undefined, 5, NaN]), 6);
|
assert.equal(mean([10, null, 3, undefined, 5, NaN]), 6);
|
||||||
},
|
},
|
||||||
"can handle large numbers without overflowing": function(d3) {
|
"can handle large numbers without overflowing": function(mean) {
|
||||||
assert.equal(d3.mean([Number.MAX_VALUE, Number.MAX_VALUE]), Number.MAX_VALUE);
|
assert.equal(mean([Number.MAX_VALUE, Number.MAX_VALUE]), Number.MAX_VALUE);
|
||||||
assert.equal(d3.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(d3) {
|
"returns undefined for empty array": function(mean) {
|
||||||
assert.isUndefined(d3.mean([]));
|
assert.isUndefined(mean([]));
|
||||||
assert.isUndefined(d3.mean([null]));
|
assert.isUndefined(mean([null]));
|
||||||
assert.isUndefined(d3.mean([undefined]));
|
assert.isUndefined(mean([undefined]));
|
||||||
assert.isUndefined(d3.mean([NaN]));
|
assert.isUndefined(mean([NaN]));
|
||||||
assert.isUndefined(d3.mean([NaN, NaN]));
|
assert.isUndefined(mean([NaN, NaN]));
|
||||||
},
|
},
|
||||||
"applies the optional accessor function": function(d3) {
|
"applies the optional accessor function": function(mean) {
|
||||||
assert.equal(d3.mean([[1, 2, 3, 4, 5], [2, 4, 6, 8, 10]], function(d) { return d3.mean(d); }), 4.5);
|
assert.equal(mean([[1, 2, 3, 4, 5], [2, 4, 6, 8, 10]], function(d) { return mean(d); }), 4.5);
|
||||||
assert.equal(d3.mean([1, 2, 3, 4, 5], function(d, i) { return i; }), 2);
|
assert.equal(mean([1, 2, 3, 4, 5], function(d, i) { return i; }), 2);
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
});
|
});
|
||||||
|
|
|
||||||
|
|
@ -6,32 +6,32 @@ var suite = vows.describe("d3.median");
|
||||||
|
|
||||||
suite.addBatch({
|
suite.addBatch({
|
||||||
"median": {
|
"median": {
|
||||||
topic: load("arrays/median"),
|
topic: load("arrays/median").expression("d3.median"),
|
||||||
"returns the median value for numbers": function(d3) {
|
"returns the median value for numbers": function(median) {
|
||||||
assert.equal(d3.median([1]), 1);
|
assert.equal(median([1]), 1);
|
||||||
assert.equal(d3.median([5, 1, 2, 3, 4]), 3);
|
assert.equal(median([5, 1, 2, 3, 4]), 3);
|
||||||
assert.equal(d3.median([20, 3]), 11.5);
|
assert.equal(median([20, 3]), 11.5);
|
||||||
assert.equal(d3.median([3, 20]), 11.5);
|
assert.equal(median([3, 20]), 11.5);
|
||||||
},
|
},
|
||||||
"ignores null, undefined and NaN": function(d3) {
|
"ignores null, undefined and NaN": function(median) {
|
||||||
assert.equal(d3.median([NaN, 1, 2, 3, 4, 5]), 3);
|
assert.equal(median([NaN, 1, 2, 3, 4, 5]), 3);
|
||||||
assert.equal(d3.median([1, 2, 3, 4, 5, NaN]), 3);
|
assert.equal(median([1, 2, 3, 4, 5, NaN]), 3);
|
||||||
assert.equal(d3.median([10, null, 3, undefined, 5, NaN]), 5);
|
assert.equal(median([10, null, 3, undefined, 5, NaN]), 5);
|
||||||
},
|
},
|
||||||
"can handle large numbers without overflowing": function(d3) {
|
"can handle large numbers without overflowing": function(median) {
|
||||||
assert.equal(d3.median([Number.MAX_VALUE, Number.MAX_VALUE]), Number.MAX_VALUE);
|
assert.equal(median([Number.MAX_VALUE, Number.MAX_VALUE]), Number.MAX_VALUE);
|
||||||
assert.equal(d3.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(d3) {
|
"returns undefined for empty array": function(median) {
|
||||||
assert.isUndefined(d3.median([]));
|
assert.isUndefined(median([]));
|
||||||
assert.isUndefined(d3.median([null]));
|
assert.isUndefined(median([null]));
|
||||||
assert.isUndefined(d3.median([undefined]));
|
assert.isUndefined(median([undefined]));
|
||||||
assert.isUndefined(d3.median([NaN]));
|
assert.isUndefined(median([NaN]));
|
||||||
assert.isUndefined(d3.median([NaN, NaN]));
|
assert.isUndefined(median([NaN, NaN]));
|
||||||
},
|
},
|
||||||
"applies the optional accessor function": function(d3) {
|
"applies the optional accessor function": function(median) {
|
||||||
assert.equal(d3.median([[1, 2, 3, 4, 5], [2, 4, 6, 8, 10]], function(d) { return d3.median(d); }), 4.5);
|
assert.equal(median([[1, 2, 3, 4, 5], [2, 4, 6, 8, 10]], function(d) { return median(d); }), 4.5);
|
||||||
assert.equal(d3.median([1, 2, 3, 4, 5], function(d, i) { return i; }), 2);
|
assert.equal(median([1, 2, 3, 4, 5], function(d, i) { return i; }), 2);
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
});
|
});
|
||||||
|
|
|
||||||
|
|
@ -6,18 +6,18 @@ var suite = vows.describe("d3.merge");
|
||||||
|
|
||||||
suite.addBatch({
|
suite.addBatch({
|
||||||
"merge": {
|
"merge": {
|
||||||
topic: load("arrays/merge"),
|
topic: load("arrays/merge").expression("d3.merge"),
|
||||||
"merges an array of arrays": function(d3) {
|
"merges an array of arrays": function(merge) {
|
||||||
var a = {}, b = {}, c = {}, d = {}, e = {}, f = {};
|
var a = {}, b = {}, c = {}, d = {}, e = {}, f = {};
|
||||||
assert.deepEqual(d3.merge([[a], [b, c], [d, e, f]]), [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(d3) {
|
"returns a new array": function(merge) {
|
||||||
var input = [[1, 2, 3], [4, 5], [6]];
|
var input = [[1, 2, 3], [4, 5], [6]];
|
||||||
assert.isFalse(d3.merge(input) === input);
|
assert.isFalse(merge(input) === input);
|
||||||
},
|
},
|
||||||
"does not modify the input arrays": function(d3) {
|
"does not modify the input arrays": function(merge) {
|
||||||
var input = [[1, 2, 3], [4, 5], [6]];
|
var input = [[1, 2, 3], [4, 5], [6]];
|
||||||
d3.merge(input);
|
merge(input);
|
||||||
assert.deepEqual(input, [[1, 2, 3], [4, 5], [6]]);
|
assert.deepEqual(input, [[1, 2, 3], [4, 5], [6]]);
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
|
||||||
|
|
@ -1,4 +1,5 @@
|
||||||
var vows = require("vows"),
|
var vows = require("vows"),
|
||||||
|
d3 = require("../../"),
|
||||||
load = require("../load"),
|
load = require("../load"),
|
||||||
assert = require("../env-assert");
|
assert = require("../env-assert");
|
||||||
|
|
||||||
|
|
@ -6,39 +7,39 @@ var suite = vows.describe("d3.min");
|
||||||
|
|
||||||
suite.addBatch({
|
suite.addBatch({
|
||||||
"min": {
|
"min": {
|
||||||
topic: load("arrays/min", "arrays/max"),
|
topic: load("arrays/min").expression("d3.min"),
|
||||||
"returns the least numeric value for numbers": function(d3) {
|
"returns the least numeric value for numbers": function(min) {
|
||||||
assert.equal(d3.min([1]), 1);
|
assert.equal(min([1]), 1);
|
||||||
assert.equal(d3.min([5, 1, 2, 3, 4]), 1);
|
assert.equal(min([5, 1, 2, 3, 4]), 1);
|
||||||
assert.equal(d3.min([20, 3]), 3);
|
assert.equal(min([20, 3]), 3);
|
||||||
assert.equal(d3.min([3, 20]), 3);
|
assert.equal(min([3, 20]), 3);
|
||||||
},
|
},
|
||||||
"returns the least lexicographic value for strings": function(d3) {
|
"returns the least lexicographic value for strings": function(min) {
|
||||||
assert.equal(d3.min(["c", "a", "b"]), "a");
|
assert.equal(min(["c", "a", "b"]), "a");
|
||||||
assert.equal(d3.min(["20", "3"]), "20");
|
assert.equal(min(["20", "3"]), "20");
|
||||||
assert.equal(d3.min(["3", "20"]), "20");
|
assert.equal(min(["3", "20"]), "20");
|
||||||
},
|
},
|
||||||
"ignores null, undefined and NaN": function(d3) {
|
"ignores null, undefined and NaN": function(min) {
|
||||||
assert.equal(d3.min([NaN, 1, 2, 3, 4, 5]), 1);
|
assert.equal(min([NaN, 1, 2, 3, 4, 5]), 1);
|
||||||
assert.equal(d3.min([1, 2, 3, 4, 5, NaN]), 1);
|
assert.equal(min([1, 2, 3, 4, 5, NaN]), 1);
|
||||||
assert.equal(d3.min([10, null, 3, undefined, 5, NaN]), 3);
|
assert.equal(min([10, null, 3, undefined, 5, NaN]), 3);
|
||||||
},
|
},
|
||||||
"compares heterogenous types as numbers": function(d3) {
|
"compares heterogenous types as numbers": function(min) {
|
||||||
assert.strictEqual(d3.min([20, "3"]), "3");
|
assert.strictEqual(min([20, "3"]), "3");
|
||||||
assert.strictEqual(d3.min(["20", 3]), 3);
|
assert.strictEqual(min(["20", 3]), 3);
|
||||||
assert.strictEqual(d3.min([3, "20"]), 3);
|
assert.strictEqual(min([3, "20"]), 3);
|
||||||
assert.strictEqual(d3.min(["3", 20]), "3");
|
assert.strictEqual(min(["3", 20]), "3");
|
||||||
},
|
},
|
||||||
"returns undefined for empty array": function(d3) {
|
"returns undefined for empty array": function(min) {
|
||||||
assert.isUndefined(d3.min([]));
|
assert.isUndefined(min([]));
|
||||||
assert.isUndefined(d3.min([null]));
|
assert.isUndefined(min([null]));
|
||||||
assert.isUndefined(d3.min([undefined]));
|
assert.isUndefined(min([undefined]));
|
||||||
assert.isUndefined(d3.min([NaN]));
|
assert.isUndefined(min([NaN]));
|
||||||
assert.isUndefined(d3.min([NaN, NaN]));
|
assert.isUndefined(min([NaN, NaN]));
|
||||||
},
|
},
|
||||||
"applies the optional accessor function": function(d3) {
|
"applies the optional accessor function": function(min) {
|
||||||
assert.equal(d3.min([[1, 2, 3, 4, 5], [2, 4, 6, 8, 10]], function(d) { return d3.max(d); }), 5);
|
assert.equal(min([[1, 2, 3, 4, 5], [2, 4, 6, 8, 10]], function(d) { return d3.max(d); }), 5);
|
||||||
assert.equal(d3.min([1, 2, 3, 4, 5], function(d, i) { return i; }), 0);
|
assert.equal(min([1, 2, 3, 4, 5], function(d, i) { return i; }), 0);
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
});
|
});
|
||||||
|
|
|
||||||
|
|
@ -1,4 +1,5 @@
|
||||||
var vows = require("vows"),
|
var vows = require("vows"),
|
||||||
|
d3 = require("../../"),
|
||||||
load = require("../load"),
|
load = require("../load"),
|
||||||
assert = require("../env-assert");
|
assert = require("../env-assert");
|
||||||
|
|
||||||
|
|
@ -6,17 +7,17 @@ var suite = vows.describe("d3.nest");
|
||||||
|
|
||||||
suite.addBatch({
|
suite.addBatch({
|
||||||
"entries": {
|
"entries": {
|
||||||
topic: load("arrays/nest", "arrays/ascending", "arrays/descending", "arrays/sum"),
|
topic: load("arrays/nest").expression("d3.nest"),
|
||||||
"returns an array of each distinct key in arbitrary order": function(d3) {
|
"returns an array of each distinct key in arbitrary order": function(nest) {
|
||||||
var keys = d3.nest()
|
var keys = nest()
|
||||||
.key(function(d) { return d.foo; })
|
.key(function(d) { return d.foo; })
|
||||||
.entries([{foo: 1}, {foo: 1}, {foo: 2}])
|
.entries([{foo: 1}, {foo: 1}, {foo: 2}])
|
||||||
.map(function(d) { return d.key; })
|
.map(function(d) { return d.key; })
|
||||||
.sort(d3.ascending);
|
.sort(d3.ascending);
|
||||||
assert.deepEqual(keys, ["1", "2"]);
|
assert.deepEqual(keys, ["1", "2"]);
|
||||||
},
|
},
|
||||||
"each entry is a key-values object, with values in input order": function(d3) {
|
"each entry is a key-values object, with values in input order": function(nest) {
|
||||||
var entries = d3.nest()
|
var entries = nest()
|
||||||
.key(function(d) { return d.foo; })
|
.key(function(d) { return d.foo; })
|
||||||
.entries([{foo: 1, bar: 0}, {foo: 2}, {foo: 1, bar: 1}]);
|
.entries([{foo: 1, bar: 0}, {foo: 2}, {foo: 1, bar: 1}]);
|
||||||
assert.deepEqual(entries, [
|
assert.deepEqual(entries, [
|
||||||
|
|
@ -24,15 +25,15 @@ suite.addBatch({
|
||||||
{key: "2", values: [{foo: 2}]}
|
{key: "2", values: [{foo: 2}]}
|
||||||
]);
|
]);
|
||||||
},
|
},
|
||||||
"keys can be sorted using an optional comparator": function(d3) {
|
"keys can be sorted using an optional comparator": function(nest) {
|
||||||
var keys = d3.nest()
|
var keys = nest()
|
||||||
.key(function(d) { return d.foo; }).sortKeys(d3.descending)
|
.key(function(d) { return d.foo; }).sortKeys(d3.descending)
|
||||||
.entries([{foo: 1}, {foo: 1}, {foo: 2}])
|
.entries([{foo: 1}, {foo: 1}, {foo: 2}])
|
||||||
.map(function(d) { return d.key; });
|
.map(function(d) { return d.key; });
|
||||||
assert.deepEqual(keys, ["2", "1"]);
|
assert.deepEqual(keys, ["2", "1"]);
|
||||||
},
|
},
|
||||||
"values can be sorted using an optional comparator": function(d3) {
|
"values can be sorted using an optional comparator": function(nest) {
|
||||||
var entries = d3.nest()
|
var entries = nest()
|
||||||
.key(function(d) { return d.foo; })
|
.key(function(d) { return d.foo; })
|
||||||
.sortValues(function(a, b) { return a.bar - b.bar; })
|
.sortValues(function(a, b) { return a.bar - b.bar; })
|
||||||
.entries([{foo: 1, bar: 2}, {foo: 1, bar: 0}, {foo: 1, bar: 1}, {foo: 2}]);
|
.entries([{foo: 1, bar: 2}, {foo: 1, bar: 0}, {foo: 1, bar: 1}, {foo: 2}]);
|
||||||
|
|
@ -41,8 +42,8 @@ suite.addBatch({
|
||||||
{key: "2", values: [{foo: 2}]}
|
{key: "2", values: [{foo: 2}]}
|
||||||
]);
|
]);
|
||||||
},
|
},
|
||||||
"values can be aggregated using an optional rollup": function(d3) {
|
"values can be aggregated using an optional rollup": function(nest) {
|
||||||
var entries = d3.nest()
|
var entries = nest()
|
||||||
.key(function(d) { return d.foo; })
|
.key(function(d) { return d.foo; })
|
||||||
.rollup(function(values) { return d3.sum(values, function(d) { return d.bar; }); })
|
.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}]);
|
.entries([{foo: 1, bar: 2}, {foo: 1, bar: 0}, {foo: 1, bar: 1}, {foo: 2}]);
|
||||||
|
|
@ -51,8 +52,8 @@ suite.addBatch({
|
||||||
{key: "2", values: 0}
|
{key: "2", values: 0}
|
||||||
]);
|
]);
|
||||||
},
|
},
|
||||||
"multiple key functions can be specified": function(d3) {
|
"multiple key functions can be specified": function(nest) {
|
||||||
var entries = d3.nest()
|
var entries = nest()
|
||||||
.key(function(d) { return d[0]; }).sortKeys(d3.ascending)
|
.key(function(d) { return d[0]; }).sortKeys(d3.ascending)
|
||||||
.key(function(d) { return d[1]; }).sortKeys(d3.ascending)
|
.key(function(d) { return d[1]; }).sortKeys(d3.ascending)
|
||||||
.entries([[0, 1], [0, 2], [1, 1], [1, 2], [0, 2]]);
|
.entries([[0, 1], [0, 2], [1, 1], [1, 2], [0, 2]]);
|
||||||
|
|
@ -67,8 +68,8 @@ suite.addBatch({
|
||||||
]}
|
]}
|
||||||
]);
|
]);
|
||||||
},
|
},
|
||||||
"the rollup function only applies to leaf values": function(d3) {
|
"the rollup function only applies to leaf values": function(nest) {
|
||||||
var entries = d3.nest()
|
var entries = nest()
|
||||||
.key(function(d) { return d[0]; }).sortKeys(d3.ascending)
|
.key(function(d) { return d[0]; }).sortKeys(d3.ascending)
|
||||||
.key(function(d) { return d[1]; }).sortKeys(d3.ascending)
|
.key(function(d) { return d[1]; }).sortKeys(d3.ascending)
|
||||||
.rollup(function(values) { return values.length; })
|
.rollup(function(values) { return values.length; })
|
||||||
|
|
@ -84,8 +85,8 @@ suite.addBatch({
|
||||||
]}
|
]}
|
||||||
]);
|
]);
|
||||||
},
|
},
|
||||||
"the value comparator only applies to leaf values": function(d3) {
|
"the value comparator only applies to leaf values": function(nest) {
|
||||||
var entries = d3.nest()
|
var entries = nest()
|
||||||
.key(function(d) { return d[0]; }).sortKeys(d3.ascending)
|
.key(function(d) { return d[0]; }).sortKeys(d3.ascending)
|
||||||
.key(function(d) { return d[1]; }).sortKeys(d3.ascending)
|
.key(function(d) { return d[1]; }).sortKeys(d3.ascending)
|
||||||
.sortValues(function(a, b) { return a[2] - b[2]; })
|
.sortValues(function(a, b) { return a[2] - b[2]; })
|
||||||
|
|
@ -101,8 +102,8 @@ suite.addBatch({
|
||||||
]}
|
]}
|
||||||
]);
|
]);
|
||||||
},
|
},
|
||||||
"the key comparator only applies to the last-specified key": function(d3) {
|
"the key comparator only applies to the last-specified key": function(nest) {
|
||||||
var entries = d3.nest()
|
var entries = nest()
|
||||||
.key(function(d) { return d[0]; }).sortKeys(d3.ascending)
|
.key(function(d) { return d[0]; }).sortKeys(d3.ascending)
|
||||||
.key(function(d) { return d[1]; }).sortKeys(d3.descending)
|
.key(function(d) { return d[1]; }).sortKeys(d3.descending)
|
||||||
.entries([[0, 1], [0, 2], [1, 1], [1, 2], [0, 2]]);
|
.entries([[0, 1], [0, 2], [1, 1], [1, 2], [0, 2]]);
|
||||||
|
|
@ -116,7 +117,7 @@ suite.addBatch({
|
||||||
{key: "1", values: [[1, 1]]}
|
{key: "1", values: [[1, 1]]}
|
||||||
]}
|
]}
|
||||||
]);
|
]);
|
||||||
var entries = d3.nest()
|
var entries = nest()
|
||||||
.key(function(d) { return d[0]; }).sortKeys(d3.descending)
|
.key(function(d) { return d[0]; }).sortKeys(d3.descending)
|
||||||
.key(function(d) { return d[1]; }).sortKeys(d3.ascending)
|
.key(function(d) { return d[1]; }).sortKeys(d3.ascending)
|
||||||
.entries([[0, 1], [0, 2], [1, 1], [1, 2], [0, 2]]);
|
.entries([[0, 1], [0, 2], [1, 1], [1, 2], [0, 2]]);
|
||||||
|
|
@ -131,18 +132,18 @@ suite.addBatch({
|
||||||
]}
|
]}
|
||||||
]);
|
]);
|
||||||
},
|
},
|
||||||
"if no keys are specified, the input array is returned": function(d3) {
|
"if no keys are specified, the input array is returned": function(nest) {
|
||||||
var array = [new Object()];
|
var array = [new Object()];
|
||||||
assert.strictEqual(d3.nest().entries(array), array);
|
assert.strictEqual(nest().entries(array), array);
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
});
|
});
|
||||||
|
|
||||||
suite.addBatch({
|
suite.addBatch({
|
||||||
"map": {
|
"map": {
|
||||||
topic: load("arrays/nest", "arrays/ascending", "arrays/descending", "arrays/sum"),
|
topic: load("arrays/nest").expression("d3.nest"),
|
||||||
"returns a map of each distinct key": function(d3) {
|
"returns a map of each distinct key": function(nest) {
|
||||||
var map = d3.nest()
|
var map = nest()
|
||||||
.key(function(d) { return d.foo; })
|
.key(function(d) { return d.foo; })
|
||||||
.map([{foo: 1, bar: 0}, {foo: 2}, {foo: 1, bar: 1}]);
|
.map([{foo: 1, bar: 0}, {foo: 2}, {foo: 1, bar: 1}]);
|
||||||
assert.deepEqual(map, {
|
assert.deepEqual(map, {
|
||||||
|
|
@ -150,8 +151,8 @@ suite.addBatch({
|
||||||
"2": [{foo: 2}]
|
"2": [{foo: 2}]
|
||||||
});
|
});
|
||||||
},
|
},
|
||||||
"values can be sorted using an optional comparator": function(d3) {
|
"values can be sorted using an optional comparator": function(nest) {
|
||||||
var map = d3.nest()
|
var map = nest()
|
||||||
.key(function(d) { return d.foo; })
|
.key(function(d) { return d.foo; })
|
||||||
.sortValues(function(a, b) { return a.bar - b.bar; })
|
.sortValues(function(a, b) { return a.bar - b.bar; })
|
||||||
.map([{foo: 1, bar: 2}, {foo: 1, bar: 0}, {foo: 1, bar: 1}, {foo: 2}]);
|
.map([{foo: 1, bar: 2}, {foo: 1, bar: 0}, {foo: 1, bar: 1}, {foo: 2}]);
|
||||||
|
|
@ -160,8 +161,8 @@ suite.addBatch({
|
||||||
"2": [{foo: 2}]
|
"2": [{foo: 2}]
|
||||||
});
|
});
|
||||||
},
|
},
|
||||||
"values can be aggregated using an optional rollup": function(d3) {
|
"values can be aggregated using an optional rollup": function(nest) {
|
||||||
var map = d3.nest()
|
var map = nest()
|
||||||
.key(function(d) { return d.foo; })
|
.key(function(d) { return d.foo; })
|
||||||
.rollup(function(values) { return d3.sum(values, function(d) { return d.bar; }); })
|
.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}]);
|
.map([{foo: 1, bar: 2}, {foo: 1, bar: 0}, {foo: 1, bar: 1}, {foo: 2}]);
|
||||||
|
|
@ -170,8 +171,8 @@ suite.addBatch({
|
||||||
"2": 0
|
"2": 0
|
||||||
});
|
});
|
||||||
},
|
},
|
||||||
"multiple key functions can be specified": function(d3) {
|
"multiple key functions can be specified": function(nest) {
|
||||||
var map = d3.nest()
|
var map = nest()
|
||||||
.key(function(d) { return d[0]; }).sortKeys(d3.ascending)
|
.key(function(d) { return d[0]; }).sortKeys(d3.ascending)
|
||||||
.key(function(d) { return d[1]; }).sortKeys(d3.ascending)
|
.key(function(d) { return d[1]; }).sortKeys(d3.ascending)
|
||||||
.map([[0, 1], [0, 2], [1, 1], [1, 2], [0, 2]]);
|
.map([[0, 1], [0, 2], [1, 1], [1, 2], [0, 2]]);
|
||||||
|
|
@ -186,8 +187,8 @@ suite.addBatch({
|
||||||
}
|
}
|
||||||
});
|
});
|
||||||
},
|
},
|
||||||
"the rollup function only applies to leaf values": function(d3) {
|
"the rollup function only applies to leaf values": function(nest) {
|
||||||
var map = d3.nest()
|
var map = nest()
|
||||||
.key(function(d) { return d[0]; }).sortKeys(d3.ascending)
|
.key(function(d) { return d[0]; }).sortKeys(d3.ascending)
|
||||||
.key(function(d) { return d[1]; }).sortKeys(d3.ascending)
|
.key(function(d) { return d[1]; }).sortKeys(d3.ascending)
|
||||||
.rollup(function(values) { return values.length; })
|
.rollup(function(values) { return values.length; })
|
||||||
|
|
@ -203,8 +204,8 @@ suite.addBatch({
|
||||||
}
|
}
|
||||||
});
|
});
|
||||||
},
|
},
|
||||||
"the value comparator only applies to leaf values": function(d3) {
|
"the value comparator only applies to leaf values": function(nest) {
|
||||||
var map = d3.nest()
|
var map = nest()
|
||||||
.key(function(d) { return d[0]; }).sortKeys(d3.ascending)
|
.key(function(d) { return d[0]; }).sortKeys(d3.ascending)
|
||||||
.key(function(d) { return d[1]; }).sortKeys(d3.ascending)
|
.key(function(d) { return d[1]; }).sortKeys(d3.ascending)
|
||||||
.sortValues(function(a, b) { return a[2] - b[2]; })
|
.sortValues(function(a, b) { return a[2] - b[2]; })
|
||||||
|
|
@ -220,18 +221,18 @@ suite.addBatch({
|
||||||
}
|
}
|
||||||
});
|
});
|
||||||
},
|
},
|
||||||
"if no keys are specified, the input array is returned": function(d3) {
|
"if no keys are specified, the input array is returned": function(nest) {
|
||||||
var array = [new Object()];
|
var array = [new Object()];
|
||||||
assert.strictEqual(d3.nest().map(array), array);
|
assert.strictEqual(nest().map(array), array);
|
||||||
},
|
},
|
||||||
"handles keys that are built-in prototype properties": function(d3) {
|
"handles keys that are built-in prototype properties": function(nest) {
|
||||||
var map = d3.nest()
|
var map = nest()
|
||||||
.key(String)
|
.key(String)
|
||||||
.map(["hasOwnProperty"]); // but note __proto__ wouldn’t work!
|
.map(["hasOwnProperty"]); // but note __proto__ wouldn’t work!
|
||||||
assert.deepEqual(map, {hasOwnProperty: ["hasOwnProperty"]});
|
assert.deepEqual(map, {hasOwnProperty: ["hasOwnProperty"]});
|
||||||
},
|
},
|
||||||
"a custom map implementation can be specified": function(d3) {
|
"a custom map implementation can be specified": function(nest) {
|
||||||
var map = d3.nest()
|
var map = nest()
|
||||||
.key(String)
|
.key(String)
|
||||||
.map(["hasOwnProperty", "__proto__"], d3.map);
|
.map(["hasOwnProperty", "__proto__"], d3.map);
|
||||||
assert.deepEqual(map.entries(), [
|
assert.deepEqual(map.entries(), [
|
||||||
|
|
@ -239,8 +240,8 @@ suite.addBatch({
|
||||||
{key: "__proto__", value: ["__proto__"]}
|
{key: "__proto__", value: ["__proto__"]}
|
||||||
]);
|
]);
|
||||||
},
|
},
|
||||||
"the custom map implementation works on multiple levels of nesting": function(d3) {
|
"the custom map implementation works on multiple levels of nesting": function(nest) {
|
||||||
var map = d3.nest()
|
var map = nest()
|
||||||
.key(function(d) { return d.foo; })
|
.key(function(d) { return d.foo; })
|
||||||
.key(function(d) { return d.bar; })
|
.key(function(d) { return d.bar; })
|
||||||
.map([{foo: 42, bar: "red"}], d3.map);
|
.map([{foo: 42, bar: "red"}], d3.map);
|
||||||
|
|
|
||||||
|
|
@ -6,39 +6,39 @@ var suite = vows.describe("d3.permute");
|
||||||
|
|
||||||
suite.addBatch({
|
suite.addBatch({
|
||||||
"permute": {
|
"permute": {
|
||||||
topic: load("arrays/permute"),
|
topic: load("arrays/permute").expression("d3.permute"),
|
||||||
"permutes according to the specified index": function(d3) {
|
"permutes according to the specified index": function(permute) {
|
||||||
assert.deepEqual(d3.permute([3, 4, 5], [2, 1, 0]), [5, 4, 3]);
|
assert.deepEqual(permute([3, 4, 5], [2, 1, 0]), [5, 4, 3]);
|
||||||
assert.deepEqual(d3.permute([3, 4, 5], [2, 0, 1]), [5, 3, 4]);
|
assert.deepEqual(permute([3, 4, 5], [2, 0, 1]), [5, 3, 4]);
|
||||||
assert.deepEqual(d3.permute([3, 4, 5], [0, 1, 2]), [3, 4, 5]);
|
assert.deepEqual(permute([3, 4, 5], [0, 1, 2]), [3, 4, 5]);
|
||||||
},
|
},
|
||||||
"does not modify the input array": function(d3) {
|
"does not modify the input array": function(permute) {
|
||||||
var input = [3, 4, 5];
|
var input = [3, 4, 5];
|
||||||
d3.permute(input, [2, 1, 0]);
|
permute(input, [2, 1, 0]);
|
||||||
assert.deepEqual(input, [3, 4, 5]);
|
assert.deepEqual(input, [3, 4, 5]);
|
||||||
},
|
},
|
||||||
"can duplicate input values": function(d3) {
|
"can duplicate input values": function(permute) {
|
||||||
assert.deepEqual(d3.permute([3, 4, 5], [0, 1, 0]), [3, 4, 3]);
|
assert.deepEqual(permute([3, 4, 5], [0, 1, 0]), [3, 4, 3]);
|
||||||
assert.deepEqual(d3.permute([3, 4, 5], [2, 2, 2]), [5, 5, 5]);
|
assert.deepEqual(permute([3, 4, 5], [2, 2, 2]), [5, 5, 5]);
|
||||||
assert.deepEqual(d3.permute([3, 4, 5], [0, 1, 1]), [3, 4, 4]);
|
assert.deepEqual(permute([3, 4, 5], [0, 1, 1]), [3, 4, 4]);
|
||||||
},
|
},
|
||||||
"can return more elements": function(d3) {
|
"can return more elements": function(permute) {
|
||||||
assert.deepEqual(d3.permute([3, 4, 5], [0, 0, 1, 2]), [3, 3, 4, 5]);
|
assert.deepEqual(permute([3, 4, 5], [0, 0, 1, 2]), [3, 3, 4, 5]);
|
||||||
assert.deepEqual(d3.permute([3, 4, 5], [0, 1, 1, 1]), [3, 4, 4, 4]);
|
assert.deepEqual(permute([3, 4, 5], [0, 1, 1, 1]), [3, 4, 4, 4]);
|
||||||
},
|
},
|
||||||
"can return fewer elements": function(d3) {
|
"can return fewer elements": function(permute) {
|
||||||
assert.deepEqual(d3.permute([3, 4, 5], [0]), [3]);
|
assert.deepEqual(permute([3, 4, 5], [0]), [3]);
|
||||||
assert.deepEqual(d3.permute([3, 4, 5], [1, 2]), [4, 5]);
|
assert.deepEqual(permute([3, 4, 5], [1, 2]), [4, 5]);
|
||||||
assert.deepEqual(d3.permute([3, 4, 5], []), []);
|
assert.deepEqual(permute([3, 4, 5], []), []);
|
||||||
},
|
},
|
||||||
"can return undefined elements": function(d3) {
|
"can return undefined elements": function(permute) {
|
||||||
var v1 = d3.permute([3, 4, 5], [10]);
|
var v1 = permute([3, 4, 5], [10]);
|
||||||
assert.equal(v1.length, 1);
|
assert.equal(v1.length, 1);
|
||||||
assert.isUndefined(v1[0]);
|
assert.isUndefined(v1[0]);
|
||||||
var v2 = d3.permute([3, 4, 5], [-1]);
|
var v2 = permute([3, 4, 5], [-1]);
|
||||||
assert.equal(v2.length, 1);
|
assert.equal(v2.length, 1);
|
||||||
assert.isUndefined(v2[0]);
|
assert.isUndefined(v2[0]);
|
||||||
var v3 = d3.permute([3, 4, 5], [0, -1]);
|
var v3 = permute([3, 4, 5], [0, -1]);
|
||||||
assert.equal(v3.length, 2);
|
assert.equal(v3.length, 2);
|
||||||
assert.equal(v3[0], 3);
|
assert.equal(v3[0], 3);
|
||||||
assert.isUndefined(v3[1]);
|
assert.isUndefined(v3[1]);
|
||||||
|
|
|
||||||
|
|
@ -6,49 +6,49 @@ var suite = vows.describe("d3.quantile");
|
||||||
|
|
||||||
suite.addBatch({
|
suite.addBatch({
|
||||||
"quantile": {
|
"quantile": {
|
||||||
topic: load("arrays/quantile"),
|
topic: load("arrays/quantile").expression("d3.quantile"),
|
||||||
"requires sorted numeric input": function(d3) {
|
"requires sorted numeric input": function(quantile) {
|
||||||
assert.equal(d3.quantile([1, 2, 3, 4], 0), 1);
|
assert.equal(quantile([1, 2, 3, 4], 0), 1);
|
||||||
assert.equal(d3.quantile([1, 2, 3, 4], 1), 4);
|
assert.equal(quantile([1, 2, 3, 4], 1), 4);
|
||||||
assert.equal(d3.quantile([4, 3, 2, 1], 0), 4);
|
assert.equal(quantile([4, 3, 2, 1], 0), 4);
|
||||||
assert.equal(d3.quantile([4, 3, 2, 1], 1), 1);
|
assert.equal(quantile([4, 3, 2, 1], 1), 1);
|
||||||
},
|
},
|
||||||
"uses the R-7 algorithm": function(d3) {
|
"uses the R-7 algorithm": function(quantile) {
|
||||||
var data = [3, 6, 7, 8, 8, 10, 13, 15, 16, 20];
|
var data = [3, 6, 7, 8, 8, 10, 13, 15, 16, 20];
|
||||||
assert.equal(d3.quantile(data, 0), 3);
|
assert.equal(quantile(data, 0), 3);
|
||||||
assert.equal(d3.quantile(data, .25), 7.25);
|
assert.equal(quantile(data, .25), 7.25);
|
||||||
assert.equal(d3.quantile(data, .5), 9);
|
assert.equal(quantile(data, .5), 9);
|
||||||
assert.equal(d3.quantile(data, .75), 14.5);
|
assert.equal(quantile(data, .75), 14.5);
|
||||||
assert.equal(d3.quantile(data, 1), 20);
|
assert.equal(quantile(data, 1), 20);
|
||||||
var data = [3, 6, 7, 8, 8, 9, 10, 13, 15, 16, 20];
|
var data = [3, 6, 7, 8, 8, 9, 10, 13, 15, 16, 20];
|
||||||
assert.equal(d3.quantile(data, 0), 3);
|
assert.equal(quantile(data, 0), 3);
|
||||||
assert.equal(d3.quantile(data, .25), 7.5);
|
assert.equal(quantile(data, .25), 7.5);
|
||||||
assert.equal(d3.quantile(data, .5), 9);
|
assert.equal(quantile(data, .5), 9);
|
||||||
assert.equal(d3.quantile(data, .75), 14);
|
assert.equal(quantile(data, .75), 14);
|
||||||
assert.equal(d3.quantile(data, 1), 20);
|
assert.equal(quantile(data, 1), 20);
|
||||||
},
|
},
|
||||||
"coerces values to numbers": function(d3) {
|
"coerces values to numbers": function(quantile) {
|
||||||
var strings = ["1", "2", "3", "4"];
|
var strings = ["1", "2", "3", "4"];
|
||||||
assert.strictEqual(d3.quantile(strings, 1/3), 2);
|
assert.strictEqual(quantile(strings, 1/3), 2);
|
||||||
assert.strictEqual(d3.quantile(strings, 1/2), 2.5);
|
assert.strictEqual(quantile(strings, 1/2), 2.5);
|
||||||
assert.strictEqual(d3.quantile(strings, 2/3), 3);
|
assert.strictEqual(quantile(strings, 2/3), 3);
|
||||||
var dates = [new Date(2011, 0, 1), new Date(2012, 0, 1)];
|
var dates = [new Date(2011, 0, 1), new Date(2012, 0, 1)];
|
||||||
assert.strictEqual(d3.quantile(dates, 0), +new Date(2011, 0, 1));
|
assert.strictEqual(quantile(dates, 0), +new Date(2011, 0, 1));
|
||||||
assert.strictEqual(d3.quantile(dates, 1/2), +new Date(2011, 6, 2, 13));
|
assert.strictEqual(quantile(dates, 1/2), +new Date(2011, 6, 2, 13));
|
||||||
assert.strictEqual(d3.quantile(dates, 1), +new Date(2012, 0, 1));
|
assert.strictEqual(quantile(dates, 1), +new Date(2012, 0, 1));
|
||||||
},
|
},
|
||||||
"returns an exact value for integer p-values": function(d3) {
|
"returns an exact value for integer p-values": function(quantile) {
|
||||||
var data = [1, 2, 3, 4];
|
var data = [1, 2, 3, 4];
|
||||||
assert.equal(d3.quantile(data, 1/3), 2);
|
assert.equal(quantile(data, 1/3), 2);
|
||||||
assert.equal(d3.quantile(data, 2/3), 3);
|
assert.equal(quantile(data, 2/3), 3);
|
||||||
},
|
},
|
||||||
"returns the first value for p = 0": function(d3) {
|
"returns the first value for p = 0": function(quantile) {
|
||||||
var data = [1, 2, 3, 4];
|
var data = [1, 2, 3, 4];
|
||||||
assert.equal(d3.quantile(data, 0), 1);
|
assert.equal(quantile(data, 0), 1);
|
||||||
},
|
},
|
||||||
"returns the last value for p = 1": function(d3) {
|
"returns the last value for p = 1": function(quantile) {
|
||||||
var data = [1, 2, 3, 4];
|
var data = [1, 2, 3, 4];
|
||||||
assert.equal(d3.quantile(data, 1), 4);
|
assert.equal(quantile(data, 1), 4);
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
});
|
});
|
||||||
|
|
|
||||||
|
|
@ -6,92 +6,92 @@ var suite = vows.describe("d3.range");
|
||||||
|
|
||||||
suite.addBatch({
|
suite.addBatch({
|
||||||
"range": {
|
"range": {
|
||||||
topic: load("arrays/range"),
|
topic: load("arrays/range").expression("d3.range"),
|
||||||
"start is an inclusive lower bound": function(d3) {
|
"start is an inclusive lower bound": function(range) {
|
||||||
assert.equal(d3.range(5)[0], 0);
|
assert.equal(range(5)[0], 0);
|
||||||
assert.equal(d3.range(1, 5)[0], 1);
|
assert.equal(range(1, 5)[0], 1);
|
||||||
assert.equal(d3.range(5, 1, -1)[0], 5);
|
assert.equal(range(5, 1, -1)[0], 5);
|
||||||
},
|
},
|
||||||
"stop is an exclusive upper bound": function(d3) {
|
"stop is an exclusive upper bound": function(range) {
|
||||||
assert.equal(d3.range(5)[4], 4);
|
assert.equal(range(5)[4], 4);
|
||||||
assert.equal(d3.range(1, 5)[3], 4);
|
assert.equal(range(1, 5)[3], 4);
|
||||||
assert.equal(d3.range(5, 1, -1)[3], 2);
|
assert.equal(range(5, 1, -1)[3], 2);
|
||||||
},
|
},
|
||||||
"with one argument, returns integers [0 … stop)": function(d3) {
|
"with one argument, returns integers [0 … stop)": function(range) {
|
||||||
assert.deepEqual(d3.range(0), []);
|
assert.deepEqual(range(0), []);
|
||||||
assert.deepEqual(d3.range(1), [0]);
|
assert.deepEqual(range(1), [0]);
|
||||||
assert.deepEqual(d3.range(5), [0, 1, 2, 3, 4]);
|
assert.deepEqual(range(5), [0, 1, 2, 3, 4]);
|
||||||
},
|
},
|
||||||
"with two arguments, returns integers [start … stop)": function(d3) {
|
"with two arguments, returns integers [start … stop)": function(range) {
|
||||||
assert.deepEqual(d3.range(0, 5), [0, 1, 2, 3, 4]);
|
assert.deepEqual(range(0, 5), [0, 1, 2, 3, 4]);
|
||||||
assert.deepEqual(d3.range(5, 9), [5, 6, 7, 8]);
|
assert.deepEqual(range(5, 9), [5, 6, 7, 8]);
|
||||||
},
|
},
|
||||||
"with three arguments, returns start + k * step": function(d3) {
|
"with three arguments, returns start + k * step": function(range) {
|
||||||
assert.deepEqual(d3.range(0, 5, 1), [0, 1, 2, 3, 4]);
|
assert.deepEqual(range(0, 5, 1), [0, 1, 2, 3, 4]);
|
||||||
assert.deepEqual(d3.range(5, 9, .5), [5, 5.5, 6, 6.5, 7, 7.5, 8, 8.5]);
|
assert.deepEqual(range(5, 9, .5), [5, 5.5, 6, 6.5, 7, 7.5, 8, 8.5]);
|
||||||
assert.deepEqual(d3.range(5, 8.5, .5), [5, 5.5, 6, 6.5, 7, 7.5, 8]);
|
assert.deepEqual(range(5, 8.5, .5), [5, 5.5, 6, 6.5, 7, 7.5, 8]);
|
||||||
assert.deepEqual(d3.range(2, 0, -.5), [2, 1.5, 1, .5]);
|
assert.deepEqual(range(2, 0, -.5), [2, 1.5, 1, .5]);
|
||||||
},
|
},
|
||||||
"handles fractional steps without rounding errors": function(d3) {
|
"handles fractional steps without rounding errors": function(range) {
|
||||||
assert.deepEqual(d3.range(0, 0.5, 0.1), [0, 0.1, 0.2, 0.3, 0.4]);
|
assert.deepEqual(range(0, 0.5, 0.1), [0, 0.1, 0.2, 0.3, 0.4]);
|
||||||
assert.deepEqual(d3.range(-2, -1.2, 0.1), [-2, -1.9, -1.8, -1.7, -1.6, -1.5, -1.4, -1.3]);
|
assert.deepEqual(range(-2, -1.2, 0.1), [-2, -1.9, -1.8, -1.7, -1.6, -1.5, -1.4, -1.3]);
|
||||||
},
|
},
|
||||||
"handles extremely small steps without rounding errors": function(d3) {
|
"handles extremely small steps without rounding errors": function(range) {
|
||||||
assert.deepEqual(d3.range(2.1e-31, 5e-31, 1.1e-31), [2.1e-31, 3.2e-31, 4.3e-31]);
|
assert.deepEqual(range(2.1e-31, 5e-31, 1.1e-31), [2.1e-31, 3.2e-31, 4.3e-31]);
|
||||||
},
|
},
|
||||||
"handles extremely large steps without rounding errors": function(d3) {
|
"handles extremely large steps without rounding errors": function(range) {
|
||||||
assert.deepEqual(d3.range(1e300, 2e300, 0.3e300), [1e300, 1.3e300, 1.6e300, 1.9e300]);
|
assert.deepEqual(range(1e300, 2e300, 0.3e300), [1e300, 1.3e300, 1.6e300, 1.9e300]);
|
||||||
},
|
},
|
||||||
"returns an ascending range if step is positive": function(d3) {
|
"returns an ascending range if step is positive": function(range) {
|
||||||
assert.deepEqual(d3.range(0, 5, 1), [0, 1, 2, 3, 4]);
|
assert.deepEqual(range(0, 5, 1), [0, 1, 2, 3, 4]);
|
||||||
},
|
},
|
||||||
"returns a descending range if step is negative": function(d3) {
|
"returns a descending range if step is negative": function(range) {
|
||||||
assert.deepEqual(d3.range(5, 0, -1), [5, 4, 3, 2, 1]);
|
assert.deepEqual(range(5, 0, -1), [5, 4, 3, 2, 1]);
|
||||||
},
|
},
|
||||||
"returns an empty range if start, stop or step are NaN": function(d3) {
|
"returns an empty range if start, stop or step are NaN": function(range) {
|
||||||
assert.isEmpty(d3.range(0, NaN));
|
assert.isEmpty(range(0, NaN));
|
||||||
assert.isEmpty(d3.range(1, NaN));
|
assert.isEmpty(range(1, NaN));
|
||||||
assert.isEmpty(d3.range(-1, NaN));
|
assert.isEmpty(range(-1, NaN));
|
||||||
assert.isEmpty(d3.range(0, undefined));
|
assert.isEmpty(range(0, undefined));
|
||||||
assert.isEmpty(d3.range(1, undefined));
|
assert.isEmpty(range(1, undefined));
|
||||||
assert.isEmpty(d3.range(-1, undefined));
|
assert.isEmpty(range(-1, undefined));
|
||||||
assert.isEmpty(d3.range(NaN, 0));
|
assert.isEmpty(range(NaN, 0));
|
||||||
assert.isEmpty(d3.range(NaN, 1));
|
assert.isEmpty(range(NaN, 1));
|
||||||
assert.isEmpty(d3.range(NaN, -1));
|
assert.isEmpty(range(NaN, -1));
|
||||||
assert.isEmpty(d3.range(undefined, 0));
|
assert.isEmpty(range(undefined, 0));
|
||||||
assert.isEmpty(d3.range(undefined, 1));
|
assert.isEmpty(range(undefined, 1));
|
||||||
assert.isEmpty(d3.range(undefined, -1));
|
assert.isEmpty(range(undefined, -1));
|
||||||
assert.isEmpty(d3.range(NaN, NaN));
|
assert.isEmpty(range(NaN, NaN));
|
||||||
assert.isEmpty(d3.range(undefined, undefined));
|
assert.isEmpty(range(undefined, undefined));
|
||||||
assert.isEmpty(d3.range(NaN, NaN, NaN));
|
assert.isEmpty(range(NaN, NaN, NaN));
|
||||||
assert.isEmpty(d3.range(undefined, undefined, undefined));
|
assert.isEmpty(range(undefined, undefined, undefined));
|
||||||
assert.isEmpty(d3.range(0, 10, NaN));
|
assert.isEmpty(range(0, 10, NaN));
|
||||||
assert.isEmpty(d3.range(10, 0, NaN));
|
assert.isEmpty(range(10, 0, NaN));
|
||||||
assert.isEmpty(d3.range(0, 10, undefined));
|
assert.isEmpty(range(0, 10, undefined));
|
||||||
assert.isEmpty(d3.range(10, 0, undefined));
|
assert.isEmpty(range(10, 0, undefined));
|
||||||
},
|
},
|
||||||
"returns an empty range if start equals stop": function(d3) {
|
"returns an empty range if start equals stop": function(range) {
|
||||||
assert.isEmpty(d3.range(10, 10));
|
assert.isEmpty(range(10, 10));
|
||||||
assert.isEmpty(d3.range(10, 10, 1));
|
assert.isEmpty(range(10, 10, 1));
|
||||||
assert.isEmpty(d3.range(10, 10, -1));
|
assert.isEmpty(range(10, 10, -1));
|
||||||
assert.isEmpty(d3.range(10, 10, -.5));
|
assert.isEmpty(range(10, 10, -.5));
|
||||||
assert.isEmpty(d3.range(10, 10, .5));
|
assert.isEmpty(range(10, 10, .5));
|
||||||
assert.isEmpty(d3.range(0, 0));
|
assert.isEmpty(range(0, 0));
|
||||||
assert.isEmpty(d3.range(0, 0, 1));
|
assert.isEmpty(range(0, 0, 1));
|
||||||
assert.isEmpty(d3.range(0, 0, -1));
|
assert.isEmpty(range(0, 0, -1));
|
||||||
assert.isEmpty(d3.range(0, 0, -.5));
|
assert.isEmpty(range(0, 0, -.5));
|
||||||
assert.isEmpty(d3.range(0, 0, .5));
|
assert.isEmpty(range(0, 0, .5));
|
||||||
},
|
},
|
||||||
"returns an empty range if stop is less than start and step is positive": function(d3) {
|
"returns an empty range if stop is less than start and step is positive": function(range) {
|
||||||
assert.isEmpty(d3.range(20, 10));
|
assert.isEmpty(range(20, 10));
|
||||||
assert.isEmpty(d3.range(20, 10, 2));
|
assert.isEmpty(range(20, 10, 2));
|
||||||
assert.isEmpty(d3.range(20, 10, 1));
|
assert.isEmpty(range(20, 10, 1));
|
||||||
assert.isEmpty(d3.range(20, 10, .5));
|
assert.isEmpty(range(20, 10, .5));
|
||||||
},
|
},
|
||||||
"returns an empty range if stop is greater than start and step is negative": function(d3) {
|
"returns an empty range if stop is greater than start and step is negative": function(range) {
|
||||||
assert.isEmpty(d3.range(10, 20, -2));
|
assert.isEmpty(range(10, 20, -2));
|
||||||
assert.isEmpty(d3.range(10, 20, -1));
|
assert.isEmpty(range(10, 20, -1));
|
||||||
assert.isEmpty(d3.range(10, 20, -.5));
|
assert.isEmpty(range(10, 20, -.5));
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
});
|
});
|
||||||
|
|
|
||||||
|
|
@ -1,4 +1,5 @@
|
||||||
var vows = require("vows"),
|
var vows = require("vows"),
|
||||||
|
d3 = require("../../"),
|
||||||
load = require("../load"),
|
load = require("../load"),
|
||||||
assert = require("assert");
|
assert = require("assert");
|
||||||
|
|
||||||
|
|
@ -6,127 +7,127 @@ var suite = vows.describe("d3.set");
|
||||||
|
|
||||||
suite.addBatch({
|
suite.addBatch({
|
||||||
"set": {
|
"set": {
|
||||||
topic: load("arrays/set", "arrays/ascending"),
|
topic: load("arrays/set").expression("d3.set"),
|
||||||
"constructor": {
|
"constructor": {
|
||||||
"set() returns an empty set": function(d3) {
|
"set() returns an empty set": function(set) {
|
||||||
var set = d3.set();
|
var s = set();
|
||||||
assert.deepEqual(set.values(), []);
|
assert.deepEqual(s.values(), []);
|
||||||
},
|
},
|
||||||
"set(null) returns an empty set": function(d3) {
|
"set(null) returns an empty set": function(set) {
|
||||||
var set = d3.set(null);
|
var s = set(null);
|
||||||
assert.deepEqual(set.values(), []);
|
assert.deepEqual(s.values(), []);
|
||||||
},
|
},
|
||||||
"set(array) adds array entries": function(d3) {
|
"set(array) adds array entries": function(set) {
|
||||||
var set = d3.set(["foo"]);
|
var s = set(["foo"]);
|
||||||
assert.isTrue(set.has("foo"));
|
assert.isTrue(s.has("foo"));
|
||||||
var set = d3.set(["foo", "bar"]);
|
var s = set(["foo", "bar"]);
|
||||||
assert.isTrue(set.has("foo"));
|
assert.isTrue(s.has("foo"));
|
||||||
assert.isTrue(set.has("bar"));
|
assert.isTrue(s.has("bar"));
|
||||||
}
|
}
|
||||||
},
|
},
|
||||||
"forEach": {
|
"forEach": {
|
||||||
"empty sets have an empty values array": function(d3) {
|
"empty sets have an empty values array": function(set) {
|
||||||
var set = d3.set();
|
var s = set();
|
||||||
assert.deepEqual(set.values(), []);
|
assert.deepEqual(s.values(), []);
|
||||||
set.add("foo");
|
s.add("foo");
|
||||||
assert.deepEqual(set.values(), ["foo"]);
|
assert.deepEqual(s.values(), ["foo"]);
|
||||||
set.remove("foo");
|
s.remove("foo");
|
||||||
assert.deepEqual(set.values(), []);
|
assert.deepEqual(s.values(), []);
|
||||||
},
|
},
|
||||||
"values are returned in arbitrary order": function(d3) {
|
"values are returned in arbitrary order": function(set) {
|
||||||
var set = d3.set(["foo", "bar"]);
|
var s = set(["foo", "bar"]);
|
||||||
assert.deepEqual(set.values().sort(d3.ascending), ["bar", "foo"]);
|
assert.deepEqual(s.values().sort(d3.ascending), ["bar", "foo"]);
|
||||||
var set = d3.set(["bar", "foo"]);
|
var s = set(["bar", "foo"]);
|
||||||
assert.deepEqual(set.values().sort(d3.ascending), ["bar", "foo"]);
|
assert.deepEqual(s.values().sort(d3.ascending), ["bar", "foo"]);
|
||||||
},
|
},
|
||||||
"observes changes via add and remove": function(d3) {
|
"observes changes via add and remove": function(set) {
|
||||||
var set = d3.set(["foo", "bar"]);
|
var s = set(["foo", "bar"]);
|
||||||
assert.deepEqual(set.values().sort(d3.ascending), ["bar", "foo"]);
|
assert.deepEqual(s.values().sort(d3.ascending), ["bar", "foo"]);
|
||||||
set.remove("foo");
|
s.remove("foo");
|
||||||
assert.deepEqual(set.values(), ["bar"]);
|
assert.deepEqual(s.values(), ["bar"]);
|
||||||
set.add("bar");
|
s.add("bar");
|
||||||
assert.deepEqual(set.values(), ["bar"]);
|
assert.deepEqual(s.values(), ["bar"]);
|
||||||
set.add("foo");
|
s.add("foo");
|
||||||
assert.deepEqual(set.values().sort(d3.ascending), ["bar", "foo"]);
|
assert.deepEqual(s.values().sort(d3.ascending), ["bar", "foo"]);
|
||||||
set.remove("bar");
|
s.remove("bar");
|
||||||
assert.deepEqual(set.values(), ["foo"]);
|
assert.deepEqual(s.values(), ["foo"]);
|
||||||
set.remove("foo");
|
s.remove("foo");
|
||||||
assert.deepEqual(set.values(), []);
|
assert.deepEqual(s.values(), []);
|
||||||
set.remove("foo");
|
s.remove("foo");
|
||||||
assert.deepEqual(set.values(), []);
|
assert.deepEqual(s.values(), []);
|
||||||
}
|
}
|
||||||
},
|
},
|
||||||
"values": {
|
"values": {
|
||||||
"returns an array of string values": function(d3) {
|
"returns an array of string values": function(set) {
|
||||||
var set = d3.set(["foo", "bar"]);
|
var s = set(["foo", "bar"]);
|
||||||
assert.deepEqual(set.values().sort(), ["bar", "foo"]);
|
assert.deepEqual(s.values().sort(), ["bar", "foo"]);
|
||||||
}
|
}
|
||||||
},
|
},
|
||||||
"has": {
|
"has": {
|
||||||
"empty sets do not have object built-ins": function(d3) {
|
"empty sets do not have object built-ins": function(set) {
|
||||||
var set = d3.set();
|
var s = set();
|
||||||
assert.isFalse(set.has("__proto__"));
|
assert.isFalse(s.has("__proto__"));
|
||||||
assert.isFalse(set.has("hasOwnProperty"));
|
assert.isFalse(s.has("hasOwnProperty"));
|
||||||
},
|
},
|
||||||
"coerces values to strings": function(d3) {
|
"coerces values to strings": function(set) {
|
||||||
var set = d3.set(["42", "null", "undefined"]);
|
var s = set(["42", "null", "undefined"]);
|
||||||
assert.isTrue(set.has(42));
|
assert.isTrue(s.has(42));
|
||||||
assert.isTrue(set.has(null));
|
assert.isTrue(s.has(null));
|
||||||
assert.isTrue(set.has(undefined));
|
assert.isTrue(s.has(undefined));
|
||||||
},
|
},
|
||||||
"observes changes via add and remove": function(d3) {
|
"observes changes via add and remove": function(set) {
|
||||||
var set = d3.set(["foo"]);
|
var s = set(["foo"]);
|
||||||
assert.isTrue(set.has("foo"));
|
assert.isTrue(s.has("foo"));
|
||||||
set.add("foo");
|
s.add("foo");
|
||||||
assert.isTrue(set.has("foo"));
|
assert.isTrue(s.has("foo"));
|
||||||
set.remove("foo");
|
s.remove("foo");
|
||||||
assert.isFalse(set.has("foo"));
|
assert.isFalse(s.has("foo"));
|
||||||
set.add("foo");
|
s.add("foo");
|
||||||
assert.isTrue(set.has("foo"));
|
assert.isTrue(s.has("foo"));
|
||||||
},
|
},
|
||||||
"returns undefined for missing values": function(d3) {
|
"returns undefined for missing values": function(set) {
|
||||||
var set = d3.set(["foo"]);
|
var s = set(["foo"]);
|
||||||
assert.isFalse(set.has("bar"));
|
assert.isFalse(s.has("bar"));
|
||||||
}
|
}
|
||||||
},
|
},
|
||||||
"add": {
|
"add": {
|
||||||
"returns the set value": function(d3) {
|
"returns the set value": function(set) {
|
||||||
var set = d3.set();
|
var s = set();
|
||||||
assert.equal(set.add("foo"), "foo");
|
assert.equal(s.add("foo"), "foo");
|
||||||
},
|
},
|
||||||
"can add values using built-in names": function(d3) {
|
"can add values using built-in names": function(set) {
|
||||||
var set = d3.set();
|
var s = set();
|
||||||
set.add("__proto__");
|
s.add("__proto__");
|
||||||
assert.isTrue(set.has("__proto__"));
|
assert.isTrue(s.has("__proto__"));
|
||||||
},
|
},
|
||||||
"coerces values to strings": function(d3) {
|
"coerces values to strings": function(set) {
|
||||||
var set = d3.set();
|
var s = set();
|
||||||
set.add(42);
|
s.add(42);
|
||||||
assert.isTrue(set.has(42));
|
assert.isTrue(s.has(42));
|
||||||
set.add(null);
|
s.add(null);
|
||||||
assert.isTrue(set.has(null));
|
assert.isTrue(s.has(null));
|
||||||
set.add(undefined);
|
s.add(undefined);
|
||||||
assert.isTrue(set.has(undefined));
|
assert.isTrue(s.has(undefined));
|
||||||
assert.deepEqual(set.values().sort(), ["42", "null", "undefined"]);
|
assert.deepEqual(s.values().sort(), ["42", "null", "undefined"]);
|
||||||
},
|
},
|
||||||
"can add null, undefined or empty string values": function(d3) {
|
"can add null, undefined or empty string values": function(set) {
|
||||||
var set = d3.set();
|
var s = set();
|
||||||
set.add("");
|
s.add("");
|
||||||
set.add("null");
|
s.add("null");
|
||||||
set.add("undefined");
|
s.add("undefined");
|
||||||
assert.isTrue(set.has(""));
|
assert.isTrue(s.has(""));
|
||||||
assert.isTrue(set.has("null"));
|
assert.isTrue(s.has("null"));
|
||||||
assert.isTrue(set.has("undefined"));
|
assert.isTrue(s.has("undefined"));
|
||||||
}
|
}
|
||||||
},
|
},
|
||||||
"remove": {
|
"remove": {
|
||||||
"returns true if the value was removed": function(d3) {
|
"returns true if the value was removed": function(set) {
|
||||||
var set = d3.set(["foo"]);
|
var s = set(["foo"]);
|
||||||
assert.isTrue(set.remove("foo"));
|
assert.isTrue(s.remove("foo"));
|
||||||
},
|
},
|
||||||
"returns false if the value is not an element": function(d3) {
|
"returns false if the value is not an element": function(set) {
|
||||||
var set = d3.set();
|
var s = set();
|
||||||
assert.isFalse(set.remove("foo"));
|
assert.isFalse(s.remove("foo"));
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
|
||||||
|
|
@ -6,36 +6,36 @@ var suite = vows.describe("d3.sum");
|
||||||
|
|
||||||
suite.addBatch({
|
suite.addBatch({
|
||||||
"sum": {
|
"sum": {
|
||||||
topic: load("arrays/sum"),
|
topic: load("arrays/sum").expression("d3.sum"),
|
||||||
"sums numbers": function(d3) {
|
"sums numbers": function(sum) {
|
||||||
assert.equal(d3.sum([1]), 1);
|
assert.equal(sum([1]), 1);
|
||||||
assert.equal(d3.sum([5, 1, 2, 3, 4]), 15);
|
assert.equal(sum([5, 1, 2, 3, 4]), 15);
|
||||||
assert.equal(d3.sum([20, 3]), 23);
|
assert.equal(sum([20, 3]), 23);
|
||||||
assert.equal(d3.sum([3, 20]), 23);
|
assert.equal(sum([3, 20]), 23);
|
||||||
},
|
},
|
||||||
"sums types that can be coerced to numbers": function(d3) {
|
"sums types that can be coerced to numbers": function(sum) {
|
||||||
assert.equal(d3.sum(["20", "3"]), 23);
|
assert.equal(sum(["20", "3"]), 23);
|
||||||
assert.equal(d3.sum(["3", "20"]), 23);
|
assert.equal(sum(["3", "20"]), 23);
|
||||||
assert.equal(d3.sum(["3", 20]), 23);
|
assert.equal(sum(["3", 20]), 23);
|
||||||
assert.equal(d3.sum([20, "3"]), 23);
|
assert.equal(sum([20, "3"]), 23);
|
||||||
assert.equal(d3.sum([3, "20"]), 23);
|
assert.equal(sum([3, "20"]), 23);
|
||||||
assert.equal(d3.sum(["20", 3]), 23);
|
assert.equal(sum(["20", 3]), 23);
|
||||||
},
|
},
|
||||||
"ignores non-numeric types": function(d3) {
|
"ignores non-numeric types": function(sum) {
|
||||||
assert.equal(d3.sum(["a", "b", "c"]), 0);
|
assert.equal(sum(["a", "b", "c"]), 0);
|
||||||
assert.equal(d3.sum(["a", 1, "2"]), 3);
|
assert.equal(sum(["a", 1, "2"]), 3);
|
||||||
},
|
},
|
||||||
"ignores null, undefined and NaN": function(d3) {
|
"ignores null, undefined and NaN": function(sum) {
|
||||||
assert.equal(d3.sum([NaN, 1, 2, 3, 4, 5]), 15);
|
assert.equal(sum([NaN, 1, 2, 3, 4, 5]), 15);
|
||||||
assert.equal(d3.sum([1, 2, 3, 4, 5, NaN]), 15);
|
assert.equal(sum([1, 2, 3, 4, 5, NaN]), 15);
|
||||||
assert.equal(d3.sum([10, null, 3, undefined, 5, NaN]), 18);
|
assert.equal(sum([10, null, 3, undefined, 5, NaN]), 18);
|
||||||
},
|
},
|
||||||
"applies the optional acccessor function": function(d3) {
|
"applies the optional acccessor function": function(sum) {
|
||||||
assert.equal(d3.sum([[1, 2, 3, 4, 5], [2, 4, 6, 8, 10]], function(d) { return d3.sum(d); }), 45);
|
assert.equal(sum([[1, 2, 3, 4, 5], [2, 4, 6, 8, 10]], function(d) { return sum(d); }), 45);
|
||||||
assert.equal(d3.sum([1, 2, 3, 4, 5], function(d, i) { return i; }), 10);
|
assert.equal(sum([1, 2, 3, 4, 5], function(d, i) { return i; }), 10);
|
||||||
},
|
},
|
||||||
"returns zero for the empty array": function(d3) {
|
"returns zero for the empty array": function(sum) {
|
||||||
assert.equal(d3.sum([]), 0);
|
assert.equal(sum([]), 0);
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
});
|
});
|
||||||
|
|
|
||||||
|
|
@ -6,21 +6,21 @@ var suite = vows.describe("d3.transpose");
|
||||||
|
|
||||||
suite.addBatch({
|
suite.addBatch({
|
||||||
"transpose": {
|
"transpose": {
|
||||||
topic: load("arrays/transpose"),
|
topic: load("arrays/transpose").expression("d3.transpose"),
|
||||||
"transposes a square matrix": function(d3) {
|
"transposes a square matrix": function(transpose) {
|
||||||
assert.deepEqual(d3.transpose([[1, 2], [3, 4]]), [[1, 3], [2, 4]]);
|
assert.deepEqual(transpose([[1, 2], [3, 4]]), [[1, 3], [2, 4]]);
|
||||||
},
|
},
|
||||||
"transposes a non-square matrix": function(d3) {
|
"transposes a non-square matrix": function(transpose) {
|
||||||
assert.deepEqual(d3.transpose([[1, 2, 3, 4, 5], [2, 4, 6, 8, 10]]), [[1, 2], [2, 4], [3, 6], [4, 8], [5, 10]]);
|
assert.deepEqual(transpose([[1, 2, 3, 4, 5], [2, 4, 6, 8, 10]]), [[1, 2], [2, 4], [3, 6], [4, 8], [5, 10]]);
|
||||||
},
|
},
|
||||||
"transposes a single-row matrix": function(d3) {
|
"transposes a single-row matrix": function(transpose) {
|
||||||
assert.deepEqual(d3.transpose([[1, 2, 3, 4, 5]]), [[1], [2], [3], [4], [5]]);
|
assert.deepEqual(transpose([[1, 2, 3, 4, 5]]), [[1], [2], [3], [4], [5]]);
|
||||||
},
|
},
|
||||||
"transposes an empty matrix": function(d3) {
|
"transposes an empty matrix": function(transpose) {
|
||||||
assert.deepEqual(d3.transpose([]), []);
|
assert.deepEqual(transpose([]), []);
|
||||||
},
|
},
|
||||||
"ignores extra elements given an irregular matrix": function(d3) {
|
"ignores extra elements given an irregular matrix": function(transpose) {
|
||||||
assert.deepEqual(d3.transpose([[1, 2], [3, 4], [5, 6, 7]]), [[1, 3, 5], [2, 4, 6]]);
|
assert.deepEqual(transpose([[1, 2], [3, 4], [5, 6, 7]]), [[1, 3, 5], [2, 4, 6]]);
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
});
|
});
|
||||||
|
|
|
||||||
|
|
@ -6,20 +6,20 @@ var suite = vows.describe("d3.values");
|
||||||
|
|
||||||
suite.addBatch({
|
suite.addBatch({
|
||||||
"values": {
|
"values": {
|
||||||
topic: load("arrays/values"),
|
topic: load("arrays/values").expression("d3.values"),
|
||||||
"enumerates every value": function(d3) {
|
"enumerates every value": function(values) {
|
||||||
assert.deepEqual(d3.values({a: 1, b: 2}), [1, 2]);
|
assert.deepEqual(values({a: 1, b: 2}), [1, 2]);
|
||||||
},
|
},
|
||||||
"includes values defined on prototypes": function(d3) {
|
"includes values defined on prototypes": function(values) {
|
||||||
function abc() {
|
function abc() {
|
||||||
this.a = 1;
|
this.a = 1;
|
||||||
this.b = 2;
|
this.b = 2;
|
||||||
}
|
}
|
||||||
abc.prototype.c = 3;
|
abc.prototype.c = 3;
|
||||||
assert.deepEqual(d3.values(new abc()), [1, 2, 3]);
|
assert.deepEqual(values(new abc()), [1, 2, 3]);
|
||||||
},
|
},
|
||||||
"includes null or undefined values": function(d3) {
|
"includes null or undefined values": function(values) {
|
||||||
var v = d3.values({a: undefined, b: null, c: NaN});
|
var v = values({a: undefined, b: null, c: NaN});
|
||||||
assert.isUndefined(v[0]);
|
assert.isUndefined(v[0]);
|
||||||
assert.isNull(v[1]);
|
assert.isNull(v[1]);
|
||||||
assert.isNaN(v[2]);
|
assert.isNaN(v[2]);
|
||||||
|
|
|
||||||
|
|
@ -1,26 +1,26 @@
|
||||||
var vows = require("vows"),
|
var vows = require("vows"),
|
||||||
load= require("../load"),
|
load = require("../load"),
|
||||||
assert = require("../env-assert");
|
assert = require("../env-assert");
|
||||||
|
|
||||||
var suite = vows.describe("d3.zip");
|
var suite = vows.describe("d3.zip");
|
||||||
|
|
||||||
suite.addBatch({
|
suite.addBatch({
|
||||||
"zip": {
|
"zip": {
|
||||||
topic: load("arrays/zip"),
|
topic: load("arrays/zip").expression("d3.zip"),
|
||||||
"transposes a square matrix": function(d3) {
|
"transposes a square matrix": function(zip) {
|
||||||
assert.deepEqual(d3.zip([1, 2], [3, 4]), [[1, 3], [2, 4]]);
|
assert.deepEqual(zip([1, 2], [3, 4]), [[1, 3], [2, 4]]);
|
||||||
},
|
},
|
||||||
"transposes a non-square matrix": function(d3) {
|
"transposes a non-square matrix": function(zip) {
|
||||||
assert.deepEqual(d3.zip([1, 2, 3, 4, 5], [2, 4, 6, 8, 10]), [[1, 2], [2, 4], [3, 6], [4, 8], [5, 10]]);
|
assert.deepEqual(zip([1, 2, 3, 4, 5], [2, 4, 6, 8, 10]), [[1, 2], [2, 4], [3, 6], [4, 8], [5, 10]]);
|
||||||
},
|
},
|
||||||
"transposes a single-row matrix": function(d3) {
|
"transposes a single-row matrix": function(zip) {
|
||||||
assert.deepEqual(d3.zip([1, 2, 3, 4, 5]), [[1], [2], [3], [4], [5]]);
|
assert.deepEqual(zip([1, 2, 3, 4, 5]), [[1], [2], [3], [4], [5]]);
|
||||||
},
|
},
|
||||||
"transposes an empty matrix": function(d3) {
|
"transposes an empty matrix": function(zip) {
|
||||||
assert.deepEqual(d3.zip(), []);
|
assert.deepEqual(zip(), []);
|
||||||
},
|
},
|
||||||
"ignores extra elements given an irregular matrix": function(d3) {
|
"ignores extra elements given an irregular matrix": function(zip) {
|
||||||
assert.deepEqual(d3.zip([1, 2], [3, 4], [5, 6, 7]), [[1, 3, 5], [2, 4, 6]]);
|
assert.deepEqual(zip([1, 2], [3, 4], [5, 6, 7]), [[1, 3, 5], [2, 4, 6]]);
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
});
|
});
|
||||||
|
|
|
||||||
Загрузка…
Ссылка в новой задаче