leetcode-core 0.5.2

This library helps to talk to leetcode APIs via REST interface
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

use leetcode_core::types::run_submit_response::{ParsedResponse, RunSubmitResult};
use serde_json::{self, Value};

const JSONS_STR: &str = include_str!("./test_solution_run_parsing.json");

pub(crate) fn get_parsed_response(key_name: &str) -> ParsedResponse {
    let parsed: Value = serde_json::from_str(JSONS_STR).unwrap();
    let run_wrong_value = &parsed[key_name];
    let parsed_response: RunSubmitResult = serde_json::from_value(run_wrong_value.clone()).unwrap();
    parsed_response.to_parsed_response().unwrap()
}

#[test]
fn test_should_parse_run_correct_response_correctly() {
    assert!(matches!(
        get_parsed_response("run_correct"),
        ParsedResponse::RunAccepted { .. }
    ))
}

#[test]
fn test_should_parse_run_wrong_response_correctly() {
    assert!(matches!(
        get_parsed_response("run_wrong"),
        ParsedResponse::RunWrongAnswer { .. }
    ))
}

#[test]
fn test_should_parse_submit_correct_response_correctly() {
    assert!(matches!(
        get_parsed_response("submit_correct"),
        ParsedResponse::SubmitAccepted { .. }
    ))
}

#[test]
fn test_should_parse_submit_wrong_response_correctly() {
    assert!(matches!(
        get_parsed_response("submit_wrong"),
        ParsedResponse::SubmitWrongAnswer { .. }
    ))
}

#[test]
fn test_run_correct_response_output() {
    let parsed_response = get_parsed_response("run_correct");
    assert_eq!(
        parsed_response.to_string(),
        vec![
            "Solution ran successfully for 2/2 cases.",
            "Memory used: 2.00 MB",
            "Solution runtime: 0 ms",
        ]
        .join("\n")
    )
}

#[test]
fn test_run_wrong_response_output() {
    let parsed_response = get_parsed_response("run_wrong");
    assert_eq!(
        parsed_response.to_string(),
        vec![
            "Test Run Failed: 0/3 cases passed.",
            "Memory used: 16.39 MB",
            "Solution runtime: 82 ms",
        ]
        .join("\n")
    )
}

#[test]
fn test_submit_correct_response_output() {
    let parsed_response = get_parsed_response("submit_correct");
    assert_eq!(
        parsed_response.to_string(),
        vec![
            "Solution ran successfully for 57/57 cases.",
            "Memory used: 2.35 MB",
            "Solution runtime: 2 ms",
            "Your runtime beats 83.9281 % of the submissions.",
            "Your memory usage beats 39.7233 % of the submissions.",
        ]
        .join("\n")
    )
}

#[test]
fn test_submit_wrong_response_output() {
    let parsed_response = get_parsed_response("submit_wrong");
    assert_eq!(
        parsed_response.to_string(),
        vec![
            "3/80 cases passed.",
            "Memory used: 2.32 MB",
            "Solution runtime: N/A",
        ]
        .join("\n")
    )
}

#[test]
fn test_memory_limit_exceeded_response_output() {
    let parsed_response = get_parsed_response("memory_limit_exceeded");
    assert_eq!(
        parsed_response.to_string(),
        vec!["Memory Limit Exceeded: 976.69 MB"].join("\n")
    )
}
#[test]
fn test_output_limit_response_output() {
    let parsed_response = get_parsed_response("output_limit");
    assert_eq!(
        parsed_response.to_string(),
        vec![
            r#"Output Limit Exceeded: Last Testcase: "maybe long testcase""#,
            r#"Expected Output:"true""#,
            r#"Std Output: "some_long_string""#,
            r#"Code Output: """#,
        ]
        .join("\n")
    )
}