summaryrefslogtreecommitdiffstats
path: root/src
diff options
context:
space:
mode:
authortv <tv@krebsco.de>2026-11-19 04:47:01 +0000
committertv <tv@krebsco.de>2026-11-19 04:47:01 +0000
commit680e1cd6fdeeb6dacb48598545d9e384dc52ffdc (patch)
tree0b6b93d5a42c5ef0f3b52a50ad8026e0b42811b6 /src
parent86e510f96659b3eb8c21de88107fd7b86cdde902 (diff)
properties: votes mostly on the earliest proposal, a stop sought past the cases
`the_store_judges_and_reads_as_the_model` asks that some history stop a store, where two thirds pass a version this continuum doesn't read. Merge events in the generator shifted every seeded history, and of the 64 cases with such versions none stopped; the corpus's scan found stopping seeds only past them (279, 314, 330 and others). Of the proposals a party knows, it now votes on, and writes the version event of, the earliest on the version current where it writes more often than not, so that parties vote alike and versions pass. And where none of the cases stopped a store, the test scans later seeds of those kinds till one does, up to 1000, and checks it too: a stop is checked whatever the generator's luck.
Diffstat (limited to 'src')
-rw-r--r--src/federation/properties.rs124
1 files changed, 85 insertions, 39 deletions
diff --git a/src/federation/properties.rs b/src/federation/properties.rs
index 91e038e..2b824f0 100644
--- a/src/federation/properties.rs
+++ b/src/federation/properties.rs
@@ -159,6 +159,16 @@ pub(super) fn generate_at(rng: &mut Rng, kind: Kind, revision: Option<Revision>)
.iter()
.filter(|(id, ..)| known[w].contains(id))
.collect();
+ // Of the proposals it knows, more often than not the earliest on the version current
+ // where it writes, else any: so that parties vote alike and versions pass, of those
+ // this continuum doesn't read too.
+ let earliest = mine.iter().position(|(_, _, on, _)| *on == current.hash);
+ let chosen = |rng: &mut Rng| -> (Id, Id, Id, bool) {
+ match earliest {
+ Some(at) if rng.chance(0.6) => *mine[at],
+ _ => **rng.pick(&mine),
+ }
+ };
let roll = rng.below(100);
let event = if roll < 4 {
// A node merges: one its party lists there, more often than not, else any.
@@ -222,7 +232,7 @@ pub(super) fn generate_at(rng: &mut Rng, kind: Kind, revision: Option<Revision>)
}
}
} else if roll < 85 {
- let &&(proposal, hash, on, named) = rng.pick(&mine);
+ let (proposal, hash, on, named) = chosen(rng);
let yes = if kind.adversary && w == adversary {
rng.chance(0.7)
} else {
@@ -237,7 +247,7 @@ pub(super) fn generate_at(rng: &mut Rng, kind: Kind, revision: Option<Revision>)
votes.push((Id::of(&bytes), proposal));
bytes
} else if roll < 96 || !kind.adversary {
- let &&(proposal, hash, ..) = rng.pick(&mine);
+ let (proposal, hash, ..) = chosen(rng);
let on_it: Vec<Id> = votes
.iter()
.filter(|(vote, voted)| *voted == proposal && known[w].contains(vote))
@@ -347,54 +357,90 @@ fn verdict(offered: &Offered) -> Verdict {
}
}
+/// Whether the store judges and reads `history` as the model does, its events offered in
+/// the order written; and whether it stopped.
+fn judged_as_the_model(history: &History) -> Result<bool, String> {
+ let mut model = Model::new(&history.root);
+ let mut store: Store<Federation> =
+ Store::new(history.root.clone(), Vec::new()).expect("a root");
+ for event in &history.events {
+ let id = Id::of(event);
+ let stored = verdict(&store.offer(event.clone()));
+ let modelled = model.offer(event);
+ if stored != modelled {
+ return Err(format!(
+ "{id}: the store says {stored:?}, the model {modelled:?}"
+ ));
+ }
+ }
+ if reads(&store) != model_reads(&model) {
+ return Err(format!(
+ "the store reads {:?}, the model {:?}",
+ reads(&store),
+ model_reads(&model)
+ ));
+ }
+ Ok(store.stopped().is_some())
+}
+
+/// Seeds of the kinds with versions this continuum doesn't read scanned beyond the cases
+/// where none of those stopped a store, till one does.
+const SCANNED_FOR_A_STOP: u64 = 1000;
+
/// Where parties propose versions this continuum doesn't read too, the store stops where
/// the model does: written in order, events come after what they build on, and both stop
-/// at the same event, taking the same before it.
+/// at the same event, taking the same before it. Where none of the cases stops a store,
+/// later seeds are scanned for one that does, which is checked too: a stop is checked
+/// whatever the generator's luck.
#[test]
fn the_store_judges_and_reads_as_the_model() {
let stopped = std::cell::Cell::new(0);
- for (adversary, unread, cases) in [
+ let kinds = [
(false, false, 48),
(true, false, 48),
(false, true, 32),
(true, true, 32),
- ] {
- check(
- cases,
- Kind {
- adversary,
- checkpoints: false,
- unread,
- },
- |history| {
- let mut model = Model::new(&history.root);
- let mut store: Store<Federation> =
- Store::new(history.root.clone(), Vec::new()).expect("a root");
- for event in &history.events {
- let id = Id::of(event);
- let stored = verdict(&store.offer(event.clone()));
- let modelled = model.offer(event);
- if stored != modelled {
- return Err(format!(
- "{id}: the store says {stored:?}, the model {modelled:?}"
- ));
- }
- }
- if store.stopped().is_some() {
- stopped.set(stopped.get() + 1);
- }
- if reads(&store) != model_reads(&model) {
- return Err(format!(
- "the store reads {:?}, the model {:?}",
- reads(&store),
- model_reads(&model)
- ));
+ ];
+ let kind = |adversary, unread| Kind {
+ adversary,
+ checkpoints: false,
+ unread,
+ };
+ for (adversary, unread, cases) in kinds {
+ check(cases, kind(adversary, unread), |history| {
+ if judged_as_the_model(history)? {
+ stopped.set(stopped.get() + 1);
+ }
+ Ok(())
+ });
+ }
+ // Past the seeds of the cases of the kinds with versions this continuum doesn't read.
+ let mut seed = kinds
+ .iter()
+ .filter(|(_, unread, _)| *unread)
+ .map(|(_, _, cases)| *cases)
+ .max()
+ .unwrap_or(0);
+ while stopped.get() == 0 && seed < SCANNED_FOR_A_STOP {
+ for adversary in [false, true] {
+ let history = generate(&mut Rng::new(seed), kind(adversary, true));
+ match judged_as_the_model(&history) {
+ Ok(true) => stopped.set(stopped.get() + 1),
+ Ok(false) => {}
+ Err(why) => {
+ let (history, why) = cut_down(history, why, &|history: &History| {
+ judged_as_the_model(history).map(|_| ())
+ });
+ panic!("{why}, for seed {seed}, in the history\n{}", history.show());
}
- Ok(())
- },
- );
+ }
+ }
+ seed += 1;
}
- assert!(stopped.get() > 0, "no history stopped a store");
+ assert!(
+ stopped.get() > 0,
+ "no history of the first {SCANNED_FOR_A_STOP} seeds stopped a store"
+ );
}
#[test]