@everyonesoftware/common 2.0.0 → 4.0.0

package/tests/characterListTests.ts

@@ -1,250 +0,0 @@
-import { CharacterList } from "../sources/characterList";
-import { EqualFunctions } from "../sources/equalFunctions";
-import { JavascriptIterable } from "../sources/javascript";
-import { NotFoundError } from "../sources/notFoundError";
-import { PreConditionError } from "../sources/preConditionError";
-import { isNumber, isString } from "../sources/types";
-import { Test } from "./test";
-import { TestRunner } from "./testRunner";
-
-export function test(runner: TestRunner): void
-{
-    runner.testFile("characterList.ts", () =>
-    {
-        runner.testType("CharacterList", () =>
-        {
-            runner.testFunction("create()", () =>
-            {
-                runner.test("with no arguments", (test: Test) =>
-                {
-                    const list: CharacterList = CharacterList.create();
-                    test.assertNotUndefinedAndNotNull(list);
-                    test.assertEqual(0, list.getCount().await());
-                    test.assertFalse(list.any().await());
-                    test.assertEqual([], list.toArray().await());
-                });
-
-                runner.test("with undefined", (test: Test) =>
-                {
-                    const list: CharacterList = CharacterList.create(undefined);
-                    test.assertNotUndefinedAndNotNull(list);
-                    test.assertEqual(0, list.getCount().await());
-                    test.assertFalse(list.any().await());
-                    test.assertEqual([], list.toArray().await());
-                });
-
-                runner.test("with null", (test: Test) =>
-                {
-                    const list: CharacterList = CharacterList.create(null!);
-                    test.assertNotUndefinedAndNotNull(list);
-                    test.assertEqual(0, list.getCount().await());
-                    test.assertFalse(list.any().await());
-                    test.assertEqual([], list.toArray().await());
-                });
-
-                runner.test("with empty initialValues", (test: Test) =>
-                {
-                    const list: CharacterList = CharacterList.create([]);
-                    test.assertNotUndefinedAndNotNull(list);
-                    test.assertEqual(0, list.getCount().await());
-                    test.assertFalse(list.any().await());
-                    test.assertEqual([], list.toArray().await());
-                });
-
-                runner.test("with one value", (test: Test) =>
-                {
-                    const list: CharacterList = CharacterList.create(["m"]);
-                    test.assertNotUndefinedAndNotNull(list);
-                    test.assertEqual(1, list.getCount().await());
-                    test.assertTrue(list.any().await());
-                    test.assertEqual(["m"], list.toArray().await());
-                });
-
-                runner.test("with two values", (test: Test) =>
-                {
-                    const list: CharacterList = CharacterList.create(["n", "l"]);
-                    test.assertNotUndefinedAndNotNull(list);
-                    test.assertEqual(2, list.getCount().await());
-                    test.assertTrue(list.any().await());
-                    test.assertEqual(["n", "l"], list.toArray().await());
-                });
-            });
-
-            runner.testFunction("add()", () =>
-            {
-                function addErrorTest(value: string, expected: Error): void
-                {
-                    runner.test(`with ${runner.toString(value)}`, (test: Test) =>
-                    {
-                        const list: CharacterList = CharacterList.create();
-                        test.assertThrows(() => list.add(value), expected);
-                        test.assertEqual([], list.toArray().await());
-                    });
-                }
-
-                addErrorTest("", new PreConditionError(
-                    "Expression: value",
-                    "Expected: character",
-                    "Actual: \"\"",
-                ));
-                addErrorTest("ab", new PreConditionError(
-                    "Expression: value",
-                    "Expected: character",
-                    "Actual: \"ab\"",
-                ));
-
-                runner.test("with valid value", (test: Test) =>
-                {
-                    const list: CharacterList = CharacterList.create();
-
-                    const addResult1: CharacterList = list.add("a");
-                    test.assertSame(list, addResult1);
-                    test.assertEqual(["a"], addResult1.toArray().await());
-
-                    const addResult2: CharacterList = list.add("b");
-                    test.assertSame(list, addResult2);
-                    test.assertEqual(["a", "b"], addResult2.toArray().await());
-
-                    const addResult3: CharacterList = list.add("c");
-                    test.assertSame(list, addResult3);
-                    test.assertEqual(["a", "b", "c"], addResult3.toArray().await());
-
-                    const addResult4: CharacterList = list.add("d");
-                    test.assertSame(list, addResult4);
-                    test.assertEqual(["a", "b", "c", "d"], addResult4.toArray().await());
-                });
-            });
-
-            runner.testFunction("addAll()", () =>
-            {
-                runner.test("with empty values", (test: Test) =>
-                {
-                    const list: CharacterList = CharacterList.create();
-
-                    const addAllResult: CharacterList = list.addAll([]);
-                    test.assertSame(list, addAllResult);
-                    test.assertEqual([], list.toArray().await());
-                });
-
-                runner.test("with non-empty values", (test: Test) =>
-                {
-                    const list: CharacterList = CharacterList.create();
-
-                    const addAllResult: CharacterList = list.addAll("abcde");
-                    test.assertSame(list, addAllResult);
-                    test.assertEqual(["a", "b", "c", "d", "e"], list.toArray().await());
-                });
-            });
-
-            runner.testFunction("insert()", () =>
-            {
-                function insertErrorTest(initialValues: string[], index: number, value: string, expected: Error): void
-                {
-                    runner.test(`with ${runner.andList([initialValues, index, value])}`, (test: Test) =>
-                    {
-                        const list: CharacterList = CharacterList.create(initialValues);
-                        test.assertThrows(() => list.insert(index, value), expected);
-                        test.assertEqual(initialValues, list.toArray().await());
-                    });
-                }
-
-                insertErrorTest([], -1, "a", new PreConditionError(
-                    "Expression: index",
-                    "Expected: 0",
-                    "Actual: -1",
-                ));
-                insertErrorTest([], 1, "a", new PreConditionError(
-                    "Expression: index",
-                    "Expected: 0",
-                    "Actual: 1",
-                ));
-                insertErrorTest(["z"], -1, "a", new PreConditionError(
-                    "Expression: index",
-                    "Expected: between 0 and 1",
-                    "Actual: -1",
-                ));
-                insertErrorTest(["z"], 2, "a", new PreConditionError(
-                    "Expression: index",
-                    "Expected: between 0 and 1",
-                    "Actual: 2",
-                ));
-                insertErrorTest([], 0, "", new PreConditionError(
-                    "Expression: value",
-                    "Expected: character",
-                    "Actual: \"\"",
-                ));
-                insertErrorTest([], 0, "ab", new PreConditionError(
-                    "Expression: value",
-                    "Expected: character",
-                    "Actual: \"ab\"",
-                ));
-
-                function insertTest(initialValues: JavascriptIterable<string>, index: number, value: string, expected: string[]): void
-                {
-                    runner.test(`with ${runner.andList([initialValues, index, value])}`, (test: Test) =>
-                    {
-                        const list: CharacterList = CharacterList.create(initialValues);
-
-                        const insertResult: CharacterList = list.insert(index, value);
-                        test.assertSame(list, insertResult);
-                        test.assertEqual(expected, list.toArray().await());
-                    });
-                }
-
-                insertTest([], 0, "z", ["z"]);
-                insertTest(["a"], 0, "y", ["y", "a"]);
-                insertTest(["a"], 1, "y", ["a", "y"]);
-                insertTest(["a", "b", "c"], 0, "z", ["z", "a", "b", "c"]);
-                insertTest(["a", "b", "c"], 1, "z", ["a", "z", "b", "c"]);
-                insertTest(["a", "b", "c"], 2, "z", ["a", "b", "z", "c"]);
-                insertTest(["a", "b", "c"], 3, "z", ["a", "b", "c", "z"]);
-                insertTest(["a", "b", "c", "d", "e"], 2, "z", ["a", "b", "z", "c", "d", "e"]);
-            });
-
-            runner.testFunction("remove()", () =>
-            {
-                runner.test("with not-found value", (test: Test) =>
-                {
-                    const list: CharacterList = CharacterList.create();
-
-                    test.assertThrows(() => list.remove("a").await(), new NotFoundError("Could not find the value to remove: \"a\""));
-                    test.assertEqual([], list.toArray().await());
-                });
-
-                runner.test("with found value", (test: Test) =>
-                {
-                    const list: CharacterList = CharacterList.create(["a"]);
-
-                    const removeResult: string = list.remove("a").await();
-                    test.assertEqual("a", removeResult);
-                    test.assertEqual([], list.toArray().await());
-                });
-
-                runner.test("with multiple found values", (test: Test) =>
-                {
-                    const list: CharacterList = CharacterList.create(["a", "a", "a"]);
-
-                    const removeResult: string = list.remove("a").await();
-                    test.assertEqual("a", removeResult);
-                    test.assertEqual(["a", "a"], list.toArray().await());
-                });
-
-                runner.test("with multiple found values and equalFunctions", (test: Test) =>
-                {
-                    const list: CharacterList = CharacterList.create(["a", "b", "c", "d", "e"]);
-                    const isVowel = (character: string) => ["a", "e", "i", "o", "u"].includes(character);
-                    const equalFunctions: EqualFunctions = EqualFunctions.create()
-                        .add((left: unknown, right: unknown) =>
-                        {
-                            return isString(left) && isString(right)
-                                ? isVowel(left) === isVowel(right)
-                                : undefined;
-                        });
-                    const removeResult: string = list.remove("i", equalFunctions).await();
-                    test.assertEqual("a", removeResult);
-                    test.assertEqual(["b", "c", "d", "e"], list.toArray().await());
-                });
-            });
-        });
-    });
-}

package/tests/characterWriteStreamTests.ts

@@ -1,12 +0,0 @@
-import { CharacterWriteStream } from "../sources/characterWriteStream";
-import { TestRunner } from "./testRunner";
-
-export function test(runner: TestRunner, creator: () => CharacterWriteStream): void
-{
-    runner.testFile("characterWriteStream.ts", () =>
-    {
-        runner.testType("CharacterWriteStream", () =>
-        {
-        });
-    });
-}

package/tests/comparerTests.ts

@@ -1,92 +0,0 @@
-import { Comparer } from "../sources/comparer";
-import { Comparison } from "../sources/comparison";
-import { Test } from "./test";
-import { TestRunner } from "./testRunner";
-
-export function test(runner: TestRunner): void
-{
-    runner.testFile("comparer.ts", () =>
-    {
-        runner.testType("Comparer<TLeft,TRight>", () =>
-        {
-            runner.testFunction("compareSameUndefinedNull()", () =>
-            {
-                function compareSameUndefinedNullTest(left: unknown, right: unknown, expected: Comparison | undefined): void
-                {
-                    runner.test(`with ${runner.andList([left, right])}`, (test: Test) =>
-                    {
-                        test.assertEqual(Comparer.compareSameUndefinedNull(left, right), expected);
-                    });
-                }
-
-                compareSameUndefinedNullTest(undefined, undefined, Comparison.Equal);
-                compareSameUndefinedNullTest(undefined, null, Comparison.LessThan);
-                compareSameUndefinedNullTest(undefined, "hello", Comparison.LessThan);
-                compareSameUndefinedNullTest(undefined, 50, Comparison.LessThan);
-
-                compareSameUndefinedNullTest(null, undefined, Comparison.GreaterThan);
-                compareSameUndefinedNullTest(null, null, Comparison.Equal);
-                compareSameUndefinedNullTest(null, "hello", Comparison.LessThan);
-                compareSameUndefinedNullTest(null, 50, Comparison.LessThan);
-
-                compareSameUndefinedNullTest("hello", undefined, Comparison.GreaterThan);
-                compareSameUndefinedNullTest("hello", null, Comparison.GreaterThan);
-                compareSameUndefinedNullTest("hello", "hello", Comparison.Equal);
-                compareSameUndefinedNullTest("hello", "abc", undefined);
-                compareSameUndefinedNullTest("hello", 50, undefined);
-            });
-
-            runner.testFunction("equalSameUndefinedNull()", () =>
-            {
-                function equalSameUndefinedNullTest(left: unknown, right: unknown, expected: boolean | undefined): void
-                {
-                    runner.test(`with ${runner.andList([left, right])}`, (test: Test) =>
-                    {
-                        test.assertEqual(Comparer.equalSameUndefinedNull(left, right), expected);
-                    });
-                }
-
-                equalSameUndefinedNullTest(undefined, undefined, true);
-                equalSameUndefinedNullTest(undefined, null, false);
-                equalSameUndefinedNullTest(undefined, "hello", false);
-                equalSameUndefinedNullTest(undefined, 50, false);
-
-                equalSameUndefinedNullTest(null, undefined, false);
-                equalSameUndefinedNullTest(null, null, true);
-                equalSameUndefinedNullTest(null, "hello", false);
-                equalSameUndefinedNullTest(null, 50, false);
-
-                equalSameUndefinedNullTest("hello", undefined, false);
-                equalSameUndefinedNullTest("hello", null, false);
-                equalSameUndefinedNullTest("hello", "hello", true);
-                equalSameUndefinedNullTest("hello", "abc", undefined);
-                equalSameUndefinedNullTest("hello", 50, undefined);
-            });
-
-            runner.testFunction("compareNumbers()", () =>
-            {
-                function compareNumbersTest(left: number | null | undefined, right: number | null | undefined, expected: Comparison | undefined): void
-                {
-                    runner.test(`with ${runner.andList([left, right])}`, (test: Test) =>
-                    {
-                        test.assertEqual(Comparer.compareNumbers(left, right), expected);
-                    });
-                }
-
-                compareNumbersTest(undefined, undefined, Comparison.Equal);
-                compareNumbersTest(undefined, null, Comparison.LessThan);
-                compareNumbersTest(undefined, 50, Comparison.LessThan);
-
-                compareNumbersTest(null, undefined, Comparison.GreaterThan);
-                compareNumbersTest(null, null, Comparison.Equal);
-                compareNumbersTest(null, 50, Comparison.LessThan);
-
-                compareNumbersTest(50, undefined, Comparison.GreaterThan);
-                compareNumbersTest(50, null, Comparison.GreaterThan);
-                compareNumbersTest(50, 30, Comparison.GreaterThan);
-                compareNumbersTest(50, 50, Comparison.Equal);
-                compareNumbersTest(50, 60, Comparison.LessThan);
-            });
-        });
-    });
-}