Intrepid/Prometeu/Runtime/pipeline/pr-master This commit looks good
Add structural Fn signatures, typed capture environments, indirect calls and Trait dispatch while preserving logical parameter and result groups, ownership and budgets. Remove guest coroutine execution and legacy loading. Activate bounded sealed PBX v1 with mandatory capture metadata, preserve frame continuations and root return results, and migrate producers and shipped cartridges. Publish coordinated specs, handoffs and the completed runtime lesson. Validation: 880 workspace tests passed, 9 existing tests ignored; both cartridges completed six production-host frames.
111 lines
2.5 KiB
Rust
111 lines
2.5 KiB
Rust
//! Test-only utilities for deterministic behavior in unit tests.
|
|
//!
|
|
//! This crate is intended to be used as a dev-dependency only. It provides:
|
|
//! - Seeded RNG helpers for reproducible randomness in tests.
|
|
//! - A tiny deterministic clock abstraction for tests that need to reason about time.
|
|
|
|
use rand::{RngCore, SeedableRng, rngs::StdRng};
|
|
|
|
/// Builds a `StdRng` from a u64 seed in a deterministic way.
|
|
///
|
|
/// This expands the u64 seed into a 32-byte array (little-endian repeated)
|
|
/// to initialize `StdRng`.
|
|
pub fn rng_from_seed(seed: u64) -> StdRng {
|
|
let le = seed.to_le_bytes();
|
|
let mut buf = [0u8; 32];
|
|
// Repeat the 8-byte seed 4 times to fill 32 bytes
|
|
for i in 0..4 {
|
|
buf[i * 8..(i + 1) * 8].copy_from_slice(&le);
|
|
}
|
|
StdRng::from_seed(buf)
|
|
}
|
|
|
|
/// Convenience helper that returns a RNG with a fixed well-known seed.
|
|
pub fn deterministic_rng() -> StdRng {
|
|
rng_from_seed(0x00C0_FFEE_5EED)
|
|
}
|
|
|
|
/// Returns the next u64 from the provided RNG.
|
|
pub fn next_u64(rng: &mut StdRng) -> u64 {
|
|
rng.next_u64()
|
|
}
|
|
|
|
/// Collects `n` u64 values from the RNG.
|
|
pub fn take_n_u64(rng: &mut StdRng, n: usize) -> Vec<u64> {
|
|
let mut out = Vec::with_capacity(n);
|
|
for _ in 0..n {
|
|
out.push(rng.next_u64());
|
|
}
|
|
out
|
|
}
|
|
|
|
/// Simple deterministic clock abstraction for tests.
|
|
pub trait Clock {
|
|
fn now_millis(&self) -> u64;
|
|
}
|
|
|
|
/// A clock that always returns a fixed instant.
|
|
pub struct FixedClock {
|
|
now: u64,
|
|
}
|
|
|
|
impl FixedClock {
|
|
pub fn new(now: u64) -> Self {
|
|
Self { now }
|
|
}
|
|
}
|
|
|
|
impl Clock for FixedClock {
|
|
fn now_millis(&self) -> u64 {
|
|
self.now
|
|
}
|
|
}
|
|
|
|
/// A clock that advances by a constant step each tick.
|
|
pub struct TickingClock {
|
|
now: u64,
|
|
step: u64,
|
|
}
|
|
|
|
impl TickingClock {
|
|
pub fn new(start: u64, step: u64) -> Self {
|
|
Self { now: start, step }
|
|
}
|
|
pub fn tick(&mut self) {
|
|
self.now = self.now.saturating_add(self.step);
|
|
}
|
|
}
|
|
|
|
impl Clock for TickingClock {
|
|
fn now_millis(&self) -> u64 {
|
|
self.now
|
|
}
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod tests {
|
|
use super::*;
|
|
|
|
#[test]
|
|
fn rng_reproducible_sequences() {
|
|
let mut a = rng_from_seed(42);
|
|
let mut b = rng_from_seed(42);
|
|
|
|
for _ in 0..10 {
|
|
assert_eq!(a.next_u64(), b.next_u64());
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn ticking_clock_advances_deterministically() {
|
|
let mut c = TickingClock::new(1000, 16);
|
|
assert_eq!(c.now_millis(), 1000);
|
|
c.tick();
|
|
assert_eq!(c.now_millis(), 1016);
|
|
c.tick();
|
|
assert_eq!(c.now_millis(), 1032);
|
|
}
|
|
}
|
|
|
|
pub mod program;
|