//! Lives in its own test binary: the assertion counts every thread in the

//! process, so a test running beside it in the same binary perturbs the count.

//! Cargo runs test targets one at a time, which makes the measurement exact.

use scripting::executor::ScriptExecutor;

use scripting::format::{ContextType, EntityType};

use scripting::serializer::MemorySerializer;

const TEST_WASM: &[u8] = include_bytes!("../../web/static/wasm/groceries_markup.wasm");

/// The epoch ticker must not outlive the execution that started it.

///

/// The epoch counter is shared by every execution on the same engine, so a

/// ticker that keeps running after its call spends the budget of whatever runs

/// next — and executors are reused (the account-script batch path drives one

/// across many transactions). A `JoinHandle` does not stop a thread when

/// dropped, it detaches it, so the previous `drop(ticker)` left it ticking, and

/// every `?` between the spawn and the call skipped even that.

///

/// This asserts the fix's actual contract — no ticker thread survives the call —

/// by counting live threads, rather than trying to catch the downstream symptom.

/// A symptom test was tried first and rejected: a stray bump only does damage if

/// it lands inside a later execution's call window, and with the fast fixtures

/// available here it lands between runs instead, so the test passed with the bug

/// deliberately reintroduced. Thread count fails against that same reintroduction.

#[test]

    // A long budget: with the ticker detached, these threads linger for a full

    // minute each, so the count after the loop is unambiguous.

    // One warm-up run first: wasmtime brings up a parallel-compilation pool

    // sized to the host's cores on first use, and counting that as a leak would

    // make this test a core-count assertion.

        "ticker threads outlived their executions: {before} live threads before 8 runs, \

         {after} after — a detached ticker keeps bumping the shared engine epoch"

    );