evaltor 0.1.0

A tool for evaluating the evaluatees on benchmarks
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63

use super::BenchIF;
use std::{
    fs,
    mem::{forget, take},
    path::PathBuf,
    process::Command,
};
use tempfile::NamedTempFile;

pub struct FuzzBench {
    cases: Vec<NamedTempFile>,
}

impl FuzzBench {
    pub fn new(num: usize) -> Self {
        fs::create_dir_all("/tmp/evaltor/fuzz/").unwrap();
        if Command::new("which")
            .arg("aigfuzz")
            .output()
            .map(|output| !output.status.success())
            .unwrap_or(true)
        {
            panic!("Error: aigfuzz binary not found");
        }
        let mut cases = Vec::new();
        for _ in 0..num {
            let fuzz =
                tempfile::NamedTempFile::with_suffix_in(".aig", "/tmp/evaltor/fuzz").unwrap();
            assert!(
                Command::new("aigfuzz")
                    .args(["-2", "-m", "-s", "-S", "-o"])
                    .arg(fuzz.path())
                    .output()
                    .unwrap()
                    .status
                    .success()
            );
            cases.push(fuzz);
        }
        Self { cases }
    }
}

impl BenchIF for FuzzBench {
    fn name(&self) -> String {
        "fuzz".to_string()
    }

    fn cases(&self) -> Vec<PathBuf> {
        self.cases.iter().map(|c| c.path().to_path_buf()).collect()
    }

    fn mount(&self) -> Vec<PathBuf> {
        vec![PathBuf::from("/tmp/evaltor/fuzz")]
    }
}

impl Drop for FuzzBench {
    fn drop(&mut self) {
        let cases = take(&mut self.cases);
        forget(cases);
    }
}