1 require("../env");

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

     3 

     4 var vows = require("vows"),

     5     assert = require("assert");

     6 

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

     8 

     9 suite.addBatch({

    10   "linear": {

    11     topic: function() {

    12       return d3.scale.linear;

    13     },

    14 

    15     "domain": {

    16       "defaults to [0, 1]": function(linear) {

    17         var x = linear();

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

    19         assert.inDelta(x(.5), .5, 1e-6);

    20       },

    21       "coerces domain values to numbers": function(linear) {

    22         var x = linear().domain([new Date(1990, 0, 1), new Date(1991, 0, 1)]);

    23         assert.equal(typeof x.domain()[0], "number");

    24         assert.equal(typeof x.domain()[1], "number");

    25         assert.inDelta(x(new Date(1989, 09, 20)), -.2, 1e-2);

    26         assert.inDelta(x(new Date(1990, 00, 01)), 0, 1e-2);

    27         assert.inDelta(x(new Date(1990, 02, 15)), .2, 1e-2);

    28         assert.inDelta(x(new Date(1990, 04, 27)), .4, 1e-2);

    29         assert.inDelta(x(new Date(1991, 00, 01)), 1, 1e-2);

    30         assert.inDelta(x(new Date(1991, 02, 15)), 1.2, 1e-2);

    31         var x = linear().domain(["0", "1"]);

    32         assert.equal(typeof x.domain()[0], "number");

    33         assert.equal(typeof x.domain()[1], "number");

    34         assert.inDelta(x(.5), .5, 1e-6);

    35         var x = linear().domain([new Number(0), new Number(1)]);

    36         assert.equal(typeof x.domain()[0], "number");

    37         assert.equal(typeof x.domain()[1], "number");

    38         assert.inDelta(x(.5), .5, 1e-6);

    39       },

    40       "can specify a polylinear domain and range": function(linear) {

    41         var x = linear().domain([-10, 0, 100]).range(["red", "white", "green"]);

    42         assert.equal(x(-5), "#ff8080");

    43         assert.equal(x(50), "#80c080");

    44         assert.equal(x(75), "#40a040");

    45       },

    46       "an empty domain maps to the range start": function(linear) {

    47         var x = linear().domain([0, 0]).range(["red", "green"]);

    48         assert.equal(x(0), "#ff0000");

    49         assert.equal(x(-1), "#ff0000");

    50         assert.equal(x(1), "#ff0000");

    51       }

    52     },

    53 

    54     "range": {

    55       "defaults to [0, 1]": function(linear) {

    56         var x = linear();

    57         assert.deepEqual(x.range(), [0, 1]);

    58         assert.inDelta(x.invert(.5), .5, 1e-6);

    59       },

    60       "does not coerce range to numbers": function(linear) {

    61         var x = linear().range(["0", "2"]);

    62         assert.equal(typeof x.range()[0], "string");

    63         assert.equal(typeof x.range()[1], "string");

    64       },

    65       "can specify range values as colors": function(linear) {

    66         var x = linear().range(["red", "blue"]);

    67         assert.equal(x(.5), "#800080");

    68         var x = linear().range(["#ff0000", "#0000ff"]);

    69         assert.equal(x(.5), "#800080");

    70         var x = linear().range(["#f00", "#00f"]);

    71         assert.equal(x(.5), "#800080");

    72         var x = linear().range([d3.rgb(255,0,0), d3.hsl(240,1,.5)]);

    73         assert.equal(x(.5), "#800080");

    74         var x = linear().range(["hsl(0,100%,50%)", "hsl(240,100%,50%)"]);

    75         assert.equal(x(.5), "#800080");

    76       },

    77       "can specify range values as arrays or objects": function(linear) {

    78         var x = linear().range([{color: "red"}, {color: "blue"}]);

    79         assert.deepEqual(x(.5), {color: "#800080"});

    80         var x = linear().range([["red"], ["blue"]]);

    81         assert.deepEqual(x(.5), ["#800080"]);

    82       }

    83     },

    84 

    85     "interpolate": {

    86       "defaults to d3.interpolate": function(linear) {

    87         var x = linear().range(["red", "blue"]);

    88         assert.equal(x.interpolate(), d3.interpolate);

    89         assert.equal(x(.5), "#800080");

    90       },

    91       "can specify a custom interpolator": function(linear) {

    92         var x = linear().range(["red", "blue"]).interpolate(d3.interpolateHsl);

    93         assert.equal(x(.5), "#00ff00");

    94       }

    95     },

    96 

    97     "clamp": {

    98       "defaults to false": function(linear) {

    99         var x = linear();

   100         assert.isFalse(x.clamp());

   101         assert.inDelta(x(-.5), -.5, 1e-6);

   102         assert.inDelta(x(1.5), 1.5, 1e-6);

   103       },

   104       "can clamp to the domain": function(linear) {

   105         var x = linear().clamp(true);

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

   107         assert.inDelta(x(.5), .5, 1e-6);

   108         assert.inDelta(x(1.5), 1, 1e-6);

   109         var x = linear().domain([1, 0]).clamp(true);

   110         assert.inDelta(x(-.5), 1, 1e-6);

   111         assert.inDelta(x(.5), .5, 1e-6);

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

   113       }

   114     },

   115 

   116     "maps a number to a number": function(linear) {

   117       var x = linear().domain([1, 2]);

   118       assert.inDelta(x(.5), -.5, 1e-6);

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

   120       assert.inDelta(x(1.5), .5, 1e-6);

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

   122       assert.inDelta(x(2.5), 1.5, 1e-6);

   123     },

   124 

   125     "invert": {

   126       "maps a number to a number": function(linear) {

   127         var x = linear().range([1, 2]);

   128         assert.inDelta(x.invert(.5), -.5, 1e-6);

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

   130         assert.inDelta(x.invert(1.5), .5, 1e-6);

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

   132         assert.inDelta(x.invert(2.5), 1.5, 1e-6);

   133       },

   134       "coerces range value to numbers": function(linear) {

   135         var x = linear().range(["0", "2"]);

   136         assert.inDelta(x.invert("1"), .5, 1e-6);

   137         var x = linear().range([new Date(1990, 0, 1), new Date(1991, 0, 1)]);

   138         assert.inDelta(x.invert(new Date(1990, 6, 2, 13)), .5, 1e-6);

   139         var x = linear().range(["#000", "#fff"]);

   140         assert.isNaN(x.invert("#999"));

   141       }

   142     },

   143 

   144     "ticks": {

   145       "generates ticks of varying degree": function(linear) {

   146         var x = linear();

   147         assert.deepEqual(x.ticks(1).map(x.tickFormat(1)), [0, 1]);

   148         assert.deepEqual(x.ticks(2).map(x.tickFormat(2)), [0, .5, 1]);

   149         assert.deepEqual(x.ticks(5).map(x.tickFormat(5)), [0, .2, .4, .6, .8, 1]);

   150         assert.deepEqual(x.ticks(10).map(x.tickFormat(10)), [0, .1, .2, .3, .4, .5, .6, .7, .8, .9, 1]);

   151         var x = linear().domain([1, 0]);

   152         assert.deepEqual(x.ticks(1).map(x.tickFormat(1)), [0, 1]);

   153         assert.deepEqual(x.ticks(2).map(x.tickFormat(2)), [0, .5, 1]);

   154         assert.deepEqual(x.ticks(5).map(x.tickFormat(5)), [0, .2, .4, .6, .8, 1]);

   155         assert.deepEqual(x.ticks(10).map(x.tickFormat(10)), [0, .1, .2, .3, .4, .5, .6, .7, .8, .9, 1]);

   156       },

   157       "formats ticks with the appropriate precision": function(linear) {

   158         var x = linear().domain([.123456789, 1.23456789]);

   159         assert.strictEqual(x.tickFormat(1)(x.ticks(1)[0]), "1");

   160         assert.strictEqual(x.tickFormat(2)(x.ticks(2)[0]), "0.5");

   161         assert.strictEqual(x.tickFormat(4)(x.ticks(4)[0]), "0.2");

   162         assert.strictEqual(x.tickFormat(8)(x.ticks(8)[0]), "0.2");

   163         assert.strictEqual(x.tickFormat(16)(x.ticks(16)[0]), "0.2");

   164         assert.strictEqual(x.tickFormat(32)(x.ticks(32)[0]), "0.15");

   165         assert.strictEqual(x.tickFormat(64)(x.ticks(64)[0]), "0.14");

   166         assert.strictEqual(x.tickFormat(128)(x.ticks(128)[0]), "0.13");

   167         assert.strictEqual(x.tickFormat(256)(x.ticks(256)[0]), "0.125");

   168       }

   169     },

   170 

   171     "nice": {

   172       "nices the domain, extending it to round numbers": function(linear) {

   173         var x = linear().domain([1.1, 10.9]).nice();

   174         assert.deepEqual(x.domain(), [1, 11]);

   175         var x = linear().domain([10.9, 1.1]).nice();

   176         assert.deepEqual(x.domain(), [11, 1]);

   177         var x = linear().domain([.7, 11.001]).nice();

   178         assert.deepEqual(x.domain(), [0, 12]);

   179         var x = linear().domain([123.1, 6.7]).nice();

   180         assert.deepEqual(x.domain(), [130, 0]);

   181         var x = linear().domain([0, .49]).nice();

   182         assert.deepEqual(x.domain(), [0, .5]);

   183         var x = linear().domain([0, 0]).nice();

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

   185         var x = linear().domain([.5, .5]).nice();

   186         assert.deepEqual(x.domain(), [.5, .5]);

   187       },

   188       "nicing a polylinear domain only affects the extent": function(linear) {

   189         var x = linear().domain([1.1, 1, 2, 3, 10.9]).nice();

   190         assert.deepEqual(x.domain(), [1, 1, 2, 3, 11]);

   191         var x = linear().domain([123.1, 1, 2, 3, -.9]).nice();

   192         assert.deepEqual(x.domain(), [130, 1, 2, 3, -10]);

   193       }

   194     },

   195 

   196     "copy": {

   197       "changes to the domain are isolated": function(linear) {

   198         var x = linear(), y = x.copy();

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

   200         assert.deepEqual(y.domain(), [0, 1]);

   201         assert.equal(x(1), 0);

   202         assert.equal(y(1), 1);

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

   204         assert.equal(x(2), 1);

   205         assert.equal(y(2), 0);

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

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

   208       },

   209       "changes to the range are isolated": function(linear) {

   210         var x = linear(), y = x.copy();

   211         x.range([1, 2]);

   212         assert.equal(x.invert(1), 0);

   213         assert.equal(y.invert(1), 1);

   214         assert.deepEqual(y.range(), [0, 1]);

   215         y.range([2, 3]);

   216         assert.equal(x.invert(2), 1);

   217         assert.equal(y.invert(2), 0);

   218         assert.deepEqual(x.range(), [1, 2]);

   219         assert.deepEqual(y.range(), [2, 3]);

   220       },

   221       "changes to the interpolator are isolated": function(linear) {

   222         var x = linear().range(["red", "blue"]), y = x.copy();

   223         x.interpolate(d3.interpolateHsl);

   224         assert.equal(x(0.5), "#00ff00");

   225         assert.equal(y(0.5), "#800080");

   226         assert.equal(y.interpolate(), d3.interpolate);

   227       },

   228       "changes to clamping are isolated": function(linear) {

   229         var x = linear().clamp(true), y = x.copy();

   230         x.clamp(false);

   231         assert.equal(x(2), 2);

   232         assert.equal(y(2), 1);

   233         assert.isTrue(y.clamp());

   234         y.clamp(false);

   235         assert.equal(x(2), 2);

   236         assert.equal(y(2), 2);

   237         assert.isFalse(x.clamp());

   238       }

   239     }

   240   }

   241 });

   242 

   243 suite.export(module);