@everyonesoftware/common 1.0.0

package/tests/testSkip.ts

@@ -0,0 +1,34 @@
+import { BasicTestSkip } from "./basicTestSkip";
+
+/**
+ * A type that is used to mark that a test group or a test should be skipped.
+ */
+export abstract class TestSkip
+{
+    protected constructor()
+    {
+    }
+
+    /**
+     * Create a new {@link TestSkip} with the provided properties.
+     * @param shouldSkip Whether the tests associated with the new {@link TestSkip}
+     * should be skipped.
+     * @param message The message that explains why the tests associated with this {@link TestSkip}
+     * should be skipped.
+     */
+    public static create(shouldSkip?: boolean, message?: string): TestSkip
+    {
+        return BasicTestSkip.create(shouldSkip, message);
+    }
+
+    /**
+     * Get whether the tests associated with this {@link TestSkip} should be skipped.
+     */
+    public abstract getShouldSkip(): boolean;
+
+    /**
+     * Get the message that explains why the tests associated with this {@link TestSkip}
+     * should be skipped.
+     */
+    public abstract getMessage(): string;
+}

package/tests/tests.ts

@@ -0,0 +1,103 @@
+import { ConsoleTestRunner } from "./consoleTestRunner";
+import * as assertTestTests from "./assertTestTests";
+import * as byteListStreamTests from "./byteListStreamTests";
+import * as byteListTests from "./byteListTests";
+import * as byteTests from "./bytesTests";
+import * as characterListStreamTests from "./characterListStreamTests";
+import * as characterListTests from "./characterListTests";
+import * as comparerTests from "./comparerTests";
+import * as conditionTests from "./conditionTests";
+import * as consoleTestRunner2Tests from "./consoleTestRunnerTests";
+import * as dateTimeTests from "./dateTimeTests";
+import * as depthFirstSearchTests from "./depthFirstSearchTests";
+import * as disposableTests from "./disposableTests";
+import * as englishTests from "./englishTests";
+import * as equalFunctionsTests from "./equalFunctionsTests";
+import * as fetchHttpClientTests from "./fetchHttpClientTests";
+import * as generatorTests from "./generatorTests";
+import * as httpClientTests from "./httpClientTests";
+import * as inMemoryCharacterWriteStreamTests from "./inMemoryCharacterWriteStreamTests";
+import * as iterableTests from "./iterableTests";
+import * as iteratorTests from "./iteratorTests";
+import * as javascriptMapMapTests from "./javascriptMapMapTests";
+import * as listTests from "./listTests";
+import * as mapIteratorTests from "./mapIteratorTests";
+import * as mapTests from "./mapTests";
+import * as mutableConditionTests from "./mutableConditionTests";
+import * as mutableMapTests from "./mutableMapTests";
+import * as notFoundErrorTests from "./notFoundErrorTests";
+import * as postConditionErrorTests from "./postConditionErrorTests";
+import * as preConditionErrorTests from "./preConditionErrorTests";
+import * as promiseAsyncResultTests from "./promiseAsyncResultTests";
+import * as propertyTests from "./propertyTests";
+import * as queueTests from "./queueTests";
+import * as realHttpServerTests from "./nodeJSHttpServerTests";
+import * as recreationDotGovClientTests from "./recreationDotGovClientTests";
+import * as setTests from "./setTests";
+import * as stackTests from "./stackTests";
+import * as stringComparerTests from "./stringComparerTests";
+import * as stringIteratorTests from "./stringIteratorTests";
+import * as stringsTests from "./stringsTests";
+import * as syncResultTests from "./syncResultTests";
+import * as testActionTests from "./testActionTests";
+import * as testRunnerTests from "./testRunnerTests";
+import * as toStringFunctionsTests from "./toStringFunctionsTests";
+import * as typesTests from "./typesTests";
+import * as whereIteratorTests from "./whereIteratorTests";
+import * as wonderlandTrailClientTests from "./wonderlandTrailClientTests";
+
+export const hasNetworkAccess: boolean = true;
+
+async function tests(): Promise<void>
+{
+    await ConsoleTestRunner.run([
+        assertTestTests,
+        promiseAsyncResultTests.test,
+        byteTests.test,
+        comparerTests,
+        conditionTests,
+        consoleTestRunner2Tests,
+        dateTimeTests,
+        disposableTests,
+        englishTests,
+        equalFunctionsTests.test,
+        fetchHttpClientTests,
+        generatorTests,
+        httpClientTests,
+        inMemoryCharacterWriteStreamTests,
+        iterableTests,
+        iteratorTests,
+        javascriptMapMapTests,
+        listTests,
+        mapIteratorTests,
+        mapTests,
+        mutableConditionTests,
+        mutableMapTests,
+        notFoundErrorTests,
+        postConditionErrorTests,
+        preConditionErrorTests,
+        propertyTests,
+        queueTests,
+        realHttpServerTests,
+        recreationDotGovClientTests,
+        stackTests,
+        stringComparerTests,
+        stringIteratorTests,
+        stringsTests,
+        syncResultTests,
+        testActionTests,
+        testRunnerTests,
+        toStringFunctionsTests,
+        typesTests,
+        whereIteratorTests,
+        wonderlandTrailClientTests,
+        setTests,
+        depthFirstSearchTests,
+        byteListTests,
+        byteListStreamTests,
+        characterListTests,
+        characterListStreamTests,
+    ]);
+}
+
+tests();

package/tests/toStringFunctionsTests.ts

@@ -0,0 +1,55 @@
+import { Comparison } from "../sources/comparison";
+import { Iterable } from "../sources/iterable";
+import { List } from "../sources/list";
+import { Map } from "../sources/map";
+import { ToStringFunctions } from "../sources/toStringFunctions";
+import { Test } from "./test";
+import { TestRunner } from "./testRunner";
+
+export function test(runner: TestRunner): void
+{
+    runner.testFile("toStringFunctions.ts", () =>
+    {
+        runner.testType("ToStringFunctions", () =>
+        {
+            runner.testFunction("toString(unknown)", () =>
+            {
+                function toStringTest(value: unknown, expected: string)
+                {
+                    runner.test(`with ${runner.toString(value)}`, (test: Test) =>
+                    {
+                        const functions: ToStringFunctions = ToStringFunctions.create();
+                        test.assertSame(functions.toString(value), expected);
+                    });
+                }
+
+                // toStringTest(undefined, "undefined");
+                // toStringTest(null, "null");
+                // toStringTest(false, "false");
+                // toStringTest(true, "true");
+                // toStringTest(50, "50");
+                // toStringTest(NaN, "NaN");
+                // toStringTest(Infinity, "Infinity");
+                // toStringTest(-Infinity, "-Infinity");
+                // toStringTest(1.2, "1.2");
+                // toStringTest("hello\tthere\nfriend", `"hello\\tthere\\nfriend"`);
+                // toStringTest({}, "{}");
+                // toStringTest({1:"one", b: "two"}, `{"1":"one","b":"two"}`);
+                // toStringTest([], "[]");
+                // toStringTest([undefined, undefined], "[undefined,undefined]");
+                // toStringTest([1, 2.3, false], "[1,2.3,false]");
+                // toStringTest([[[]]], "[[[]]]");
+                // toStringTest(Iterable.create(), `[]`);
+                // toStringTest(Iterable.create<string>(["abc"]), `["abc"]`);
+                // toStringTest(Iterable.create([1, 2, 3]), `[1,2,3]`);
+                // toStringTest(List.create(), `[]`);
+                // toStringTest(List.create<string>(["abc"]), `["abc"]`);
+                // toStringTest(List.create([1, 2, 3]), `[1,2,3]`);
+                toStringTest(Map.create(), `{}`);
+                // toStringTest(Map.create<string,number>().set("a", 1), `{"a":1}`);
+                // toStringTest(Map.create<string,number>().set("a", 1).set("b", 2), `{"a":1,"b":2}`);
+                // toStringTest(Comparison.LessThan, "0");
+            });
+        });
+    });
+}

package/tests/typesTests.ts

@@ -0,0 +1,257 @@
+import { Iterable } from "../sources/iterable";
+import { List } from "../sources/list";
+import {
+    asBoolean, hasFunction, hasProperty, isArray, isBoolean, isFunction, isNumber, isObject,
+    isObjectOrArrayOrNull, isString
+} from "../sources/types";
+import { Test } from "./test";
+import { TestRunner } from "./testRunner";
+
+export function test(runner: TestRunner): void
+{
+    runner.testFile("types.ts", () =>
+    {
+        runner.testFunction("isBoolean(unknown)", () =>
+        {
+            function isBooleanTest(value: unknown, expected: boolean): void
+            {
+                runner.test(`with ${runner.toString(value)}`, (test: Test) =>
+                {
+                    test.assertSame(isBoolean(value), expected);
+                });
+            }
+
+            isBooleanTest(undefined, false);
+            isBooleanTest(null, false);
+            isBooleanTest("", false);
+            isBooleanTest("true", false);
+            isBooleanTest(123, false);
+            isBooleanTest({}, false);
+            isBooleanTest([], false);
+            isBooleanTest(true, true);
+            isBooleanTest(false, true);
+        });
+
+        runner.testFunction("asBoolean(unknown)", () =>
+        {
+            function asBooleanTest(value: unknown, expected: boolean | undefined): void
+            {
+                runner.test(`with ${runner.toString(value)}`, (test: Test) =>
+                {
+                    test.assertEqual(asBoolean(value), expected);
+                });
+            }
+
+            asBooleanTest(undefined, undefined);
+            asBooleanTest(null, undefined);
+            asBooleanTest("", undefined);
+            asBooleanTest("true", undefined);
+            asBooleanTest(123, undefined);
+            asBooleanTest({}, undefined);
+            asBooleanTest([], undefined);
+            asBooleanTest(true, true);
+            asBooleanTest(false, false);
+            asBooleanTest(() => false, undefined);
+            asBooleanTest(() => true, undefined);
+        });
+
+        runner.testFunction("isNumber(unknown)", () =>
+        {
+            function isNumberTest(value: unknown, expected: boolean): void
+            {
+                runner.test(`with ${runner.toString(value)}`, (test: Test) =>
+                {
+                    test.assertSame(isNumber(value), expected);
+                });
+            }
+
+            isNumberTest(undefined, false);
+            isNumberTest(null, false);
+            isNumberTest("", false);
+            isNumberTest("123", false);
+            isNumberTest({}, false);
+            isNumberTest([], false);
+            isNumberTest(true, false);
+            isNumberTest(false, false);
+            isNumberTest(123, true);
+            isNumberTest(Infinity, true);
+            isNumberTest(-Infinity, true);
+            isNumberTest(NaN, true);
+        });
+
+        runner.testFunction("isString(unknown)", () =>
+        {
+            function isStringTest(value: unknown, expected: boolean): void
+            {
+                runner.test(`with ${runner.toString(value)}`, (test: Test) =>
+                {
+                    test.assertSame(isString(value), expected);
+                });
+            }
+
+            isStringTest(undefined, false);
+            isStringTest(null, false);
+            isStringTest(50, false);
+            isStringTest({}, false);
+            isStringTest("", true);
+            isStringTest("hello", true);
+        });
+
+        runner.testFunction("isFunction(unknown)", () =>
+        {
+            function isFunctionTest(value: unknown, expected: boolean): void
+            {
+                runner.test(`with ${runner.toString(value)}`, (test: Test) =>
+                {
+                    test.assertSame(isFunction(value), expected);
+                });
+            }
+
+            isFunctionTest(undefined, false);
+            isFunctionTest(null, false);
+            isFunctionTest(false, false);
+            isFunctionTest(true, false);
+            isFunctionTest(123, false);
+            isFunctionTest("abc", false);
+            isFunctionTest({}, false);
+            isFunctionTest([], false);
+
+            isFunctionTest(isArray, true);
+            isFunctionTest(isFunction, true);
+            isFunctionTest(() => 123, true);
+        });
+
+        runner.testFunction("isArray(unknown)", () =>
+        {
+            function isArrayTest(value: unknown, expected: boolean): void
+            {
+                runner.test(`with ${runner.toString(value)}`, (test: Test) =>
+                {
+                    test.assertSame(isArray(value), expected);
+                });
+            }
+
+            isArrayTest(undefined, false);
+            isArrayTest(null, false);
+            isArrayTest(50, false);
+            isArrayTest({}, false);
+            isArrayTest("", false);
+            isArrayTest("hello", false);
+            isArrayTest(Iterable.create(), false);
+            isArrayTest(List.create(), false);
+            isArrayTest(new Uint8Array(), false);
+
+            isArrayTest([], true);
+            isArrayTest(["a", "b"], true);
+            isArrayTest(new Array(), true);
+            isArrayTest(Array.from([1, 2]), true);
+        });
+
+        runner.testFunction("isObjectOrArrayOrNull(unknown)", () =>
+        {
+            function isObjectOrArrayOrNullTest(value: unknown, expected: boolean): void
+            {
+                runner.test(`with ${runner.toString(value)}`, (test: Test) =>
+                {
+                    test.assertSame(isObjectOrArrayOrNull(value), expected);
+                });
+            }
+
+            isObjectOrArrayOrNullTest(undefined, false);
+            isObjectOrArrayOrNullTest(50, false);
+            isObjectOrArrayOrNullTest("", false);
+            isObjectOrArrayOrNullTest("hello", false);
+            
+            isObjectOrArrayOrNullTest({}, true);
+            isObjectOrArrayOrNullTest(null, true);
+            isObjectOrArrayOrNullTest([], true);
+            isObjectOrArrayOrNullTest(["a", "b"], true);
+            isObjectOrArrayOrNullTest(new Array(), true);
+            isObjectOrArrayOrNullTest(Array.from([1, 2]), true);
+            isObjectOrArrayOrNullTest(Iterable.create(), true);
+            isObjectOrArrayOrNullTest(List.create(), true);
+        });
+
+        runner.testFunction("isObject(unknown)", () =>
+        {
+            function isObjectTest(value: unknown, expected: boolean): void
+            {
+                runner.test(`with ${runner.toString(value)}`, (test: Test) =>
+                {
+                    test.assertSame(isObject(value), expected);
+                });
+            }
+
+            isObjectTest(undefined, false);
+            isObjectTest(50, false);
+            isObjectTest("", false);
+            isObjectTest("hello", false);
+            isObjectTest(null, false);
+            isObjectTest([], false);
+            isObjectTest(["a", "b"], false);
+            isObjectTest(new Array(), false);
+            isObjectTest(Array.from([1, 2]), false);
+            
+            isObjectTest({}, true);
+            isObjectTest(Iterable.create(), true);
+            isObjectTest(List.create(), true);
+        });
+
+        runner.testFunction("hasProperty(TValue,TPropertyKey extends PropertyKey)", () =>
+        {
+            function hasPropertyTest<TPropertyKey extends PropertyKey>(value: unknown, propertyKey: TPropertyKey, expected: boolean): void
+            {
+                runner.test(`with ${runner.andList([value, propertyKey])}`, (test: Test) =>
+                {
+                    const result: boolean = hasProperty(value, propertyKey);
+                    test.assertSame(result, expected);
+                    if (value !== undefined && value !== null)
+                    {
+                        if (result)
+                        {
+                            test.assertNotUndefined((value as any)[propertyKey]);
+                        }
+                        else
+                        {
+                            test.assertUndefined((value as any)[propertyKey]);
+                        }
+                    }
+                });
+            }
+
+            hasPropertyTest(undefined, "spam", false);
+            hasPropertyTest(null, "spam", false);
+            hasPropertyTest([], "spam", false);
+            hasPropertyTest([], "length", true);
+            hasPropertyTest({}, "spam", false);
+            hasPropertyTest("", "spam", false);
+            hasPropertyTest("", "length", true);
+            hasPropertyTest(5, "spam", false);
+            hasPropertyTest(5, "toString", true);
+        });
+
+        runner.testFunction("hasFunction(TValue,TPropertyKey extends PropertyKey)", () =>
+        {
+            function hasFunctionTest<TPropertyKey extends PropertyKey>(value: unknown, propertyKey: TPropertyKey, expected: boolean): void
+            {
+                runner.test(`with ${runner.andList([value, propertyKey])}`, (test: Test) =>
+                {
+                    test.assertSame(hasFunction(value, propertyKey), expected);
+                });
+            }
+
+            hasFunctionTest(undefined, "spam", false);
+            hasFunctionTest(null, "spam", false);
+            hasFunctionTest([], "spam", false);
+            hasFunctionTest([], "length", false);
+            hasFunctionTest([], Symbol.iterator, true);
+            hasFunctionTest({}, "spam", false);
+            hasFunctionTest("", "spam", false);
+            hasFunctionTest("", "length", false);
+            hasFunctionTest("", "at", true);
+            hasFunctionTest("", Symbol.iterator, true);
+            hasFunctionTest(5, "spam", false);
+            hasFunctionTest(5, "toString", true);
+        });
+    });
+}

package/tests/whereIteratorTests.ts

@@ -0,0 +1,77 @@
+import { Iterator } from "../sources/iterator";
+import { PreConditionError } from "../sources/preConditionError";
+import { WhereIterator } from "../sources/whereIterator";
+import { iteratorTests } from "./iteratorTests";
+import { Test } from "./test";
+import { TestRunner } from "./testRunner";
+
+export function test(runner: TestRunner): void
+{
+    runner.testFile("whereIterator.ts", () =>
+    {
+        runner.testType("WhereIterator<T>", () =>
+        {
+            iteratorTests(runner, () => WhereIterator.create(Iterator.create<number>([]), (_: number) => true));
+
+            runner.testFunction("create(T[])", () =>
+            {
+                function createErrorTest<T>(testName: string, innerIterator: Iterator<T>, condition: (value: T) => boolean, expected: Error): void
+                {
+                    runner.test(testName, (test: Test) =>
+                    {
+                        test.assertThrows(() => WhereIterator.create(innerIterator, condition), expected);
+                    });
+                }
+
+                createErrorTest(
+                    `with undefined innerIterator`,
+                    undefined!,
+                    (_: number) => true,
+                    new PreConditionError(
+                        "Expression: innerIterator",
+                        "Expected: not undefined and not null",
+                        "Actual: undefined",
+                    ),
+                );
+                createErrorTest(
+                    `with null innerIterator`,
+                    null!,
+                    (_: number) => true,
+                    new PreConditionError(
+                        "Expression: innerIterator",
+                        "Expected: not undefined and not null",
+                        "Actual: null",
+                    ),
+                );
+
+                function createTest<T>(testName: string, innerIterator: Iterator<T>, condition: (value: T) => boolean, expected: T[]): void
+                {
+                    runner.test(testName, async (test: Test) =>
+                    {
+                        const iterator: WhereIterator<T> = WhereIterator.create(innerIterator, condition);
+                        test.assertEqual(await iterator.toArray(), expected);
+                    });
+                }
+
+                createTest(
+                    `with empty innerIterator`,
+                    Iterator.create<number>([]),
+                    (_: number) => true,
+                    [],
+                );
+                createTest(
+                    `with none of the iterator values match the condition`,
+                    Iterator.create([1, 2, 3]),
+                    (value: number) => value > 10,
+                    [],
+                );
+                createTest(
+                    `with some of the iterator values match the condition`,
+                    Iterator.create([1, 2, 3]),
+                    (value: number) => value % 2 == 1,
+                    [1, 3],
+                );
+            });
+        });
+    });
+}