--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/toolkit/javascript/d3/test/scale/ordinal-test.js Thu Apr 10 14:20:23 2014 +0200
@@ -0,0 +1,196 @@
+require("../env");
+require("../../d3");
+
+var vows = require("vows"),
+ assert = require("assert");
+
+var suite = vows.describe("d3.scale.ordinal");
+
+suite.addBatch({
+ "ordinal": {
+ topic: function() {
+ return d3.scale.ordinal;
+ },
+
+ "domain": {
+ "defaults to the empty array": function(ordinal) {
+ assert.isEmpty(ordinal().domain());
+ },
+ "new input values are added to the domain": function(ordinal) {
+ var x = ordinal().range(["foo", "bar"]);
+ assert.equal(x(0), "foo");
+ assert.deepEqual(x.domain(), ["0"]);
+ assert.equal(x(1), "bar");
+ assert.deepEqual(x.domain(), ["0", "1"]);
+ assert.equal(x(0), "foo");
+ assert.deepEqual(x.domain(), ["0", "1"]);
+ },
+ "setting the domain forgets previous values": function(ordinal) {
+ var x = ordinal().range(["foo", "bar"]);
+ assert.equal(x(1), "foo");
+ assert.equal(x(0), "bar");
+ assert.deepEqual(x.domain(), [1, 0]);
+ x.domain(["0", "1"]);
+ assert.equal(x(0), "foo"); // it changed!
+ assert.equal(x(1), "bar");
+ assert.deepEqual(x.domain(), ["0", "1"]);
+ },
+ "uniqueness is based on string coercion": function(ordinal) {
+ var x = ordinal().domain(["foo"]).range([42, 43, 44]);
+ assert.equal(x(new String("foo")), 42);
+ assert.equal(x({toString: function() { return "foo"; }}), 42);
+ assert.equal(x({toString: function() { return "bar"; }}), 43);
+ },
+ "orders domain values by the order in which they are seen": function(ordinal) {
+ var x = ordinal();
+ x("foo");
+ x("bar");
+ x("baz");
+ assert.deepEqual(x.domain(), ["foo", "bar", "baz"]);
+ x.domain(["baz", "bar"]);
+ x("foo");
+ assert.deepEqual(x.domain(), ["baz", "bar", "foo"]);
+ x.domain(["baz", "foo"]);
+ assert.deepEqual(x.domain(), ["baz", "foo"]);
+ x.domain([]);
+ x("foo");
+ x("bar");
+ assert.deepEqual(x.domain(), ["foo", "bar"]);
+ },
+ "does not coerce domain values to strings": function(ordinal) {
+ var x = ordinal().domain([0, 1]);
+ assert.deepEqual(x.domain(), [0, 1]);
+ assert.typeOf(x.domain()[0], "number");
+ assert.typeOf(x.domain()[1], "number");
+ }
+ },
+
+ "range": {
+ "defaults to the empty array": function(ordinal) {
+ var x = ordinal();
+ assert.isEmpty(x.range());
+ assert.isUndefined(x(0));
+ },
+ "setting the range remembers previous values": function(ordinal) {
+ var x = ordinal();
+ assert.isUndefined(x(0));
+ assert.isUndefined(x(1));
+ x.range(["foo", "bar"]);
+ assert.equal(x(0), "foo");
+ assert.equal(x(1), "bar");
+ },
+ "recycles values when exhausted": function(ordinal) {
+ var x = ordinal().range(["a", "b", "c"]);
+ assert.equal(x(0), "a");
+ assert.equal(x(1), "b");
+ assert.equal(x(2), "c");
+ assert.equal(x(3), "a");
+ assert.equal(x(4), "b");
+ assert.equal(x(5), "c");
+ assert.equal(x(2), "c");
+ assert.equal(x(1), "b");
+ assert.equal(x(0), "a");
+ }
+ },
+
+ "maps distinct values to discrete values": function(ordinal) {
+ var x = ordinal().range(["a", "b", "c"]);
+ assert.equal(x(0), "a");
+ assert.equal(x("0"), "a");
+ assert.equal(x([0]), "a");
+ assert.equal(x(1), "b");
+ assert.equal(x(2.0), "c");
+ assert.equal(x(new Number(2)), "c");
+ },
+
+ "rangePoints": {
+ "computes discrete points in a continuous range": function(ordinal) {
+ var x = ordinal().domain(["a", "b", "c"]).rangePoints([0, 120]);
+ assert.deepEqual(x.range(), [0, 60, 120]);
+ assert.equal(x.rangeBand(), 0);
+ var x = ordinal().domain(["a", "b", "c"]).rangePoints([0, 120], 1);
+ assert.deepEqual(x.range(), [20, 60, 100]);
+ assert.equal(x.rangeBand(), 0);
+ var x = ordinal().domain(["a", "b", "c"]).rangePoints([0, 120], 2);
+ assert.deepEqual(x.range(), [30, 60, 90]);
+ assert.equal(x.rangeBand(), 0);
+ }
+ },
+
+ "rangeBands": {
+ "computes discrete bands in a continuous range": function(ordinal) {
+ var x = ordinal().domain(["a", "b", "c"]).rangeBands([0, 120]);
+ assert.deepEqual(x.range(), [0, 40, 80]);
+ assert.equal(x.rangeBand(), 40);
+ var x = ordinal().domain(["a", "b", "c"]).rangeBands([0, 120], .2);
+ assert.deepEqual(x.range(), [7.5, 45, 82.5]);
+ assert.equal(x.rangeBand(), 30);
+ },
+ "setting domain recomputes range bands": function(ordinal) {
+ var x = ordinal().rangeRoundBands([0, 100]).domain(["a", "b", "c"]);
+ assert.deepEqual(x.range(), [1, 34, 67]);
+ assert.equal(x.rangeBand(), 33);
+ x.domain(["a", "b", "c", "d"]);
+ assert.deepEqual(x.range(), [0, 25, 50, 75]);
+ assert.equal(x.rangeBand(), 25);
+ }
+ },
+
+ "rangeRoundBands": {
+ "computes discrete rounded bands in a continuous range": function(ordinal) {
+ var x = ordinal().domain(["a", "b", "c"]).rangeRoundBands([0, 100]);
+ assert.deepEqual(x.range(), [1, 34, 67]);
+ assert.equal(x.rangeBand(), 33);
+ var x = ordinal().domain(["a", "b", "c"]).rangeRoundBands([0, 100], .2);
+ assert.deepEqual(x.range(), [7, 38, 69]);
+ assert.equal(x.rangeBand(), 25);
+ }
+ },
+
+ "copy": {
+ "changes to the domain are isolated": function(ordinal) {
+ var x = ordinal().range(["foo", "bar"]), y = x.copy();
+ x.domain([1, 2]);
+ assert.deepEqual(y.domain(), []);
+ assert.equal(x(1), "foo");
+ assert.equal(y(1), "foo");
+ y.domain([2, 3]);
+ assert.equal(x(2), "bar");
+ assert.equal(y(2), "foo");
+ assert.deepEqual(x.domain(), ["1", "2"]);
+ assert.deepEqual(y.domain(), ["2", "3"]);
+ },
+ "changes to the range are isolated": function(ordinal) {
+ var x = ordinal().range(["foo", "bar"]), y = x.copy();
+ x.range(["bar", "foo"]);
+ assert.equal(x(1), "bar");
+ assert.equal(y(1), "foo");
+ assert.deepEqual(y.range(), ["foo", "bar"]);
+ y.range(["foo", "baz"]);
+ assert.equal(x(2), "foo");
+ assert.equal(y(2), "baz");
+ assert.deepEqual(x.range(), ["bar", "foo"]);
+ assert.deepEqual(y.range(), ["foo", "baz"]);
+ },
+ "changes to the range type are isolated": function(ordinal) {
+ var x = ordinal().domain([0, 1]).rangeBands([0, 1], .2), y = x.copy();
+ x.rangePoints([1, 2]);
+ assert.inDelta(x(0), 1, 1e-6);
+ assert.inDelta(x(1), 2, 1e-6);
+ assert.inDelta(x.rangeBand(), 0, 1e-6);
+ assert.inDelta(y(0), 1/11, 1e-6);
+ assert.inDelta(y(1), 6/11, 1e-6);
+ assert.inDelta(y.rangeBand(), 4/11, 1e-6);
+ y.rangeBands([0, 1]);
+ assert.inDelta(x(0), 1, 1e-6);
+ assert.inDelta(x(1), 2, 1e-6);
+ assert.inDelta(x.rangeBand(), 0, 1e-6);
+ assert.inDelta(y(0), 0, 1e-6);
+ assert.inDelta(y(1), 1/2, 1e-6);
+ assert.inDelta(y.rangeBand(), 1/2, 1e-6);
+ }
+ }
+ }
+});
+
+suite.export(module);