ezcp 0.4.0

A simple tool to automatically generate test cases for competitive programming problems.
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
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132

#[cfg(test)]
#[allow(clippy::unwrap_used)]
pub mod gcc_tests {
    use crate::Error;
    use crate::runner::gcc::{Gcc, GccOptimization, GccStandard};

    #[test]
    fn test_gcc_new() {
        let gcc = Gcc::new();
        assert!(gcc.is_ok());
    }

    #[test]
    fn test_gcc_compile() {
        let gcc = Gcc::new().unwrap();

        let tempdir = tempfile::TempDir::new().unwrap();

        let source_code = r#"
        #include <iostream>
        using namespace std;

        int main() {
            cout << "Hello, World!" << endl;
            return 0;
        }
        "#;

        let source_path = tempdir.path().join("test.cpp");
        // Write the source code to a file
        std::fs::write(&source_path, source_code).unwrap();
        let out_file = gcc.compile(&source_path, None).unwrap();

        assert!(out_file.exists());

        drop(tempdir);
    }

    #[test]
    fn test_gcc_compile_with_flags() {
        let mut gcc = Gcc::new().unwrap();
        gcc.optimization = Some(GccOptimization::Level2);
        gcc.standard = Some(GccStandard::Cpp17);

        let tempdir = tempfile::TempDir::new().unwrap();

        let source_code = r#"
        #include <iostream>
        using namespace std;

        int main() {
            cout << "Hello, World!" << endl;
            return 0;
        }
        "#;

        let source_path = tempdir.path().join("test.cpp");
        // Write the source code to a file
        std::fs::write(&source_path, source_code).unwrap();
        let out_file = gcc.compile(&source_path, None).unwrap();

        assert!(out_file.exists());

        drop(tempdir);
    }


    #[test]
    fn test_gcc_compile_output() {
        let gcc = Gcc::new().unwrap();

        let tempdir = tempfile::TempDir::new().unwrap();

        let key = rand::random::<u64>();

        let source_code = r#"
        #include <iostream>
        using namespace std;

        int main() {
            cout << "KEY" << endl;
            return 0;
        }
        "#.replace("KEY", &key.to_string());

        let source_path = tempdir.path().join("test.cpp");
        // Write the source code to a file
        std::fs::write(&source_path, source_code).unwrap();

        let output_path = gcc.compile(&source_path, None).unwrap();

        assert!(output_path.exists());

        // run the compiled program
        let output = std::process::Command::new(&output_path)
            .output()
            .expect("Failed to execute compiled program");

        assert!(output.status.success());

        let output_str = String::from_utf8_lossy(&output.stdout);

        assert!(output_str.contains(&key.to_string()));

        drop(tempdir);
    }

    #[test]
    fn test_compile_error() {
        let gcc = Gcc::new().unwrap();

        let tempdir = tempfile::TempDir::new().unwrap();

        let source_code = r#"
        #include <iostream>
        using namespace std;

        int main() {
        fdsahfjkasfhjk;
            cout << "Hello, World!" << endl;
            return 0;
        }
        "#;

        let source_path = tempdir.path().join("test.cpp");
        // Write the source code to a file
        std::fs::write(&source_path, source_code).unwrap();
        assert!(matches!(gcc.compile(&source_path, None), Err(Error::CompilerError { .. })));

        drop(tempdir);
    }
}