Skip to content

Commit a61eb7e

Browse files
Mr-LeshiyMr-Leshiy
committed
refactor character_sets tests
1 parent 4e4deec commit a61eb7e

File tree

2 files changed

+65
-117
lines changed

2 files changed

+65
-117
lines changed

‎rust/cbork-cddl-parser/tests/character_sets.rs‎

Lines changed: 60 additions & 114 deletions
Original file line numberDiff line numberDiff line change
@@ -1,149 +1,95 @@
11
// cspell: words PCHAR pchar BCHAR bchar SESC sesc SCHAR schar fffd fffe
22

33
mod common;
4-
use common::{CDDLTestParser, Rule};
5-
use pest::Parser;
4+
use common::Rule;
65

7-
#[test]
86
/// Test if the `WHITESPACE` rule passes properly.
7+
#[test]
98
fn check_whitespace() {
10-
let whitespace = vec![" ", "\t", "\r", "\n", "\r\n"];
11-
12-
let not_whitespace = "not";
13-
14-
for ws in whitespace {
15-
let parse = CDDLTestParser::parse(Rule::WHITESPACE, ws);
16-
assert!(parse.is_ok());
17-
}
18-
19-
let parse = CDDLTestParser::parse(Rule::WHITESPACE, not_whitespace);
20-
assert!(parse.is_err());
9+
common::check_tests_rule(Rule::WHITESPACE, &[" ", "\t", "\r", "\n", "\r\n"], &["not"]);
2110
}
2211

23-
#[test]
2412
/// Test if the `PCHAR` rule passes properly.
13+
#[test]
2514
fn check_pchar() {
26-
for x in ('\u{0}'..='\u{ff}').map(char::from) {
27-
let test = format!("{x}");
28-
let parse = CDDLTestParser::parse(Rule::PCHAR, &test);
29-
if x < ' ' || x == '\u{7f}' {
30-
assert!(parse.is_err());
31-
} else {
32-
assert!(parse.is_ok());
33-
}
34-
}
35-
36-
let parse = CDDLTestParser::parse(Rule::ASCII_VISIBLE, "\r");
37-
assert!(parse.is_err());
15+
let passes = ('\u{0}'..='\u{ff}')
16+
.filter(|x| x >= &' ' && x != &'\u{7f}')
17+
.map(String::from)
18+
.collect::<Vec<_>>();
19+
let fails = ('\u{0}'..='\u{ff}')
20+
.filter(|x| x < &' ' || x == &'\u{7f}')
21+
.map(String::from)
22+
.collect::<Vec<_>>();
23+
common::check_tests_rule(Rule::PCHAR, &passes, &fails);
3824
}
3925

40-
#[test]
4126
/// Test if the `BCHAR` rule passes properly.
27+
#[test]
4228
fn check_bchar() {
43-
for x in ('\u{0}'..='\u{ff}').map(char::from) {
44-
let test = format!("{x}");
45-
let parse = CDDLTestParser::parse(Rule::BCHAR, &test);
46-
if !matches!(x, '\n' | '\r') && x < ' ' || matches!(x, '\t' | '\'' | '\\' | '\u{7f}') {
47-
assert!(parse.is_err());
48-
} else {
49-
assert!(parse.is_ok());
50-
}
51-
}
52-
53-
let parse = CDDLTestParser::parse(Rule::ASCII_VISIBLE, "\r");
54-
assert!(parse.is_err());
29+
let passes = ('\u{0}'..='\u{ff}')
30+
.filter(|x| {
31+
(x >= &' ' && !matches!(x, '\t' | '\'' | '\\' | '\u{7f}')) || matches!(x, '\n' | '\r')
32+
})
33+
.map(String::from)
34+
.collect::<Vec<_>>();
35+
36+
let fails = ('\u{0}'..='\u{ff}')
37+
.filter(|x| {
38+
x < &' ' && !matches!(x, '\n' | '\r') || matches!(x, '\t' | '\'' | '\\' | '\u{7f}')
39+
})
40+
.map(String::from)
41+
.collect::<Vec<_>>();
42+
43+
common::check_tests_rule(Rule::BCHAR, &passes, &fails);
5544
}
5645

57-
#[test]
5846
/// Test if the `SESC` rule passes properly.
47+
#[test]
5948
fn check_sesc() {
60-
for x in (' '..='\u{ff}').map(char::from) {
61-
let test = format!("\\{x}");
62-
let parse = CDDLTestParser::parse(Rule::SESC, &test);
63-
if x == '\u{7f}' {
64-
assert!(parse.is_err());
65-
} else {
66-
assert!(parse.is_ok());
67-
}
68-
}
69-
70-
let parse = CDDLTestParser::parse(Rule::ASCII_VISIBLE, "\r");
71-
assert!(parse.is_err());
49+
let passes = (' '..='\u{ff}')
50+
.filter(|x| x != &'\u{7f}')
51+
.map(|x| format!("\\{x}"))
52+
.collect::<Vec<_>>();
53+
common::check_tests_rule(Rule::SESC, &passes, &["\u{7f}"]);
7254
}
7355

74-
#[test]
7556
/// Test if the `ASCII_VISIBLE` rule passes properly.
57+
#[test]
7658
fn check_ascii_visible() {
77-
for x in (b' '..=b'~').map(char::from) {
78-
let test = x.to_string();
79-
let parse = CDDLTestParser::parse(Rule::ASCII_VISIBLE, &test);
80-
assert!(parse.is_ok());
81-
}
82-
83-
let parse = CDDLTestParser::parse(Rule::ASCII_VISIBLE, "\r");
84-
assert!(parse.is_err());
85-
86-
let parse = CDDLTestParser::parse(Rule::ASCII_VISIBLE, "\u{80}");
87-
assert!(parse.is_err());
59+
let passes = (' '..='~').map(String::from).collect::<Vec<_>>();
60+
common::check_tests_rule(Rule::ASCII_VISIBLE, &passes, &["\r", "\u{80}"]);
8861
}
8962

90-
#[test]
9163
/// Test if the `SCHAR_ASCII_VISIBLE` rule passes properly.
64+
#[test]
9265
fn check_schar_ascii_visible() {
93-
let invalids = "\"\\";
94-
for x in (b' '..=b'~').map(char::from) {
95-
let test = x.to_string();
96-
let parse = CDDLTestParser::parse(Rule::SCHAR_ASCII_VISIBLE, &test);
97-
if invalids.contains(x) {
98-
assert!(parse.is_err());
99-
} else {
100-
assert!(parse.is_ok());
101-
}
102-
}
103-
104-
let parse = CDDLTestParser::parse(Rule::SCHAR_ASCII_VISIBLE, "\r");
105-
assert!(parse.is_err());
106-
107-
let parse = CDDLTestParser::parse(Rule::SCHAR_ASCII_VISIBLE, "\u{80}");
108-
assert!(parse.is_err());
66+
let passes = (' '..='~')
67+
.filter(|c| c != &'"' && c != &'\\')
68+
.map(String::from)
69+
.collect::<Vec<_>>();
70+
common::check_tests_rule(Rule::SCHAR_ASCII_VISIBLE, &passes, &[
71+
"\"", "\\", "\r", "\u{80}",
72+
]);
10973
}
11074

111-
#[test]
11275
/// Test if the `BCHAR_ASCII_VISIBLE` rule passes properly.
76+
#[test]
11377
fn check_bchar_ascii_visible() {
114-
let invalids = "'\\";
115-
for x in (b' '..=b'~').map(char::from) {
116-
let test = x.to_string();
117-
let parse = CDDLTestParser::parse(Rule::BCHAR_ASCII_VISIBLE, &test);
118-
if invalids.contains(x) {
119-
assert!(parse.is_err());
120-
} else {
121-
assert!(parse.is_ok());
122-
}
123-
}
124-
125-
let parse = CDDLTestParser::parse(Rule::BCHAR_ASCII_VISIBLE, "\r");
126-
assert!(parse.is_err());
127-
128-
let parse = CDDLTestParser::parse(Rule::BCHAR_ASCII_VISIBLE, "\u{80}");
129-
assert!(parse.is_err());
78+
let passes = (' '..='~')
79+
.filter(|c| c != &'\'' && c != &'\\')
80+
.map(String::from)
81+
.collect::<Vec<_>>();
82+
common::check_tests_rule(Rule::BCHAR_ASCII_VISIBLE, &passes, &[
83+
"'", "\\", "\r", "\u{80}",
84+
]);
13085
}
13186

132-
#[test]
13387
/// Test if the `UNICODE_CHAR` rule passes properly.
88+
#[test]
13489
fn check_unicode() {
135-
let parse = CDDLTestParser::parse(Rule::UNICODE_CHAR, "\r");
136-
assert!(parse.is_err());
137-
138-
let parse = CDDLTestParser::parse(Rule::UNICODE_CHAR, "\u{80}");
139-
assert!(parse.is_ok());
140-
141-
let parse = CDDLTestParser::parse(Rule::UNICODE_CHAR, "\u{10fffd}");
142-
assert!(parse.is_ok());
143-
144-
let parse = CDDLTestParser::parse(Rule::UNICODE_CHAR, "\u{7ffff}");
145-
assert!(parse.is_ok());
146-
147-
let parse = CDDLTestParser::parse(Rule::UNICODE_CHAR, "\u{10fffe}");
148-
assert!(parse.is_err());
90+
common::check_tests_rule(
91+
Rule::UNICODE_CHAR,
92+
&["\u{80}", "\u{10fffd}", "\u{7ffff}"],
93+
&["\r", "\u{10fffe}"],
94+
);
14995
}

‎rust/cbork-cddl-parser/tests/common/mod.rs‎

Lines changed: 5 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -19,14 +19,16 @@ pub struct CDDLTestParser;
1919

2020
/// # Panics
2121
#[allow(dead_code)]
22-
pub(crate) fn check_tests_rule(rule_type: Rule, passes: &[&str], fails: &[&str]) {
22+
pub(crate) fn check_tests_rule(
23+
rule_type: Rule, passes: &[impl AsRef<str>], fails: &[impl AsRef<str>],
24+
) {
2325
for test in passes {
24-
let parse = CDDLTestParser::parse(rule_type, test);
26+
let parse = CDDLTestParser::parse(rule_type, test.as_ref());
2527
assert!(parse.is_ok());
2628
}
2729

2830
for test in fails {
29-
let parse = CDDLTestParser::parse(rule_type, test);
31+
let parse = CDDLTestParser::parse(rule_type, test.as_ref());
3032
assert!(parse.is_err());
3133
}
3234
}

0 commit comments

Comments
 (0)