eval-stack 0.3.4

Extremely fast async online judge evaluation system for ACM/OI contests.
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
64
65
66
67
68
69
70
71
72
73
74
75
76

use std::time::Duration;

use anyhow::Result;
use eval_stack::{case::run_test_cases, compile::Language, config::JudgeOptions};

#[tokio::test]
async fn test_fs() -> Result<()> {
    let current_dir = std::env::current_dir()?;
    let workspace_path = current_dir.join("fs_workspace");
    let tests_path = current_dir.join("tests");

    let results = run_test_cases(
        Language::Python,
        &workspace_path,
        &tests_path.join("fail_to_write.py"),
        JudgeOptions {
            time_limit: Duration::from_secs(1),
            memory_limit: 128 * 1024 * 1024,
            fail_fast: true,
            no_startup_limits: false,
            unsafe_mode: false,
        },
        vec![
            (tests_path.join("1.in"), tests_path.join("1.out")),
            (tests_path.join("2.in"), tests_path.join("2.out")),
        ],
        true,
    )
    .await?;

    for result in results {
        println!("{:?}", result);
        assert!(!result.is_accepted());
        assert!(matches!(
            result.status,
            eval_stack::judge::JudgeStatus::SystemError {
                code: -1,
                stderr: _stderr,
                signal: 31
            }
        ))
    }

    let results = run_test_cases(
        Language::NodeJs,
        &workspace_path,
        &tests_path.join("fail_to_write.mjs"),
        JudgeOptions {
            time_limit: Duration::from_secs(1),
            memory_limit: 128 * 1024 * 1024,
            fail_fast: true,
            no_startup_limits: true,
            unsafe_mode: false,
        },
        vec![
            (tests_path.join("1.in"), tests_path.join("1.out")),
            (tests_path.join("2.in"), tests_path.join("2.out")),
        ],
        true,
    )
    .await?;

    for result in results {
        println!("{:?}", result);
        assert!(!result.is_accepted());
        assert!(matches!(
            result.status,
            eval_stack::judge::JudgeStatus::RuntimeError {
                code: 1,
                stderr: _stderr
            }
        ))
    }

    Ok(())
}