From 3dcb316a5ce97048073988b4bf4cb7ce3c486303 Mon Sep 17 00:00:00 2001
From: Andrey Kuprianov <andrey@informal.systems>
Date: Wed, 2 Sep 2020 12:31:15 +0200
Subject: [PATCH 01/10] #414: testgen tester -- utilities to run multiple tests
 with logs and reports

---
 testgen/Cargo.toml    |   1 +
 testgen/src/tester.rs | 414 +++++++++++++++++++++++++++++++-----------
 2 files changed, 307 insertions(+), 108 deletions(-)

diff --git a/testgen/Cargo.toml b/testgen/Cargo.toml
index 42855ed5e..5e1d2b5b6 100644
--- a/testgen/Cargo.toml
+++ b/testgen/Cargo.toml
@@ -11,6 +11,7 @@ serde_json = "1"
 ed25519-dalek = "1"
 gumdrop = "0.8.0"
 simple-error = "0.2.1"
+tempfile = "3.1.0"
 
 [[bin]]
 name = "tendermint-testgen"
diff --git a/testgen/src/tester.rs b/testgen/src/tester.rs
index d905125c4..2b2c3902f 100644
--- a/testgen/src/tester.rs
+++ b/testgen/src/tester.rs
@@ -1,39 +1,115 @@
 use crate::helpers::*;
 use crate::tester::TestResult::{Failure, ParseError, ReadError, Success};
 use serde::de::DeserializeOwned;
-use std::panic::UnwindSafe;
-use std::{fs, path::PathBuf};
 use std::{
-    panic,
+    fs,
+    io::Write,
+    panic::{self, UnwindSafe},
+    path::{Path, PathBuf},
     sync::{Arc, Mutex},
 };
+use tempfile::TempDir;
 
+/// A test environment, which is essentially a wrapper around some directory,
+/// with some utility functions operating relative to that directory.
 #[derive(Debug, Clone)]
 pub struct TestEnv {
-    root_dir: String,
-    logs: Vec<String>,
+    /// Directory where the test is being executed
+    current_dir: String,
 }
 
 impl TestEnv {
-    pub fn add_log(&mut self, log: &str) {
-        self.logs.push(log.to_string());
+    pub fn new(current_dir: &str) -> Option<Self> {
+        fs::create_dir_all(current_dir).ok().map(|_| TestEnv {
+            current_dir: current_dir.to_string(),
+        })
     }
 
-    /// Read a file from a path relative to the environment root into a string
-    pub fn read_file(&mut self, path: &str) -> Option<String> {
-        match self.full_path(path) {
-            None => None,
-            Some(full_path) => match fs::read_to_string(&full_path) {
-                Ok(file) => Some(file),
-                Err(_) => None,
-            },
+    pub fn cleanup(&self) -> Option<()> {
+        fs::remove_dir_all(&self.current_dir)
+            .ok()
+            .and(fs::create_dir_all(&self.current_dir).ok())
+    }
+
+    pub fn push(&self, child: &str) -> Option<Self> {
+        let mut path = PathBuf::from(&self.current_dir);
+        path.push(child);
+        path.to_str().and_then(|path| TestEnv::new(path))
+    }
+
+    pub fn current_dir(&self) -> &str {
+        &self.current_dir
+    }
+
+    pub fn logln(&self, msg: &str) -> Option<()> {
+        println!("{}", msg);
+        self.full_path("_log").and_then(|full_path| {
+            fs::OpenOptions::new()
+                .create(true)
+                .append(true)
+                .open(full_path)
+                .ok()
+                .and_then(|mut file| file.write_all((String::from(msg) + "\n").as_bytes()).ok())
+        })
+    }
+
+    pub fn logln_to(&self, msg: &str, rel_path: &str) -> Option<()> {
+        println!("{}", msg);
+        self.full_path(rel_path).and_then(|full_path| {
+            fs::OpenOptions::new()
+                .create(true)
+                .append(true)
+                .open(full_path)
+                .ok()
+                .and_then(|mut file| file.write_all((String::from(msg) + "\n").as_bytes()).ok())
+        })
+    }
+
+    /// Read a file from a path relative to the environment current dir into a string
+    pub fn read_file(&self, rel_path: &str) -> Option<String> {
+        self.full_path(rel_path)
+            .and_then(|full_path| fs::read_to_string(&full_path).ok())
+    }
+
+    /// Write a file to a path relative to the environment current dir
+    pub fn write_file(&self, rel_path: &str, contents: &str) -> Option<()> {
+        self.full_path(rel_path)
+            .and_then(|full_path| fs::write(full_path, contents).ok())
+    }
+
+    /// Parse a file from a path relative to the environment current dir as the given type
+    pub fn parse_file_as<T: DeserializeOwned>(&self, rel_path: &str) -> Option<T> {
+        self.read_file(rel_path)
+            .and_then(|input| serde_json::from_str(&input).ok())
+    }
+
+    /// Copy a file from the path outside environment into the environment current dir
+    /// Returns the relative path of the file, or None if copying was not successful
+    pub fn copy_file_from(&self, path: &str) -> Option<String> {
+        let path = Path::new(path);
+        if !path.is_file() {
+            return None;
         }
+        path.file_name().and_then(|name| {
+            name.to_str().and_then(|name| {
+                self.full_path(name)
+                    .and_then(|dest| fs::copy(path, dest).ok().map(|_| name.to_string()))
+            })
+        })
+    }
+
+    /// Copy a file from the path relative to the other environment into the environment current dir
+    /// Returns the relative path of the file, or None if copying was not successful
+    pub fn copy_file_from_env(&self, other: &TestEnv, path: &str) -> Option<String> {
+        other
+            .full_path(path)
+            .and_then(|full_path| self.copy_file_from(&full_path))
     }
 
     /// Convert a relative path to the full path from the test root
     /// Return None if the full path can't be formed
     pub fn full_path(&self, rel_path: &str) -> Option<String> {
-        let full_path = PathBuf::from(&self.root_dir).join(rel_path);
+        let full_path = PathBuf::from(&self.current_dir).join(rel_path);
         match full_path.to_str() {
             None => None,
             Some(full_path) => Some(full_path.to_string()),
@@ -41,9 +117,9 @@ impl TestEnv {
     }
 
     /// Convert a full path to the path relative to the test root
-    /// Return None if the full path doesn't contain test root as prefix
+    /// Returns None if the full path doesn't contain test root as prefix
     pub fn rel_path(&self, full_path: &str) -> Option<String> {
-        match PathBuf::from(full_path).strip_prefix(&self.root_dir) {
+        match PathBuf::from(full_path).strip_prefix(&self.current_dir) {
             Err(_) => None,
             Ok(rel_path) => match rel_path.to_str() {
                 None => None,
@@ -51,28 +127,71 @@ impl TestEnv {
             },
         }
     }
-}
 
-type TestFn = Box<dyn Fn(&str) -> TestResult>;
-
-pub struct Tester {
-    root_dir: String,
-    tests: Vec<(String, TestFn)>,
-    results: std::collections::BTreeMap<String, Vec<(String, TestResult)>>,
+    /// Convert a relative path to the full path from the test root, canonicalized
+    /// Returns None the full path can't be formed
+    pub fn full_canonical_path(&self, rel_path: &str) -> Option<String> {
+        let full_path = PathBuf::from(&self.current_dir).join(rel_path);
+        full_path
+            .canonicalize()
+            .ok()
+            .and_then(|p| p.to_str().map(|x| x.to_string()))
+    }
 }
 
 #[derive(Debug, Clone)]
 pub enum TestResult {
     ReadError,
     ParseError,
-    Success(TestEnv),
+    Success,
     Failure { message: String, location: String },
 }
 
+/// A function that takes as input the test file path and its content,
+/// and returns the result of running the test on it
+type TestFn = Box<dyn Fn(&str, &str) -> TestResult>;
+
+/// A function that takes as input the batch file path and its content,
+/// and returns the vector of test names/contents for tests in the batch,
+/// or None if the batch could not be parsed
+type BatchFn = Box<dyn Fn(&str, &str) -> Option<Vec<(String, String)>>>;
+
+pub struct Test {
+    /// test name
+    pub name: String,
+    /// test function
+    pub test: TestFn,
+}
+
+/// Tester allows you to easily run some test functions over a set of test files.
+/// You create a Tester instance with the reference to some specific directory, containing your test files.
+/// After a creation, you can add several types of tests there:
+///  * add_test() adds a simple test function, which can run on some test, deserilizable from a file.
+///  * add_test_with_env() allows your test function to receive several test environments,
+///    so that it can easily perform some operations on files when necessary
+///  * add_test_batch() adds a batch of test: a function that accepts a ceserializable batch description,
+///    and produces a set of test from it
+///
+///  After you have added all your test functions, you run Tester either on individual files
+///  using run_for_file(), or for whole directories, using run_foreach_in_dir();
+///  the directories will be traversed recursively top-down.
+///
+///  The last step involves calling the finalize() function, which will produce the test report
+///  and panic in case there was at least one failing test.
+///  When there are files in the directories you run Tester on, that could not be read/parsed,
+///  it is also considered an error, and leads to panic.
+pub struct Tester {
+    name: String,
+    root_dir: String,
+    tests: Vec<Test>,
+    batches: Vec<BatchFn>,
+    results: std::collections::BTreeMap<String, Vec<(String, TestResult)>>,
+}
+
 impl TestResult {
     pub fn is_success(&self) -> bool {
         match self {
-            TestResult::Success(_) => true,
+            TestResult::Success => true,
             _ => false,
         }
     }
@@ -100,24 +219,29 @@ impl TestResult {
 }
 
 impl Tester {
-    pub fn new(root_dir: &str) -> Tester {
+    pub fn new(name: &str, root_dir: &str) -> Tester {
         Tester {
+            name: name.to_string(),
             root_dir: root_dir.to_string(),
             tests: vec![],
+            batches: vec![],
             results: Default::default(),
         }
     }
 
-    pub fn env(&self) -> TestEnv {
-        TestEnv {
-            root_dir: self.root_dir.clone(),
-            logs: vec![],
-        }
+    pub fn env(&self) -> Option<TestEnv> {
+        TestEnv::new(&self.root_dir)
     }
 
-    fn capture_test<F>(env: TestEnv, test: F) -> TestResult
+    pub fn output_env(&self) -> Option<TestEnv> {
+        fs::create_dir_all(self.root_dir.clone() + "/_" + &self.name)
+            .ok()
+            .and(TestEnv::new(&(self.root_dir.clone() + "/_" + &self.name)))
+    }
+
+    fn capture_test<F>(test: F) -> TestResult
     where
-        F: FnOnce(TestEnv) -> TestEnv + UnwindSafe,
+        F: FnOnce() + UnwindSafe,
     {
         let test_result = Arc::new(Mutex::new(ParseError));
         let old_hook = panic::take_hook();
@@ -139,11 +263,10 @@ impl Tester {
                 *result = Failure { message, location };
             })
         });
-        let test_fun = || test(env.clone());
-        let result = panic::catch_unwind(test_fun);
+        let result = panic::catch_unwind(|| test());
         panic::set_hook(old_hook);
         match result {
-            Ok(res) => Success(res),
+            Ok(_) => Success,
             Err(_) => (*test_result.lock().unwrap()).clone(),
         }
     }
@@ -152,60 +275,79 @@ impl Tester {
     where
         T: 'static + DeserializeOwned + UnwindSafe,
     {
-        let test_env = self.env();
-        let test_fn = move |input: &str| match parse_as::<T>(&input) {
-            Ok(test_case) => Tester::capture_test(test_env.clone(), |env| {
+        let test_fn = move |_path: &str, input: &str| match parse_as::<T>(&input) {
+            Ok(test_case) => Tester::capture_test(|| {
                 test(test_case);
-                env
             }),
             Err(_) => ParseError,
         };
-        self.tests.push((name.to_string(), Box::new(test_fn)));
+        self.tests.push(Test {
+            name: name.to_string(),
+            test: Box::new(test_fn),
+        });
     }
 
-    pub fn add_test_with_env<T>(&mut self, name: &str, test: fn(T, &mut TestEnv))
+    pub fn add_test_with_env<T>(&mut self, name: &str, test: fn(T, &TestEnv, &TestEnv, &TestEnv))
     where
         T: 'static + DeserializeOwned + UnwindSafe,
     {
-        let test_env = self.env();
-        let test_fn = move |input: &str| match parse_as::<T>(&input) {
-            Ok(test_case) => Tester::capture_test(test_env.clone(), |env| {
-                let mut env = env;
-                test(test_case, &mut env);
-                env
+        let test_env = self.env().unwrap();
+        let output_env = self.output_env().unwrap();
+        let test_fn = move |path: &str, input: &str| match parse_as::<T>(&input) {
+            Ok(test_case) => Tester::capture_test(|| {
+                // It is OK to unwrap() here: in case of unwrapping failure, the test will fail.
+                let dir = TempDir::new().unwrap();
+                let env = TestEnv::new(dir.path().to_str().unwrap()).unwrap();
+                let output_dir = output_env.full_path(path).unwrap();
+                let output_env = TestEnv::new(&output_dir).unwrap();
+                output_env.cleanup();
+                test(test_case, &env, &test_env, &output_env);
             }),
             Err(_) => ParseError,
         };
-        self.tests.push((name.to_string(), Box::new(test_fn)));
+        self.tests.push(Test {
+            name: name.to_string(),
+            test: Box::new(test_fn),
+        });
+    }
+
+    pub fn add_test_batch<T>(&mut self, batch: fn(T) -> Vec<(String, String)>)
+    where
+        T: 'static + DeserializeOwned,
+    {
+        let batch_fn = move |_path: &str, input: &str| match parse_as::<T>(&input) {
+            Ok(test_batch) => Some(batch(test_batch)),
+            Err(_) => None,
+        };
+        self.batches.push(Box::new(batch_fn));
     }
 
-    fn add_result(&mut self, name: &str, path: &str, result: TestResult) {
+    fn results_for(&mut self, name: &str) -> &mut Vec<(String, TestResult)> {
         self.results
             .entry(name.to_string())
             .or_insert_with(Vec::new)
-            .push((path.to_string(), result))
+    }
+
+    fn add_result(&mut self, name: &str, path: &str, result: TestResult) {
+        self.results_for(name).push((path.to_string(), result));
     }
 
     fn read_error(&mut self, path: &str) {
-        self.results
-            .entry("".to_string())
-            .or_insert_with(Vec::new)
+        self.results_for("")
             .push((path.to_string(), TestResult::ReadError))
     }
 
     fn parse_error(&mut self, path: &str) {
-        self.results
-            .entry("".to_string())
-            .or_insert_with(Vec::new)
+        self.results_for("")
             .push((path.to_string(), TestResult::ParseError))
     }
 
-    pub fn successful_tests(&self, test: &str) -> Vec<(String, TestEnv)> {
+    pub fn successful_tests(&self, test: &str) -> Vec<String> {
         let mut tests = Vec::new();
         if let Some(results) = self.results.get(test) {
             for (path, res) in results {
-                if let Success(env) = res {
-                    tests.push((path.clone(), env.clone()))
+                if let Success = res {
+                    tests.push(path.clone())
                 }
             }
         }
@@ -248,63 +390,47 @@ impl Tester {
         tests
     }
 
-    pub fn print_results(&mut self) {
-        let tests = self.unreadable_tests();
-        if !tests.is_empty() {
-            println!("Unreadable tests:  ");
-            for path in tests {
-                println!("  > {}", path)
+    fn run_for_input(&mut self, path: &str, input: &str) {
+        let mut results = Vec::new();
+        for Test { name, test } in &self.tests {
+            match test(path, input) {
+                TestResult::ParseError => continue,
+                res => results.push((name.to_string(), path, res)),
             }
-            panic!("Some tests could not be read");
         }
-        let tests = self.unparseable_tests();
-        if !tests.is_empty() {
-            println!("Unparseable tests:  ");
-            for path in tests {
-                println!("  > {}", path)
+        if !results.is_empty() {
+            for (name, path, res) in results {
+                self.add_result(&name, path, res)
             }
-            panic!("Some tests could not be parsed");
-        }
-
-        for name in self.results.keys() {
-            println!("Results for '{}'", name);
-            let tests = self.successful_tests(name);
-            if !tests.is_empty() {
-                println!("  Successful tests:  ");
-                for (path, _) in tests {
-                    println!("    > {}", path)
+        } else {
+            // parsing as a test failed; try parse as a batch
+            let mut res_tests = Vec::new();
+            for batch in &self.batches {
+                match batch(path, input) {
+                    None => continue,
+                    Some(tests) => {
+                        for (name, input) in tests {
+                            let test_path = path.to_string() + "/" + &name;
+                            res_tests.push((test_path, input));
+                        }
+                    }
                 }
             }
-            let tests = self.failed_tests(name);
-            if !tests.is_empty() {
-                println!("  Failed tests:  ");
-                for (path, message, location) in tests {
-                    println!("    > {}, '{}', {}", path, message, location)
+            if !res_tests.is_empty() {
+                for (path, input) in res_tests {
+                    self.run_for_input(&path, &input);
                 }
-                panic!("Some tests failed");
+            } else {
+                // parsing both as a test and as a batch failed
+                self.parse_error(path);
             }
         }
     }
 
     pub fn run_for_file(&mut self, path: &str) {
-        match self.env().read_file(path) {
+        match self.env().unwrap().read_file(path) {
             None => self.read_error(path),
-            Some(input) => {
-                let mut results = Vec::new();
-                for (name, test) in &self.tests {
-                    match test(&input) {
-                        TestResult::ParseError => continue,
-                        res => results.push((name.to_string(), path, res)),
-                    }
-                }
-                if results.is_empty() {
-                    self.parse_error(path);
-                } else {
-                    for (name, path, res) in results {
-                        self.add_result(&name, path, res)
-                    }
-                }
-            }
+            Some(input) => self.run_for_input(path, &input),
         }
     }
 
@@ -317,9 +443,17 @@ impl Tester {
                 Ok(paths) => {
                     for path in paths {
                         if let Ok(entry) = path {
+                            // ignore path components starting with '_'
+                            if let Some(last) = entry.path().iter().rev().next() {
+                                if let Some(last) = last.to_str() {
+                                    if last.starts_with('_') {
+                                        continue;
+                                    }
+                                }
+                            }
                             if let Ok(kind) = entry.file_type() {
                                 let path = format!("{}", entry.path().display());
-                                let rel_path = self.env().rel_path(&path).unwrap();
+                                let rel_path = self.env().unwrap().rel_path(&path).unwrap();
                                 if kind.is_file() || kind.is_symlink() {
                                     if !rel_path.ends_with(".json") {
                                         continue;
@@ -336,4 +470,68 @@ impl Tester {
             },
         }
     }
+
+    pub fn finalize(&mut self) {
+        let env = self.output_env().unwrap();
+        env.write_file("_report", "");
+        let print = |msg: &str| {
+            env.logln_to(msg, "_report");
+        };
+        let mut do_panic = false;
+
+        print(&format!(
+            "\n====== Report for '{}' tester run ======",
+            &self.name
+        ));
+        for name in self.results.keys() {
+            if name.is_empty() {
+                continue;
+            }
+            print(&format!("\nResults for '{}'", name));
+            let tests = self.successful_tests(name);
+            if !tests.is_empty() {
+                print("  Successful tests:  ");
+                for path in tests {
+                    print(&format!("    {}", path));
+                    if let Some(logs) = env.read_file(&(path + "/_log")) {
+                        print(&logs)
+                    }
+                }
+            }
+            let tests = self.failed_tests(name);
+            if !tests.is_empty() {
+                do_panic = true;
+                print("  Failed tests:  ");
+                for (path, message, location) in tests {
+                    print(&format!("    {}, '{}', {}", path, message, location));
+                    if let Some(logs) = env.read_file(&(path + "/_log")) {
+                        print(&logs)
+                    }
+                }
+            }
+        }
+        let tests = self.unreadable_tests();
+        if !tests.is_empty() {
+            do_panic = true;
+            print("\nUnreadable tests:  ");
+            for path in tests {
+                print(&format!("  {}", path))
+            }
+        }
+        let tests = self.unparseable_tests();
+        if !tests.is_empty() {
+            do_panic = true;
+            print("\nUnparseable tests:  ");
+            for path in tests {
+                print(&format!("  {}", path))
+            }
+        }
+        print(&format!(
+            "\n====== End of report for '{}' tester run ======\n",
+            &self.name
+        ));
+        if do_panic {
+            panic!("Some tests failed or could not be read/parsed");
+        }
+    }
 }

From b5853cab3585e1ec714c98c907cca50177e00cc4 Mon Sep 17 00:00:00 2001
From: Andrey Kuprianov <andrey@informal.systems>
Date: Wed, 2 Sep 2020 13:32:14 +0200
Subject: [PATCH 02/10] 14: add testgen commands, in particular to call
 apalache and jsonatr

---
 testgen/jsonatr-lib/apalache-tendermint.json  | 150 ++++++++++++++++++
 .../jsonatr-lib/apalache_to_lite_test.json    |  42 +++++
 testgen/jsonatr-lib/tendermint.json           |  31 ++++
 testgen/jsonatr-lib/unix.json                 |  29 ++++
 testgen/src/apalache.rs                       | 122 ++++++++++++++
 testgen/src/command.rs                        |  82 ++++++++++
 testgen/src/jsonatr.rs                        |  36 +++++
 testgen/src/lib.rs                            |  16 +-
 8 files changed, 505 insertions(+), 3 deletions(-)
 create mode 100644 testgen/jsonatr-lib/apalache-tendermint.json
 create mode 100644 testgen/jsonatr-lib/apalache_to_lite_test.json
 create mode 100644 testgen/jsonatr-lib/tendermint.json
 create mode 100644 testgen/jsonatr-lib/unix.json
 create mode 100644 testgen/src/apalache.rs
 create mode 100644 testgen/src/command.rs
 create mode 100644 testgen/src/jsonatr.rs

diff --git a/testgen/jsonatr-lib/apalache-tendermint.json b/testgen/jsonatr-lib/apalache-tendermint.json
new file mode 100644
index 000000000..d56efc334
--- /dev/null
+++ b/testgen/jsonatr-lib/apalache-tendermint.json
@@ -0,0 +1,150 @@
+{
+  "description": "Transformers for Apalache counterexamples (CEs) with Tendermint blockchains",
+  "use": [
+    "tendermint.json"
+  ],
+  "input": [
+    {
+      "name": "first_state",
+      "description": "extract the first state from Apalache CE",
+      "kind": "INLINE",
+      "source": "$.declarations[1].body.and | unwrap"
+    },
+    {
+      "name": "last_state",
+      "description": "extract the last state from Apalache CE",
+      "kind": "INLINE",
+      "source": "$.declarations[-2].body.and | unwrap"
+    },
+    {
+      "name": "history",
+      "description": "extract the history from the last state of Apalache CE",
+      "kind": "INLINE",
+      "source": "$last_state..[?(@.eq == 'history')].arg.atat..arg.record"
+    },
+    {
+      "name": "states",
+      "description": "extract all state from Apalache CE",
+      "kind": "INLINE",
+      "source": "$.declarations[1:-1].body.and"
+    },
+    {
+      "name": "lightblock_commits",
+      "description": "extract commits from a LightClient block of Apalache CE",
+      "kind": "INLINE",
+      "source": "$..[?(@.key.str == 'Commits')].value..str"
+    },
+    {
+      "name": "block_validators",
+      "description": "extract validators from a block of Apalache CE",
+      "kind": "INLINE",
+      "source": "$..[?(@.key.str == 'VS')].value..str"
+    },
+    {
+      "name": "block_next_validators",
+      "description": "extract next validators from a block of Apalache CE",
+      "kind": "INLINE",
+      "source": "$..[?(@.key.str == 'NextVS')].value..str"
+    },
+    {
+      "name": "block_height",
+      "description": "extract height from a block of Apalache CE",
+      "kind": "INLINE",
+      "source": "$..[?(@.key.str == 'height')].value | unwrap"
+    },
+    {
+      "name": "block_time",
+      "description": "extract time from a block of Apalache CE",
+      "kind": "INLINE",
+      "source": "$..[?(@.key.str == 'time')].value | unwrap"
+    },
+    {
+      "name": "id_to_validator",
+      "description": "transform an identifier into a validator expected by `tendermint-testgen validator`",
+      "kind": "INLINE",
+      "source": {
+        "id": "$",
+        "voting_power": 50
+      }
+    },
+    {
+      "name": "id_to_vote",
+      "description": "transform an identifier into a vote expected by `tendermint-testgen vote`",
+      "kind": "INLINE",
+      "source": {
+        "validator": "$ | id_to_validator",
+        "header": "$header"
+      }
+    },
+    {
+      "name": "block_to_header",
+      "description": "transform a block from Apalache CE into a header expected by `tendermint-testgen header`",
+      "kind": "INLINE",
+      "source": {
+        "validators": "$ | block_validators | map(id_to_validator)",
+        "next_validators": "$ | block_next_validators | map(id_to_validator)",
+        "height": "$ | block_height",
+        "time": "$ | block_time"
+      }
+    },
+    {
+      "name": "block_to_commit",
+      "description": "transform a block from Apalache CE into a commit expected by `tendermint-testgen commit`",
+      "kind": "INLINE",
+      "let": {
+        "header": "$ | block_to_header"
+      },
+      "source": {
+        "header": "$header",
+        "votes": "$ | lightblock_commits | map(id_to_vote)"
+      }
+    },
+    {
+      "name": "ids_to_validators",
+      "description": "transform a non-empty array of identifiers into Tendermint validators",
+      "kind": "INLINE",
+      "source": "$ | map(id_to_validator) | map(tendermint_validator)"
+    },
+    {
+      "name": "empty_array",
+      "description": "just an empty array",
+      "kind": "INLINE",
+      "source": []
+    },
+    {
+      "name": "first_validator",
+      "description": "extract first validator from a non-empty array of identifiers",
+      "kind": "INLINE",
+      "source": "$[0] | unwrap | id_to_validator | tendermint_validator"
+    },
+    {
+      "name": "const_id",
+      "description": "constant identifier",
+      "kind": "INLINE",
+      "source": "a"
+    },    {
+      "name": "fixed_validator",
+      "description": "extract first validator from a non-empty array of identifiers",
+      "kind": "INLINE",
+      "source": "$const_id | id_to_validator | tendermint_validator"
+    },
+    {
+      "name": "ids_to_validator_set",
+      "description": "transform an array of identifiers into a JSON-encoded Tendermint validator set",
+      "kind": "INLINE",
+      "source": {
+        "validators": "$ | ifelse(ids_to_validators,empty_array)",
+        "proposer": "$ | ifelse(first_validator,fixed_validator)"
+      }
+    },
+    {
+      "name": "block_to_signed_header",
+      "description": "transform a block from Apalache CE into a JSON-encoded Tendermint signed header",
+      "kind": "INLINE",
+      "source": {
+        "header": "$ | block_to_header | tendermint_header",
+        "commit": "$ | block_to_commit | tendermint_commit"
+      }
+    }
+  ]
+}
\ No newline at end of file
diff --git a/testgen/jsonatr-lib/apalache_to_lite_test.json b/testgen/jsonatr-lib/apalache_to_lite_test.json
new file mode 100644
index 000000000..0df1663f0
--- /dev/null
+++ b/testgen/jsonatr-lib/apalache_to_lite_test.json
@@ -0,0 +1,42 @@
+{
+  "description": "Transform an Apalache counterexample into a Tendermint LightClient test",
+  "use": [
+    "unix.json",
+    "apalache-tendermint.json"
+  ],
+  "input": [
+    {
+      "name": "block_to_initial_block",
+      "description": "transforms a block from Apalache CE into a JSON-encoded Tendermint initial light block",
+      "kind": "INLINE",
+      "source": {
+        "signed_header": "$ | block_to_signed_header",
+        "next_validator_set": "$ | block_next_validators | ids_to_validator_set",
+        "trusting_period": "1400000000000",
+        "now": "$utc_timestamp"
+      }
+    },
+    {
+      "name": "state_to_lite_block_verdict",
+      "description": "transforms a block from Apalache CE into a JSON-encoded Tendermint light block",
+      "kind": "INLINE",
+      "let": {
+        "block": "$..[?(@.key.str == 'current')].value"
+      },
+      "source": {
+        "block": {
+          "signed_header": "$block | block_to_signed_header",
+          "validator_set": "$block | block_validators | ids_to_validator_set",
+          "next_validator_set": "$block | block_next_validators | ids_to_validator_set"
+        },
+        "now": "$..[?(@.key.str == 'now')].value | unwrap | tendermint_time",
+        "verdict": "$..[?(@.key.str == 'verdict')].value.str | unwrap"
+      }
+    }
+  ],
+  "output": {
+    "description": "auto-generated from Apalache counterexample",
+    "initial": "$history[0]..[?(@.key.str == 'current')].value | block_to_initial_block",
+    "input": "$history[1:] | map(state_to_lite_block_verdict)"
+  }
+}
diff --git a/testgen/jsonatr-lib/tendermint.json b/testgen/jsonatr-lib/tendermint.json
new file mode 100644
index 000000000..ba119bd81
--- /dev/null
+++ b/testgen/jsonatr-lib/tendermint.json
@@ -0,0 +1,31 @@
+{
+  "description": "Transformers for generating Tendermint datastructures",
+  "prerequisites": "add tendermint-testgen to your $PATH",
+  "input": [
+    {
+      "name": "tendermint_validator",
+      "kind": "COMMAND",
+      "source": "tendermint-testgen --stdin validator"
+    },
+    {
+      "name": "tendermint_header",
+      "kind": "COMMAND",
+      "source": "tendermint-testgen --stdin header"
+    },
+    {
+      "name": "tendermint_commit",
+      "kind": "COMMAND",
+      "source": "tendermint-testgen --stdin commit"
+    },
+    {
+      "name": "tendermint_vote",
+      "kind": "COMMAND",
+      "source": "tendermint-testgen --stdin vote"
+    },
+    {
+      "name": "tendermint_time",
+      "kind": "COMMAND",
+      "source": "tendermint-testgen --stdin time"
+    }
+  ]
+}
diff --git a/testgen/jsonatr-lib/unix.json b/testgen/jsonatr-lib/unix.json
new file mode 100644
index 000000000..ee31c113b
--- /dev/null
+++ b/testgen/jsonatr-lib/unix.json
@@ -0,0 +1,29 @@
+{
+  "description": "Useful external commands",
+  "input": [
+    {
+      "name": "date",
+      "kind": "COMMAND",
+      "source": "date -I",
+      "stdin": false
+    },
+    {
+      "name": "utc_timestamp",
+      "kind": "COMMAND",
+      "source": "date --utc +%FT%H:%M:%S.%NZ",
+      "stdin": false
+    },
+    {
+      "name": "utc_timestamp_hour_ago",
+      "kind": "COMMAND",
+      "source": "date --utc +%FT%H:%M:%S.%NZ --date '-1 hour'",
+      "stdin": false
+    },
+    {
+      "name": "utc_timestamp_2hours_ago",
+      "kind": "COMMAND",
+      "source": "date --utc +%FT%H:%M:%S.%NZ --date '-2 hour'",
+      "stdin": false
+    }
+  ]
+}
\ No newline at end of file
diff --git a/testgen/src/apalache.rs b/testgen/src/apalache.rs
new file mode 100644
index 000000000..1c0ce83aa
--- /dev/null
+++ b/testgen/src/apalache.rs
@@ -0,0 +1,122 @@
+use crate::{command::*, tester::TestEnv};
+use serde::{Deserialize, Serialize};
+use std::io;
+
+#[derive(Deserialize, Clone, Debug)]
+pub struct ApalacheTestBatch {
+    pub description: String,
+    pub model: String,
+    pub length: Option<u64>,
+    pub timeout: Option<u64>,
+    pub tests: Vec<String>,
+}
+
+#[derive(Serialize, Deserialize, Clone, Debug)]
+pub struct ApalacheTestCase {
+    pub model: String,
+    pub test: String,
+    pub length: Option<u64>,
+    pub timeout: Option<u64>,
+}
+
+pub enum ApalacheRun {
+    /// Apalache has found a counterexample
+    Counterexample(CommandRun),
+    /// Apalache has not found a counterexample up to specified length bound
+    NoCounterexample(CommandRun),
+    /// Apalache has found a deadlock
+    Deadlock(CommandRun),
+    /// Apalache model checking run failed (e.g. a parsing error)
+    ModelError(CommandRun),
+    /// Apalache returned an unknown error code
+    Unknown(CommandRun),
+    /// The tool has reached the specified timeout without producing an answer
+    Timeout(CommandRun),
+}
+
+impl ApalacheRun {
+    pub fn message(&self) -> &str {
+        match self {
+            ApalacheRun::Counterexample(_) => "Apalache has generated a counterexample",
+            ApalacheRun::NoCounterexample(_) => "Apalache failed to generate a counterexample; consider increasing the length bound, or changing your test",
+            ApalacheRun::Deadlock(_) => "Apalache has found a deadlock; please inspect your model and test",
+            ApalacheRun::ModelError(_) => "Apalache failed to process the model; please check it",
+            ApalacheRun::Unknown(_) => "Apalache has generated an unknown outcome; please contact Apalache developers",
+            ApalacheRun::Timeout(_) => "Apalache failed to generate a counterexample within given time; consider increasing the timeout, or changing your test",
+        }
+    }
+}
+
+pub fn run_apalache_test(dir: &str, test: ApalacheTestCase) -> io::Result<ApalacheRun> {
+    let inv = test.test.clone() + "Inv";
+
+    // Mutate the model: negate the test assertion to get the invariant to check
+    let mutation_failed = || {
+        io::Error::new(
+            io::ErrorKind::InvalidInput,
+            "failed to mutate the model and add invariant",
+        )
+    };
+    let env = TestEnv::new(dir).ok_or_else(mutation_failed)?;
+    let model = env.read_file(&test.model).unwrap();
+    let mut new_model = String::new();
+    for line in model.lines() {
+        if line.starts_with(&inv) {
+            // invariant already present; skip mutation
+            new_model.clear();
+            break;
+        }
+        if line.starts_with("======") {
+            new_model += &(inv.clone() + " == ~" + &test.test + "\n")
+        }
+        new_model += line;
+        new_model += "\n";
+    }
+    if !new_model.is_empty() {
+        env.write_file(&test.model, &new_model)
+            .ok_or_else(mutation_failed)?;
+    }
+
+    // Run Apalache, and process the result
+    let mut cmd = Command::new();
+    if let Some(timeout) = test.timeout {
+        cmd.program("timeout");
+        cmd.arg(&timeout.to_string());
+        cmd.arg("apalache-mc");
+    } else {
+        cmd.program("apalache-mc");
+    }
+    cmd.arg("check");
+    cmd.arg_from_parts(vec!["--inv=", &inv]);
+    if let Some(length) = test.length {
+        cmd.arg_from_parts(vec!["--length=", &length.to_string()]);
+    }
+    cmd.arg(&test.model);
+    if !dir.is_empty() {
+        cmd.current_dir(dir);
+    }
+    match cmd.spawn() {
+        Ok(run) => {
+            if run.status.success() {
+                if run.stdout.contains("The outcome is: NoError") {
+                    Ok(ApalacheRun::NoCounterexample(run))
+                } else if run.stdout.contains("The outcome is: Error") {
+                    Ok(ApalacheRun::Counterexample(run))
+                } else if run.stdout.contains("The outcome is: Deadlock") {
+                    Ok(ApalacheRun::Deadlock(run))
+                } else {
+                    Ok(ApalacheRun::Unknown(run))
+                }
+            } else if let Some(code) = run.status.code() {
+                match code {
+                    99 => Ok(ApalacheRun::ModelError(run)),
+                    124 => Ok(ApalacheRun::Timeout(run)),
+                    _ => Ok(ApalacheRun::Unknown(run)),
+                }
+            } else {
+                Ok(ApalacheRun::Timeout(run))
+            }
+        }
+        Err(e) => Err(e),
+    }
+}
diff --git a/testgen/src/command.rs b/testgen/src/command.rs
new file mode 100644
index 000000000..c6aca4576
--- /dev/null
+++ b/testgen/src/command.rs
@@ -0,0 +1,82 @@
+use std::io::Read;
+use std::{io, process};
+
+/// A thin wrapper around process::Command to facilitate running external commands.
+pub struct Command {
+    program: Option<String>,
+    args: Vec<String>,
+    dir: Option<String>,
+}
+
+/// The result of a command execution if the child process managed to execute
+pub struct CommandRun {
+    pub status: process::ExitStatus,
+    pub stdout: String,
+    pub stderr: String,
+}
+
+impl Command {
+    /// Check whether the given program can be executed
+    pub fn exists_program(program: &str) -> bool {
+        Command::new().program(program).spawn().is_ok()
+    }
+    /// Construct a new Command
+    pub fn new() -> Command {
+        Command {
+            program: None,
+            args: vec![],
+            dir: None,
+        }
+    }
+    /// Set the program to run
+    pub fn program(&mut self, program: &str) -> &mut Self {
+        self.program = Some(program.to_owned());
+        self
+    }
+    /// Add a new program argument
+    pub fn arg(&mut self, arg: &str) -> &mut Self {
+        self.args.push(arg.to_owned());
+        self
+    }
+    /// Add a new program argument, concatenated from several parts
+    pub fn arg_from_parts(&mut self, parts: Vec<&str>) -> &mut Self {
+        let mut arg: String = String::new();
+        for part in parts {
+            arg += part;
+        }
+        self.args.push(arg);
+        self
+    }
+    /// Set the working directory for the child process
+    pub fn current_dir(&mut self, dir: &str) -> &mut Self {
+        self.dir = Some(dir.to_owned());
+        self
+    }
+    /// Execute the command as a child process, and extract its status, stdout, stderr.
+    pub fn spawn(&mut self) -> io::Result<CommandRun> {
+        match &self.program {
+            None => Err(io::Error::new(io::ErrorKind::InvalidInput, "")),
+            Some(program) => {
+                let mut command = process::Command::new(program);
+                command
+                    .args(&self.args)
+                    .stdout(process::Stdio::piped())
+                    .stderr(process::Stdio::piped());
+                if let Some(dir) = &self.dir {
+                    command.current_dir(dir);
+                }
+                let mut process = command.spawn()?;
+                let status = process.wait()?;
+                let mut stdout = String::new();
+                process.stdout.unwrap().read_to_string(&mut stdout)?;
+                let mut stderr = String::new();
+                process.stderr.unwrap().read_to_string(&mut stderr)?;
+                Ok(CommandRun {
+                    status,
+                    stdout,
+                    stderr,
+                })
+            }
+        }
+    }
+}
diff --git a/testgen/src/jsonatr.rs b/testgen/src/jsonatr.rs
new file mode 100644
index 000000000..028065417
--- /dev/null
+++ b/testgen/src/jsonatr.rs
@@ -0,0 +1,36 @@
+use crate::command::*;
+use serde::Deserialize;
+use std::io;
+
+#[derive(Deserialize, Clone, Debug)]
+pub struct JsonatrTransform {
+    pub input: String,
+    pub include: Vec<String>,
+    pub output: String,
+}
+
+pub fn run_jsonatr_transform(dir: &str, transform: JsonatrTransform) -> io::Result<CommandRun> {
+    let mut cmd = Command::new();
+    cmd.program("jsonatr");
+    cmd.arg("--in");
+    cmd.arg(&transform.input);
+    cmd.arg("--out");
+    cmd.arg(&transform.output);
+    for include in transform.include {
+        cmd.arg("--use");
+        cmd.arg(&include);
+    }
+    if !dir.is_empty() {
+        cmd.current_dir(dir);
+    }
+    match cmd.spawn() {
+        Ok(run) => {
+            if run.status.success() {
+                Ok(run)
+            } else {
+                Err(io::Error::new(io::ErrorKind::Interrupted, run.stderr))
+            }
+        }
+        Err(e) => Err(e),
+    }
+}
diff --git a/testgen/src/lib.rs b/testgen/src/lib.rs
index 861714dfd..8e6606a99 100644
--- a/testgen/src/lib.rs
+++ b/testgen/src/lib.rs
@@ -1,18 +1,28 @@
 #[macro_use]
 pub mod helpers;
 
+/// Helper types for generating Tendermint datastructures
 pub mod commit;
 pub mod consensus;
 pub mod generator;
 pub mod header;
-pub mod tester;
+pub mod time;
 pub mod validator;
 pub mod vote;
 
 pub use commit::Commit;
 pub use generator::Generator;
 pub use header::Header;
-pub use tester::TestEnv;
-pub use tester::Tester;
+pub use time::Time;
 pub use validator::Validator;
 pub use vote::Vote;
+
+/// Helpers for organizing and running the tests
+pub mod apalache;
+pub mod command;
+pub mod jsonatr;
+pub mod tester;
+
+pub use command::Command;
+pub use tester::TestEnv;
+pub use tester::Tester;

From d9167e1487614c44f738b40319d7ece1c4c612b6 Mon Sep 17 00:00:00 2001
From: Andrey Kuprianov <andrey@informal.systems>
Date: Wed, 2 Sep 2020 13:48:22 +0200
Subject: [PATCH 03/10] #414: add model-based test driver to LightClient tests

---
 light-client/src/tests.rs                     |  46 +++++
 light-client/tests/light_client.rs            |  53 +-----
 light-client/tests/model_based.rs             | 176 ++++++++++++++++++
 light-client/tests/supervisor.rs              |   4 +-
 .../support/model_based/Blockchain_A_1.tla    |   1 +
 .../tests/support/model_based/LightTests.tla  |  40 ++++
 .../support/model_based/Lightclient_A_1.tla   |   1 +
 .../support/model_based/MC4_4_faulty.json     |  11 ++
 .../support/model_based/MC4_4_faulty.tla      |  16 ++
 .../tests/support/model_based/README.md       |  66 +++++++
 .../tests/support/model_based/_jsonatr-lib    |   1 +
 11 files changed, 366 insertions(+), 49 deletions(-)
 create mode 100644 light-client/tests/model_based.rs
 create mode 120000 light-client/tests/support/model_based/Blockchain_A_1.tla
 create mode 100644 light-client/tests/support/model_based/LightTests.tla
 create mode 120000 light-client/tests/support/model_based/Lightclient_A_1.tla
 create mode 100644 light-client/tests/support/model_based/MC4_4_faulty.json
 create mode 100644 light-client/tests/support/model_based/MC4_4_faulty.tla
 create mode 100644 light-client/tests/support/model_based/README.md
 create mode 120000 light-client/tests/support/model_based/_jsonatr-lib

diff --git a/light-client/src/tests.rs b/light-client/src/tests.rs
index dcc407bcb..6ad1a400e 100644
--- a/light-client/src/tests.rs
+++ b/light-client/src/tests.rs
@@ -8,9 +8,14 @@ use tendermint_rpc as rpc;
 
 use crate::components::clock::Clock;
 use crate::components::io::{AtHeight, Io, IoError};
+use crate::components::verifier::{ProdVerifier, Verdict, Verifier};
+use crate::errors::Error;
 use crate::evidence::EvidenceReporter;
+use crate::light_client::{LightClient, Options};
+use crate::state::State;
 use contracts::contract_trait;
 use std::collections::HashMap;
+use std::time::Duration;
 use tendermint::block::Height as HeightStr;
 use tendermint::evidence::{Duration as DurationStr, Evidence};
 
@@ -148,6 +153,47 @@ impl MockEvidenceReporter {
     }
 }
 
+pub fn verify_single(
+    trusted_state: Trusted,
+    input: LightBlock,
+    trust_threshold: TrustThreshold,
+    trusting_period: Duration,
+    clock_drift: Duration,
+    now: Time,
+) -> Result<LightBlock, Verdict> {
+    let verifier = ProdVerifier::default();
+
+    let trusted_state = LightBlock::new(
+        trusted_state.signed_header,
+        trusted_state.next_validators.clone(),
+        trusted_state.next_validators,
+        default_peer_id(),
+    );
+
+    let options = Options {
+        trust_threshold,
+        trusting_period,
+        clock_drift,
+    };
+
+    let result = verifier.verify(&input, &trusted_state, &options, now);
+
+    match result {
+        Verdict::Success => Ok(input),
+        error => Err(error),
+    }
+}
+
+pub fn verify_bisection(
+    untrusted_height: Height,
+    light_client: &mut LightClient,
+    state: &mut State,
+) -> Result<Vec<LightBlock>, Error> {
+    light_client
+        .verify_to_target(untrusted_height, state)
+        .map(|_| state.get_trace(untrusted_height))
+}
+
 // -----------------------------------------------------------------------------
 // Everything below is a temporary workaround for the lack of `provider` field
 // in the light blocks serialized in the JSON fixtures.
diff --git a/light-client/tests/light_client.rs b/light-client/tests/light_client.rs
index 8c6d1146c..d618d2350 100644
--- a/light-client/tests/light_client.rs
+++ b/light-client/tests/light_client.rs
@@ -5,14 +5,14 @@ use tendermint_light_client::{
     components::{
         io::{AtHeight, Io},
         scheduler,
-        verifier::{ProdVerifier, Verdict, Verifier},
+        verifier::ProdVerifier,
     },
     errors::{Error, ErrorKind},
     light_client::{LightClient, Options},
     state::State,
     store::{memory::MemoryStore, LightStore},
     tests::{Trusted, *},
-    types::{Height, LightBlock, Status, Time, TrustThreshold},
+    types::{LightBlock, Status, TrustThreshold},
 };
 
 use tendermint_testgen::Tester;
@@ -21,47 +21,6 @@ use tendermint_testgen::Tester;
 // https://github.com/informalsystems/conformance-tests
 const TEST_FILES_PATH: &str = "./tests/support/";
 
-fn verify_single(
-    trusted_state: Trusted,
-    input: LightBlock,
-    trust_threshold: TrustThreshold,
-    trusting_period: Duration,
-    clock_drift: Duration,
-    now: Time,
-) -> Result<LightBlock, Verdict> {
-    let verifier = ProdVerifier::default();
-
-    let trusted_state = LightBlock::new(
-        trusted_state.signed_header,
-        trusted_state.next_validators.clone(),
-        trusted_state.next_validators,
-        default_peer_id(),
-    );
-
-    let options = Options {
-        trust_threshold,
-        trusting_period,
-        clock_drift,
-    };
-
-    let result = verifier.verify(&input, &trusted_state, &options, now);
-
-    match result {
-        Verdict::Success => Ok(input),
-        error => Err(error),
-    }
-}
-
-fn verify_bisection(
-    untrusted_height: Height,
-    light_client: &mut LightClient,
-    state: &mut State,
-) -> Result<Vec<LightBlock>, Error> {
-    light_client
-        .verify_to_target(untrusted_height, state)
-        .map(|_| state.get_trace(untrusted_height))
-}
-
 struct BisectionTestResult {
     untrusted_light_block: LightBlock,
     new_states: Result<Vec<LightBlock>, Error>,
@@ -229,17 +188,17 @@ fn bisection_lower_test(tc: TestBisection<AnonLightBlock>) {
 
 #[test]
 fn run_single_step_tests() {
-    let mut tester = Tester::new(TEST_FILES_PATH);
+    let mut tester = Tester::new("single_step", TEST_FILES_PATH);
     tester.add_test("single-step test", single_step_test);
     tester.run_foreach_in_dir("single_step");
-    tester.print_results();
+    tester.finalize();
 }
 
 #[test]
 fn run_bisection_tests() {
-    let mut tester = Tester::new(TEST_FILES_PATH);
+    let mut tester = Tester::new("bisection", TEST_FILES_PATH);
     tester.add_test("bisection test", bisection_test);
     tester.add_test("bisection lower test", bisection_lower_test);
     tester.run_foreach_in_dir("bisection/single_peer");
-    tester.print_results();
+    tester.finalize();
 }
diff --git a/light-client/tests/model_based.rs b/light-client/tests/model_based.rs
new file mode 100644
index 000000000..026e1a996
--- /dev/null
+++ b/light-client/tests/model_based.rs
@@ -0,0 +1,176 @@
+use serde::Deserialize;
+use std::time::Duration;
+use tendermint_light_client::components::verifier::Verdict;
+use tendermint_light_client::{
+    tests::{Trusted, *},
+    types::{LightBlock, Time, TrustThreshold},
+};
+use tendermint_testgen::{apalache::*, jsonatr::*, Command, TestEnv, Tester};
+
+#[derive(Deserialize, Clone, Debug, PartialEq)]
+pub enum LiteTestKind {
+    SingleStep,
+    Bisection,
+}
+
+/// An abstraction of the LightClient verification verdict
+#[derive(Deserialize, Clone, Debug, PartialEq)]
+pub enum LiteVerdict {
+    /// verified successfully
+    #[serde(rename = "SUCCESS")]
+    Success,
+    /// outside of trusting period
+    #[serde(rename = "FAILED_TRUSTING_PERIOD")]
+    FailedTrustingPeriod,
+    /// block verification based on the header and commit structure failed
+    #[serde(rename = "INVALID")]
+    Invalid,
+    /// passed block verification, but the validator set is too different to verify it
+    #[serde(rename = "NOT_ENOUGH_TRUST")]
+    NotEnoughTrust,
+}
+
+/// A single-step test case is a test for `Verifier::verify()` function.
+/// It contains an initial trusted block, plus a sequence of input blocks,
+/// each with the expected verdict.
+/// The trusted state is to be updated only if the verdict is "Success"
+#[derive(Deserialize, Clone, Debug)]
+pub struct SingleStepTestCase {
+    description: String,
+    initial: Initial,
+    input: Vec<BlockVerdict>,
+}
+
+/// A LiteBlock together with the time when it's being checked, and the expected verdict
+#[derive(Deserialize, Clone, Debug)]
+pub struct BlockVerdict {
+    block: AnonLightBlock,
+    now: Time,
+    verdict: LiteVerdict,
+}
+
+fn single_step_test(
+    tc: SingleStepTestCase,
+    _env: &TestEnv,
+    _root_env: &TestEnv,
+    output_env: &TestEnv,
+) {
+    let mut latest_trusted = Trusted::new(
+        tc.initial.signed_header.clone(),
+        tc.initial.next_validator_set.clone(),
+    );
+    let clock_drift = Duration::from_secs(1);
+    let trusting_period: Duration = tc.initial.trusting_period.into();
+    for (i, input) in tc.input.iter().enumerate() {
+        output_env.logln(&format!("    > step {}, expecting {:?}", i, input.verdict));
+        let now = input.now;
+        match verify_single(
+            latest_trusted.clone(),
+            input.block.clone().into(),
+            TrustThreshold::default(),
+            trusting_period,
+            clock_drift,
+            now,
+        ) {
+            Ok(new_state) => {
+                assert_eq!(input.verdict, LiteVerdict::Success);
+                let expected_state: LightBlock = input.block.clone().into();
+                assert_eq!(new_state, expected_state);
+                latest_trusted = Trusted::new(new_state.signed_header, new_state.next_validators);
+            }
+            Err(e) => {
+                output_env.logln(&format!("      > lite: {:?}", e));
+                match e {
+                    Verdict::Invalid(_) => assert_eq!(input.verdict, LiteVerdict::Invalid),
+                    Verdict::NotEnoughTrust(_) => {
+                        assert_eq!(input.verdict, LiteVerdict::NotEnoughTrust)
+                    }
+                    Verdict::Success => {
+                        panic!("verify_single() returned error with Verdict::Success")
+                    }
+                }
+            }
+        }
+    }
+}
+
+fn model_based_test(
+    test: ApalacheTestCase,
+    env: &TestEnv,
+    root_env: &TestEnv,
+    output_env: &TestEnv,
+) {
+    println!("  Running model-based single-step test case: {}", test.test);
+    let check_program = |program| {
+        if !Command::exists_program(program) {
+            output_env.logln(&format!("    > {} not found", program));
+            return false;
+        }
+        true
+    };
+    if !check_program("tendermint-testgen")
+        || !check_program("apalache-mc")
+        || !check_program("jsonatr")
+    {
+        output_env.logln("    failed to find necessary programs; consider adding them to your PATH. skipping the test");
+        return;
+    }
+    env.copy_file_from_env(root_env, "Lightclient_A_1.tla");
+    env.copy_file_from_env(root_env, "Blockchain_A_1.tla");
+    env.copy_file_from_env(root_env, "LightTests.tla");
+    env.copy_file_from_env(root_env, &test.model);
+
+    println!("  > running Apalache...");
+    match run_apalache_test(env.current_dir(), test) {
+        Ok(run) => match run {
+            ApalacheRun::Counterexample(_) => (),
+            run => panic!(run.message().to_string()),
+        },
+        Err(e) => panic!("failed to run Apalache; reason: {}", e),
+    }
+
+    let transform_spec = root_env
+        .full_canonical_path("_jsonatr-lib/apalache_to_lite_test.json")
+        .unwrap();
+    let transform = JsonatrTransform {
+        input: "counterexample.json".to_string(),
+        include: vec![transform_spec],
+        output: "test.json".to_string(),
+    };
+    assert!(run_jsonatr_transform(env.current_dir(), transform).is_ok());
+    output_env.copy_file_from_env(env, "test.json");
+
+    let tc = env
+        .parse_file_as::<SingleStepTestCase>("test.json")
+        .unwrap();
+    println!("  > running auto-generated test...");
+    single_step_test(tc, env, root_env, output_env);
+    output_env.copy_file_from_env(env, "counterexample.tla");
+    output_env.copy_file_from_env(env, "counterexample.json");
+}
+
+fn model_based_test_batch(batch: ApalacheTestBatch) -> Vec<(String, String)> {
+    let mut res = Vec::new();
+    for test in batch.tests {
+        let tc = ApalacheTestCase {
+            model: batch.model.clone(),
+            test: test.clone(),
+            length: batch.length,
+            timeout: batch.timeout,
+        };
+        res.push((test.clone(), serde_json::to_string(&tc).unwrap()));
+    }
+    res
+}
+
+const TEST_DIR: &str = "./tests/support/model_based";
+
+#[test]
+fn run_model_based_single_step_tests() {
+    let mut tester = Tester::new("single_step", TEST_DIR);
+    tester.add_test_with_env("static model-based single-step test", single_step_test);
+    tester.add_test_with_env("full model-based single-step test", model_based_test);
+    tester.add_test_batch(model_based_test_batch);
+    tester.run_foreach_in_dir("");
+    tester.finalize();
+}
diff --git a/light-client/tests/supervisor.rs b/light-client/tests/supervisor.rs
index ce8098d2a..a5867ff3c 100644
--- a/light-client/tests/supervisor.rs
+++ b/light-client/tests/supervisor.rs
@@ -121,8 +121,8 @@ fn run_multipeer_test(tc: TestBisection<AnonLightBlock>) {
 
 #[test]
 fn run_multipeer_tests() {
-    let mut tester = Tester::new(TEST_FILES_PATH);
+    let mut tester = Tester::new("bisection_multi_peer", TEST_FILES_PATH);
     tester.add_test("multipeer test", run_multipeer_test);
     tester.run_foreach_in_dir("bisection/multi_peer");
-    tester.print_results();
+    tester.finalize();
 }
diff --git a/light-client/tests/support/model_based/Blockchain_A_1.tla b/light-client/tests/support/model_based/Blockchain_A_1.tla
new file mode 120000
index 000000000..6b0a7e4b0
--- /dev/null
+++ b/light-client/tests/support/model_based/Blockchain_A_1.tla
@@ -0,0 +1 @@
+../../../../docs/spec/lightclient/verification/Blockchain_A_1.tla
\ No newline at end of file
diff --git a/light-client/tests/support/model_based/LightTests.tla b/light-client/tests/support/model_based/LightTests.tla
new file mode 100644
index 000000000..c761a39ba
--- /dev/null
+++ b/light-client/tests/support/model_based/LightTests.tla
@@ -0,0 +1,40 @@
+------------------------- MODULE LightTests ---------------------------
+
+EXTENDS Lightclient_A_1
+
+TestFailure ==
+    /\ state = "finishedFailure"
+    /\ Cardinality(DOMAIN fetchedLightBlocks) = TARGET_HEIGHT
+
+TestSuccess ==
+    /\ state = "finishedSuccess"
+    /\ Cardinality(DOMAIN fetchedLightBlocks) = TARGET_HEIGHT
+
+\* This test never produces a counterexample; so the model should be corrected
+TestFailedTrustingPeriod ==
+   \E s \in DOMAIN history :
+      history[s].verdict = "FAILED_TRUSTING_PERIOD"
+
+Test2NotEnoughTrustSuccess ==
+    /\ state = "finishedSuccess"
+    /\ \E s1, s2 \in DOMAIN history :
+       /\ s1 /= s2
+       /\ history[s1].verdict = "NOT_ENOUGH_TRUST"
+       /\ history[s2].verdict = "NOT_ENOUGH_TRUST"
+
+Test2NotEnoughTrustFailure ==
+    /\ state = "finishedFailure"
+    /\ \E s1, s2 \in DOMAIN history :
+       /\ s1 /= s2
+       /\ history[s1].verdict = "NOT_ENOUGH_TRUST"
+       /\ history[s2].verdict = "NOT_ENOUGH_TRUST"
+
+Test3NotEnoughTrustSuccess ==
+    /\ state = "finishedSuccess"
+    /\ \E s1, s2, s3 \in DOMAIN history :
+       /\ s1 /= s2 /\ s2 /= s3 /\ s1 /= s3
+       /\ history[s1].verdict = "NOT_ENOUGH_TRUST"
+       /\ history[s2].verdict = "NOT_ENOUGH_TRUST"
+       /\ history[s3].verdict = "NOT_ENOUGH_TRUST"
+
+============================================================================
diff --git a/light-client/tests/support/model_based/Lightclient_A_1.tla b/light-client/tests/support/model_based/Lightclient_A_1.tla
new file mode 120000
index 000000000..e2bdf7956
--- /dev/null
+++ b/light-client/tests/support/model_based/Lightclient_A_1.tla
@@ -0,0 +1 @@
+../../../../docs/spec/lightclient/verification/Lightclient_A_1.tla
\ No newline at end of file
diff --git a/light-client/tests/support/model_based/MC4_4_faulty.json b/light-client/tests/support/model_based/MC4_4_faulty.json
new file mode 100644
index 000000000..1d43ae8e4
--- /dev/null
+++ b/light-client/tests/support/model_based/MC4_4_faulty.json
@@ -0,0 +1,11 @@
+{
+  "description": "Tests for 4 validators, target height 4, with faulty primary",
+  "model": "MC4_4_faulty.tla",
+  "timeout": 60,
+  "tests": [
+    "TestSuccess",
+    "TestFailure",
+    "Test2NotEnoughTrustSuccess",
+    "Test2NotEnoughTrustFailure"
+  ]
+}
diff --git a/light-client/tests/support/model_based/MC4_4_faulty.tla b/light-client/tests/support/model_based/MC4_4_faulty.tla
new file mode 100644
index 000000000..a1542f5e9
--- /dev/null
+++ b/light-client/tests/support/model_based/MC4_4_faulty.tla
@@ -0,0 +1,16 @@
+------------------------- MODULE MC4_4_faulty ---------------------------
+
+AllNodes == {"n1", "n2", "n3", "n4"}
+TRUSTED_HEIGHT == 1
+TARGET_HEIGHT == 4
+TRUSTING_PERIOD == 1400 \* two weeks, one day is 100 time units :-)
+IS_PRIMARY_CORRECT == FALSE
+
+VARIABLES
+  state, nextHeight, fetchedLightBlocks, lightBlockStatus, latestVerified,
+  history, nprobes,
+  now, blockchain, Faulty
+
+INSTANCE LightTests
+
+============================================================================
diff --git a/light-client/tests/support/model_based/README.md b/light-client/tests/support/model_based/README.md
new file mode 100644
index 000000000..bf26cc512
--- /dev/null
+++ b/light-client/tests/support/model_based/README.md
@@ -0,0 +1,66 @@
+## Light Client model-based testing guide
+
+In this directory you will find the model-based tests for the light client. 
+They are "model-based" because they are based on the formal `TLA+` model of the Light Client: see [Lightclient_A_1.tla](../../../../docs/spec/lightclient/verification/Lightclient_A_1.tla).
+The tests themselves are simple `TLA+` assertions, that describe the desired shape of the Light Client execution; 
+see [LightTests.tla](LightTests.tla) for some examples. 
+To be able to specify test assertions we have extended the Light Client model with `history` variable, 
+which records the whole execution history. 
+So, by way of referring to `history` you simply specify declaratively what execution history you want to see.
+
+After you have specified your `TLA+` test, list among tests of a _test batch_, such as [MC4_4_faulty.json](MC4_4_faulty.json). 
+Such test batches are then executed automatically when you run `cargo test`.
+
+When you run `cargo test` some machinery will run under the hood, namely:
+* [Apalache model checker](https://github.com/informalsystems/apalache) 
+  will execute your `TLA+` test, and will try to find an execution you've described.
+* The model execution (or _counterexample_ in model checking terms) 
+  will be translated into the format that is understood by the Light Client implementation.
+  For that translation two other components are necessary:
+  * [Jsonatr (JSON Arrifact Translator)](https://github.com/informalsystems/jsonatr) 
+    performs the translation by executing this [transformation spec](_jsonatr-lib/apalache_to_lite_test.json);
+  * [Tendermint Testgen](https://github.com/informalsystems/tendermint-rs/tree/master/testgen)
+  takes care of translating abstract values from the model into the concrete implementation values.
+  
+So, for the model-based test to run, the programs `apalache-mc`, `jsonatr`, and `tendermint-testgen` 
+should be present in your `PATH`. The easiest way to run Apalache is by [using a Docker image](https://github.com/informalsystems/apalache/blob/unstable/docs/manual.md#useDocker); 
+to run the latter two you need to locally clone the repositories, and then, 
+after building them, just add their `target/debug` directories into your `PATH`. 
+If any of the programs is not found, execution of a model-based test will be skipped.
+
+After you run your model-based tests with `cargo test`, the results will be printed to screen, 
+and also saved to disk in the [_single_step](_single_step) directory.
+Results include:
+* [Report](_single_step/_report) on which tests were run, and what is the outcome
+* For each test, it's relevant files are also saved in a subdirectory of [_single_step](_single_step). 
+  E.g. For the test `TestSuccess`, which is referenced in [MC4_4_faulty.json](MC4_4_faulty.json), 
+  the results of it's execution will be saved into [_single_step/MC4_4_faulty.json/TestSuccess](_single_step/MC4_4_faulty.json/TestSuccess).
+  These results include, for a successful test:
+  * [log file](_single_step/MC4_4_faulty.json/TestSuccess/_log), where test logs are stored
+  * [counterexample.tla](_single_step/MC4_4_faulty.json/TestSuccess/counterexample.tla), 
+  the counterexample produced by Apalache in `TLA+` format
+  * [counterexample.json](_single_step/MC4_4_faulty.json/TestSuccess/counterexample.json), 
+  the counterexample produced by Apalache in `JSON` format
+  * [test.json](_single_step/MC4_4_faulty.json/TestSuccess/test.json), 
+  the actual static Light Client test, generated by Jsonatr from the counterexample.
+       
+One important feature of the model-based testing is that each time you run a model-based test, 
+a different static test could be produced. This happens due to the fact that the test you describe
+is very abstract, and it's requirements can be fulfilled by a multitude of concrete tests. 
+To see what peculiarities a particular test has, please inspect the test report or logs.
+
+We suggest the following workflow for running model-based tests:
+
+1. Experiment with your model-based test, by trying different scenarios. 
+For that you might want to run your test in isolation, 
+as counterexample generation by Apalache may take a significant time. 
+In order to run only your test, just create a new test batch with your test, 
+and temporarily remove/rename other test batches (files or diretories starting with `_` are ignored).
+2. After running your model-based test, inspect its report/logs. 
+3. If you find the test details interesting, simply copy the generated `test.json` file 
+into [single_step](single_step) directory, and rename it to reflect the model and model-based test you used to generate it.
+For example, [single_step/MC4_4_faulty_TestSuccess.json](single_step/MC4_4_faulty_TestSuccess.json) 
+was auto-generated from the model [MC4_4_faulty.tla](MC4_4_faulty.tla) and the test `TestSuccess`.
+4. Next time you run `cargo test` this static test will be picked up and executed automatically.
+
+ 
\ No newline at end of file
diff --git a/light-client/tests/support/model_based/_jsonatr-lib b/light-client/tests/support/model_based/_jsonatr-lib
new file mode 120000
index 000000000..f2ef6f0a5
--- /dev/null
+++ b/light-client/tests/support/model_based/_jsonatr-lib
@@ -0,0 +1 @@
+../../../../testgen/jsonatr-lib
\ No newline at end of file

From e03c10f0f21f55e63ef733a2c82a36ffe9c246d5 Mon Sep 17 00:00:00 2001
From: Andrey Kuprianov <andrey@informal.systems>
Date: Wed, 2 Sep 2020 14:42:39 +0200
Subject: [PATCH 04/10] add talk abstract

---
 .../tests/support/model_based/Abstract.md     |  50 ++++++++++++++++++
 .../support/model_based/LightClientMBT.png    | Bin 0 -> 94990 bytes
 2 files changed, 50 insertions(+)
 create mode 100644 light-client/tests/support/model_based/Abstract.md
 create mode 100644 light-client/tests/support/model_based/LightClientMBT.png

diff --git a/light-client/tests/support/model_based/Abstract.md b/light-client/tests/support/model_based/Abstract.md
new file mode 100644
index 000000000..5a1da00ea
--- /dev/null
+++ b/light-client/tests/support/model_based/Abstract.md
@@ -0,0 +1,50 @@
+# Model-based testing with TLA+ and Apalache
+
+In this talk we present our instantiation of model-based testing (MBT) using the TLA+ modeling language and the Apalache model checker. In our work we have created the infrastructure that facilitates model-based testing, and makes it appealing and beneficial for software developers to apply in their everyday development practice -- much more so than the standard integration testing with manually written tests that we've employed previously.
+
+Our model-based testing procedure finds its rightful place in the verification-driven development process (VDD) we apply at Informal Systems. More concretely, we use it as an alternative approach to integration testing of the implementation in the Rust programming language of the fault-tolerant distributed consensus protocol named Tendermint. In the VDD process, we start with the semi-formal English language description of the protocol, which is then formally specified in TLA+, and verified by our Apalache model checker. The TLA+ specification is used as a reference model for clarifying misunderstanding both at the English language level, and at the level of the concrete implementation in Rust. Model-based tests are expressed in pure TLA+, and respresent simple assertions on the computation history the user wants to examine. Consider the model-based test below:
+
+```tla+
+Test2NoSuccess ==
+    /\ state = "finishedSuccess"
+    /\ \E s1, s2 \in DOMAIN history:
+       /\ s1 /= s2
+       /\ history[s1].verdict /= "SUCCESS"
+       /\ history[s2].verdict /= "SUCCESS"
+
+```
+
+This is the model-based test of the Tendermint LightClient sub-protocol, which is used to establish a trust in a blockchain block retrieved from an untrusted source. The test describes a computation history in which the protocol execution, despite passing through two distinct intermediate states with unsuccessful block verification, still finishes successfully. This model-based test is then used to automatically generate and execute the complete integration test for the Tendermint LightClient protocol: e.g., in a Tendermint network with 4 validators these 6 lines of TLA+ are translated to more than 500 lines of the JSON integration test with all necessary details: private and public keys, signatures, timestamps, etc.
+
+In our presentation we would like to convey three main messages on model-based testing, which we describe below.
+
+## Model-based testing with TLA+ is easy to understand, and can be sucessfully appllied in the industry to provide correctness guarantees for real-world software.
+
+In our initial experience of implementing and applying MBT, we find quite appealing its simplicity for the end user, being it a researcher or a developer. The model-based tests are quite abstract and concise; they can precisely describe what behavior needs to be tested. At the same time, in sharp contrast to standard integration tests, they leave a lot of details unspecified. An important feature of MBT is that these missing details will be instantiated in different ways with each run of the model-based test; moreover, this behavior can be easily employed to _exhaustively_ test all scenarios falling under the abstract test. In the above example, the intermediate results are only restricted to be unsuccessful, but concrete verification errors are left open. And the model checker will indeed instantiate for each run different combinations of failures: due to the blockchain block falling out of the trusting period, not enough trust in the validator set, signature validation errors, etc.
+
+One of the main reasons for the Tendermint modeling and model-based testing being successfully implemented and accepted within our teams is the rich syntax and sematics of the TLA+ language. TLA+ allowed us to concisely model the complex aspects of the Tendermint protocol, as well as to express correctness properties and tests about it. In particular, even for developers without a prior exposure to TLA+, following the models written by our researchers has helped to clarify the protocol abstractions before diving into the implementation, thus avoiding the painful experience and countless hours of correcting them when the implementation is already done.
+
+
+## Substantial infrastructure is necessary for model-based testing, but the complexity is reasonable.
+
+Some infrastructure naturally needs to be implemented in order to apply MBT. The good news is that a lot of that infrastructure is reusable: some for different components of the same product, some for different products or even different companies. Within our first MBT project we have implemented the following infrastructure components, highlighed in the figure:
+
+* Apalache model checker extension for providing JSON input/output (reusable globally);
+* JSON Artifact Translator (Jsonatr),  which, with the help of a transformation specification, maps an abstract counterexample produced by the model checker, into the concrete integration test (the tool reusable globally, the transformation spec -- for a specific product);
+* Test generator (Testgen), which plays the role of a _concretization function_, mapping abstract model states into concrete implementation states (reusable for multiple products sharing the same data structures);
+* Model-based test driver, which orchestrates the above infrastructure components to run them within the standard continuous integration (CI) framework; for Rust this is done via the standard `cargo test` command (used only for a specific product/component, but quite minimalistic).
+
+Implementation of the above infrastructure took us about 3 person-months of work, which is quite a reasonable cost taking into account the reusability of most of the components.
+
+![Model-based testing of the Tendermint Light Client](LightClientMBT.png) 
+
+
+## MBT can serve as a "missing link" to synchronize formal specification and concrete implementation, and to connect academia and industry.
+
+
+The original VDD process, while being highly successful as acknowledged both by our research and development teams, still lacks some necessary feedback loops. We have observed that after some time the English specification, the TLA+ model, and the concrete implementation start to diverge. Our initial experience with MBT suggests that it can successfully play the role of the missing link, providing feedback loops between the three levels of abstraction. In particular, in this talk we will demonstrate on concrete examples how MBT has helped us to eliminate the growing divergence between the abstraction levels with the help of simple model-based tests.
+
+Another aspect that can be observed on the figure, is that MBT brings a research engineer in the process, as _some_ research experience is necessary for implementing the models and tests concisely and efficiently. What we have observed quite frequently is that while academic researchers often excel in devising new verification approaches, they struggle to find real-world applications for their methods. The developers in the industry, on the other hand, desperately need _some_ level of formal reasoning to be applied to their products, in order to provide reasonable correctness guarantees within the time and budget bounds. Our experience demonstrates that the advantages of MBT can be made so convincing as to justify for commercial companies hiring researches as staff or contractors in order to apply MBT to their products, and, thus, to establish the long-needed dialog between academia and industry.
+
+
+
diff --git a/light-client/tests/support/model_based/LightClientMBT.png b/light-client/tests/support/model_based/LightClientMBT.png
new file mode 100644
index 0000000000000000000000000000000000000000..a5233ccb8387bb48cb48525111a433226a3ff058
GIT binary patch
literal 94990
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%0AAg3enGm
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

literal 0
HcmV?d00001


From 29807a49255a749400f419576690bda7a5f6da32 Mon Sep 17 00:00:00 2001
From: Andrey Kuprianov <andrey@informal.systems>
Date: Fri, 4 Sep 2020 11:04:20 +0200
Subject: [PATCH 05/10] #547 add missing file updates from #529

---
 light-client/src/tests.rs          | 46 ++++++++++++++++++++++++++
 light-client/tests/light_client.rs | 53 ++++--------------------------
 light-client/tests/supervisor.rs   |  4 +--
 3 files changed, 54 insertions(+), 49 deletions(-)

diff --git a/light-client/src/tests.rs b/light-client/src/tests.rs
index dcc407bcb..6ad1a400e 100644
--- a/light-client/src/tests.rs
+++ b/light-client/src/tests.rs
@@ -8,9 +8,14 @@ use tendermint_rpc as rpc;
 
 use crate::components::clock::Clock;
 use crate::components::io::{AtHeight, Io, IoError};
+use crate::components::verifier::{ProdVerifier, Verdict, Verifier};
+use crate::errors::Error;
 use crate::evidence::EvidenceReporter;
+use crate::light_client::{LightClient, Options};
+use crate::state::State;
 use contracts::contract_trait;
 use std::collections::HashMap;
+use std::time::Duration;
 use tendermint::block::Height as HeightStr;
 use tendermint::evidence::{Duration as DurationStr, Evidence};
 
@@ -148,6 +153,47 @@ impl MockEvidenceReporter {
     }
 }
 
+pub fn verify_single(
+    trusted_state: Trusted,
+    input: LightBlock,
+    trust_threshold: TrustThreshold,
+    trusting_period: Duration,
+    clock_drift: Duration,
+    now: Time,
+) -> Result<LightBlock, Verdict> {
+    let verifier = ProdVerifier::default();
+
+    let trusted_state = LightBlock::new(
+        trusted_state.signed_header,
+        trusted_state.next_validators.clone(),
+        trusted_state.next_validators,
+        default_peer_id(),
+    );
+
+    let options = Options {
+        trust_threshold,
+        trusting_period,
+        clock_drift,
+    };
+
+    let result = verifier.verify(&input, &trusted_state, &options, now);
+
+    match result {
+        Verdict::Success => Ok(input),
+        error => Err(error),
+    }
+}
+
+pub fn verify_bisection(
+    untrusted_height: Height,
+    light_client: &mut LightClient,
+    state: &mut State,
+) -> Result<Vec<LightBlock>, Error> {
+    light_client
+        .verify_to_target(untrusted_height, state)
+        .map(|_| state.get_trace(untrusted_height))
+}
+
 // -----------------------------------------------------------------------------
 // Everything below is a temporary workaround for the lack of `provider` field
 // in the light blocks serialized in the JSON fixtures.
diff --git a/light-client/tests/light_client.rs b/light-client/tests/light_client.rs
index 8c6d1146c..d618d2350 100644
--- a/light-client/tests/light_client.rs
+++ b/light-client/tests/light_client.rs
@@ -5,14 +5,14 @@ use tendermint_light_client::{
     components::{
         io::{AtHeight, Io},
         scheduler,
-        verifier::{ProdVerifier, Verdict, Verifier},
+        verifier::ProdVerifier,
     },
     errors::{Error, ErrorKind},
     light_client::{LightClient, Options},
     state::State,
     store::{memory::MemoryStore, LightStore},
     tests::{Trusted, *},
-    types::{Height, LightBlock, Status, Time, TrustThreshold},
+    types::{LightBlock, Status, TrustThreshold},
 };
 
 use tendermint_testgen::Tester;
@@ -21,47 +21,6 @@ use tendermint_testgen::Tester;
 // https://github.com/informalsystems/conformance-tests
 const TEST_FILES_PATH: &str = "./tests/support/";
 
-fn verify_single(
-    trusted_state: Trusted,
-    input: LightBlock,
-    trust_threshold: TrustThreshold,
-    trusting_period: Duration,
-    clock_drift: Duration,
-    now: Time,
-) -> Result<LightBlock, Verdict> {
-    let verifier = ProdVerifier::default();
-
-    let trusted_state = LightBlock::new(
-        trusted_state.signed_header,
-        trusted_state.next_validators.clone(),
-        trusted_state.next_validators,
-        default_peer_id(),
-    );
-
-    let options = Options {
-        trust_threshold,
-        trusting_period,
-        clock_drift,
-    };
-
-    let result = verifier.verify(&input, &trusted_state, &options, now);
-
-    match result {
-        Verdict::Success => Ok(input),
-        error => Err(error),
-    }
-}
-
-fn verify_bisection(
-    untrusted_height: Height,
-    light_client: &mut LightClient,
-    state: &mut State,
-) -> Result<Vec<LightBlock>, Error> {
-    light_client
-        .verify_to_target(untrusted_height, state)
-        .map(|_| state.get_trace(untrusted_height))
-}
-
 struct BisectionTestResult {
     untrusted_light_block: LightBlock,
     new_states: Result<Vec<LightBlock>, Error>,
@@ -229,17 +188,17 @@ fn bisection_lower_test(tc: TestBisection<AnonLightBlock>) {
 
 #[test]
 fn run_single_step_tests() {
-    let mut tester = Tester::new(TEST_FILES_PATH);
+    let mut tester = Tester::new("single_step", TEST_FILES_PATH);
     tester.add_test("single-step test", single_step_test);
     tester.run_foreach_in_dir("single_step");
-    tester.print_results();
+    tester.finalize();
 }
 
 #[test]
 fn run_bisection_tests() {
-    let mut tester = Tester::new(TEST_FILES_PATH);
+    let mut tester = Tester::new("bisection", TEST_FILES_PATH);
     tester.add_test("bisection test", bisection_test);
     tester.add_test("bisection lower test", bisection_lower_test);
     tester.run_foreach_in_dir("bisection/single_peer");
-    tester.print_results();
+    tester.finalize();
 }
diff --git a/light-client/tests/supervisor.rs b/light-client/tests/supervisor.rs
index ce8098d2a..a5867ff3c 100644
--- a/light-client/tests/supervisor.rs
+++ b/light-client/tests/supervisor.rs
@@ -121,8 +121,8 @@ fn run_multipeer_test(tc: TestBisection<AnonLightBlock>) {
 
 #[test]
 fn run_multipeer_tests() {
-    let mut tester = Tester::new(TEST_FILES_PATH);
+    let mut tester = Tester::new("bisection_multi_peer", TEST_FILES_PATH);
     tester.add_test("multipeer test", run_multipeer_test);
     tester.run_foreach_in_dir("bisection/multi_peer");
-    tester.print_results();
+    tester.finalize();
 }

From f95a8c9a3795aed9ea85dddfccf75955a9df448a Mon Sep 17 00:00:00 2001
From: Andrey Kuprianov <andrey@informal.systems>
Date: Fri, 4 Sep 2020 11:18:31 +0200
Subject: [PATCH 06/10] fix merge typo

---
 testgen/src/tester.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/testgen/src/tester.rs b/testgen/src/tester.rs
index 92131c906..909b1095a 100644
--- a/testgen/src/tester.rs
+++ b/testgen/src/tester.rs
@@ -190,7 +190,7 @@ pub struct Tester {
 
 impl TestResult {
     pub fn is_success(&self) -> bool {
-        matches!(self, TestResult::Success(_))
+        matches!(self, TestResult::Success)
     }
     pub fn is_failure(&self) -> bool {
         matches!(self, TestResult::Failure {

From 9d4531a45603e0f4f86a3b98a7725088ba85fde1 Mon Sep 17 00:00:00 2001
From: Andrey Kuprianov <andrey@informal.systems>
Date: Fri, 4 Sep 2020 11:58:33 +0200
Subject: [PATCH 07/10] remove ref to time: it's in another PR

---
 testgen/src/lib.rs | 2 --
 1 file changed, 2 deletions(-)

diff --git a/testgen/src/lib.rs b/testgen/src/lib.rs
index 8e6606a99..58c875e94 100644
--- a/testgen/src/lib.rs
+++ b/testgen/src/lib.rs
@@ -6,14 +6,12 @@ pub mod commit;
 pub mod consensus;
 pub mod generator;
 pub mod header;
-pub mod time;
 pub mod validator;
 pub mod vote;
 
 pub use commit::Commit;
 pub use generator::Generator;
 pub use header::Header;
-pub use time::Time;
 pub use validator::Validator;
 pub use vote::Vote;
 

From 4df1e28be19ac158e828909ee4602211c702fc7d Mon Sep 17 00:00:00 2001
From: Andrey Kuprianov <andrey@informal.systems>
Date: Fri, 4 Sep 2020 12:03:14 +0200
Subject: [PATCH 08/10] fix clippy warning

---
 testgen/src/command.rs | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/testgen/src/command.rs b/testgen/src/command.rs
index c6aca4576..b75339cf8 100644
--- a/testgen/src/command.rs
+++ b/testgen/src/command.rs
@@ -80,3 +80,9 @@ impl Command {
         }
     }
 }
+
+impl Default for Command {
+    fn default() -> Self {
+        Self::new()
+    }
+}

From f032a208f86f7a0b8dbbfd45536899b7f55a9e52 Mon Sep 17 00:00:00 2001
From: Andrey Kuprianov <andrey@informal.systems>
Date: Fri, 11 Sep 2020 14:17:30 +0200
Subject: [PATCH 09/10] fix merging typo

---
 light-client/tests/model_based.rs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/light-client/tests/model_based.rs b/light-client/tests/model_based.rs
index 026e1a996..ec6e626ce 100644
--- a/light-client/tests/model_based.rs
+++ b/light-client/tests/model_based.rs
@@ -140,8 +140,8 @@ fn model_based_test(
     assert!(run_jsonatr_transform(env.current_dir(), transform).is_ok());
     output_env.copy_file_from_env(env, "test.json");
 
-    let tc = env
-        .parse_file_as::<SingleStepTestCase>("test.json")
+    let tc: SingleStepTestCase = env
+        .parse_file("test.json")
         .unwrap();
     println!("  > running auto-generated test...");
     single_step_test(tc, env, root_env, output_env);

From 6af3bd0b89d0ef8150ac4ab9dcf48a1d6e32d026 Mon Sep 17 00:00:00 2001
From: Andrey Kuprianov <andrey@informal.systems>
Date: Fri, 11 Sep 2020 14:23:18 +0200
Subject: [PATCH 10/10] cargo fmt

---
 light-client/tests/model_based.rs | 4 +---
 1 file changed, 1 insertion(+), 3 deletions(-)

diff --git a/light-client/tests/model_based.rs b/light-client/tests/model_based.rs
index ec6e626ce..6bf80ed4f 100644
--- a/light-client/tests/model_based.rs
+++ b/light-client/tests/model_based.rs
@@ -140,9 +140,7 @@ fn model_based_test(
     assert!(run_jsonatr_transform(env.current_dir(), transform).is_ok());
     output_env.copy_file_from_env(env, "test.json");
 
-    let tc: SingleStepTestCase = env
-        .parse_file("test.json")
-        .unwrap();
+    let tc: SingleStepTestCase = env.parse_file("test.json").unwrap();
     println!("  > running auto-generated test...");
     single_step_test(tc, env, root_env, output_env);
     output_env.copy_file_from_env(env, "counterexample.tla");