@everyonesoftware/common 12.0.0 → 14.0.0

package/outputs/tests/TokenizerTests.js

@@ -0,0 +1,100 @@
+import { Iterator, PreConditionError, Tokenizer } from "../sources/index.js";
+import { Token } from "../sources/Token.js";
+export function test(runner) {
+    runner.testFile("Tokenizer.ts", () => {
+        runner.testType("Tokenizer", () => {
+            runner.testFunction("create()", () => {
+                function createErrorTest(characters, expected) {
+                    runner.test(`with ${runner.toString(characters)}`, (test) => {
+                        test.assertThrows(() => Tokenizer.create(characters), expected);
+                    });
+                }
+                createErrorTest(undefined, new PreConditionError("Expression: characters", "Expected: not undefined and not null", "Actual: undefined"));
+                createErrorTest(null, new PreConditionError("Expression: characters", "Expected: not undefined and not null", "Actual: null"));
+                function createTest(characters) {
+                    runner.test(`with ${runner.toString(characters)}`, (test) => {
+                        const tokenizer = Tokenizer.create(Iterator.create(characters));
+                        test.assertNotUndefinedAndNotNull(tokenizer);
+                        test.assertFalse(tokenizer.hasStarted());
+                        test.assertFalse(tokenizer.hasCurrent());
+                    });
+                }
+                createTest("");
+                createTest("abc");
+            });
+            runner.testFunction("next()", () => {
+                function nextTest(text, expected) {
+                    runner.test(`with ${runner.toString(text)}`, (test) => {
+                        if (expected instanceof Token) {
+                            expected = [expected];
+                        }
+                        const tokenizer = Tokenizer.create(text);
+                        const tokens = tokenizer.toArray().await();
+                        test.assertEqual(expected, tokens);
+                        test.assertTrue(tokenizer.hasStarted());
+                        test.assertFalse(tokenizer.hasCurrent());
+                    });
+                }
+                nextTest("", []);
+                nextTest(" ", Token.whitespace(" "));
+                nextTest("\t", Token.whitespace("\t"));
+                nextTest("\n", Token.newLine());
+                nextTest("\r\n", Token.newLine("\r\n"));
+                nextTest("\r", Token.whitespace("\r"));
+                nextTest("(", Token.leftParenthesis());
+                nextTest(")", Token.rightParenthesis());
+                nextTest(".", Token.period());
+                nextTest("_", Token.underscore());
+                nextTest("a", Token.letters("a"));
+                nextTest("abcdef", Token.letters("abcdef"));
+                nextTest("1", Token.digits("1"));
+                nextTest("1234", Token.digits("1234"));
+                nextTest("/", Token.forwardSlash());
+                nextTest("\\", Token.backslash());
+                nextTest(":", Token.colon());
+                nextTest("*", Token.unknown("*"));
+                nextTest("  at ", [
+                    Token.whitespace("  "),
+                    Token.letters("at"),
+                    Token.whitespace(" "),
+                ]);
+                nextTest("  at _AssertTest.assertEqual (tests/assertTest.ts:76:16)", [
+                    Token.whitespace("  "),
+                    Token.letters("at"),
+                    Token.whitespace(" "),
+                    Token.underscore(),
+                    Token.letters("AssertTest"),
+                    Token.period(),
+                    Token.letters("assertEqual"),
+                    Token.whitespace(" "),
+                    Token.leftParenthesis(),
+                    Token.letters("tests"),
+                    Token.forwardSlash(),
+                    Token.letters("assertTest"),
+                    Token.period(),
+                    Token.letters("ts"),
+                    Token.colon(),
+                    Token.digits("76"),
+                    Token.colon(),
+                    Token.digits("16"),
+                    Token.rightParenthesis(),
+                ]);
+                nextTest("  at tests/TokenizerTests.ts:61:30", [
+                    Token.whitespace("  "),
+                    Token.letters("at"),
+                    Token.whitespace(" "),
+                    Token.letters("tests"),
+                    Token.forwardSlash(),
+                    Token.letters("TokenizerTests"),
+                    Token.period(),
+                    Token.letters("ts"),
+                    Token.colon(),
+                    Token.digits("61"),
+                    Token.colon(),
+                    Token.digits("30"),
+                ]);
+            });
+        });
+    });
+}
+//# sourceMappingURL=TokenizerTests.js.map

package/outputs/tests/TokenizerTests.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"TokenizerTests.js","sourceRoot":"","sources":["../../tests/TokenizerTests.ts"],"names":[],"mappings":"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"}

package/outputs/tests/assertTest.d.ts

@@ -0,0 +1,32 @@
+import { Type } from "../sources/types.js";
+import { Test } from "./test.js";
+import { SyncResult } from "../sources/syncResult.js";
+import { PromiseAsyncResult } from "../sources/promiseAsyncResult.js";
+import { JavascriptIterable } from "../sources/index.js";
+/**
+ * A {@link Test} type that uses the standard "assert" module to make assertions.
+ */
+export declare class AssertTest implements Test {
+    private constructor();
+    /**
+     * Create a new {@link AssertTest} object.
+     */
+    static create(): AssertTest;
+    fail(message: string): never;
+    assertUndefined(value: unknown): asserts value is undefined;
+    assertNotUndefined<T>(value: T): asserts value is NonNullable<T>;
+    assertNull(value: unknown): asserts value is null;
+    assertNotNull<T>(value: T): asserts value is NonNullable<T>;
+    assertNotUndefinedAndNotNull<T>(value: T): asserts value is NonNullable<T>;
+    assertNotEmpty(value: JavascriptIterable<unknown>): void;
+    assertSame<T>(left: T, right: T): void;
+    assertNotSame<T>(left: T, right: T): void;
+    assertEqual<T>(left: T, right: T, message?: string): void;
+    assertNotEqual<T>(left: T, right: T): void;
+    assertFalse(value: boolean): void;
+    assertTrue(value: boolean): void;
+    assertThrows(action: SyncResult<unknown> | (() => void), expectedError?: Error): void;
+    assertThrowsAsync(action: Promise<unknown> | (() => Promise<unknown>), expectedError: Error): PromiseAsyncResult<void>;
+    assertInstanceOf<T>(value: unknown, type: Type<T>, typeCheck?: (value: unknown) => value is T): asserts value is T;
+}
+//# sourceMappingURL=assertTest.d.ts.map

package/outputs/tests/assertTest.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"assertTest.d.ts","sourceRoot":"","sources":["../../tests/assertTest.ts"],"names":[],"mappings":"AAGA,OAAO,EAAc,IAAI,EAAE,MAAM,qBAAqB,CAAC;AACvD,OAAO,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC;AACjC,OAAO,EAAE,UAAU,EAAE,MAAM,0BAA0B,CAAC;AACtD,OAAO,EAAE,kBAAkB,EAAE,MAAM,kCAAkC,CAAC;AACtE,OAAO,EAAE,kBAAkB,EAAE,MAAM,qBAAqB,CAAC;AAEzD;;GAEG;AACH,qBAAa,UAAW,YAAW,IAAI;IAEnC,OAAO,eAEN;IAED;;OAEG;IACH,OAAc,MAAM,IAAI,UAAU,CAGjC;IAEM,IAAI,CAAC,OAAO,EAAE,MAAM,GAAG,KAAK,CAKlC;IAEM,eAAe,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CAAC,KAAK,IAAI,SAAS,CAGjE;IAEM,kBAAkB,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,GAAG,OAAO,CAAC,KAAK,IAAI,WAAW,CAAC,CAAC,CAAC,CAGtE;IAEM,UAAU,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CAAC,KAAK,IAAI,IAAI,CAGvD;IAEM,aAAa,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,GAAG,OAAO,CAAC,KAAK,IAAI,WAAW,CAAC,CAAC,CAAC,CAGjE;IAEM,4BAA4B,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,GAAG,OAAO,CAAC,KAAK,IAAI,WAAW,CAAC,CAAC,CAAC,CAGhF;IAEM,cAAc,CAAC,KAAK,EAAE,kBAAkB,CAAC,OAAO,CAAC,GAAG,IAAI,CAG9D;IAEM,UAAU,CAAC,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE,KAAK,EAAE,CAAC,GAAG,IAAI,CAG5C;IAEM,aAAa,CAAC,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE,KAAK,EAAE,CAAC,GAAG,IAAI,CAG/C;IAEM,WAAW,CAAC,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,OAAO,CAAC,EAAE,MAAM,GAAG,IAAI,CAG/D;IAEM,cAAc,CAAC,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE,KAAK,EAAE,CAAC,GAAG,IAAI,CAGhD;IAEM,WAAW,CAAC,KAAK,EAAE,OAAO,GAAG,IAAI,CAGvC;IAEM,UAAU,CAAC,KAAK,EAAE,OAAO,GAAG,IAAI,CAGtC;IAEM,YAAY,CAAC,MAAM,EAAE,UAAU,CAAC,OAAO,CAAC,GAAG,CAAC,MAAM,IAAI,CAAC,EAAE,aAAa,CAAC,EAAE,KAAK,GAAG,IAAI,CAQ3F;IAEM,iBAAiB,CAAC,MAAM,EAAE,OAAO,CAAC,OAAO,CAAC,GAAG,CAAC,MAAM,OAAO,CAAC,OAAO,CAAC,CAAC,EAAE,aAAa,EAAE,KAAK,GAAG,kBAAkB,CAAC,IAAI,CAAC,CAM5H;IAEM,gBAAgB,CAAC,CAAC,EAAE,KAAK,EAAE,OAAO,EAAE,IAAI,EAAE,IAAI,CAAC,CAAC,CAAC,EAAE,SAAS,CAAC,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,KAAK,IAAI,CAAC,GAAG,OAAO,CAAC,KAAK,IAAI,CAAC,CAGxH;CACJ"}

package/outputs/tests/assertTest.js

@@ -0,0 +1,75 @@
+import * as assert from "assert";
+import { PreCondition } from "../sources/preCondition.js";
+import { isFunction } from "../sources/types.js";
+import { Test } from "./test.js";
+import { PromiseAsyncResult } from "../sources/promiseAsyncResult.js";
+/**
+ * A {@link Test} type that uses the standard "assert" module to make assertions.
+ */
+export class AssertTest {
+    constructor() {
+    }
+    /**
+     * Create a new {@link AssertTest} object.
+     */
+    static create() {
+        return new AssertTest();
+    }
+    fail(message) {
+        PreCondition.assertNotEmpty(message, "message");
+        assert.fail(message);
+    }
+    assertUndefined(value) {
+        Test.assertUndefined(this, value);
+    }
+    assertNotUndefined(value) {
+        Test.assertNotUndefined(this, value);
+    }
+    assertNull(value) {
+        Test.assertNull(this, value);
+    }
+    assertNotNull(value) {
+        Test.assertNotNull(this, value);
+    }
+    assertNotUndefinedAndNotNull(value) {
+        Test.assertNotUndefinedAndNotNull(this, value);
+    }
+    assertNotEmpty(value) {
+        Test.assertNotEmpty(this, value);
+    }
+    assertSame(left, right) {
+        assert.strictEqual(left, right);
+    }
+    assertNotSame(left, right) {
+        assert.notStrictEqual(left, right);
+    }
+    assertEqual(left, right, message) {
+        assert.deepStrictEqual(left, right, message);
+    }
+    assertNotEqual(left, right) {
+        assert.notDeepStrictEqual(left, right);
+    }
+    assertFalse(value) {
+        Test.assertFalse(this, value);
+    }
+    assertTrue(value) {
+        Test.assertTrue(this, value);
+    }
+    assertThrows(action, expectedError) {
+        if (!isFunction(action)) {
+            const syncResult = action;
+            action = () => { syncResult.await(); };
+        }
+        assert.throws(action, expectedError);
+    }
+    assertThrowsAsync(action, expectedError) {
+        const promiseOrAsyncAction = isFunction(action)
+            ? async () => await action()
+            : action;
+        return PromiseAsyncResult.create(assert.rejects(promiseOrAsyncAction, expectedError));
+    }
+    assertInstanceOf(value, type, typeCheck) {
+        Test.assertInstanceOf(this, value, type, typeCheck);
+    }
+}
+//# sourceMappingURL=assertTest.js.map

package/outputs/tests/assertTest.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"assertTest.js","sourceRoot":"","sources":["../../tests/assertTest.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,MAAM,QAAQ,CAAC;AAEjC,OAAO,EAAE,YAAY,EAAE,MAAM,4BAA4B,CAAC;AAC1D,OAAO,EAAE,UAAU,EAAQ,MAAM,qBAAqB,CAAC;AACvD,OAAO,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC;AAEjC,OAAO,EAAE,kBAAkB,EAAE,MAAM,kCAAkC,CAAC;AAGtE;;GAEG;AACH,MAAM,OAAO,UAAU;IAEnB;IAEA,CAAC;IAED;;OAEG;IACI,MAAM,CAAC,MAAM;QAEhB,OAAO,IAAI,UAAU,EAAE,CAAC;IAC5B,CAAC;IAEM,IAAI,CAAC,OAAe;QAEvB,YAAY,CAAC,cAAc,CAAC,OAAO,EAAE,SAAS,CAAC,CAAC;QAEhD,MAAM,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;IACzB,CAAC;IAEM,eAAe,CAAC,KAAc;QAEjC,IAAI,CAAC,eAAe,CAAC,IAAI,EAAE,KAAK,CAAC,CAAC;IACtC,CAAC;IAEM,kBAAkB,CAAI,KAAQ;QAEjC,IAAI,CAAC,kBAAkB,CAAC,IAAI,EAAE,KAAK,CAAC,CAAC;IACzC,CAAC;IAEM,UAAU,CAAC,KAAc;QAE5B,IAAI,CAAC,UAAU,CAAC,IAAI,EAAE,KAAK,CAAC,CAAC;IACjC,CAAC;IAEM,aAAa,CAAI,KAAQ;QAE5B,IAAI,CAAC,aAAa,CAAC,IAAI,EAAE,KAAK,CAAC,CAAC;IACpC,CAAC;IAEM,4BAA4B,CAAI,KAAQ;QAE3C,IAAI,CAAC,4BAA4B,CAAC,IAAI,EAAE,KAAK,CAAC,CAAC;IACnD,CAAC;IAEM,cAAc,CAAC,KAAkC;QAEpD,IAAI,CAAC,cAAc,CAAC,IAAI,EAAE,KAAK,CAAC,CAAC;IACrC,CAAC;IAEM,UAAU,CAAI,IAAO,EAAE,KAAQ;QAElC,MAAM,CAAC,WAAW,CAAC,IAAI,EAAE,KAAK,CAAC,CAAC;IACpC,CAAC;IAEM,aAAa,CAAI,IAAO,EAAE,KAAQ;QAErC,MAAM,CAAC,cAAc,CAAC,IAAI,EAAE,KAAK,CAAC,CAAC;IACvC,CAAC;IAEM,WAAW,CAAI,IAAO,EAAE,KAAQ,EAAE,OAAgB;QAErD,MAAM,CAAC,eAAe,CAAC,IAAI,EAAE,KAAK,EAAE,OAAO,CAAC,CAAC;IACjD,CAAC;IAEM,cAAc,CAAI,IAAO,EAAE,KAAQ;QAEtC,MAAM,CAAC,kBAAkB,CAAC,IAAI,EAAE,KAAK,CAAC,CAAC;IAC3C,CAAC;IAEM,WAAW,CAAC,KAAc;QAE7B,IAAI,CAAC,WAAW,CAAC,IAAI,EAAE,KAAK,CAAC,CAAC;IAClC,CAAC;IAEM,UAAU,CAAC,KAAc;QAE5B,IAAI,CAAC,UAAU,CAAC,IAAI,EAAE,KAAK,CAAC,CAAC;IACjC,CAAC;IAEM,YAAY,CAAC,MAA0C,EAAE,aAAqB;QAEjF,IAAI,CAAC,UAAU,CAAC,MAAM,CAAC,EACvB,CAAC;YACG,MAAM,UAAU,GAAwB,MAAM,CAAC;YAC/C,MAAM,GAAG,GAAG,EAAE,GAAG,UAAU,CAAC,KAAK,EAAE,CAAC,CAAC,CAAC,CAAC;QAC3C,CAAC;QACD,MAAM,CAAC,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC,CAAC;IACzC,CAAC;IAEM,iBAAiB,CAAC,MAAmD,EAAE,aAAoB;QAE9F,MAAM,oBAAoB,GAAG,UAAU,CAAC,MAAM,CAAC;YAC3C,CAAC,CAAC,KAAK,IAAI,EAAE,CAAC,MAAM,MAAM,EAAE;YAC5B,CAAC,CAAC,MAAM,CAAC;QACb,OAAO,kBAAkB,CAAC,MAAM,CAAC,MAAM,CAAC,OAAO,CAAC,oBAAoB,EAAE,aAAa,CAAC,CAAC,CAAC;IAC1F,CAAC;IAEM,gBAAgB,CAAI,KAAc,EAAE,IAAa,EAAE,SAA0C;QAEhG,IAAI,CAAC,gBAAgB,CAAC,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,SAAS,CAAC,CAAC;IACxD,CAAC;CACJ"}

package/outputs/tests/assertTestTests.d.ts

@@ -0,0 +1,3 @@
+import { TestRunner } from "./testRunner.js";
+export declare function test(runner: TestRunner): void;
+//# sourceMappingURL=assertTestTests.d.ts.map

package/outputs/tests/assertTestTests.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"assertTestTests.d.ts","sourceRoot":"","sources":["../../tests/assertTestTests.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAE7C,wBAAgB,IAAI,CAAC,MAAM,EAAE,UAAU,GAAG,IAAI,CAqE7C"}

package/outputs/tests/assertTestTests.js

@@ -0,0 +1,49 @@
+import { AssertionError } from "assert";
+import { AssertTest } from "./assertTest.js";
+export function test(runner) {
+    runner.testFile("assertTest.ts", () => {
+        runner.testType("AssertTest", () => {
+            runner.testFunction("assertThrows()", () => {
+                runner.test("with throwing action", (test) => {
+                    const at = AssertTest.create();
+                    at.assertThrows(() => { throw new Error("abc"); }, new Error("abc"));
+                });
+                runner.test("with non-throwing action", (test) => {
+                    const at = AssertTest.create();
+                    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) => {
+                    const at = AssertTest.create();
+                    await at.assertThrowsAsync(() => { throw new Error("abc"); }, new Error("abc"));
+                });
+                runner.test("with throwing async action", async (test) => {
+                    const at = AssertTest.create();
+                    await at.assertThrowsAsync(async () => { throw new Error("abc"); }, new Error("abc"));
+                });
+                runner.test("with rejected Promise", async (test) => {
+                    const at = AssertTest.create();
+                    await at.assertThrowsAsync(Promise.reject(new Error("abc")), new Error("abc"));
+                });
+                runner.test("with throwing action that returns a rejected Promise", async (test) => {
+                    const at = AssertTest.create();
+                    await at.assertThrowsAsync(() => Promise.reject(new Error("abc")), new Error("abc"));
+                });
+                runner.test("with non-throwing async action", async (test) => {
+                    const at = AssertTest.create();
+                    await test.assertThrowsAsync(async () => await at.assertThrowsAsync(async () => { }, new Error("oops")), new AssertionError({
+                        message: "Missing expected rejection (Error).",
+                        operator: "rejects",
+                        expected: new Error("oops"),
+                    }));
+                });
+            });
+        });
+    });
+}
+//# sourceMappingURL=assertTestTests.js.map

package/outputs/tests/assertTestTests.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"assertTestTests.js","sourceRoot":"","sources":["../../tests/assertTestTests.ts"],"names":[],"mappings":"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"}

package/outputs/tests/basicTestSkip.d.ts

@@ -0,0 +1,20 @@
+import { TestSkip } from "./testSkip.js";
+/**
+ * A type that is used to mark that a test group or a test should be skipped.
+ */
+export declare class BasicTestSkip implements TestSkip {
+    private readonly shouldSkip;
+    private readonly message;
+    private constructor();
+    /**
+     * 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.
+     */
+    static create(shouldSkip?: boolean, message?: string): BasicTestSkip;
+    getShouldSkip(): boolean;
+    getMessage(): string;
+}
+//# sourceMappingURL=basicTestSkip.d.ts.map

package/outputs/tests/basicTestSkip.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"basicTestSkip.d.ts","sourceRoot":"","sources":["../../tests/basicTestSkip.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AAEzC;;GAEG;AACH,qBAAa,aAAc,YAAW,QAAQ;IAE1C,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAU;IACrC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAS;IAEjC,OAAO,eAMN;IAED;;;;;;OAMG;IACH,OAAc,MAAM,CAAC,UAAU,CAAC,EAAE,OAAO,EAAE,OAAO,CAAC,EAAE,MAAM,GAAG,aAAa,CAa1E;IAEM,aAAa,IAAI,OAAO,CAG9B;IAEM,UAAU,IAAI,MAAM,CAG1B;CACJ"}

package/outputs/tests/basicTestSkip.js

@@ -0,0 +1,36 @@
+import { PreCondition } from "../sources/preCondition.js";
+/**
+ * A type that is used to mark that a test group or a test should be skipped.
+ */
+export class BasicTestSkip {
+    shouldSkip;
+    message;
+    constructor(shouldSkip, message) {
+        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.
+     */
+    static create(shouldSkip, message) {
+        if (shouldSkip === undefined || shouldSkip === null) {
+            shouldSkip = true;
+        }
+        if (message === undefined || message === null) {
+            message = "";
+        }
+        return new BasicTestSkip(shouldSkip, message);
+    }
+    getShouldSkip() {
+        return this.shouldSkip;
+    }
+    getMessage() {
+        return this.message;
+    }
+}
+//# sourceMappingURL=basicTestSkip.js.map

package/outputs/tests/basicTestSkip.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"basicTestSkip.js","sourceRoot":"","sources":["../../tests/basicTestSkip.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,4BAA4B,CAAC;AAG1D;;GAEG;AACH,MAAM,OAAO,aAAa;IAEL,UAAU,CAAU;IACpB,OAAO,CAAS;IAEjC,YAAoB,UAAmB,EAAE,OAAe;QAEpD,YAAY,CAAC,4BAA4B,CAAC,OAAO,EAAE,SAAS,CAAC,CAAC;QAE9D,IAAI,CAAC,UAAU,GAAG,UAAU,CAAC;QAC7B,IAAI,CAAC,OAAO,GAAG,OAAO,CAAC;IAC3B,CAAC;IAED;;;;;;OAMG;IACI,MAAM,CAAC,MAAM,CAAC,UAAoB,EAAE,OAAgB;QAEvD,IAAI,UAAU,KAAK,SAAS,IAAI,UAAU,KAAK,IAAI,EACnD,CAAC;YACG,UAAU,GAAG,IAAI,CAAC;QACtB,CAAC;QAED,IAAI,OAAO,KAAK,SAAS,IAAI,OAAO,KAAK,IAAI,EAC7C,CAAC;YACG,OAAO,GAAG,EAAE,CAAC;QACjB,CAAC;QAED,OAAO,IAAI,aAAa,CAAC,UAAU,EAAE,OAAO,CAAC,CAAC;IAClD,CAAC;IAEM,aAAa;QAEhB,OAAO,IAAI,CAAC,UAAU,CAAC;IAC3B,CAAC;IAEM,UAAU;QAEb,OAAO,IAAI,CAAC,OAAO,CAAC;IACxB,CAAC;CACJ"}

package/outputs/tests/byteListStreamTests.d.ts

@@ -0,0 +1,3 @@
+import { TestRunner } from "./testRunner.js";
+export declare function test(runner: TestRunner): void;
+//# sourceMappingURL=byteListStreamTests.d.ts.map

package/outputs/tests/byteListStreamTests.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"byteListStreamTests.d.ts","sourceRoot":"","sources":["../../tests/byteListStreamTests.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAE7C,wBAAgB,IAAI,CAAC,MAAM,EAAE,UAAU,GAAG,IAAI,CA+X7C"}

package/outputs/tests/byteListStreamTests.js

@@ -0,0 +1,247 @@
+import { ByteListStream } from "../sources/byteListStream.js";
+import { EmptyError } from "../sources/emptyError.js";
+import { PreConditionError } from "../sources/preConditionError.js";
+export function test(runner) {
+    runner.testFile("byteListStream.ts", () => {
+        runner.testType("ByteListStream", () => {
+            runner.testFunction("create()", () => {
+                runner.test("with no arguments", (test) => {
+                    const stream = ByteListStream.create();
+                    test.assertNotUndefinedAndNotNull(stream);
+                    test.assertEqual(0, stream.getAvailableByteCount());
+                });
+                runner.test("with empty array", (test) => {
+                    const stream = ByteListStream.create([]);
+                    test.assertNotUndefinedAndNotNull(stream);
+                    test.assertEqual(0, stream.getAvailableByteCount());
+                });
+                runner.test("with non-empty array", (test) => {
+                    const stream = ByteListStream.create([1, 2, 3]);
+                    test.assertNotUndefinedAndNotNull(stream);
+                    test.assertEqual(3, stream.getAvailableByteCount());
+                });
+            });
+            runner.testFunction("writeBytes()", () => {
+                runner.test("with undefined bytes", (test) => {
+                    const stream = 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) => {
+                    const stream = 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) => {
+                    const stream = ByteListStream.create();
+                    test.assertEqual(0, stream.writeBytes([]).await());
+                    test.assertEqual(0, stream.getAvailableByteCount());
+                });
+                runner.test("with non-empty bytes", (test) => {
+                    const stream = ByteListStream.create();
+                    test.assertEqual(4, stream.writeBytes([1, 2, 3, 4]).await());
+                    test.assertEqual(4, stream.getAvailableByteCount());
+                    const bytes = 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) => {
+                    const stream = 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) => {
+                    const stream = 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) => {
+                    const stream = ByteListStream.create();
+                    const writeBytesResult = 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) => {
+                    const stream = ByteListStream.create();
+                    const writeBytesResult = stream.writeBytes([1, 2], 2).await();
+                    test.assertEqual(0, writeBytesResult);
+                    test.assertEqual(0, stream.getAvailableByteCount());
+                });
+                runner.test("with negative length", (test) => {
+                    const stream = 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) => {
+                    const stream = 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) => {
+                    const stream = ByteListStream.create();
+                    const writeBytesResult = 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) => {
+                        const stream = 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) => {
+                        const stream = ByteListStream.create();
+                        test.assertThrows(() => stream.readBytes(0).await(), new EmptyError());
+                        test.assertEqual(0, stream.getAvailableByteCount());
+                    });
+                    runner.test("with positive count", (test) => {
+                        const stream = 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) => {
+                        const stream = 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) => {
+                        const stream = ByteListStream.create([1, 2, 3]);
+                        const readBytesResult = stream.readBytes(0).await();
+                        test.assertEqual(new Uint8Array(), readBytesResult);
+                        test.assertEqual(3, stream.getAvailableByteCount());
+                    });
+                    runner.test("with positive count less than bytes available", (test) => {
+                        const stream = ByteListStream.create([1, 2, 3]);
+                        const readBytesResult = 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) => {
+                        const stream = ByteListStream.create([1, 2, 3]);
+                        const readBytesResult = 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) => {
+                        const stream = ByteListStream.create([1, 2, 3]);
+                        const readBytesResult = stream.readBytes(4).await();
+                        test.assertEqual(new Uint8Array([1, 2, 3]), readBytesResult);
+                        test.assertEqual(0, stream.getAvailableByteCount());
+                    });
+                    runner.test("with undefined output", (test) => {
+                        const stream = 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) => {
+                        const stream = 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) => {
+                        const stream = ByteListStream.create([1, 2, 3]);
+                        const output = new Uint8Array();
+                        const readBytesResult = 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) => {
+                        const stream = ByteListStream.create([1, 2, 3]);
+                        const output = new Uint8Array(1);
+                        const readBytesResult = 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) => {
+                        const stream = ByteListStream.create([1, 2, 3]);
+                        const output = new Uint8Array(3);
+                        const readBytesResult = 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) => {
+                        const stream = ByteListStream.create([1, 2, 3]);
+                        const output = new Uint8Array(5);
+                        const readBytesResult = 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) => {
+                        const stream = ByteListStream.create([1, 2, 3]);
+                        const output = 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) => {
+                        const stream = ByteListStream.create([1, 2, 3]);
+                        const output = 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) => {
+                        const stream = ByteListStream.create([1, 2, 3]);
+                        const output = 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) => {
+                        const stream = ByteListStream.create([1, 2, 3]);
+                        const output = 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) => {
+                        const stream = ByteListStream.create([1, 2, 3]);
+                        const output = 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) => {
+                        const stream = ByteListStream.create([1, 2, 3]);
+                        const output = 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) => {
+                        const stream = ByteListStream.create([1, 2, 3]);
+                        const output = 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) => {
+                        const stream = ByteListStream.create([1, 2, 3]);
+                        const output = 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) => {
+                        const stream = ByteListStream.create([1, 2, 3]);
+                        const output = 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());
+                    });
+                });
+            });
+        });
+    });
+}
+//# sourceMappingURL=byteListStreamTests.js.map