@everyonesoftware/common 2.0.0 → 4.0.0

package/tests/testSkip.ts

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

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

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

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

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