@everyonesoftware/common 1.0.0

package/tests/assertTest.ts

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

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

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

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

@@ -0,0 +1,27 @@
+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", () =>
+    {
+        
+        
+
+
+
+
+
+
+
+
+
+
+        
+    });
+}