@everyonesoftware/common 3.0.0 → 4.0.0

package/tests/assertTest.ts

@@ -1,113 +0,0 @@
-import * as assert from "assert";
-
-import { PreCondition } from "../sources/preCondition";
-import { isFunction, Type } from "../sources/types";
-import { Test } from "./test";
-import { SyncResult } from "../sources/syncResult";
-import { PromiseAsyncResult } from "../sources/promiseAsyncResult";
-
-/**
- * A {@link Test} type that uses the standard "assert" module to make assertions.
- */
-export class AssertTest implements Test
-{
-    private readonly name: string;
-
-    protected constructor(name: string)
-    {
-        this.name = name;
-    }
-
-    /**
-     * Create a new {@link AssertTest} object.
-     */
-    public static create(name: string): AssertTest
-    {
-        return new AssertTest(name);
-    }
-
-    public fail(message: string): never
-    {
-        PreCondition.assertNotEmpty(message, "message");
-
-        assert.fail(message);
-    }
-
-    public assertUndefined(value: unknown): asserts value is undefined
-    {
-        Test.assertUndefined(this, value);
-    }
-
-    public assertNotUndefined<T>(value: T): asserts value is NonNullable<T>
-    {
-        Test.assertNotUndefined(this, value);
-    }
-
-    public assertNull(value: unknown): asserts value is null
-    {
-        Test.assertNull(this, value);
-    }
-
-    public assertNotNull<T>(value: T): asserts value is NonNullable<T>
-    {
-        Test.assertNotNull(this, value);
-    }
-
-    public assertNotUndefinedAndNotNull<T>(value: T): asserts value is NonNullable<T>
-    {
-        Test.assertNotUndefinedAndNotNull(this, value);
-    }
-
-    public assertSame<T>(left: T, right: T): void
-    {
-        assert.strictEqual(left, right);
-    }
-
-    public assertNotSame<T>(left: T, right: T): void
-    {
-        assert.notStrictEqual(left, right);
-    }
-
-    public assertEqual<T>(left: T, right: T, message?: string): void
-    {
-        assert.deepStrictEqual(left, right, message);
-    }
-
-    public assertNotEqual<T>(left: T, right: T): void
-    {
-        assert.notDeepStrictEqual(left, right);
-    }
-
-    public assertFalse(value: boolean): void
-    {
-        Test.assertFalse(this, value);
-    }
-
-    public assertTrue(value: boolean): void
-    {
-        Test.assertTrue(this, value);
-    }
-
-    public assertThrows(action: SyncResult<unknown> | (() => void), expectedError?: Error): void
-    {
-        if (!isFunction(action))
-        {
-            const syncResult: SyncResult<unknown> = action;
-            action = () => { syncResult.await(); };
-        }
-        assert.throws(action, expectedError);
-    }
-
-    public assertThrowsAsync(action: Promise<unknown> | (() => Promise<unknown>), expectedError: Error): PromiseAsyncResult<void>
-    {
-        const promiseOrAsyncAction = isFunction(action)
-            ? async () => await action()
-            : action;
-        return PromiseAsyncResult.create(assert.rejects(promiseOrAsyncAction, expectedError));
-    }
-
-    public assertInstanceOf<T>(value: unknown, type: Type<T>, typeCheck?: (value: unknown) => value is T): asserts value is T
-    {
-        Test.assertInstanceOf(this, value, type, typeCheck);
-    }
-}

package/tests/assertTestTests.ts

@@ -1,75 +0,0 @@
-import { AssertionError } from "assert";
-import { AssertTest } from "./assertTest";
-import { Test } from "./test";
-import { TestRunner } from "./testRunner";
-
-export function test(runner: TestRunner): void
-{
-    runner.testFile("assertTest.ts", () =>
-    {
-        runner.testType("AssertTest", () =>
-        {
-            runner.testFunction("assertThrows()", () =>
-            {
-                runner.test("with throwing action", (test: Test) =>
-                {
-                    const at: AssertTest = AssertTest.create("fake-test-name");
-                    at.assertThrows(() => { throw new Error("abc"); }, new Error("abc"));
-                });
-
-                runner.test("with non-throwing action", (test: Test) =>
-                {
-                    const at: AssertTest = AssertTest.create("fake-test-name");
-                    test.assertThrows(
-                        () => at.assertThrows(() => {}, new Error("oops")),
-                        new AssertionError({
-                            message: "Missing expected exception (Error).",
-                            operator: "throws",
-                            expected: new Error("oops"),
-                        }),
-                    );
-                });
-            });
-
-            runner.testFunction("assertThrowsAsync()", () =>
-            {
-                runner.test("with throwing sync action", async (test: Test) =>
-                {
-                    const at: AssertTest = AssertTest.create("fake-test-name");
-                    await at.assertThrowsAsync(() => { throw new Error("abc"); }, new Error("abc"));
-                });
-
-                runner.test("with throwing async action", async (test: Test) =>
-                {
-                    const at: AssertTest = AssertTest.create("fake-test-name");
-                    await at.assertThrowsAsync(async () => { throw new Error("abc"); }, new Error("abc"));
-                });
-
-                runner.test("with rejected Promise", async (test: Test) =>
-                {
-                    const at: AssertTest = AssertTest.create("fake-test-name");
-                    await at.assertThrowsAsync(Promise.reject(new Error("abc")), new Error("abc"));
-                });
-
-                runner.test("with throwing action that returns a rejected Promise", async (test: Test) =>
-                {
-                    const at: AssertTest = AssertTest.create("fake-test-name");
-                    await at.assertThrowsAsync(() => Promise.reject(new Error("abc")), new Error("abc"));
-                });
-
-                runner.test("with non-throwing async action", async (test: Test) =>
-                {
-                    const at: AssertTest = AssertTest.create("fake-test-name");
-                    await test.assertThrowsAsync(
-                        async () => await at.assertThrowsAsync(async () => {}, new Error("oops")),
-                        new AssertionError({
-                            message: "Missing expected rejection (Error).",
-                            operator: "rejects",
-                            expected: new Error("oops"),
-                        }),
-                    );
-                });
-            });
-        });
-    });
-}

package/tests/basicTestSkip.ts

@@ -1,51 +0,0 @@
-import { PreCondition } from "../sources/preCondition";
-import { TestSkip } from "./testSkip";
-
-/**
- * A type that is used to mark that a test group or a test should be skipped.
- */
-export class BasicTestSkip implements TestSkip
-{
-    private readonly shouldSkip: boolean;
-    private readonly message: string;
-
-    private constructor(shouldSkip: boolean, message: string)
-    {
-        PreCondition.assertNotUndefinedAndNotNull(message, "message");
-
-        this.shouldSkip = shouldSkip;
-        this.message = message;
-    }
-
-    /**
-     * 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): BasicTestSkip
-    {
-        if (shouldSkip === undefined || shouldSkip === null)
-        {
-            shouldSkip = true;
-        }
-
-        if (message === undefined || message === null)
-        {
-            message = "";
-        }
-
-        return new BasicTestSkip(shouldSkip, message);
-    }
-
-    public getShouldSkip(): boolean
-    {
-        return this.shouldSkip;
-    }
-
-    public getMessage(): string
-    {
-        return this.message;
-    }
-}

package/tests/byteListStreamTests.ts

@@ -1,390 +0,0 @@
-import { ByteListStream } from "../sources/byteListStream";
-import { EmptyError } from "../sources/emptyError";
-import { PreConditionError } from "../sources/preConditionError";
-import { Test } from "./test";
-import { TestRunner } from "./testRunner";
-
-export function test(runner: TestRunner): void
-{
-    runner.testFile("byteListStream.ts", () =>
-    {
-        runner.testType("ByteListStream", () =>
-        {
-            runner.testFunction("create()", () =>
-            {
-                runner.test("with no arguments", (test: Test) =>
-                {
-                    const stream: ByteListStream = ByteListStream.create();
-                    test.assertNotUndefinedAndNotNull(stream);
-                    test.assertEqual(0, stream.getAvailableByteCount());
-                });
-
-                runner.test("with empty array", (test: Test) =>
-                {
-                    const stream: ByteListStream = ByteListStream.create([]);
-                    test.assertNotUndefinedAndNotNull(stream);
-                    test.assertEqual(0, stream.getAvailableByteCount());
-                });
-
-                runner.test("with non-empty array", (test: Test) =>
-                {
-                    const stream: ByteListStream = ByteListStream.create([1, 2, 3]);
-                    test.assertNotUndefinedAndNotNull(stream);
-                    test.assertEqual(3, stream.getAvailableByteCount());
-                });
-            });
-
-            runner.testFunction("writeBytes()", () =>
-            {
-                runner.test("with undefined bytes", (test: Test) =>
-                {
-                    const stream: ByteListStream = ByteListStream.create();
-                    test.assertThrows(() => stream.writeBytes(undefined!), new PreConditionError(
-                        "Expression: bytes",
-                        "Expected: not undefined and not null",
-                        "Actual: undefined",
-                    ));
-                    test.assertEqual(0, stream.getAvailableByteCount());
-                });
-
-                runner.test("with null bytes", (test: Test) =>
-                {
-                    const stream: ByteListStream = ByteListStream.create();
-                    test.assertThrows(() => stream.writeBytes(null!), new PreConditionError(
-                        "Expression: bytes",
-                        "Expected: not undefined and not null",
-                        "Actual: null",
-                    ));
-                    test.assertEqual(0, stream.getAvailableByteCount());
-                });
-
-                runner.test("with empty bytes", (test: Test) =>
-                {
-                    const stream: ByteListStream = ByteListStream.create();
-                    test.assertEqual(0, stream.writeBytes([]).await());
-                    test.assertEqual(0, stream.getAvailableByteCount());
-                });
-
-                runner.test("with non-empty bytes", (test: Test) =>
-                {
-                    const stream: ByteListStream = ByteListStream.create();
-
-                    test.assertEqual(4, stream.writeBytes([1, 2, 3, 4]).await());
-                    test.assertEqual(4, stream.getAvailableByteCount());
-
-                    const bytes: Uint8Array = stream.readBytes(10).await();
-                    test.assertNotUndefinedAndNotNull(bytes);
-                    test.assertEqual(4, bytes.length);
-                    test.assertEqual(new Uint8Array([1, 2, 3, 4]), bytes);
-                    test.assertEqual(0, stream.getAvailableByteCount());
-                });
-
-                runner.test("with negative startIndex", (test: Test) =>
-                {
-                    const stream: ByteListStream = ByteListStream.create();
-                    test.assertThrows(() => stream.writeBytes([1, 2], -1), new PreConditionError(
-                        "Expression: startIndex",
-                        "Expected: between 0 and 2",
-                        "Actual: -1",
-                    ));
-                    test.assertEqual(0, stream.getAvailableByteCount());
-                });
-
-                runner.test("with too large startIndex", (test: Test) =>
-                {
-                    const stream: ByteListStream = ByteListStream.create();
-                    test.assertThrows(() => stream.writeBytes([1, 2], 3), new PreConditionError(
-                        "Expression: startIndex",
-                        "Expected: between 0 and 2",
-                        "Actual: 3",
-                    ));
-                    test.assertEqual(0, stream.getAvailableByteCount());
-                });
-
-                runner.test("with valid non-zero startIndex", (test: Test) =>
-                {
-                    const stream: ByteListStream = ByteListStream.create();
-                    const writeBytesResult: number = stream.writeBytes([1, 2], 1).await();
-                    test.assertEqual(1, writeBytesResult);
-                    test.assertEqual(1, stream.getAvailableByteCount());
-
-                    test.assertEqual(new Uint8Array([2]), stream.readBytes(5).await());
-                    test.assertEqual(0, stream.getAvailableByteCount());
-                });
-
-                runner.test("with startIndex equal to bytes length", (test: Test) =>
-                {
-                    const stream: ByteListStream = ByteListStream.create();
-                    const writeBytesResult: number = stream.writeBytes([1, 2], 2).await();
-                    test.assertEqual(0, writeBytesResult);
-                    test.assertEqual(0, stream.getAvailableByteCount());
-                });
-
-                runner.test("with negative length", (test: Test) =>
-                {
-                    const stream: ByteListStream = ByteListStream.create();
-                    test.assertThrows(() => stream.writeBytes([1, 2], 0, -1), new PreConditionError(
-                        "Expression: length",
-                        "Expected: between 0 and 2",
-                        "Actual: -1",
-                    ));
-                    test.assertEqual(0, stream.getAvailableByteCount());
-                });
-
-                runner.test("with too large length", (test: Test) =>
-                {
-                    const stream: ByteListStream = ByteListStream.create();
-                    test.assertThrows(() => stream.writeBytes([1, 2], 0, 3), new PreConditionError(
-                        "Expression: length",
-                        "Expected: between 0 and 2",
-                        "Actual: 3",
-                    ));
-                    test.assertEqual(0, stream.getAvailableByteCount());
-                });
-
-                runner.test("with valid startIndex and length values", (test: Test) =>
-                {
-                    const stream: ByteListStream = ByteListStream.create();
-                    const writeBytesResult: number = stream.writeBytes([1, 2, 3, 4, 5], 2, 2).await();
-                    test.assertEqual(2, writeBytesResult);
-                    test.assertEqual(2, stream.getAvailableByteCount());
-
-                    test.assertEqual(new Uint8Array([3, 4]), stream.readBytes(50).await());
-                    test.assertEqual(0, stream.getAvailableByteCount());
-                });
-            });
-
-            runner.testFunction("readBytes()", () =>
-            {
-                runner.testGroup("with empty stream", () =>
-                {
-                    runner.test("with negative count", (test: Test) =>
-                    {
-                        const stream: ByteListStream = ByteListStream.create();
-                        test.assertThrows(() => stream.readBytes(-1).await(), new PreConditionError(
-                            "Expression: count",
-                            "Expected: greater than or equal to 0",
-                            "Actual: -1",
-                        ));
-                        test.assertEqual(0, stream.getAvailableByteCount());
-                    });
-
-                    runner.test("with zero count", (test: Test) =>
-                    {
-                        const stream: ByteListStream = ByteListStream.create();
-                        test.assertThrows(() => stream.readBytes(0).await(), new EmptyError());
-                        test.assertEqual(0, stream.getAvailableByteCount());
-                    });
-
-                    runner.test("with positive count", (test: Test) =>
-                    {
-                        const stream: ByteListStream = ByteListStream.create();
-                        test.assertThrows(() => stream.readBytes(1).await(), new EmptyError());
-                        test.assertEqual(0, stream.getAvailableByteCount());
-                    });
-                });
-
-                runner.testGroup("with non-empty stream", () =>
-                {
-                    runner.test("with negative count", (test: Test) =>
-                    {
-                        const stream: ByteListStream = ByteListStream.create([1, 2, 3]);
-                        test.assertThrows(() => stream.readBytes(-1).await(), new PreConditionError(
-                            "Expression: count",
-                            "Expected: greater than or equal to 0",
-                            "Actual: -1",
-                        ));
-                        test.assertEqual(3, stream.getAvailableByteCount());
-                    });
-
-                    runner.test("with zero count", (test: Test) =>
-                    {
-                        const stream: ByteListStream = ByteListStream.create([1, 2, 3]);
-                        const readBytesResult: Uint8Array = stream.readBytes(0).await();
-                        test.assertEqual(new Uint8Array(), readBytesResult);
-                        test.assertEqual(3, stream.getAvailableByteCount());
-                    });
-
-                    runner.test("with positive count less than bytes available", (test: Test) =>
-                    {
-                        const stream: ByteListStream = ByteListStream.create([1, 2, 3]);
-                        const readBytesResult: Uint8Array = stream.readBytes(2).await();
-                        test.assertEqual(new Uint8Array([1, 2]), readBytesResult);
-                        test.assertEqual(1, stream.getAvailableByteCount());
-                    });
-
-                    runner.test("with positive count equal to bytes available", (test: Test) =>
-                    {
-                        const stream: ByteListStream = ByteListStream.create([1, 2, 3]);
-                        const readBytesResult: Uint8Array = stream.readBytes(3).await();
-                        test.assertEqual(new Uint8Array([1, 2, 3]), readBytesResult);
-                        test.assertEqual(0, stream.getAvailableByteCount());
-                    });
-
-                    runner.test("with positive count greater than bytes available", (test: Test) =>
-                    {
-                        const stream: ByteListStream = ByteListStream.create([1, 2, 3]);
-                        const readBytesResult: Uint8Array = stream.readBytes(4).await();
-                        test.assertEqual(new Uint8Array([1, 2, 3]), readBytesResult);
-                        test.assertEqual(0, stream.getAvailableByteCount());
-                    });
-
-                    runner.test("with undefined output", (test: Test) =>
-                    {
-                        const stream: ByteListStream = ByteListStream.create([1, 2, 3]);
-                        test.assertThrows(() => stream.readBytes(undefined!), new PreConditionError(
-                            "Expression: output",
-                            "Expected: not undefined and not null",
-                            "Actual: undefined",
-                        ));
-                        test.assertEqual(3, stream.getAvailableByteCount());
-                    });
-
-                    runner.test("with null output", (test: Test) =>
-                    {
-                        const stream: ByteListStream = ByteListStream.create([1, 2, 3]);
-                        test.assertThrows(() => stream.readBytes(null!), new PreConditionError(
-                            "Expression: output",
-                            "Expected: not undefined and not null",
-                            "Actual: null",
-                        ));
-                        test.assertEqual(3, stream.getAvailableByteCount());
-                    });
-
-                    runner.test("with empty output", (test: Test) =>
-                    {
-                        const stream: ByteListStream = ByteListStream.create([1, 2, 3]);
-                        const output: Uint8Array = new Uint8Array();
-                        const readBytesResult: number = stream.readBytes(output).await();
-                        test.assertEqual(0, readBytesResult);
-                        test.assertEqual(output, new Uint8Array());
-                        test.assertEqual(3, stream.getAvailableByteCount());
-                    });
-
-                    runner.test("with output smaller than the available bytes", (test: Test) =>
-                    {
-                        const stream: ByteListStream = ByteListStream.create([1, 2, 3]);
-                        const output: Uint8Array = new Uint8Array(1);
-                        const readBytesResult: number = stream.readBytes(output).await();
-                        test.assertEqual(1, readBytesResult);
-                        test.assertEqual(output, new Uint8Array([1]));
-                        test.assertEqual(2, stream.getAvailableByteCount());
-                    });
-
-                    runner.test("with output equal to the available bytes", (test: Test) =>
-                    {
-                        const stream: ByteListStream = ByteListStream.create([1, 2, 3]);
-                        const output: Uint8Array = new Uint8Array(3);
-                        const readBytesResult: number = stream.readBytes(output).await();
-                        test.assertEqual(3, readBytesResult);
-                        test.assertEqual(output, new Uint8Array([1, 2, 3]));
-                        test.assertEqual(0, stream.getAvailableByteCount());
-                    });
-
-                    runner.test("with output larger than available bytes", (test: Test) =>
-                    {
-                        const stream: ByteListStream = ByteListStream.create([1, 2, 3]);
-                        const output: Uint8Array = new Uint8Array(5);
-                        const readBytesResult: number = stream.readBytes(output).await();
-                        test.assertEqual(3, readBytesResult);
-                        test.assertEqual(output, new Uint8Array([1, 2, 3, 0, 0]));
-                        test.assertEqual(0, stream.getAvailableByteCount());
-                    });
-
-                    runner.test("with negative startIndex", (test: Test) =>
-                    {
-                        const stream: ByteListStream = ByteListStream.create([1, 2, 3]);
-                        const output: Uint8Array = new Uint8Array(5);
-                        test.assertThrows(() => stream.readBytes(output, -1), new PreConditionError(
-                            "Expression: startIndex",
-                            "Expected: between 0 and 5",
-                            "Actual: -1",
-                        ));
-                        test.assertEqual(3, stream.getAvailableByteCount());
-                    });
-
-                    runner.test("with too large startIndex", (test: Test) =>
-                    {
-                        const stream: ByteListStream = ByteListStream.create([1, 2, 3]);
-                        const output: Uint8Array = new Uint8Array(5);
-                        test.assertThrows(() => stream.readBytes(output, 6), new PreConditionError(
-                            "Expression: startIndex",
-                            "Expected: between 0 and 5",
-                            "Actual: 6",
-                        ));
-                        test.assertEqual(3, stream.getAvailableByteCount());
-                    });
-
-                    runner.test("with startIndex with enough space to read the entire stream", (test: Test) =>
-                    {
-                        const stream: ByteListStream = ByteListStream.create([1, 2, 3]);
-                        const output: Uint8Array = new Uint8Array(5);
-                        test.assertEqual(3, stream.readBytes(output, 2).await());
-                        test.assertEqual(new Uint8Array([0, 0, 1, 2, 3]), output);
-                        test.assertEqual(0, stream.getAvailableByteCount());
-                    });
-
-                    runner.test("with startIndex with not enough space to read the entire stream", (test: Test) =>
-                    {
-                        const stream: ByteListStream = ByteListStream.create([1, 2, 3]);
-                        const output: Uint8Array = new Uint8Array(5);
-                        test.assertEqual(2, stream.readBytes(output, 3).await());
-                        test.assertEqual(new Uint8Array([0, 0, 0, 1, 2]), output);
-                        test.assertEqual(1, stream.getAvailableByteCount());
-                    });
-
-                    runner.test("with startIndex equal to output length", (test: Test) =>
-                    {
-                        const stream: ByteListStream = ByteListStream.create([1, 2, 3]);
-                        const output: Uint8Array = new Uint8Array(5);
-                        test.assertEqual(0, stream.readBytes(output, 5).await());
-                        test.assertEqual(new Uint8Array(5), output);
-                        test.assertEqual(3, stream.getAvailableByteCount());
-                    });
-
-                    runner.test("with negative count", (test: Test) =>
-                    {
-                        const stream: ByteListStream = ByteListStream.create([1, 2, 3]);
-                        const output: Uint8Array = new Uint8Array(5);
-                        test.assertThrows(() => stream.readBytes(output, 1, -1), new PreConditionError(
-                            "Expression: count",
-                            "Expected: between 0 and 4",
-                            "Actual: -1",
-                        ));
-                        test.assertEqual(3, stream.getAvailableByteCount());
-                    });
-
-                    runner.test("with count larger than output.length - startIndex", (test: Test) =>
-                    {
-                        const stream: ByteListStream = ByteListStream.create([1, 2, 3]);
-                        const output: Uint8Array = new Uint8Array(5);
-                        test.assertThrows(() => stream.readBytes(output, 1, 5), new PreConditionError(
-                            "Expression: count",
-                            "Expected: between 0 and 4",
-                            "Actual: 5",
-                        ));
-                        test.assertEqual(3, stream.getAvailableByteCount());
-                    });
-
-                    runner.test("with startIndex with enough space to read the entire stream", (test: Test) =>
-                    {
-                        const stream: ByteListStream = ByteListStream.create([1, 2, 3]);
-                        const output: Uint8Array = new Uint8Array(5);
-                        test.assertEqual(3, stream.readBytes(output, 2, 3).await());
-                        test.assertEqual(new Uint8Array([0, 0, 1, 2, 3]), output);
-                        test.assertEqual(0, stream.getAvailableByteCount());
-                    });
-
-                    runner.test("with startIndex with not enough space to read the entire stream", (test: Test) =>
-                    {
-                        const stream: ByteListStream = ByteListStream.create([1, 2, 3]);
-                        const output: Uint8Array = new Uint8Array(5);
-                        test.assertEqual(1, stream.readBytes(output, 3, 1).await());
-                        test.assertEqual(new Uint8Array([0, 0, 0, 1, 0]), output);
-                        test.assertEqual(2, stream.getAvailableByteCount());
-                    });
-                });
-            });
-        });
-    });
-}

package/tests/byteListTests.ts

@@ -1,27 +0,0 @@
-import { ByteList } from "../sources/byteList";
-import { EqualFunctions } from "../sources/equalFunctions";
-import { NotFoundError } from "../sources/notFoundError";
-import { PreConditionError } from "../sources/preConditionError";
-import { isNumber } from "../sources/types";
-import { Test } from "./test";
-import { TestRunner } from "./testRunner";
-
-export function test(runner: TestRunner): void
-{
-    runner.testFile("byteList.ts", () =>
-    {
-        
-        
-
-
-
-
-
-
-
-
-
-
-        
-    });
-}