1 require("../env");

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

     3 

     4 var vows = require("vows"),

     5     assert = require("assert");

     6 

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

     8 

     9 suite.addBatch({

    10   "log": {

    11     topic: function() {

    12       return d3.scale.log;

    13     },

    14 

    15     "domain": {

    16       "defaults to [1, 10]": function(log) {

    17         var x = log();

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

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

    20       },

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

    22         var x = log().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 = log().domain(["1", "10"]);

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

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

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

    35         var x = log().domain([new Number(1), new Number(10)]);

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

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

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

    39       },

    40       "can specify negative domain values": function(log) {

    41         var x = log().domain([-100, -1]);

    42         assert.deepEqual(x.ticks().map(x.tickFormat()), [

    43           "−1e+2",

    44           "−9e+1", "−8e+1", "−7e+1", "−6e+1", "−5e+1", "−4e+1", "−3e+1", "−2e+1", "−1e+1",

    45           "−9e+0", "−8e+0", "−7e+0", "−6e+0", "−5e+0", "−4e+0", "−3e+0", "−2e+0", "−1e+0"

    46         ]);

    47         assert.inDelta(x(-50), 0.150515, 1e-6);

    48       },

    49       "can specify a polylog domain and range": function(log) {

    50         var x = log().domain([.1, 1, 100]).range(["red", "white", "green"]);

    51         assert.equal(x(.5), "#ffb2b2");

    52         assert.equal(x(50), "#269326");

    53         assert.equal(x(75), "#108810");

    54       }

    55     },

    56 

    57     "range": {

    58       "defaults to [0, 1]": function(log) {

    59         var x = log();

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

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

    62       },

    63       "does not coerce range to numbers": function(log) {

    64         var x = log().range(["0", "2"]);

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

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

    67       },

    68       "can specify range values as colors": function(log) {

    69         var x = log().range(["red", "blue"]);

    70         assert.equal(x(5), "#4d00b2");

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

    72         assert.equal(x(5), "#4d00b2");

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

    74         assert.equal(x(5), "#4d00b2");

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

    76         assert.equal(x(5), "#4d00b2");

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

    78         assert.equal(x(5), "#4d00b2");

    79       },

    80       "can specify range values as arrays or objects": function(log) {

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

    82         assert.deepEqual(x(5), {color: "#4d00b2"});

    83         var x = log().range([["red"], ["blue"]]);

    84         assert.deepEqual(x(5), ["#4d00b2"]);

    85       }

    86     },

    87 

    88     "interpolate": {

    89       "defaults to d3.interpolate": function(log) {

    90         var x = log().range(["red", "blue"]);

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

    92         assert.equal(x(5), "#4d00b2");

    93       },

    94       "can specify a custom interpolator": function(log) {

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

    96         assert.equal(x(5), "#00ffcb");

    97       }

    98     },

    99 

   100     "clamp": {

   101       "defaults to false": function(log) {

   102         var x = log();

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

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

   105         assert.inDelta(x(15), 1.1760913, 1e-6);

   106       },

   107       "can clamp to the domain": function(log) {

   108         var x = log().clamp(true);

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

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

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

   112         var x = log().domain([10, 1]).clamp(true);

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

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

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

   116       }

   117     },

   118 

   119     "maps a number to a number": function(log) {

   120       var x = log().domain([1, 2]);

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

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

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

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

   125       assert.inDelta(x(2.5), 1.3219281, 1e-6);

   126     },

   127 

   128     "invert": {

   129       "maps a number to a number": function(log) {

   130         var x = log().domain([1, 2]);

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

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

   133         assert.inDelta(x.invert(0.5849625), 1.5, 1e-6);

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

   135         assert.inDelta(x.invert(1.3219281), 2.5, 1e-6);

   136       },

   137       "coerces range value to number on invert": function(log) {

   138         var x = log().range(["0", "2"]);

   139         assert.inDelta(x.invert("1"), 3.1622777, 1e-6);

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

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

   142         var x = log().range(["#000", "#fff"]);

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

   144       }

   145     },

   146 

   147     "ticks": {

   148       "can generate ticks": function(log) {

   149         var x = log();

   150         assert.deepEqual(x.ticks().map(x.tickFormat()), [

   151           "1e+0", "2e+0", "3e+0", "4e+0", "5e+0", "6e+0", "7e+0", "8e+0", "9e+0",

   152           "1e+1"

   153         ]);

   154         var x = log().domain([100, 1]);

   155         assert.deepEqual(x.ticks().map(x.tickFormat()), [

   156           "1e+0", "2e+0", "3e+0", "4e+0", "5e+0", "6e+0", "7e+0", "8e+0", "9e+0",

   157           "1e+1", "2e+1", "3e+1", "4e+1", "5e+1", "6e+1", "7e+1", "8e+1", "9e+1",

   158           "1e+2"

   159         ]);

   160       },

   161       "can generate fewer ticks, if desired": function(log) {

   162         var x = log();

   163         assert.deepEqual(x.ticks().map(x.tickFormat(5)), [

   164           "1e+0", "2e+0", "3e+0", "4e+0", "", "", "", "", "",

   165           "1e+1"

   166         ]);

   167         var x = log().domain([100, 1]);

   168         assert.deepEqual(x.ticks().map(x.tickFormat(10)), [

   169           "1e+0", "2e+0", "3e+0", "4e+0", "5e+0", "", "", "", "",

   170           "1e+1", "2e+1", "3e+1", "4e+1", "5e+1", "", "", "", "",

   171           "1e+2"

   172         ]);

   173       },

   174       "can override the tick format": function(log) {

   175         var x = log().domain([1000, 1]);

   176         assert.deepEqual(x.ticks().map(x.tickFormat(10, d3.format("+,d"))), [

   177           "+1", "+2", "+3", "", "", "", "", "", "",

   178           "+10", "+20", "+30", "", "", "", "", "", "",

   179           "+100", "+200", "+300", "", "", "", "", "", "",

   180           "+1,000"

   181         ]);

   182       }

   183     },

   184 

   185     "nice": {

   186       "can nice the domain, extending it to powers of ten": function(log) {

   187         var x = log().domain([1.1, 10.9]).nice();

   188         assert.deepEqual(x.domain(), [1, 100]);

   189         var x = log().domain([10.9, 1.1]).nice();

   190         assert.deepEqual(x.domain(), [100, 1]);

   191         var x = log().domain([.7, 11.001]).nice();

   192         assert.deepEqual(x.domain(), [.1, 100]);

   193         var x = log().domain([123.1, 6.7]).nice();

   194         assert.deepEqual(x.domain(), [1000, 1]);

   195         var x = log().domain([.01, .49]).nice();

   196         assert.deepEqual(x.domain(), [.01, 1]);

   197         var x = log().domain([0, 0]).nice();

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

   199         var x = log().domain([.5, .5]).nice();

   200         assert.inDelta(x.domain(), [.5, .5], 1e-6);

   201       },

   202       "nicing a polylog domain only affects the extent": function(log) {

   203         var x = log().domain([1.1, 1.5, 10.9]).nice();

   204         assert.deepEqual(x.domain(), [1, 1.5, 100]);

   205         var x = log().domain([-123.1, -1.5, -.5]).nice();

   206         assert.deepEqual(x.domain(), [-1000, -1.5, -.1]);

   207       }

   208     },

   209 

   210     "copy": {

   211       "changes to the domain are isolated": function(log) {

   212         var x = log(), y = x.copy();

   213         x.domain([10, 100]);

   214         assert.deepEqual(y.domain(), [1, 10]);

   215         assert.equal(x(10), 0);

   216         assert.equal(y(1), 0);

   217         y.domain([100, 1000]);

   218         assert.equal(x(100), 1);

   219         assert.equal(y(100), 0);

   220         assert.deepEqual(x.domain(), [10, 100]);

   221         assert.deepEqual(y.domain().map(Math.round), [100, 1000]);

   222       },

   223       "changes to the range are isolated": function(log) {

   224         var x = log(), y = x.copy();

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

   226         assert.equal(x.invert(1), 1);

   227         assert.equal(y.invert(1), 10);

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

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

   230         assert.equal(x.invert(2), 10);

   231         assert.equal(y.invert(2), 1);

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

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

   234       },

   235       "changes to the interpolator are isolated": function(log) {

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

   237         x.interpolate(d3.interpolateHsl);

   238         assert.equal(x(5), "#00ffcb");

   239         assert.equal(y(5), "#4d00b2");

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

   241       },

   242       "changes to clamping are isolated": function(log) {

   243         var x = log().clamp(true), y = x.copy();

   244         x.clamp(false);

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

   246         assert.equal(y(.5), 0);

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

   248         y.clamp(false);

   249         assert.inDelta(x(20), 1.30103, 1e-6);

   250         assert.inDelta(y(20), 1.30103, 1e-6);

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

   252       }

   253     }

   254   }

   255 });

   256 

   257 suite.export(module);