@everyonesoftware/common 1.0.0

package/tests/depthFirstSearchTests.ts

@@ -0,0 +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());
+            });
+        });
+    });
+}

package/tests/disposableTests.ts

@@ -0,0 +1,121 @@
+import { SyncDisposable } from "../sources/basicDisposable";
+import { Disposable } from "../sources/disposable";
+import { PreConditionError } from "../sources/preConditionError";
+import { SyncResult } from "../sources/syncResult";
+import { Test } from "./test";
+import { TestRunner } from "./testRunner";
+
+export function test(runner: TestRunner): void
+{
+    runner.testFile("disposable.ts", () =>
+    {
+        runner.testType("Disposable", () =>
+        {
+            runner.testFunction("create()", () =>
+            {
+                function createErrorTest(testName: string, disposedFunction: () => void, expectedError: Error): void
+                {
+                    runner.test(testName, (test: Test) =>
+                    {
+                        test.assertThrows(() => Disposable.create(disposedFunction), expectedError);
+                    });
+                }
+
+                createErrorTest("with undefined", undefined!, new PreConditionError(
+                    "Expression: disposedFunction",
+                    "Expected: not undefined and not null",
+                    "Actual: undefined",
+                ));
+                createErrorTest("with null", null!, new PreConditionError(
+                    "Expression: disposedFunction",
+                    "Expected: not undefined and not null",
+                    "Actual: null",
+                ));
+
+                runner.test("with function", (test: Test) =>
+                {
+                    let value: number = 0;
+                    const disposable: Disposable = Disposable.create(() => value += 1);
+                    test.assertNotUndefinedAndNotNull(disposable);
+                    test.assertFalse(disposable.isDisposed());
+                    test.assertEqual(value, 0);
+                });
+            });
+
+            runner.testFunction("dispose()", () =>
+            {
+                runner.test("with function that doesn't throw", (test: Test) =>
+                {
+                    let value: number = 0;
+                    const disposable: SyncDisposable = Disposable.create(() =>
+                    {
+                        test.assertEqual(disposable.isDisposed(), value !== 0);
+                        value += 1;
+                    });
+
+                    const result1: SyncResult<boolean> = disposable.dispose();
+                    test.assertNotUndefinedAndNotNull(result1);
+                    test.assertTrue(disposable.isDisposed());
+                    test.assertEqual(value, 1);
+
+                    for (let i = 0; i < 3; i++)
+                    {
+                        const resultValue: boolean = result1.await();
+                        test.assertTrue(resultValue);
+                        test.assertTrue(disposable.isDisposed());
+                        test.assertEqual(value, 1);
+                    }
+
+                    const result2: SyncResult<boolean> = disposable.dispose();
+                    test.assertNotUndefinedAndNotNull(result2);
+                    test.assertTrue(disposable.isDisposed());
+                    test.assertEqual(value, 1);
+
+                    for (let i = 0; i < 3; i++)
+                    {
+                        const resultValue: boolean = result2.await();
+                        test.assertFalse(resultValue);
+                        test.assertTrue(disposable.isDisposed());
+                        test.assertEqual(value, 1);
+                    }
+                });
+
+                runner.test("with function that throws", (test: Test) =>
+                {
+                    let value: number = 0;
+                    const disposable: SyncDisposable = Disposable.create(() =>
+                    {
+                        test.assertEqual(disposable.isDisposed(), value !== 0);
+                        value += 1;
+                        throw new Error("oops!");
+                    });
+
+                    const result1: SyncResult<boolean> = disposable.dispose();
+                    test.assertNotUndefinedAndNotNull(result1);
+                    test.assertTrue(disposable.isDisposed());
+                    test.assertEqual(value, 1);
+
+                    for (let i = 0; i < 3; i++)
+                    {
+                        test.assertThrows(() => result1.await(), new Error("oops!"));
+                        test.assertTrue(disposable.isDisposed());
+                        test.assertEqual(value, 1);
+                    }
+
+                    const result2: SyncResult<boolean> = disposable.dispose();
+                    test.assertNotUndefinedAndNotNull(result2);
+                    test.assertTrue(disposable.isDisposed());
+                    test.assertEqual(value, 1);
+
+                    for (let i = 0; i < 3; i++)
+                    {
+                        const resultValue: boolean = result2.await();
+                        test.assertFalse(resultValue);
+                        test.assertTrue(disposable.isDisposed());
+                        test.assertEqual(value, 1);
+                    }
+                });
+            });
+        });
+    });
+}

package/tests/englishTests.ts

@@ -0,0 +1,103 @@
+import { andList, orList } from "../sources/english";
+import { PreConditionError } from "../sources/preConditionError";
+import { join } from "../sources/strings";
+import { Test } from "./test";
+import { TestRunner } from "./testRunner";
+
+export function test(runner: TestRunner): void
+{
+    runner.testFile("english.ts", () =>
+    {
+        runner.testFunction("andList(string[])", () =>
+        {
+            function andListErrorTest(values: string[] | undefined | null, expectedError: Error): void
+            {
+                runner.test(`with ${runner.toString(values)}`, (test: Test) =>
+                {
+                    test.assertThrows(() => andList(values!), expectedError);
+                });
+            }
+
+            andListErrorTest(
+                undefined,
+                new PreConditionError(
+                    join("\n", [
+                        "Expression: values",
+                        "Expected: not undefined and not null",
+                        "Actual: undefined",
+                    ])));
+                    andListErrorTest(
+                null,
+                new PreConditionError(
+                    join("\n", [
+                        "Expression: values",
+                        "Expected: not undefined and not null",
+                        "Actual: null",
+                    ])));
+
+            function andListTest(values: string[], expected: string): void
+            {
+                runner.test(`with ${runner.toString(values)}`, (test: Test) =>
+                {
+                    test.assertEqual(andList(values), expected);
+                });
+            }
+
+            andListTest([], "");
+            andListTest([""], "");
+            andListTest(["", ""], " and ");
+            andListTest(["", "", ""], ", , and ");
+            
+            andListTest(["a"], "a");
+            andListTest(["a", "b"], "a and b");
+            andListTest(["a", "b", "c"], "a, b, and c");
+            andListTest(["a", "b", "c", "d"], "a, b, c, and d");
+        });
+
+        runner.testFunction("orList(string[])", () =>
+        {
+            function orListErrorTest(values: string[] | undefined | null, expectedError: Error): void
+            {
+                runner.test(`with ${runner.toString(values)}`, (test: Test) =>
+                {
+                    test.assertThrows(() => orList(values!), expectedError);
+                });
+            }
+
+            orListErrorTest(
+                undefined,
+                new PreConditionError(
+                    join("\n", [
+                        "Expression: values",
+                        "Expected: not undefined and not null",
+                        "Actual: undefined",
+                    ])));
+                    orListErrorTest(
+                null,
+                new PreConditionError(
+                    join("\n", [
+                        "Expression: values",
+                        "Expected: not undefined and not null",
+                        "Actual: null",
+                    ])));
+
+            function orListTest(values: string[], expected: string): void
+            {
+                runner.test(`with ${runner.toString(values)}`, (test: Test) =>
+                {
+                    test.assertEqual(orList(values), expected);
+                });
+            }
+
+            orListTest([], "");
+            orListTest([""], "");
+            orListTest(["", ""], " or ");
+            orListTest(["", "", ""], ", , or ");
+            
+            orListTest(["a"], "a");
+            orListTest(["a", "b"], "a or b");
+            orListTest(["a", "b", "c"], "a, b, or c");
+            orListTest(["a", "b", "c", "d"], "a, b, c, or d");
+        });
+    });
+}

package/tests/equalFunctionsTests.ts

@@ -0,0 +1,223 @@
+import { andList } from "../sources/english";
+import { EqualFunctions } from "../sources/equalFunctions";
+import { List } from "../sources/list";
+import { Map } from "../sources/map";
+import { PreConditionError } from "../sources/preConditionError";
+import { isNumber } from "../sources/types";
+import { Test } from "./test";
+import { TestRunner } from "./testRunner";
+
+export function test(runner: TestRunner): void
+{
+    runner.testFile("equalFunctions.ts", () =>
+    {
+        runner.testType("EqualFunctions", () =>
+        {
+            runner.test("create()", (test: Test) =>
+            {
+                const functions: EqualFunctions = EqualFunctions.create();
+                test.assertNotUndefinedAndNotNull(functions);
+            });
+
+            runner.testFunction("areEqual()", () =>
+            {
+                function areEqualTest(left: unknown, right: unknown, expected: boolean): void
+                {
+                    runner.test(`with ${runner.andList([left, right])}`, (test: Test) =>
+                    {
+                        const functions: EqualFunctions = EqualFunctions.create();
+                        test.assertEqual(functions.areEqual(left, right).await(), expected);
+                    });
+                }
+
+                areEqualTest(undefined, undefined, true);
+                areEqualTest(undefined, null, false);
+                areEqualTest(undefined, false, false);
+                areEqualTest(undefined, true, false);
+                areEqualTest(undefined, "hello", false);
+                areEqualTest(undefined, 20, false);
+                areEqualTest(undefined, {}, false);
+                areEqualTest(undefined, [], false);
+                areEqualTest(undefined, Map.create(), false);
+
+                areEqualTest(null, undefined, false);
+                areEqualTest(null, null, true);
+                areEqualTest(null, false, false);
+                areEqualTest(null, true, false);
+                areEqualTest(null, "hello", false);
+                areEqualTest(null, 20, false);
+                areEqualTest(null, {}, false);
+                areEqualTest(null, [], false);
+                areEqualTest(null, Map.create(), false);
+
+                areEqualTest(false, undefined, false);
+                areEqualTest(false, null, false);
+                areEqualTest(false, false, true);
+                areEqualTest(false, true, false);
+                areEqualTest(false, "hello", false);
+                areEqualTest(false, 20, false);
+                areEqualTest(false, {}, false);
+                areEqualTest(false, [], false);
+                areEqualTest(false, Map.create(), false);
+
+                areEqualTest(true, undefined, false);
+                areEqualTest(true, null, false);
+                areEqualTest(true, false, false);
+                areEqualTest(true, true, true);
+                areEqualTest(true, "hello", false);
+                areEqualTest(true, 20, false);
+                areEqualTest(true, {}, false);
+                areEqualTest(true, [], false);
+                areEqualTest(true, Map.create(), false);
+                
+                areEqualTest("hello", undefined, false);
+                areEqualTest("hello", null, false);
+                areEqualTest("hello", false, false);
+                areEqualTest("hello", true, false);
+                areEqualTest("hello", "hello", true);
+                areEqualTest("hello", "hello there", false);
+                areEqualTest("hello", "HELLO", false);
+                areEqualTest("hello", 20, false);
+                areEqualTest("hello", {}, false);
+                areEqualTest("hello", [], false);
+                areEqualTest("", [], false);
+                areEqualTest("abc", ["a", "b", "c"], false);
+                areEqualTest("hello", Map.create(), false);
+
+                areEqualTest(10, undefined, false);
+                areEqualTest(10, null, false);
+                areEqualTest(10, false, false);
+                areEqualTest(10, true, false);
+                areEqualTest(10, "hello", false);
+                areEqualTest(10, 10, true);
+                areEqualTest(10, 10.0, true);
+                areEqualTest(10, -10, false);
+                areEqualTest(10, 10.0000001, false);
+                areEqualTest(10, 20, false);
+                areEqualTest(10, {}, false);
+                areEqualTest(10, [], false);
+                areEqualTest(10, Map.create(), false);
+
+                areEqualTest({}, undefined, false);
+                areEqualTest({}, null, false);
+                areEqualTest({}, false, false);
+                areEqualTest({}, true, false);
+                areEqualTest({}, "hello", false);
+                areEqualTest({}, 20, false);
+                areEqualTest({}, {}, true);
+                areEqualTest({}, {a:5}, false);
+                areEqualTest({a:5}, {a:5}, true);
+                areEqualTest({a:{b:5}}, {a:{b:5}}, true);
+                areEqualTest({a:6}, {a:5}, false);
+                areEqualTest({A:5}, {a:5}, false);
+                areEqualTest({}, [], false);
+                areEqualTest({}, Map.create(), false);
+                areEqualTest({a:5}, Map.create<string,number>().set("a", 5), false);
+
+                areEqualTest([], undefined, false);
+                areEqualTest([], null, false);
+                areEqualTest([], false, false);
+                areEqualTest([], true, false);
+                areEqualTest([], "hello", false);
+                areEqualTest(["a", "b", "c"], "abc", false);
+                areEqualTest([], 20, false);
+                areEqualTest([], {}, false);
+                areEqualTest([], List.create(), true);
+                areEqualTest([], [], true);
+                areEqualTest([], [1], false);
+                areEqualTest([1], [1], true);
+                areEqualTest([1,2,3], [1,2,3], true);
+                areEqualTest([1,2], [1,2,3], false);
+                areEqualTest([1,2], [1,3], false);
+                areEqualTest([], Map.create(), false);
+
+                areEqualTest(List.create(), undefined, false);
+                areEqualTest(List.create(), null, false);
+                areEqualTest(List.create(), false, false);
+                areEqualTest(List.create(), true, false);
+                areEqualTest(List.create(), "hello", false);
+                areEqualTest(List.create(), 20, false);
+                areEqualTest(List.create(), {}, false);
+                areEqualTest(List.create(), [], true);
+                areEqualTest(List.create(), [1], false);
+                areEqualTest(List.create([1]), [1], true);
+                areEqualTest(List.create([1,2,3]), [1,2,3], true);
+                areEqualTest(List.create([1,2]), [1,2,3], false);
+                areEqualTest(List.create([1,2]), [1,3], false);
+                areEqualTest(List.create(), Map.create(), false);
+
+                areEqualTest(Map.create(), undefined, false);
+                areEqualTest(Map.create(), null, false);
+                areEqualTest(Map.create(), false, false);
+                areEqualTest(Map.create(), true, false);
+                areEqualTest(Map.create(), "hello", false);
+                areEqualTest(Map.create(), 20, false);
+                areEqualTest(Map.create(), {}, false);
+                areEqualTest(Map.create().set("d", 4), {d:4}, false);
+                areEqualTest(Map.create().set("d", 4), {d:5}, false);
+                areEqualTest(Map.create().set("d", 4), {e:4}, false);
+                areEqualTest(Map.create(), [], false);
+                areEqualTest(Map.create(), Map.create(), true);
+                areEqualTest(Map.create(), Map.create().set("e", 5), false);
+                areEqualTest(Map.create().set("e", 5), Map.create().set("e", 5), true);
+                areEqualTest(Map.create().set("e", 5), Map.create().set("f", 5), false);
+                areEqualTest(Map.create().set("e", 5), Map.create().set("e", 6), false);
+                areEqualTest(Map.create().set("e", 5).set("f", 6), Map.create().set("f", 6).set("e", 5), true);
+            });
+
+            runner.testFunction("add()", () =>
+            {
+                runner.test("with undefined equalFunction", (test: Test) =>
+                {
+                    const functions: EqualFunctions = EqualFunctions.create();
+                    test.assertThrows(
+                        () => functions.add(undefined!),
+                        new PreConditionError([
+                            "Expression: equalFunction",
+                            "Expected: not undefined and not null",
+                            "Actual: undefined"
+                        ].join("\n")),
+                    );
+                });
+
+                runner.test("with null equalFunction", (test: Test) =>
+                {
+                    const functions: EqualFunctions = EqualFunctions.create();
+                    test.assertThrows(
+                        () => functions.add(null!),
+                        new PreConditionError([
+                            "Expression: equalFunction",
+                            "Expected: not undefined and not null",
+                            "Actual: null"
+                        ].join("\n")),
+                    );
+                });
+
+                runner.test("with equalFunction that compares numbers based on their mod 2 result", (test: Test) =>
+                {
+                    const functions: EqualFunctions = EqualFunctions.create();
+                    const result: EqualFunctions = functions.add((left: unknown, right: unknown) =>
+                    {
+                        let result: boolean | undefined;
+                        if (isNumber(left) && isNumber(right))
+                        {
+                            const leftMod2: number = left % 2;
+                            const rightMod2: number = right % 2;
+                            result = leftMod2 === rightMod2;
+                        }
+                        return result;
+                    });
+                    test.assertSame(functions, result);
+                    test.assertTrue(functions.areEqual(0, 0).await());
+                    test.assertTrue(functions.areEqual(1, 1).await());
+                    test.assertTrue(functions.areEqual(0, 2).await());
+                    test.assertTrue(functions.areEqual(1, 3).await());
+                    test.assertFalse(functions.areEqual(-1, 5).await());
+                    test.assertFalse(functions.areEqual(0, 1).await());
+                    test.assertTrue(functions.areEqual(false, false).await());
+                    test.assertFalse(functions.areEqual(false, true).await());
+                });
+            });
+        });
+    });
+}

package/tests/failedTest.ts

@@ -0,0 +1,43 @@
+import { JavascriptIterable } from "../sources/javascript";
+import { PreCondition } from "../sources/preCondition";
+import { join } from "../sources/strings";
+
+export class FailedTest
+{
+    private readonly fullTestNameParts: JavascriptIterable<string>;
+    private readonly error: unknown;
+
+    private constructor(fullTestNameParts: JavascriptIterable<string>, error: unknown)
+    {
+        PreCondition.assertNotEmpty(fullTestNameParts, "fullTestName");
+        PreCondition.assertNotUndefinedAndNotNull(error, "error");
+
+        this.fullTestNameParts = fullTestNameParts;
+        this.error = error;
+    }
+
+    public static create(fullTestNameParts: JavascriptIterable<string>, error: unknown): FailedTest
+    {
+        return new FailedTest(fullTestNameParts, error);
+    }
+
+    public getFullTestNameParts(): JavascriptIterable<string>
+    {
+        return this.fullTestNameParts;
+    }
+
+    public getFullTestName(): string
+    {
+        return join(" ", this.fullTestNameParts);
+    }
+
+    public getError(): unknown
+    {
+        return this.error;
+    }
+
+    public getErrorMessage(): string
+    {
+        return this.error instanceof Error && this.error.stack ? this.error.stack : `${this.error}`;
+    }
+}

package/tests/fetchHttpClientTests.ts

@@ -0,0 +1,33 @@
+import { FetchHttpClient } from "../sources/fetchHttpClient";
+import { FetchHttpIncomingResponse } from "../sources/fetchHttpResponse";
+import { HttpOutgoingRequest } from "../sources/httpOutgoingRequest";
+import { Test } from "./test";
+import { TestRunner } from "./testRunner";
+import { hasNetworkAccess } from "./tests";
+
+export function test(runner: TestRunner): void
+{
+    runner.testFile("fetchHttpClient.ts", () =>
+    {
+        runner.testType("FetchHttpClient", () =>
+        {
+            runner.test("create()", (test: Test) =>
+            {
+                const client: FetchHttpClient = FetchHttpClient.create();
+                test.assertNotUndefinedAndNotNull(client);
+            });
+
+            runner.testFunction("sendRequest()", () =>
+            {
+                runner.test("to URL that exists", runner.skip(!hasNetworkAccess), async (test: Test) =>
+                {
+                    const client: FetchHttpClient = FetchHttpClient.create();
+
+                    const response: FetchHttpIncomingResponse = await client.sendRequest(HttpOutgoingRequest.get("https://www.example.com"));
+                    test.assertNotUndefinedAndNotNull(response);
+                    test.assertEqual(200, response.getStatusCode());
+                });
+            });
+        });
+    });
+}