1 require("../env");

     2 require("../../d3");

     3 

     4 var vows = require("vows"),

     5     assert = require("assert");

     6 

     7 var suite = vows.describe("d3.scale.ordinal");

     8 

     9 suite.addBatch({

    10   "ordinal": {

    11     topic: function() {

    12       return d3.scale.ordinal;

    13     },

    14 

    15     "domain": {

    16       "defaults to the empty array": function(ordinal) {

    17         assert.isEmpty(ordinal().domain());

    18       },

    19       "new input values are added to the domain": function(ordinal) {

    20         var x = ordinal().range(["foo", "bar"]);

    21         assert.equal(x(0), "foo");

    22         assert.deepEqual(x.domain(), ["0"]);

    23         assert.equal(x(1), "bar");

    24         assert.deepEqual(x.domain(), ["0", "1"]);

    25         assert.equal(x(0), "foo");

    26         assert.deepEqual(x.domain(), ["0", "1"]);

    27       },

    28       "setting the domain forgets previous values": function(ordinal) {

    29         var x = ordinal().range(["foo", "bar"]);

    30         assert.equal(x(1), "foo");

    31         assert.equal(x(0), "bar");

    32         assert.deepEqual(x.domain(), [1, 0]);

    33         x.domain(["0", "1"]);

    34         assert.equal(x(0), "foo"); // it changed!

    35         assert.equal(x(1), "bar");

    36         assert.deepEqual(x.domain(), ["0", "1"]);

    37       },

    38       "uniqueness is based on string coercion": function(ordinal) {

    39         var x = ordinal().domain(["foo"]).range([42, 43, 44]);

    40         assert.equal(x(new String("foo")), 42);

    41         assert.equal(x({toString: function() { return "foo"; }}), 42);

    42         assert.equal(x({toString: function() { return "bar"; }}), 43);

    43       },

    44       "orders domain values by the order in which they are seen": function(ordinal) {

    45         var x = ordinal();

    46         x("foo");

    47         x("bar");

    48         x("baz");

    49         assert.deepEqual(x.domain(), ["foo", "bar", "baz"]);

    50         x.domain(["baz", "bar"]);

    51         x("foo");

    52         assert.deepEqual(x.domain(), ["baz", "bar", "foo"]);

    53         x.domain(["baz", "foo"]);

    54         assert.deepEqual(x.domain(), ["baz", "foo"]);

    55         x.domain([]);

    56         x("foo");

    57         x("bar");

    58         assert.deepEqual(x.domain(), ["foo", "bar"]);

    59       },

    60       "does not coerce domain values to strings": function(ordinal) {

    61         var x = ordinal().domain([0, 1]);

    62         assert.deepEqual(x.domain(), [0, 1]);

    63         assert.typeOf(x.domain()[0], "number");

    64         assert.typeOf(x.domain()[1], "number");

    65       }

    66     },

    67 

    68     "range": {

    69       "defaults to the empty array": function(ordinal) {

    70         var x = ordinal();

    71         assert.isEmpty(x.range());

    72         assert.isUndefined(x(0));

    73       },

    74       "setting the range remembers previous values": function(ordinal) {

    75         var x = ordinal();

    76         assert.isUndefined(x(0));

    77         assert.isUndefined(x(1));

    78         x.range(["foo", "bar"]);

    79         assert.equal(x(0), "foo");

    80         assert.equal(x(1), "bar");

    81       },

    82       "recycles values when exhausted": function(ordinal) {

    83         var x = ordinal().range(["a", "b", "c"]);

    84         assert.equal(x(0), "a");

    85         assert.equal(x(1), "b");

    86         assert.equal(x(2), "c");

    87         assert.equal(x(3), "a");

    88         assert.equal(x(4), "b");

    89         assert.equal(x(5), "c");

    90         assert.equal(x(2), "c");

    91         assert.equal(x(1), "b");

    92         assert.equal(x(0), "a");

    93       }

    94     },

    95 

    96     "maps distinct values to discrete values": function(ordinal) {

    97       var x = ordinal().range(["a", "b", "c"]);

    98       assert.equal(x(0), "a");

    99       assert.equal(x("0"), "a");

   100       assert.equal(x([0]), "a");

   101       assert.equal(x(1), "b");

   102       assert.equal(x(2.0), "c");

   103       assert.equal(x(new Number(2)), "c");

   104     },

   105 

   106     "rangePoints": {

   107       "computes discrete points in a continuous range": function(ordinal) {

   108         var x = ordinal().domain(["a", "b", "c"]).rangePoints([0, 120]);

   109         assert.deepEqual(x.range(), [0, 60, 120]);

   110         assert.equal(x.rangeBand(), 0);

   111         var x = ordinal().domain(["a", "b", "c"]).rangePoints([0, 120], 1);

   112         assert.deepEqual(x.range(), [20, 60, 100]);

   113         assert.equal(x.rangeBand(), 0);

   114         var x = ordinal().domain(["a", "b", "c"]).rangePoints([0, 120], 2);

   115         assert.deepEqual(x.range(), [30, 60, 90]);

   116         assert.equal(x.rangeBand(), 0);

   117       }

   118     },

   119 

   120     "rangeBands": {

   121       "computes discrete bands in a continuous range": function(ordinal) {

   122         var x = ordinal().domain(["a", "b", "c"]).rangeBands([0, 120]);

   123         assert.deepEqual(x.range(), [0, 40, 80]);

   124         assert.equal(x.rangeBand(), 40);

   125         var x = ordinal().domain(["a", "b", "c"]).rangeBands([0, 120], .2);

   126         assert.deepEqual(x.range(), [7.5, 45, 82.5]);

   127         assert.equal(x.rangeBand(), 30);

   128       },

   129       "setting domain recomputes range bands": function(ordinal) {

   130         var x = ordinal().rangeRoundBands([0, 100]).domain(["a", "b", "c"]);

   131         assert.deepEqual(x.range(), [1, 34, 67]);

   132         assert.equal(x.rangeBand(), 33);

   133         x.domain(["a", "b", "c", "d"]);

   134         assert.deepEqual(x.range(), [0, 25, 50, 75]);

   135         assert.equal(x.rangeBand(), 25);

   136       }

   137     },

   138 

   139     "rangeRoundBands": {

   140       "computes discrete rounded bands in a continuous range": function(ordinal) {

   141         var x = ordinal().domain(["a", "b", "c"]).rangeRoundBands([0, 100]);

   142         assert.deepEqual(x.range(), [1, 34, 67]);

   143         assert.equal(x.rangeBand(), 33);

   144         var x = ordinal().domain(["a", "b", "c"]).rangeRoundBands([0, 100], .2);

   145         assert.deepEqual(x.range(), [7, 38, 69]);

   146         assert.equal(x.rangeBand(), 25);

   147       }

   148     },

   149 

   150     "copy": {

   151       "changes to the domain are isolated": function(ordinal) {

   152         var x = ordinal().range(["foo", "bar"]), y = x.copy();

   153         x.domain([1, 2]);

   154         assert.deepEqual(y.domain(), []);

   155         assert.equal(x(1), "foo");

   156         assert.equal(y(1), "foo");

   157         y.domain([2, 3]);

   158         assert.equal(x(2), "bar");

   159         assert.equal(y(2), "foo");

   160         assert.deepEqual(x.domain(), ["1", "2"]);

   161         assert.deepEqual(y.domain(), ["2", "3"]);

   162       },

   163       "changes to the range are isolated": function(ordinal) {

   164         var x = ordinal().range(["foo", "bar"]), y = x.copy();

   165         x.range(["bar", "foo"]);

   166         assert.equal(x(1), "bar");

   167         assert.equal(y(1), "foo");

   168         assert.deepEqual(y.range(), ["foo", "bar"]);

   169         y.range(["foo", "baz"]);

   170         assert.equal(x(2), "foo");

   171         assert.equal(y(2), "baz");

   172         assert.deepEqual(x.range(), ["bar", "foo"]);

   173         assert.deepEqual(y.range(), ["foo", "baz"]);

   174       },

   175       "changes to the range type are isolated": function(ordinal) {

   176         var x = ordinal().domain([0, 1]).rangeBands([0, 1], .2), y = x.copy();

   177         x.rangePoints([1, 2]);

   178         assert.inDelta(x(0), 1, 1e-6);

   179         assert.inDelta(x(1), 2, 1e-6);

   180         assert.inDelta(x.rangeBand(), 0, 1e-6);

   181         assert.inDelta(y(0), 1/11, 1e-6);

   182         assert.inDelta(y(1), 6/11, 1e-6);

   183         assert.inDelta(y.rangeBand(), 4/11, 1e-6);

   184         y.rangeBands([0, 1]);

   185         assert.inDelta(x(0), 1, 1e-6);

   186         assert.inDelta(x(1), 2, 1e-6);

   187         assert.inDelta(x.rangeBand(), 0, 1e-6);

   188         assert.inDelta(y(0), 0, 1e-6);

   189         assert.inDelta(y(1), 1/2, 1e-6);

   190         assert.inDelta(y.rangeBand(), 1/2, 1e-6);

   191       }

   192     }

   193   }

   194 });

   195 

   196 suite.export(module);