robinson 0.5.21

For when you go to a lonely island and survival depends on parsing XML.
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

use std::env::var;
use std::fs::{read_dir, read_to_string, write};

use pretty_assertions::assert_eq;
use robinson::Document;

fn test(name: &str) {
    let input = format!("tests/inputs/{name}.xml");
    let output = format!("tests/outputs/{name}.dbg");

    let text = read_to_string(&input).unwrap();

    let res = Document::parse(&text);
    let ast = format!("{res:#?}\n");

    let expected_ast = read_to_string(&output).unwrap_or_default();

    if var("OVERWRITE_OUTPUTS").is_ok() {
        write(&output, &ast).unwrap();
    }

    assert_eq!(expected_ast, ast);
}

macro_rules! test {
    ($name:ident) => {
        #[test]
        fn $name() {
            test(stringify!($name));
        }
    };
}

// <<<<<<< discovered_tests
test!(attribute_values);
test!(attributes);
test!(billion_laughs_attribute_value);
test!(billion_laughs_element);
test!(cdata);
test!(children);
test!(comment);
test!(crlf_via_char);
test!(crlf_via_entity);
test!(declaration);
test!(declaration_pi);
test!(empty);
test!(entity_reference_attribute_value);
test!(entity_reference_element);
test!(invalid_reference_hexcode);
test!(missing_root_element);
test!(namespace_close_element);
test!(overwrite_namespace);
test!(pi);
test!(public_doctype);
test!(text);
test!(text_entity_interleaved);
test!(unclosed_root_element);
test!(unknown_namespace_empty);
test!(xml_namespace);
// >>>>>>> discovered_tests

#[test]
fn discover_tests() {
    let mut tests = Vec::new();

    for entry in read_dir("tests/inputs").unwrap() {
        let entry = entry.unwrap();

        let file_name = entry.file_name().into_string().unwrap();

        if let Some(test) = file_name.strip_suffix(".xml") {
            tests.push(format!("test!({test});"));
        }
    }

    let source = read_to_string("tests/parse.rs").unwrap();

    let mut discovered_tests = source
        .lines()
        .skip_while(|line| *line != "// <<<<<<< discovered_tests")
        .skip(1)
        .take_while(|line| *line != "// >>>>>>> discovered_tests")
        .collect::<Vec<_>>();

    tests.sort_unstable();
    discovered_tests.sort_unstable();

    if tests != discovered_tests {
        let mut old_lines = source.lines();
        let mut new_lines = Vec::new();

        for line in &mut old_lines {
            new_lines.push(line);
            if line == "// <<<<<<< discovered_tests" {
                break;
            }
        }

        new_lines.extend(tests.iter().map(|test| test.as_str()));

        for line in &mut old_lines {
            if line == "// >>>>>>> discovered_tests" {
                new_lines.push(line);
                break;
            }
        }

        new_lines.extend(old_lines);

        write("tests/parse.rs", new_lines.join("\n")).unwrap();
    }

    assert_eq!(tests, discovered_tests);
}