Struct emjudge_judgecore::test::StandardTester

pub struct StandardTester { /* private fields */ }

Implementations

impl StandardTester

pub fn new( test_runner: &StandardRunner, eval_runner: &StandardRunner, exe_test_script: &Vec<u8>, exe_eval_script: &Vec<u8> ) -> Self

Examples found in repository

examples/test_aplusb.rs (line 27)

fn main() {
    let settings = settings::Settings::new();
    let compiler = compile::Compiler::new(&settings.compile_setting);
    let runner = run::StandardRunner::new(&RunSetting{memory_limit_KB: 1024 * 1024, cpu_limit_ms: 10000, dir: settings.run_setting.dir.clone()});
    let mut eval_script = vec![];
    let mut test_script = vec![];
    let mut input  = vec![];
    let mut output = vec![];
    File::open("examples/programs/aplusb/eval.cpp").unwrap().read_to_end(&mut eval_script).unwrap();
    File::open("examples/programs/aplusb/main.cpp").unwrap().read_to_end(&mut test_script).unwrap();
    File::open("examples/programs/aplusb/in").unwrap().read_to_end(&mut input).unwrap();
    File::open("examples/programs/aplusb/out").unwrap().read_to_end(&mut output).unwrap();
    println!("Compiling eval...");
    let compile_eval = compiler.compile(&String::from("C++"), &eval_script);
    println!("Finish");
    if let CompileResult::OK(exe_eval) = compile_eval {
        println!("Compiling test...");
        let compile_test = compiler.compile(&String::from("C++"), &test_script);
        println!("Finish");
        if let CompileResult::OK(exe_test) = compile_test {
            println!("Testing...");
            let tester = test::StandardTester::new(&runner, &runner, &exe_test, &exe_eval);
            println!("Finish: {:?}", tester.single_test(&input, &output));
        }
    }
}

pub fn single_test(&self, input: &Vec<u8>, output: &Vec<u8>) -> TestResult

Examples found in repository

examples/test_aplusb.rs (line 28)

fn main() {
    let settings = settings::Settings::new();
    let compiler = compile::Compiler::new(&settings.compile_setting);
    let runner = run::StandardRunner::new(&RunSetting{memory_limit_KB: 1024 * 1024, cpu_limit_ms: 10000, dir: settings.run_setting.dir.clone()});
    let mut eval_script = vec![];
    let mut test_script = vec![];
    let mut input  = vec![];
    let mut output = vec![];
    File::open("examples/programs/aplusb/eval.cpp").unwrap().read_to_end(&mut eval_script).unwrap();
    File::open("examples/programs/aplusb/main.cpp").unwrap().read_to_end(&mut test_script).unwrap();
    File::open("examples/programs/aplusb/in").unwrap().read_to_end(&mut input).unwrap();
    File::open("examples/programs/aplusb/out").unwrap().read_to_end(&mut output).unwrap();
    println!("Compiling eval...");
    let compile_eval = compiler.compile(&String::from("C++"), &eval_script);
    println!("Finish");
    if let CompileResult::OK(exe_eval) = compile_eval {
        println!("Compiling test...");
        let compile_test = compiler.compile(&String::from("C++"), &test_script);
        println!("Finish");
        if let CompileResult::OK(exe_test) = compile_test {
            println!("Testing...");
            let tester = test::StandardTester::new(&runner, &runner, &exe_test, &exe_eval);
            println!("Finish: {:?}", tester.single_test(&input, &output));
        }
    }
}

Trait Implementations

impl Clone for StandardTester

fn clone(&self) -> StandardTester

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for StandardTester

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for StandardTester

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for StandardTester

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.