1 files changed, 139 insertions, 0 deletions
diff --git a/tensorflow/tensorboard/components/tf-categorizer/test/categorizerTest.ts b/tensorflow/tensorboard/components/tf-categorizer/test/categorizerTest.ts
new file mode 100644
index 0000000000..be09c56c41
--- /dev/null
+++ b/tensorflow/tensorboard/components/tf-categorizer/test/categorizerTest.ts
@@ -0,0 +1,139 @@
+/// <reference path="../../../typings/tsd.d.ts" />
+/// <reference path="../categorizer.ts" />
+var assert = chai.assert;
+
+module Categorizer {
+  describe("categorizer", () => {
+    describe("topLevelNamespaceCategorizer", () => {
+      it("returns empty array on empty tags", () => {
+        assert.lengthOf(topLevelNamespaceCategorizer([]), 0);
+      });
+
+      it("handles a simple case", () => {
+        var simple = ["foo1/bar", "foo1/zod", "foo2/bar", "foo2/zod",
+          "gosh/lod/mar", "gosh/lod/ned"];
+        var expected = [
+          { name: "foo1", tags: ["foo1/bar", "foo1/zod"] },
+          { name: "foo2", tags: ["foo2/bar", "foo2/zod"] },
+          { name: "gosh", tags: ["gosh/lod/mar", "gosh/lod/ned"] },
+        ];
+        assert.deepEqual(topLevelNamespaceCategorizer(simple), expected);
+      });
+
+      it("orders the categories", () => {
+        var test = ["e", "f", "g", "a", "b", "c"];
+        var expected = [
+          { name: "a", tags: ["a"] },
+          { name: "b", tags: ["b"] },
+          { name: "c", tags: ["c"] },
+          { name: "e", tags: ["e"] },
+          { name: "f", tags: ["f"] },
+          { name: "g", tags: ["g"] },
+        ];
+        assert.deepEqual(topLevelNamespaceCategorizer(test), expected);
+      });
+
+      it("handles cases where category names overlap node names", () => {
+        var test = ["a", "a/a", "a/b", "a/c", "b", "b/a"];
+        var actual = topLevelNamespaceCategorizer(test);
+        var expected = [
+          { name: "a", tags: ["a", "a/a", "a/b", "a/c"] },
+          { name: "b", tags: ["b", "b/a"] },
+        ];
+        assert.deepEqual(actual, expected);
+      });
+
+      it("handles singleton case", () => {
+        assert.deepEqual(topLevelNamespaceCategorizer(["a"]), [{ name: "a", tags: ["a"] }]);
+      });
+    });
+
+    describe("legacyUnderscoreCategorizer", () => {
+      it("splits by shorter of first _ or /", () => {
+        var tags = ["l0_bar/foo", "l0_bar/baz", "l0_foo/wob", "l1_zoink/bla",
+                    "l1_wibble/woz", "l1/foo_woink", "l2/wozzle_wizzle"];
+        var actual = legacyUnderscoreCategorizer(tags);
+        var expected = [
+          { name: "l0", tags: ["l0_bar/baz", "l0_bar/foo", "l0_foo/wob"] },
+          { name: "l1", tags: ["l1/foo_woink", "l1_wibble/woz", "l1_zoink/bla"] },
+          { name: "l2", tags: ["l2/wozzle_wizzle"] },
+        ];
+        assert.deepEqual(actual, expected);
+      });
+    });
+
+    describe("customCategorizer", () => {
+      function noFallbackCategorizer(tags: string[]): Category[] {
+        return [];
+      }
+
+      function testCategorizer(defs: string[],
+                               fallback: Categorizer, tags: string[]): Category[] {
+        var catDefs = defs.map(defineCategory);
+        return _categorizer(catDefs, fallback)(tags);
+      }
+
+      it("categorizes by regular expression", () => {
+        var defs = ["foo..", "bar.."];
+        var tags = ["fooab", "fooxa", "barts", "barms"];
+        var actual = testCategorizer(defs, noFallbackCategorizer, tags);
+        var expected = [
+          { name: "foo..", tags: ["fooab", "fooxa"] },
+          { name: "bar..", tags: ["barms", "barts"] },
+        ];
+        assert.deepEqual(actual, expected);
+      });
+
+      it("matches non-exclusively", () => {
+        var tags = ["abc", "bar", "zod"];
+        var actual = testCategorizer(["...", "bar"], noFallbackCategorizer, tags);
+        var expected = [
+          { name: "...", tags: ["abc", "bar", "zod"] },
+          { name: "bar", tags: ["bar"] },
+        ];
+        assert.deepEqual(actual, expected);
+      });
+
+      it("creates categories for unmatched rules", () => {
+        var actual = testCategorizer(["a", "b", "c"], noFallbackCategorizer, []);
+        var expected = [
+          { name: "a", tags: [] },
+          { name: "b", tags: [] },
+          { name: "c", tags: [] },
+        ];
+        assert.deepEqual(actual, expected);
+      });
+
+      it("category regexs work with special characters", () => {
+        var defs = ["^\\w+$", "^\\d+$", "^\\/..$"];
+        var tags = ["foo", "3243", "/xa"];
+        var actual = testCategorizer(defs, noFallbackCategorizer, tags);
+        var expected = [
+          { name: "^\\w+$", tags: ["3243", "foo"] },
+          { name: "^\\d+$", tags: ["3243"] },
+          { name: "^\\/..$", tags: ["/xa"] },
+        ];
+        assert.deepEqual(actual, expected);
+      });
+
+      it("category tags are sorted", () => {
+        var tags = ["a", "z", "c", "d", "e", "x", "f", "y", "g"];
+        var sorted = tags.slice().sort();
+        var expected = [{ name: ".*", tags: sorted}];
+        var actual = testCategorizer([".*"], noFallbackCategorizer, tags);
+        assert.deepEqual(actual, expected);
+      });
+
+      it("if nonexclusive: all tags passed to fallback", () => {
+        var passedToDefault = null;
+        function defaultCategorizer(tags: string[]): Category[] {
+          passedToDefault = tags;
+          return [];
+        }
+        var tags = ["foo", "bar", "foo123"];
+        testCategorizer(["foo"], defaultCategorizer, tags);
+        assert.deepEqual(passedToDefault, tags);
+      });
+    });
+  });
+}