@everyonesoftware/common 1.0.0

package/tests/javascriptMapMapTests.ts

@@ -0,0 +1,21 @@
+import { JavascriptMapMap } from "../sources/javascriptMapMap";
+import { mapTests } from "./mapTests";
+import { Test } from "./test";
+import { TestRunner } from "./testRunner";
+
+export function test(runner: TestRunner): void
+{
+    runner.testFile("javascriptMapMap.ts", () =>
+    {
+        runner.testType("JavascriptMapMap<TKey,TValue>", () =>
+        {
+            runner.testFunction("create()", (test: Test) =>
+            {
+                const map: JavascriptMapMap<number,string> = JavascriptMapMap.create();
+                test.assertEqual(map.getCount().await(), 0);
+            });
+
+            mapTests(runner, JavascriptMapMap.create);
+        });
+    });
+}

package/tests/listTests.ts

@@ -0,0 +1,338 @@
+import { JavascriptIterable } from "../sources/javascript";
+import { List } from "../sources/list";
+import { PreConditionError } from "../sources/preConditionError";
+import { isIterable } from "../sources/types";
+import { Test } from "./test";
+import { TestRunner } from "./testRunner";
+
+export function test(runner: TestRunner): void
+{
+    runner.testFile("list.ts", () =>
+    {
+        runner.testType("List<T>", () =>
+        {
+            runner.testFunction("create(T[]|Iterable<T>|undefined)", () =>
+            {
+                runner.test("with no arguments", (test: Test) =>
+                {
+                    const list: List<number> = List.create();
+                    test.assertNotUndefinedAndNotNull(list);
+                    test.assertEqual(list.toArray().await(), []);
+                    test.assertEqual(list.toString(), "[]");
+                    test.assertEqual(list.getCount().await(), 0);
+                });
+
+                runner.test("with undefined", (test: Test) =>
+                {
+                    const list: List<number> = List.create(undefined);
+                    test.assertNotUndefinedAndNotNull(list);
+                    test.assertEqual(list.toArray().await(), []);
+                    test.assertEqual(list.toString(), "[]");
+                    test.assertEqual(list.getCount().await(), 0);
+                });
+
+                runner.test("with empty array", (test: Test) =>
+                {
+                    const list: List<number> = List.create<number>([]);
+                    test.assertNotUndefinedAndNotNull(list);
+                    test.assertEqual(list.toArray().await(), []);
+                    test.assertSame(list.toString(), "[]");
+                    test.assertSame(list.getCount().await(), 0);
+                });
+
+                runner.test("with non-empty array", (test: Test) =>
+                {
+                    const list: List<number> = List.create([1, 2, 3]);
+                    test.assertNotUndefinedAndNotNull(list);
+                    test.assertEqual(list.toArray().await(), [1, 2, 3]);
+                    test.assertSame(list.toString(), "[1,2,3]");
+                    test.assertSame(list.getCount().await(), 3);
+                });
+
+                runner.test("with empty Iterable<T>", (test: Test) =>
+                {
+                    const list: List<number> = List.create(List.create());
+                    test.assertNotUndefinedAndNotNull(list);
+                    test.assertEqual(list.toArray().await(), []);
+                    test.assertSame(list.toString(), "[]");
+                    test.assertSame(list.getCount().await(), 0);
+                });
+
+                runner.test("with non-empty Iterable<T>", (test: Test) =>
+                {
+                    const list: List<number> = List.create(List.create([1, 2, 3]));
+                    test.assertNotUndefinedAndNotNull(list);
+                    test.assertEqual(list.toArray().await(), [1, 2, 3]);
+                    test.assertTrue(isIterable(list));
+                    test.assertSame(list.toString(), "[1,2,3]");
+                    test.assertSame(list.getCount().await(), 3);
+                });
+            });
+
+            runner.testFunction("set(number,T)", () =>
+            {
+                function setErrorTest(list: List<number>, index: number, value: number, expectedError: Error): void
+                {
+                    runner.test(`with ${runner.andList([list, index, value])}`, (test: Test) =>
+                    {
+                        const backupList: List<number> = List.create(list);
+                        test.assertThrows(() => list.set(index, value), expectedError);
+                        test.assertEqual(list, backupList);
+                    });
+                }
+
+                setErrorTest(List.create(), -1, 5, new PreConditionError(
+                    "Expression: count",
+                    "Expected: greater than or equal to 1",
+                    "Actual: 0",
+                ));
+                setErrorTest(List.create(), 0, 5, new PreConditionError(
+                    "Expression: count",
+                    "Expected: greater than or equal to 1",
+                    "Actual: 0",
+                ));
+                setErrorTest(List.create(), 1, 5, new PreConditionError(
+                    "Expression: count",
+                    "Expected: greater than or equal to 1",
+                    "Actual: 0"
+                ));
+                setErrorTest(List.create([1]), -1, 5, new PreConditionError(
+                    "Expression: index",
+                    "Expected: 0",
+                    "Actual: -1"
+                ));
+                setErrorTest(List.create([1]), 1, 5, new PreConditionError(
+                    "Expression: index",
+                    "Expected: 0",
+                    "Actual: 1"
+                ));
+
+                function setTest(list: List<number>, index: number, value: number, expected: number[]): void
+                {
+                    runner.test(`with ${runner.andList([list, index, value])}`, (test: Test) =>
+                    {
+                        const setResult: List<number> = list.set(index, value);
+                        test.assertSame(list, setResult);
+                        test.assertEqual(list.toArray().await(), expected);
+                    });
+                }
+
+                setTest(List.create([1]), 0, 5, [5]);
+                setTest(List.create([1, 2]), 0, 5, [5, 2]);
+                setTest(List.create([1, 2]), 1, 5, [1, 5]);
+            });
+
+            runner.testFunction("get(number)", () =>
+            {
+                function getErrorTest(list: List<number>, index: number, expectedError: Error): void
+                {
+                    runner.test(`with ${runner.andList([list, index])}`, (test: Test) =>
+                    {
+                        const backupList: List<number> = List.create(list);
+                        test.assertThrows(() => list.get(index), expectedError);
+                        test.assertEqual(list, backupList);
+                    });
+                }
+
+                getErrorTest(List.create(), -1, new PreConditionError(
+                    "Expression: count",
+                    "Expected: greater than or equal to 1",
+                    "Actual: 0"
+                ));
+                getErrorTest(List.create(), 0, new PreConditionError(
+                    "Expression: count",
+                    "Expected: greater than or equal to 1",
+                    "Actual: 0"
+                ));
+                getErrorTest(List.create(), 1, new PreConditionError(
+                    "Expression: count",
+                    "Expected: greater than or equal to 1",
+                    "Actual: 0"
+                ));
+                getErrorTest(List.create([1]), -1, new PreConditionError(
+                    "Expression: index",
+                    "Expected: 0",
+                    "Actual: -1"
+                ));
+                getErrorTest(List.create([1]), 1, new PreConditionError(
+                    "Expression: index",
+                    "Expected: 0",
+                    "Actual: 1"
+                ));
+
+                function getTest(list: List<number>, index: number, expected: number): void
+                {
+                    runner.test(`with ${runner.andList([list, index])}`, (test: Test) =>
+                    {
+                        test.assertSame(list.get(index).await(), expected);
+                    });
+                }
+
+                getTest(List.create([1]), 0, 1);
+                getTest(List.create([1, 2]), 0, 1);
+                getTest(List.create([1, 2]), 1, 2);
+            });
+
+            runner.testFunction("add(T)", () =>
+            {
+                function addTest(list: List<number>, value: number, expected: number[]): void
+                {
+                    runner.test(`with ${runner.andList([list, value])}`, (test: Test) =>
+                    {
+                        const addResult: List<number> = list.add(value);
+                        test.assertSame(addResult, list);
+                        test.assertEqual(list.toArray().await(), expected);
+                    });
+                }
+
+                addTest(List.create(), 1, [1]);
+                addTest(List.create([1]), 2, [1, 2]);
+                addTest(List.create([1, 2]), 3, [1, 2, 3]);
+            });
+
+            runner.testFunction("addAll(T)", () =>
+            {
+                function addAllTest(list: List<number>, values: JavascriptIterable<number>, expected: number[]): void
+                {
+                    runner.test(`with ${runner.andList([list, values])}`, (test: Test) =>
+                    {
+                        const addResult: List<number> = list.addAll(values);
+                        test.assertSame(addResult, list);
+                        test.assertEqual(list.toArray().await(), expected);
+                    });
+                }
+
+                addAllTest(List.create(), [1], [1]);
+                addAllTest(List.create([1]), [2], [1, 2]);
+                addAllTest(List.create([1, 2]), [3], [1, 2, 3]);
+                addAllTest(List.create(), [1, 2], [1, 2]);
+                addAllTest(List.create([1]), [2, 3], [1, 2, 3]);
+                addAllTest(List.create([1, 2]), [3, 4], [1, 2, 3, 4]);
+
+                addAllTest(List.create(), List.create([1]), [1]);
+                addAllTest(List.create([1]), List.create([2]), [1, 2]);
+                addAllTest(List.create([1, 2]), List.create([3]), [1, 2, 3]);
+                addAllTest(List.create(), List.create([1, 2]), [1, 2]);
+                addAllTest(List.create([1]), List.create([2, 3]), [1, 2, 3]);
+                addAllTest(List.create([1, 2]), List.create([3, 4]), [1, 2, 3, 4]);
+            });
+
+            runner.testFunction("insert(number,T)", () =>
+            {
+                function insertErrorTest(list: List<number>, index: number, value: number, expected: Error): void
+                {
+                    runner.test(`with ${runner.andList([list, index, value])}`, (test: Test) =>
+                    {
+                        const backupList: List<number> = List.create(list);
+                        test.assertThrows(() => list.insert(index, value), expected);
+                        test.assertEqual(list, backupList);
+                    });
+                }
+
+                insertErrorTest(List.create(), -1, 1, new PreConditionError(
+                    "Expression: index",
+                    "Expected: 0",
+                    "Actual: -1"
+                ));
+                insertErrorTest(List.create(), 1, 1, new PreConditionError(
+                    "Expression: index",
+                    "Expected: 0",
+                    "Actual: 1"
+                ));
+                insertErrorTest(List.create([1]), -1, 1, new PreConditionError(
+                    "Expression: index",
+                    "Expected: between 0 and 1",
+                    "Actual: -1"
+                ));
+                insertErrorTest(List.create([1]), 2, 1, new PreConditionError(
+                    "Expression: index",
+                    "Expected: between 0 and 1",
+                    "Actual: 2"
+                ));
+
+                function insertTest(list: List<number>, index: number, value: number, expected: number[]): void
+                {
+                    runner.test(`with ${runner.andList([list, index, value])}`, (test: Test) =>
+                    {
+                        const insertResult: List<number> = list.insert(index, value);
+                        test.assertSame(insertResult, list);
+                        test.assertEqual(list.toArray().await(), expected);
+                    });
+                }
+
+                insertTest(List.create(), 0, 1, [1]);
+                insertTest(List.create([2]), 0, 1, [1, 2]);
+                insertTest(List.create([1]), 1, 2, [1, 2]);
+                insertTest(List.create([2, 3]), 0, 1, [1, 2, 3]);
+                insertTest(List.create([1, 3]), 1, 2, [1, 2, 3]);
+                insertTest(List.create([1, 2]), 2, 3, [1, 2, 3]);
+            });
+
+            runner.testFunction("insertAll(number,T)", () =>
+            {
+                function insertAllErrorTest(list: List<number>, index: number, values: number[] | Iterable<number>, expected: Error): void
+                {
+                    runner.test(`with ${runner.andList([list, index, values])}`, (test: Test) =>
+                    {
+                        const backupList: List<number> = List.create(list);
+                        test.assertThrows(() => list.insertAll(index, values), expected);
+                        test.assertEqual(list, backupList);
+                    });
+                }
+
+                insertAllErrorTest(List.create(), -1, [1], new PreConditionError(
+                    "Expression: index",
+                    "Expected: 0",
+                    "Actual: -1"
+                ));
+                insertAllErrorTest(List.create(), 1, [1], new PreConditionError(
+                    "Expression: index",
+                    "Expected: 0",
+                    "Actual: 1"
+                ));
+                insertAllErrorTest(List.create([1]), -1, [1], new PreConditionError(
+                    "Expression: index",
+                    "Expected: between 0 and 1",
+                    "Actual: -1"
+                ));
+                insertAllErrorTest(List.create([1]), 2, [1], new PreConditionError(
+                    "Expression: index",
+                    "Expected: between 0 and 1",
+                    "Actual: 2",
+                ));
+
+                function insertAllTest(list: List<number>, index: number, values: JavascriptIterable<number>, expected: number[]): void
+                {
+                    runner.test(`with ${runner.andList([list, index, values])}`, (test: Test) =>
+                    {
+                        const insertResult: List<number> = list.insertAll(index, values);
+                        test.assertSame(insertResult, list);
+                        test.assertEqual(list.toArray().await(), expected);
+                    });
+                }
+
+                insertAllTest(List.create(), 0, [], []);
+                insertAllTest(List.create(), 0, [1], [1]);
+                insertAllTest(List.create([2]), 0, [1], [1, 2]);
+                insertAllTest(List.create([1]), 1, [2], [1, 2]);
+                insertAllTest(List.create([2, 3]), 0, [1], [1, 2, 3]);
+                insertAllTest(List.create([1, 3]), 1, [2], [1, 2, 3]);
+                insertAllTest(List.create([1, 2]), 2, [3], [1, 2, 3]);
+                insertAllTest(List.create([3]), 0, [1, 2], [1, 2, 3]);
+                insertAllTest(List.create([1]), 1, [2, 3], [1, 2, 3]);
+                insertAllTest(List.create([1, 4]), 1, [2, 3], [1, 2, 3, 4]);
+
+                insertAllTest(List.create(), 0, List.create(), []);
+                insertAllTest(List.create(), 0, List.create([1]), [1]);
+                insertAllTest(List.create([2]), 0, List.create([1]), [1, 2]);
+                insertAllTest(List.create([1]), 1, List.create([2]), [1, 2]);
+                insertAllTest(List.create([2, 3]), 0, List.create([1]), [1, 2, 3]);
+                insertAllTest(List.create([1, 3]), 1, List.create([2]), [1, 2, 3]);
+                insertAllTest(List.create([1, 2]), 2, List.create([3]), [1, 2, 3]);
+                insertAllTest(List.create([3]), 0, List.create([1, 2]), [1, 2, 3]);
+                insertAllTest(List.create([1]), 1, List.create([2, 3]), [1, 2, 3]);
+                insertAllTest(List.create([1, 4]), 1, List.create([2, 3]), [1, 2, 3, 4]);
+            });
+        });
+    });
+}

package/tests/mapIteratorTests.ts

@@ -0,0 +1,55 @@
+import { Iterator } from "../sources/iterator";
+import { MapIterator } from "../sources/mapIterator";
+import { PreConditionError } from "../sources/preConditionError";
+import { Test } from "./test";
+import { TestRunner } from "./testRunner";
+
+export function test(runner: TestRunner): void
+{
+    runner.testFile("mapIterator.ts", () =>
+    {
+        runner.testType("MapIterator<TInput,TOutput>", () =>
+        {
+            runner.testFunction("create(Iterator<TInput>,(TInput)=>TOutput)", () =>
+            {
+                function createErrorTest<TInput,TOutput>(testName: string, innerIterator: Iterator<TInput>, mapping: (value: TInput) => TOutput, expected: Error): void
+                {
+                    runner.test(testName, (test: Test) =>
+                    {
+                        test.assertThrows(() => MapIterator.create(innerIterator, mapping), expected);
+                    });
+                }
+        
+                createErrorTest(
+                    "with undefined inputIterator",
+                    undefined!,
+                    (value: number) => value.toString(),
+                    new PreConditionError(
+                        "Expression: inputIterator",
+                        "Expected: not undefined and not null",
+                        "Actual: undefined",
+                    ));
+                createErrorTest(
+                    "with null inputIterator",
+                    null!,
+                    (value: number) => value.toString(),
+                    new PreConditionError(
+                        "Expression: inputIterator",
+                        "Expected: not undefined and not null",
+                        "Actual: null",
+                    ));
+        
+                runner.test("with valid values", (test: Test) =>
+                {
+                    const inputIterator: Iterator<number> = Iterator.create([1, 2, 3]);
+                    test.assertFalse(inputIterator.hasStarted());
+                    test.assertFalse(inputIterator.hasCurrent());
+        
+                    const iterator: MapIterator<number,string> = MapIterator.create(inputIterator, (value: number) => value.toString());
+                    test.assertFalse(iterator.hasStarted());
+                    test.assertFalse(iterator.hasCurrent());
+                });
+            });
+        });
+    });
+}

package/tests/mapTests.ts

@@ -0,0 +1,104 @@
+import { Iterator } from "../sources/iterator";
+import { JavascriptIterable } from "../sources/javascript";
+import { isMap, Map } from "../sources/map";
+import { MutableMap } from "../sources/mutableMap";
+import { NotFoundError } from "../sources/notFoundError";
+import { Test } from "./test";
+import { TestRunner } from "./testRunner";
+
+export function test(runner: TestRunner): void
+{
+    runner.testFile("map.ts", () =>
+    {
+        runner.testType("Map<TKey,TValue>", () =>
+        {
+            runner.testFunction("create()", (test: Test) =>
+            {
+                const map: MutableMap<number,string> = Map.create();
+                test.assertSame(map.getCount().await(), 0);
+            });
+
+            mapTests(runner, Map.create);
+        });
+    });
+}
+
+export function mapTests(runner: TestRunner, creator: () => Map<number,string>): void
+{
+    runner.testType("Map<TKey,TValue>", () =>
+    {
+        runner.testFunction("creator()", (test: Test) =>
+        {
+            test.assertNotUndefinedAndNotNull(creator);
+            
+            const map: Map<number,string> = creator();
+            test.assertNotUndefinedAndNotNull(map);
+            test.assertEqual(map.getCount().await(), 0);
+            test.assertTrue(isMap(map));
+        });
+
+        runner.testFunction("containsKey(TKey)", () =>
+        {
+            runner.test("when it doesn't contain the key", (test: Test) =>
+            {
+                const map: Map<number,string> = creator();
+
+                test.assertFalse(map.containsKey(50).await());
+            });
+        });
+
+        runner.testFunction("get(TKey)", () =>
+        {
+            runner.test("when it doesn't contain the key", (test: Test) =>
+            {
+                const map: Map<number,string> = creator();
+
+                test.assertThrows(() => map.get(1).await(),
+                    new NotFoundError(
+                        "The key 1 was not found in the map."));
+                test.assertEqual(map.getCount().await(), 0);
+            });
+        });
+
+        runner.testFunction("toString()", () =>
+        {
+            function toStringTest(map: Map<number,string>, expected: string): void
+            {
+                runner.test(`with ${runner.toString(map)}`, (test: Test) =>
+                {
+                    test.assertEqual(map.toString(), expected);
+                });
+            }
+
+            toStringTest(creator(), "{}");
+        });
+
+        runner.testFunction("iterateKeys()", () =>
+        {
+            function iterateKeysTests(map: Map<number,string>, expected: JavascriptIterable<number>): void
+            {
+                runner.test(`with ${runner.toString(map)}`, async (test: Test) =>
+                {
+                    const keyIterator: Iterator<number> = map.iterateKeys();
+                    test.assertEqual(await keyIterator.toArray(), [...expected]);
+                });
+            }
+
+            iterateKeysTests(creator(), []);
+        });
+
+        runner.testFunction("iterateValues()", () =>
+        {
+            function iterateValuesTests(map: Map<number,string>, expected: JavascriptIterable<string>): void
+            {
+                runner.test(`with ${runner.toString(map)}`, async (test: Test) =>
+                {
+                    const valueIterator: Iterator<string> = map.iterateValues();
+                    test.assertEqual(await valueIterator.toArray(), [...expected]);
+                });
+            }
+
+            iterateValuesTests(creator(), []);
+        });
+    });
+}