@everyonesoftware/common 1.0.0

package/tests/generatorTests.ts

@@ -0,0 +1,86 @@
+import { Generator } from "../sources/generator";
+import { PreConditionError } from "../sources/preConditionError";
+import { Test } from "./test";
+import { TestRunner } from "./testRunner";
+import { iteratorTests } from "./iteratorTests";
+
+export function test(runner: TestRunner): void
+{
+    runner.testFile("generator.ts", () =>
+    {
+        runner.testType("Generator<T>", () =>
+        {
+            iteratorTests(runner, () => Generator.create(() => {}));
+
+            runner.testFunction("create()", () =>
+            {
+                runner.test("with undefined", (test: Test) =>
+                {
+                    test.assertThrows(() => Generator.create(undefined!), new PreConditionError(
+                        "Expression: generatorAction",
+                        "Expected: not undefined and not null",
+                        "Actual: undefined",
+                    ));
+                });
+
+                runner.test("with null", (test: Test) =>
+                {
+                    test.assertThrows(() => Generator.create(null!), new PreConditionError(
+                        "Expression: generatorAction",
+                        "Expected: not undefined and not null",
+                        "Actual: null",
+                    ));
+                });
+
+                runner.test("with function that doesn't add any return values or return a value", (test: Test) =>
+                {
+                    const generator: Generator<void> = Generator.create(() => {});
+                    test.assertNotUndefinedAndNotNull(generator);
+                    test.assertEqual([], generator.toArray().await());
+                });
+
+                runner.test("with function that returns a constant value", (test: Test) =>
+                {
+                    const generator: Generator<number> = Generator.create(() => 20);
+                    test.assertNotUndefinedAndNotNull(generator);
+                    test.assertEqual([20, 20, 20, 20], generator.take(4).toArray().await());
+                });
+
+                runner.test("with function that returns an incrementing value", (test: Test) =>
+                {
+                    let value: number = 20;
+                    const generator: Generator<number> = Generator.create(() => value++);
+                    test.assertNotUndefinedAndNotNull(generator);
+                    test.assertEqual([20, 21, 22, 23, 24], generator.take(5).toArray().await());
+                });
+
+                runner.test("with function that always adds a return value", (test: Test) =>
+                {
+                    const generator: Generator<number> = Generator.create(control => control.addValue(20));
+                    test.assertNotUndefinedAndNotNull(generator);
+                    test.assertEqual([20, 20, 20, 20], generator.take(4).toArray().await());
+                });
+
+                runner.test("with function that always adds multiple return values", (test: Test) =>
+                {
+                    const generator: Generator<number> = Generator.create(control => { control.addValues([20, 21, 22]); });
+                    test.assertNotUndefinedAndNotNull(generator);
+                    test.assertEqual([20, 21, 22, 20, 21], generator.take(5).toArray().await());
+                });
+
+                runner.test("with function that always adds a return value and returns a value", (test: Test) =>
+                {
+                    const generator: Generator<number> = Generator.create(control =>
+                    {
+                        control.addValue(20);
+                        test.assertTrue(control.hasCurrent());
+                        test.assertEqual(20, control.getCurrent());
+                        return 21;
+                    });
+                    test.assertNotUndefinedAndNotNull(generator);
+                    test.assertEqual([20, 21, 20, 21, 20], generator.take(5).toArray().await());
+                });
+            });
+        });
+    });
+}

package/tests/httpClientTests.ts

@@ -0,0 +1,18 @@
+import { HttpClient } from "../sources/httpClient";
+import { Test } from "./test";
+import { TestRunner } from "./testRunner";
+
+export function test(runner: TestRunner): void
+{
+    runner.testFile("httpClient.ts", () =>
+    {
+        runner.testType("HttpClient", () =>
+        {
+            runner.test("create()", (test: Test) =>
+            {
+                const client: HttpClient = HttpClient.create();
+                test.assertNotUndefinedAndNotNull(client);
+            });
+        });
+    });
+}

package/tests/inMemoryCharacterWriteStreamTests.ts

@@ -0,0 +1,117 @@
+import { InMemoryCharacterWriteStream } from "../sources/inMemoryCharacterWriteStream";
+import { SyncResult } from "../sources/syncResult";
+import { isUndefined } from "../sources/types";
+import * as characterWriteStreamTests from "./characterWriteStreamTests";
+import { Test } from "./test";
+import { TestRunner } from "./testRunner";
+
+export function test(runner: TestRunner): void
+{
+    runner.testFile("inMemoryCharacterWriteStream.ts", () =>
+    {
+        runner.testType("InMemoryCharacterWriteStream", () =>
+        {
+            characterWriteStreamTests.test(runner, InMemoryCharacterWriteStream.create);
+
+            runner.testFunction("create()", (test: Test) =>
+            {
+                const writeStream: InMemoryCharacterWriteStream = InMemoryCharacterWriteStream.create();
+                test.assertNotUndefinedAndNotNull(writeStream);
+                test.assertEqual("", writeStream.getWrittenText());
+                test.assertEqual("\n", writeStream.getNewlineSequence());
+            });
+
+            runner.testFunction("clearWrittenText()", (test: Test) =>
+            {
+                const writeStream = InMemoryCharacterWriteStream.create();
+
+                const result1: InMemoryCharacterWriteStream = writeStream.clearWrittenText();
+                test.assertSame(writeStream, result1);
+                test.assertEqual("", writeStream.getWrittenText());
+
+                writeStream.writeString("hello world!").await();
+                test.assertEqual("hello world!", writeStream.getWrittenText());
+
+                const result2: InMemoryCharacterWriteStream = writeStream.clearWrittenText();
+                test.assertSame(writeStream, result2);
+                test.assertEqual("", writeStream.getWrittenText());
+            });
+
+            runner.testFunction("setNewlineSequence()", (test: Test) =>
+            {
+                const writeStream = InMemoryCharacterWriteStream.create();
+
+                const result1: InMemoryCharacterWriteStream = writeStream.setNewlineSequence("e");
+                test.assertSame(writeStream, result1);
+                test.assertEqual("e", writeStream.getNewlineSequence());
+                test.assertEqual("", writeStream.getWrittenText());
+
+                const result2: SyncResult<number> = writeStream.writeString("ab");
+                test.assertEqual("ab", writeStream.getWrittenText());
+                for (let i = 0; i < 3; i++)
+                {
+                    test.assertEqual(2, result2.await());
+                    test.assertEqual("ab", writeStream.getWrittenText());
+                }
+
+                const result3: SyncResult<number> = writeStream.writeLine("cd");
+                test.assertEqual("abcde", writeStream.getWrittenText());
+                for (let i = 0; i < 3; i++)
+                {
+                    test.assertEqual(3, result3.await());
+                    test.assertEqual("abcde", writeStream.getWrittenText());
+                }
+            });
+
+            runner.testFunction("writeString()", () =>
+            {
+                function writeStringTest(text: string): void
+                {
+                    runner.test(`with ${runner.toString(text)}`, (test: Test) =>
+                    {
+                        const expectedWrittenText: string = text || "";
+                        const writeStream = InMemoryCharacterWriteStream.create();
+                        const result: number = writeStream.writeString(text).await();
+                        test.assertEqual(expectedWrittenText.length, result);
+                        test.assertEqual(expectedWrittenText, writeStream.getWrittenText());
+                    });
+                }
+
+                writeStringTest(undefined!);
+                writeStringTest(null!);
+                writeStringTest("");
+                writeStringTest("a");
+                writeStringTest("abc");
+            });
+
+            runner.testFunction("writeLine()", () =>
+            {
+                function writeLineTest(text: string, newlineSequence?: string): void
+                {
+                    runner.test(`with ${runner.toString(text)}${isUndefined(newlineSequence) ? "" : ` and ${runner.toString(newlineSequence)}`}`, (test: Test) =>
+                    {
+                        
+                        const writeStream = InMemoryCharacterWriteStream.create();
+                        if (!isUndefined(newlineSequence))
+                        {
+                            writeStream.setNewlineSequence(newlineSequence);
+                        }
+                        const expectedWrittenText: string = (text || "") + writeStream.getNewlineSequence();
+
+                        const result: number = writeStream.writeLine(text).await();
+                        test.assertEqual(expectedWrittenText.length, result);
+                        test.assertEqual(expectedWrittenText, writeStream.getWrittenText());
+                    });
+                }
+
+                writeLineTest(undefined!);
+                writeLineTest(null!);
+                writeLineTest("");
+                writeLineTest("a");
+                writeLineTest("abc");
+                writeLineTest("abc", "\r\n");
+                writeLineTest("abc", "");
+            });
+        });
+    });
+}

package/tests/iterableTests.ts

@@ -0,0 +1,141 @@
+import { Iterable } from "../sources/iterable";
+import { Test } from "./test";
+import { TestRunner } from "./testRunner";
+
+export function test(runner: TestRunner): void
+{
+    runner.testFile("iterable.ts", () =>
+    {
+        runner.testType("Iterable<T>", () =>
+        {
+            runner.testFunction("create(JavascriptIterable<T>|undefined)", () =>
+            {
+                runner.test("with no arguments", async (test: Test) =>
+                {
+                    const iterable: Iterable<number> = Iterable.create();
+                    test.assertNotUndefinedAndNotNull(iterable);
+                    test.assertEqual(await iterable.toArray(), []);
+                    test.assertEqual(await iterable.getCount(), 0);
+                });
+
+                runner.test("with empty array", async (test: Test) =>
+                {
+                    const iterable: Iterable<number> = Iterable.create<number>([]);
+                    test.assertNotUndefinedAndNotNull(iterable);
+                    test.assertEqual(await iterable.toArray(), []);
+                    test.assertEqual(await iterable.getCount(), 0);
+                });
+
+                runner.test("with non-empty array", async (test: Test) =>
+                {
+                    const iterable: Iterable<number> = Iterable.create([1, 2, 3]);
+                    test.assertNotUndefinedAndNotNull(iterable);
+                    test.assertEqual(await iterable.toArray(), [1, 2, 3]);
+                    test.assertEqual(await iterable.getCount(), 3);
+                });
+            });
+
+            runner.testGroup("concatenate()", () =>
+            {
+                runner.testGroup("empty and", () =>
+                {
+                    runner.test("empty", (test: Test) =>
+                    {
+                        const iterable: Iterable<number> = Iterable.create([]);
+                        const concatenateIterable: Iterable<number> = iterable.concatenate([]);
+                        test.assertEqual(concatenateIterable.toArray().await(), []);
+                    });
+
+                    runner.test("non-empty", (test: Test) =>
+                    {
+                        const iterable: Iterable<number> = Iterable.create([]);
+                        const concatenateIterable: Iterable<number> = iterable.concatenate([5]);
+                        test.assertEqual(concatenateIterable.toArray().await(), [5]);
+                    });
+
+                    runner.test("two non-emptys", (test: Test) =>
+                    {
+                        const iterable: Iterable<number> = Iterable.create([]);
+                        const concatenateIterable: Iterable<number> = iterable.concatenate([5], [6, 7]);
+                        test.assertEqual(concatenateIterable.toArray().await(), [5, 6, 7]);
+                    });
+                });
+
+                runner.testGroup("non-empty and", () =>
+                {
+                    runner.test("empty", (test: Test) =>
+                    {
+                        const iterable: Iterable<number> = Iterable.create([1, 2]);
+                        const concatenateIterable: Iterable<number> = iterable.concatenate([]);
+                        test.assertEqual(concatenateIterable.toArray().await(), [1, 2]);
+                    });
+
+                    runner.test("non-empty", (test: Test) =>
+                    {
+                        const iterable: Iterable<number> = Iterable.create([3]);
+                        const concatenateIterable: Iterable<number> = iterable.concatenate([4, 5, 6]);
+                        test.assertEqual(concatenateIterable.toArray().await(), [3, 4, 5, 6]);
+                    });
+
+                    runner.test("two non-emptys", (test: Test) =>
+                    {
+                        const iterable: Iterable<number> = Iterable.create([7, 8, 9]);
+                        const concatenateIterable: Iterable<number> = iterable.concatenate([10, 11, 12], [13]);
+                        test.assertEqual(concatenateIterable.toArray().await(), [7, 8, 9, 10, 11, 12, 13]);
+                    });
+                });
+            });
+
+            runner.testFunction("flatMap()", () =>
+            {
+                runner.test("with empty iterable", (test: Test) =>
+                {
+                    const iterable: Iterable<number> = Iterable.create([]);
+                    const flatMapIterable: Iterable<string> = iterable.flatMap((value: number) =>
+                    {
+                        const result: string[] = [];
+                        for (let i = 0; i < value; i++)
+                        {
+                            result.push(value.toString());
+                        }
+                        return result;
+                    });
+                    test.assertEqual(flatMapIterable.toArray().await(), []);
+                });
+
+                runner.test("with non-empty iterable", (test: Test) =>
+                {
+                    const iterable: Iterable<number> = Iterable.create([1, 2, 3]);
+                    const flatMapIterable: Iterable<string> = iterable.flatMap((value: number) =>
+                    {
+                        const result: string[] = [];
+                        for (let i = 0; i < value; i++)
+                        {
+                            result.push(value.toString());
+                        }
+                        return result;
+                    });
+                    test.assertEqual(flatMapIterable.toArray().await(), ["1", "2", "2", "3", "3", "3"]);
+                });
+
+                runner.test("with mapping that sometimes returns an empty iterable", (test: Test) =>
+                {
+                    const iterable: Iterable<number> = Iterable.create([1, 2, 3, 4]);
+                    const flatMapIterable: Iterable<string> = iterable.flatMap((value: number) =>
+                    {
+                        const result: string[] = [];
+                        if (value % 2 === 1)
+                        {
+                            for (let i = 0; i < value; i++)
+                            {
+                                result.push(value.toString());
+                            }
+                        }
+                        return result;
+                    });
+                    test.assertEqual(flatMapIterable.toArray().await(), ["1", "3", "3", "3"]);
+                });
+            });
+        });
+    });
+}