@everyonesoftware/common 3.0.0 → 4.0.0

package/tests/depthFirstSearchTests.ts

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

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

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

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

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

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