1 require("../env");

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

     3 

     4 var vows = require("vows"),

     5     assert = require("assert");

     6 

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

     8 

     9 suite.addBatch({

    10   "interpolate": {

    11     topic: function() {

    12       return d3.interpolate;

    13     },

    14     "interpolates numbers": function(interpolate) {

    15       assert.equal(interpolate(2, 12)(.4), 6);

    16     },

    17     "interpolates colors": function(interpolate) {

    18       assert.equal(interpolate("#abcdef", "#fedcba")(.4), "#ccd3da");

    19     },

    20     "interpolates strings": function(interpolate) {

    21       assert.equal(interpolate("width:10px;", "width:50px;")(.2), "width:18px;");

    22     },

    23     "interpolates arrays": function(interpolate) {

    24       assert.deepEqual(interpolate([2, 4], [12, 24])(.4), [6, 12]);

    25     },

    26     "interpolates objects": function(interpolate) {

    27       assert.deepEqual(interpolate({foo: 2}, {foo: 12})(.4), {foo: 6});

    28     }

    29   }

    30 });

    31 

    32 suite.addBatch({

    33   "interpolateNumber": {

    34     topic: function() {

    35       return d3.interpolateNumber;

    36     },

    37     "interpolates numbers": function(interpolate) {

    38       assert.equal(interpolate(2, 12)(.4), 6);

    39       assert.equal(interpolate(2, 12)(.6), 8);

    40     }

    41   }

    42 });

    43 

    44 suite.addBatch({

    45   "interpolateRound": {

    46     topic: function() {

    47       return d3.interpolateRound;

    48     },

    49     "interpolates integers": function(interpolate) {

    50       assert.equal(interpolate(2, 12)(.456), 7);

    51       assert.equal(interpolate(2, 12)(.678), 9);

    52     }

    53   }

    54 });

    55 

    56 suite.addBatch({

    57   "interpolateString": {

    58     topic: function() {

    59       return d3.interpolateString;

    60     },

    61     "interpolates matching numbers in both strings": function(interpolate) {

    62       assert.equal(interpolate(" 10/20 30", "50/10 100 ")(.2), "18/18 44 ");

    63       assert.equal(interpolate(" 10/20 30", "50/10 100 ")(.4), "26/16 58 ");

    64     },

    65     "preserves non-numbers in string b": function(interpolate) {

    66       assert.equal(interpolate(" 10/20 30", "50/10 foo ")(.2), "18/18 foo ");

    67       assert.equal(interpolate(" 10/20 30", "50/10 foo ")(.4), "26/16 foo ");

    68     },

    69     "preserves non-matching numbers in string b": function(interpolate) {

    70       assert.equal(interpolate(" 10/20 foo", "50/10 100 ")(.2), "18/18 100 ");

    71       assert.equal(interpolate(" 10/20 bar", "50/10 100 ")(.4), "26/16 100 ");

    72     },

    73     "preserves equal-value numbers in both strings": function(interpolate) {

    74       assert.equal(interpolate(" 10/20 100 20", "50/10 100, 20 ")(.2), "18/18 100, 20 ");

    75       assert.equal(interpolate(" 10/20 100 20", "50/10 100, 20 ")(.4), "26/16 100, 20 ");

    76     },

    77     "interpolates exponent notation correctly": function(interpolate) {

    78       assert.equal(interpolate("1e+3", "1e+4")(.5), "5500");

    79       assert.equal(interpolate("1e-3", "1e-4")(.5), "0.00055");

    80     }

    81   }

    82 });

    83 

    84 suite.addBatch({

    85   "interpolateRgb": {

    86     topic: function() {

    87       return d3.interpolateRgb;

    88     },

    89     "parses string input": function(interpolate) {

    90       assert.equal(interpolate("steelblue", "#f00")(.2), "#6b6890");

    91       assert.equal(interpolate("steelblue", "#f00")(.6), "#b53448");

    92     },

    93     "parses d3.rgb input": function(interpolate) {

    94       assert.equal(interpolate(d3.rgb("steelblue"), "#f00")(.2), "#6b6890");

    95       assert.equal(interpolate("steelblue", d3.rgb(255, 0, 0))(.6), "#b53448");

    96     },

    97     "parses d3.hsl input": function(interpolate) {

    98       assert.equal(interpolate(d3.hsl("steelblue"), "#f00")(.2), "#6b6890");

    99       assert.equal(interpolate("steelblue", d3.hsl(0, 1, .5))(.6), "#b53448");

   100     },

   101     "interpolates in RGB color space": function(interpolate) {

   102       assert.equal(interpolate("steelblue", "#f00")(.2), "#6b6890");

   103     },

   104     "outputs an RGB string": function(interpolate) {

   105       assert.equal(interpolate("steelblue", "#f00")(.2), "#6b6890");

   106     }

   107   }

   108 });

   109 

   110 suite.addBatch({

   111   "interpolateHsl": {

   112     topic: function() {

   113       return d3.interpolateHsl;

   114     },

   115     "parses string input": function(interpolate) {

   116       assert.equal(interpolate("steelblue", "#f00")(.2), "#38c3a2");

   117       assert.equal(interpolate("steelblue", "#f00")(.6), "#96e11c");

   118     },

   119     "parses d3.hsl input": function(interpolate) {

   120       assert.equal(interpolate(d3.hsl("steelblue"), "#f00")(.2), "#38c3a2");

   121       assert.equal(interpolate("steelblue", d3.hsl(0, 1, .5))(.6), "#96e11c");

   122     },

   123     "parses d3.rgb input": function(interpolate) {

   124       assert.equal(interpolate(d3.rgb("steelblue"), "#f00")(.2), "#38c3a2");

   125       assert.equal(interpolate("steelblue", d3.rgb(255, 0, 0))(.6), "#96e11c");

   126     },

   127     "interpolates in HSL color space": function(interpolate) {

   128       assert.equal(interpolate("steelblue", "#f00")(.2), "#38c3a2");

   129     },

   130     "outputs a hexadecimal string": function(interpolate) {

   131       assert.equal(interpolate("steelblue", "#f00")(.2), "#38c3a2");

   132     }

   133   }

   134 });

   135 

   136 suite.addBatch({

   137   "interpolateArray": {

   138     topic: function() {

   139       return d3.interpolateArray;

   140     },

   141     "interpolates defined elements": function(interpolate) {

   142       assert.deepEqual(interpolate([2, 12], [4, 24])(.5), [3, 18]);

   143     },

   144     "interpolates nested objects and arrays": function(interpolate) {

   145       assert.deepEqual(interpolate([[2, 12]], [[4, 24]])(.5), [[3, 18]]);

   146       assert.deepEqual(interpolate([{foo: [2, 12]}], [{foo: [4, 24]}])(.5), [{foo: [3, 18]}]);

   147     },

   148     "merges non-shared elements": function(interpolate) {

   149       assert.deepEqual(interpolate([2, 12], [4, 24, 12])(.5), [3, 18, 12]);

   150       assert.deepEqual(interpolate([2, 12, 12], [4, 24])(.5), [3, 18, 12]);

   151     }

   152   }

   153 });

   154 

   155 suite.addBatch({

   156   "interpolateObject": {

   157     topic: function() {

   158       return d3.interpolateObject;

   159     },

   160     "interpolates defined properties": function(interpolate) {

   161       assert.deepEqual(interpolate({a: 2, b: 12}, {a: 4, b: 24})(.5), {a: 3, b: 18});

   162     },

   163     "interpolates inherited properties": function(interpolate) {

   164       function a(a) { this.a = a; }

   165       a.prototype.b = 12;

   166       assert.deepEqual(interpolate(new a(2), new a(4))(.5), {a: 3, b: 12});

   167     },

   168     "interpolates color properties as rgb": function(interpolate) {

   169       assert.deepEqual(interpolate({background: "red"}, {background: "green"})(.5), {background: "#804000"});

   170       assert.deepEqual(interpolate({fill: "red"}, {fill: "green"})(.5), {fill: "#804000"});

   171       assert.deepEqual(interpolate({stroke: "red"}, {stroke: "green"})(.5), {stroke: "#804000"});

   172       assert.deepEqual(interpolate({color: "red"}, {color: "green"})(.5), {color: "#804000"});

   173     },

   174     "interpolates nested objects and arrays": function(interpolate) {

   175       assert.deepEqual(interpolate({foo: [2, 12]}, {foo: [4, 24]})(.5), {foo: [3, 18]});

   176       assert.deepEqual(interpolate({foo: {bar: [2, 12]}}, {foo: {bar: [4, 24]}})(.5), {foo: {bar: [3, 18]}});

   177     },

   178     "merges non-shared properties": function(interpolate) {

   179       assert.deepEqual(interpolate({foo: 2}, {foo: 4, bar: 12})(.5), {foo: 3, bar: 12});

   180       assert.deepEqual(interpolate({foo: 2, bar: 12}, {foo: 4})(.5), {foo: 3, bar: 12});

   181     }

   182   }

   183 });

   184 

   185 suite.addBatch({

   186   "interpolators": {

   187     topic: function() {

   188       return d3.interpolate;

   189     },

   190     "can register a custom interpolator": function(interpolate) {

   191       try {

   192         d3.interpolators.push(function(a, b) {

   193           return a == "one" && b == "two" && d3.interpolateNumber(1, 2);

   194         });

   195         assert.equal(interpolate("one", "two")(-.5), .5);

   196         assert.equal(interpolate("one", "two")(0), 1);

   197         assert.equal(interpolate("one", "two")(.5), 1.5);

   198         assert.equal(interpolate("one", "two")(1), 2);

   199         assert.equal(interpolate("one", "two")(1.5), 2.5);

   200       } finally {

   201         d3.interpolators.pop();

   202       }

   203     }

   204   }

   205 });

   206 

   207 suite.export(module);