From 3550279bea05360d7d84b7cd70939106096af43b Mon Sep 17 00:00:00 2001
From: Determinant <tederminant@gmail.com>
Date: Thu, 11 Jun 2020 12:49:23 -0400
Subject: clean up test code

---
 tests/rand_fail.rs | 115 +++++++++--------------------------------------------
 1 file changed, 18 insertions(+), 97 deletions(-)

(limited to 'tests/rand_fail.rs')

diff --git a/tests/rand_fail.rs b/tests/rand_fail.rs
index e01fe58..d129e4f 100644
--- a/tests/rand_fail.rs
+++ b/tests/rand_fail.rs
@@ -1,109 +1,30 @@
 #[cfg(test)]
 
 mod common;
-use std::collections::HashMap;
-use std::rc::Rc;
-use growthring::wal::{WALLoader, WALWriter, WALStore, WALRingId, WALBytes, WALPos};
-use common::{FailGen, SingleFailGen, CountFailGen, Canvas, WALStoreEmulState, WALStoreEmul, PaintStrokes};
 
-fn run<G: 'static + FailGen, R: rand::Rng>(n: usize, m: usize, k: usize,
-                    state: &mut WALStoreEmulState, canvas: &mut Canvas, wal: WALLoader,
-                    ops: &mut Vec<PaintStrokes>, ringid_map: &mut HashMap<WALRingId, usize>,
-                    fgen: Rc<G>, rng: &mut R) -> Result<(), ()> {
-    let mut wal = wal.recover(WALStoreEmul::new(state, fgen, |_, _|{}))?;
-    for _ in 0..n {
-        let s = (0..m).map(|_|
-            PaintStrokes::gen_rand(1000, 10, 256, 5, rng)).collect::<Vec<PaintStrokes>>();
-        let recs = s.iter().map(|e| e.to_bytes()).collect::<Vec<WALBytes>>();
-        // write ahead
-        let (rids, ok) = wal.grow(recs);
-        for (e, rid) in s.iter().zip(rids.iter()) {
-            ops.push(e.clone());
-            ringid_map.insert(*rid, ops.len() - 1);
-        }
-        ok?;
-        //for rid in rids.iter() {
-        //    println!("got ring id: {:?}", rid);
-        //}
-        // WAL append done
-        // prepare data writes
-        for (e, rid) in s.into_iter().zip(rids.iter()) {
-            canvas.prepaint(&e, &*rid);
-        }
-        // run the scheduler for a bit
-        for _ in 0..k {
-            if let Some((fin_rid, t)) = canvas.rand_paint(rng) {
-                if let Some(rid) = fin_rid {
-                    wal.peel(&[rid])?
-                }
-                //trace.push(t);
-            } else { break }
-        }
-    }
-    while let Some((fin_rid, t)) = canvas.rand_paint(rng) {
-        if let Some(rid) = fin_rid {
-            wal.peel(&[rid])?
-        }
-        //trace.push(t);
-    }
-    canvas.print(40);
-    Ok(())
-}
-
-fn check(state: &mut WALStoreEmulState, canvas: &mut Canvas,
-         wal: WALLoader,
-         ops: &Vec<PaintStrokes>, ringid_map: &HashMap<WALRingId, usize>) -> bool {
-    if ops.is_empty() { return true }
-    let mut last_idx = 0;
-    canvas.clear_queued();
-    wal.recover(WALStoreEmul::new(state, Rc::new(common::ZeroFailGen), |payload, ringid| {
-        let s = PaintStrokes::from_bytes(&payload);
-        canvas.prepaint(&s, &ringid);
-        last_idx = *ringid_map.get(&ringid).unwrap() + 1;
-    })).unwrap();
-    println!("last = {}/{}", last_idx, ops.len() - 1);
-    canvas.paint_all();
-    // recover complete
-    let canvas0 = canvas.new_reference(&ops[..last_idx]);
-    let res = canvas.is_same(&canvas0);
-    if !res {
-        canvas.print(40);
-        canvas0.print(40);
-    }
-    res
-}
-
-fn get_nticks(n: usize, m: usize, k: usize, csize: usize) -> usize {
-    let mut rng = <rand::rngs::StdRng as rand::SeedableRng>::from_seed([0; 32]);
-    let mut state = WALStoreEmulState::new();
-    let wal = WALLoader::new(9, 8, 1000);
-    let mut ops: Vec<PaintStrokes> = Vec::new();
-    let mut ringid_map = HashMap::new();
-    let mut canvas = Canvas::new(csize);
-    let fgen = Rc::new(CountFailGen::new());
-    run(n, m, k, &mut state, &mut canvas, wal, &mut ops, &mut ringid_map, fgen.clone(), &mut rng).unwrap();
-    fgen.get_count()
-}
-
-fn run_(n: usize, m: usize, k: usize, csize: usize) {
-    let nticks = get_nticks(n, m, k, csize);
+fn single_point_failure(sim: &common::PaintingSim) {
+    let nticks = sim.get_nticks();
     println!("nticks = {}", nticks);
     for i in 0..nticks {
-        let mut rng = <rand::rngs::StdRng as rand::SeedableRng>::from_seed([0; 32]);
-        let mut state = WALStoreEmulState::new();
-        let wal = WALLoader::new(9, 8, 1000);
-        let mut ops: Vec<PaintStrokes> = Vec::new();
-        let mut ringid_map = HashMap::new();
-        let mut canvas = Canvas::new(csize);
-        let fgen = Rc::new(SingleFailGen::new(i));
-        if run(n, m, k, &mut state, &mut canvas, wal, &mut ops, &mut ringid_map, fgen, &mut rng).is_err() {
-            let wal = WALLoader::new(9, 8, 1000);
-            assert!(check(&mut state, &mut canvas, wal, &ops, &ringid_map));
-        }
+        print!("fail pos = {}, ", i);
+        assert!(sim.test(common::SingleFailGen::new(i)));
     }
 }
 
 #[test]
 fn test_rand_fail() {
-    run_(100, 10, 100, 1000)
+    let sim = common::PaintingSim {
+        block_nbit: 8,
+        file_nbit: 9,
+        file_cache: 1000,
+        n: 100,
+        m: 10,
+        k: 100,
+        csize: 1000,
+        stroke_max_len: 10,
+        stroke_max_col: 256,
+        stroke_max_n: 5,
+        seed: 0
+    };
+    single_point_failure(&sim);
 }
-- 
cgit v1.2.3-70-g09d2