d3_rails 2.8.0 → 2.8.1

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

@@ -0,0 +1,63 @@
+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

@@ -0,0 +1,83 @@
+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

@@ -0,0 +1,655 @@
+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);