@everyonesoftware/common 5.0.0 → 7.0.0

package/outputs/chunk-VF6FBNAU.js

@@ -0,0 +1,1062 @@
+import {
+  ANSIStyles,
+  AsyncResult,
+  CurrentProcess,
+  IndentedCharacterWriteStream,
+  Iterable,
+  List,
+  Map,
+  NodeJSCharacterWriteStream,
+  NotFoundError,
+  PreCondition,
+  PromiseAsyncResult,
+  Stack,
+  ToStringFunctions,
+  __export,
+  andList,
+  getName,
+  getParameterCount,
+  isBoolean,
+  isFunction,
+  isJavascriptIterable,
+  isString,
+  isUndefinedOrNull,
+  join
+} from "./chunk-MMAX3IZF.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 collection is not undefined, not null, and not empty.
+   * @param value The value to check.
+   */
+  assertNotEmpty(value) {
+    _Test.assertNotEmpty(this, value);
+  }
+  static assertNotEmpty(test2, value) {
+    test2.assertNotUndefinedAndNotNull(value);
+    test2.assertTrue(Iterable.any(value).await());
+  }
+  /**
+   * Assert that the provided value is false.
+   * @param value The value to check.
+   */
+  assertFalse(value) {
+    _Test.assertFalse(this, value);
+  }
+  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);
+  }
+  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);
+  }
+};
+
+// 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 {
+  testAction;
+  error;
+  constructor(testAction, error) {
+    PreCondition.assertNotUndefinedAndNotNull(testAction, "testAction");
+    PreCondition.assertNotUndefinedAndNotNull(error, "error");
+    this.testAction = testAction;
+    this.error = error;
+  }
+  static create(testAction, error) {
+    return new _FailedTest(testAction, error);
+  }
+  getTestAction() {
+    return this.testAction;
+  }
+  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;
+  testAction;
+  constructor(skip, testAction) {
+    PreCondition.assertNotUndefinedAndNotNull(skip, "skip");
+    PreCondition.assertNotUndefinedAndNotNull(testAction, "testAction");
+    this.skip = skip;
+    this.testAction = testAction;
+  }
+  static create(skip, testAction) {
+    return new _SkippedTest(skip, testAction);
+  }
+  getSkipMessage() {
+    return this.skip.getMessage();
+  }
+  getTestAction() {
+    return this.testAction;
+  }
+};
+
+// tests/testAction.ts
+var TestAction = class _TestAction {
+  parent;
+  name;
+  type;
+  skip;
+  action;
+  constructor(parent, name, type, skip, action) {
+    PreCondition.assertNotUndefinedAndNotNull(name, "name");
+    PreCondition.assertNotEmpty(type, "type");
+    PreCondition.assertNotUndefinedAndNotNull(action, "action");
+    this.parent = parent;
+    this.name = name;
+    this.type = type;
+    this.skip = skip;
+    this.action = action;
+  }
+  static create(parent, name, type, skip, action) {
+    return new _TestAction(parent, name, type, 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());
+  }
+  getType() {
+    return this.type;
+  }
+  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);
+  }
+};
+
+// tests/ConsoleTestRunnerUI.ts
+var ConsoleTestRunnerUI = class {
+  writeStream;
+  styles;
+  constructor() {
+    this.styles = Map.create();
+  }
+  static flat() {
+    return FlatConsoleTestRunnerUI.create();
+  }
+  static tree() {
+    return TreeConsoleTestRunnerUI.create();
+  }
+  setWriteStream(writeStream) {
+    PreCondition.assertNotUndefinedAndNotNull(writeStream, "writeStream");
+    this.writeStream = IndentedCharacterWriteStream.create(writeStream);
+    return this;
+  }
+  setStyle(style, styleFunction) {
+    PreCondition.assertNotEmpty(style, "style");
+    PreCondition.assertNotUndefinedAndNotNull(styleFunction, "styleFunction");
+    this.styles.set(style, styleFunction);
+    return this;
+  }
+  setStyles(styles) {
+    PreCondition.assertNotUndefinedAndNotNull(styles, "styles");
+    for (const entry of Object.entries(styles)) {
+      this.setStyle(entry[0], entry[1]);
+    }
+    return this;
+  }
+  applyStyle(style, text) {
+    PreCondition.assertNotEmpty(style, "style");
+    PreCondition.assertNotUndefinedAndNotNull(text, "text");
+    const styleFunction = this.styles.get(style).catch(NotFoundError, () => {
+      return (text2) => text2;
+    }).await();
+    return styleFunction(text);
+  }
+  addIndentation() {
+    this.writeStream?.addIndentation();
+  }
+  removeIndentation() {
+    this.writeStream?.removeIndentation();
+  }
+  indent(action) {
+    return this.writeStream?.indent(action) ?? AsyncResult.value(0);
+  }
+  writeString(text) {
+    return this.writeStream?.writeString(text) ?? AsyncResult.value(0);
+  }
+  writeLine(text) {
+    return this.writeStream?.writeLine(text) ?? AsyncResult.value(0);
+  }
+  writeTestActionName(testAction) {
+    return this.writeString(this.applyStyle(testAction.getType(), testAction.getName()));
+  }
+  writeFullTestActionName(testAction) {
+    return AsyncResult.create(async () => {
+      let result = 0;
+      const testActionStack = Stack.create();
+      let currentTestAction = testAction;
+      while (currentTestAction) {
+        testActionStack.add(currentTestAction);
+        currentTestAction = currentTestAction.getParent();
+      }
+      while (await testActionStack.any()) {
+        currentTestAction = await testActionStack.remove();
+        if (currentTestAction.getParent()) {
+          result += await this.writeString(" ");
+        }
+        result += await this.writeTestActionName(currentTestAction);
+      }
+      return result;
+    });
+  }
+  beforeTestGroup(testGroup) {
+    PreCondition.assertNotUndefinedAndNotNull(testGroup, "testGroup");
+    return AsyncResult.empty();
+  }
+  afterTestGroup(testGroup) {
+    PreCondition.assertNotUndefinedAndNotNull(testGroup, "testGroup");
+    return AsyncResult.empty();
+  }
+  beforeTest(testAction) {
+    return AsyncResult.empty();
+  }
+  afterPassedTest(testAction) {
+    return AsyncResult.create(async () => {
+      await this.writeLine(` - ${this.applyStyle("passed", "Passed")}`);
+    });
+  }
+  afterSkippedTest(testAction, skip) {
+    PreCondition.assertNotUndefinedAndNotNull(testAction, "testAction");
+    PreCondition.assertNotUndefinedAndNotNull(skip, "skip");
+    return AsyncResult.create(async () => {
+      await this.writeLine(` - ${this.applyStyle("skipped", "Skipped")}`);
+    });
+  }
+  afterFailedTest(currentTestAction, error) {
+    PreCondition.assertNotUndefinedAndNotNull(currentTestAction, "currentTestAction");
+    PreCondition.assertNotUndefinedAndNotNull(error, "error");
+    return AsyncResult.create(async () => {
+      await this.writeLine(` - ${this.applyStyle("failed", "Failed")}`);
+    });
+  }
+  writeSummary(passedTestCount, skippedTests, failedTests) {
+    PreCondition.assertGreaterThanOrEqualTo(passedTestCount, 0, "passedTestCount");
+    PreCondition.assertNotUndefinedAndNotNull(skippedTests, "skippedTests");
+    PreCondition.assertNotUndefinedAndNotNull(failedTests, "failedTests");
+    return AsyncResult.create(async () => {
+      await this.writeLine();
+      if (await skippedTests.any()) {
+        await this.writeLine(`${this.applyStyle("skipped", "Skipped Tests")}:`);
+        let counter = 0;
+        for (const skippedTest of skippedTests) {
+          await this.writeString(`${++counter}) `);
+          await this.writeFullTestActionName(skippedTest.getTestAction());
+          await this.writeLine();
+          const skipMessage = skippedTest.getSkipMessage();
+          if (skipMessage) {
+            await this.indent(() => this.writeLine(skipMessage));
+          }
+        }
+        await this.writeLine();
+      }
+      if (await failedTests.any()) {
+        await this.writeLine(`${this.applyStyle("failed", "Failed Tests")}:`);
+        let counter = 0;
+        for (const failedTest of failedTests) {
+          await this.writeString(`${++counter}) `);
+          await this.writeFullTestActionName(failedTest.getTestAction());
+          await this.writeLine();
+          await this.indent(() => this.writeLine(failedTest.getErrorMessage()));
+          await this.writeLine();
+        }
+      }
+      if (passedTestCount > 0) {
+        await this.writeLine(`${this.applyStyle("passed", "Passed")}:  ${passedTestCount}`);
+      }
+      if (await skippedTests.any()) {
+        await this.writeLine(`${this.applyStyle("skipped", "Skipped")}: ${skippedTests.getCount().await()}`);
+      }
+      if (await failedTests.any()) {
+        await this.writeLine(`${this.applyStyle("failed", "Failed")}:  ${failedTests.getCount().await()}`);
+      }
+    });
+  }
+};
+var FlatConsoleTestRunnerUI = class _FlatConsoleTestRunnerUI extends ConsoleTestRunnerUI {
+  constructor() {
+    super();
+  }
+  static create() {
+    return new _FlatConsoleTestRunnerUI();
+  }
+  beforeTest(testAction) {
+    return AsyncResult.create(async () => {
+      await this.writeFullTestActionName(testAction);
+    });
+  }
+};
+var TreeConsoleTestRunnerUI = class _TreeConsoleTestRunnerUI extends ConsoleTestRunnerUI {
+  testActions;
+  testActionWrittenDepth;
+  constructor() {
+    super();
+    this.testActions = List.create();
+    this.testActionWrittenDepth = 0;
+  }
+  static create() {
+    return new _TreeConsoleTestRunnerUI();
+  }
+  beforeTestGroup(testGroup) {
+    return AsyncResult.create(() => {
+      this.testActions.add(testGroup);
+    });
+  }
+  afterTestGroup(testGroup) {
+    PreCondition.assertNotUndefinedAndNotNull(testGroup, "testGroup");
+    PreCondition.assertTrue(this.testActions.any().await(), "this.testActions.any().await()");
+    return AsyncResult.create(() => {
+      this.testActions.removeLast().await();
+      const testActionCount = this.testActions.getCount().await();
+      if (this.testActionWrittenDepth > testActionCount) {
+        this.testActionWrittenDepth--;
+        this.removeIndentation();
+      }
+    });
+  }
+  beforeTest(testAction) {
+    PreCondition.assertNotUndefinedAndNotNull(testAction, "testAction");
+    return AsyncResult.create(async () => {
+      const testActionCount = this.testActions.getCount().await();
+      while (this.testActionWrittenDepth < testActionCount) {
+        const testGroup = this.testActions.get(this.testActionWrittenDepth).await();
+        await this.writeTestActionName(testGroup);
+        await this.writeLine();
+        this.addIndentation();
+        this.testActionWrittenDepth++;
+      }
+      await this.writeTestActionName(testAction);
+    });
+  }
+};
+
+// tests/consoleTestRunner.ts
+var ConsoleTestRunner = class _ConsoleTestRunner {
+  writeStream;
+  testActions;
+  testActionInsertIndex;
+  currentTestAction;
+  currentTest;
+  passedTestCount;
+  skippedTests;
+  testFailures;
+  ui;
+  constructor(ui) {
+    this.writeStream = IndentedCharacterWriteStream.create(NodeJSCharacterWriteStream.create(process.stdout));
+    this.testActions = List.create();
+    this.testActionInsertIndex = 0;
+    this.passedTestCount = 0;
+    this.skippedTests = List.create();
+    this.testFailures = List.create();
+    this.ui = ui || ConsoleTestRunnerUI.tree();
+    this.ui.setWriteStream(this.writeStream);
+  }
+  static create(ui) {
+    return new _ConsoleTestRunner(ui);
+  }
+  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()).setStyles({
+        file: (t) => ANSIStyles.blue(t),
+        function: (t) => ANSIStyles.blue(t),
+        type: (t) => ANSIStyles.blue(t),
+        group: (t) => ANSIStyles.blue(t),
+        passed: (t) => ANSIStyles.green(`\u2713 ${t}`),
+        skipped: (t) => ANSIStyles.yellow(`\u25CC ${t}`),
+        failed: (t) => ANSIStyles.red(`\u2717 ${t}`)
+      });
+      await testFunction(runner);
+      await runner.runAsync();
+      await runner.printSummary();
+    });
+  }
+  setWriteStream(writeStream) {
+    PreCondition.assertNotUndefinedAndNotNull(writeStream, "writeStream");
+    this.writeStream = IndentedCharacterWriteStream.create(writeStream);
+    this.ui.setWriteStream(this.writeStream);
+    return this;
+  }
+  setStyle(style, styleFunction) {
+    this.ui.setStyle(style, styleFunction);
+    return this;
+  }
+  setStyles(styles) {
+    this.ui.setStyles(styles);
+    return this;
+  }
+  /**
+   * Get the number of {@link TestAction}s that have yet to be executed.
+   */
+  getTestActionCount() {
+    return this.testActions.getCount().await();
+  }
+  /**
+   * Get the index in the {@link TestAction} list that new {@link TestAction}s will be
+   * inserted at.
+   */
+  getTestActionInsertIndex() {
+    return this.testActionInsertIndex;
+  }
+  resetTestActionInsertIndex() {
+    this.testActionInsertIndex = 0;
+  }
+  insertTestAction(testActionName, testActionType, skip, action) {
+    const parentTestAction = this.getCurrentTestAction();
+    const testAction = TestAction.create(parentTestAction, testActionName, testActionType, skip, action);
+    this.testActions.insert(this.testActionInsertIndex, testAction);
+    this.testActionInsertIndex++;
+  }
+  /**
+   * 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) {
+      this.currentTest.fail("Can't start a new test group or a new test while running a test.");
+    }
+  }
+  beforeTestGroup(testAction) {
+    return this.ui.beforeTestGroup(testAction);
+  }
+  afterTestGroup(testAction) {
+    return this.ui.afterTestGroup(testAction);
+  }
+  beforeTest(testAction) {
+    return this.ui.beforeTest(testAction);
+  }
+  afterPassedTest(testAction) {
+    return AsyncResult.create(async () => {
+      await this.ui.afterPassedTest(testAction);
+      this.passedTestCount++;
+    });
+  }
+  afterSkippedTest(testAction, skip) {
+    PreCondition.assertNotUndefinedAndNotNull(testAction, "testAction");
+    return AsyncResult.create(async () => {
+      await this.ui.afterSkippedTest(testAction, skip);
+      this.skippedTests.add(SkippedTest.create(skip, testAction));
+    });
+  }
+  afterFailedTest(testAction, error) {
+    PreCondition.assertNotUndefinedAndNotNull(testAction, "testAction");
+    PreCondition.assertNotUndefinedAndNotNull(error, "error");
+    return AsyncResult.create(async () => {
+      await this.ui.afterFailedTest(testAction, error);
+      this.testFailures.add(FailedTest.create(testAction, error));
+    });
+  }
+  andList(values) {
+    return TestRunner.andList(this, values);
+  }
+  toString(value) {
+    return TestRunner.toString(this, value);
+  }
+  skip(messageOrShouldSkip, message) {
+    let shouldSkip;
+    if (!isBoolean(messageOrShouldSkip)) {
+      shouldSkip = true;
+      message = messageOrShouldSkip;
+    } else {
+      shouldSkip = messageOrShouldSkip;
+    }
+    return TestRunner.skip(this, shouldSkip, message);
+  }
+  testFile(fileName, skipOrTestAction, testAction) {
+    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");
+    this.testGroupOrTest(fileName, "file", skip, testAction);
+  }
+  testType(typeNameOrType, skipOrTestAction, testAction) {
+    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");
+    this.testGroupOrTest(typeName, "type", skip, testAction);
+  }
+  testFunction(functionSignature, skipOrTestAction, testAction) {
+    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");
+    this.testGroupOrTest(functionSignature, "function", skip, testAction);
+  }
+  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.innerTestGroup(testGroupName, "group", skip, testAction);
+  }
+  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.innerTest(testName, "test", skip, testAction);
+  }
+  innerTestGroup(testGroupName, type, skip, testGroupAction) {
+    PreCondition.assertNotEmpty(testGroupName, "testGroupName");
+    PreCondition.assertNotUndefinedAndNotNull(testGroupAction, "testGroupAction");
+    this.assertNoCurrentTest();
+    this.insertTestAction(
+      testGroupName,
+      type,
+      skip,
+      () => this.beforeTestGroup(this.getCurrentTestAction())
+    );
+    this.insertTestAction(
+      testGroupName,
+      type,
+      skip,
+      async () => {
+        this.resetTestActionInsertIndex();
+        try {
+          await testGroupAction();
+        } catch (error) {
+          const currentTestGroupAction = this.getCurrentTestAction();
+          await this.afterFailedTest(currentTestGroupAction, error);
+        }
+      }
+    );
+    this.insertTestAction(
+      testGroupName,
+      type,
+      skip,
+      () => this.afterTestGroup(this.getCurrentTestAction())
+    );
+  }
+  innerTest(testName, testType, skip, testAction) {
+    PreCondition.assertNotEmpty(testName, "testName");
+    PreCondition.assertNotUndefinedAndNotNull(testAction, "testAction");
+    this.assertNoCurrentTest();
+    this.insertTestAction(
+      testName,
+      testType,
+      skip,
+      async () => {
+        const currentTestAction = this.getCurrentTestAction();
+        try {
+          await this.beforeTest(currentTestAction);
+          const skip2 = currentTestAction.getSkip();
+          if (skip2?.getShouldSkip()) {
+            await this.afterSkippedTest(currentTestAction, skip2);
+          } else {
+            this.currentTest = AssertTest.create(testName);
+            try {
+              await testAction(this.currentTest);
+            } finally {
+              this.currentTest = void 0;
+            }
+            await this.afterPassedTest(currentTestAction);
+          }
+        } catch (error) {
+          await this.afterFailedTest(currentTestAction, error);
+        }
+      }
+    );
+  }
+  testGroupOrTest(name, type, skip, testAction) {
+    if (getParameterCount(testAction) === 0) {
+      this.innerTestGroup(name, type, skip, testAction);
+    } else {
+      this.innerTest(name, type, skip, testAction);
+    }
+  }
+  async runAsync() {
+    while (this.testActions.any().await()) {
+      this.resetTestActionInsertIndex();
+      this.currentTestAction = this.testActions.removeFirst().await();
+      try {
+        await this.currentTestAction.runAsync();
+      } finally {
+        this.currentTestAction = void 0;
+      }
+    }
+    this.resetTestActionInsertIndex();
+  }
+  printSummary() {
+    return this.ui.writeSummary(this.passedTestCount, this.getSkippedTests(), this.getFailedTests());
+  }
+};
+
+export {
+  Test,
+  AssertTest,
+  test,
+  assertTestTests_exports,
+  BasicTestSkip,
+  FailedTest,
+  SkippedTest,
+  TestAction,
+  TestSkip,
+  TestRunner,
+  ConsoleTestRunner
+};
+//# sourceMappingURL=chunk-VF6FBNAU.js.map