use std::fmt::Write as _;
use sensor_db::db::CompactScope;
use sensor_db::mock::MockFlash;
use sensor_db::zerocopy::{FromBytes, Immutable, IntoBytes, KnownLayout};
use sensor_db::{Error, RUN_FRAME_SIZE, Run, SensorData, SensorDb};
struct Rng(u64);
impl Rng {
fn new(seed: u64) -> Self {
Self(seed.wrapping_mul(0x9E37_79B9_7F4A_7C15) | 1)
}
fn next_u64(&mut self) -> u64 {
let mut x = self.0;
x ^= x >> 12;
x ^= x << 25;
x ^= x >> 27;
self.0 = x;
x.wrapping_mul(0x2545_F491_4F6C_DD1D)
}
fn below(&mut self, n: u64) -> u64 {
self.next_u64() % n
}
}
const SENSORS: [u16; 4] = [1, 2, 7, 900];
#[derive(FromBytes, IntoBytes, KnownLayout, Immutable, Clone, Copy)]
#[repr(C)]
struct Burst {
v: u32,
}
impl SensorData for Burst {
const SENSOR_ID: u16 = SENSORS[0];
}
fn run_sample_payload(ts: u64) -> Vec<u8> {
let mut payload = vec![Burst::SCHEMA_VERSION];
payload.extend_from_slice(Burst { v: ts as u32 }.as_bytes());
payload
}
#[derive(Clone, Copy, PartialEq, Eq, Debug)]
enum Op {
Append { sensor: u16, len: usize },
Run { count: usize },
Sync,
Compact(u16),
Remount,
}
fn workload(rng: &mut Rng, len: usize, max_payload: usize) -> Vec<Op> {
(0..len)
.map(|_| match rng.below(100) {
0..=59 => Op::Append {
sensor: SENSORS[rng.below(SENSORS.len() as u64) as usize],
len: rng.below(max_payload as u64 + 1) as usize,
},
60..=69 => Op::Run {
count: rng.below(24) as usize + 1,
},
70..=86 => Op::Sync,
87..=94 => Op::Compact(rng.below(3) as u16 + 1),
_ => Op::Remount,
})
.collect()
}
#[derive(Clone, PartialEq, Eq)]
struct Entry {
sensor: u16,
ts: u64,
payload: Vec<u8>,
}
impl std::fmt::Debug for Entry {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
write!(
f,
"({}, ts={}, {}B)",
self.sensor,
self.ts,
self.payload.len()
)
}
}
fn payload_for(ts: u64, len: usize) -> Vec<u8> {
let mut rng = Rng::new(ts ^ 0xD1CE_D1CE);
(0..len).map(|_| rng.next_u64() as u8).collect()
}
struct Model {
entries: Vec<Entry>,
evicted: usize,
durable: usize,
next_ts: u64,
}
impl Model {
fn new() -> Self {
Self {
entries: Vec::new(),
evicted: 0,
durable: 0,
next_ts: 1,
}
}
fn live(&self) -> &[Entry] {
&self.entries[self.evicted.min(self.entries.len())..]
}
}
type Failure = String;
macro_rules! ensure {
($cond:expr, $($arg:tt)*) => {
if !($cond) {
return Err(format!($($arg)*));
}
};
}
type Db<const PAGE: usize, const SECTOR: usize, const SECTORS: usize> =
SensorDb<MockFlash<PAGE, SECTOR>, PAGE, SECTORS>;
fn read_all<const PAGE: usize, const SECTOR: usize, const SECTORS: usize>(
db: &mut Db<PAGE, SECTOR, SECTORS>,
) -> Result<Vec<Entry>, Error> {
let mut out = Vec::new();
db.query_all(None, |hdr, payload| {
out.push(Entry {
sensor: hdr.sensor_id,
ts: hdr.timestamp,
payload: payload.to_vec(),
});
true
})?;
Ok(out)
}
fn check<const PAGE: usize, const SECTOR: usize, const SECTORS: usize>(
db: &mut Db<PAGE, SECTOR, SECTORS>,
model: &mut Model,
step: usize,
op: Op,
) -> Result<(), Failure> {
let at = format!("step {step} after {op:?}");
let actual = read_all(db).map_err(|e| format!("{at}: query_all failed: {e:?}"))?;
ensure!(
actual.len() <= model.entries.len(),
"{at}: database reports {} entries, only {} were ever appended",
actual.len(),
model.entries.len()
);
let k = model.entries.len() - actual.len();
ensure!(
k >= model.evicted,
"{at}: {} entries came back from the dead (evicted was {}, now {k})",
model.evicted - k,
model.evicted
);
ensure!(
actual == model.entries[k..],
"{at}: contents are not the model's suffix from {k}\n expected: {:?}\n actual: {:?}",
&model.entries[k..],
&actual
);
model.evicted = k;
ensure!(
actual.windows(2).all(|w| w[0].ts < w[1].ts),
"{at}: entries are not in ascending timestamp order"
);
let live = model.live().to_vec();
let total = db
.count(None)
.map_err(|e| format!("{at}: count(None) failed: {e:?}"))?;
ensure!(
total as usize == live.len(),
"{at}: count(None) = {total}, model has {}",
live.len()
);
for sensor in SENSORS {
let expected: Vec<&Entry> = live.iter().filter(|e| e.sensor == sensor).collect();
let counted = db
.count(Some(sensor))
.map_err(|e| format!("{at}: count({sensor}) failed: {e:?}"))?;
ensure!(
counted as usize == expected.len(),
"{at}: count({sensor}) = {counted}, model has {}",
expected.len()
);
let mut buf = [0u8; PAGE];
let latest = db
.latest(sensor, &mut buf)
.map_err(|e| format!("{at}: latest({sensor}) failed: {e:?}"))?;
match (latest, expected.last()) {
(None, None) => {}
(Some((hdr, n)), Some(want)) => {
ensure!(
hdr.timestamp == want.ts
&& hdr.sensor_id == sensor
&& buf[..n] == want.payload[..],
"{at}: latest({sensor}) = ts {} ({n}B), model says {:?}",
hdr.timestamp,
want
);
}
(a, b) => {
return Err(format!(
"{at}: latest({sensor}) presence disagrees: db {:?}, model {:?}",
a.map(|(h, _)| h.timestamp),
b.map(|e| e.ts)
));
}
}
let oldest = db
.oldest(sensor, &mut buf)
.map_err(|e| format!("{at}: oldest({sensor}) failed: {e:?}"))?;
match (oldest, expected.first()) {
(None, None) => {}
(Some((hdr, n)), Some(want)) => {
ensure!(
hdr.timestamp == want.ts && buf[..n] == want.payload[..],
"{at}: oldest({sensor}) = ts {}, model says {:?}",
hdr.timestamp,
want
);
}
(a, b) => {
return Err(format!(
"{at}: oldest({sensor}) presence disagrees: db {:?}, model {:?}",
a.map(|(h, _)| h.timestamp),
b.map(|e| e.ts)
));
}
}
}
if let (Some(first), Some(last)) = (live.first(), live.last()) {
let span = last.ts - first.ts;
let lo = first.ts + span / 4;
let hi = last.ts - span / 4;
if lo <= hi {
let want: Vec<&Entry> = live.iter().filter(|e| e.ts >= lo && e.ts <= hi).collect();
let mut got = Vec::new();
let n = db
.query_range(None, lo, hi, |hdr, _| {
got.push(hdr.timestamp);
true
})
.map_err(|e| format!("{at}: query_range failed: {e:?}"))?;
ensure!(
n as usize == want.len() && got == want.iter().map(|e| e.ts).collect::<Vec<_>>(),
"{at}: query_range({lo}..={hi}) yielded {n}, model says {}",
want.len()
);
}
}
Ok(())
}
fn replay<const PAGE: usize, const SECTOR: usize, const SECTORS: usize>(
ops: &[Op],
reserved: u16,
) -> Result<(), Failure> {
let max_payload = PAGE - 20;
let flash = MockFlash::<PAGE, SECTOR>::new(SECTORS * SECTOR);
let mut db: Db<PAGE, SECTOR, SECTORS> =
SensorDb::new(flash, 0, SECTORS as u16, reserved).map_err(|e| format!("new: {e:?}"))?;
db.format().map_err(|e| format!("format: {e:?}"))?;
let mut model = Model::new();
for (step, &op) in ops.iter().enumerate() {
match op {
Op::Append { sensor, len } => {
let len = len.min(max_payload);
let ts = model.next_ts;
let payload = payload_for(ts, len);
match db.append(sensor, ts, &payload) {
Ok(()) => {
model.next_ts += 1;
model.entries.push(Entry {
sensor,
ts,
payload,
});
}
Err(Error::NoSpace) => {}
Err(e) => return Err(format!("step {step}: append failed: {e:?}")),
}
}
Op::Run { count } => {
let room = max_payload.saturating_sub(RUN_FRAME_SIZE) / size_of::<Burst>();
let count = count.clamp(1, room.max(1));
let base = model.next_ts;
let values: Vec<Burst> = (0..count)
.map(|i| Burst {
v: (base + i as u64) as u32,
})
.collect();
let run = Run::of(base, 1, &values)
.map_err(|e| format!("step {step}: Run::of: {e:?}"))?;
match db.append_run(&run) {
Ok(()) => {
model.next_ts += count as u64;
for i in 0..count as u64 {
model.entries.push(Entry {
sensor: Burst::SENSOR_ID,
ts: base + i,
payload: run_sample_payload(base + i),
});
}
}
Err(Error::NoSpace) => {}
Err(e) => return Err(format!("step {step}: append_run failed: {e:?}")),
}
}
Op::Sync => {
db.sync().map_err(|e| format!("step {step}: sync: {e:?}"))?;
model.durable = model.entries.len();
}
Op::Compact(n) => {
db.compact(n, CompactScope::All)
.map_err(|e| format!("step {step}: compact: {e:?}"))?;
}
Op::Remount => {
let flash = db.into_inner();
let mut fresh: Db<PAGE, SECTOR, SECTORS> =
SensorDb::new(flash, 0, SECTORS as u16, reserved)
.map_err(|e| format!("step {step}: rebuild: {e:?}"))?;
fresh
.mount()
.map_err(|e| format!("step {step}: mount: {e:?}"))?;
db = fresh;
reconcile_after_remount(&mut db, &mut model, step)?;
}
}
check(&mut db, &mut model, step, op)?;
}
Ok(())
}
fn reconcile_after_remount<const PAGE: usize, const SECTOR: usize, const SECTORS: usize>(
db: &mut Db<PAGE, SECTOR, SECTORS>,
model: &mut Model,
step: usize,
) -> Result<(), Failure> {
let actual = read_all(db).map_err(|e| format!("step {step}: query_all: {e:?}"))?;
let survived = match actual.last() {
None => {
ensure!(
model.durable <= model.evicted,
"step {step}: remount lost everything, but {} entries were acknowledged \
and only {} had been evicted",
model.durable,
model.evicted
);
model.entries.len()
}
Some(last) => {
let pos = model
.entries
.iter()
.position(|e| e.ts == last.ts)
.ok_or_else(|| {
format!(
"step {step}: remount produced ts {} which was never appended",
last.ts
)
})?;
pos + 1
}
};
ensure!(
survived >= model.durable,
"step {step}: remount kept only {survived} entries, but {} were acknowledged by a \
successful sync",
model.durable
);
model.entries.truncate(survived);
Ok(())
}
fn shrink<const PAGE: usize, const SECTOR: usize, const SECTORS: usize>(
ops: &[Op],
reserved: u16,
) -> (Vec<Op>, Failure) {
let mut best = ops.to_vec();
let mut failure = match replay::<PAGE, SECTOR, SECTORS>(&best, reserved) {
Err(f) => f,
Ok(()) => return (best, "not reproducible".into()),
};
let mut chunk = best.len() / 2;
while chunk > 0 {
let mut i = 0;
while i < best.len() {
let mut candidate = best.clone();
let end = (i + chunk).min(candidate.len());
candidate.drain(i..end);
match replay::<PAGE, SECTOR, SECTORS>(&candidate, reserved) {
Err(f) => {
best = candidate;
failure = f;
}
Ok(()) => i += chunk,
}
}
chunk /= 2;
}
(best, failure)
}
fn sweep<const PAGE: usize, const SECTOR: usize, const SECTORS: usize>(
seeds: u64,
ops_per_seed: usize,
reserved: u16,
) {
for seed in 0..seeds {
let mut rng = Rng::new(seed ^ (PAGE as u64) << 32 ^ (SECTORS as u64));
let ops = workload(&mut rng, ops_per_seed, PAGE - 20);
if let Err(first) = replay::<PAGE, SECTOR, SECTORS>(&ops, reserved) {
let (minimal, failure) = shrink::<PAGE, SECTOR, SECTORS>(&ops, reserved);
let mut trace = String::new();
for (i, op) in minimal.iter().enumerate() {
let _ = writeln!(trace, " {i:3}: {op:?}");
}
panic!(
"model disagreed\n\
geometry: PAGE={PAGE} SECTOR={SECTOR} SECTORS={SECTORS} reserved={reserved}\n\
seed: {seed}\n\
\n{failure}\n\
\nminimal failing sequence ({} ops, shrunk from {}):\n{trace}\
\noriginal failure was:\n{first}",
minimal.len(),
ops.len()
);
}
}
}
#[test]
fn model_standard_geometry() {
sweep::<256, 4096, 8>(24, 160, 1);
}
#[test]
fn model_tiny_ring_wraps_constantly() {
sweep::<64, 512, 4>(24, 200, 1);
}
#[test]
fn model_minimal_ring() {
sweep::<64, 256, 3>(24, 160, 1);
}
#[test]
fn model_large_pages() {
sweep::<1024, 8192, 4>(12, 120, 1);
}
#[test]
fn model_no_reserved_sectors() {
sweep::<128, 1024, 6>(16, 160, 0);
}
mod tiered {
use super::*;
use sensor_db::db::DbConfig;
use sensor_db::mock::RemovableFlash;
use sensor_db::sector::LogId;
use sensor_db::spool::{SpoolBudget, Spooler, TieredDb, WritePolicy};
const PAGE: usize = 64;
const SECTOR: usize = 512;
const SECTORS: usize = 8;
const CURSOR_SECTORS: u16 = 2;
const CARD_SECTORS: usize = 12;
const LOG: u32 = 0x5EED;
type OnFlash = MockFlash<PAGE, SECTOR>;
type CardFlash = RemovableFlash<MockFlash<PAGE, SECTOR>>;
type Card = SensorDb<CardFlash, PAGE, CARD_SECTORS>;
type Tiered = TieredDb<OnFlash, CardFlash, PAGE, SECTORS, PAGE, CARD_SECTORS>;
#[derive(Clone, Copy, PartialEq, Eq, Debug)]
enum TOp {
Append {
sensor: u16,
len: usize,
},
Run {
count: usize,
},
Sync,
Spool(u32),
Drain,
Detach,
Attach,
CompactSpooled(u16),
}
fn workload(rng: &mut Rng, len: usize, max_payload: usize) -> Vec<TOp> {
(0..len)
.map(|_| match rng.below(100) {
0..=46 => TOp::Append {
sensor: SENSORS[rng.below(SENSORS.len() as u64) as usize],
len: rng.below(max_payload as u64 + 1) as usize,
},
47..=54 => TOp::Run {
count: rng.below(6) as usize + 1,
},
55..=67 => TOp::Sync,
68..=80 => TOp::Spool(rng.below(24) as u32 + 1),
81..=87 => TOp::Drain,
88..=92 => TOp::CompactSpooled(rng.below(2) as u16 + 1),
93..=96 => TOp::Detach,
_ => TOp::Attach,
})
.collect()
}
fn log_id() -> Option<LogId> {
LogId::new(LOG)
}
fn card_config() -> DbConfig {
DbConfig::new(
CURSOR_SECTORS as u32 * SECTOR as u32,
CARD_SECTORS as u16 - CURSOR_SECTORS,
1,
)
.unwrap()
.with_log_id(log_id().unwrap())
}
fn new_card() -> Card {
let flash = RemovableFlash::new(MockFlash::<PAGE, SECTOR>::new(CARD_SECTORS * SECTOR));
let mut db: Card = SensorDb::with_config(flash, card_config()).unwrap();
db.format().unwrap();
db
}
fn read_all(db: &mut Tiered) -> Result<Vec<Entry>, Error> {
let mut out = Vec::new();
db.query_all(None, |hdr, payload| {
out.push(Entry {
sensor: hdr.sensor_id,
ts: hdr.timestamp,
payload: payload.to_vec(),
});
true
})?;
Ok(out)
}
fn check(
db: &mut Tiered,
model: &[Entry],
attached: bool,
step: usize,
op: TOp,
) -> Result<(), Failure> {
let card = if attached { "in" } else { "out" };
let at = format!("step {step} after {op:?} (card {card})");
let actual = read_all(db).map_err(|e| format!("{at}: query_all: {e:?}"))?;
ensure!(
actual.len() <= model.len(),
"{at}: {} entries visible, only {} appended",
actual.len(),
model.len()
);
ensure!(
actual.windows(2).all(|w| w[0].ts < w[1].ts),
"{at}: timestamps are not strictly ascending — a duplicate or a reorder \
across the card/onboard seam\n actual: {actual:?}"
);
let mut breaks = Vec::new();
let mut previous: Option<usize> = None;
for entry in &actual {
let i = (entry.ts - 1) as usize;
ensure!(
i < model.len() && *entry == model[i],
"{at}: ts {} does not match the model entry at {i}\n expected: {:?}\n \
actual: {entry:?}",
entry.ts,
model.get(i)
);
if let Some(p) = previous
&& i != p + 1
{
breaks.push((p, i));
}
previous = Some(i);
}
ensure!(
breaks.len() <= 1,
"{at}: the union has {} gaps, and two rings can produce at most one: {breaks:?}\n \
actual: {actual:?}",
breaks.len()
);
let total = db
.count(None)
.map_err(|e| format!("{at}: count(None): {e:?}"))?;
ensure!(
total as usize == actual.len(),
"{at}: count(None) = {total}, {} visible",
actual.len()
);
for sensor in SENSORS {
let want: Vec<&Entry> = actual.iter().filter(|e| e.sensor == sensor).collect();
let counted = db
.count(Some(sensor))
.map_err(|e| format!("{at}: count({sensor}): {e:?}"))?;
ensure!(
counted as usize == want.len(),
"{at}: count({sensor}) = {counted}, {} visible",
want.len()
);
let mut buf = [0u8; PAGE];
let latest = db
.latest(sensor, &mut buf)
.map_err(|e| format!("{at}: latest({sensor}): {e:?}"))?;
match (latest, want.last()) {
(None, None) => {}
(Some((hdr, n)), Some(w)) => ensure!(
hdr.timestamp == w.ts && buf[..n] == w.payload[..],
"{at}: latest({sensor}) = ts {}, expected {:?}",
hdr.timestamp,
w
),
(a, b) => {
return Err(format!(
"{at}: latest({sensor}) presence disagrees: {:?} vs {:?}",
a.map(|(h, _)| h.timestamp),
b.map(|e| e.ts)
));
}
}
}
Ok(())
}
fn unchanged(
db: &mut Tiered,
before: &[Entry],
step: usize,
what: &str,
) -> Result<(), Failure> {
let after = read_all(db).map_err(|e| format!("step {step}: post-{what} read: {e:?}"))?;
ensure!(
after == before,
"step {step}: {what} changed the visible series\n before: {before:?}\n \
after: {after:?}"
);
Ok(())
}
fn suffix_of_before(
db: &mut Tiered,
before: &[Entry],
step: usize,
what: &str,
) -> Result<(), Failure> {
let after = read_all(db).map_err(|e| format!("step {step}: post-{what} read: {e:?}"))?;
ensure!(
after.len() <= before.len(),
"step {step}: {what} added {} entries",
after.len() - before.len()
);
let k = before.len() - after.len();
ensure!(
after == before[k..],
"step {step}: {what} did not merely drop the oldest {k}\n before: {before:?}\n \
after: {after:?}"
);
Ok(())
}
fn replay(ops: &[TOp]) -> Result<(), Failure> {
let max_payload = PAGE - 20;
let mut onboard: SensorDb<OnFlash, PAGE, SECTORS> = SensorDb::with_config(
MockFlash::new(SECTORS * SECTOR),
DbConfig::new(0, SECTORS as u16, 1)
.unwrap()
.with_log_id(log_id().unwrap()),
)
.map_err(|e| format!("onboard: {e:?}"))?;
onboard.format().map_err(|e| format!("format: {e:?}"))?;
let spooler: Spooler<CardFlash, PAGE, CARD_SECTORS> =
Spooler::new(log_id(), 0, SECTOR as u32).map_err(|e| format!("spooler: {e:?}"))?;
let mut db = TieredDb::new(onboard, spooler, WritePolicy::OnboardFirst)
.map_err(|e| format!("tiered: {e:?}"))?;
db.attach(new_card())
.map_err(|e| format!("attach: {e:?}"))?;
let mut parked: Option<Card> = None;
let mut model: Vec<Entry> = Vec::new();
let mut next_ts = 1u64;
for (step, &op) in ops.iter().enumerate() {
let before = read_all(&mut db).map_err(|e| format!("step {step}: pre-read: {e:?}"))?;
let attached_before = parked.is_none();
match op {
TOp::Append { sensor, len } => {
let len = len.min(max_payload);
let payload = payload_for(next_ts, len);
match db.append(sensor, next_ts, &payload) {
Ok(()) => {
model.push(Entry {
sensor,
ts: next_ts,
payload,
});
next_ts += 1;
}
Err(Error::NoSpace) => {}
Err(e) => return Err(format!("step {step}: append: {e:?}")),
}
}
TOp::Run { count } => {
let room = max_payload.saturating_sub(RUN_FRAME_SIZE) / size_of::<Burst>();
let count = count.clamp(1, room.max(1));
let base = next_ts;
let values: Vec<Burst> = (0..count)
.map(|i| Burst {
v: (base + i as u64) as u32,
})
.collect();
let run = Run::of(base, 1, &values)
.map_err(|e| format!("step {step}: Run::of: {e:?}"))?;
match db.append_run(&run) {
Ok(()) => {
for i in 0..count as u64 {
model.push(Entry {
sensor: Burst::SENSOR_ID,
ts: base + i,
payload: run_sample_payload(base + i),
});
}
next_ts += count as u64;
}
Err(Error::NoSpace) => {}
Err(e) => return Err(format!("step {step}: append_run: {e:?}")),
}
}
TOp::Sync => db.sync().map_err(|e| format!("step {step}: sync: {e:?}"))?,
TOp::Spool(n) => {
db.spool_step(SpoolBudget::new(n))
.map_err(|e| format!("step {step}: spool_step: {e:?}"))?;
suffix_of_before(&mut db, &before, step, "spool_step")?;
}
TOp::Drain => {
db.drain(SpoolBudget::new(16), 64)
.map_err(|e| format!("step {step}: drain: {e:?}"))?;
suffix_of_before(&mut db, &before, step, "drain")?;
}
TOp::CompactSpooled(n) => {
db.onboard_mut()
.compact(n, CompactScope::SpooledOnly)
.map_err(|e| format!("step {step}: compact: {e:?}"))?;
if attached_before {
unchanged(&mut db, &before, step, "compact(SpooledOnly)")?;
}
}
TOp::Detach => {
if let Some(card) = db.detach() {
parked = Some(card);
let after = read_all(&mut db)
.map_err(|e| format!("step {step}: post-detach read: {e:?}"))?;
ensure!(
after.len() <= before.len(),
"step {step}: detaching the card revealed {} entries",
after.len() - before.len()
);
}
}
TOp::Attach => {
if let Some(card) = parked.take() {
let mut flash = card.into_inner();
flash.insert();
let mut card: Card = SensorDb::with_config(flash, card_config())
.map_err(|e| format!("step {step}: rebuild card: {e:?}"))?;
card.mount()
.map_err(|e| format!("step {step}: card mount: {e:?}"))?;
db.attach(card)
.map_err(|e| format!("step {step}: attach: {e:?}"))?;
let after = read_all(&mut db)
.map_err(|e| format!("step {step}: post-attach read: {e:?}"))?;
ensure!(
after.len() >= before.len(),
"step {step}: attaching the card hid {} entries",
before.len() - after.len()
);
}
}
}
check(&mut db, &model, parked.is_none(), step, op)?;
}
Ok(())
}
fn shrink(ops: &[TOp]) -> (Vec<TOp>, Failure) {
let mut best = ops.to_vec();
let mut failure = match replay(&best) {
Err(f) => f,
Ok(()) => return (best, "not reproducible".into()),
};
let mut chunk = best.len() / 2;
while chunk > 0 {
let mut i = 0;
while i < best.len() {
let mut candidate = best.clone();
let end = (i + chunk).min(candidate.len());
candidate.drain(i..end);
match replay(&candidate) {
Err(f) => {
best = candidate;
failure = f;
}
Ok(()) => i += chunk,
}
}
chunk /= 2;
}
(best, failure)
}
#[test]
fn model_store_and_forward() {
for seed in 0..16u64 {
let mut rng = Rng::new(seed ^ 0x7EA5_1E55);
let ops = workload(&mut rng, 140, PAGE - 20);
if let Err(first) = replay(&ops) {
let (minimal, failure) = shrink(&ops);
let mut trace = String::new();
for (i, op) in minimal.iter().enumerate() {
let _ = writeln!(trace, " {i:3}: {op:?}");
}
panic!(
"tiered model disagreed\nseed: {seed}\n\n{failure}\n\n\
minimal failing sequence ({} ops, shrunk from {}):\n{trace}\n\
original failure was:\n{first}",
minimal.len(),
ops.len()
);
}
}
}
}