@everyonesoftware/common 2.0.0 → 3.0.0

package/tests/depthFirstSearchTests.ts

@@ -1,106 +1,106 @@
-import { depthFirstSearch } from "../sources/depthFirstSearch";
-import { Node } from "../sources/node";
-import { Iterator } from "../sources/iterator";
-import { PreConditionError } from "../sources/preConditionError";
-import { Test } from "./test";
-import { TestRunner } from "./testRunner";
-import { List } from "../sources/list";
-import { SearchControl } from "../sources/searchControl";
-
-export function test(runner: TestRunner): void
-{
-    runner.testFile("depthFirstSearch.ts", () =>
-    {
-        runner.testFunction("depthFirstSearch()", () =>
-        {
-            runner.test("with undefined initialToVisit", (test: Test) =>
-            {
-                test.assertThrows(() => depthFirstSearch(undefined!, () => {}), new PreConditionError(
-                    "Expression: parameters",
-                    "Expected: not undefined and not null",
-                    "Actual: undefined",
-                ));
-            });
-
-            runner.test("with null initialToVisit", (test: Test) =>
-            {
-                test.assertThrows(() => depthFirstSearch(null!, () => {}), new PreConditionError(
-                    "Expression: parameters",
-                    "Expected: not undefined and not null",
-                    "Actual: null",
-                ));
-            });
-
-            runner.test("with undefined searchAction", (test: Test) =>
-            {
-                test.assertThrows(() => depthFirstSearch([], undefined!), new PreConditionError(
-                    "Expression: searchAction",
-                    "Expected: not undefined and not null",
-                    "Actual: undefined",
-                ));
-            });
-
-            runner.test("with null searchAction", (test: Test) =>
-            {
-                test.assertThrows(() => depthFirstSearch([], null!), new PreConditionError(
-                    "Expression: searchAction",
-                    "Expected: not undefined and not null",
-                    "Actual: null",
-                ));
-            });
-
-            runner.test("with empty initialToVisit", (test: Test) =>
-            {
-                const iterator: Iterator<number> = depthFirstSearch([], (searchControl: SearchControl<Node<number>,number>, current: Node<number>) =>
-                {
-                    searchControl.addAllToVisit(current.iterateConnectedNodes());
-
-                    const currentValue: number = current.getValue();
-                    if (currentValue >= 7)
-                    {
-                        searchControl.addResult(currentValue);
-                    }
-                });
-                test.assertEqual([], iterator.toArray().await());
-            });
-
-            runner.test("with non-empty initialToVisit with return values", (test: Test) =>
-            {
-                const nodes: List<Node<number>> = List.create();
-                for (let i = 0; i < 10; i++)
-                {
-                    nodes.add(Node.create(i));
-                }
-                
-                function connectNodes(index1: number, index2: number): void
-                {
-                    nodes.get(index1).await().addConnectedNode(nodes.get(index2).await());
-                }
-                connectNodes(0, 1);
-                connectNodes(0, 2);
-                connectNodes(1, 5);
-                connectNodes(2, 4);
-                connectNodes(3, 6);
-                connectNodes(4, 5);
-                connectNodes(4, 6);
-                connectNodes(5, 9);
-                connectNodes(6, 7);
-                connectNodes(7, 3);
-                connectNodes(8, 9);
-
-                const iterator: Iterator<number> = depthFirstSearch([nodes.get(0).await()], (searchControl: SearchControl<Node<number>,number>, current: Node<number>) =>
-                {
-                    searchControl.addAllToVisit(current.iterateConnectedNodes());
-
-                    const currentValue: number = current.getValue();
-                    if (currentValue >= 7)
-                    {
-                        searchControl.addResult(currentValue);
-                    }
-                });
-
-                test.assertEqual([7, 9], iterator.toArray().await());
-            });
-        });
-    });
+import { depthFirstSearch } from "../sources/depthFirstSearch";
+import { Node } from "../sources/node";
+import { Iterator } from "../sources/iterator";
+import { PreConditionError } from "../sources/preConditionError";
+import { Test } from "./test";
+import { TestRunner } from "./testRunner";
+import { List } from "../sources/list";
+import { SearchControl } from "../sources/searchControl";
+
+export function test(runner: TestRunner): void
+{
+    runner.testFile("depthFirstSearch.ts", () =>
+    {
+        runner.testFunction("depthFirstSearch()", () =>
+        {
+            runner.test("with undefined initialToVisit", (test: Test) =>
+            {
+                test.assertThrows(() => depthFirstSearch(undefined!, () => {}), new PreConditionError(
+                    "Expression: parameters",
+                    "Expected: not undefined and not null",
+                    "Actual: undefined",
+                ));
+            });
+
+            runner.test("with null initialToVisit", (test: Test) =>
+            {
+                test.assertThrows(() => depthFirstSearch(null!, () => {}), new PreConditionError(
+                    "Expression: parameters",
+                    "Expected: not undefined and not null",
+                    "Actual: null",
+                ));
+            });
+
+            runner.test("with undefined searchAction", (test: Test) =>
+            {
+                test.assertThrows(() => depthFirstSearch([], undefined!), new PreConditionError(
+                    "Expression: searchAction",
+                    "Expected: not undefined and not null",
+                    "Actual: undefined",
+                ));
+            });
+
+            runner.test("with null searchAction", (test: Test) =>
+            {
+                test.assertThrows(() => depthFirstSearch([], null!), new PreConditionError(
+                    "Expression: searchAction",
+                    "Expected: not undefined and not null",
+                    "Actual: null",
+                ));
+            });
+
+            runner.test("with empty initialToVisit", (test: Test) =>
+            {
+                const iterator: Iterator<number> = depthFirstSearch([], (searchControl: SearchControl<Node<number>,number>, current: Node<number>) =>
+                {
+                    searchControl.addAllToVisit(current.iterateConnectedNodes());
+
+                    const currentValue: number = current.getValue();
+                    if (currentValue >= 7)
+                    {
+                        searchControl.addResult(currentValue);
+                    }
+                });
+                test.assertEqual([], iterator.toArray().await());
+            });
+
+            runner.test("with non-empty initialToVisit with return values", (test: Test) =>
+            {
+                const nodes: List<Node<number>> = List.create();
+                for (let i = 0; i < 10; i++)
+                {
+                    nodes.add(Node.create(i));
+                }
+                
+                function connectNodes(index1: number, index2: number): void
+                {
+                    nodes.get(index1).await().addConnectedNode(nodes.get(index2).await());
+                }
+                connectNodes(0, 1);
+                connectNodes(0, 2);
+                connectNodes(1, 5);
+                connectNodes(2, 4);
+                connectNodes(3, 6);
+                connectNodes(4, 5);
+                connectNodes(4, 6);
+                connectNodes(5, 9);
+                connectNodes(6, 7);
+                connectNodes(7, 3);
+                connectNodes(8, 9);
+
+                const iterator: Iterator<number> = depthFirstSearch([nodes.get(0).await()], (searchControl: SearchControl<Node<number>,number>, current: Node<number>) =>
+                {
+                    searchControl.addAllToVisit(current.iterateConnectedNodes());
+
+                    const currentValue: number = current.getValue();
+                    if (currentValue >= 7)
+                    {
+                        searchControl.addResult(currentValue);
+                    }
+                });
+
+                test.assertEqual([7, 9], iterator.toArray().await());
+            });
+        });
+    });
 }

package/tests/generatorTests.ts

@@ -1,86 +1,86 @@
-import { Generator } from "../sources/generator";
-import { PreConditionError } from "../sources/preConditionError";
-import { Test } from "./test";
-import { TestRunner } from "./testRunner";
-import { iteratorTests } from "./iteratorTests";
-
-export function test(runner: TestRunner): void
-{
-    runner.testFile("generator.ts", () =>
-    {
-        runner.testType("Generator<T>", () =>
-        {
-            iteratorTests(runner, () => Generator.create(() => {}));
-
-            runner.testFunction("create()", () =>
-            {
-                runner.test("with undefined", (test: Test) =>
-                {
-                    test.assertThrows(() => Generator.create(undefined!), new PreConditionError(
-                        "Expression: generatorAction",
-                        "Expected: not undefined and not null",
-                        "Actual: undefined",
-                    ));
-                });
-
-                runner.test("with null", (test: Test) =>
-                {
-                    test.assertThrows(() => Generator.create(null!), new PreConditionError(
-                        "Expression: generatorAction",
-                        "Expected: not undefined and not null",
-                        "Actual: null",
-                    ));
-                });
-
-                runner.test("with function that doesn't add any return values or return a value", (test: Test) =>
-                {
-                    const generator: Generator<void> = Generator.create(() => {});
-                    test.assertNotUndefinedAndNotNull(generator);
-                    test.assertEqual([], generator.toArray().await());
-                });
-
-                runner.test("with function that returns a constant value", (test: Test) =>
-                {
-                    const generator: Generator<number> = Generator.create(() => 20);
-                    test.assertNotUndefinedAndNotNull(generator);
-                    test.assertEqual([20, 20, 20, 20], generator.take(4).toArray().await());
-                });
-
-                runner.test("with function that returns an incrementing value", (test: Test) =>
-                {
-                    let value: number = 20;
-                    const generator: Generator<number> = Generator.create(() => value++);
-                    test.assertNotUndefinedAndNotNull(generator);
-                    test.assertEqual([20, 21, 22, 23, 24], generator.take(5).toArray().await());
-                });
-
-                runner.test("with function that always adds a return value", (test: Test) =>
-                {
-                    const generator: Generator<number> = Generator.create(control => control.addValue(20));
-                    test.assertNotUndefinedAndNotNull(generator);
-                    test.assertEqual([20, 20, 20, 20], generator.take(4).toArray().await());
-                });
-
-                runner.test("with function that always adds multiple return values", (test: Test) =>
-                {
-                    const generator: Generator<number> = Generator.create(control => { control.addValues([20, 21, 22]); });
-                    test.assertNotUndefinedAndNotNull(generator);
-                    test.assertEqual([20, 21, 22, 20, 21], generator.take(5).toArray().await());
-                });
-
-                runner.test("with function that always adds a return value and returns a value", (test: Test) =>
-                {
-                    const generator: Generator<number> = Generator.create(control =>
-                    {
-                        control.addValue(20);
-                        test.assertTrue(control.hasCurrent());
-                        test.assertEqual(20, control.getCurrent());
-                        return 21;
-                    });
-                    test.assertNotUndefinedAndNotNull(generator);
-                    test.assertEqual([20, 21, 20, 21, 20], generator.take(5).toArray().await());
-                });
-            });
-        });
-    });
+import { Generator } from "../sources/generator";
+import { PreConditionError } from "../sources/preConditionError";
+import { Test } from "./test";
+import { TestRunner } from "./testRunner";
+import { iteratorTests } from "./iteratorTests";
+
+export function test(runner: TestRunner): void
+{
+    runner.testFile("generator.ts", () =>
+    {
+        runner.testType("Generator<T>", () =>
+        {
+            iteratorTests(runner, () => Generator.create(() => {}));
+
+            runner.testFunction("create()", () =>
+            {
+                runner.test("with undefined", (test: Test) =>
+                {
+                    test.assertThrows(() => Generator.create(undefined!), new PreConditionError(
+                        "Expression: generatorAction",
+                        "Expected: not undefined and not null",
+                        "Actual: undefined",
+                    ));
+                });
+
+                runner.test("with null", (test: Test) =>
+                {
+                    test.assertThrows(() => Generator.create(null!), new PreConditionError(
+                        "Expression: generatorAction",
+                        "Expected: not undefined and not null",
+                        "Actual: null",
+                    ));
+                });
+
+                runner.test("with function that doesn't add any return values or return a value", (test: Test) =>
+                {
+                    const generator: Generator<void> = Generator.create(() => {});
+                    test.assertNotUndefinedAndNotNull(generator);
+                    test.assertEqual([], generator.toArray().await());
+                });
+
+                runner.test("with function that returns a constant value", (test: Test) =>
+                {
+                    const generator: Generator<number> = Generator.create(() => 20);
+                    test.assertNotUndefinedAndNotNull(generator);
+                    test.assertEqual([20, 20, 20, 20], generator.take(4).toArray().await());
+                });
+
+                runner.test("with function that returns an incrementing value", (test: Test) =>
+                {
+                    let value: number = 20;
+                    const generator: Generator<number> = Generator.create(() => value++);
+                    test.assertNotUndefinedAndNotNull(generator);
+                    test.assertEqual([20, 21, 22, 23, 24], generator.take(5).toArray().await());
+                });
+
+                runner.test("with function that always adds a return value", (test: Test) =>
+                {
+                    const generator: Generator<number> = Generator.create(control => control.addValue(20));
+                    test.assertNotUndefinedAndNotNull(generator);
+                    test.assertEqual([20, 20, 20, 20], generator.take(4).toArray().await());
+                });
+
+                runner.test("with function that always adds multiple return values", (test: Test) =>
+                {
+                    const generator: Generator<number> = Generator.create(control => { control.addValues([20, 21, 22]); });
+                    test.assertNotUndefinedAndNotNull(generator);
+                    test.assertEqual([20, 21, 22, 20, 21], generator.take(5).toArray().await());
+                });
+
+                runner.test("with function that always adds a return value and returns a value", (test: Test) =>
+                {
+                    const generator: Generator<number> = Generator.create(control =>
+                    {
+                        control.addValue(20);
+                        test.assertTrue(control.hasCurrent());
+                        test.assertEqual(20, control.getCurrent());
+                        return 21;
+                    });
+                    test.assertNotUndefinedAndNotNull(generator);
+                    test.assertEqual([20, 21, 20, 21, 20], generator.take(5).toArray().await());
+                });
+            });
+        });
+    });
 }