@effectionx/bdd 0.1.0

package/README.md

@@ -0,0 +1,171 @@
+# @effectionx/bdd
+
+A BDD (Behavior-Driven Development) testing harness for Deno that integrates
+seamlessly with [Effection](https://github.com/thefrontside/effection)
+operations. This package provides a familiar `describe`/`it`/`beforeEach` API
+that works natively with Effection's generator-based operations.
+
+## Features
+
+- 🔄 **Native Effection Support**: Test functions can be generator functions
+  that yield operations
+- 🏗️ **Familiar BDD API**: Uses the standard `describe`, `it`, and `beforeEach`
+  functions you know and love
+- 🧹 **Automatic Cleanup**: Proper resource management and cleanup for Effection
+  operations
+- 🎯 **Skip and Only**: Full support for `.skip` and `.only` modifiers
+- 📦 **Zero Configuration**: Works out of the box with Deno's built-in testing
+  framework
+
+## Installation
+
+Add to your `deno.json` imports:
+
+```json
+{
+  "imports": {
+    "@effectionx/bdd": "npm:@effectionx/bdd"
+  }
+}
+```
+
+## Basic Usage
+
+```typescript
+import { beforeEach, describe, it } from "@effectionx/bdd";
+import { expect } from "@std/expect";
+import { sleep, spawn } from "effection";
+import { createSignal, is } from "@effectionx/signals";
+
+describe("My async operations", () => {
+  let counter: ReturnType<typeof createSignal<number, void>>;
+
+  beforeEach(function* () {
+    // Setup that runs before each test
+    counter = yield* createSignal(0);
+    yield* sleep(10); // Can use Effection operations in setup
+  });
+
+  it("should increment counter", function* () {
+    // Test function is a generator that can yield operations
+    counter.update((n) => n + 1);
+    yield* is(counter, (value) => value === 1);
+    expect(counter.valueOf()).toBe(1);
+  });
+});
+```
+
+## Real-World Examples
+
+The following packages have been migrated to use `@effectionx/bdd` and provide
+excellent examples of testing patterns:
+
+- **stream-helpers**: See [`batch.test.ts`](../stream-helpers/batch.test.ts) for
+  testing stream batching with time and size limits
+- **signals**: See [`array.test.ts`](../signals/array.test.ts) for testing array
+  signal operations like push, set, and update
+- **timebox**: See [`timebox.test.ts`](../timebox/timebox.test.ts) for testing
+  timeout scenarios with both success and timeout cases
+- **task-buffer**: See
+  [`task-buffer.test.ts`](../task-buffer/task-buffer.test.ts) for testing task
+  queuing and buffer management
+- **websocket**: See [`websocket.test.ts`](../websocket/websocket.test.ts) for
+  testing bidirectional WebSocket communication and connection lifecycle
+- **worker**: See [`worker.test.ts`](../worker/worker.test.ts) for testing web
+  worker communication, error handling, and lifecycle management
+
+### Common Patterns Demonstrated
+
+These test files show how to:
+
+- **Handle async operations** without `run()` wrappers
+- **Test error scenarios** using try/catch blocks instead of Promise rejections
+- **Use `beforeEach`** for test setup with Effection operations
+- **Wait for signal changes** using the `is` helper
+- **Test resource cleanup** and proper teardown
+- **Handle timeouts and concurrent operations**
+
+## API Reference
+
+### `describe(name: string, body: () => void)`
+
+Creates a test suite with the given name. Test suites can be nested.
+
+**Options:**
+
+- `describe.skip()` - Skip this test suite
+- `describe.only()` - Run only this test suite
+
+### `it(desc: string, body?: () => Operation<void>)`
+
+Creates a test case with the given description. The body function should be a
+generator function that can yield Effection operations.
+
+**Options:**
+
+- `it.skip()` - Skip this test case
+- `it.only()` - Run only this test case
+
+**Parameters:**
+
+- `desc` - Description of what the test should do
+- `body` - Generator function containing the test logic (optional for pending
+  tests)
+
+### `beforeEach(body: () => Operation<void>)`
+
+Registers a setup function that runs before each test in the current suite. The
+body function should be a generator function that can yield Effection
+operations.
+
+### ~~`afterEach`~~
+
+This package doesn't include `afterEach` because it's typically used for clean
+up. With Effection, clean up is done in `finally` block of the resource.
+Consider creating a resource in beforeEach if you encounter a need for
+`afterEach`.
+
+### `beforeAll`
+
+Is not implemented yet.
+
+## Migration from Standard Deno Testing
+
+If you're migrating from standard Deno testing with Effection, the changes are
+minimal:
+
+**Before:**
+
+```typescript
+import { describe, it } from "@std/testing/bdd";
+import { run } from "effection";
+
+describe("my tests", () => {
+  it("should work", async () => {
+    await run(function* () {
+      const result = yield* someOperation();
+      expect(result).toBe("success");
+    });
+  });
+});
+```
+
+**After:**
+
+```typescript
+import { describe, it } from "@effectionx/bdd";
+// No need to import 'run'
+
+describe("my tests", () => {
+  it("should work", function* () {
+    const result = yield* someOperation();
+    expect(result).toBe("success");
+  });
+});
+```
+
+## Contributing
+
+This package is part of the
+[Effection](https://github.com/thefrontside/effection) ecosystem. Contributions
+are welcome!

package/esm/_dnt.shims.d.ts

@@ -0,0 +1,2 @@
+export declare const dntGlobalThis: Omit<typeof globalThis, never>;
+//# sourceMappingURL=_dnt.shims.d.ts.map

package/esm/_dnt.shims.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"_dnt.shims.d.ts","sourceRoot":"","sources":["../src/_dnt.shims.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,aAAa,gCAA2C,CAAC"}

package/esm/_dnt.shims.js

@@ -0,0 +1,57 @@
+const dntGlobals = {};
+export const dntGlobalThis = createMergeProxy(globalThis, dntGlobals);
+function createMergeProxy(baseObj, extObj) {
+    return new Proxy(baseObj, {
+        get(_target, prop, _receiver) {
+            if (prop in extObj) {
+                return extObj[prop];
+            }
+            else {
+                return baseObj[prop];
+            }
+        },
+        set(_target, prop, value) {
+            if (prop in extObj) {
+                delete extObj[prop];
+            }
+            baseObj[prop] = value;
+            return true;
+        },
+        deleteProperty(_target, prop) {
+            let success = false;
+            if (prop in extObj) {
+                delete extObj[prop];
+                success = true;
+            }
+            if (prop in baseObj) {
+                delete baseObj[prop];
+                success = true;
+            }
+            return success;
+        },
+        ownKeys(_target) {
+            const baseKeys = Reflect.ownKeys(baseObj);
+            const extKeys = Reflect.ownKeys(extObj);
+            const extKeysSet = new Set(extKeys);
+            return [...baseKeys.filter((k) => !extKeysSet.has(k)), ...extKeys];
+        },
+        defineProperty(_target, prop, desc) {
+            if (prop in extObj) {
+                delete extObj[prop];
+            }
+            Reflect.defineProperty(baseObj, prop, desc);
+            return true;
+        },
+        getOwnPropertyDescriptor(_target, prop) {
+            if (prop in extObj) {
+                return Reflect.getOwnPropertyDescriptor(extObj, prop);
+            }
+            else {
+                return Reflect.getOwnPropertyDescriptor(baseObj, prop);
+            }
+        },
+        has(_target, prop) {
+            return prop in extObj || prop in baseObj;
+        },
+    });
+}

package/esm/deps/jsr.io/@std/assert/1.0.14/assertion_error.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Error thrown when an assertion fails.
+ *
+ * @example Usage
+ * ```ts ignore
+ * import { AssertionError } from "@std/assert";
+ *
+ * try {
+ *   throw new AssertionError("foo", { cause: "bar" });
+ * } catch (error) {
+ *   if (error instanceof AssertionError) {
+ *     error.message === "foo"; // true
+ *     error.cause === "bar"; // true
+ *   }
+ * }
+ * ```
+ */
+export declare class AssertionError extends Error {
+    /** Constructs a new instance.
+     *
+     * @param message The error message.
+     * @param options Additional options. This argument is still unstable. It may change in the future release.
+     */
+    constructor(message: string, options?: ErrorOptions);
+}
+//# sourceMappingURL=assertion_error.d.ts.map

package/esm/deps/jsr.io/@std/assert/1.0.14/assertion_error.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"assertion_error.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/assert/1.0.14/assertion_error.ts"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;GAgBG;AACH,qBAAa,cAAe,SAAQ,KAAK;IACvC;;;;OAIG;gBACS,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,YAAY;CAIpD"}

package/esm/deps/jsr.io/@std/assert/1.0.14/assertion_error.js

@@ -0,0 +1,30 @@
+// Copyright 2018-2025 the Deno authors. MIT license.
+// This module is browser compatible.
+/**
+ * Error thrown when an assertion fails.
+ *
+ * @example Usage
+ * ```ts ignore
+ * import { AssertionError } from "@std/assert";
+ *
+ * try {
+ *   throw new AssertionError("foo", { cause: "bar" });
+ * } catch (error) {
+ *   if (error instanceof AssertionError) {
+ *     error.message === "foo"; // true
+ *     error.cause === "bar"; // true
+ *   }
+ * }
+ * ```
+ */
+export class AssertionError extends Error {
+    /** Constructs a new instance.
+     *
+     * @param message The error message.
+     * @param options Additional options. This argument is still unstable. It may change in the future release.
+     */
+    constructor(message, options) {
+        super(message, options);
+        this.name = "AssertionError";
+    }
+}

package/esm/deps/jsr.io/@std/internal/1.0.10/assertion_state.d.ts

@@ -0,0 +1,150 @@
+export declare class AssertionState {
+    #private;
+    constructor();
+    /**
+     * Get the number that through `expect.assertions` api set.
+     *
+     * @returns the number that through `expect.assertions` api set.
+     *
+     * @example Usage
+     * ```ts ignore
+     * import { AssertionState } from "@std/internal";
+     *
+     * const assertionState = new AssertionState();
+     * assertionState.assertionCount;
+     * ```
+     */
+    get assertionCount(): number | undefined;
+    /**
+     * Get a certain number that assertions were called before.
+     *
+     * @returns return a certain number that assertions were called before.
+     *
+     * @example Usage
+     * ```ts ignore
+     * import { AssertionState } from "@std/internal";
+     *
+     * const assertionState = new AssertionState();
+     * assertionState.assertionTriggeredCount;
+     * ```
+     */
+    get assertionTriggeredCount(): number;
+    /**
+     * If `expect.hasAssertions` called, then through this method to update #state.assertionCheck value.
+     *
+     * @param val Set #state.assertionCheck's value
+     *
+     * @example Usage
+     * ```ts ignore
+     * import { AssertionState } from "@std/internal";
+     *
+     * const assertionState = new AssertionState();
+     * assertionState.setAssertionCheck(true);
+     * ```
+     */
+    setAssertionCheck(val: boolean): void;
+    /**
+     * If any matchers was called, `#state.assertionTriggered` will be set through this method.
+     *
+     * @param val Set #state.assertionTriggered's value
+     *
+     * @example Usage
+     * ```ts ignore
+     * import { AssertionState } from "@std/internal";
+     *
+     * const assertionState = new AssertionState();
+     * assertionState.setAssertionTriggered(true);
+     * ```
+     */
+    setAssertionTriggered(val: boolean): void;
+    /**
+     * If `expect.assertions` called, then through this method to update #state.assertionCheck value.
+     *
+     * @param num Set #state.assertionCount's value, for example if the value is set 2, that means
+     * you must have two assertion matchers call in your test suite.
+     *
+     * @example Usage
+     * ```ts ignore
+     * import { AssertionState } from "@std/internal";
+     *
+     * const assertionState = new AssertionState();
+     * assertionState.setAssertionCount(2);
+     * ```
+     */
+    setAssertionCount(num: number): void;
+    /**
+     * If any matchers was called, `#state.assertionTriggeredCount` value will plus one internally.
+     *
+     * @example Usage
+     * ```ts ignore
+     * import { AssertionState } from "@std/internal";
+     *
+     * const assertionState = new AssertionState();
+     * assertionState.updateAssertionTriggerCount();
+     * ```
+     */
+    updateAssertionTriggerCount(): void;
+    /**
+     * Check Assertion internal state, if `#state.assertionCheck` is set true, but
+     * `#state.assertionTriggered` is still false, then should throw an Assertion Error.
+     *
+     * @returns a boolean value, that the test suite is satisfied with the check. If not,
+     * it should throw an AssertionError.
+     *
+     * @example Usage
+     * ```ts ignore
+     * import { AssertionState } from "@std/internal";
+     *
+     * const assertionState = new AssertionState();
+     * if (assertionState.checkAssertionErrorState()) {
+     *   // throw AssertionError("");
+     * }
+     * ```
+     */
+    checkAssertionErrorState(): boolean;
+    /**
+     * Reset all assertion state when every test suite function ran completely.
+     *
+     * @example Usage
+     * ```ts ignore
+     * import { AssertionState } from "@std/internal";
+     *
+     * const assertionState = new AssertionState();
+     * assertionState.resetAssertionState();
+     * ```
+     */
+    resetAssertionState(): void;
+    /**
+     * Check Assertion called state, if `#state.assertionCount` is set to a number value, but
+     * `#state.assertionTriggeredCount` is less then it, then should throw an assertion error.
+     *
+     * @returns a boolean value, that the test suite is satisfied with the check. If not,
+     * it should throw an AssertionError.
+     *
+     * @example Usage
+     * ```ts ignore
+     * import { AssertionState } from "@std/internal";
+     *
+     * const assertionState = new AssertionState();
+     * if (assertionState.checkAssertionCountSatisfied()) {
+     *   // throw AssertionError("");
+     * }
+     * ```
+     */
+    checkAssertionCountSatisfied(): boolean;
+}
+/**
+ * return an instance of AssertionState
+ *
+ * @returns AssertionState
+ *
+ * @example Usage
+ * ```ts ignore
+ * import { getAssertionState } from "@std/internal";
+ *
+ * const assertionState = getAssertionState();
+ * assertionState.setAssertionTriggered(true);
+ * ```
+ */
+export declare function getAssertionState(): AssertionState;
+//# sourceMappingURL=assertion_state.d.ts.map

package/esm/deps/jsr.io/@std/internal/1.0.10/assertion_state.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"assertion_state.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/internal/1.0.10/assertion_state.ts"],"names":[],"mappings":"AAeA,qBAAa,cAAc;;;IAgDzB;;;;;;;;;;;;OAYG;IACH,IAAI,cAAc,IAAI,MAAM,GAAG,SAAS,CAEvC;IAED;;;;;;;;;;;;OAYG;IACH,IAAI,uBAAuB,IAAI,MAAM,CAEpC;IAED;;;;;;;;;;;;OAYG;IACH,iBAAiB,CAAC,GAAG,EAAE,OAAO;IAI9B;;;;;;;;;;;;OAYG;IACH,qBAAqB,CAAC,GAAG,EAAE,OAAO;IAIlC;;;;;;;;;;;;;OAaG;IACH,iBAAiB,CAAC,GAAG,EAAE,MAAM;IAI7B;;;;;;;;;;OAUG;IACH,2BAA2B;IAM3B;;;;;;;;;;;;;;;;OAgBG;IACH,wBAAwB,IAAI,OAAO;IAInC;;;;;;;;;;OAUG;IACH,mBAAmB,IAAI,IAAI;IAS3B;;;;;;;;;;;;;;;;OAgBG;IACH,4BAA4B,IAAI,OAAO;CAIxC;AAID;;;;;;;;;;;;GAYG;AACH,wBAAgB,iBAAiB,IAAI,cAAc,CAElD"}

package/esm/deps/jsr.io/@std/internal/1.0.10/assertion_state.js

@@ -0,0 +1,237 @@
+// Copyright 2018-2025 the Deno authors. MIT license.
+// This module is browser compatible.
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _AssertionState_instances, _AssertionState_state, _AssertionState_ensureCleanedUp;
+/**
+ * Check the test suite internal state
+ *
+ * @example Usage
+ * ```ts ignore
+ * import { AssertionState } from "@std/internal";
+ *
+ * const assertionState = new AssertionState();
+ * ```
+ */
+import * as dntShim from "../../../../../_dnt.shims.js";
+export class AssertionState {
+    constructor() {
+        _AssertionState_instances.add(this);
+        _AssertionState_state.set(this, void 0);
+        __classPrivateFieldSet(this, _AssertionState_state, {
+            assertionCount: undefined,
+            assertionCheck: false,
+            assertionTriggered: false,
+            assertionTriggeredCount: 0,
+        }, "f");
+        if (typeof globalThis?.addEventListener === "function") {
+            globalThis.addEventListener("unload", () => {
+                __classPrivateFieldGet(this, _AssertionState_instances, "m", _AssertionState_ensureCleanedUp).call(this);
+            });
+        }
+        else if (
+        // deno-lint-ignore no-explicit-any
+        typeof dntShim.dntGlobalThis?.process?.on === "function") {
+            // deno-lint-ignore no-explicit-any
+            dntShim.dntGlobalThis.process.on("exit", () => {
+                __classPrivateFieldGet(this, _AssertionState_instances, "m", _AssertionState_ensureCleanedUp).call(this);
+            });
+        }
+        else {
+            // deno-lint-ignore no-console
+            console.warn("AssertionCounter cleanup step was not registered");
+        }
+    }
+    /**
+     * Get the number that through `expect.assertions` api set.
+     *
+     * @returns the number that through `expect.assertions` api set.
+     *
+     * @example Usage
+     * ```ts ignore
+     * import { AssertionState } from "@std/internal";
+     *
+     * const assertionState = new AssertionState();
+     * assertionState.assertionCount;
+     * ```
+     */
+    get assertionCount() {
+        return __classPrivateFieldGet(this, _AssertionState_state, "f").assertionCount;
+    }
+    /**
+     * Get a certain number that assertions were called before.
+     *
+     * @returns return a certain number that assertions were called before.
+     *
+     * @example Usage
+     * ```ts ignore
+     * import { AssertionState } from "@std/internal";
+     *
+     * const assertionState = new AssertionState();
+     * assertionState.assertionTriggeredCount;
+     * ```
+     */
+    get assertionTriggeredCount() {
+        return __classPrivateFieldGet(this, _AssertionState_state, "f").assertionTriggeredCount;
+    }
+    /**
+     * If `expect.hasAssertions` called, then through this method to update #state.assertionCheck value.
+     *
+     * @param val Set #state.assertionCheck's value
+     *
+     * @example Usage
+     * ```ts ignore
+     * import { AssertionState } from "@std/internal";
+     *
+     * const assertionState = new AssertionState();
+     * assertionState.setAssertionCheck(true);
+     * ```
+     */
+    setAssertionCheck(val) {
+        __classPrivateFieldGet(this, _AssertionState_state, "f").assertionCheck = val;
+    }
+    /**
+     * If any matchers was called, `#state.assertionTriggered` will be set through this method.
+     *
+     * @param val Set #state.assertionTriggered's value
+     *
+     * @example Usage
+     * ```ts ignore
+     * import { AssertionState } from "@std/internal";
+     *
+     * const assertionState = new AssertionState();
+     * assertionState.setAssertionTriggered(true);
+     * ```
+     */
+    setAssertionTriggered(val) {
+        __classPrivateFieldGet(this, _AssertionState_state, "f").assertionTriggered = val;
+    }
+    /**
+     * If `expect.assertions` called, then through this method to update #state.assertionCheck value.
+     *
+     * @param num Set #state.assertionCount's value, for example if the value is set 2, that means
+     * you must have two assertion matchers call in your test suite.
+     *
+     * @example Usage
+     * ```ts ignore
+     * import { AssertionState } from "@std/internal";
+     *
+     * const assertionState = new AssertionState();
+     * assertionState.setAssertionCount(2);
+     * ```
+     */
+    setAssertionCount(num) {
+        __classPrivateFieldGet(this, _AssertionState_state, "f").assertionCount = num;
+    }
+    /**
+     * If any matchers was called, `#state.assertionTriggeredCount` value will plus one internally.
+     *
+     * @example Usage
+     * ```ts ignore
+     * import { AssertionState } from "@std/internal";
+     *
+     * const assertionState = new AssertionState();
+     * assertionState.updateAssertionTriggerCount();
+     * ```
+     */
+    updateAssertionTriggerCount() {
+        if (__classPrivateFieldGet(this, _AssertionState_state, "f").assertionCount !== undefined) {
+            __classPrivateFieldGet(this, _AssertionState_state, "f").assertionTriggeredCount += 1;
+        }
+    }
+    /**
+     * Check Assertion internal state, if `#state.assertionCheck` is set true, but
+     * `#state.assertionTriggered` is still false, then should throw an Assertion Error.
+     *
+     * @returns a boolean value, that the test suite is satisfied with the check. If not,
+     * it should throw an AssertionError.
+     *
+     * @example Usage
+     * ```ts ignore
+     * import { AssertionState } from "@std/internal";
+     *
+     * const assertionState = new AssertionState();
+     * if (assertionState.checkAssertionErrorState()) {
+     *   // throw AssertionError("");
+     * }
+     * ```
+     */
+    checkAssertionErrorState() {
+        return __classPrivateFieldGet(this, _AssertionState_state, "f").assertionCheck && !__classPrivateFieldGet(this, _AssertionState_state, "f").assertionTriggered;
+    }
+    /**
+     * Reset all assertion state when every test suite function ran completely.
+     *
+     * @example Usage
+     * ```ts ignore
+     * import { AssertionState } from "@std/internal";
+     *
+     * const assertionState = new AssertionState();
+     * assertionState.resetAssertionState();
+     * ```
+     */
+    resetAssertionState() {
+        __classPrivateFieldSet(this, _AssertionState_state, {
+            assertionCount: undefined,
+            assertionCheck: false,
+            assertionTriggered: false,
+            assertionTriggeredCount: 0,
+        }, "f");
+    }
+    /**
+     * Check Assertion called state, if `#state.assertionCount` is set to a number value, but
+     * `#state.assertionTriggeredCount` is less then it, then should throw an assertion error.
+     *
+     * @returns a boolean value, that the test suite is satisfied with the check. If not,
+     * it should throw an AssertionError.
+     *
+     * @example Usage
+     * ```ts ignore
+     * import { AssertionState } from "@std/internal";
+     *
+     * const assertionState = new AssertionState();
+     * if (assertionState.checkAssertionCountSatisfied()) {
+     *   // throw AssertionError("");
+     * }
+     * ```
+     */
+    checkAssertionCountSatisfied() {
+        return __classPrivateFieldGet(this, _AssertionState_state, "f").assertionCount !== undefined &&
+            __classPrivateFieldGet(this, _AssertionState_state, "f").assertionCount !== __classPrivateFieldGet(this, _AssertionState_state, "f").assertionTriggeredCount;
+    }
+}
+_AssertionState_state = new WeakMap(), _AssertionState_instances = new WeakSet(), _AssertionState_ensureCleanedUp = function _AssertionState_ensureCleanedUp() {
+    // If any checks were registered, after the test suite runs the checks,
+    // `resetAssertionState` should also have been called. If it was not,
+    // then the test suite did not run the checks.
+    if (__classPrivateFieldGet(this, _AssertionState_state, "f").assertionCheck ||
+        __classPrivateFieldGet(this, _AssertionState_state, "f").assertionCount !== undefined) {
+        throw new Error("AssertionCounter was not cleaned up: If tests are not otherwise failing, ensure `expect.hasAssertion` and `expect.assertions` are only run in bdd tests");
+    }
+};
+const assertionState = new AssertionState();
+/**
+ * return an instance of AssertionState
+ *
+ * @returns AssertionState
+ *
+ * @example Usage
+ * ```ts ignore
+ * import { getAssertionState } from "@std/internal";
+ *
+ * const assertionState = getAssertionState();
+ * assertionState.setAssertionTriggered(true);
+ * ```
+ */
+export function getAssertionState() {
+    return assertionState;
+}