stripmem 0.0.1

data/lib/stripmem/public/components/d3/test/geo/stream-test.js

@@ -0,0 +1,264 @@
+var vows = require("vows"),
+    load = require("../load"),
+    assert = require("../assert");
+
+var suite = vows.describe("d3.geo.stream");
+
+suite.addBatch({
+  "stream": {
+    topic: load("geo/stream").expression("d3.geo.stream"),
+    "does not allow null input": function(stream) {
+      try {
+        stream(null);
+        assert.fail("expected error");
+      } catch (expected) {}
+    },
+    "ignores unknown types": function(stream) {
+      stream({type: "Unknown"}, {});
+      stream({type: "Feature", geometry: {type: "Unknown"}}, {});
+      stream({type: "FeatureCollection", features: [{type: "Feature", geometry: {type: "Unknown"}}]}, {});
+      stream({type: "GeometryCollection", geometries: [{type: "Unknown"}]}, {});
+    },
+    "ignores null geometries": function(stream) {
+      stream(null, {});
+      stream({type: "Feature", geometry: null}, {});
+      stream({type: "FeatureCollection", features: [{type: "Feature", geometry: null}]}, {});
+      stream({type: "GeometryCollection", geometries: [null]}, {});
+    },
+    "returns void": function(stream) {
+      assert.isUndefined(stream({type: "Point", coordinates: [1, 2]}, {point: function() { return true; }}));
+    },
+    "allows empty multi-geometries": function(stream) {
+      stream({type: "MultiPoint", coordinates: []}, {});
+      stream({type: "MultiLineString", coordinates: []}, {});
+      stream({type: "MultiPolygon", coordinates: []}, {});
+    },
+    "Sphere ↦ sphere": function(stream) {
+      var calls = 0;
+      stream({type: "Sphere"}, {
+        sphere: function() {
+          ++calls;
+          assert.equal(arguments.length, 0);
+        }
+      });
+      assert.equal(calls, 1);
+    },
+    "Point ↦ point": function(stream) {
+      var calls = 0;
+      stream({type: "Point", coordinates: [1, 2]}, {
+        point: function(x, y) {
+          ++calls;
+          assert.equal(arguments.length, 2);
+          assert.equal(x, 1);
+          assert.equal(y, 2);
+        }
+      });
+      assert.equal(calls, 1);
+    },
+    "MultiPoint ↦ point*": function(stream) {
+      var calls = 0;
+      stream({type: "MultiPoint", coordinates: [[1, 2], [3, 4]]}, {
+        point: function(x, y) {
+          assert.equal(arguments.length, 2);
+          if (++calls === 1) {
+            assert.equal(x, 1);
+            assert.equal(y, 2);
+          } else {
+            assert.equal(x, 3);
+            assert.equal(y, 4);
+          }
+        }
+      });
+      assert.equal(calls, 2);
+    },
+    "LineString ↦ lineStart, point{2,}, lineEnd": function(stream) {
+      var calls = 0;
+      stream({type: "LineString", coordinates: [[1, 2], [3, 4]]}, {
+        lineStart: function() {
+          assert.equal(++calls, 1);
+          assert.equal(arguments.length, 0);
+        },
+        point: function(x, y) {
+          assert.equal(arguments.length, 2);
+          if (++calls === 2) {
+            assert.equal(x, 1);
+            assert.equal(y, 2);
+          } else if (calls === 3) {
+            assert.equal(x, 3);
+            assert.equal(y, 4);
+          } else {
+            assert.fail("too many points");
+          }
+        },
+        lineEnd: function() {
+          assert.equal(++calls, 4);
+          assert.equal(arguments.length, 0);
+        }
+      });
+      assert.equal(calls, 4);
+    },
+    "MultiLineString ↦ (lineStart, point{2,}, lineEnd)*": function(stream) {
+      var calls = 0;
+      stream({type: "MultiLineString", coordinates: [[[1, 2], [3, 4]], [[5, 6], [7, 8]]]}, {
+        lineStart: function() {
+          ++calls;
+          assert.isTrue(calls === 1 || calls === 5);
+          assert.equal(arguments.length, 0);
+        },
+        point: function(x, y) {
+          ++calls;
+          assert.equal(arguments.length, 2);
+          if (calls === 2) {
+            assert.equal(x, 1);
+            assert.equal(y, 2);
+          } else if (calls === 3) {
+            assert.equal(x, 3);
+            assert.equal(y, 4);
+          } else if (calls === 6) {
+            assert.equal(x, 5);
+            assert.equal(y, 6);
+          } else if (calls === 7) {
+            assert.equal(x, 7);
+            assert.equal(y, 8);
+          } else {
+            assert.fail("too many points");
+          }
+        },
+        lineEnd: function() {
+          ++calls;
+          assert.isTrue(calls === 4 || calls === 8);
+          assert.equal(arguments.length, 0);
+        }
+      });
+      assert.equal(calls, 8);
+    },
+    "Polygon ↦ polygonStart, lineStart, point{2,}, lineEnd, polygonEnd": function(stream) {
+      var calls = 0;
+      stream({type: "Polygon", coordinates: [[[1, 2], [3, 4], [1, 2]], [[5, 6], [7, 8], [5, 6]]]}, {
+        polygonStart: function() {
+          ++calls;
+          assert.isTrue(calls === 1);
+          assert.equal(arguments.length, 0);
+        },
+        lineStart: function() {
+          ++calls;
+          assert.isTrue(calls === 2 || calls === 6);
+          assert.equal(arguments.length, 0);
+        },
+        point: function(x, y) {
+          ++calls;
+          assert.equal(arguments.length, 2);
+          if (calls === 3) {
+            assert.equal(x, 1);
+            assert.equal(y, 2);
+          } else if (calls === 4) {
+            assert.equal(x, 3);
+            assert.equal(y, 4);
+          } else if (calls === 7) {
+            assert.equal(x, 5);
+            assert.equal(y, 6);
+          } else if (calls === 8) {
+            assert.equal(x, 7);
+            assert.equal(y, 8);
+          } else {
+            assert.fail("too many points");
+          }
+        },
+        lineEnd: function() {
+          ++calls;
+          assert.isTrue(calls === 5 || calls === 9);
+          assert.equal(arguments.length, 0);
+        },
+        polygonEnd: function() {
+          ++calls;
+          assert.isTrue(calls === 10);
+          assert.equal(arguments.length, 0);
+        }
+      });
+      assert.equal(calls, 10);
+    },
+    "MultiPolygon ↦ (polygonStart, lineStart, point{2,}, lineEnd, polygonEnd)*": function(stream) {
+      var calls = 0;
+      stream({type: "MultiPolygon", coordinates: [[[[1, 2], [3, 4], [1, 2]]], [[[5, 6], [7, 8], [5, 6]]]]}, {
+        polygonStart: function() {
+          ++calls;
+          assert.isTrue(calls === 1 || calls === 7);
+          assert.equal(arguments.length, 0);
+        },
+        lineStart: function() {
+          ++calls;
+          assert.isTrue(calls === 2 || calls === 8);
+          assert.equal(arguments.length, 0);
+        },
+        point: function(x, y) {
+          ++calls;
+          assert.equal(arguments.length, 2);
+          if (calls === 3) {
+            assert.equal(x, 1);
+            assert.equal(y, 2);
+          } else if (calls === 4) {
+            assert.equal(x, 3);
+            assert.equal(y, 4);
+          } else if (calls === 9) {
+            assert.equal(x, 5);
+            assert.equal(y, 6);
+          } else if (calls === 10) {
+            assert.equal(x, 7);
+            assert.equal(y, 8);
+          } else {
+            assert.fail("too many points");
+          }
+        },
+        lineEnd: function() {
+          ++calls;
+          assert.isTrue(calls === 5 || calls === 11);
+          assert.equal(arguments.length, 0);
+        },
+        polygonEnd: function() {
+          ++calls;
+          assert.isTrue(calls === 6 || calls === 12);
+          assert.equal(arguments.length, 0);
+        }
+      });
+      assert.equal(calls, 12);
+    },
+    "Feature ↦ .*": function(stream) {
+      var calls = 0;
+      stream({type: "Feature", geometry: {type: "Point", coordinates: [1, 2]}}, {
+        point: function(x, y) {
+          ++calls;
+          assert.equal(arguments.length, 2);
+          assert.equal(x, 1);
+          assert.equal(y, 2);
+        }
+      });
+      assert.equal(calls, 1);
+    },
+    "FeatureCollection ↦ .*": function(stream) {
+      var calls = 0;
+      stream({type: "FeatureCollection", features: [{type: "Feature", geometry: {type: "Point", coordinates: [1, 2]}}]}, {
+        point: function(x, y) {
+          ++calls;
+          assert.equal(arguments.length, 2);
+          assert.equal(x, 1);
+          assert.equal(y, 2);
+        }
+      });
+      assert.equal(calls, 1);
+    },
+    "GeometryCollection ↦ .*": function(stream) {
+      var calls = 0;
+      stream({type: "GeometryCollection", geometries: [{type: "Point", coordinates: [1, 2]}]}, {
+        point: function(x, y) {
+          ++calls;
+          assert.equal(arguments.length, 2);
+          assert.equal(x, 1);
+          assert.equal(y, 2);
+        }
+      });
+      assert.equal(calls, 1);
+    }
+  }
+});
+
+suite.export(module);

data/lib/stripmem/public/components/d3/test/geo/transverse-mercator-test.js

@@ -0,0 +1,38 @@
+var vows = require("vows"),
+    load = require("../load"),
+    assert = require("../assert"),
+    projectionTestSuite = require("./projection-test-suite");
+
+var suite = vows.describe("d3.geo.transverseMercator");
+
+suite.addBatch({
+  "transverseMercator": {
+    topic: load("geo/transverse-mercator").expression("d3.geo.transverseMercator"),
+    "default": projectionTestSuite({
+      topic: function(projection) { return projection(); }
+    }, {
+      "Null Island":       [[   0.00000000,    0.00000000], [ 480.00000000,  250.00000000]],
+      "Honolulu, HI":      [[ -21.01262744,   82.63349103], [ 473.09890692,   32.39629813]],
+      "San Francisco, CA": [[ -46.16620803,   77.04946507], [ 455.53607488,   38.07095444]],
+      "Svalbard":          [[   3.13977663,   61.55241523], [ 483.91452378,   88.76181349]],
+      "Tierra del Fuego":  [[ -35.62300462,  -60.29317484], [ 435.43771875,  420.48139861]],
+      "Tokyo":             [[  33.38709832,   79.49539834], [ 495.09974957,   37.42095689]],
+      "the South Pole":    [[   0.00000000,  -85.00000000], [ 480.00000000,  472.52947963]],
+      "the North Pole":    [[   0.00000000,   85.00000000], [ 480.00000000,   27.47052037]]
+    }),
+    "translated to 0,0 and at scale 1": projectionTestSuite({
+      topic: function(projection) { return projection().translate([0, 0]).scale(1); }
+    }, {
+      "Null Island":       [[   0.00000000,    0.00000000], [   0.00000000,    0.00000000]],
+      "Honolulu, HI":      [[ -21.01262744,   82.63349120], [  -0.04600729,   -1.45069135]],
+      "San Francisco, CA": [[ -46.16620803,   77.04946507], [  -0.16309283,   -1.41286030]],
+      "Svalbard":          [[   3.13977663,   61.55241523], [   0.02609683,   -1.07492124]],
+      "Tierra del Fuego":  [[ -35.62300462,  -60.29317484], [  -0.29708188,    1.13654266]],
+      "Tokyo":             [[  33.38709832,   79.49539834], [   0.10066500,   -1.41719362]],
+      "the South Pole":    [[   0.00000000,  -85.00000000], [   0.00000000,    1.48352986]],
+      "the North Pole":    [[   0.00000000,   85.00000000], [   0.00000000,   -1.48352986]]
+    })
+  }
+});
+
+suite.export(module);

data/lib/stripmem/public/components/d3/test/geom/hull-test.js

@@ -0,0 +1,68 @@
+var vows = require("vows"),
+    _ = require("../../"),
+    load = require("../load"),
+    assert = require("../assert");
+
+var suite = vows.describe("d3.geom.hull");
+
+suite.addBatch({
+  "hull": {
+    topic: load("geom/hull").expression("d3.geom.hull"),
+    "the default hull layout": {
+      topic: function(hull) {
+        return hull();
+      },
+      "has the default x-accessor, d[0]": function(h) {
+        assert.strictEqual(h.x()([42, 43]), 42);
+      },
+      "has the default y-accessor, d[1]": function(h) {
+        assert.strictEqual(h.y()([42, 43]), 43);
+      },
+      "of no points is empty": function(h) {
+        assert.deepEqual(h([]), []);
+      },
+      "of one point is empty": function(h) {
+        assert.deepEqual(h([[200, 200]]), []);
+      },
+      "of two points is empty": function(h) {
+        assert.deepEqual(h([[200, 200], [760, 300]]), []);
+      },
+      "for three points": function(h) {
+        assert.deepEqual(h([[200, 200], [760, 300], [500, 500]]), [[500, 500], [760, 300], [200, 200]]);
+      },
+      "for four points": function(h) {
+        assert.deepEqual(h([[200, 200], [760, 300], [500, 500], [400, 400]]), [[500, 500], [760, 300], [200, 200]]);
+      },
+      "returns a counter-clockwise polygon": function(h) {
+        assert.greater(_.geom.polygon(h([[200, 200], [760, 300], [500, 500], [400, 400]])).area(), 0);
+      }
+    },
+    "the hull layout with custom accessors": {
+      topic: function(hull) {
+        return hull().x(function(d) { return d.x; }).y(function(d) { return d.y; });
+      },
+      "of four points": function(h) {
+        assert.deepEqual(h([{x: 200, y: 200}, {x: 760, y: 300}, {x: 500, y: 500}, {x: 400, y: 400}]), [{x: 500, y: 500}, {x: 760, y: 300}, {x: 200, y: 200}]);
+      }
+    },
+    "the default hull layout applied directly": {
+      "for no points is empty": function(h) {
+        return h([]);
+      },
+      "for one point is empty": function(h) {
+        return h([[200, 200]]);
+      },
+      "for two points is empty": function(h) {
+        return h([[200, 200], [760, 300]]);
+      },
+      "for three points": function(h) {
+        assert.deepEqual(h([[200, 200], [760, 300], [500, 500]]), [[500, 500], [760, 300], [200, 200]]);
+      },
+      "for four points": function(h) {
+        assert.deepEqual(h([[200, 200], [760, 300], [500, 500], [400, 400]]), [[500, 500], [760, 300], [200, 200]]);
+      }
+    }
+  }
+});
+
+suite.export(module);

data/lib/stripmem/public/components/d3/test/geom/polygon-test.js

@@ -0,0 +1,151 @@
+var vows = require("vows"),
+    _ = require("../../"),
+    load = require("../load"),
+    assert = require("../assert");
+
+var suite = vows.describe("d3.geom.polygon");
+
+suite.addBatch({
+  "polygon": {
+    topic: load("geom/polygon").expression("d3.geom.polygon"),
+    "closed counterclockwise unit square": {
+      topic: function(polygon) {
+        return polygon([[0, 0], [0, 1], [1, 1], [1, 0], [0, 0]]);
+      },
+      "preserves input coordinates": function(p) {
+        assertPolygonInDelta(p, [[0, 0], [0, 1], [1, 1], [1, 0], [0, 0]]);
+      },
+      "has area 1": function(p) {
+        assert.equal(p.area(), 1);
+      },
+      "has centroid ⟨.5,.5⟩": function(p) {
+        assertPointInDelta(p.centroid(), [.5, .5]);
+      },
+      "can clip an open counterclockwise triangle": function(p) {
+        assertPolygonInDelta(p.clip([[0.9, 0.5], [2, -1], [0.5, 0.1]]), [[0.9, 0.5], [1, 0.363636], [1, 0], [0.636363, 0], [0.5, 0.1]], 1e-4);
+      },
+      "can clip a closed counterclockwise triangle": function(p) {
+        assertPolygonInDelta(p.clip([[0.9, 0.5], [2, -1], [0.5, 0.1], [0.9, 0.5]]), [[0.9, 0.5], [1, 0.363636], [1, 0], [0.636363, 0], [0.5, 0.1], [0.9, 0.5]], 1e-4);
+      }
+    },
+    "closed clockwise unit square": {
+      topic: function(polygon) {
+        return polygon([[0, 0], [1, 0], [1, 1], [0, 1], [0, 0]]);
+      },
+      "preserves input coordinates": function(p) {
+        assertPolygonInDelta(p, [[0, 0], [1, 0], [1, 1], [0, 1], [0, 0]]);
+      },
+      "has area 1": function(p) {
+        assert.equal(p.area(), -1);
+      },
+      "has centroid ⟨.5,.5⟩": function(p) {
+        assertPointInDelta(p.centroid(), [.5, .5]);
+      },
+      "is not currently supported for clipping": function(p) {
+        // because clipping requires a counterclockwise source polygon
+      }
+    },
+    "closed clockwise triangle": {
+      topic: function(polygon) {
+        return polygon([[1, 1], [3, 2], [2, 3], [1, 1]]);
+      },
+      "preserves input coordinates": function(p) {
+        assertPolygonInDelta(p, [[1, 1], [3, 2], [2, 3], [1, 1]]);
+      },
+      "has area 1.5": function(p) {
+        assert.equal(p.area(), -1.5);
+      },
+      "has centroid ⟨2,2⟩": function(p) {
+        assertPointInDelta(p.centroid(), [2, 2]);
+      },
+      "is not currently supported for clipping": function(p) {
+        // because clipping requires a counterclockwise source polygon
+      }
+    },
+    "open counterclockwise unit square": {
+      topic: function(polygon) {
+        return polygon([[0, 0], [0, 1], [1, 1], [1, 0]]);
+      },
+      "remains an open polygon": function(p) {
+        assertPolygonInDelta(p, [[0, 0], [0, 1], [1, 1], [1, 0]]);
+      },
+      "has area 1": function(p) {
+        assert.equal(p.area(), 1);
+      },
+      "has centroid ⟨.5,.5⟩": function(p) {
+        assertPointInDelta(p.centroid(), [.5, .5]);
+      },
+      "can clip an open counterclockwise triangle": function(p) {
+        assertPolygonInDelta(p.clip([[0.9, 0.5], [2, -1], [0.5, 0.1]]), [[0.9, 0.5], [1, 0.363636], [1, 0], [0.636363, 0], [0.5, 0.1]], 1e-4);
+      },
+      "can clip an closed counterclockwise triangle": function(p) {
+        assertPolygonInDelta(p.clip([[0.9, 0.5], [2, -1], [0.5, 0.1], [0.9, 0.5]]), [[0.9, 0.5], [1, 0.363636], [1, 0], [0.636363, 0], [0.5, 0.1], [0.9, 0.5]], 1e-4);
+      }
+    },
+    "open clockwise unit square": {
+      topic: function(polygon) {
+        return polygon([[0, 0], [1, 0], [1, 1], [0, 1]]);
+      },
+      "remains an open polygon": function(p) {
+        assertPolygonInDelta(p, [[0, 0], [1, 0], [1, 1], [0, 1]]);
+      },
+      "has area 1": function(p) {
+        assert.equal(p.area(), -1);
+      },
+      "has centroid ⟨.5,.5⟩": function(p) {
+        assertPointInDelta(p.centroid(), [.5, .5]);
+      },
+      "is not currently supported for clipping": function(p) {
+        // because clipping requires a counterclockwise source polygon
+      }
+    },
+    "open clockwise triangle": {
+      topic: function(polygon) {
+        return polygon([[1, 1], [3, 2], [2, 3]]);
+      },
+      "remains an open polygon": function(p) {
+        assertPolygonInDelta(p, [[1, 1], [3, 2], [2, 3]]);
+      },
+      "has area 1.5": function(p) {
+        assert.equal(p.area(), -1.5);
+      },
+      "has centroid ⟨2,2⟩": function(p) {
+        assertPointInDelta(p.centroid(), [2, 2]);
+      }
+    },
+    "large square": {
+      topic: function(polygon) {
+        var r = 1e8,
+            d = _.range(0, r, r / 1e4);
+        return polygon(
+            d.map(function(y) { return [0, y]; }).concat(
+            d.map(function(x) { return [x, r]; })).concat(
+            d.map(function(y) { return [r, y]; }).reverse()).concat(
+            d.map(function(x) { return [x, 0]; }).reverse()));
+      },
+      "has area 1e16 - 5e7": function(p) {
+        assert.equal(p.area(), 1e16 - 5e7);
+      }
+    }
+  }
+});
+
+function assertPointInDelta(expected, actual, δ, message) {
+  if (!δ) δ = 0;
+  if (!pointInDelta(expected, actual, δ)) {
+    assert.fail(JSON.stringify(actual), JSON.stringify(expected), message || "expected {expected}, got {actual}", "===", assertPointInDelta);
+  }
+}
+
+function assertPolygonInDelta(expected, actual, δ, message) {
+  if (!δ) δ = 0;
+  if (expected.length !== actual.length || expected.some(function(e, i) { return !pointInDelta(e, actual[i], δ); })) {
+    assert.fail(JSON.stringify(actual), JSON.stringify(expected), message || "expected {expected}, got {actual}", "===", assertPolygonInDelta);
+  }
+}
+
+function pointInDelta(a, b, δ) {
+  return !(Math.abs(a[0] - b[0]) > δ || Math.abs(a[1] - b[1]) > δ);
+}
+
+suite.export(module);

data/lib/stripmem/public/components/d3/test/geom/quadtree-test.js

@@ -0,0 +1,139 @@
+var vows = require("vows"),
+    load = require("../load"),
+    assert = require("../assert");
+
+var suite = vows.describe("d3.geom.quadtree");
+
+suite.addBatch({
+  "quadtree": {
+    topic: load("geom/quadtree").expression("d3.geom.quadtree"),
+    "the default quadtree layout": {
+      topic: function(quadtree) {
+        return quadtree();
+      },
+      "has no defined size": function(q) {
+        assert.isNull(q.size());
+      },
+      "has no defined extent": function(q) {
+        assert.isNull(q.extent());
+      },
+      "has the default x-accessor, d[0]": function(q) {
+        assert.strictEqual(q.x()([42, 43]), 42);
+      },
+      "has the default y-accessor, d[1]": function(q) {
+        assert.strictEqual(q.y()([42, 43]), 43);
+      },
+      "can create a single-node quadtree with no bounds": function(q) {
+        var point = [0, 0],
+            q = q([point]),
+            n = 0;
+        q.visit(function(node, x1, y1, x2, y2) {
+          assert.deepEqual(node.point, point);
+          assert.isUndefined(node[0]);
+          assert.isUndefined(node[1]);
+          assert.isUndefined(node[2]);
+          assert.isUndefined(node[3]);
+          assert.isTrue(node.leaf);
+          ++n;
+        });
+        assert.strictEqual(n, 1, "number of visits");
+      }
+    },
+    "the quadtree applied directly": {
+      "can create a single-node quadtree with no bounds": function(quadtree) {
+        var point = {x: 0, y: 0},
+            q = quadtree([point]),
+            n = 0;
+        q.visit(function(node, x1, y1, x2, y2) {
+          assert.deepEqual(node.point, point);
+          assert.isUndefined(node[0]);
+          assert.isUndefined(node[1]);
+          assert.isUndefined(node[2]);
+          assert.isUndefined(node[3]);
+          assert.isTrue(node.leaf);
+          ++n;
+        });
+        assert.strictEqual(n, 1, "number of visits");
+      },
+      "can create an empty quadtree": function(quadtree) {
+        var q = quadtree([], 8, 10, 56, 47),
+            n = 0;
+        q.visit(function(node, x1, y1, x2, y2) {
+          assert.isNull(node.point);
+          assert.isUndefined(node[0]);
+          assert.isUndefined(node[1]);
+          assert.isUndefined(node[2]);
+          assert.isUndefined(node[3]);
+          assert.isTrue(node.leaf);
+          ++n;
+        });
+        assert.strictEqual(n, 1, "number of visits");
+      },
+      "squarifies the input dimensions": function(quadtree) {
+        var ox1 = 8,
+            oy1 = 10,
+            ox2 = 56,
+            oy2 = 47,
+            q = quadtree([], ox1, oy1, ox2, oy2),
+            n = 0;
+        q.visit(function(node, x1, y1, x2, y2) {
+          assert.strictEqual(x1, ox1);
+          assert.strictEqual(y1, oy1);
+          assert.strictEqual(x2, Math.max(ox2 - ox1, oy2 - oy1) + x1);
+          assert.strictEqual(y2, Math.max(ox2 - ox1, oy2 - oy1) + y1);
+          ++n;
+        });
+        assert.strictEqual(n, 1, "number of visits");
+      },
+      "with three arguments, x1 and y1 are 0,0": function(quadtree) {
+        var dx = 56,
+            dy = 47,
+            q = quadtree([], dx, dy),
+            n = 0;
+        q.visit(function(node, x1, y1, x2, y2) {
+          assert.strictEqual(x1, 0);
+          assert.strictEqual(y1, 0);
+          assert.strictEqual(x2, Math.max(dx, dy));
+          assert.strictEqual(y2, Math.max(dx, dy));
+          ++n;
+        });
+        assert.strictEqual(n, 1, "number of visits");
+      },
+      "visit": {
+        "uses pre-order traversal": function(quadtree) {
+          var a = {x: 100, y: 100},
+              b = {x: 200, y: 200},
+              c = {x: 300, y: 300},
+              q = quadtree([a, b, c], 960, 500),
+              expected = [
+                {point: null, x1:   0, y1:   0, x2: 960, y2: 960},
+                {point: null, x1:   0, y1:   0, x2: 480, y2: 480},
+                {point: null, x1:   0, y1:   0, x2: 240, y2: 240},
+                {point:    a, x1:   0, y1:   0, x2: 120, y2: 120},
+                {point:    b, x1: 120, y1: 120, x2: 240, y2: 240},
+                {point:    c, x1: 240, y1: 240, x2: 480, y2: 480}
+              ];
+          q.visit(function(node, x1, y1, x2, y2) {
+            assert.deepEqual({point: node.point, x1: x1, y1: y1, x2: x2, y2: y2}, expected.shift());
+            assert.equal(!!node.point, node.leaf);
+          });
+          assert.isEmpty(expected);
+        },
+        "does not recurse if the callback returns truthy": function(quadtree) {
+          var a = {x: 100, y: 100},
+              b = {x: 700, y: 700},
+              c = {x: 800, y: 800},
+              q = quadtree([a, b, c], 960, 500),
+              n = 0;
+          q.visit(function(node, x1, y1, x2, y2) {
+            ++n;
+            return x1 > 0;
+          });
+          assert.equal(n, 3);
+        }
+      }
+    }
+  }
+});
+
+suite.export(module);