runner/
runner.rs

Help
1mod code;
2use code::output::{Output, Status};
3use proptest::prelude::TestCaseError;
4use proptest::test_runner::{Config, TestError, TestRunner};
5use std::cell::RefCell;
6use std::io::{BufRead, BufReader, Write};
7use std::process::Stdio;
8use std::{fs, path::PathBuf};
9
10const START_TAG: &str = ";; ELPROP_START:";
11const END_TAG: &str = "\n;; ELPROP_END\n";
12
13fn main() {
14    let crate_root = PathBuf::from(env!("CARGO_MANIFEST_DIR"));
15    let workspace_root = crate_root.parent().unwrap();
16    let target = workspace_root.join("target/elprop");
17
18    let json = target.join("functions.json");
19    // read the file to a string
20    let json_string = fs::read_to_string(json).expect("Unable to read file");
21
22    let config: code::data::Config =
23        serde_json::from_str(&json_string).expect("Unable to deserialize json");
24
25    let mut runner = TestRunner::new(Config {
26        cases: config.test_count,
27        failure_persistence: None,
28        ..Config::default()
29    });
30
31    let cmd = crate_root.parent().unwrap().join("target/debug/rune");
32    #[expect(clippy::zombie_processes)]
33    let mut child = std::process::Command::new(cmd)
34        .arg("--eval-stdin")
35        .stdin(Stdio::piped())
36        .stdout(Stdio::piped())
37        .spawn()
38        .expect("Failed to start rune");
39
40    let rune_stdin = RefCell::new(child.stdin.take().unwrap());
41    let rune_stdout = RefCell::new(child.stdout.take().unwrap());
42    let rune_panicked = RefCell::new(false);
43    let master_count = RefCell::new(0);
44
45    let outputs = RefCell::new(Vec::new());
46    let regex = regex::Regex::new("^\\((wrong-[a-zA-Z0-9-]*|[a-zA-Z0-9-]*error) ").unwrap();
47    for func in config.functions {
48        let name = func.name.clone();
49        let result = runner.run(&func.strategy(), |input| {
50            if *rune_panicked.borrow() {
51                return Err(TestCaseError::Reject("Rune panicked".into()));
52            }
53            let body = code::data::print_args(&input);
54            // send to emacs
55            println!(";; sending to Emacs");
56            let test_str = format!(";; ELPROP_START\n({name} {body})\n;; ELPROP_END");
57            println!("{test_str}");
58            // send to rune
59            println!(";; sending to rune");
60            match writeln!(rune_stdin.borrow_mut(), "{test_str}") {
61                Ok(()) => (),
62                Err(e) => {
63                    *rune_panicked.borrow_mut() = true;
64                    return Err(TestCaseError::Reject(format!("Rune panicked {e}").into()));
65                }
66            }
67
68            let mut reader = BufReader::new(std::io::stdin());
69            println!(";; reading from Emacs");
70            let emacs_output =
71                process_eval_result("Emacs", *master_count.borrow(), &mut reader, |text| {
72                    regex.is_match(text)
73                });
74
75            let mut rune_stdout = rune_stdout.borrow_mut();
76            let mut reader = BufReader::new(&mut *rune_stdout);
77            println!(";; reading from Rune");
78            let rune_output =
79                process_eval_result("Rune", *master_count.borrow(), &mut reader, |text| {
80                    text.starts_with("Error: ")
81                });
82            println!(";; done");
83
84            *master_count.borrow_mut() += 1;
85
86            match (emacs_output, rune_output) {
87                (Ok(e), Ok(r)) if e == r => Ok(()),
88                (Err(_), Err(_)) => Ok(()),
89                (Ok(e) | Err(e), Ok(r)) | (Ok(e), Err(r)) => {
90                    println!("\"Emacs: '{e}', Rune: '{r}'\"");
91                    Err(TestCaseError::Fail(format!("Emacs: {e}, Rune: {r}").into()))
92                }
93            }
94        });
95
96        // send the output of "result" to a file
97        // open the file in write mode
98
99        println!(";; sending output");
100        let status = match result {
101            Err(TestError::Fail(reason, value)) => Status::Fail(reason.to_string(), value),
102            Err(TestError::Abort(reason)) => Status::Abort(reason.to_string()),
103            Ok(()) => Status::Pass,
104        };
105        let output = Output { function: name, status };
106        outputs.borrow_mut().push(output);
107    }
108
109    let _ = child.kill();
110    let json = serde_json::to_string(&*outputs.borrow()).expect("Malformed Output JSON");
111    let output_file = target.join("output.json");
112    fs::write(output_file, json).unwrap();
113    println!(";; exit process");
114}
115
116fn process_eval_result(
117    name: &str,
118    master_count: usize,
119    reader: &mut impl BufRead,
120    test_fail: impl Fn(&str) -> bool,
121) -> Result<String, String> {
122    let mut line = String::new();
123    reader.read_line(&mut line).unwrap();
124    if line.contains("thread 'main' panicked") {
125        return Err("Rune panicked".to_owned());
126    }
127    let count = line.strip_prefix(START_TAG).unwrap().trim().parse::<usize>().unwrap();
128    assert_eq!(
129        master_count, count,
130        "Count from {name} was off. actual {count}, expected {master_count}",
131    );
132    line.clear();
133    while !line.contains(END_TAG) {
134        reader.read_line(&mut line).unwrap();
135    }
136    let text = line.strip_suffix(END_TAG).unwrap().trim().to_string();
137    if test_fail(&text) { Err(text) } else { Ok(text) }
138}
runner/runner.rs

runner/
runner.rs
