code-executor 2.7.0

A library designed for the backend of competitive programming platforms
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

mod cgroup;
mod compiler;
mod error;
mod language;
mod metrics;
mod runner;
mod util;

pub use cgroup::*;
pub use compiler::*;
pub use error::*;
pub use language::*;
pub use metrics::*;
pub use runner::*;

#[derive(Debug, Clone, Copy, Hash, PartialEq, Eq)]
pub struct CommandArgs<'a> {
    pub binary: &'a str,
    pub args: &'a [&'a str],
}

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct Language<'a> {
    pub compiler: Compiler<'a>,
    pub runner_args: CommandArgs<'a>,
}

#[cfg(test)]
mod test {
    use std::{fs, path::Path};

    use crate::Language;

    pub fn read_test_cases(problem_path: &Path) -> Vec<(Vec<u8>, Vec<u8>)> {
        let test_cases: Vec<_> = fs::read_dir(problem_path)
            .unwrap()
            .filter_map(|entry| {
                let entry = entry.unwrap();
                let path = entry.path();
                if !path.is_dir() {
                    return None;
                }

                let input_path = path.join("in.txt");
                let input = fs::read(input_path).unwrap();

                let output_path = path.join("out.txt");
                let output = fs::read(output_path).unwrap();

                Some((input, output))
            })
            .collect();

        test_cases
    }

    pub fn read_code(language: Language, problem_path: &Path) -> Vec<u8> {
        fs::read(problem_path.join(language.compiler.main_file)).unwrap()
    }
}