diff --git a/test/arrays/ascending-test.js b/test/arrays/ascending-test.js index 28fc6f18..108ed181 100644 --- a/test/arrays/ascending-test.js +++ b/test/arrays/ascending-test.js @@ -6,37 +6,37 @@ var suite = vows.describe("d3.ascending"); suite.addBatch({ "d3.ascending": { - topic: load("arrays/ascending"), + topic: load("arrays/ascending").expression("d3.ascending"), "numbers": { - "returns a negative number if a < b": function(d3) { - assert.isTrue(d3.ascending(0, 1) < 0); + "returns a negative number if a < b": function(ascending) { + assert.isTrue(ascending(0, 1) < 0); }, - "returns a positive number if a > b": function(d3) { - assert.isTrue(d3.ascending(1, 0) > 0); + "returns a positive number if a > b": function(ascending) { + assert.isTrue(ascending(1, 0) > 0); }, - "returns zero if a == b": function(d3) { - assert.equal(d3.ascending(0, 0), 0); + "returns zero if a == b": function(ascending) { + assert.equal(ascending(0, 0), 0); }, - "returns NaN if a or b is undefined": function(d3) { - assert.isNaN(d3.ascending(0, undefined)); - assert.isNaN(d3.ascending(undefined, 0)); - assert.isNaN(d3.ascending(undefined, undefined)); + "returns NaN if a or b is undefined": function(ascending) { + assert.isNaN(ascending(0, undefined)); + assert.isNaN(ascending(undefined, 0)); + assert.isNaN(ascending(undefined, undefined)); }, - "returns NaN if a or b is NaN": function(d3) { - assert.isNaN(d3.ascending(0, NaN)); - assert.isNaN(d3.ascending(NaN, 0)); - assert.isNaN(d3.ascending(NaN, NaN)); + "returns NaN if a or b is NaN": function(ascending) { + assert.isNaN(ascending(0, NaN)); + assert.isNaN(ascending(NaN, 0)); + assert.isNaN(ascending(NaN, NaN)); } }, "strings": { - "returns a negative number if a < b": function(d3) { - assert.isTrue(d3.ascending("a", "b") < 0); + "returns a negative number if a < b": function(ascending) { + assert.isTrue(ascending("a", "b") < 0); }, - "returns a positive number if a > b": function(d3) { - assert.isTrue(d3.ascending("b", "a") > 0); + "returns a positive number if a > b": function(ascending) { + assert.isTrue(ascending("b", "a") > 0); }, - "returns zero if a == b": function(d3) { - assert.equal(d3.ascending("a", "a"), 0); + "returns zero if a == b": function(ascending) { + assert.equal(ascending("a", "a"), 0); } } } diff --git a/test/arrays/bisect-test.js b/test/arrays/bisect-test.js index e5b98f08..9ea38d7d 100644 --- a/test/arrays/bisect-test.js +++ b/test/arrays/bisect-test.js @@ -8,47 +8,47 @@ var i30 = 1 << 30; suite.addBatch({ "bisectLeft": { - topic: load("arrays/bisect"), - "finds the index of an exact match": function(d3) { + topic: load("arrays/bisect").expression("d3.bisectLeft"), + "finds the index of an exact match": function(bisect) { var array = [1, 2, 3]; - assert.equal(d3.bisectLeft(array, 1), 0); - assert.equal(d3.bisectLeft(array, 2), 1); - assert.equal(d3.bisectLeft(array, 3), 2); + assert.equal(bisect(array, 1), 0); + assert.equal(bisect(array, 2), 1); + 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]; - assert.equal(d3.bisectLeft(array, 1), 0); - assert.equal(d3.bisectLeft(array, 2), 1); - assert.equal(d3.bisectLeft(array, 3), 3); + assert.equal(bisect(array, 1), 0); + assert.equal(bisect(array, 2), 1); + 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]; - assert.equal(d3.bisectLeft(array, 0.5), 0); - assert.equal(d3.bisectLeft(array, 1.5), 1); - assert.equal(d3.bisectLeft(array, 2.5), 2); - assert.equal(d3.bisectLeft(array, 3.5), 3); + assert.equal(bisect(array, 0.5), 0); + assert.equal(bisect(array, 1.5), 1); + assert.equal(bisect(array, 2.5), 2); + 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]; - assert.equal(d3.bisectLeft(array, 0, 2), 2); - assert.equal(d3.bisectLeft(array, 1, 2), 2); - assert.equal(d3.bisectLeft(array, 2, 2), 2); - assert.equal(d3.bisectLeft(array, 3, 2), 2); - assert.equal(d3.bisectLeft(array, 4, 2), 3); - assert.equal(d3.bisectLeft(array, 5, 2), 4); - assert.equal(d3.bisectLeft(array, 6, 2), 5); + assert.equal(bisect(array, 0, 2), 2); + assert.equal(bisect(array, 1, 2), 2); + assert.equal(bisect(array, 2, 2), 2); + assert.equal(bisect(array, 3, 2), 2); + assert.equal(bisect(array, 4, 2), 3); + assert.equal(bisect(array, 5, 2), 4); + 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]; - assert.equal(d3.bisectLeft(array, 0, 2, 3), 2); - assert.equal(d3.bisectLeft(array, 1, 2, 3), 2); - assert.equal(d3.bisectLeft(array, 2, 2, 3), 2); - assert.equal(d3.bisectLeft(array, 3, 2, 3), 2); - assert.equal(d3.bisectLeft(array, 4, 2, 3), 3); - assert.equal(d3.bisectLeft(array, 5, 2, 3), 3); - assert.equal(d3.bisectLeft(array, 6, 2, 3), 3); + assert.equal(bisect(array, 0, 2, 3), 2); + assert.equal(bisect(array, 1, 2, 3), 2); + assert.equal(bisect(array, 2, 2, 3), 2); + assert.equal(bisect(array, 3, 2, 3), 2); + assert.equal(bisect(array, 4, 2, 3), 3); + assert.equal(bisect(array, 5, 2, 3), 3); + assert.equal(bisect(array, 6, 2, 3), 3); }, - "large arrays": function(d3) { + "large arrays": function(bisect) { var array = [], i = i30; array[i++] = 1; @@ -56,57 +56,57 @@ suite.addBatch({ array[i++] = 3; array[i++] = 4; array[i++] = 5; - assert.equal(d3.bisectLeft(array, 0, i - 5, i), i - 5); - assert.equal(d3.bisectLeft(array, 1, i - 5, i), i - 5); - assert.equal(d3.bisectLeft(array, 2, i - 5, i), i - 4); - assert.equal(d3.bisectLeft(array, 3, i - 5, i), i - 3); - assert.equal(d3.bisectLeft(array, 4, i - 5, i), i - 2); - assert.equal(d3.bisectLeft(array, 5, i - 5, i), i - 1); - assert.equal(d3.bisectLeft(array, 6, i - 5, i), i - 0); + assert.equal(bisect(array, 0, i - 5, i), i - 5); + assert.equal(bisect(array, 1, i - 5, i), i - 5); + assert.equal(bisect(array, 2, i - 5, i), i - 4); + assert.equal(bisect(array, 3, i - 5, i), i - 3); + assert.equal(bisect(array, 4, i - 5, i), i - 2); + assert.equal(bisect(array, 5, i - 5, i), i - 1); + assert.equal(bisect(array, 6, i - 5, i), i - 0); } }, "bisectRight": { - topic: load("arrays/bisect"), - "finds the index after an exact match": function(d3) { + topic: load("arrays/bisect").expression("d3.bisectRight"), + "finds the index after an exact match": function(bisect) { var array = [1, 2, 3]; - assert.equal(d3.bisectRight(array, 1), 1); - assert.equal(d3.bisectRight(array, 2), 2); - assert.equal(d3.bisectRight(array, 3), 3); + assert.equal(bisect(array, 1), 1); + assert.equal(bisect(array, 2), 2); + 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]; - assert.equal(d3.bisectRight(array, 1), 1); - assert.equal(d3.bisectRight(array, 2), 3); - assert.equal(d3.bisectRight(array, 3), 4); + assert.equal(bisect(array, 1), 1); + assert.equal(bisect(array, 2), 3); + 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]; - assert.equal(d3.bisectRight(array, 0.5), 0); - assert.equal(d3.bisectRight(array, 1.5), 1); - assert.equal(d3.bisectRight(array, 2.5), 2); - assert.equal(d3.bisectRight(array, 3.5), 3); + assert.equal(bisect(array, 0.5), 0); + assert.equal(bisect(array, 1.5), 1); + assert.equal(bisect(array, 2.5), 2); + 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]; - assert.equal(d3.bisectRight(array, 0, 2), 2); - assert.equal(d3.bisectRight(array, 1, 2), 2); - assert.equal(d3.bisectRight(array, 2, 2), 2); - assert.equal(d3.bisectRight(array, 3, 2), 3); - assert.equal(d3.bisectRight(array, 4, 2), 4); - assert.equal(d3.bisectRight(array, 5, 2), 5); - assert.equal(d3.bisectRight(array, 6, 2), 5); + assert.equal(bisect(array, 0, 2), 2); + assert.equal(bisect(array, 1, 2), 2); + assert.equal(bisect(array, 2, 2), 2); + assert.equal(bisect(array, 3, 2), 3); + assert.equal(bisect(array, 4, 2), 4); + assert.equal(bisect(array, 5, 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]; - assert.equal(d3.bisectRight(array, 0, 2, 3), 2); - assert.equal(d3.bisectRight(array, 1, 2, 3), 2); - assert.equal(d3.bisectRight(array, 2, 2, 3), 2); - assert.equal(d3.bisectRight(array, 3, 2, 3), 3); - assert.equal(d3.bisectRight(array, 4, 2, 3), 3); - assert.equal(d3.bisectRight(array, 5, 2, 3), 3); - assert.equal(d3.bisectRight(array, 6, 2, 3), 3); + assert.equal(bisect(array, 0, 2, 3), 2); + assert.equal(bisect(array, 1, 2, 3), 2); + assert.equal(bisect(array, 2, 2, 3), 2); + assert.equal(bisect(array, 3, 2, 3), 3); + assert.equal(bisect(array, 4, 2, 3), 3); + assert.equal(bisect(array, 5, 2, 3), 3); + assert.equal(bisect(array, 6, 2, 3), 3); }, - "large arrays": function(d3) { + "large arrays": function(bisect) { var array = [], i = i30; array[i++] = 1; @@ -114,20 +114,20 @@ suite.addBatch({ array[i++] = 3; array[i++] = 4; array[i++] = 5; - assert.equal(d3.bisectRight(array, 0, i - 5, i), i - 5); - assert.equal(d3.bisectRight(array, 1, i - 5, i), i - 4); - assert.equal(d3.bisectRight(array, 2, i - 5, i), i - 3); - assert.equal(d3.bisectRight(array, 3, i - 5, i), i - 2); - assert.equal(d3.bisectRight(array, 4, i - 5, i), i - 1); - assert.equal(d3.bisectRight(array, 5, i - 5, i), i - 0); - assert.equal(d3.bisectRight(array, 6, i - 5, i), i - 0); + assert.equal(bisect(array, 0, i - 5, i), i - 5); + assert.equal(bisect(array, 1, i - 5, i), i - 4); + assert.equal(bisect(array, 2, i - 5, i), i - 3); + assert.equal(bisect(array, 3, i - 5, i), i - 2); + assert.equal(bisect(array, 4, i - 5, i), i - 1); + assert.equal(bisect(array, 5, i - 5, i), i - 0); + assert.equal(bisect(array, 6, i - 5, i), i - 0); } }, "bisector(key)": { - topic: load("arrays/bisect"), + topic: load("arrays/bisect").expression("d3.bisector"), "left": { - topic: function(d3) { - return d3.bisector(function(d) { return d.key; }).left; + topic: function(bisector) { + return bisector(function(d) { return d.key; }).left; }, "finds the index of an exact match": function(bisect) { var array = [{key: 1}, {key: 2}, {key: 3}]; @@ -186,8 +186,8 @@ suite.addBatch({ } }, "right": { - topic: function(d3) { - return d3.bisector(function(d) { return d.key; }).right; + topic: function(bisector) { + return bisector(function(d) { return d.key; }).right; }, "finds the index after an exact match": function(bisect) { var array = [{key: 1}, {key: 2}, {key: 3}]; diff --git a/test/arrays/descending-test.js b/test/arrays/descending-test.js index fb0639b9..1de84b0c 100644 --- a/test/arrays/descending-test.js +++ b/test/arrays/descending-test.js @@ -6,37 +6,37 @@ var suite = vows.describe("d3.descending"); suite.addBatch({ "descending": { - topic: load("arrays/descending"), + topic: load("arrays/descending").expression("d3.descending"), "numbers": { - "returns a negative number if a > b": function(d3) { - assert.isTrue(d3.descending(1, 0) < 0); + "returns a negative number if a > b": function(descending) { + assert.isTrue(descending(1, 0) < 0); }, - "returns a positive number if a < b": function(d3) { - assert.isTrue(d3.descending(0, 1) > 0); + "returns a positive number if a < b": function(descending) { + assert.isTrue(descending(0, 1) > 0); }, - "returns zero if a == b": function(d3) { - assert.equal(d3.descending(0, 0), 0); + "returns zero if a == b": function(descending) { + assert.equal(descending(0, 0), 0); }, - "returns NaN if a or b is undefined": function(d3) { - assert.isNaN(d3.descending(0, undefined)); - assert.isNaN(d3.descending(undefined, 0)); - assert.isNaN(d3.descending(undefined, undefined)); + "returns NaN if a or b is undefined": function(descending) { + assert.isNaN(descending(0, undefined)); + assert.isNaN(descending(undefined, 0)); + assert.isNaN(descending(undefined, undefined)); }, - "returns NaN if a or b is NaN": function(d3) { - assert.isNaN(d3.descending(0, NaN)); - assert.isNaN(d3.descending(NaN, 0)); - assert.isNaN(d3.descending(NaN, NaN)); + "returns NaN if a or b is NaN": function(descending) { + assert.isNaN(descending(0, NaN)); + assert.isNaN(descending(NaN, 0)); + assert.isNaN(descending(NaN, NaN)); } }, "strings": { - "returns a negative number if a > b": function(d3) { - assert.isTrue(d3.descending("b", "a") < 0); + "returns a negative number if a > b": function(descending) { + assert.isTrue(descending("b", "a") < 0); }, - "returns a positive number if a < b": function(d3) { - assert.isTrue(d3.descending("a", "b") > 0); + "returns a positive number if a < b": function(descending) { + assert.isTrue(descending("a", "b") > 0); }, - "returns zero if a == b": function(d3) { - assert.equal(d3.descending("a", "a"), 0); + "returns zero if a == b": function(descending) { + assert.equal(descending("a", "a"), 0); } } } diff --git a/test/arrays/entries-test.js b/test/arrays/entries-test.js index 3b56c9b7..03eecfd5 100644 --- a/test/arrays/entries-test.js +++ b/test/arrays/entries-test.js @@ -6,27 +6,27 @@ var suite = vows.describe("d3.entries"); suite.addBatch({ "entries": { - topic: load("arrays/entries"), - "enumerates every entry": function(d3) { - assert.deepEqual(d3.entries({a: 1, b: 2}), [ + topic: load("arrays/entries").expression("d3.entries"), + "enumerates every entry": function(entries) { + assert.deepEqual(entries({a: 1, b: 2}), [ {key: "a", value: 1}, {key: "b", value: 2} ]); }, - "includes entries defined on prototypes": function(d3) { + "includes entries defined on prototypes": function(entries) { function abc() { this.a = 1; this.b = 2; } abc.prototype.c = 3; - assert.deepEqual(d3.entries(new abc()), [ + assert.deepEqual(entries(new abc()), [ {key: "a", value: 1}, {key: "b", value: 2}, {key: "c", value: 3} ]); }, - "includes null or undefined values": function(d3) { - var v = d3.entries({a: undefined, b: null, c: NaN}); + "includes null or undefined values": function(entries) { + var v = entries({a: undefined, b: null, c: NaN}); assert.equal(v.length, 3); assert.deepEqual(v[0], {key: "a", value: undefined}); assert.deepEqual(v[1], {key: "b", value: null}); diff --git a/test/arrays/extent-test.js b/test/arrays/extent-test.js index 54867e70..d107531e 100644 --- a/test/arrays/extent-test.js +++ b/test/arrays/extent-test.js @@ -6,40 +6,40 @@ var suite = vows.describe("d3.extent"); suite.addBatch({ "extent": { - topic: load("arrays/extent"), - "returns the numeric extent for numbers": function(d3) { - assert.deepEqual(d3.extent([1]), [1, 1]); - assert.deepEqual(d3.extent([5, 1, 2, 3, 4]), [1, 5]); - assert.deepEqual(d3.extent([20, 3]), [3, 20]); - assert.deepEqual(d3.extent([3, 20]), [3, 20]); + topic: load("arrays/extent").expression("d3.extent"), + "returns the numeric extent for numbers": function(extent) { + assert.deepEqual(extent([1]), [1, 1]); + assert.deepEqual(extent([5, 1, 2, 3, 4]), [1, 5]); + assert.deepEqual(extent([20, 3]), [3, 20]); + assert.deepEqual(extent([3, 20]), [3, 20]); }, - "returns the lexicographic extent for strings": function(d3) { - assert.deepEqual(d3.extent(["c", "a", "b"]), ["a", "c"]); - assert.deepEqual(d3.extent(["20", "3"]), ["20", "3"]); - assert.deepEqual(d3.extent(["3", "20"]), ["20", "3"]); + "returns the lexicographic extent for strings": function(extent) { + assert.deepEqual(extent(["c", "a", "b"]), ["a", "c"]); + assert.deepEqual(extent(["20", "3"]), ["20", "3"]); + assert.deepEqual(extent(["3", "20"]), ["20", "3"]); }, - "ignores null, undefined and NaN": function(d3) { - assert.deepEqual(d3.extent([NaN, 1, 2, 3, 4, 5]), [1, 5]); - assert.deepEqual(d3.extent([1, 2, 3, 4, 5, NaN]), [1, 5]); - assert.deepEqual(d3.extent([10, null, 3, undefined, 5, NaN]), [3, 10]); - assert.deepEqual(d3.extent([-1, null, -3, undefined, -5, NaN]), [-5, -1]); + "ignores null, undefined and NaN": function(extent) { + assert.deepEqual(extent([NaN, 1, 2, 3, 4, 5]), [1, 5]); + assert.deepEqual(extent([1, 2, 3, 4, 5, NaN]), [1, 5]); + assert.deepEqual(extent([10, null, 3, undefined, 5, NaN]), [3, 10]); + assert.deepEqual(extent([-1, null, -3, undefined, -5, NaN]), [-5, -1]); }, - "compares heterogenous types as numbers": function(d3) { - assert.deepEqual(d3.extent([20, "3"]), ["3", 20]); - assert.deepEqual(d3.extent(["20", 3]), [3, "20"]); - assert.deepEqual(d3.extent([3, "20"]), [3, "20"]); - assert.deepEqual(d3.extent(["3", 20]), ["3", 20]); + "compares heterogenous types as numbers": function(extent) { + assert.deepEqual(extent([20, "3"]), ["3", 20]); + assert.deepEqual(extent(["20", 3]), [3, "20"]); + assert.deepEqual(extent([3, "20"]), [3, "20"]); + assert.deepEqual(extent(["3", 20]), ["3", 20]); }, - "returns undefined for empty array": function(d3) { - assert.deepEqual(d3.extent([]), [undefined, undefined]); - assert.deepEqual(d3.extent([null]), [undefined, undefined]); - assert.deepEqual(d3.extent([undefined]), [undefined, undefined]); - assert.deepEqual(d3.extent([NaN]), [undefined, undefined]); - assert.deepEqual(d3.extent([NaN, NaN]), [undefined, undefined]); + "returns undefined for empty array": function(extent) { + assert.deepEqual(extent([]), [undefined, undefined]); + assert.deepEqual(extent([null]), [undefined, undefined]); + assert.deepEqual(extent([undefined]), [undefined, undefined]); + assert.deepEqual(extent([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; - 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]); } } }); diff --git a/test/arrays/keys-test.js b/test/arrays/keys-test.js index 20e1ebce..c54a0ae2 100644 --- a/test/arrays/keys-test.js +++ b/test/arrays/keys-test.js @@ -6,20 +6,20 @@ var suite = vows.describe("d3.keys"); suite.addBatch({ "keys": { - topic: load("arrays/keys"), - "enumerates every defined key": function(d3) { - assert.deepEqual(d3.keys({a: 1, b: 1}), ["a", "b"]); + topic: load("arrays/keys").expression("d3.keys"), + "enumerates every defined key": function(keys) { + 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() { this.a = 1; this.b = 2; } 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) { - assert.deepEqual(d3.keys({a: undefined, b: null, c: NaN}), ["a", "b", "c"]); + "includes keys with null or undefined values": function(keys) { + assert.deepEqual(keys({a: undefined, b: null, c: NaN}), ["a", "b", "c"]); } } }); diff --git a/test/arrays/map-test.js b/test/arrays/map-test.js index 35887fe8..62a20157 100644 --- a/test/arrays/map-test.js +++ b/test/arrays/map-test.js @@ -6,202 +6,202 @@ var suite = vows.describe("d3.map"); suite.addBatch({ "map": { - topic: load("arrays/map"), + topic: load("arrays/map").expression("d3.map"), "constructor": { - "map() returns an empty map": function(d3) { - var map = d3.map(); - assert.deepEqual(map.keys(), []); + "map() returns an empty map": function(map) { + var m = map(); + assert.deepEqual(m.keys(), []); }, - "map(null) returns an empty map": function(d3) { - var map = d3.map(null); - assert.deepEqual(map.keys(), []); + "map(null) returns an empty map": function(map) { + var m = map(null); + assert.deepEqual(m.keys(), []); }, - "map(object) copies enumerable keys": function(d3) { - var map = d3.map({foo: 42}); - assert.isTrue(map.has("foo")); - assert.equal(map.get("foo"), 42); - var map = d3.map(Object.create(null, {foo: {value: 42, enumerable: true}})); - assert.isTrue(map.has("foo")); - assert.equal(map.get("foo"), 42); + "map(object) copies enumerable keys": function(map) { + var m = map({foo: 42}); + assert.isTrue(m.has("foo")); + assert.equal(m.get("foo"), 42); + var m = map(Object.create(null, {foo: {value: 42, enumerable: true}})); + assert.isTrue(m.has("foo")); + assert.equal(m.get("foo"), 42); }, - "map(object) copies inherited keys": function(d3) { + "map(object) copies inherited keys": function(map) { function Foo() {} Foo.prototype.foo = 42; - var map = d3.map(Object.create({foo: 42})); - assert.isTrue(map.has("foo")); - assert.equal(map.get("foo"), 42); - var map = d3.map(new Foo()); - assert.isTrue(map.has("foo")); - assert.equal(map.get("foo"), 42); + var m = map(Object.create({foo: 42})); + assert.isTrue(m.has("foo")); + assert.equal(m.get("foo"), 42); + var m = map(new Foo()); + assert.isTrue(m.has("foo")); + assert.equal(m.get("foo"), 42); }, - "map(object) does not copy non-enumerable keys": function(d3) { - var map = d3.map({__proto__: 42}); // because __proto__ isn't enumerable - assert.isFalse(map.has("__proto__")); - assert.isUndefined(map.get("__proto__")); - var map = d3.map(Object.create(null, {foo: {value: 42, enumerable: false}})); - assert.isFalse(map.has("foo")); - assert.isUndefined(map.get("foo")); + "map(object) does not copy non-enumerable keys": function(map) { + var m = map({__proto__: 42}); // because __proto__ isn't enumerable + assert.isFalse(m.has("__proto__")); + assert.isUndefined(m.get("__proto__")); + var m = map(Object.create(null, {foo: {value: 42, enumerable: false}})); + assert.isFalse(m.has("foo")); + assert.isUndefined(m.get("foo")); } }, "forEach": { - "empty maps have an empty keys array": function(d3) { - var map = d3.map(); - assert.deepEqual(map.entries(), []); - map.set("foo", "bar"); - assert.deepEqual(map.entries(), [{key: "foo", value: "bar"}]); - map.remove("foo"); - assert.deepEqual(map.entries(), []); + "empty maps have an empty keys array": function(map) { + var m = map(); + assert.deepEqual(m.entries(), []); + m.set("foo", "bar"); + assert.deepEqual(m.entries(), [{key: "foo", value: "bar"}]); + m.remove("foo"); + assert.deepEqual(m.entries(), []); }, - "keys are returned in arbitrary order": function(d3) { - var map = d3.map({foo: 1, bar: "42"}); - assert.deepEqual(map.entries().sort(ascendingByKey), [{key: "bar", value: "42"}, {key: "foo", value: 1}]); - var map = d3.map({bar: "42", foo: 1}); - assert.deepEqual(map.entries().sort(ascendingByKey), [{key: "bar", value: "42"}, {key: "foo", value: 1}]); + "keys are returned in arbitrary order": function(map) { + var m = map({foo: 1, bar: "42"}); + assert.deepEqual(m.entries().sort(ascendingByKey), [{key: "bar", value: "42"}, {key: "foo", value: 1}]); + var m = map({bar: "42", foo: 1}); + assert.deepEqual(m.entries().sort(ascendingByKey), [{key: "bar", value: "42"}, {key: "foo", value: 1}]); }, - "observes changes via set and remove": function(d3) { - var map = d3.map({foo: 1, bar: "42"}); - assert.deepEqual(map.entries().sort(ascendingByKey), [{key: "bar", value: "42"}, {key: "foo", value: 1}]); - map.remove("foo"); - assert.deepEqual(map.entries(), [{key: "bar", value: "42"}]); - map.set("bar", "bar"); - assert.deepEqual(map.entries(), [{key: "bar", value: "bar"}]); - map.set("foo", "foo"); - assert.deepEqual(map.entries().sort(ascendingByKey), [{key: "bar", value: "bar"}, {key: "foo", value: "foo"}]); - map.remove("bar"); - assert.deepEqual(map.entries(), [{key: "foo", value: "foo"}]); - map.remove("foo"); - assert.deepEqual(map.entries(), []); - map.remove("foo"); - assert.deepEqual(map.entries(), []); + "observes changes via set and remove": function(map) { + var m = map({foo: 1, bar: "42"}); + assert.deepEqual(m.entries().sort(ascendingByKey), [{key: "bar", value: "42"}, {key: "foo", value: 1}]); + m.remove("foo"); + assert.deepEqual(m.entries(), [{key: "bar", value: "42"}]); + m.set("bar", "bar"); + assert.deepEqual(m.entries(), [{key: "bar", value: "bar"}]); + m.set("foo", "foo"); + assert.deepEqual(m.entries().sort(ascendingByKey), [{key: "bar", value: "bar"}, {key: "foo", value: "foo"}]); + m.remove("bar"); + assert.deepEqual(m.entries(), [{key: "foo", value: "foo"}]); + m.remove("foo"); + assert.deepEqual(m.entries(), []); + m.remove("foo"); + assert.deepEqual(m.entries(), []); } }, "keys": { - "returns an array of string keys": function(d3) { - var map = d3.map({foo: 1, bar: "42"}); - assert.deepEqual(map.keys().sort(), ["bar", "foo"]); + "returns an array of string keys": function(map) { + var m = map({foo: 1, bar: "42"}); + assert.deepEqual(m.keys().sort(), ["bar", "foo"]); } }, "values": { - "returns an array of arbitrary values": function(d3) { - var map = d3.map({foo: 1, bar: "42"}); - assert.deepEqual(map.values().sort(), [1, "42"]); + "returns an array of arbitrary values": function(map) { + var m = map({foo: 1, bar: "42"}); + assert.deepEqual(m.values().sort(), [1, "42"]); } }, "entries": { - "returns an array of key-value objects": function(d3) { - var map = d3.map({foo: 1, bar: "42"}); - assert.deepEqual(map.entries().sort(ascendingByKey), [{key: "bar", value: "42"}, {key: "foo", value: 1}]); + "returns an array of key-value objects": function(map) { + var m = map({foo: 1, bar: "42"}); + assert.deepEqual(m.entries().sort(ascendingByKey), [{key: "bar", value: "42"}, {key: "foo", value: 1}]); } }, "has": { - "empty maps do not have object built-ins": function(d3) { - var map = d3.map(); - assert.isFalse(map.has("__proto__")); - assert.isFalse(map.has("hasOwnProperty")); + "empty maps do not have object built-ins": function(map) { + var m = map(); + assert.isFalse(m.has("__proto__")); + assert.isFalse(m.has("hasOwnProperty")); }, - "can has keys using built-in names": function(d3) { - var map = d3.map(); - map.set("__proto__", 42); - assert.isTrue(map.has("__proto__")); + "can has keys using built-in names": function(map) { + var m = map(); + m.set("__proto__", 42); + assert.isTrue(m.has("__proto__")); }, - "can has keys with null or undefined properties": function(d3) { - var map = d3.map(); - map.set("", ""); - map.set("null", null); - map.set("undefined", undefined); - assert.isTrue(map.has("")); - assert.isTrue(map.has("null")); - assert.isTrue(map.has("undefined")); + "can has keys with null or undefined properties": function(map) { + var m = map(); + m.set("", ""); + m.set("null", null); + m.set("undefined", undefined); + assert.isTrue(m.has("")); + assert.isTrue(m.has("null")); + assert.isTrue(m.has("undefined")); }, - "coerces keys to strings": function(d3) { - var map = d3.map({"42": "foo", "null": 1, "undefined": 2}); - assert.isTrue(map.has(42)); - assert.isTrue(map.has(null)); - assert.isTrue(map.has(undefined)); + "coerces keys to strings": function(map) { + var m = map({"42": "foo", "null": 1, "undefined": 2}); + assert.isTrue(m.has(42)); + assert.isTrue(m.has(null)); + assert.isTrue(m.has(undefined)); }, - "returns the latest value": function(d3) { - var map = d3.map({foo: 42}); - assert.isTrue(map.has("foo")); - map.set("foo", 43); - assert.isTrue(map.has("foo")); - map.remove("foo"); - assert.isFalse(map.has("foo")); - map.set("foo", "bar"); - assert.isTrue(map.has("foo")); + "returns the latest value": function(map) { + var m = map({foo: 42}); + assert.isTrue(m.has("foo")); + m.set("foo", 43); + assert.isTrue(m.has("foo")); + m.remove("foo"); + assert.isFalse(m.has("foo")); + m.set("foo", "bar"); + assert.isTrue(m.has("foo")); }, - "returns undefined for missing keys": function(d3) { - var map = d3.map({foo: 42}); - assert.isFalse(map.has("bar")); + "returns undefined for missing keys": function(map) { + var m = map({foo: 42}); + assert.isFalse(m.has("bar")); } }, "get": { - "empty maps do not have object built-ins": function(d3) { - var map = d3.map(); - assert.isUndefined(map.get("__proto__")); - assert.isUndefined(map.get("hasOwnProperty")); + "empty maps do not have object built-ins": function(map) { + var m = map(); + assert.isUndefined(m.get("__proto__")); + assert.isUndefined(m.get("hasOwnProperty")); }, - "can get keys using built-in names": function(d3) { - var map = d3.map(); - map.set("__proto__", 42); - assert.equal(map.get("__proto__"), 42); + "can get keys using built-in names": function(map) { + var m = map(); + m.set("__proto__", 42); + assert.equal(m.get("__proto__"), 42); }, - "coerces keys to strings": function(d3) { - var map = d3.map({"42": 1, "null": 2, "undefined": 3}); - assert.equal(map.get(42), 1); - assert.equal(map.get(null), 2); - assert.equal(map.get(undefined), 3); + "coerces keys to strings": function(map) { + var m = map({"42": 1, "null": 2, "undefined": 3}); + assert.equal(m.get(42), 1); + assert.equal(m.get(null), 2); + assert.equal(m.get(undefined), 3); }, - "returns the latest value": function(d3) { - var map = d3.map({foo: 42}); - assert.equal(map.get("foo"), 42); - map.set("foo", 43); - assert.equal(map.get("foo"), 43); - map.remove("foo"); - assert.isUndefined(map.get("foo")); - map.set("foo", "bar"); - assert.equal(map.get("foo"), "bar"); + "returns the latest value": function(map) { + var m = map({foo: 42}); + assert.equal(m.get("foo"), 42); + m.set("foo", 43); + assert.equal(m.get("foo"), 43); + m.remove("foo"); + assert.isUndefined(m.get("foo")); + m.set("foo", "bar"); + assert.equal(m.get("foo"), "bar"); }, - "returns undefined for missing keys": function(d3) { - var map = d3.map({foo: 42}); - assert.isUndefined(map.get("bar")); + "returns undefined for missing keys": function(map) { + var m = map({foo: 42}); + assert.isUndefined(m.get("bar")); } }, "set": { - "returns the set value": function(d3) { - var map = d3.map(); - assert.equal(map.set("foo", 42), 42); + "returns the set value": function(map) { + var m = map(); + assert.equal(m.set("foo", 42), 42); }, - "can set keys using built-in names": function(d3) { - var map = d3.map(); - map.set("__proto__", 42); - assert.equal(map.get("__proto__"), 42); + "can set keys using built-in names": function(map) { + var m = map(); + m.set("__proto__", 42); + assert.equal(m.get("__proto__"), 42); }, - "coerces keys to strings": function(d3) { - var map = d3.map(); - map.set(42, 1); - assert.equal(map.get(42), 1); - map.set(null, 2); - assert.equal(map.get(null), 2); - map.set(undefined, 3); - assert.equal(map.get(undefined), 3); - assert.deepEqual(map.keys().sort(), ["42", "null", "undefined"]); + "coerces keys to strings": function(map) { + var m = map(); + m.set(42, 1); + assert.equal(m.get(42), 1); + m.set(null, 2); + assert.equal(m.get(null), 2); + m.set(undefined, 3); + assert.equal(m.get(undefined), 3); + assert.deepEqual(m.keys().sort(), ["42", "null", "undefined"]); }, - "can replace values": function(d3) { - var map = d3.map({foo: 42}); - assert.equal(map.get("foo"), 42); - map.set("foo", 43); - assert.equal(map.get("foo"), 43); - map.set("foo", "bar"); - assert.equal(map.get("foo"), "bar"); + "can replace values": function(map) { + var m = map({foo: 42}); + assert.equal(m.get("foo"), 42); + m.set("foo", 43); + assert.equal(m.get("foo"), 43); + m.set("foo", "bar"); + assert.equal(m.get("foo"), "bar"); }, - "can set null, undefined or empty string values": function(d3) { - var map = d3.map(); - map.set("", ""); - map.set("null", null); - map.set("undefined", undefined); - assert.equal(map.get(""), ""); - assert.isNull(map.get("null")); - assert.isUndefined(map.get("undefined")); + "can set null, undefined or empty string values": function(map) { + var m = map(); + m.set("", ""); + m.set("null", null); + m.set("undefined", undefined); + assert.equal(m.get(""), ""); + assert.isNull(m.get("null")); + assert.isUndefined(m.get("undefined")); } } } diff --git a/test/arrays/max-test.js b/test/arrays/max-test.js index 7a3b0ec5..5500a7a2 100644 --- a/test/arrays/max-test.js +++ b/test/arrays/max-test.js @@ -1,4 +1,5 @@ var vows = require("vows"), + d3 = require("../../"), load = require("../load"), assert = require("../env-assert"); @@ -6,40 +7,40 @@ var suite = vows.describe("d3.max"); suite.addBatch({ "max": { - topic: load("arrays/max", "arrays/min"), - "returns the greatest numeric value for numbers": function(d3) { - assert.equal(d3.max([1]), 1); - assert.equal(d3.max([5, 1, 2, 3, 4]), 5); - assert.equal(d3.max([20, 3]), 20); - assert.equal(d3.max([3, 20]), 20); + topic: load("arrays/max").expression("d3.max"), + "returns the greatest numeric value for numbers": function(max) { + assert.equal(max([1]), 1); + assert.equal(max([5, 1, 2, 3, 4]), 5); + assert.equal(max([20, 3]), 20); + assert.equal(max([3, 20]), 20); }, - "returns the greatest lexicographic value for strings": function(d3) { - assert.equal(d3.max(["c", "a", "b"]), "c"); - assert.equal(d3.max(["20", "3"]), "3"); - assert.equal(d3.max(["3", "20"]), "3"); + "returns the greatest lexicographic value for strings": function(max) { + assert.equal(max(["c", "a", "b"]), "c"); + assert.equal(max(["20", "3"]), "3"); + assert.equal(max(["3", "20"]), "3"); }, - "ignores null, undefined and NaN": function(d3) { - assert.equal(d3.max([NaN, 1, 2, 3, 4, 5]), 5); - assert.equal(d3.max([1, 2, 3, 4, 5, NaN]), 5); - assert.equal(d3.max([10, null, 3, undefined, 5, NaN]), 10); - assert.equal(d3.max([-1, null, -3, undefined, -5, NaN]), -1); + "ignores null, undefined and NaN": function(max) { + assert.equal(max([NaN, 1, 2, 3, 4, 5]), 5); + assert.equal(max([1, 2, 3, 4, 5, NaN]), 5); + assert.equal(max([10, null, 3, undefined, 5, NaN]), 10); + assert.equal(max([-1, null, -3, undefined, -5, NaN]), -1); }, - "compares heterogenous types as numbers": function(d3) { - assert.strictEqual(d3.max([20, "3"]), 20); - assert.strictEqual(d3.max(["20", 3]), "20"); - assert.strictEqual(d3.max([3, "20"]), "20"); - assert.strictEqual(d3.max(["3", 20]), 20); + "compares heterogenous types as numbers": function(max) { + assert.strictEqual(max([20, "3"]), 20); + assert.strictEqual(max(["20", 3]), "20"); + assert.strictEqual(max([3, "20"]), "20"); + assert.strictEqual(max(["3", 20]), 20); }, - "returns undefined for empty array": function(d3) { - assert.isUndefined(d3.max([])); - assert.isUndefined(d3.max([null])); - assert.isUndefined(d3.max([undefined])); - assert.isUndefined(d3.max([NaN])); - assert.isUndefined(d3.max([NaN, NaN])); + "returns undefined for empty array": function(max) { + assert.isUndefined(max([])); + assert.isUndefined(max([null])); + assert.isUndefined(max([undefined])); + assert.isUndefined(max([NaN])); + assert.isUndefined(max([NaN, NaN])); }, - "applies the optional accessor function": function(d3) { - assert.equal(d3.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); + "applies the optional accessor function": function(max) { + assert.equal(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], function(d, i) { return i; }), 4); } } }); diff --git a/test/arrays/mean-test.js b/test/arrays/mean-test.js index 41d12332..1af0a5c8 100644 --- a/test/arrays/mean-test.js +++ b/test/arrays/mean-test.js @@ -6,32 +6,32 @@ var suite = vows.describe("d3.mean"); suite.addBatch({ "mean": { - topic: load("arrays/mean"), - "returns the mean value for numbers": function(d3) { - assert.equal(d3.mean([1]), 1); - assert.equal(d3.mean([5, 1, 2, 3, 4]), 3); - assert.equal(d3.mean([20, 3]), 11.5); - assert.equal(d3.mean([3, 20]), 11.5); + topic: load("arrays/mean").expression("d3.mean"), + "returns the mean value for numbers": function(mean) { + assert.equal(mean([1]), 1); + assert.equal(mean([5, 1, 2, 3, 4]), 3); + assert.equal(mean([20, 3]), 11.5); + assert.equal(mean([3, 20]), 11.5); }, - "ignores null, undefined and NaN": function(d3) { - assert.equal(d3.mean([NaN, 1, 2, 3, 4, 5]), 3); - assert.equal(d3.mean([1, 2, 3, 4, 5, NaN]), 3); - assert.equal(d3.mean([10, null, 3, undefined, 5, NaN]), 6); + "ignores null, undefined and NaN": function(mean) { + assert.equal(mean([NaN, 1, 2, 3, 4, 5]), 3); + assert.equal(mean([1, 2, 3, 4, 5, NaN]), 3); + assert.equal(mean([10, null, 3, undefined, 5, NaN]), 6); }, - "can handle large numbers without overflowing": function(d3) { - assert.equal(d3.mean([Number.MAX_VALUE, Number.MAX_VALUE]), Number.MAX_VALUE); - assert.equal(d3.mean([-Number.MAX_VALUE, -Number.MAX_VALUE]), -Number.MAX_VALUE); + "can handle large numbers without overflowing": function(mean) { + assert.equal(mean([Number.MAX_VALUE, Number.MAX_VALUE]), Number.MAX_VALUE); + assert.equal(mean([-Number.MAX_VALUE, -Number.MAX_VALUE]), -Number.MAX_VALUE); }, - "returns undefined for empty array": function(d3) { - assert.isUndefined(d3.mean([])); - assert.isUndefined(d3.mean([null])); - assert.isUndefined(d3.mean([undefined])); - assert.isUndefined(d3.mean([NaN])); - assert.isUndefined(d3.mean([NaN, NaN])); + "returns undefined for empty array": function(mean) { + assert.isUndefined(mean([])); + assert.isUndefined(mean([null])); + assert.isUndefined(mean([undefined])); + assert.isUndefined(mean([NaN])); + assert.isUndefined(mean([NaN, NaN])); }, - "applies the optional accessor function": function(d3) { - assert.equal(d3.mean([[1, 2, 3, 4, 5], [2, 4, 6, 8, 10]], function(d) { return d3.mean(d); }), 4.5); - assert.equal(d3.mean([1, 2, 3, 4, 5], function(d, i) { return i; }), 2); + "applies the optional accessor function": function(mean) { + assert.equal(mean([[1, 2, 3, 4, 5], [2, 4, 6, 8, 10]], function(d) { return mean(d); }), 4.5); + assert.equal(mean([1, 2, 3, 4, 5], function(d, i) { return i; }), 2); } } }); diff --git a/test/arrays/median-test.js b/test/arrays/median-test.js index 12525f70..400ea645 100644 --- a/test/arrays/median-test.js +++ b/test/arrays/median-test.js @@ -6,32 +6,32 @@ var suite = vows.describe("d3.median"); suite.addBatch({ "median": { - topic: load("arrays/median"), - "returns the median value for numbers": function(d3) { - assert.equal(d3.median([1]), 1); - assert.equal(d3.median([5, 1, 2, 3, 4]), 3); - assert.equal(d3.median([20, 3]), 11.5); - assert.equal(d3.median([3, 20]), 11.5); + topic: load("arrays/median").expression("d3.median"), + "returns the median value for numbers": function(median) { + assert.equal(median([1]), 1); + assert.equal(median([5, 1, 2, 3, 4]), 3); + assert.equal(median([20, 3]), 11.5); + assert.equal(median([3, 20]), 11.5); }, - "ignores null, undefined and NaN": function(d3) { - assert.equal(d3.median([NaN, 1, 2, 3, 4, 5]), 3); - assert.equal(d3.median([1, 2, 3, 4, 5, NaN]), 3); - assert.equal(d3.median([10, null, 3, undefined, 5, NaN]), 5); + "ignores null, undefined and NaN": function(median) { + assert.equal(median([NaN, 1, 2, 3, 4, 5]), 3); + assert.equal(median([1, 2, 3, 4, 5, NaN]), 3); + assert.equal(median([10, null, 3, undefined, 5, NaN]), 5); }, - "can handle large numbers without overflowing": function(d3) { - assert.equal(d3.median([Number.MAX_VALUE, Number.MAX_VALUE]), Number.MAX_VALUE); - assert.equal(d3.median([-Number.MAX_VALUE, -Number.MAX_VALUE]), -Number.MAX_VALUE); + "can handle large numbers without overflowing": function(median) { + assert.equal(median([Number.MAX_VALUE, Number.MAX_VALUE]), Number.MAX_VALUE); + assert.equal(median([-Number.MAX_VALUE, -Number.MAX_VALUE]), -Number.MAX_VALUE); }, - "returns undefined for empty array": function(d3) { - assert.isUndefined(d3.median([])); - assert.isUndefined(d3.median([null])); - assert.isUndefined(d3.median([undefined])); - assert.isUndefined(d3.median([NaN])); - assert.isUndefined(d3.median([NaN, NaN])); + "returns undefined for empty array": function(median) { + assert.isUndefined(median([])); + assert.isUndefined(median([null])); + assert.isUndefined(median([undefined])); + assert.isUndefined(median([NaN])); + assert.isUndefined(median([NaN, NaN])); }, - "applies the optional accessor function": function(d3) { - assert.equal(d3.median([[1, 2, 3, 4, 5], [2, 4, 6, 8, 10]], function(d) { return d3.median(d); }), 4.5); - assert.equal(d3.median([1, 2, 3, 4, 5], function(d, i) { return i; }), 2); + "applies the optional accessor function": function(median) { + assert.equal(median([[1, 2, 3, 4, 5], [2, 4, 6, 8, 10]], function(d) { return median(d); }), 4.5); + assert.equal(median([1, 2, 3, 4, 5], function(d, i) { return i; }), 2); } } }); diff --git a/test/arrays/merge-test.js b/test/arrays/merge-test.js index 0ae94640..a48be2eb 100644 --- a/test/arrays/merge-test.js +++ b/test/arrays/merge-test.js @@ -6,18 +6,18 @@ var suite = vows.describe("d3.merge"); suite.addBatch({ "merge": { - topic: load("arrays/merge"), - "merges an array of arrays": function(d3) { + topic: load("arrays/merge").expression("d3.merge"), + "merges an array of arrays": function(merge) { 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]]; - 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]]; - d3.merge(input); + merge(input); assert.deepEqual(input, [[1, 2, 3], [4, 5], [6]]); } } diff --git a/test/arrays/min-test.js b/test/arrays/min-test.js index 0e916e11..84470ca6 100644 --- a/test/arrays/min-test.js +++ b/test/arrays/min-test.js @@ -1,4 +1,5 @@ var vows = require("vows"), + d3 = require("../../"), load = require("../load"), assert = require("../env-assert"); @@ -6,39 +7,39 @@ var suite = vows.describe("d3.min"); suite.addBatch({ "min": { - topic: load("arrays/min", "arrays/max"), - "returns the least numeric value for numbers": function(d3) { - assert.equal(d3.min([1]), 1); - assert.equal(d3.min([5, 1, 2, 3, 4]), 1); - assert.equal(d3.min([20, 3]), 3); - assert.equal(d3.min([3, 20]), 3); + topic: load("arrays/min").expression("d3.min"), + "returns the least numeric value for numbers": function(min) { + assert.equal(min([1]), 1); + assert.equal(min([5, 1, 2, 3, 4]), 1); + assert.equal(min([20, 3]), 3); + assert.equal(min([3, 20]), 3); }, - "returns the least lexicographic value for strings": function(d3) { - assert.equal(d3.min(["c", "a", "b"]), "a"); - assert.equal(d3.min(["20", "3"]), "20"); - assert.equal(d3.min(["3", "20"]), "20"); + "returns the least lexicographic value for strings": function(min) { + assert.equal(min(["c", "a", "b"]), "a"); + assert.equal(min(["20", "3"]), "20"); + assert.equal(min(["3", "20"]), "20"); }, - "ignores null, undefined and NaN": function(d3) { - assert.equal(d3.min([NaN, 1, 2, 3, 4, 5]), 1); - assert.equal(d3.min([1, 2, 3, 4, 5, NaN]), 1); - assert.equal(d3.min([10, null, 3, undefined, 5, NaN]), 3); + "ignores null, undefined and NaN": function(min) { + assert.equal(min([NaN, 1, 2, 3, 4, 5]), 1); + assert.equal(min([1, 2, 3, 4, 5, NaN]), 1); + assert.equal(min([10, null, 3, undefined, 5, NaN]), 3); }, - "compares heterogenous types as numbers": function(d3) { - assert.strictEqual(d3.min([20, "3"]), "3"); - assert.strictEqual(d3.min(["20", 3]), 3); - assert.strictEqual(d3.min([3, "20"]), 3); - assert.strictEqual(d3.min(["3", 20]), "3"); + "compares heterogenous types as numbers": function(min) { + assert.strictEqual(min([20, "3"]), "3"); + assert.strictEqual(min(["20", 3]), 3); + assert.strictEqual(min([3, "20"]), 3); + assert.strictEqual(min(["3", 20]), "3"); }, - "returns undefined for empty array": function(d3) { - assert.isUndefined(d3.min([])); - assert.isUndefined(d3.min([null])); - assert.isUndefined(d3.min([undefined])); - assert.isUndefined(d3.min([NaN])); - assert.isUndefined(d3.min([NaN, NaN])); + "returns undefined for empty array": function(min) { + assert.isUndefined(min([])); + assert.isUndefined(min([null])); + assert.isUndefined(min([undefined])); + assert.isUndefined(min([NaN])); + assert.isUndefined(min([NaN, NaN])); }, - "applies the optional accessor function": function(d3) { - assert.equal(d3.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); + "applies the optional accessor function": function(min) { + assert.equal(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], function(d, i) { return i; }), 0); } } }); diff --git a/test/arrays/nest-test.js b/test/arrays/nest-test.js index 6ca8c414..61c46f05 100644 --- a/test/arrays/nest-test.js +++ b/test/arrays/nest-test.js @@ -1,4 +1,5 @@ var vows = require("vows"), + d3 = require("../../"), load = require("../load"), assert = require("../env-assert"); @@ -6,17 +7,17 @@ var suite = vows.describe("d3.nest"); suite.addBatch({ "entries": { - topic: load("arrays/nest", "arrays/ascending", "arrays/descending", "arrays/sum"), - "returns an array of each distinct key in arbitrary order": function(d3) { - var keys = d3.nest() + topic: load("arrays/nest").expression("d3.nest"), + "returns an array of each distinct key in arbitrary order": function(nest) { + var keys = nest() .key(function(d) { return d.foo; }) .entries([{foo: 1}, {foo: 1}, {foo: 2}]) .map(function(d) { return d.key; }) .sort(d3.ascending); assert.deepEqual(keys, ["1", "2"]); }, - "each entry is a key-values object, with values in input order": function(d3) { - var entries = d3.nest() + "each entry is a key-values object, with values in input order": function(nest) { + var entries = nest() .key(function(d) { return d.foo; }) .entries([{foo: 1, bar: 0}, {foo: 2}, {foo: 1, bar: 1}]); assert.deepEqual(entries, [ @@ -24,15 +25,15 @@ suite.addBatch({ {key: "2", values: [{foo: 2}]} ]); }, - "keys can be sorted using an optional comparator": function(d3) { - var keys = d3.nest() + "keys can be sorted using an optional comparator": function(nest) { + var keys = nest() .key(function(d) { return d.foo; }).sortKeys(d3.descending) .entries([{foo: 1}, {foo: 1}, {foo: 2}]) .map(function(d) { return d.key; }); assert.deepEqual(keys, ["2", "1"]); }, - "values can be sorted using an optional comparator": function(d3) { - var entries = d3.nest() + "values can be sorted using an optional comparator": function(nest) { + var entries = nest() .key(function(d) { return d.foo; }) .sortValues(function(a, b) { return a.bar - b.bar; }) .entries([{foo: 1, bar: 2}, {foo: 1, bar: 0}, {foo: 1, bar: 1}, {foo: 2}]); @@ -41,8 +42,8 @@ suite.addBatch({ {key: "2", values: [{foo: 2}]} ]); }, - "values can be aggregated using an optional rollup": function(d3) { - var entries = d3.nest() + "values can be aggregated using an optional rollup": function(nest) { + var entries = nest() .key(function(d) { return d.foo; }) .rollup(function(values) { return d3.sum(values, function(d) { return d.bar; }); }) .entries([{foo: 1, bar: 2}, {foo: 1, bar: 0}, {foo: 1, bar: 1}, {foo: 2}]); @@ -51,8 +52,8 @@ suite.addBatch({ {key: "2", values: 0} ]); }, - "multiple key functions can be specified": function(d3) { - var entries = d3.nest() + "multiple key functions can be specified": function(nest) { + var entries = nest() .key(function(d) { return d[0]; }).sortKeys(d3.ascending) .key(function(d) { return d[1]; }).sortKeys(d3.ascending) .entries([[0, 1], [0, 2], [1, 1], [1, 2], [0, 2]]); @@ -67,8 +68,8 @@ suite.addBatch({ ]} ]); }, - "the rollup function only applies to leaf values": function(d3) { - var entries = d3.nest() + "the rollup function only applies to leaf values": function(nest) { + var entries = nest() .key(function(d) { return d[0]; }).sortKeys(d3.ascending) .key(function(d) { return d[1]; }).sortKeys(d3.ascending) .rollup(function(values) { return values.length; }) @@ -84,8 +85,8 @@ suite.addBatch({ ]} ]); }, - "the value comparator only applies to leaf values": function(d3) { - var entries = d3.nest() + "the value comparator only applies to leaf values": function(nest) { + var entries = nest() .key(function(d) { return d[0]; }).sortKeys(d3.ascending) .key(function(d) { return d[1]; }).sortKeys(d3.ascending) .sortValues(function(a, b) { return a[2] - b[2]; }) @@ -101,8 +102,8 @@ suite.addBatch({ ]} ]); }, - "the key comparator only applies to the last-specified key": function(d3) { - var entries = d3.nest() + "the key comparator only applies to the last-specified key": function(nest) { + var entries = nest() .key(function(d) { return d[0]; }).sortKeys(d3.ascending) .key(function(d) { return d[1]; }).sortKeys(d3.descending) .entries([[0, 1], [0, 2], [1, 1], [1, 2], [0, 2]]); @@ -116,7 +117,7 @@ suite.addBatch({ {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[1]; }).sortKeys(d3.ascending) .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()]; - assert.strictEqual(d3.nest().entries(array), array); + assert.strictEqual(nest().entries(array), array); } } }); suite.addBatch({ "map": { - topic: load("arrays/nest", "arrays/ascending", "arrays/descending", "arrays/sum"), - "returns a map of each distinct key": function(d3) { - var map = d3.nest() + topic: load("arrays/nest").expression("d3.nest"), + "returns a map of each distinct key": function(nest) { + var map = nest() .key(function(d) { return d.foo; }) .map([{foo: 1, bar: 0}, {foo: 2}, {foo: 1, bar: 1}]); assert.deepEqual(map, { @@ -150,8 +151,8 @@ suite.addBatch({ "2": [{foo: 2}] }); }, - "values can be sorted using an optional comparator": function(d3) { - var map = d3.nest() + "values can be sorted using an optional comparator": function(nest) { + var map = nest() .key(function(d) { return d.foo; }) .sortValues(function(a, b) { return a.bar - b.bar; }) .map([{foo: 1, bar: 2}, {foo: 1, bar: 0}, {foo: 1, bar: 1}, {foo: 2}]); @@ -160,8 +161,8 @@ suite.addBatch({ "2": [{foo: 2}] }); }, - "values can be aggregated using an optional rollup": function(d3) { - var map = d3.nest() + "values can be aggregated using an optional rollup": function(nest) { + var map = nest() .key(function(d) { return d.foo; }) .rollup(function(values) { return d3.sum(values, function(d) { return d.bar; }); }) .map([{foo: 1, bar: 2}, {foo: 1, bar: 0}, {foo: 1, bar: 1}, {foo: 2}]); @@ -170,8 +171,8 @@ suite.addBatch({ "2": 0 }); }, - "multiple key functions can be specified": function(d3) { - var map = d3.nest() + "multiple key functions can be specified": function(nest) { + var map = nest() .key(function(d) { return d[0]; }).sortKeys(d3.ascending) .key(function(d) { return d[1]; }).sortKeys(d3.ascending) .map([[0, 1], [0, 2], [1, 1], [1, 2], [0, 2]]); @@ -186,8 +187,8 @@ suite.addBatch({ } }); }, - "the rollup function only applies to leaf values": function(d3) { - var map = d3.nest() + "the rollup function only applies to leaf values": function(nest) { + var map = nest() .key(function(d) { return d[0]; }).sortKeys(d3.ascending) .key(function(d) { return d[1]; }).sortKeys(d3.ascending) .rollup(function(values) { return values.length; }) @@ -203,8 +204,8 @@ suite.addBatch({ } }); }, - "the value comparator only applies to leaf values": function(d3) { - var map = d3.nest() + "the value comparator only applies to leaf values": function(nest) { + var map = nest() .key(function(d) { return d[0]; }).sortKeys(d3.ascending) .key(function(d) { return d[1]; }).sortKeys(d3.ascending) .sortValues(function(a, b) { return a[2] - b[2]; }) @@ -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()]; - assert.strictEqual(d3.nest().map(array), array); + assert.strictEqual(nest().map(array), array); }, - "handles keys that are built-in prototype properties": function(d3) { - var map = d3.nest() + "handles keys that are built-in prototype properties": function(nest) { + var map = nest() .key(String) .map(["hasOwnProperty"]); // but note __proto__ wouldn’t work! assert.deepEqual(map, {hasOwnProperty: ["hasOwnProperty"]}); }, - "a custom map implementation can be specified": function(d3) { - var map = d3.nest() + "a custom map implementation can be specified": function(nest) { + var map = nest() .key(String) .map(["hasOwnProperty", "__proto__"], d3.map); assert.deepEqual(map.entries(), [ @@ -239,8 +240,8 @@ suite.addBatch({ {key: "__proto__", value: ["__proto__"]} ]); }, - "the custom map implementation works on multiple levels of nesting": function(d3) { - var map = d3.nest() + "the custom map implementation works on multiple levels of nesting": function(nest) { + var map = nest() .key(function(d) { return d.foo; }) .key(function(d) { return d.bar; }) .map([{foo: 42, bar: "red"}], d3.map); diff --git a/test/arrays/permute-test.js b/test/arrays/permute-test.js index f1df3523..c265d855 100644 --- a/test/arrays/permute-test.js +++ b/test/arrays/permute-test.js @@ -6,39 +6,39 @@ var suite = vows.describe("d3.permute"); suite.addBatch({ "permute": { - topic: load("arrays/permute"), - "permutes according to the specified index": function(d3) { - assert.deepEqual(d3.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(d3.permute([3, 4, 5], [0, 1, 2]), [3, 4, 5]); + topic: load("arrays/permute").expression("d3.permute"), + "permutes according to the specified index": function(permute) { + assert.deepEqual(permute([3, 4, 5], [2, 1, 0]), [5, 4, 3]); + assert.deepEqual(permute([3, 4, 5], [2, 0, 1]), [5, 3, 4]); + 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]; - d3.permute(input, [2, 1, 0]); + permute(input, [2, 1, 0]); assert.deepEqual(input, [3, 4, 5]); }, - "can duplicate input values": function(d3) { - assert.deepEqual(d3.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(d3.permute([3, 4, 5], [0, 1, 1]), [3, 4, 4]); + "can duplicate input values": function(permute) { + assert.deepEqual(permute([3, 4, 5], [0, 1, 0]), [3, 4, 3]); + assert.deepEqual(permute([3, 4, 5], [2, 2, 2]), [5, 5, 5]); + assert.deepEqual(permute([3, 4, 5], [0, 1, 1]), [3, 4, 4]); }, - "can return more elements": function(d3) { - assert.deepEqual(d3.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]); + "can return more elements": function(permute) { + assert.deepEqual(permute([3, 4, 5], [0, 0, 1, 2]), [3, 3, 4, 5]); + assert.deepEqual(permute([3, 4, 5], [0, 1, 1, 1]), [3, 4, 4, 4]); }, - "can return fewer elements": function(d3) { - assert.deepEqual(d3.permute([3, 4, 5], [0]), [3]); - assert.deepEqual(d3.permute([3, 4, 5], [1, 2]), [4, 5]); - assert.deepEqual(d3.permute([3, 4, 5], []), []); + "can return fewer elements": function(permute) { + assert.deepEqual(permute([3, 4, 5], [0]), [3]); + assert.deepEqual(permute([3, 4, 5], [1, 2]), [4, 5]); + assert.deepEqual(permute([3, 4, 5], []), []); }, - "can return undefined elements": function(d3) { - var v1 = d3.permute([3, 4, 5], [10]); + "can return undefined elements": function(permute) { + var v1 = permute([3, 4, 5], [10]); assert.equal(v1.length, 1); 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.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[0], 3); assert.isUndefined(v3[1]); diff --git a/test/arrays/quantile-test.js b/test/arrays/quantile-test.js index bdf59a48..df5b631d 100644 --- a/test/arrays/quantile-test.js +++ b/test/arrays/quantile-test.js @@ -6,49 +6,49 @@ var suite = vows.describe("d3.quantile"); suite.addBatch({ "quantile": { - topic: load("arrays/quantile"), - "requires sorted numeric input": function(d3) { - assert.equal(d3.quantile([1, 2, 3, 4], 0), 1); - assert.equal(d3.quantile([1, 2, 3, 4], 1), 4); - assert.equal(d3.quantile([4, 3, 2, 1], 0), 4); - assert.equal(d3.quantile([4, 3, 2, 1], 1), 1); + topic: load("arrays/quantile").expression("d3.quantile"), + "requires sorted numeric input": function(quantile) { + assert.equal(quantile([1, 2, 3, 4], 0), 1); + assert.equal(quantile([1, 2, 3, 4], 1), 4); + assert.equal(quantile([4, 3, 2, 1], 0), 4); + 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]; - assert.equal(d3.quantile(data, 0), 3); - assert.equal(d3.quantile(data, .25), 7.25); - assert.equal(d3.quantile(data, .5), 9); - assert.equal(d3.quantile(data, .75), 14.5); - assert.equal(d3.quantile(data, 1), 20); + assert.equal(quantile(data, 0), 3); + assert.equal(quantile(data, .25), 7.25); + assert.equal(quantile(data, .5), 9); + assert.equal(quantile(data, .75), 14.5); + assert.equal(quantile(data, 1), 20); var data = [3, 6, 7, 8, 8, 9, 10, 13, 15, 16, 20]; - assert.equal(d3.quantile(data, 0), 3); - assert.equal(d3.quantile(data, .25), 7.5); - assert.equal(d3.quantile(data, .5), 9); - assert.equal(d3.quantile(data, .75), 14); - assert.equal(d3.quantile(data, 1), 20); + assert.equal(quantile(data, 0), 3); + assert.equal(quantile(data, .25), 7.5); + assert.equal(quantile(data, .5), 9); + assert.equal(quantile(data, .75), 14); + assert.equal(quantile(data, 1), 20); }, - "coerces values to numbers": function(d3) { + "coerces values to numbers": function(quantile) { var strings = ["1", "2", "3", "4"]; - assert.strictEqual(d3.quantile(strings, 1/3), 2); - assert.strictEqual(d3.quantile(strings, 1/2), 2.5); - assert.strictEqual(d3.quantile(strings, 2/3), 3); + assert.strictEqual(quantile(strings, 1/3), 2); + assert.strictEqual(quantile(strings, 1/2), 2.5); + assert.strictEqual(quantile(strings, 2/3), 3); 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(d3.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, 0), +new Date(2011, 0, 1)); + assert.strictEqual(quantile(dates, 1/2), +new Date(2011, 6, 2, 13)); + 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]; - assert.equal(d3.quantile(data, 1/3), 2); - assert.equal(d3.quantile(data, 2/3), 3); + assert.equal(quantile(data, 1/3), 2); + 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]; - 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]; - assert.equal(d3.quantile(data, 1), 4); + assert.equal(quantile(data, 1), 4); } } }); diff --git a/test/arrays/range-test.js b/test/arrays/range-test.js index 4aa465be..f6912d97 100644 --- a/test/arrays/range-test.js +++ b/test/arrays/range-test.js @@ -6,92 +6,92 @@ var suite = vows.describe("d3.range"); suite.addBatch({ "range": { - topic: load("arrays/range"), - "start is an inclusive lower bound": function(d3) { - assert.equal(d3.range(5)[0], 0); - assert.equal(d3.range(1, 5)[0], 1); - assert.equal(d3.range(5, 1, -1)[0], 5); + topic: load("arrays/range").expression("d3.range"), + "start is an inclusive lower bound": function(range) { + assert.equal(range(5)[0], 0); + assert.equal(range(1, 5)[0], 1); + assert.equal(range(5, 1, -1)[0], 5); }, - "stop is an exclusive upper bound": function(d3) { - assert.equal(d3.range(5)[4], 4); - assert.equal(d3.range(1, 5)[3], 4); - assert.equal(d3.range(5, 1, -1)[3], 2); + "stop is an exclusive upper bound": function(range) { + assert.equal(range(5)[4], 4); + assert.equal(range(1, 5)[3], 4); + assert.equal(range(5, 1, -1)[3], 2); }, - "with one argument, returns integers [0 … stop)": function(d3) { - assert.deepEqual(d3.range(0), []); - assert.deepEqual(d3.range(1), [0]); - assert.deepEqual(d3.range(5), [0, 1, 2, 3, 4]); + "with one argument, returns integers [0 … stop)": function(range) { + assert.deepEqual(range(0), []); + assert.deepEqual(range(1), [0]); + assert.deepEqual(range(5), [0, 1, 2, 3, 4]); }, - "with two arguments, returns integers [start … stop)": function(d3) { - assert.deepEqual(d3.range(0, 5), [0, 1, 2, 3, 4]); - assert.deepEqual(d3.range(5, 9), [5, 6, 7, 8]); + "with two arguments, returns integers [start … stop)": function(range) { + assert.deepEqual(range(0, 5), [0, 1, 2, 3, 4]); + assert.deepEqual(range(5, 9), [5, 6, 7, 8]); }, - "with three arguments, returns start + k * step": function(d3) { - assert.deepEqual(d3.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(d3.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]); + "with three arguments, returns start + k * step": function(range) { + assert.deepEqual(range(0, 5, 1), [0, 1, 2, 3, 4]); + assert.deepEqual(range(5, 9, .5), [5, 5.5, 6, 6.5, 7, 7.5, 8, 8.5]); + assert.deepEqual(range(5, 8.5, .5), [5, 5.5, 6, 6.5, 7, 7.5, 8]); + assert.deepEqual(range(2, 0, -.5), [2, 1.5, 1, .5]); }, - "handles fractional steps without rounding errors": function(d3) { - assert.deepEqual(d3.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]); + "handles fractional steps without rounding errors": function(range) { + assert.deepEqual(range(0, 0.5, 0.1), [0, 0.1, 0.2, 0.3, 0.4]); + 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) { - assert.deepEqual(d3.range(2.1e-31, 5e-31, 1.1e-31), [2.1e-31, 3.2e-31, 4.3e-31]); + "handles extremely small steps without rounding errors": function(range) { + 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) { - assert.deepEqual(d3.range(1e300, 2e300, 0.3e300), [1e300, 1.3e300, 1.6e300, 1.9e300]); + "handles extremely large steps without rounding errors": function(range) { + assert.deepEqual(range(1e300, 2e300, 0.3e300), [1e300, 1.3e300, 1.6e300, 1.9e300]); }, - "returns an ascending range if step is positive": function(d3) { - assert.deepEqual(d3.range(0, 5, 1), [0, 1, 2, 3, 4]); + "returns an ascending range if step is positive": function(range) { + assert.deepEqual(range(0, 5, 1), [0, 1, 2, 3, 4]); }, - "returns a descending range if step is negative": function(d3) { - assert.deepEqual(d3.range(5, 0, -1), [5, 4, 3, 2, 1]); + "returns a descending range if step is negative": function(range) { + assert.deepEqual(range(5, 0, -1), [5, 4, 3, 2, 1]); }, - "returns an empty range if start, stop or step are NaN": function(d3) { - assert.isEmpty(d3.range(0, NaN)); - assert.isEmpty(d3.range(1, NaN)); - assert.isEmpty(d3.range(-1, NaN)); - assert.isEmpty(d3.range(0, undefined)); - assert.isEmpty(d3.range(1, undefined)); - assert.isEmpty(d3.range(-1, undefined)); - assert.isEmpty(d3.range(NaN, 0)); - assert.isEmpty(d3.range(NaN, 1)); - assert.isEmpty(d3.range(NaN, -1)); - assert.isEmpty(d3.range(undefined, 0)); - assert.isEmpty(d3.range(undefined, 1)); - assert.isEmpty(d3.range(undefined, -1)); - assert.isEmpty(d3.range(NaN, NaN)); - assert.isEmpty(d3.range(undefined, undefined)); - assert.isEmpty(d3.range(NaN, NaN, NaN)); - assert.isEmpty(d3.range(undefined, undefined, undefined)); - assert.isEmpty(d3.range(0, 10, NaN)); - assert.isEmpty(d3.range(10, 0, NaN)); - assert.isEmpty(d3.range(0, 10, undefined)); - assert.isEmpty(d3.range(10, 0, undefined)); + "returns an empty range if start, stop or step are NaN": function(range) { + assert.isEmpty(range(0, NaN)); + assert.isEmpty(range(1, NaN)); + assert.isEmpty(range(-1, NaN)); + assert.isEmpty(range(0, undefined)); + assert.isEmpty(range(1, undefined)); + assert.isEmpty(range(-1, undefined)); + assert.isEmpty(range(NaN, 0)); + assert.isEmpty(range(NaN, 1)); + assert.isEmpty(range(NaN, -1)); + assert.isEmpty(range(undefined, 0)); + assert.isEmpty(range(undefined, 1)); + assert.isEmpty(range(undefined, -1)); + assert.isEmpty(range(NaN, NaN)); + assert.isEmpty(range(undefined, undefined)); + assert.isEmpty(range(NaN, NaN, NaN)); + assert.isEmpty(range(undefined, undefined, undefined)); + assert.isEmpty(range(0, 10, NaN)); + assert.isEmpty(range(10, 0, NaN)); + assert.isEmpty(range(0, 10, undefined)); + assert.isEmpty(range(10, 0, undefined)); }, - "returns an empty range if start equals stop": function(d3) { - assert.isEmpty(d3.range(10, 10)); - assert.isEmpty(d3.range(10, 10, 1)); - assert.isEmpty(d3.range(10, 10, -1)); - assert.isEmpty(d3.range(10, 10, -.5)); - assert.isEmpty(d3.range(10, 10, .5)); - assert.isEmpty(d3.range(0, 0)); - assert.isEmpty(d3.range(0, 0, 1)); - assert.isEmpty(d3.range(0, 0, -1)); - assert.isEmpty(d3.range(0, 0, -.5)); - assert.isEmpty(d3.range(0, 0, .5)); + "returns an empty range if start equals stop": function(range) { + assert.isEmpty(range(10, 10)); + assert.isEmpty(range(10, 10, 1)); + assert.isEmpty(range(10, 10, -1)); + assert.isEmpty(range(10, 10, -.5)); + assert.isEmpty(range(10, 10, .5)); + assert.isEmpty(range(0, 0)); + assert.isEmpty(range(0, 0, 1)); + assert.isEmpty(range(0, 0, -1)); + assert.isEmpty(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) { - assert.isEmpty(d3.range(20, 10)); - assert.isEmpty(d3.range(20, 10, 2)); - assert.isEmpty(d3.range(20, 10, 1)); - assert.isEmpty(d3.range(20, 10, .5)); + "returns an empty range if stop is less than start and step is positive": function(range) { + assert.isEmpty(range(20, 10)); + assert.isEmpty(range(20, 10, 2)); + assert.isEmpty(range(20, 10, 1)); + assert.isEmpty(range(20, 10, .5)); }, - "returns an empty range if stop is greater than start and step is negative": function(d3) { - assert.isEmpty(d3.range(10, 20, -2)); - assert.isEmpty(d3.range(10, 20, -1)); - assert.isEmpty(d3.range(10, 20, -.5)); + "returns an empty range if stop is greater than start and step is negative": function(range) { + assert.isEmpty(range(10, 20, -2)); + assert.isEmpty(range(10, 20, -1)); + assert.isEmpty(range(10, 20, -.5)); } } }); diff --git a/test/arrays/set-test.js b/test/arrays/set-test.js index 2238d207..b934095d 100644 --- a/test/arrays/set-test.js +++ b/test/arrays/set-test.js @@ -1,4 +1,5 @@ var vows = require("vows"), + d3 = require("../../"), load = require("../load"), assert = require("assert"); @@ -6,127 +7,127 @@ var suite = vows.describe("d3.set"); suite.addBatch({ "set": { - topic: load("arrays/set", "arrays/ascending"), + topic: load("arrays/set").expression("d3.set"), "constructor": { - "set() returns an empty set": function(d3) { - var set = d3.set(); - assert.deepEqual(set.values(), []); + "set() returns an empty set": function(set) { + var s = set(); + assert.deepEqual(s.values(), []); }, - "set(null) returns an empty set": function(d3) { - var set = d3.set(null); - assert.deepEqual(set.values(), []); + "set(null) returns an empty set": function(set) { + var s = set(null); + assert.deepEqual(s.values(), []); }, - "set(array) adds array entries": function(d3) { - var set = d3.set(["foo"]); - assert.isTrue(set.has("foo")); - var set = d3.set(["foo", "bar"]); - assert.isTrue(set.has("foo")); - assert.isTrue(set.has("bar")); + "set(array) adds array entries": function(set) { + var s = set(["foo"]); + assert.isTrue(s.has("foo")); + var s = set(["foo", "bar"]); + assert.isTrue(s.has("foo")); + assert.isTrue(s.has("bar")); } }, "forEach": { - "empty sets have an empty values array": function(d3) { - var set = d3.set(); - assert.deepEqual(set.values(), []); - set.add("foo"); - assert.deepEqual(set.values(), ["foo"]); - set.remove("foo"); - assert.deepEqual(set.values(), []); + "empty sets have an empty values array": function(set) { + var s = set(); + assert.deepEqual(s.values(), []); + s.add("foo"); + assert.deepEqual(s.values(), ["foo"]); + s.remove("foo"); + assert.deepEqual(s.values(), []); }, - "values are returned in arbitrary order": function(d3) { - var set = d3.set(["foo", "bar"]); - assert.deepEqual(set.values().sort(d3.ascending), ["bar", "foo"]); - var set = d3.set(["bar", "foo"]); - assert.deepEqual(set.values().sort(d3.ascending), ["bar", "foo"]); + "values are returned in arbitrary order": function(set) { + var s = set(["foo", "bar"]); + assert.deepEqual(s.values().sort(d3.ascending), ["bar", "foo"]); + var s = set(["bar", "foo"]); + assert.deepEqual(s.values().sort(d3.ascending), ["bar", "foo"]); }, - "observes changes via add and remove": function(d3) { - var set = d3.set(["foo", "bar"]); - assert.deepEqual(set.values().sort(d3.ascending), ["bar", "foo"]); - set.remove("foo"); - assert.deepEqual(set.values(), ["bar"]); - set.add("bar"); - assert.deepEqual(set.values(), ["bar"]); - set.add("foo"); - assert.deepEqual(set.values().sort(d3.ascending), ["bar", "foo"]); - set.remove("bar"); - assert.deepEqual(set.values(), ["foo"]); - set.remove("foo"); - assert.deepEqual(set.values(), []); - set.remove("foo"); - assert.deepEqual(set.values(), []); + "observes changes via add and remove": function(set) { + var s = set(["foo", "bar"]); + assert.deepEqual(s.values().sort(d3.ascending), ["bar", "foo"]); + s.remove("foo"); + assert.deepEqual(s.values(), ["bar"]); + s.add("bar"); + assert.deepEqual(s.values(), ["bar"]); + s.add("foo"); + assert.deepEqual(s.values().sort(d3.ascending), ["bar", "foo"]); + s.remove("bar"); + assert.deepEqual(s.values(), ["foo"]); + s.remove("foo"); + assert.deepEqual(s.values(), []); + s.remove("foo"); + assert.deepEqual(s.values(), []); } }, "values": { - "returns an array of string values": function(d3) { - var set = d3.set(["foo", "bar"]); - assert.deepEqual(set.values().sort(), ["bar", "foo"]); + "returns an array of string values": function(set) { + var s = set(["foo", "bar"]); + assert.deepEqual(s.values().sort(), ["bar", "foo"]); } }, "has": { - "empty sets do not have object built-ins": function(d3) { - var set = d3.set(); - assert.isFalse(set.has("__proto__")); - assert.isFalse(set.has("hasOwnProperty")); + "empty sets do not have object built-ins": function(set) { + var s = set(); + assert.isFalse(s.has("__proto__")); + assert.isFalse(s.has("hasOwnProperty")); }, - "coerces values to strings": function(d3) { - var set = d3.set(["42", "null", "undefined"]); - assert.isTrue(set.has(42)); - assert.isTrue(set.has(null)); - assert.isTrue(set.has(undefined)); + "coerces values to strings": function(set) { + var s = set(["42", "null", "undefined"]); + assert.isTrue(s.has(42)); + assert.isTrue(s.has(null)); + assert.isTrue(s.has(undefined)); }, - "observes changes via add and remove": function(d3) { - var set = d3.set(["foo"]); - assert.isTrue(set.has("foo")); - set.add("foo"); - assert.isTrue(set.has("foo")); - set.remove("foo"); - assert.isFalse(set.has("foo")); - set.add("foo"); - assert.isTrue(set.has("foo")); + "observes changes via add and remove": function(set) { + var s = set(["foo"]); + assert.isTrue(s.has("foo")); + s.add("foo"); + assert.isTrue(s.has("foo")); + s.remove("foo"); + assert.isFalse(s.has("foo")); + s.add("foo"); + assert.isTrue(s.has("foo")); }, - "returns undefined for missing values": function(d3) { - var set = d3.set(["foo"]); - assert.isFalse(set.has("bar")); + "returns undefined for missing values": function(set) { + var s = set(["foo"]); + assert.isFalse(s.has("bar")); } }, "add": { - "returns the set value": function(d3) { - var set = d3.set(); - assert.equal(set.add("foo"), "foo"); + "returns the set value": function(set) { + var s = set(); + assert.equal(s.add("foo"), "foo"); }, - "can add values using built-in names": function(d3) { - var set = d3.set(); - set.add("__proto__"); - assert.isTrue(set.has("__proto__")); + "can add values using built-in names": function(set) { + var s = set(); + s.add("__proto__"); + assert.isTrue(s.has("__proto__")); }, - "coerces values to strings": function(d3) { - var set = d3.set(); - set.add(42); - assert.isTrue(set.has(42)); - set.add(null); - assert.isTrue(set.has(null)); - set.add(undefined); - assert.isTrue(set.has(undefined)); - assert.deepEqual(set.values().sort(), ["42", "null", "undefined"]); + "coerces values to strings": function(set) { + var s = set(); + s.add(42); + assert.isTrue(s.has(42)); + s.add(null); + assert.isTrue(s.has(null)); + s.add(undefined); + assert.isTrue(s.has(undefined)); + assert.deepEqual(s.values().sort(), ["42", "null", "undefined"]); }, - "can add null, undefined or empty string values": function(d3) { - var set = d3.set(); - set.add(""); - set.add("null"); - set.add("undefined"); - assert.isTrue(set.has("")); - assert.isTrue(set.has("null")); - assert.isTrue(set.has("undefined")); + "can add null, undefined or empty string values": function(set) { + var s = set(); + s.add(""); + s.add("null"); + s.add("undefined"); + assert.isTrue(s.has("")); + assert.isTrue(s.has("null")); + assert.isTrue(s.has("undefined")); } }, "remove": { - "returns true if the value was removed": function(d3) { - var set = d3.set(["foo"]); - assert.isTrue(set.remove("foo")); + "returns true if the value was removed": function(set) { + var s = set(["foo"]); + assert.isTrue(s.remove("foo")); }, - "returns false if the value is not an element": function(d3) { - var set = d3.set(); - assert.isFalse(set.remove("foo")); + "returns false if the value is not an element": function(set) { + var s = set(); + assert.isFalse(s.remove("foo")); } } } diff --git a/test/arrays/sum-test.js b/test/arrays/sum-test.js index 76b9ecdd..ff0cd376 100644 --- a/test/arrays/sum-test.js +++ b/test/arrays/sum-test.js @@ -6,36 +6,36 @@ var suite = vows.describe("d3.sum"); suite.addBatch({ "sum": { - topic: load("arrays/sum"), - "sums numbers": function(d3) { - assert.equal(d3.sum([1]), 1); - assert.equal(d3.sum([5, 1, 2, 3, 4]), 15); - assert.equal(d3.sum([20, 3]), 23); - assert.equal(d3.sum([3, 20]), 23); + topic: load("arrays/sum").expression("d3.sum"), + "sums numbers": function(sum) { + assert.equal(sum([1]), 1); + assert.equal(sum([5, 1, 2, 3, 4]), 15); + assert.equal(sum([20, 3]), 23); + assert.equal(sum([3, 20]), 23); }, - "sums types that can be coerced to numbers": function(d3) { - assert.equal(d3.sum(["20", "3"]), 23); - assert.equal(d3.sum(["3", "20"]), 23); - assert.equal(d3.sum(["3", 20]), 23); - assert.equal(d3.sum([20, "3"]), 23); - assert.equal(d3.sum([3, "20"]), 23); - assert.equal(d3.sum(["20", 3]), 23); + "sums types that can be coerced to numbers": function(sum) { + assert.equal(sum(["20", "3"]), 23); + assert.equal(sum(["3", "20"]), 23); + assert.equal(sum(["3", 20]), 23); + assert.equal(sum([20, "3"]), 23); + assert.equal(sum([3, "20"]), 23); + assert.equal(sum(["20", 3]), 23); }, - "ignores non-numeric types": function(d3) { - assert.equal(d3.sum(["a", "b", "c"]), 0); - assert.equal(d3.sum(["a", 1, "2"]), 3); + "ignores non-numeric types": function(sum) { + assert.equal(sum(["a", "b", "c"]), 0); + assert.equal(sum(["a", 1, "2"]), 3); }, - "ignores null, undefined and NaN": function(d3) { - assert.equal(d3.sum([NaN, 1, 2, 3, 4, 5]), 15); - assert.equal(d3.sum([1, 2, 3, 4, 5, NaN]), 15); - assert.equal(d3.sum([10, null, 3, undefined, 5, NaN]), 18); + "ignores null, undefined and NaN": function(sum) { + assert.equal(sum([NaN, 1, 2, 3, 4, 5]), 15); + assert.equal(sum([1, 2, 3, 4, 5, NaN]), 15); + assert.equal(sum([10, null, 3, undefined, 5, NaN]), 18); }, - "applies the optional acccessor function": function(d3) { - assert.equal(d3.sum([[1, 2, 3, 4, 5], [2, 4, 6, 8, 10]], function(d) { return d3.sum(d); }), 45); - assert.equal(d3.sum([1, 2, 3, 4, 5], function(d, i) { return i; }), 10); + "applies the optional acccessor function": function(sum) { + assert.equal(sum([[1, 2, 3, 4, 5], [2, 4, 6, 8, 10]], function(d) { return sum(d); }), 45); + assert.equal(sum([1, 2, 3, 4, 5], function(d, i) { return i; }), 10); }, - "returns zero for the empty array": function(d3) { - assert.equal(d3.sum([]), 0); + "returns zero for the empty array": function(sum) { + assert.equal(sum([]), 0); } } }); diff --git a/test/arrays/transpose-test.js b/test/arrays/transpose-test.js index 130b6bf9..573dd266 100644 --- a/test/arrays/transpose-test.js +++ b/test/arrays/transpose-test.js @@ -6,21 +6,21 @@ var suite = vows.describe("d3.transpose"); suite.addBatch({ "transpose": { - topic: load("arrays/transpose"), - "transposes a square matrix": function(d3) { - assert.deepEqual(d3.transpose([[1, 2], [3, 4]]), [[1, 3], [2, 4]]); + topic: load("arrays/transpose").expression("d3.transpose"), + "transposes a square matrix": function(transpose) { + assert.deepEqual(transpose([[1, 2], [3, 4]]), [[1, 3], [2, 4]]); }, - "transposes a non-square matrix": function(d3) { - assert.deepEqual(d3.transpose([[1, 2, 3, 4, 5], [2, 4, 6, 8, 10]]), [[1, 2], [2, 4], [3, 6], [4, 8], [5, 10]]); + "transposes a non-square matrix": function(transpose) { + 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) { - assert.deepEqual(d3.transpose([[1, 2, 3, 4, 5]]), [[1], [2], [3], [4], [5]]); + "transposes a single-row matrix": function(transpose) { + assert.deepEqual(transpose([[1, 2, 3, 4, 5]]), [[1], [2], [3], [4], [5]]); }, - "transposes an empty matrix": function(d3) { - assert.deepEqual(d3.transpose([]), []); + "transposes an empty matrix": function(transpose) { + assert.deepEqual(transpose([]), []); }, - "ignores extra elements given an irregular matrix": function(d3) { - assert.deepEqual(d3.transpose([[1, 2], [3, 4], [5, 6, 7]]), [[1, 3, 5], [2, 4, 6]]); + "ignores extra elements given an irregular matrix": function(transpose) { + assert.deepEqual(transpose([[1, 2], [3, 4], [5, 6, 7]]), [[1, 3, 5], [2, 4, 6]]); } } }); diff --git a/test/arrays/values-test.js b/test/arrays/values-test.js index 81c70f50..0376ccc5 100644 --- a/test/arrays/values-test.js +++ b/test/arrays/values-test.js @@ -6,20 +6,20 @@ var suite = vows.describe("d3.values"); suite.addBatch({ "values": { - topic: load("arrays/values"), - "enumerates every value": function(d3) { - assert.deepEqual(d3.values({a: 1, b: 2}), [1, 2]); + topic: load("arrays/values").expression("d3.values"), + "enumerates every value": function(values) { + 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() { this.a = 1; this.b = 2; } 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) { - var v = d3.values({a: undefined, b: null, c: NaN}); + "includes null or undefined values": function(values) { + var v = values({a: undefined, b: null, c: NaN}); assert.isUndefined(v[0]); assert.isNull(v[1]); assert.isNaN(v[2]); diff --git a/test/arrays/zip-test.js b/test/arrays/zip-test.js index ea61db2d..d668b75f 100644 --- a/test/arrays/zip-test.js +++ b/test/arrays/zip-test.js @@ -1,26 +1,26 @@ var vows = require("vows"), - load= require("../load"), + load = require("../load"), assert = require("../env-assert"); var suite = vows.describe("d3.zip"); suite.addBatch({ "zip": { - topic: load("arrays/zip"), - "transposes a square matrix": function(d3) { - assert.deepEqual(d3.zip([1, 2], [3, 4]), [[1, 3], [2, 4]]); + topic: load("arrays/zip").expression("d3.zip"), + "transposes a square matrix": function(zip) { + assert.deepEqual(zip([1, 2], [3, 4]), [[1, 3], [2, 4]]); }, - "transposes a non-square matrix": function(d3) { - assert.deepEqual(d3.zip([1, 2, 3, 4, 5], [2, 4, 6, 8, 10]), [[1, 2], [2, 4], [3, 6], [4, 8], [5, 10]]); + "transposes a non-square matrix": function(zip) { + 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) { - assert.deepEqual(d3.zip([1, 2, 3, 4, 5]), [[1], [2], [3], [4], [5]]); + "transposes a single-row matrix": function(zip) { + assert.deepEqual(zip([1, 2, 3, 4, 5]), [[1], [2], [3], [4], [5]]); }, - "transposes an empty matrix": function(d3) { - assert.deepEqual(d3.zip(), []); + "transposes an empty matrix": function(zip) { + assert.deepEqual(zip(), []); }, - "ignores extra elements given an irregular matrix": function(d3) { - assert.deepEqual(d3.zip([1, 2], [3, 4], [5, 6, 7]), [[1, 3, 5], [2, 4, 6]]); + "ignores extra elements given an irregular matrix": function(zip) { + assert.deepEqual(zip([1, 2], [3, 4], [5, 6, 7]), [[1, 3, 5], [2, 4, 6]]); } } });