@everyonesoftware/common 3.0.0 → 5.0.0

package/tests/generatorTests.ts

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

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

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

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