d3_rails 2.9.1 → 2.9.2.rc1

data/vendor/assets/javascripts/tesseract/test/select-test.js

@@ -1,63 +0,0 @@
-var vows = require("vows"),
-    assert = require("assert"),
-    tesseract = require("../");
-
-var suite = vows.describe("select");
-
-suite.addBatch({
-  "heapselect": batch(tesseract.heapselect)
-});
-
-function batch(select, extras) {
-  var batch = {
-    topic: function() {
-      return select;
-    },
-    "can select from a small array of positive integers": function(select) {
-      var array = [6, 5, 3, 1, 8, 7, 2, 4];
-      assert.deepEqual(select(array, 0, array.length, 1), [8]);
-      assert.deepEqual(select(array, 0, array.length, 2).sort(descending), [8, 7]);
-      assert.deepEqual(select(array, 0, array.length, 3).sort(descending), [8, 7, 6]);
-      assert.deepEqual(select(array, 0, array.length, 4).sort(descending), [8, 7, 6, 5]);
-      assert.deepEqual(select(array, 0, array.length, 5).sort(descending), [8, 7, 6, 5, 4]);
-      assert.deepEqual(select(array, 0, array.length, 6).sort(descending), [8, 7, 6, 5, 4, 3]);
-      assert.deepEqual(select(array, 0, array.length, 7).sort(descending), [8, 7, 6, 5, 4, 3, 2]);
-      assert.deepEqual(select(array, 0, array.length, 8).sort(descending), [8, 7, 6, 5, 4, 3, 2, 1]);
-    },
-    "does not affect the original order; returns a copy": function(select) {
-      var array = [6, 5, 3, 1, 8, 7, 2, 4];
-      select(array, 0, array.length, 4);
-      assert.deepEqual(array, [6, 5, 3, 1, 8, 7, 2, 4]);
-    },
-    "returns fewer than k elements when k is too big": function(select) {
-      var array = [6, 5, 3, 1, 8, 7, 2, 4];
-      assert.deepEqual(select(array, 0, array.length, 8).sort(descending), [8, 7, 6, 5, 4, 3, 2, 1]);
-    },
-    "returns an empty array when selecting nothing": function(select) {
-      var array = [];
-      select = select.by(function(d) { return d.value; });
-      assert.deepEqual(select(array, 0, array.length, 1), []);
-    },
-    "the returned array is a binary heap": function(select) {
-      var array = [6, 5, 3, 1, 8, 7, 2, 4];
-      for (var i = 0; i < 10; ++i) assert(heapy(select(array, 0, array.length, i)), array + "");
-    }
-  };
-  for (var key in extras) batch[key] = extras[key];
-  return batch;
-}
-
-function descending(a, b) {
-  return a > b ? -1 : a < b ? 1 : 0;
-}
-
-function heapy(array) {
-  for (var i = 1; i < n; ++i) {
-    if (array[i] < array[i - 1 >> 1]) {
-      return false;
-    }
-  }
-  return true;
-}
-
-suite.export(module);

data/vendor/assets/javascripts/tesseract/test/sort-test.js

@@ -1,83 +0,0 @@
-var vows = require("vows"),
-    assert = require("assert"),
-    tesseract = require("../");
-
-var suite = vows.describe("sort");
-
-suite.addBatch({
-  "insertionsort": batch(tesseract.insertionsort),
-  "quicksort": batch(tesseract.quicksort, {
-    "can sort a largeish Uint32Array quickly": function(sort) {
-      var n = 1e6,
-          typedArray = new Uint32Array(n),
-          start,
-          duration;
-      for (var i = 0; i < n; i++) typedArray[i] = Math.random() * (1 << 30) | 0;
-      start = Date.now();
-      sort(typedArray, 0, n);
-      duration = Date.now() - start;
-      assert.lesser(duration, 500);
-      for (var i = 1; i < n; i++) assert(typedArray[i - 1] <= typedArray[i]);
-    }
-  })
-});
-
-function batch(sort, extras) {
-  var batch = {
-    topic: function() {
-      return sort;
-    },
-    "can sort a small array of positive integers": function(sort) {
-      var array = [6, 5, 3, 1, 8, 7, 2, 4];
-      assert.strictEqual(sort(array, 0, array.length), array);
-      assert.deepEqual(array, [1, 2, 3, 4, 5, 6, 7, 8]);
-    },
-    "can sort a subset of a small array of positive integers": function(sort) {
-      var array = [6, 5, 3, 1, 8, 7, 2, 4];
-      assert.strictEqual(sort(array, 0, 4), array);
-      assert.deepEqual(array, [1, 3, 5, 6, 8, 7, 2, 4]);
-      assert.strictEqual(sort(array, 4, 8), array);
-      assert.deepEqual(array, [1, 3, 5, 6, 2, 4, 7, 8]);
-    },
-    "can sort a small array of strings": function(sort) {
-      var array = ["1", "2", "10"];
-      assert.strictEqual(sort(array, 0, array.length), array);
-      assert.deepEqual(array, ["1", "10", "2"]);
-    },
-    "can sort a small array of objects using an accessor": function(sort) {
-      var array = [{value: 6}, {value: 1}, {value: 3}, {value: 8}];
-      assert.strictEqual(sort.by(function(d) { return d.value; })(array, 0, array.length), array);
-      assert.deepEqual(array, [{value: 1}, {value: 3}, {value: 6}, {value: 8}]);
-    },
-    "can sort a small Int32Array": function(sort) {
-      var n = 17,
-          typedArray = new Int32Array(n),
-          untypedArray = new Array(n),
-          untypedActual = new Array(n);
-      for (var i = 0; i < n; i++) typedArray[i] = untypedArray[i] = Math.random() * (1 << 31) | 0;
-      assert.strictEqual(sort(typedArray, 0, n), typedArray);
-      assert.strictEqual(untypedArray.sort(ascending), untypedArray);
-      for (var i = 0; i < n; i++) untypedActual[i] = typedArray[i];
-      assert.deepEqual(untypedActual, untypedArray);
-    },
-    "can sort a smallish Float64Array": function(sort) {
-      var n = 1e4,
-          typedArray = new Float64Array(n),
-          untypedArray = new Array(n),
-          untypedActual = new Array(n);
-      for (var i = 0; i < n; i++) typedArray[i] = untypedArray[i] = Math.random();
-      assert.strictEqual(sort(typedArray, 0, n), typedArray);
-      assert.strictEqual(untypedArray.sort(ascending), untypedArray);
-      for (var i = 0; i < n; i++) untypedActual[i] = typedArray[i];
-      assert.deepEqual(untypedActual, untypedArray);
-    }
-  };
-  for (var key in extras) batch[key] = extras[key];
-  return batch;
-}
-
-function ascending(a, b) {
-  return a < b ? -1 : a > b ? 1 : 0;
-}
-
-suite.export(module);

data/vendor/assets/javascripts/tesseract/test/tesseract-test.js

@@ -1,655 +0,0 @@
-var vows = require("vows"),
-    assert = require("assert"),
-    d3 = require("d3"),
-    tesseract = require("../");
-
-var suite = vows.describe("tesseract");
-
-suite.addBatch({
-  "tesseract": {
-    topic: function() {
-      var data = tesseract([
-        {date: "2011-11-14T16:17:54Z", quantity: 2, total: 190, tip: 100, type: "tab"},
-        {date: "2011-11-14T16:20:19Z", quantity: 2, total: 190, tip: 100, type: "tab"},
-        {date: "2011-11-14T16:28:54Z", quantity: 1, total: 300, tip: 200, type: "visa"},
-        {date: "2011-11-14T16:30:43Z", quantity: 2, total: 90, tip: 0, type: "tab"},
-        {date: "2011-11-14T16:48:46Z", quantity: 2, total: 90, tip: 0, type: "tab"},
-        {date: "2011-11-14T16:53:41Z", quantity: 2, total: 90, tip: 0, type: "tab"},
-        {date: "2011-11-14T16:54:06Z", quantity: 1, total: 100, tip: null, type: "cash"},
-        {date: "2011-11-14T17:02:03Z", quantity: 2, total: 90, tip: 0, type: "tab"},
-        {date: "2011-11-14T17:07:21Z", quantity: 2, total: 90, tip: 0, type: "tab"},
-        {date: "2011-11-14T17:22:59Z", quantity: 2, total: 90, tip: 0, type: "tab"},
-        {date: "2011-11-14T17:25:45Z", quantity: 2, total: 200, tip: null, type: "cash"},
-        {date: "2011-11-14T17:29:52Z", quantity: 1, total: 200, tip: 100, type: "visa"},
-        {date: "2011-11-14T17:33:46Z", quantity: 2, total: 190, tip: 100, type: "tab"},
-        {date: "2011-11-14T17:33:59Z", quantity: 2, total: 90, tip: 0, type: "tab"},
-        {date: "2011-11-14T17:38:40Z", quantity: 2, total: 200, tip: 100, type: "visa"},
-        {date: "2011-11-14T17:52:02Z", quantity: 2, total: 90, tip: 0, type: "tab"},
-        {date: "2011-11-14T18:02:42Z", quantity: 2, total: 190, tip: 100, type: "tab"},
-        {date: "2011-11-14T18:02:51Z", quantity: 2, total: 190, tip: 100, type: "tab"},
-        {date: "2011-11-14T18:12:54Z", quantity: 1, total: 200, tip: 100, type: "visa"},
-        {date: "2011-11-14T18:14:53Z", quantity: 2, total: 100, tip: null, type: "cash"},
-        {date: "2011-11-14T18:45:24Z", quantity: 2, total: 90, tip: 0, type: "tab"},
-        {date: "2011-11-14T19:00:31Z", quantity: 2, total: 190, tip: 100, type: "tab"},
-        {date: "2011-11-14T19:04:22Z", quantity: 2, total: 90, tip: 0, type: "tab"},
-        {date: "2011-11-14T19:30:44Z", quantity: 2, total: 90, tip: 0, type: "tab"},
-        {date: "2011-11-14T20:06:33Z", quantity: 1, total: 100, tip: null, type: "cash"},
-        {date: "2011-11-14T20:49:07Z", quantity: 2, total: 290, tip: 200, type: "tab"},
-        {date: "2011-11-14T21:05:36Z", quantity: 2, total: 90, tip: 0, type: "tab"},
-        {date: "2011-11-14T21:18:48Z", quantity: 4, total: 270, tip: 0, type: "tab"},
-        {date: "2011-11-14T21:22:31Z", quantity: 1, total: 200, tip: 100, type: "visa"},
-        {date: "2011-11-14T21:26:30Z", quantity: 2, total: 190, tip: 100, type: "tab"},
-        {date: "2011-11-14T21:30:55Z", quantity: 2, total: 190, tip: 100, type: "tab"},
-        {date: "2011-11-14T21:31:05Z", quantity: 2, total: 90, tip: 0, type: "tab"},
-        {date: "2011-11-14T22:30:22Z", quantity: 2, total: 90, tip: 0, type: "tab"},
-        {date: "2011-11-14T22:34:28Z", quantity: 2, total: 190, tip: 100, type: "tab"},
-        {date: "2011-11-14T22:48:05Z", quantity: 2, total: 90, tip: 0, type: "tab"},
-        {date: "2011-11-14T22:51:40Z", quantity: 2, total: 190, tip: 100, type: "tab"},
-        {date: "2011-11-14T22:58:54Z", quantity: 2, total: 100, tip: 0, type: "visa"},
-        {date: "2011-11-14T23:06:25Z", quantity: 2, total: 190, tip: 100, type: "tab"},
-        {date: "2011-11-14T23:07:58Z", quantity: 2, total: 190, tip: 100, type: "tab"},
-        {date: "2011-11-14T23:16:09Z", quantity: 1, total: 200, tip: 100, type: "visa"},
-        {date: "2011-11-14T23:21:22Z", quantity: 2, total: 190, tip: 100, type: "tab"},
-        {date: "2011-11-14T23:23:29Z", quantity: 2, total: 190, tip: 100, type: "tab"},
-        {date: "2011-11-14T23:28:54Z", quantity: 2, total: 190, tip: 100, type: "tab"}
-      ]);
-
-      // be sure you don't clobber a built-in method if you do this!
-      try {
-        data.date = data.dimension(function(d) { return new Date(d.date); });
-        data.quantity = data.dimension(function(d) { return d.quantity; });
-        data.tip = data.dimension(function(d) { return d.tip; });
-        data.total = data.dimension(function(d) { return d.total; });
-        data.type = data.dimension(function(d) { return d.type; });
-      } catch (e) {
-        console.log(e.stack);
-      }
-
-      return data;
-    },
-
-    "up to 32 dimensions supported": function() {
-      var data = tesseract([]);
-      for (var i = 0; i < 32; i++) data.dimension(function() { return 0; });
-      assert.throws(function() { data.dimension(function() { return 0; }); }, Error);
-    },
-
-    "dimension": {
-
-      "top": {
-        "returns the top k records by value, in descending order": function(data) {
-          assert.deepEqual(data.total.top(3), [
-            {date: "2011-11-14T16:28:54Z", quantity: 1, total: 300, tip: 200, type: "visa"},
-            {date: "2011-11-14T20:49:07Z", quantity: 2, total: 290, tip: 200, type: "tab"},
-            {date: "2011-11-14T21:18:48Z", quantity: 4, total: 270, tip: 0, type: "tab"}
-          ]);
-          assert.deepEqual(data.date.top(3), [
-            {date: "2011-11-14T23:28:54Z", quantity: 2, total: 190, tip: 100, type: "tab"},
-            {date: "2011-11-14T23:23:29Z", quantity: 2, total: 190, tip: 100, type: "tab"},
-            {date: "2011-11-14T23:21:22Z", quantity: 2, total: 190, tip: 100, type: "tab"}
-          ]);
-        },
-        "observes the associated dimension's filters": function(data) {
-          try {
-            data.quantity.filterExact(4);
-            assert.deepEqual(data.total.top(3), [
-              {date: "2011-11-14T21:18:48Z", quantity: 4, total: 270, tip: 0, type: "tab"}
-            ]);
-          } finally {
-            data.quantity.filterAll();
-          }
-          try {
-            data.date.filterRange([new Date(Date.UTC(2011, 10, 14, 19)), new Date(Date.UTC(2011, 10, 14, 20))]);
-            assert.deepEqual(data.date.top(10), [
-              {date: "2011-11-14T19:30:44Z", quantity: 2, total: 90, tip: 0, type: "tab"},
-              {date: "2011-11-14T19:04:22Z", quantity: 2, total: 90, tip: 0, type: "tab"},
-              {date: "2011-11-14T19:00:31Z", quantity: 2, total: 190, tip: 100, type: "tab"}
-            ]);
-            data.date.filterRange([Date.UTC(2011, 10, 14, 19), Date.UTC(2011, 10, 14, 20)]); // also comparable
-            assert.deepEqual(data.date.top(10), [
-              {date: "2011-11-14T19:30:44Z", quantity: 2, total: 90, tip: 0, type: "tab"},
-              {date: "2011-11-14T19:04:22Z", quantity: 2, total: 90, tip: 0, type: "tab"},
-              {date: "2011-11-14T19:00:31Z", quantity: 2, total: 190, tip: 100, type: "tab"}
-            ]);
-          } finally {
-            data.date.filterAll();
-          }
-        },
-        "observes other dimensions' filters": function(data) {
-          try {
-            data.type.filterExact("tab");
-            assert.deepEqual(data.total.top(2), [
-              {date: "2011-11-14T20:49:07Z", quantity: 2, total: 290, tip: 200, type: "tab"},
-              {date: "2011-11-14T21:18:48Z", quantity: 4, total: 270, tip: 0, type: "tab"}
-            ]);
-            data.type.filterExact("visa");
-            assert.deepEqual(data.total.top(1), [
-              {date: "2011-11-14T16:28:54Z", quantity: 1, total: 300, tip: 200, type: "visa"}
-            ]);
-            data.quantity.filterExact(2);
-            assert.deepEqual(data.tip.top(1), [
-              {date: "2011-11-14T17:38:40Z", quantity: 2, total: 200, tip: 100, type: "visa"}
-            ]);
-          } finally {
-            data.type.filterAll();
-            data.quantity.filterAll();
-          }
-          try {
-            data.type.filterExact("tab");
-            assert.deepEqual(data.date.top(2), [
-              {date: "2011-11-14T23:28:54Z", quantity: 2, total: 190, tip: 100, type: "tab"},
-              {date: "2011-11-14T23:23:29Z", quantity: 2, total: 190, tip: 100, type: "tab"}
-            ]);
-            data.type.filterExact("visa");
-            assert.deepEqual(data.date.top(1), [
-              {date: "2011-11-14T23:16:09Z", quantity: 1, total: 200, tip: 100, type: "visa"}
-            ]);
-            data.quantity.filterExact(2);
-            assert.deepEqual(data.date.top(1), [
-              {date: "2011-11-14T22:58:54Z", quantity: 2, total: 100, tip: 0, type: "visa"}
-            ]);
-          } finally {
-            data.type.filterAll();
-            data.quantity.filterAll();
-          }
-        },
-        "negative or zero k returns an empty array": function(data) {
-          assert.deepEqual(data.quantity.top(0), []);
-          assert.deepEqual(data.quantity.top(-1), []);
-          assert.deepEqual(data.quantity.top(NaN), []);
-          assert.deepEqual(data.quantity.top(-Infinity), []);
-          assert.deepEqual(data.date.top(0), []);
-          assert.deepEqual(data.date.top(-1), []);
-          assert.deepEqual(data.date.top(NaN), []);
-          assert.deepEqual(data.date.top(-Infinity), []);
-        }
-      },
-
-      "filterExact": {
-        "selects records that match the specified value exactly": function(data) {
-          try {
-            data.tip.filterExact(100);
-            assert.deepEqual(data.date.top(2), [
-              {date: "2011-11-14T23:28:54Z", quantity: 2, total: 190, tip: 100, type: "tab"},
-              {date: "2011-11-14T23:23:29Z", quantity: 2, total: 190, tip: 100, type: "tab"}
-            ]);
-          } finally {
-            data.tip.filterAll();
-          }
-        },
-        "allows the filter value to be null": function(data) {
-          try {
-            data.tip.filterExact(null); // equivalent to 0 by natural ordering
-            assert.deepEqual(data.date.top(2), [
-              {date: "2011-11-14T22:58:54Z", quantity: 2, total: 100, tip: 0, type: "visa"},
-              {date: "2011-11-14T22:48:05Z", quantity: 2, total: 90, tip: 0, type: "tab"}
-            ]);
-          } finally {
-            data.tip.filterAll();
-          }
-        }
-      },
-
-      "filterRange": {
-        "selects records greater than or equal to the inclusive lower bound": function(data) {
-          try {
-            data.total.filterRange([100, 190]);
-            assert.isTrue(data.date.top(Infinity).every(function(d) { return d.total >= 100; }));
-            data.total.filterRange([110, 190]);
-            assert.isTrue(data.date.top(Infinity).every(function(d) { return d.total >= 110; }));
-          } finally {
-            data.total.filterAll();
-          }
-        },
-        "selects records less than the exclusive lower bound": function(data) {
-          try {
-            data.total.filterRange([100, 200]);
-            assert.isTrue(data.date.top(Infinity).every(function(d) { return d.total < 200; }));
-            data.total.filterRange([100, 190]);
-            assert.isTrue(data.date.top(Infinity).every(function(d) { return d.total < 190; }));
-          } finally {
-            data.total.filterAll();
-          }
-        }
-      },
-
-      "filterAll": {
-        "clears the filter": function(data) {
-          data.total.filterRange([100, 200]);
-          assert.lesser(data.date.top(Infinity).length, 43);
-          data.total.filterAll();
-          assert.equal(data.date.top(Infinity).length, 43);
-        }
-      },
-
-      "filter": {
-        "is equivalent to filterRange when passed an array": function(data) {
-          try {
-            data.total.filter([100, 190]);
-            assert.isTrue(data.date.top(Infinity).every(function(d) { return d.total >= 100; }));
-          } finally {
-            data.total.filter(null);
-          }
-        },
-        "is equivalent to filterExact when passed a single value": function(data) {
-          try {
-            data.total.filter(100);
-            assert.isTrue(data.date.top(Infinity).every(function(d) { return d.total == 100; }));
-          } finally {
-            data.total.filter(null);
-          }
-        },
-        "is equivalent to filterAll when passed null": function(data) {
-          data.total.filter([100, 200]);
-          assert.lesser(data.date.top(Infinity).length, 43);
-          data.total.filter(null);
-          assert.equal(data.date.top(Infinity).length, 43);
-        }
-      },
-
-      "groupAll (count, the default)": {
-        topic: function(data) {
-          data.quantity.count = data.quantity.groupAll();
-          return data;
-        },
-
-        "does not have top and order methods": function(data) {
-          assert.isFalse("top" in data.quantity.count);
-          assert.isFalse("order" in data.quantity.count);
-        },
-
-        "reduce": {
-          "reduces by add, remove, and initial": function(data) {
-            try {
-              data.quantity.count.reduce(
-                  function(p, v) { return p + v.total; },
-                  function(p, v) { return p - v.total; },
-                  function() { return 0; });
-              assert.strictEqual(data.quantity.count.value(), 6660);
-            } finally {
-              data.quantity.count.reduceCount();
-            }
-          }
-        },
-
-        "reduceCount": {
-          "reduces by count": function(data) {
-            data.quantity.count.reduceSum(function(d) { return d.total; });
-            assert.strictEqual(data.quantity.count.value(), 6660);
-            data.quantity.count.reduceCount();
-            assert.strictEqual(data.quantity.count.value(), 43);
-          }
-        },
-
-        "reduceSum": {
-          "reduces by sum of accessor function": function(data) {
-            try {
-              data.quantity.count.reduceSum(function(d) { return d.total; });
-              assert.strictEqual(data.quantity.count.value(), 6660);
-              data.quantity.count.reduceSum(function() { return 1; });
-              assert.strictEqual(data.quantity.count.value(), 43);
-            } finally {
-              data.quantity.count.reduceCount();
-            }
-          }
-        },
-
-        "value": {
-          "returns the count of matching records": function(data) {
-            assert.strictEqual(data.quantity.count.value(), 43);
-          },
-          "does not observe the associated dimension's filters": function(data) {
-            try {
-              data.quantity.filterRange([100, 200]);
-              assert.strictEqual(data.quantity.count.value(), 43);
-            } finally {
-              data.quantity.filterAll();
-            }
-          },
-          "observes other dimensions' filters": function(data) {
-            try {
-              data.type.filterExact("tab");
-              assert.strictEqual(data.quantity.count.value(), 32);
-              data.type.filterExact("visa");
-              assert.strictEqual(data.quantity.count.value(), 7);
-              data.tip.filterExact(100);
-              assert.strictEqual(data.quantity.count.value(), 5);
-            } finally {
-              data.type.filterAll();
-              data.tip.filterAll();
-            }
-          }
-        }
-      },
-
-      "groupAll (sum of total)": {
-        topic: function(data) {
-          data.quantity.total = data.quantity.groupAll().reduceSum(function(d) { return d.total; });
-          return data;
-        },
-
-        "does not have top and order methods": function(data) {
-          assert.isFalse("top" in data.quantity.total);
-          assert.isFalse("order" in data.quantity.total);
-        },
-
-        "reduce": {
-          "determines the computed reduce value": function(data) {
-            try {
-              data.quantity.total.reduce(
-                  function(p) { return p + 1; },
-                  function(p) { return p - 1; },
-                  function() { return 0; });
-              assert.strictEqual(data.quantity.total.value(), 43);
-            } finally {
-              data.quantity.total.reduceSum(function(d) { return d.total; });
-            }
-          }
-        },
-
-        "value": {
-          "returns the sum total of matching records": function(data) {
-            assert.strictEqual(data.quantity.total.value(), 6660);
-          },
-          "does not observe the associated dimension's filters": function(data) {
-            try {
-              data.quantity.filterRange([100, 200]);
-              assert.strictEqual(data.quantity.total.value(), 6660);
-            } finally {
-              data.quantity.filterAll();
-            }
-          },
-          "observes other dimensions' filters": function(data) {
-            try {
-              data.type.filterExact("tab");
-              assert.strictEqual(data.quantity.total.value(), 4760);
-              data.type.filterExact("visa");
-              assert.strictEqual(data.quantity.total.value(), 1400);
-              data.tip.filterExact(100);
-              assert.strictEqual(data.quantity.total.value(), 1000);
-            } finally {
-              data.type.filterAll();
-              data.tip.filterAll();
-            }
-          }
-        }
-      },
-
-      "group": {
-        topic: function(data) {
-          data.date.hours = data.date.group(function(d) { d = new Date(+d); d.setHours(d.getHours(), 0, 0, 0); return d; });
-          data.type.types = data.type.group();
-          return data;
-        },
-
-        "key defaults to value": function(data) {
-          assert.deepEqual(data.type.types.top(Infinity), [
-            {key: "tab", value: 32},
-            {key: "visa", value: 7},
-            {key: "cash", value: 4}
-          ]);
-        },
-
-        "cardinality may be greater than 256": function() {
-          var data = tesseract(d3.range(256).concat(256, 256)),
-              index = data.dimension(function(d) { return d; }),
-              indexes = index.group();
-          assert.deepEqual(index.top(2), [256, 256]);
-          assert.deepEqual(indexes.top(1), [{key: 256, value: 2}]);
-          assert.equal(indexes.size(), 257);
-        },
-
-        "cardinality may be greater than 65536": function() {
-          var data = tesseract(d3.range(65536).concat(65536, 65536)),
-              index = data.dimension(function(d) { return d; }),
-              indexes = index.group();
-          assert.deepEqual(index.top(2), [65536, 65536]);
-          assert.deepEqual(indexes.top(1), [{key: 65536, value: 2}]);
-          assert.equal(indexes.size(), 65537);
-        },
-
-        "size": {
-          "returns the cardinality": function(data) {
-            assert.equal(data.date.hours.size(), 8);
-            assert.equal(data.type.types.size(), 3);
-          },
-          "ignores any filters": function(data) {
-            try {
-              data.type.filterExact("tab");
-              data.quantity.filterRange([100, 200]);
-              assert.equal(data.date.hours.size(), 8);
-              assert.equal(data.type.types.size(), 3);
-            } finally {
-              data.quantity.filterAll();
-              data.type.filterAll();
-            }
-          }
-        },
-
-        "reduce": {
-          "defaults to count": function(data) {
-            assert.deepEqual(data.date.hours.top(1), [
-              {key: new Date(Date.UTC(2011, 10, 14, 17, 00, 00)), value: 9}
-            ]);
-          },
-          "determines the computed reduce value": function(data) {
-            try {
-              data.date.hours.reduceSum(function(d) { return d.total; });
-              assert.deepEqual(data.date.hours.top(1), [
-                {key: new Date(Date.UTC(2011, 10, 14, 17, 00, 00)), value: 1240}
-              ]);
-            } finally {
-              data.date.hours.reduceCount();
-            }
-          }
-        },
-
-        "top": {
-          "returns the top k groups by reduce value, in descending order": function(data) {
-            assert.deepEqual(data.date.hours.top(3), [
-              {key: new Date(Date.UTC(2011, 10, 14, 17, 00, 00)), value: 9},
-              {key: new Date(Date.UTC(2011, 10, 14, 16, 00, 00)), value: 7},
-              {key: new Date(Date.UTC(2011, 10, 14, 21, 00, 00)), value: 6}
-            ]);
-          },
-          "observes the specified order": function(data) {
-            try {
-              data.date.hours.order(function(v) { return -v; });
-              assert.deepEqual(data.date.hours.top(3), [
-                {key: new Date(Date.UTC(2011, 10, 14, 20, 00, 00)), value: 2},
-                {key: new Date(Date.UTC(2011, 10, 14, 19, 00, 00)), value: 3},
-                {key: new Date(Date.UTC(2011, 10, 14, 18, 00, 00)), value: 5}
-              ]);
-            } finally {
-              data.date.hours.order(function(v) { return v; });
-            }
-          }
-        },
-
-        "order": {
-          "defaults to the identity function": function(data) {
-            assert.deepEqual(data.date.hours.top(1), [
-              {key: new Date(Date.UTC(2011, 10, 14, 17, 00, 00)), value: 9}
-            ]);
-          },
-          "is useful in conjunction with a compound reduce value": function(data) {
-            try {
-              data.date.hours.reduce(
-                  function(p, v) { ++p.count; p.total += v.total; return p; },
-                  function(p, v) { --p.count; p.total -= v.total; return p; },
-                  function() { return {count: 0, total: 0}; })
-                  .order(function(v) { return v.total; });
-              assert.deepEqual(data.date.hours.top(1), [
-                {key: new Date(Date.UTC(2011, 10, 14, 17, 00, 00)), value: {count: 9, total: 1240}}
-              ]);
-            } finally {
-              data.date.hours.reduceCount().orderNatural();
-            }
-          }
-        }
-      }
-    },
-
-    "groupAll": {
-      topic: function(data) {
-        data.all = data.groupAll().reduceSum(function(d) { return d.total; });
-        return data;
-      },
-
-      "does not have top and order methods": function(data) {
-        assert.isFalse("top" in data.all);
-        assert.isFalse("order" in data.all);
-      },
-
-      "reduce": {
-        "determines the computed reduce value": function(data) {
-          try {
-            data.all.reduceCount();
-            assert.strictEqual(data.all.value(), 43);
-          } finally {
-            data.all.reduceSum(function(d) { return d.total; });
-          }
-        }
-      },
-
-      "value": {
-        "returns the sum total of matching records": function(data) {
-          assert.strictEqual(data.all.value(), 6660);
-        },
-        "observes all dimension's filters": function(data) {
-          try {
-            data.type.filterExact("tab");
-            assert.strictEqual(data.all.value(), 4760);
-            data.type.filterExact("visa");
-            assert.strictEqual(data.all.value(), 1400);
-            data.tip.filterExact(100);
-            assert.strictEqual(data.all.value(), 1000);
-          } finally {
-            data.type.filterAll();
-            data.tip.filterAll();
-          }
-        }
-      }
-    },
-
-    "size": {
-      "returns the total number of elements": function(data) {
-        assert.equal(data.size(), 43);
-      },
-      "is not affected by any dimension filters": function(data) {
-        try {
-          data.quantity.filterExact(4);
-          assert.equal(data.size(), 43);
-        } finally {
-          data.quantity.filterAll();
-        }
-      }
-    },
-
-    "add": {
-      "increases the size of the tesseract": function() {
-        var data = tesseract([]);
-        assert.equal(data.size(), 0);
-        data.add([0, 1, 2, 3, 4, 5, 6, 6, 6, 7]);
-        assert.equal(data.size(), 10);
-        data.add([]);
-        assert.equal(data.size(), 10);
-      },
-      "existing filters are consistent with new records": function(data) {
-        var data = tesseract([]),
-            foo = data.dimension(function(d) { return +d; }),
-            bar = data.dimension(function(d) { return -d; });
-        assert.deepEqual(foo.top(Infinity), []);
-        foo.filterExact(42);
-        data.add([43, 42, 41]);
-        assert.deepEqual(foo.top(Infinity), [42]);
-        assert.deepEqual(bar.top(Infinity), [42]);
-        data.add([43, 42]);
-        assert.deepEqual(foo.top(Infinity), [42, 42]);
-        assert.deepEqual(bar.top(Infinity), [42, 42]);
-        foo.filterRange([42, 44]);
-        data.add([43]);
-        assert.deepEqual(foo.top(Infinity), [43, 43, 43, 42, 42]);
-        assert.deepEqual(bar.top(Infinity), [42, 42, 43, 43, 43]);
-        bar.filterExact([-43]);
-        assert.deepEqual(bar.top(Infinity), [43, 43, 43]);
-        data.add([43]);
-        assert.deepEqual(bar.top(Infinity), [43, 43, 43, 43]);
-        bar.filterAll();
-        data.add([0]);
-        assert.deepEqual(bar.top(Infinity), [42, 42, 43, 43, 43, 43]);
-        foo.filterAll();
-        assert.deepEqual(bar.top(Infinity), [0, 41, 42, 42, 43, 43, 43, 43]);
-      },
-      "existing groups are consistent with new records": function(data) {
-        var data = tesseract([]),
-            foo = data.dimension(function(d) { return +d; }),
-            bar = data.dimension(function(d) { return -d; }),
-            foos = foo.group(),
-            all = data.groupAll();
-        assert.equal(all.value(), 0);
-        assert.deepEqual(foos.all(), []);
-        foo.filterExact(42);
-        data.add([43, 42, 41]);
-        assert.equal(all.value(), 1);
-        assert.deepEqual(foos.all(), [{key: 41, value: 1}, {key: 42, value: 1}, {key: 43, value: 1}]);
-        bar.filterExact(-42);
-        assert.equal(all.value(), 1);
-        assert.deepEqual(foos.all(), [{key: 41, value: 0}, {key: 42, value: 1}, {key: 43, value: 0}]);
-        data.add([43, 42, 41]);
-        assert.equal(all.value(), 2);
-        assert.deepEqual(foos.all(), [{key: 41, value: 0}, {key: 42, value: 2}, {key: 43, value: 0}]);
-        bar.filterAll();
-        assert.equal(all.value(), 2);
-        assert.deepEqual(foos.all(), [{key: 41, value: 2}, {key: 42, value: 2}, {key: 43, value: 2}]);
-        foo.filterAll();
-        assert.equal(all.value(), 6);
-      },
-      "can add new groups that are before existing groups": function(data) {
-        var data = tesseract(),
-            foo = data.dimension(function(d) { return +d; }),
-            foos = foo.group().reduce(add, remove, initial).order(order);
-        data.add([2]).add([1, 1, 1]);
-        assert.deepEqual(foos.top(2), [{key: 1, value: {foo: 3}}, {key: 2, value: {foo: 1}}]);
-        function order(p) { return p.foo; }
-        function add(p, v) { ++p.foo; return p; }
-        function remove(p, v) { --p.foo; return p; }
-        function initial() { return {foo: 0}; }
-      },
-      "can add more than 256 groups": function(data) {
-        var data = tesseract(),
-            foo = data.dimension(function(d) { return +d; }),
-            bar = data.dimension(function(d) { return +d; }),
-            foos = foo.group();
-        data.add(d3.range(0, 256));
-        assert.deepEqual(foos.all().map(function(d) { return d.key; }), d3.range(0, 256));
-        assert(foos.all().every(function(d) { return d.value == 1; }));
-        data.add([128]);
-        assert.deepEqual(foos.top(1), [{key: 128, value: 2}]);
-        bar.filterExact(0);
-        data.add(d3.range(-256, 0));
-        assert.deepEqual(foos.all().map(function(d) { return d.key; }), d3.range(-256, 256));
-        assert.deepEqual(foos.top(1), [{key: 0, value: 1}]);
-      },
-      "can add lots of groups in reverse order": function(data) {
-        var data = tesseract(),
-            foo = data.dimension(function(d) { return -d.foo; }),
-            bar = data.dimension(function(d) { return d.bar; }),
-            foos = foo.group(Math.floor).reduceSum(function(d) { return d.foo; });
-        bar.filterExact(1);
-        for (var i = 0; i < 1000; i++) {
-          data.add(d3.range(10).map(function(d) {
-            return {foo: i + d / 10, bar: i % 4, baz: d + i * 10};
-          }));
-        }
-        assert.deepEqual(foos.top(1), [{key: -998, value: 8977.5}]);
-      }
-    }
-  }
-});
-
-function key(d) {
-  return d.key;
-}
-
-suite.export(module);