verbena 0.1.0

Scripting language
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
133
134
135
136
137
138
139
140
141

use verbena::*;

#[test]
fn ats() {
    let text = prep("@@@@@");
    let r = parse(&text);
    match r {
        Ok(_) => panic!(),
        Err(_) => {}
    }
}

#[test]
fn test_invalid_escape_sequence() {
    let text = prep("print \"Hello\\z World\"");
    let r = parse(&text);
    match r {
        Ok(_) => panic!("Should fail on invalid escape sequence"),
        Err(_) => {}
    }
}

#[test]
fn test_invalid_hex_escape() {
    let text = prep("print \"Hello\\xZG World\"");
    let r = parse(&text);
    match r {
        Ok(_) => panic!("Should fail on invalid hex escape"),
        Err(_) => {}
    }
}

#[test]
fn test_invalid_unicode_escape_no_brace() {
    let text = prep("print \"Hello\\u1234 World\"");
    let r = parse(&text);
    match r {
        Ok(_) => panic!("Should fail on invalid unicode escape without braces"),
        Err(_) => {}
    }
}

#[test]
fn test_invalid_unicode_escape_non_hex() {
    let text = prep("print \"Hello\\u{XYZW} World\"");
    let r = parse(&text);
    match r {
        Ok(_) => panic!("Should fail on non-hex characters in unicode escape"),
        Err(_) => {}
    }
}

#[test]
fn test_unterminated_string() {
    let text = prep("print \"Hello World");
    let r = parse(&text);
    match r {
        Ok(_) => panic!("Should fail on unterminated string"),
        Err(_) => {}
    }
}

#[test]
fn test_unclosed_unicode_brace() {
    let text = prep("print \"Hello\\u{1234 World\"");
    let r = parse(&text);
    match r {
        Ok(_) => panic!("Should fail on unclosed unicode escape brace"),
        Err(_) => {}
    }
}

#[test]
fn test_invalid_bang() {
    let text = prep("print !true");
    let r = parse(&text);
    match r {
        Ok(_) => panic!("Should fail on invalid bang usage"),
        Err(_) => {}
    }
}

#[test]
fn test_multiline_error() {
    let text = prep("print \"Hello\"\n@@@");
    let r = parse(&text);
    match r {
        Ok(_) => panic!("Should fail on invalid character"),
        Err(_) => {}
    }
}

#[test]
fn test_invalid_unicode_codepoint() {
    let text = prep("print \"Hello\\u{D800} World\""); // D800 is an invalid codepoint (surrogate)
    let r = parse(&text);
    match r {
        Ok(_) => panic!("Should fail on invalid Unicode codepoint"),
        Err(_) => {}
    }
}

#[test]
fn test_empty_unicode_escape() {
    let text = prep("print \"Hello\\u{} World\"");
    let r = parse(&text);
    match r {
        Ok(_) => panic!("Should fail on empty Unicode escape"),
        Err(_) => {}
    }
}

#[test]
fn test_unicode_escape_too_large() {
    let text = prep("print \"Hello\\u{110000} World\""); // Larger than U+10FFFF
    let r = parse(&text);
    match r {
        Ok(_) => panic!("Should fail on Unicode codepoint too large"),
        Err(_) => {}
    }
}

#[test]
fn test_incomplete_hex_escape() {
    let text = prep("print \"Hello\\x4\""); // Needs two hex digits
    let r = parse(&text);
    match r {
        Ok(_) => panic!("Should fail on incomplete hex escape"),
        Err(_) => {}
    }
}

#[test]
fn test_invalid_token_sequence() {
    let text = prep("print + \"Hello\"");
    let r = parse(&text);
    match r {
        Ok(_) => panic!("Should fail on invalid token sequence"),
        Err(_) => {}
    }
}