@everyonesoftware/common 4.0.0 → 6.0.0

package/outputs/chunk-CHBOMCYM.js

@@ -0,0 +1,845 @@
+import {
+  CurrentProcess,
+  List,
+  NodeJSCharacterWriteStream,
+  PreCondition,
+  PromiseAsyncResult,
+  ToStringFunctions,
+  __export,
+  andList,
+  getName,
+  getParameterCount,
+  isBoolean,
+  isFunction,
+  isJavascriptIterable,
+  isPromise,
+  isString,
+  isUndefinedOrNull,
+  join
+} from "./chunk-5Z677JON.js";
+
+// tests/test.ts
+var Test = class _Test {
+  /**
+   * Assert that the provided value is undefined;
+   * @param value The value to check.
+   */
+  assertUndefined(value) {
+    _Test.assertUndefined(this, value);
+  }
+  /**
+   * Assert that the provided value is undefined.
+   * @param test The current {@link Test}.
+   * @param value The value to check.
+   */
+  static assertUndefined(test2, value) {
+    test2.assertSame(value, void 0);
+  }
+  /**
+   * Assert that the provided value is not undefined;
+   * @param value The value to check.
+   */
+  assertNotUndefined(value) {
+    _Test.assertNotUndefined(this, value);
+  }
+  /**
+   * Assert that the provided value is not undefined.
+   * @param test The current {@link Test}.
+   * @param value The value to check.
+   */
+  static assertNotUndefined(test2, value) {
+    test2.assertNotSame(value, void 0);
+  }
+  /**
+   * Assert that the provided value is null.
+   * @param value The value to check.
+   */
+  assertNull(value) {
+    _Test.assertNull(this, value);
+  }
+  /**
+   * Assert that the provided value is null.
+   * @param value The value to check.
+   */
+  static assertNull(test2, value) {
+    test2.assertSame(value, null);
+  }
+  /**
+   * Assert that the provided value is not null.
+   * @param value The value to check.
+   */
+  assertNotNull(value) {
+    _Test.assertNull(this, value);
+  }
+  /**
+   * Assert that the provided value is not null.
+   * @param value The value to check.
+   */
+  static assertNotNull(test2, value) {
+    test2.assertNotSame(value, null);
+  }
+  /**
+   * Assert that the provided value is not undefined and not null.
+   * @param value The value to check.
+   */
+  assertNotUndefinedAndNotNull(value) {
+    _Test.assertNotUndefinedAndNotNull(this, value);
+  }
+  /**
+   * Assert that the provided value is not undefined and not null.
+   * @param value The value to check.
+   */
+  static assertNotUndefinedAndNotNull(test2, value) {
+    test2.assertNotSame(value, null);
+    test2.assertNotSame(value, void 0);
+  }
+  /**
+   * Assert that the provided value is false.
+   * @param value The value to check.
+   */
+  assertFalse(value) {
+    _Test.assertFalse(this, value);
+  }
+  /**
+   * Assert that the provided value is false.
+   * @param value The value to check.
+   */
+  static assertFalse(test2, value) {
+    PreCondition.assertNotUndefinedAndNotNull(test2, "test");
+    test2.assertSame(value, false);
+  }
+  /**
+   * Assert that the provided value is true.
+   * @param value The value to check.
+   */
+  assertTrue(value) {
+    _Test.assertTrue(this, value);
+  }
+  /**
+   * Assert that the provided value is true.
+   * @param value The value to check.
+   */
+  static assertTrue(test2, value) {
+    PreCondition.assertNotUndefinedAndNotNull(test2, "test");
+    test2.assertSame(value, true);
+  }
+  /**
+   * Assert that the provided value is an instance of the provided {@link Type}.
+   * @param value The value to check.
+   * @param type The {@link Type} to check.
+   * @param expression The expression that produced the value.
+   * @param message An optional error message.
+   */
+  assertInstanceOf(value, type, typeCheck) {
+    return _Test.assertInstanceOf(this, value, type, typeCheck);
+  }
+  /**
+   * Assert that the provided value is an instance of the provided {@link Type}.
+   * @param value The value to check.
+   * @param type The {@link Type} to check.
+   * @param expression The expression that produced the value.
+   * @param message An optional error message.
+   */
+  static assertInstanceOf(test2, value, type, typeCheck) {
+    PreCondition.assertNotUndefinedAndNotNull(type, "type");
+    if (isUndefinedOrNull(typeCheck)) {
+      typeCheck = ((value2) => value2 instanceof type);
+    }
+    if (!typeCheck(value)) {
+      test2.fail(`Expected value to be of type ${type.name} but found ${value} instead.`);
+    }
+  }
+};
+
+// tests/assertTest.ts
+import * as assert from "assert";
+var AssertTest = class _AssertTest {
+  name;
+  constructor(name) {
+    this.name = name;
+  }
+  /**
+   * Create a new {@link AssertTest} object.
+   */
+  static create(name) {
+    return new _AssertTest(name);
+  }
+  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);
+  }
+  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);
+  }
+};
+
+// tests/assertTestTests.ts
+var assertTestTests_exports = {};
+__export(assertTestTests_exports, {
+  test: () => test
+});
+import { AssertionError } from "assert";
+function test(runner) {
+  runner.testFile("assertTest.ts", () => {
+    runner.testType("AssertTest", () => {
+      runner.testFunction("assertThrows()", () => {
+        runner.test("with throwing action", (test2) => {
+          const at = AssertTest.create("fake-test-name");
+          at.assertThrows(() => {
+            throw new Error("abc");
+          }, new Error("abc"));
+        });
+        runner.test("with non-throwing action", (test2) => {
+          const at = AssertTest.create("fake-test-name");
+          test2.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 (test2) => {
+          const at = AssertTest.create("fake-test-name");
+          await at.assertThrowsAsync(() => {
+            throw new Error("abc");
+          }, new Error("abc"));
+        });
+        runner.test("with throwing async action", async (test2) => {
+          const at = AssertTest.create("fake-test-name");
+          await at.assertThrowsAsync(async () => {
+            throw new Error("abc");
+          }, new Error("abc"));
+        });
+        runner.test("with rejected Promise", async (test2) => {
+          const at = 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 (test2) => {
+          const at = AssertTest.create("fake-test-name");
+          await at.assertThrowsAsync(() => Promise.reject(new Error("abc")), new Error("abc"));
+        });
+        runner.test("with non-throwing async action", async (test2) => {
+          const at = AssertTest.create("fake-test-name");
+          await test2.assertThrowsAsync(
+            async () => await at.assertThrowsAsync(async () => {
+            }, new Error("oops")),
+            new AssertionError({
+              message: "Missing expected rejection (Error).",
+              operator: "rejects",
+              expected: new Error("oops")
+            })
+          );
+        });
+      });
+    });
+  });
+}
+
+// tests/basicTestSkip.ts
+var BasicTestSkip = 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 === void 0 || shouldSkip === null) {
+      shouldSkip = true;
+    }
+    if (message === void 0 || message === null) {
+      message = "";
+    }
+    return new _BasicTestSkip(shouldSkip, message);
+  }
+  getShouldSkip() {
+    return this.shouldSkip;
+  }
+  getMessage() {
+    return this.message;
+  }
+};
+
+// tests/failedTest.ts
+var FailedTest = class _FailedTest {
+  fullTestNameParts;
+  error;
+  constructor(fullTestNameParts, error) {
+    PreCondition.assertNotEmpty(fullTestNameParts, "fullTestName");
+    PreCondition.assertNotUndefinedAndNotNull(error, "error");
+    this.fullTestNameParts = fullTestNameParts;
+    this.error = error;
+  }
+  static create(fullTestNameParts, error) {
+    return new _FailedTest(fullTestNameParts, error);
+  }
+  getFullTestNameParts() {
+    return this.fullTestNameParts;
+  }
+  getFullTestName() {
+    return join(" ", this.fullTestNameParts);
+  }
+  getError() {
+    return this.error;
+  }
+  getErrorMessage() {
+    return this.error instanceof Error && this.error.stack ? this.error.stack : `${this.error}`;
+  }
+};
+
+// tests/skippedTest.ts
+var SkippedTest = class _SkippedTest {
+  skip;
+  fullTestNameParts;
+  constructor(skip, fullTestNameParts) {
+    PreCondition.assertNotUndefinedAndNotNull(skip, "skip");
+    PreCondition.assertNotEmpty(fullTestNameParts, "fullTestNameParts");
+    this.skip = skip;
+    this.fullTestNameParts = fullTestNameParts;
+  }
+  static create(skip, fullTestNameParts) {
+    return new _SkippedTest(skip, fullTestNameParts);
+  }
+  getSkipMessage() {
+    return this.skip.getMessage();
+  }
+  getFullTestNameParts() {
+    return this.fullTestNameParts;
+  }
+  getFullTestName() {
+    return join(" ", this.fullTestNameParts);
+  }
+};
+
+// tests/testAction.ts
+var TestAction = class _TestAction {
+  parent;
+  name;
+  skip;
+  action;
+  constructor(parent, name, skip, action) {
+    PreCondition.assertNotUndefinedAndNotNull(name, "name");
+    PreCondition.assertNotUndefinedAndNotNull(action, "action");
+    this.parent = parent;
+    this.name = name;
+    this.skip = skip;
+    this.action = action;
+  }
+  static create(parent, name, skip, action) {
+    return new _TestAction(parent, name, skip, action);
+  }
+  getParent() {
+    return this.parent;
+  }
+  getName() {
+    return this.name;
+  }
+  getFullNameParts() {
+    const result = List.create();
+    if (this.parent) {
+      result.addAll(this.parent.getFullNameParts());
+    }
+    result.add(this.getName());
+    return result;
+  }
+  getFullName() {
+    return join(" ", this.getFullNameParts());
+  }
+  getSkip() {
+    return this.skip || this.parent?.getSkip();
+  }
+  shouldSkip() {
+    return !!this.getSkip()?.getShouldSkip();
+  }
+  getAction() {
+    return this.action;
+  }
+  runAsync() {
+    return this.action();
+  }
+};
+
+// tests/testSkip.ts
+var TestSkip = class {
+  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, message) {
+    return BasicTestSkip.create(shouldSkip, message);
+  }
+};
+
+// tests/testRunner.ts
+var TestRunner = class _TestRunner {
+  /**
+   * Get a {@link string} that concatenates the {@link string} representation of each
+   * of the provided values into an "and-list".
+   * @param values The values to concatenate.
+   */
+  andList(values) {
+    return _TestRunner.andList(this, values);
+  }
+  /**
+   * Get a {@link string} that concatenates the {@link string} representation of each
+   * of the provided values into an "and-list".
+   * @param values The values to concatenate.
+   */
+  static andList(runner, values) {
+    PreCondition.assertNotUndefinedAndNotNull(runner, "runner");
+    PreCondition.assertNotUndefinedAndNotNull(values, "values");
+    return andList(values.map((value) => runner.toString(value)));
+  }
+  /**
+   * Get the {@link string} representation of the provided value.
+   * @param value The value to get the {@link string} representation of.
+   */
+  toString(value) {
+    return _TestRunner.toString(this, value);
+  }
+  /**
+   * Get the {@link string} representation of the provided value.
+   * @param value The value to get the {@link string} representation of.
+   */
+  static toString(_runner, value) {
+    const toStringFunctions = ToStringFunctions.create();
+    return toStringFunctions.toString(value);
+  }
+  skip(messageOrShouldSkip, message) {
+    let shouldSkip;
+    if (!isBoolean(messageOrShouldSkip)) {
+      shouldSkip = true;
+      message = messageOrShouldSkip;
+    } else {
+      shouldSkip = messageOrShouldSkip;
+    }
+    return _TestRunner.skip(this, shouldSkip, message);
+  }
+  /**
+   * Create a {@link TestSkip} object that will prevent tests from being run.
+   * @param shouldSkip Whether these tests should be skipped.
+   * @param message The message that explains why the tests are being skipped.
+   */
+  static skip(_runner, shouldSkip, message) {
+    return TestSkip.create(shouldSkip, message);
+  }
+  static runTestAction(runner, name, skip, testAction) {
+    if (getParameterCount(testAction) === 0) {
+      runner.testGroup(name, skip, testAction);
+    } else {
+      runner.test(name, skip, testAction);
+    }
+  }
+  testFile(fileName, skipOrTestAction, testAction) {
+    _TestRunner.testFile(this, fileName, skipOrTestAction, testAction);
+  }
+  /**
+   * Create a test group that will test the provided file.
+   * @param runner The {@link TestRunner} that will run the tests.
+   * @param fileName The name of the file that is being tested.
+   * @param testAction The action that will run the tests.
+   */
+  static testFile(runner, fileName, skipOrTestAction, testAction) {
+    PreCondition.assertNotUndefinedAndNotNull(runner, "runner");
+    PreCondition.assertNotUndefinedAndNotNull(fileName, "fileName");
+    PreCondition.assertNotEmpty(fileName, "fileName");
+    let skip;
+    if (isFunction(skipOrTestAction)) {
+      PreCondition.assertUndefined(testAction, "testAction");
+      skip = void 0;
+      testAction = skipOrTestAction;
+    } else {
+      skip = skipOrTestAction;
+    }
+    PreCondition.assertNotUndefinedAndNotNull(testAction, "testAction");
+    _TestRunner.runTestAction(runner, fileName, skip, testAction);
+  }
+  testType(typeNameOrType, skipOrTestAction, testAction) {
+    _TestRunner.testType(this, typeNameOrType, skipOrTestAction, testAction);
+  }
+  /**
+   * Create a test group that will test the provided type.
+   * @param runner The {@link TestRunner} that will run the tests.
+   * @param type The {@link Type} or name of the type that is being tested.
+   * @param testAction The action that will run the tests.
+   */
+  static testType(runner, typeNameOrType, skipOrTestAction, testAction) {
+    PreCondition.assertNotUndefinedAndNotNull(runner, "runner");
+    PreCondition.assertNotUndefinedAndNotNull(typeNameOrType, "typeNameOrType");
+    let typeName;
+    if (isString(typeNameOrType)) {
+      typeName = typeNameOrType;
+    } else {
+      typeName = getName(typeNameOrType);
+    }
+    PreCondition.assertNotEmpty(typeName, "typeName");
+    let skip;
+    if (isFunction(skipOrTestAction)) {
+      PreCondition.assertUndefined(testAction, "testAction");
+      skip = void 0;
+      testAction = skipOrTestAction;
+    } else {
+      skip = skipOrTestAction;
+    }
+    PreCondition.assertNotUndefinedAndNotNull(testAction, "testAction");
+    _TestRunner.runTestAction(runner, typeName, skip, testAction);
+  }
+  testFunction(functionSignature, skipOrTestAction, testAction) {
+    _TestRunner.testFunction(this, functionSignature, skipOrTestAction, testAction);
+  }
+  /**
+   * Create a test group that will test the provided function.
+   * @param runner The {@link TestRunner} that will run the tests.
+   * @param functionSignature The signature of the function that is being tested.
+   * @param testAction The action that will run the tests.
+   */
+  static testFunction(runner, functionSignature, skipOrTestAction, testAction) {
+    PreCondition.assertNotUndefinedAndNotNull(runner, "runner");
+    PreCondition.assertNotEmpty(functionSignature, "functionSignature");
+    let skip;
+    if (isFunction(skipOrTestAction)) {
+      PreCondition.assertUndefined(testAction, "testAction");
+      skip = void 0;
+      testAction = skipOrTestAction;
+    } else {
+      skip = skipOrTestAction;
+    }
+    PreCondition.assertNotUndefinedAndNotNull(testAction, "testAction");
+    _TestRunner.runTestAction(runner, functionSignature, skip, testAction);
+  }
+};
+
+// tests/consoleTestRunner.ts
+var ConsoleTestRunner = class _ConsoleTestRunner extends TestRunner {
+  writeStream;
+  pendingActions;
+  pendingActionsInsertIndex;
+  currentTestAction;
+  currentTest;
+  passedTestCount;
+  skippedTests;
+  testFailures;
+  constructor() {
+    super();
+    this.writeStream = NodeJSCharacterWriteStream.create(process.stdout);
+    this.pendingActions = List.create();
+    this.pendingActionsInsertIndex = 0;
+    this.passedTestCount = 0;
+    this.skippedTests = List.create();
+    this.testFailures = List.create();
+  }
+  static create() {
+    return new _ConsoleTestRunner();
+  }
+  static run(testFunctionOrTestFunctions) {
+    let testFunction;
+    if (isFunction(testFunctionOrTestFunctions)) {
+      testFunction = testFunctionOrTestFunctions;
+    } else if (!isJavascriptIterable(testFunctionOrTestFunctions)) {
+      testFunction = testFunctionOrTestFunctions.test;
+    } else {
+      const testFunctions = testFunctionOrTestFunctions;
+      testFunction = async (runner) => {
+        for (const testFunction2 of testFunctions) {
+          if (isFunction(testFunction2)) {
+            await testFunction2(runner);
+          } else {
+            await testFunction2.test(runner);
+          }
+        }
+      };
+    }
+    return CurrentProcess.run(async (currentProcess) => {
+      const runner = _ConsoleTestRunner.create().setWriteStream(currentProcess.getOutputWriteStream());
+      await testFunction(runner);
+      await runner.runAsync();
+      await runner.printSummary();
+    });
+  }
+  setWriteStream(writeStream) {
+    PreCondition.assertNotUndefinedAndNotNull(writeStream, "writeStream");
+    this.writeStream = writeStream;
+    return this;
+  }
+  /**
+   * Get the number of {@link TestAction}s that have yet to be executed.
+   */
+  getPendingTestActionsCount() {
+    return this.pendingActions.getCount().await();
+  }
+  /**
+   * Get the index in the pending-{@link TestAction} stack that new {@link TestAction}s will be
+   * inserted at.
+   */
+  getPendingTestActionsInsertIndex() {
+    return this.pendingActionsInsertIndex;
+  }
+  /**
+   * Get the number of tests that have been skipped.
+   */
+  getSkippedTestCount() {
+    return this.skippedTests.getCount().await();
+  }
+  getSkippedTests() {
+    return this.skippedTests;
+  }
+  /**
+   * Get the number of tests that have passed.
+   */
+  getPassedTestCount() {
+    return this.passedTestCount;
+  }
+  getFailedTestCount() {
+    return this.testFailures.getCount().await();
+  }
+  getFailedTests() {
+    return this.testFailures;
+  }
+  /**
+   * Get the {@link TestAction} that is currently executing or undefined if no {@link TestAction}
+   * is executing.
+   */
+  getCurrentTestAction() {
+    return this.currentTestAction;
+  }
+  getCurrentTest() {
+    return this.currentTest;
+  }
+  assertNoCurrentTest() {
+    if (this.currentTest !== void 0) {
+      this.currentTest.fail("Can't start a new test group or a new test while running a test.");
+    }
+  }
+  beforeTest(fullTestNameParts) {
+    return PromiseAsyncResult.create(async () => {
+      await this.writeStream.writeString(join(" ", fullTestNameParts));
+    });
+  }
+  afterPassedTest() {
+    return PromiseAsyncResult.create(async () => {
+      await this.writeStream.writeLine(" - Passed");
+      this.passedTestCount++;
+    });
+  }
+  afterSkippedTest(fullTestNameParts, skip) {
+    PreCondition.assertNotEmpty(fullTestNameParts, "fullTestNameParts");
+    PreCondition.assertNotUndefinedAndNotNull(skip, "skip");
+    return PromiseAsyncResult.create(async () => {
+      this.skippedTests.add(SkippedTest.create(skip, fullTestNameParts));
+      await this.writeStream.writeLine(" - Skipped");
+    });
+  }
+  afterFailedTest(fullTestNameParts, error) {
+    PreCondition.assertNotEmpty(fullTestNameParts, "fullTestNameParts");
+    PreCondition.assertNotUndefinedAndNotNull(error, "error");
+    return PromiseAsyncResult.create(async () => {
+      this.testFailures.add(FailedTest.create(fullTestNameParts, error));
+      await this.writeStream.writeLine(" - Failed");
+    });
+  }
+  testGroup(testGroupName, skipOrTestAction, testAction) {
+    PreCondition.assertNotUndefinedAndNotNull(testGroupName, "testGroupName");
+    PreCondition.assertNotEmpty(testGroupName, "testGroupName");
+    let skip;
+    if (isFunction(skipOrTestAction)) {
+      PreCondition.assertUndefined(testAction, "testAction");
+      skip = void 0;
+      testAction = skipOrTestAction;
+    } else {
+      skip = skipOrTestAction;
+    }
+    PreCondition.assertNotUndefinedAndNotNull(testAction, "testAction");
+    this.assertNoCurrentTest();
+    this.pendingActions.insert(
+      this.pendingActionsInsertIndex,
+      TestAction.create(
+        this.getCurrentTestAction(),
+        testGroupName,
+        skip,
+        async () => {
+          const previousTestActionInsertIndex = this.pendingActionsInsertIndex;
+          this.pendingActionsInsertIndex = this.pendingActions.getCount().await();
+          const currentTestAction = this.getCurrentTestAction();
+          try {
+            await testAction();
+          } catch (error) {
+            await this.afterFailedTest(currentTestAction.getFullNameParts(), error);
+          } finally {
+            this.pendingActionsInsertIndex = previousTestActionInsertIndex;
+          }
+        }
+      )
+    );
+  }
+  test(testName, skipOrTestAction, testAction) {
+    PreCondition.assertNotUndefinedAndNotNull(testName, "testName");
+    PreCondition.assertNotEmpty(testName, "testName");
+    let skip;
+    if (isFunction(skipOrTestAction)) {
+      PreCondition.assertUndefined(testAction, "testAction");
+      skip = void 0;
+      testAction = skipOrTestAction;
+    } else {
+      skip = skipOrTestAction;
+    }
+    PreCondition.assertNotUndefinedAndNotNull(testAction, "testAction");
+    this.assertNoCurrentTest();
+    this.pendingActions.insert(
+      this.pendingActionsInsertIndex,
+      TestAction.create(
+        this.getCurrentTestAction(),
+        testName,
+        skip,
+        async () => {
+          const currentTestAction = this.getCurrentTestAction();
+          try {
+            await this.beforeTest(currentTestAction.getFullNameParts());
+            if (currentTestAction.shouldSkip()) {
+              await this.afterSkippedTest(currentTestAction.getFullNameParts(), currentTestAction.getSkip());
+            } else {
+              this.currentTest = AssertTest.create(testName);
+              try {
+                await testAction(this.currentTest);
+                await this.afterPassedTest();
+              } finally {
+                this.currentTest = void 0;
+              }
+            }
+          } catch (error) {
+            await this.afterFailedTest(currentTestAction.getFullNameParts(), error);
+          }
+        }
+      )
+    );
+  }
+  async runAsync() {
+    while (this.pendingActions.any().await()) {
+      this.currentTestAction = this.pendingActions.removeLast().await();
+      try {
+        const result = this.currentTestAction.runAsync();
+        if (isPromise(result)) {
+          await result;
+        }
+      } finally {
+        this.currentTestAction = void 0;
+      }
+    }
+  }
+  printSummary() {
+    return PromiseAsyncResult.create(async () => {
+      await this.writeStream.writeLine();
+      const skippedTests = this.getSkippedTests();
+      if (await skippedTests.any()) {
+        await this.writeStream.writeLine(`Skipped Tests:`);
+        let counter = 0;
+        for (const skippedTest of skippedTests) {
+          await this.writeStream.writeLine(`${++counter}) ${skippedTest.getFullTestName()}`);
+          const skipMessage = skippedTest.getSkipMessage();
+          if (skipMessage) {
+            await this.writeStream.writeLine(`  ${skipMessage}`);
+          }
+        }
+        await this.writeStream.writeLine();
+      }
+      const failedTests = this.getFailedTests();
+      if (await failedTests.any()) {
+        await this.writeStream.writeLine("Failed Tests:");
+        let counter = 0;
+        for (const failedTest of failedTests) {
+          await this.writeStream.writeLine(`${++counter}) ${failedTest.getFullTestName()}`);
+          await this.writeStream.writeLine(`  ${failedTest.getErrorMessage()}`);
+          await this.writeStream.writeLine();
+        }
+      }
+      const passedTestCount = this.getPassedTestCount();
+      if (passedTestCount > 0) {
+        await this.writeStream.writeLine(`Passed:  ${passedTestCount}`);
+      }
+      if (await skippedTests.any()) {
+        await this.writeStream.writeLine(`Skipped: ${skippedTests.getCount().await()}`);
+      }
+      if (await failedTests.any()) {
+        await this.writeStream.writeLine(`Failed:  ${failedTests.getCount().await()}`);
+      }
+    });
+  }
+};
+
+export {
+  Test,
+  AssertTest,
+  test,
+  assertTestTests_exports,
+  BasicTestSkip,
+  FailedTest,
+  SkippedTest,
+  TestAction,
+  TestSkip,
+  TestRunner,
+  ConsoleTestRunner
+};
+//# sourceMappingURL=chunk-CHBOMCYM.js.map