1 require("../env");

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

     3 

     4 var vows = require("vows"),

     5     assert = require("assert");

     6 

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

     8 

     9 suite.addBatch({

    10   "pow": {

    11     topic: function() {

    12       return d3.scale.pow;

    13     },

    14 

    15     "domain": {

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

    17         var x = pow();

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

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

    20       },

    21       "coerces domain to numbers": function(pow) {

    22         var x = pow().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 = pow().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 = pow().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 polypower domain and range": function(pow) {

    41         var x = pow().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     },

    47 

    48     "range": {

    49       "defaults to [0, 1]": function(pow) {

    50         var x = pow();

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

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

    53       },

    54       "does not coerce range values to numbers": function(pow) {

    55         var x = pow().range(["0", "2"]);

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

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

    58       },

    59       "coerces range values to number on invert": function(pow) {

    60         var x = pow().range(["0", "2"]);

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

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

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

    64         var x = pow().range(["#000", "#fff"]);

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

    66       },

    67       "can specify range values as colors": function(pow) {

    68         var x = pow().range(["red", "blue"]);

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

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

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

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

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

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

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

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

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

    78       },

    79       "can specify range values as arrays or objects": function(pow) {

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

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

    82         var x = pow().range([["red"], ["blue"]]);

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

    84       }

    85     },

    86 

    87     "exponent": {

    88       "defaults to one": function(pow) {

    89         var x = pow();

    90         assert.equal(x.exponent(), 1);

    91       },

    92       "observes the specified exponent": function(pow) {

    93         var x = pow().exponent(.5).domain([1, 2]);

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

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

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

    97         assert.equal(x.exponent(), .5);

    98         var x = pow().exponent(2).domain([1, 2]);

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

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

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

   102         assert.equal(x.exponent(), 2);

   103         var x = pow().exponent(-1).domain([1, 2]);

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

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

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

   107         assert.equal(x.exponent(), -1);

   108       },

   109       "changing the exponent does not change the domain or range": function(pow) {

   110         var x = pow().domain([1, 2]).range([3, 4]), f = d3.format(".6f");

   111         x.exponent(.5);

   112         assert.deepEqual(x.domain().map(f), [1, 2]);

   113         assert.deepEqual(x.range(), [3, 4]);

   114         x.exponent(2);

   115         assert.deepEqual(x.domain().map(f), [1, 2]);

   116         assert.deepEqual(x.range(), [3, 4]);

   117         x.exponent(-1);

   118         assert.deepEqual(x.domain().map(f), [1, 2]);

   119         assert.deepEqual(x.range(), [3, 4]);

   120       }

   121     },

   122 

   123     "interpolate": {

   124       "defaults to d3.interpolate": function(pow) {

   125         var x = pow().range(["red", "blue"]);

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

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

   128       },

   129       "can specify a custom interpolator": function(pow) {

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

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

   132       }

   133     },

   134 

   135     "clamp": {

   136       "does not clamp by default": function(pow) {

   137         var x = pow();

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

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

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

   141       },

   142       "can clamp to the domain": function(pow) {

   143         var x = pow().clamp(true);

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

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

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

   147         var x = pow().domain([1, 0]).clamp(true);

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

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

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

   151       }

   152     },

   153 

   154     "maps a number to a number": function(pow) {

   155       var x = pow().domain([1, 2]);

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

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

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

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

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

   161     },

   162 

   163     "ticks": {

   164       "can generate ticks of varying degree": function(pow) {

   165         var x = pow();

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

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

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

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

   170         var x = pow().domain([1, 0]);

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

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

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

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

   175       }

   176     },

   177 

   178     "nice": {

   179       "can nice the domain, extending it to round numbers": function(pow) {

   180         var x = pow().domain([1.1, 10.9]).nice();

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

   182         var x = pow().domain([10.9, 1.1]).nice();

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

   184         var x = pow().domain([.7, 11.001]).nice();

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

   186         var x = pow().domain([123.1, 6.7]).nice();

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

   188         var x = pow().domain([0, .49]).nice();

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

   190         var x = pow().domain([0, 0]).nice();

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

   192         var x = pow().domain([.5, .5]).nice();

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

   194       },

   195       "nicing a polypower domain only affects the extent": function(pow) {

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

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

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

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

   200       }

   201     },

   202 

   203     "copy": {

   204       "changes to the domain are isolated": function(pow) {

   205         var x = pow(), y = x.copy();

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

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

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

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

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

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

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

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

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

   215       },

   216       "changes to the range are isolated": function(pow) {

   217         var x = pow(), y = x.copy();

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

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

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

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

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

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

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

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

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

   227       },

   228       "changes to the exponent are isolated": function(pow) {

   229         var x = pow().exponent(2), y = x.copy();

   230         x.exponent(.5);

   231         assert.inDelta(x(.5), Math.SQRT1_2, 1e-6);

   232         assert.inDelta(y(.5), 0.25, 1e-6);

   233         assert.equal(x.exponent(), .5);

   234         assert.equal(y.exponent(), 2);

   235         y.exponent(3);

   236         assert.inDelta(x(.5), Math.SQRT1_2, 1e-6);

   237         assert.inDelta(y(.5), 0.125, 1e-6);

   238         assert.equal(x.exponent(), .5);

   239         assert.equal(y.exponent(), 3);

   240       },

   241       "changes to the interpolator are isolated": function(pow) {

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

   243         x.interpolate(d3.interpolateHsl);

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

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

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

   247       },

   248       "changes to clamping are isolated": function(pow) {

   249         var x = pow().clamp(true), y = x.copy();

   250         x.clamp(false);

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

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

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

   254         y.clamp(false);

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

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

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

   258       }

   259     }

   260   }

   261 });

   262 

   263 suite.export(module);