stripmem 0.0.1

data/lib/stripmem/public/components/d3/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);

data/lib/stripmem/public/components/d3/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.labEqual(d3.interpolateLab("steelblue", "#f00")(.2), 52.62, 12.76, -12.31);
+      assert.labEqual(d3.interpolateLab("steelblue", "#f00")(.6), 52.93, 46.42, 27.45);
+    },
+    "parses d3.hsl input": function(d3) {
+      assert.labEqual(d3.interpolateLab(d3.hsl("steelblue"), "#f00")(.2), 52.62, 12.76, -12.31);
+      assert.labEqual(d3.interpolateLab("steelblue", d3.hsl(0, 1, .5))(.6), 52.93, 46.42, 27.45);
+    },
+    "parses d3.rgb input": function(d3) {
+      assert.labEqual(d3.interpolateLab(d3.rgb("steelblue"), "#f00")(.2), 52.62, 12.76, -12.31);
+      assert.labEqual(d3.interpolateLab("steelblue", d3.rgb(255, 0, 0))(.6), 52.93, 46.42, 27.45);
+    },
+    "interpolates in HSL color space": function(d3) {
+      assert.labEqual(d3.interpolateLab("steelblue", "#f00")(.2), 52.62, 12.76, -12.31);
+    },
+    "returns an instanceof d3.lab": function(d3) {
+      assert.labEqual(d3.interpolateLab("steelblue", "#f00")(.2), 52.62, 12.76, -12.31);
+    }
+  }
+});
+
+suite.export(module);

data/lib/stripmem/public/components/d3/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)(.4), 6);
+      assert.strictEqual(interpolate(2, 12)(.6), 8);
+    },
+    "coerces strings to numbers": function(interpolate) {
+      assert.strictEqual(interpolate("2", "12")(.4), 6);
+    }
+  }
+});
+
+suite.export(module);

data/lib/stripmem/public/components/d3/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: d3.rgb(128, 64, 0)});
+      assert.deepEqual(interpolate({fill: "red"}, {fill: "green"})(.5), {fill: d3.rgb(128, 64, 0)});
+      assert.deepEqual(interpolate({stroke: "red"}, {stroke: "green"})(.5), {stroke: d3.rgb(128, 64, 0)});
+      assert.deepEqual(interpolate({color: "red"}, {color: "green"})(.5), {color: d3.rgb(128, 64, 0)});
+    },
+    "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);

data/lib/stripmem/public/components/d3/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.rgbEqual(d3.interpolateRgb("steelblue", "#f00")(.2), 107, 104, 144);
+      assert.rgbEqual(d3.interpolateRgb("steelblue", "#f00")(.6), 181, 52, 72);
+    },
+    "parses d3.rgb input": function(d3) {
+      assert.rgbEqual(d3.interpolateRgb(d3.rgb("steelblue"), "#f00")(.2), 107, 104, 144);
+      assert.rgbEqual(d3.interpolateRgb("steelblue", d3.rgb(255, 0, 0))(.6), 181, 52, 72);
+    },
+    "parses d3.hsl input": function(d3) {
+      assert.rgbEqual(d3.interpolateRgb(d3.hsl("steelblue"), "#f00")(.2), 107, 104, 144);
+      assert.rgbEqual(d3.interpolateRgb("steelblue", d3.hsl(0, 1, .5))(.6), 181, 52, 72);
+    },
+    "interpolates in RGB color space": function(d3) {
+      assert.rgbEqual(d3.interpolateRgb("steelblue", "#f00")(.2), 107, 104, 144);
+    },
+    "returns an instanceof d3.rgb": function(d3) {
+      assert.rgbEqual(d3.interpolateRgb("steelblue", "#f00")(.2), 107, 104, 144);
+    }
+  }
+});
+
+suite.export(module);

data/lib/stripmem/public/components/d3/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);

data/lib/stripmem/public/components/d3/test/interpolate/string-test.js

@@ -0,0 +1,43 @@
+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"; }})(.4), "6px");
+    },
+    "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");
+    }
+  }
+});
+
+suite.export(module);

data/lib/stripmem/public/components/d3/test/layout/chord-test.js

@@ -0,0 +1,164 @@
+var vows = require("vows"),
+    load = require("../load"),
+    assert = require("../assert");
+
+var suite = vows.describe("d3.layout.chord");
+
+suite.addBatch({
+  "chord": {
+    topic: load("layout/chord").expression("d3.layout.chord"),
+    "of a simple matrix": {
+      topic: function(chord) {
+        return chord()
+            .padding(.05)
+            .sortSubgroups(function(a, b) { return b - a; })
+            .matrix([
+              [11975,  5871, 8916, 2868],
+              [ 1951, 10048, 2060, 6171],
+              [ 8010, 16145, 8090, 8045],
+              [ 1013,   990,  940, 6907]
+            ]);
+      },
+      "computes chord groups": function(chord) {
+        var groups = chord.groups();
+        assert.equal(groups.length, 4);
+
+        assert.equal(groups[0].index, 0);
+        assert.inDelta(groups[0].startAngle, 0.0000000000000000, 1e-6);
+        assert.inDelta(groups[0].endAngle, 1.8024478065173115, 1e-6);
+        assert.inDelta(groups[0].value, 29630, 1e-6);
+
+        assert.equal(groups[1].index, 1);
+        assert.inDelta(groups[1].startAngle, 1.8524478065173116, 1e-6);
+        assert.inDelta(groups[1].endAngle, 3.0830761941597418, 1e-6);
+        assert.inDelta(groups[1].value, 20230, 1e-6);
+
+        assert.equal(groups[2].index, 2);
+        assert.inDelta(groups[2].startAngle, 3.1330761941597416, 1e-6);
+        assert.inDelta(groups[2].endAngle, 5.583991554422396, 1e-6);
+        assert.inDelta(groups[2].value, 40290, 1e-6);
+
+        assert.equal(groups[3].index, 3);
+        assert.inDelta(groups[3].startAngle, 5.6339915544223960, 1e-6);
+        assert.inDelta(groups[3].endAngle, 6.233185307179585, 1e-6);
+        assert.inDelta(groups[3].value, 9850, 1e-6);
+      },
+      "computes chords": function(chord) {
+        var chords = chord.chords();
+        assert.equal(chords.length, 10);
+
+        assert.equal(chords[0].source.index, 0);
+        assert.equal(chords[0].source.subindex, 0);
+        assert.inDelta(chords[0].source.startAngle, 0, 1e-6);
+        assert.inDelta(chords[0].source.endAngle, 0.7284614405347555, 1e-6);
+        assert.equal(chords[0].source.value, 11975);
+        assert.equal(chords[0].target.index, 0);
+        assert.equal(chords[0].target.subindex, 0);
+        assert.inDelta(chords[0].target.startAngle, 0, 1e-6);
+        assert.inDelta(chords[0].target.endAngle, 0.7284614405347555, 1e-6);
+        assert.equal(chords[0].target.value, 11975);
+
+        assert.equal(chords[1].source.index, 0);
+        assert.equal(chords[1].source.subindex, 1);
+        assert.inDelta(chords[1].source.startAngle, 1.2708382425228875, 1e-6);
+        assert.inDelta(chords[1].source.endAngle, 1.6279820519074009, 1e-6);
+        assert.equal(chords[1].source.value, 5871);
+        assert.equal(chords[1].target.index, 1);
+        assert.equal(chords[1].target.subindex, 0);
+        assert.inDelta(chords[1].target.startAngle, 2.964393248816668, 1e-6);
+        assert.inDelta(chords[1].target.endAngle, 3.0830761941597418, 1e-6);
+        assert.equal(chords[1].target.value, 1951);
+
+        assert.equal(chords[2].source.index, 0);
+        assert.equal(chords[2].source.subindex, 2);
+        assert.inDelta(chords[2].source.startAngle, 0.7284614405347555, 1e-6);
+        assert.inDelta(chords[2].source.endAngle, 1.2708382425228875, 1e-6);
+        assert.equal(chords[2].source.value, 8916);
+        assert.equal(chords[2].target.index, 2);
+        assert.equal(chords[2].target.subindex, 0);
+        assert.inDelta(chords[2].target.startAngle, 5.0967284113173115, 1e-6);
+        assert.inDelta(chords[2].target.endAngle, 5.583991554422396, 1e-6);
+        assert.equal(chords[2].target.value, 8010);
+
+        assert.equal(chords[3].source.index, 0);
+        assert.equal(chords[3].source.subindex, 3);
+        assert.inDelta(chords[3].source.startAngle, 1.6279820519074009, 1e-6);
+        assert.inDelta(chords[3].source.endAngle, 1.8024478065173115, 1e-6);
+        assert.equal(chords[3].source.value, 2868);
+        assert.equal(chords[3].target.index, 3);
+        assert.equal(chords[3].target.subindex, 0);
+        assert.inDelta(chords[3].target.startAngle, 6.05415716358929, 1e-6);
+        assert.inDelta(chords[3].target.endAngle, 6.115779830751019, 1e-6);
+        assert.equal(chords[3].target.value, 1013);
+
+        assert.equal(chords[4].source.index, 1);
+        assert.equal(chords[4].source.subindex, 1);
+        assert.inDelta(chords[4].source.startAngle, 1.8524478065173116, 1e-6);
+        assert.inDelta(chords[4].source.endAngle, 2.4636862661827164, 1e-6);
+        assert.equal(chords[4].source.value, 10048);
+        assert.equal(chords[4].target.index, 1);
+        assert.equal(chords[4].target.subindex, 1);
+        assert.inDelta(chords[4].target.startAngle, 1.8524478065173116, 1e-6);
+        assert.inDelta(chords[4].target.endAngle, 2.4636862661827164, 1e-6);
+        assert.equal(chords[4].target.value, 10048);
+
+        assert.equal(chords[5].source.index, 2);
+        assert.equal(chords[5].source.subindex, 1);
+        assert.inDelta(chords[5].source.startAngle, 3.1330761941597416, 1e-6);
+        assert.inDelta(chords[5].source.endAngle, 4.1152064620038855, 1e-6);
+        assert.equal(chords[5].source.value, 16145);
+        assert.equal(chords[5].target.index, 1);
+        assert.equal(chords[5].target.subindex, 2);
+        assert.inDelta(chords[5].target.startAngle, 2.8390796314887687, 1e-6);
+        assert.inDelta(chords[5].target.endAngle, 2.964393248816668, 1e-6);
+        assert.equal(chords[5].target.value, 2060);
+
+        assert.equal(chords[6].source.index, 1);
+        assert.equal(chords[6].source.subindex, 3);
+        assert.inDelta(chords[6].source.startAngle, 2.4636862661827164, 1e-6);
+        assert.inDelta(chords[6].source.endAngle, 2.8390796314887687, 1e-6);
+        assert.equal(chords[6].source.value, 6171);
+        assert.equal(chords[6].target.index, 3);
+        assert.equal(chords[6].target.subindex, 1);
+        assert.inDelta(chords[6].target.startAngle, 6.115779830751019, 1e-6);
+        assert.inDelta(chords[6].target.endAngle, 6.176003365292097, 1e-6);
+        assert.equal(chords[6].target.value, 990);
+
+        assert.equal(chords[7].source.index, 2);
+        assert.equal(chords[7].source.subindex, 2);
+        assert.inDelta(chords[7].source.startAngle, 4.1152064620038855, 1e-6);
+        assert.inDelta(chords[7].source.endAngle, 4.607336153354714, 1e-6);
+        assert.equal(chords[7].source.value, 8090);
+        assert.equal(chords[7].target.index, 2);
+        assert.equal(chords[7].target.subindex, 2);
+        assert.inDelta(chords[7].target.startAngle, 4.1152064620038855, 1e-6);
+        assert.inDelta(chords[7].target.endAngle, 4.607336153354714, 1e-6);
+        assert.equal(chords[7].target.value, 8090);
+
+        assert.equal(chords[8].source.index, 2);
+        assert.equal(chords[8].source.subindex, 3);
+        assert.inDelta(chords[8].source.startAngle, 4.607336153354714, 1e-6);
+        assert.inDelta(chords[8].source.endAngle, 5.0967284113173115, 1e-6);
+        assert.equal(chords[8].source.value, 8045);
+        assert.equal(chords[8].target.index, 3);
+        assert.equal(chords[8].target.subindex, 2);
+        assert.inDelta(chords[8].target.startAngle, 6.176003365292097, 1e-6);
+        assert.inDelta(chords[8].target.endAngle, 6.233185307179585, 1e-6);
+        assert.equal(chords[8].target.value, 940);
+
+        assert.equal(chords[9].source.index, 3);
+        assert.equal(chords[9].source.subindex, 3);
+        assert.inDelta(chords[9].source.startAngle, 5.633991554422396, 1e-6);
+        assert.inDelta(chords[9].source.endAngle, 6.05415716358929, 1e-6);
+        assert.equal(chords[9].source.value, 6907);
+        assert.equal(chords[9].target.index, 3);
+        assert.equal(chords[9].target.subindex, 3);
+        assert.inDelta(chords[9].target.startAngle, 5.633991554422396, 1e-6);
+        assert.inDelta(chords[9].target.endAngle, 6.05415716358929, 1e-6);
+        assert.equal(chords[9].target.value, 6907);
+      }
+    }
+  }
+});
+
+suite.export(module);

data/lib/stripmem/public/components/d3/test/layout/cluster-test.js

@@ -0,0 +1,44 @@
+var vows = require("vows"),
+    load = require("../load"),
+    assert = require("../assert");
+
+var suite = vows.describe("d3.layout.cluster");
+
+suite.addBatch({
+  "cluster": {
+    topic: load("layout/cluster").expression("d3.layout.cluster"),
+    "can handle an empty children array": function(cluster) {
+      var c = cluster();
+      assert.deepEqual(c.nodes({value: 1, children: [{value: 1, children: []}, {value: 1}]}).map(layout), [
+        {value: 1, depth: 0, x: 0.5,  y: 0},
+        {value: 1, depth: 1, x: 0.25, y: 1},
+        {value: 1, depth: 1, x: 0.75, y: 1}
+      ]);
+    },
+    "can handle zero-valued nodes": function(cluster) {
+      var c = cluster();
+      assert.deepEqual(c.nodes({value: 0, children: [{value: 0}, {value: 1}]}).map(layout), [
+        {value: 0, depth: 0, x: 0.5,  y: 0},
+        {value: 0, depth: 1, x: 0.25, y: 1},
+        {value: 1, depth: 1, x: 0.75, y: 1}
+      ]);
+    },
+    "can handle a single node": function(cluster) {
+      var c = cluster();
+      assert.deepEqual(c.nodes({value: 0}).map(layout), [
+        {value: 0, depth: 0, x: 0.5,  y: 0}
+      ]);
+    }
+  }
+});
+
+function layout(node) {
+  return {
+    value: node.value,
+    depth: node.depth,
+    x: node.x,
+    y: node.y
+  };
+}
+
+suite.export(module);

data/lib/stripmem/public/components/d3/test/layout/force-test.js

@@ -0,0 +1,119 @@
+var vows = require("vows"),
+    load = require("../load"),
+    assert = require("../assert");
+
+var suite = vows.describe("d3.layout.force");
+
+suite.addBatch({
+  "force": {
+    topic: load("layout/force").expression("d3.layout.force").document(),
+
+    "default instance": {
+      topic: function(force) {
+        return force();
+      },
+
+      "friction": {
+        "defaults to .9": function(f) {
+          assert.equal(f.friction(), .9);
+        },
+        "can be a number": function(f) {
+          f.friction(.5);
+          assert.equal(f.friction(), .5);
+        },
+        "coerces to a number": function(f) {
+          f.friction(".5");
+          assert.strictEqual(f.friction(), .5);
+        }
+      },
+
+      "gravity": {
+        "defaults to .1": function(f) {
+          assert.equal(f.gravity(), .1);
+        },
+        "can be a number": function(f) {
+          f.gravity(.5);
+          assert.equal(f.gravity(), .5);
+        },
+        "coerces to a number": function(f) {
+          f.gravity(".5");
+          assert.strictEqual(f.gravity(), .5);
+        }
+      },
+
+      "theta": {
+        "defaults to .8": function(f) {
+          assert.equal(f.theta(), .8);
+        },
+        "can be a number": function(f) {
+          f.theta(.5);
+          assert.equal(f.theta(), .5);
+        },
+        "coerces to a number": function(f) {
+          f.theta(".5");
+          assert.strictEqual(f.theta(), .5);
+        }
+      },
+
+      "charge": {
+        "defaults to -30": function(f) {
+          assert.equal(f.charge(), -30);
+        },
+        "can be a number": function(f) {
+          f.charge(-40);
+          assert.equal(f.charge(), -40);
+        },
+        "can be a function": function(f) { // TODO expose the computed value?
+          f.charge(foo);
+          assert.equal(f.charge(), foo);
+        },
+        "coerces to a number": function(f) {
+          f.charge("-40");
+          assert.strictEqual(f.charge(), -40);
+        }
+      },
+
+      "linkDistance": {
+        "defaults to 20": function(f) {
+          assert.equal(f.linkDistance(), 20);
+        },
+        "can be a number": function(f) {
+          f.linkDistance(40);
+          assert.equal(f.linkDistance(), 40);
+        },
+        "can be a function": function(f) { // TODO expose the computed value?
+          f.linkDistance(foo);
+          assert.equal(f.linkDistance(), foo);
+        },
+        "coerces to a number": function(f) {
+          f.linkDistance("40");
+          assert.strictEqual(f.linkDistance(), 40);
+        }
+      },
+
+      "linkStrength": {
+        "defaults to 1": function(f) {
+          assert.equal(f.linkStrength(), 1);
+        },
+        "can be a number": function(f) {
+          f.linkStrength(.5);
+          assert.equal(f.linkStrength(), .5);
+        },
+        "can be a function": function(f) { // TODO expose the computed value?
+          f.linkStrength(foo);
+          assert.equal(f.linkStrength(), foo);
+        },
+        "coerces to a number": function(f) {
+          f.linkStrength(".5");
+          assert.strictEqual(f.linkStrength(), .5);
+        }
+      }
+    }
+  }
+});
+
+function foo(d) {
+  return d.foo;
+}
+
+suite.export(module);

data/lib/stripmem/public/components/d3/test/layout/hierarchy-test.js

@@ -0,0 +1,27 @@
+var vows = require("vows"),
+    load = require("../load"),
+    assert = require("../assert");
+
+var suite = vows.describe("d3.layout.hierarchy");
+
+suite.addBatch({
+  "hierarchy": {
+    topic: load("layout/treemap").expression("d3.layout.treemap"), // hierarchy is abstract, so test a subclass
+    "doesn't overwrite the value of a node that has an empty children array": function(hierarchy) {
+      var h = hierarchy(),
+          nodes = h.sticky(true).nodes({value: 1, children: []});
+      assert.equal(nodes[0].value, 1);
+      h.nodes(nodes[0]);
+      assert.equal(nodes[0].value, 1);
+    },
+    "a valueless node that has an empty children array gets a value of 0": function(hierarchy) {
+      var h = hierarchy(),
+          nodes = h.sticky(true).nodes({children: []});
+      assert.equal(nodes[0].value, 0);
+      h.nodes(nodes[0]);
+      assert.equal(nodes[0].value, 0);
+    }
+  }
+});
+
+suite.export(module);