diff options
Diffstat (limited to 'web/nms.gathering.org/speedometer/d3-master/test/interpolate')
13 files changed, 682 insertions, 0 deletions
diff --git a/web/nms.gathering.org/speedometer/d3-master/test/interpolate/array-test.js b/web/nms.gathering.org/speedometer/d3-master/test/interpolate/array-test.js new file mode 100644 index 0000000..34ac6ef --- /dev/null +++ b/web/nms.gathering.org/speedometer/d3-master/test/interpolate/array-test.js @@ -0,0 +1,24 @@ +var vows = require("vows"), + load = require("../load"), + assert = require("../assert"); + +var suite = vows.describe("d3.interpolateArray"); + +suite.addBatch({ + "interpolateArray": { + topic: load("interpolate/array").expression("d3.interpolateArray"), + "interpolates defined elements": function(interpolate) { + assert.deepEqual(interpolate([2, 12], [4, 24])(.5), [3, 18]); + }, + "interpolates nested objects and arrays": function(interpolate) { + assert.deepEqual(interpolate([[2, 12]], [[4, 24]])(.5), [[3, 18]]); + assert.deepEqual(interpolate([{foo: [2, 12]}], [{foo: [4, 24]}])(.5), [{foo: [3, 18]}]); + }, + "merges non-shared elements": function(interpolate) { + assert.deepEqual(interpolate([2, 12], [4, 24, 12])(.5), [3, 18, 12]); + assert.deepEqual(interpolate([2, 12, 12], [4, 24])(.5), [3, 18, 12]); + } + } +}); + +suite.export(module); diff --git a/web/nms.gathering.org/speedometer/d3-master/test/interpolate/ease-test.js b/web/nms.gathering.org/speedometer/d3-master/test/interpolate/ease-test.js new file mode 100644 index 0000000..7e36548 --- /dev/null +++ b/web/nms.gathering.org/speedometer/d3-master/test/interpolate/ease-test.js @@ -0,0 +1,135 @@ +var vows = require("vows"), + load = require("../load"), + assert = require("../assert"); + +var suite = vows.describe("d3.ease"); + +suite.addBatch({ + "ease": { + topic: load("interpolate/ease").expression("d3.ease"), + "supports linear easing": function(ease) { + var e = ease("linear"); + assert.inDelta(e(.5), .5, 1e-6); + }, + "supports polynomial easing": function(ease) { + var e = ease("poly", 2); + assert.inDelta(e(.5), .25, 1e-6); + }, + "supports quadratic easing": function(ease) { + var e = ease("quad"); + assert.inDelta(e(.5), .25, 1e-6); + }, + "supports cubic easing": function(ease) { + var e = ease("cubic"); + assert.inDelta(e(.5), .125, 1e-6); + }, + "supports sinusoidal easing": function(ease) { + var e = ease("sin"); + assert.inDelta(e(.5), 1 - Math.cos(Math.PI / 4), 1e-6); + }, + "supports exponential easing": function(ease) { + var e = ease("exp"); + assert.inDelta(e(.5), 0.03125, 1e-6); + }, + "supports circular easing": function(ease) { + var e = ease("circle"); + assert.inDelta(e(.5), 0.133975, 1e-6); + }, + "supports elastic easing": function(ease) { + var e = ease("elastic"); + assert.inDelta(e(.5), 0.976061, 1e-6); + }, + "supports back easing": function(ease) { + var e = ease("back"); + assert.inDelta(e(.5), -0.0876975, 1e-6); + }, + "supports bounce easing": function(ease) { + var e = ease("bounce"); + assert.inDelta(e(.5), 0.765625, 1e-6); + }, + "invalid eases and modes default to linear-in": function(ease) { + var e = ease("__proto__-__proto__"); + assert.strictEqual(e(0), 0); + assert.strictEqual(e(.5), .5); + assert.strictEqual(e(1), 1); + var e = ease("hasOwnProperty-constructor"); + assert.strictEqual(e(0), 0); + assert.strictEqual(e(.5), .5); + assert.strictEqual(e(1), 1); + }, + "all easing functions return exactly 0 for t = 0": function(ease) { + assert.strictEqual(ease("linear")(0), 0); + assert.strictEqual(ease("poly", 2)(0), 0); + assert.strictEqual(ease("quad")(0), 0); + assert.strictEqual(ease("cubic")(0), 0); + assert.strictEqual(ease("sin")(0), 0); + assert.strictEqual(ease("exp")(0), 0); + assert.strictEqual(ease("circle")(0), 0); + assert.strictEqual(ease("elastic")(0), 0); + assert.strictEqual(ease("back")(0), 0); + assert.strictEqual(ease("bounce")(0), 0); + }, + "all easing functions return exactly 1 for t = 1": function(ease) { + assert.strictEqual(ease("linear")(1), 1); + assert.strictEqual(ease("poly", 2)(1), 1); + assert.strictEqual(ease("quad")(1), 1); + assert.strictEqual(ease("cubic")(1), 1); + assert.strictEqual(ease("sin")(1), 1); + assert.strictEqual(ease("exp")(1), 1); + assert.strictEqual(ease("circle")(1), 1); + assert.strictEqual(ease("elastic")(1), 1); + assert.strictEqual(ease("back")(1), 1); + assert.strictEqual(ease("bounce")(1), 1); + }, + "the -in suffix returns the identity": function(ease) { + assert.inDelta(ease("linear-in")(.25), ease("linear")(.25), 1e-6); + assert.inDelta(ease("quad-in")(.75), ease("quad")(.75), 1e-6); + }, + "the -out suffix returns the reverse": function(ease) { + assert.inDelta(ease("sin-out")(.25), 1 - ease("sin-in")(.75), 1e-6); + assert.inDelta(ease("bounce-out")(.25), 1 - ease("bounce-in")(.75), 1e-6); + assert.inDelta(ease("elastic-out")(.25), 1 - ease("elastic-in")(.75), 1e-6); + }, + "the -in-out suffix returns the reflection": function(ease) { + assert.inDelta(ease("sin-in-out")(.25), .5 * ease("sin-in")(.5), 1e-6); + assert.inDelta(ease("bounce-in-out")(.25), .5 * ease("bounce-in")(.5), 1e-6); + assert.inDelta(ease("elastic-in-out")(.25), .5 * ease("elastic-in")(.5), 1e-6); + }, + "the -out-in suffix returns the reverse reflection": function(ease) { + assert.inDelta(ease("sin-out-in")(.25), .5 * ease("sin-out")(.5), 1e-6); + assert.inDelta(ease("bounce-out-in")(.25), .5 * ease("bounce-out")(.5), 1e-6); + assert.inDelta(ease("elastic-out-in")(.25), .5 * ease("elastic-out")(.5), 1e-6); + }, + "clamps input time": function(ease) { + var e = ease("linear"); + assert.inDelta(e(-1), 0, 1e-6); + assert.inDelta(e(2), 1, 1e-6); + }, + "poly": { + "supports an optional polynomial": function(ease) { + var e = ease("poly", 1); + assert.inDelta(e(.5), .5, 1e-6); + var e = ease("poly", .5); + assert.inDelta(e(.5), Math.SQRT1_2, 1e-6); + } + }, + "elastic": { + "supports an optional amplifier (>1)": function(ease) { + var e = ease("elastic", 1.5); + assert.inDelta(e(.5), 0.998519, 1e-6); + }, + "supports an optional amplifier (>1) and period (>0)": function(ease) { + var e = ease("elastic", 1.5, .5); + assert.inDelta(e(.5), 0.96875, 1e-6); + } + }, + "back": { + "supports an optional speed": function(ease) { + var e = ease("back", 2); + assert.inDelta(e(.5), -0.125, 1e-6); + } + } + } +}); + +suite.export(module); diff --git a/web/nms.gathering.org/speedometer/d3-master/test/interpolate/hcl-test.js b/web/nms.gathering.org/speedometer/d3-master/test/interpolate/hcl-test.js new file mode 100644 index 0000000..f21ab3b --- /dev/null +++ b/web/nms.gathering.org/speedometer/d3-master/test/interpolate/hcl-test.js @@ -0,0 +1,47 @@ +var vows = require("vows"), + load = require("../load"), + assert = require("../assert"); + +var suite = vows.describe("d3.interpolateHcl"); + +suite.addBatch({ + "interpolateHcl": { + topic: load("interpolate/hcl"), // beware instanceof d3_Color + "parses string input": function(d3) { + assert.strictEqual(d3.interpolateHcl("steelblue", "#f00")(.2), "#6978c9"); + assert.strictEqual(d3.interpolateHcl("steelblue", "#f00")(.6), "#e034a2"); + }, + "parses d3.hsl input": function(d3) { + assert.strictEqual(d3.interpolateHcl(d3.hsl("steelblue"), "#f00")(.2), "#6978c9"); + assert.strictEqual(d3.interpolateHcl("steelblue", d3.hsl(0, 1, .5))(.6), "#e034a2"); + }, + "parses d3.rgb input": function(d3) { + assert.strictEqual(d3.interpolateHcl(d3.rgb("steelblue"), "#f00")(.2), "#6978c9"); + assert.strictEqual(d3.interpolateHcl("steelblue", d3.rgb(255, 0, 0))(.6), "#e034a2"); + }, + "interpolates in HSL color space": function(d3) { + assert.strictEqual(d3.interpolateHcl("steelblue", "#f00")(.2), "#6978c9"); + }, + "uses source hue when destination hue is undefined": function(d3) { + assert.equal(d3.interpolateHcl("#f60", "#000")(.5), "#9b0000"); + assert.equal(d3.interpolateHcl("#6f0", "#000")(.5), "#008100"); + }, + "uses destination hue when source hue is undefined": function(d3) { + assert.equal(d3.interpolateHcl("#000", "#f60")(.5), "#9b0000"); + assert.equal(d3.interpolateHcl("#000", "#6f0")(.5), "#008100"); + }, + "uses source chroma when destination chroma is undefined": function(d3) { + assert.equal(d3.interpolateHcl("#ccc", "#000")(.5), "#616161"); + assert.equal(d3.interpolateHcl("#f00", "#000")(.5), "#a60000"); + }, + "uses destination chroma when source chroma is undefined": function(d3) { + assert.equal(d3.interpolateHcl("#000", "#ccc")(.5), "#616161"); + assert.equal(d3.interpolateHcl("#000", "#f00")(.5), "#a60000"); + }, + "outputs a hexadecimal string": function(d3) { + assert.strictEqual(d3.interpolateHcl("steelblue", "#f00")(.2), "#6978c9"); + } + } +}); + +suite.export(module); diff --git a/web/nms.gathering.org/speedometer/d3-master/test/interpolate/hsl-test.js b/web/nms.gathering.org/speedometer/d3-master/test/interpolate/hsl-test.js new file mode 100644 index 0000000..26689a3 --- /dev/null +++ b/web/nms.gathering.org/speedometer/d3-master/test/interpolate/hsl-test.js @@ -0,0 +1,47 @@ +var vows = require("vows"), + load = require("../load"), + assert = require("../assert"); + +var suite = vows.describe("d3.interpolateHsl"); + +suite.addBatch({ + "interpolateHsl": { + topic: load("interpolate/hsl"), // beware instanceof d3_Color + "parses string input": function(d3) { + assert.strictEqual(d3.interpolateHsl("steelblue", "#f00")(.2), "#383dc3"); + assert.strictEqual(d3.interpolateHsl("steelblue", "#f00")(.6), "#dd1ce1"); + }, + "parses d3.hsl input": function(d3) { + assert.strictEqual(d3.interpolateHsl(d3.hsl("steelblue"), "#f00")(.2), "#383dc3"); + assert.strictEqual(d3.interpolateHsl("steelblue", d3.hsl(0, 1, .5))(.6), "#dd1ce1"); + }, + "parses d3.rgb input": function(d3) { + assert.strictEqual(d3.interpolateHsl(d3.rgb("steelblue"), "#f00")(.2), "#383dc3"); + assert.strictEqual(d3.interpolateHsl("steelblue", d3.rgb(255, 0, 0))(.6), "#dd1ce1"); + }, + "interpolates in HSL color space": function(d3) { + assert.strictEqual(d3.interpolateHsl("steelblue", "#f00")(.2), "#383dc3"); + }, + "uses source hue when destination hue is undefined": function(d3) { + assert.equal(d3.interpolateHsl("#f60", "#000")(.5), "#803300"); + assert.equal(d3.interpolateHsl("#6f0", "#fff")(.5), "#b3ff80"); + }, + "uses destination hue when source hue is undefined": function(d3) { + assert.equal(d3.interpolateHsl("#000", "#f60")(.5), "#803300"); + assert.equal(d3.interpolateHsl("#fff", "#6f0")(.5), "#b3ff80"); + }, + "uses source saturation when destination saturation is undefined": function(d3) { + assert.equal(d3.interpolateHsl("#ccc", "#000")(.5), "#666666"); + assert.equal(d3.interpolateHsl("#f00", "#000")(.5), "#800000"); + }, + "uses destination saturation when source saturation is undefined": function(d3) { + assert.equal(d3.interpolateHsl("#000", "#ccc")(.5), "#666666"); + assert.equal(d3.interpolateHsl("#000", "#f00")(.5), "#800000"); + }, + "outputs a hexadecimal string": function(d3) { + assert.strictEqual(d3.interpolateHsl("steelblue", "#f00")(.2), "#383dc3"); + } + } +}); + +suite.export(module); diff --git a/web/nms.gathering.org/speedometer/d3-master/test/interpolate/interpolate-string-benchmark b/web/nms.gathering.org/speedometer/d3-master/test/interpolate/interpolate-string-benchmark new file mode 100755 index 0000000..e8babf9 --- /dev/null +++ b/web/nms.gathering.org/speedometer/d3-master/test/interpolate/interpolate-string-benchmark @@ -0,0 +1,31 @@ +#!/usr/bin/env node + +var d3 = require("../../"); + +var n = +process.argv[2], + p = +process.argv[3], + k = +process.argv[4]; + +var formatTime = d3.format(".3s"), + formatNumber = d3.format(",.0f"); + +// Returns the time required to construct a string interpolator +// for two strings with n numbers, separated by commas, +// with probability p that the corresponding numbers in a & b are different. +// The test is run k times, and the mean result is returned. +function observeConstruction(n, p, k) { + if (arguments.length < 3) k = 1; + for (var i = 0, sum = 0; i < k; ++i) { + var a = d3.range(n).map(function() { return Math.random() * 1000; }), + b = d3.range(n).map(function(i) { return Math.random() < p ? Math.random() * 1000 : a[i]; }); + var start = process.hrtime(); + d3.interpolateString(a, b); + var elapsed = process.hrtime(start); + sum += elapsed[0] + elapsed[1] / 1e9; + process.stdout.write("."); + } + console.log(""); + return sum / k; +} + +console.log(formatTime(observeConstruction(n, p, k)) + "s\tn=" + formatNumber(n) + "\tp=" + p); diff --git a/web/nms.gathering.org/speedometer/d3-master/test/interpolate/interpolate-test.js b/web/nms.gathering.org/speedometer/d3-master/test/interpolate/interpolate-test.js new file mode 100644 index 0000000..c05e290 --- /dev/null +++ b/web/nms.gathering.org/speedometer/d3-master/test/interpolate/interpolate-test.js @@ -0,0 +1,151 @@ +var vows = require("vows"), + load = require("../load"), + assert = require("../assert"); + +var suite = vows.describe("d3.interpolate"); + +suite.addBatch({ + "interpolate": { + topic: load("interpolate/interpolate"), + + "when b is a number": { + "interpolates numbers": function(d3) { + assert.strictEqual(d3.interpolate(2, 12)(.25), 4.5); + }, + "coerces a to a number": function(d3) { + assert.strictEqual(d3.interpolate("", 1)(.5), .5); + assert.strictEqual(d3.interpolate("2", 12)(.25), 4.5); + assert.strictEqual(d3.interpolate([2], 12)(.25), 4.5); + } + }, + + "when b is a color string": { + "interpolates RGB values and returns a hexadecimal string": function(d3) { + assert.strictEqual(d3.interpolate("#ff0000", "#008000")(.4), "#993300"); + }, + "interpolates named colors in RGB": function(d3) { + assert.strictEqual(d3.interpolate("red", "green")(.4), "#993300"); + }, + "interpolates decimal RGB colors in RGB": function(d3) { + assert.strictEqual(d3.interpolate("rgb(255,0,0)", "rgb(0,128,0)")(.4), "#993300"); + }, + "interpolates decimal HSL colors in RGB": function(d3) { + assert.strictEqual(d3.interpolate("hsl(0,100%,50%)", "hsl(120,100%,25%)")(.4), "#993300"); + }, + "coerces a to a color": function(d3) { + assert.strictEqual(d3.interpolate({toString: function() { return "red"; }}, "green")(.4), "#993300"); + } + }, + + "when b is a color object": { + "interpolates RGB values and returns a hexadecimal string": function(d3) { + assert.strictEqual(d3.interpolate(d3.rgb(255, 0, 0), d3.rgb(0, 128, 0))(.4), "#993300"); + }, + "interpolates d3.hsl in RGB": function(d3) { + assert.strictEqual(d3.interpolate(d3.hsl("red"), d3.hsl("green"))(.4), "#993300"); + }, + "interpolates d3.lab in RGB": function(d3) { + assert.strictEqual(d3.interpolate(d3.lab("red"), d3.lab("green"))(.4), "#993300"); + }, + "interpolates d3.hcl in RGB": function(d3) { + assert.strictEqual(d3.interpolate(d3.hcl("red"), d3.hcl("green"))(.4), "#993300"); + }, + "coerces a to a color": function(d3) { + assert.strictEqual(d3.interpolate({toString: function() { return "red"; }}, "green")(.4), "#993300"); + } + }, + + "when b is a string": { + "interpolates matching numbers in both strings": function(d3) { + assert.strictEqual(d3.interpolate(" 10/20 30", "50/10 100 ")(.4), "26/16 58 "); + }, + "if b is coercible to a number, still returns a string": function(d3) { + assert.strictEqual(d3.interpolate("1.", "2.")(.5), "1.5"); + assert.strictEqual(d3.interpolate("1e+3", "1e+4")(.5), "5500"); + }, + "preserves non-numbers in string b": function(d3) { + assert.strictEqual(d3.interpolate(" 10/20 30", "50/10 foo ")(.4), "26/16 foo "); + }, + "preserves non-matching numbers in string b": function(d3) { + assert.strictEqual(d3.interpolate(" 10/20 bar", "50/10 100 ")(.4), "26/16 100 "); + }, + "preserves equal-value numbers in both strings": function(d3) { + assert.strictEqual(d3.interpolate(" 10/20 100 20", "50/10 100, 20 ")(.4), "26/16 100, 20 "); + }, + "coerces a to a string": function(d3) { + assert.strictEqual(d3.interpolate({toString: function() { return "1."; }}, "2.")(.5), "1.5"); + } + }, + + "when b is an array": { + "interpolates each element in b": function(d3) { + assert.strictEqual(JSON.stringify(d3.interpolate([2, 4], [12, 24])(.25)), "[4.5,9]"); + }, + "interpolates arrays, even when both a and b are coercible to numbers": function(d3) { + assert.strictEqual(JSON.stringify(d3.interpolate([2], [12])(.25)), "[4.5]"); + assert.strictEqual(JSON.stringify(d3.interpolate([[2]], [[12]])(.25)), "[[4.5]]"); + }, + "reuses the returned array during interpolation": function(d3) { + var i = d3.interpolate([2], [12]); + assert.strictEqual(i(.2), i(.4)); + } + }, + + "when b is an object": { + "interpolates each property in b": function(d3) { + assert.deepEqual(d3.interpolate({foo: 2, bar: 4}, {foo: 12, bar: 24})(.25), {foo: 4.5, bar: 9}); + }, + "interpolates numbers if b is coercible to a number (!isNaN(+b))": function(d3) { + assert.strictEqual(d3.interpolate(new Number(2), new Number(12))(.25), 4.5); + assert.strictEqual(d3.interpolate(new Date(2012, 0, 1), new Date(2013, 0, 1))(.5), +new Date(2012, 6, 2, 1)); + assert.strictEqual(d3.interpolate(1, null)(.4), .6); // +null = 0 + assert.isNaN(d3.interpolate("blue", null)(.4)); + }, + "reuses the returned object during interpolation": function(d3) { + var i = d3.interpolate({foo: 2, bar: 4}, {foo: 12, bar: 24}); + assert.strictEqual(i(.2), i(.4)); + } + }, + + "may or may not interpolate between enumerable and non-enumerable properties": function(d3) { + var a = Object.create({}, {foo: {value: 1, enumerable: true}}), + b = Object.create({}, {foo: {value: 2, enumerable: false}}); + try { + assert.deepEqual(d3.interpolate(a, b)(1), {}); + } catch (e) { + assert.deepEqual(d3.interpolate(a, b)(1), {foo: 2}); + } + try { + assert.deepEqual(d3.interpolate(b, a)(1), {}); + } catch (e) { + assert.deepEqual(d3.interpolate(b, a)(1), {foo: 1}); + } + }, + "interpolates inherited properties of objects": function(d3) { + var a = Object.create({foo: 0}), + b = Object.create({foo: 2}); + assert.deepEqual(d3.interpolate(a, b)(.5), {foo: 1}); + }, + "doesn't interpret properties in the default object's prototype chain as RGB": function(d3) { + assert.equal(d3.interpolate("hasOwnProperty", "hasOwnProperty")(0), "hasOwnProperty"); + } + }, + + "interpolators": { + topic: load("interpolate/interpolate").document(), + "can register a custom interpolator": function(d3) { + d3.interpolators.push(function(a, b) { return a == "one" && b == "two" && d3.interpolateNumber(1, 2); }); + try { + assert.equal(d3.interpolate("one", "two")(-.5), .5); + assert.equal(d3.interpolate("one", "two")(0), 1); + assert.equal(d3.interpolate("one", "two")(.5), 1.5); + assert.equal(d3.interpolate("one", "two")(1), 2); + assert.equal(d3.interpolate("one", "two")(1.5), 2.5); + } finally { + d3.interpolators.pop(); + } + } + } +}); + +suite.export(module); diff --git a/web/nms.gathering.org/speedometer/d3-master/test/interpolate/interpolate-transform-test.js b/web/nms.gathering.org/speedometer/d3-master/test/interpolate/interpolate-transform-test.js new file mode 100644 index 0000000..5320740 --- /dev/null +++ b/web/nms.gathering.org/speedometer/d3-master/test/interpolate/interpolate-transform-test.js @@ -0,0 +1,60 @@ +var vows = require("vows"), + load = require("../load"), + assert = require("../assert"); + +var suite = vows.describe("d3.interpolateTransform"); + +suite.addBatch({ + "interpolateTransform": { + topic: load("interpolate/transform").document(), + "interpolation of a decomposed transform": { + topic: function(d3) { + // Use a custom d3.transform to parse a decomposed transform, since + // JSDOM doesn't support consolidating SVG transform strings. + d3.transform = function(s) { + var m = s.split(/,/g).map(Number); + return { + translate: [m[0], m[1]], + rotate: m[2], + skew: m[3], + scale: [m[4], m[5]] + }; + }; + return d3; + }, + "identity": function(d3) { + assert.strictEqual(d3.interpolateTransform([0, 0, 0, 0, 1, 1] + "", [0, 0, 0, 0, 1, 1] + "")(.4), ""); + }, + "translate": { + "x": function(d3) { + assert.strictEqual(d3.interpolateTransform([0, 0, 0, 0, 1, 1] + "", [10, 0, 0, 0, 1, 1] + "")(.4), "translate(4,0)"); + }, + "y": function(d3) { + assert.strictEqual(d3.interpolateTransform([0, 0, 0, 0, 1, 1] + "", [0, 10, 0, 0, 1, 1] + "")(.4), "translate(0,4)"); + }, + "x and y": function(d3) { + assert.strictEqual(d3.interpolateTransform([0, 0, 0, 0, 1, 1] + "", [1, 10, 0, 0, 1, 1] + "")(.4), "translate(0.4,4)"); + } + }, + "rotate": { + "simple": function(d3) { + assert.strictEqual(d3.interpolateTransform([0, 0, -10, 0, 1, 1] + "", [0, 0, 30, 0, 1, 1] + "")(.4), "rotate(6)"); + }, + "with constant translate": function(d3) { + assert.strictEqual(d3.interpolateTransform([5, 6, -10, 0, 1, 1] + "", [5, 6, 30, 0, 1, 1] + "")(.4), "translate(5,6)rotate(6)"); + } + }, + "skew": function(d3) { + assert.strictEqual(d3.interpolateTransform([0, 0, 0, 0, 1, 1] + "", [0, 0, 0, 40, 1, 1] + "")(.4), "skewX(16)"); + }, + "scale": function(d3) { + assert.strictEqual(d3.interpolateTransform([0, 0, 0, 0, 1, 1] + "", [0, 0, 0, 0, 10, 1] + "")(.5), "scale(5.5,1)"); + }, + "translate and rotate": function(d3) { + assert.strictEqual(d3.interpolateTransform([0, 0, 0, 0, 1, 1] + "", [100, 0, 90, 0, 1, 1] + "")(.5), "translate(50,0)rotate(45)"); + } + } + } +}); + +suite.export(module); diff --git a/web/nms.gathering.org/speedometer/d3-master/test/interpolate/lab-test.js b/web/nms.gathering.org/speedometer/d3-master/test/interpolate/lab-test.js new file mode 100644 index 0000000..bb4622a --- /dev/null +++ b/web/nms.gathering.org/speedometer/d3-master/test/interpolate/lab-test.js @@ -0,0 +1,31 @@ +var vows = require("vows"), + load = require("../load"), + assert = require("../assert"); + +var suite = vows.describe("d3.interpolateLab"); + +suite.addBatch({ + "interpolateLab": { + topic: load("interpolate/lab"), // beware instanceof d3_Color + "parses string input": function(d3) { + assert.strictEqual(d3.interpolateLab("steelblue", "#f00")(.2), "#8a7793"); + assert.strictEqual(d3.interpolateLab("steelblue", "#f00")(.6), "#cf5952"); + }, + "parses d3.hsl input": function(d3) { + assert.strictEqual(d3.interpolateLab(d3.hsl("steelblue"), "#f00")(.2), "#8a7793"); + assert.strictEqual(d3.interpolateLab("steelblue", d3.hsl(0, 1, .5))(.6), "#cf5952"); + }, + "parses d3.rgb input": function(d3) { + assert.strictEqual(d3.interpolateLab(d3.rgb("steelblue"), "#f00")(.2), "#8a7793"); + assert.strictEqual(d3.interpolateLab("steelblue", d3.rgb(255, 0, 0))(.6), "#cf5952"); + }, + "interpolates in HSL color space": function(d3) { + assert.strictEqual(d3.interpolateLab("steelblue", "#f00")(.2), "#8a7793"); + }, + "returns an instanceof d3.lab": function(d3) { + assert.strictEqual(d3.interpolateLab("steelblue", "#f00")(.2), "#8a7793"); + } + } +}); + +suite.export(module); diff --git a/web/nms.gathering.org/speedometer/d3-master/test/interpolate/number-test.js b/web/nms.gathering.org/speedometer/d3-master/test/interpolate/number-test.js new file mode 100644 index 0000000..61c3477 --- /dev/null +++ b/web/nms.gathering.org/speedometer/d3-master/test/interpolate/number-test.js @@ -0,0 +1,20 @@ +var vows = require("vows"), + load = require("../load"), + assert = require("../assert"); + +var suite = vows.describe("d3.interpolateNumber"); + +suite.addBatch({ + "interpolateNumber": { + topic: load("interpolate/number").expression("d3.interpolateNumber"), + "interpolates numbers": function(interpolate) { + assert.strictEqual(interpolate(2, 12)(.25), 4.5); + assert.strictEqual(interpolate(2, 12)(.75), 9.5); + }, + "coerces strings to numbers": function(interpolate) { + assert.strictEqual(interpolate("2", "12")(.25), 4.5); + } + } +}); + +suite.export(module); diff --git a/web/nms.gathering.org/speedometer/d3-master/test/interpolate/object-test.js b/web/nms.gathering.org/speedometer/d3-master/test/interpolate/object-test.js new file mode 100644 index 0000000..f9539a6 --- /dev/null +++ b/web/nms.gathering.org/speedometer/d3-master/test/interpolate/object-test.js @@ -0,0 +1,35 @@ +var vows = require("vows"), + load = require("../load"), + assert = require("../assert"); + +var suite = vows.describe("d3.interpolateObject"); + +suite.addBatch({ + "interpolateObject": { + topic: load("interpolate/object").expression("d3.interpolateObject"), + "interpolates defined properties": function(interpolate) { + assert.deepEqual(interpolate({a: 2, b: 12}, {a: 4, b: 24})(.5), {a: 3, b: 18}); + }, + "interpolates inherited properties": function(interpolate) { + function a(a) { this.a = a; } + a.prototype.b = 12; + assert.deepEqual(interpolate(new a(2), new a(4))(.5), {a: 3, b: 12}); + }, + "interpolates color properties as rgb": function(interpolate) { + assert.deepEqual(interpolate({background: "red"}, {background: "green"})(.5), {background: "#804000"}); + assert.deepEqual(interpolate({fill: "red"}, {fill: "green"})(.5), {fill: "#804000"}); + assert.deepEqual(interpolate({stroke: "red"}, {stroke: "green"})(.5), {stroke: "#804000"}); + assert.deepEqual(interpolate({color: "red"}, {color: "green"})(.5), {color: "#804000"}); + }, + "interpolates nested objects and arrays": function(interpolate) { + assert.deepEqual(interpolate({foo: [2, 12]}, {foo: [4, 24]})(.5), {foo: [3, 18]}); + assert.deepEqual(interpolate({foo: {bar: [2, 12]}}, {foo: {bar: [4, 24]}})(.5), {foo: {bar: [3, 18]}}); + }, + "merges non-shared properties": function(interpolate) { + assert.deepEqual(interpolate({foo: 2}, {foo: 4, bar: 12})(.5), {foo: 3, bar: 12}); + assert.deepEqual(interpolate({foo: 2, bar: 12}, {foo: 4})(.5), {foo: 3, bar: 12}); + } + } +}); + +suite.export(module); diff --git a/web/nms.gathering.org/speedometer/d3-master/test/interpolate/rgb-test.js b/web/nms.gathering.org/speedometer/d3-master/test/interpolate/rgb-test.js new file mode 100644 index 0000000..89f9959 --- /dev/null +++ b/web/nms.gathering.org/speedometer/d3-master/test/interpolate/rgb-test.js @@ -0,0 +1,31 @@ +var vows = require("vows"), + load = require("../load"), + assert = require("../assert"); + +var suite = vows.describe("d3.interpolateRgb"); + +suite.addBatch({ + "interpolateRgb": { + topic: load("interpolate/rgb"), // beware instanceof d3_Color + "parses string input": function(d3) { + assert.strictEqual(d3.interpolateRgb("steelblue", "#f00")(.2), "#6b6890"); + assert.strictEqual(d3.interpolateRgb("steelblue", "#f00")(.6), "#b53448"); + }, + "parses d3.rgb input": function(d3) { + assert.strictEqual(d3.interpolateRgb(d3.rgb("steelblue"), "#f00")(.2), "#6b6890"); + assert.strictEqual(d3.interpolateRgb("steelblue", d3.rgb(255, 0, 0))(.6), "#b53448"); + }, + "parses d3.hsl input": function(d3) { + assert.strictEqual(d3.interpolateRgb(d3.hsl("steelblue"), "#f00")(.2), "#6b6890"); + assert.strictEqual(d3.interpolateRgb("steelblue", d3.hsl(0, 1, .5))(.6), "#b53448"); + }, + "interpolates in RGB color space": function(d3) { + assert.strictEqual(d3.interpolateRgb("steelblue", "#f00")(.2), "#6b6890"); + }, + "outputs an RGB string": function(d3) { + assert.strictEqual(d3.interpolateRgb("steelblue", "#f00")(.2), "#6b6890"); + } + } +}); + +suite.export(module); diff --git a/web/nms.gathering.org/speedometer/d3-master/test/interpolate/round-test.js b/web/nms.gathering.org/speedometer/d3-master/test/interpolate/round-test.js new file mode 100644 index 0000000..98fad58 --- /dev/null +++ b/web/nms.gathering.org/speedometer/d3-master/test/interpolate/round-test.js @@ -0,0 +1,17 @@ +var vows = require("vows"), + load = require("../load"), + assert = require("../assert"); + +var suite = vows.describe("d3.interpolateRound"); + +suite.addBatch({ + "interpolateRound": { + topic: load("interpolate/round").expression("d3.interpolateRound"), + "interpolates integers": function(interpolate) { + assert.strictEqual(interpolate(2, 12)(.456), 7); + assert.strictEqual(interpolate(2, 12)(.678), 9); + } + } +}); + +suite.export(module); diff --git a/web/nms.gathering.org/speedometer/d3-master/test/interpolate/string-test.js b/web/nms.gathering.org/speedometer/d3-master/test/interpolate/string-test.js new file mode 100644 index 0000000..37aeade --- /dev/null +++ b/web/nms.gathering.org/speedometer/d3-master/test/interpolate/string-test.js @@ -0,0 +1,53 @@ +var vows = require("vows"), + load = require("../load"), + assert = require("../assert"); + +var suite = vows.describe("d3.interpolateString"); + +suite.addBatch({ + "interpolateString": { + topic: load("interpolate/string").expression("d3.interpolateString"), + "interpolates matching numbers in both strings": function(interpolate) { + assert.strictEqual(interpolate(" 10/20 30", "50/10 100 ")(.2), "18/18 44 "); + assert.strictEqual(interpolate(" 10/20 30", "50/10 100 ")(.4), "26/16 58 "); + }, + "coerces objects to strings": function(interpolate) { + assert.strictEqual(interpolate({toString: function() { return "2px"; }}, {toString: function() { return "12px"; }})(.25), "4.5px"); + }, + "preserves non-numbers in string b": function(interpolate) { + assert.strictEqual(interpolate(" 10/20 30", "50/10 foo ")(.2), "18/18 foo "); + assert.strictEqual(interpolate(" 10/20 30", "50/10 foo ")(.4), "26/16 foo "); + }, + "preserves non-matching numbers in string b": function(interpolate) { + assert.strictEqual(interpolate(" 10/20 foo", "50/10 100 ")(.2), "18/18 100 "); + assert.strictEqual(interpolate(" 10/20 bar", "50/10 100 ")(.4), "26/16 100 "); + }, + "preserves equal-value numbers in both strings": function(interpolate) { + assert.strictEqual(interpolate(" 10/20 100 20", "50/10 100, 20 ")(.2), "18/18 100, 20 "); + assert.strictEqual(interpolate(" 10/20 100 20", "50/10 100, 20 ")(.4), "26/16 100, 20 "); + }, + "interpolates decimal notation correctly": function(interpolate) { + assert.strictEqual(interpolate("1.", "2.")(.5), "1.5"); + }, + "interpolates exponent notation correctly": function(interpolate) { + assert.strictEqual(interpolate("1e+3", "1e+4")(.5), "5500"); + assert.strictEqual(interpolate("1e-3", "1e-4")(.5), "0.00055"); + assert.strictEqual(interpolate("1.e-3", "1.e-4")(.5), "0.00055"); + assert.strictEqual(interpolate("-1.e-3", "-1.e-4")(.5), "-0.00055"); + assert.strictEqual(interpolate("+1.e-3", "+1.e-4")(.5), "0.00055"); + assert.strictEqual(interpolate(".1e-2", ".1e-3")(.5), "0.00055"); + }, + "with no numbers, returns the target string": function(interpolate) { + assert.strictEqual(interpolate("foo", "bar")(.5), "bar"); + assert.strictEqual(interpolate("foo", "")(.5), ""); + assert.strictEqual(interpolate("", "bar")(.5), "bar"); + assert.strictEqual(interpolate("", "")(.5), ""); + }, + "with two numerically-equivalent numbers, returns the default format": function(interpolate) { + assert.strictEqual(interpolate("top: 1000px;", "top: 1e3px;")(.5), "top: 1000px;"); + assert.strictEqual(interpolate("top: 1e3px;", "top: 1000px;")(.5), "top: 1000px;"); + } + } +}); + +suite.export(module); |