]>
Commit | Line | Data |
---|---|---|
94b46f34 XL |
1 | #[test] |
2 | fn empty_regex_empty_match() { | |
3 | let re = regex!(""); | |
4 | assert_eq!(vec![(0, 0)], findall!(re, "")); | |
5 | } | |
6 | ||
7 | #[test] | |
8 | fn empty_regex_nonempty_match() { | |
9 | let re = regex!(""); | |
10 | assert_eq!(vec![(0, 0), (1, 1), (2, 2), (3, 3)], findall!(re, "abc")); | |
11 | } | |
12 | ||
13 | #[test] | |
14 | fn one_zero_length_match() { | |
f9f354fc | 15 | let re = regex!(r"[0-9]*"); |
94b46f34 XL |
16 | assert_eq!(vec![(0, 0), (1, 2), (3, 4)], findall!(re, "a1b2")); |
17 | } | |
18 | ||
19 | #[test] | |
20 | fn many_zero_length_match() { | |
f9f354fc XL |
21 | let re = regex!(r"[0-9]*"); |
22 | assert_eq!( | |
23 | vec![(0, 0), (1, 2), (3, 3), (4, 4), (5, 6)], | |
24 | findall!(re, "a1bbb2") | |
25 | ); | |
94b46f34 XL |
26 | } |
27 | ||
28 | #[test] | |
29 | fn many_sequential_zero_length_match() { | |
f9f354fc XL |
30 | let re = regex!(r"[0-9]?"); |
31 | assert_eq!( | |
32 | vec![(0, 0), (1, 2), (2, 3), (4, 5), (6, 6)], | |
33 | findall!(re, "a12b3c") | |
34 | ); | |
94b46f34 XL |
35 | } |
36 | ||
37 | #[test] | |
38 | fn quoted_bracket_set() { | |
39 | let re = regex!(r"([\x{5b}\x{5d}])"); | |
40 | assert_eq!(vec![(0, 1), (1, 2)], findall!(re, "[]")); | |
41 | let re = regex!(r"([\[\]])"); | |
42 | assert_eq!(vec![(0, 1), (1, 2)], findall!(re, "[]")); | |
43 | } | |
44 | ||
45 | #[test] | |
46 | fn first_range_starts_with_left_bracket() { | |
47 | let re = regex!(r"([\[-z])"); | |
48 | assert_eq!(vec![(0, 1), (1, 2)], findall!(re, "[]")); | |
49 | } | |
50 | ||
51 | #[test] | |
52 | fn range_ends_with_escape() { | |
53 | let re = regex!(r"([\[-\x{5d}])"); | |
54 | assert_eq!(vec![(0, 1), (1, 2)], findall!(re, "[]")); | |
55 | } | |
56 | ||
57 | #[test] | |
58 | fn empty_match_find_iter() { | |
59 | let re = regex!(r".*?"); | |
60 | assert_eq!(vec![(0, 0), (1, 1), (2, 2), (3, 3)], findall!(re, "abc")); | |
61 | } | |
62 | ||
63 | #[test] | |
64 | fn empty_match_captures_iter() { | |
65 | let re = regex!(r".*?"); | |
f9f354fc XL |
66 | let ms: Vec<_> = re |
67 | .captures_iter(text!("abc")) | |
68 | .map(|c| c.get(0).unwrap()) | |
69 | .map(|m| (m.start(), m.end())) | |
70 | .collect(); | |
94b46f34 XL |
71 | assert_eq!(ms, vec![(0, 0), (1, 1), (2, 2), (3, 3)]); |
72 | } | |
73 | ||
74 | #[test] | |
75 | fn capture_names() { | |
76 | let re = regex!(r"(.)(?P<a>.)"); | |
77 | assert_eq!(3, re.captures_len()); | |
78 | assert_eq!((3, Some(3)), re.capture_names().size_hint()); | |
f9f354fc XL |
79 | assert_eq!( |
80 | vec![None, None, Some("a")], | |
81 | re.capture_names().collect::<Vec<_>>() | |
82 | ); | |
94b46f34 XL |
83 | } |
84 | ||
85 | #[test] | |
86 | fn regex_string() { | |
87 | assert_eq!(r"[a-zA-Z0-9]+", regex!(r"[a-zA-Z0-9]+").as_str()); | |
88 | assert_eq!(r"[a-zA-Z0-9]+", &format!("{}", regex!(r"[a-zA-Z0-9]+"))); | |
89 | assert_eq!(r"[a-zA-Z0-9]+", &format!("{:?}", regex!(r"[a-zA-Z0-9]+"))); | |
90 | } | |
91 | ||
92 | #[test] | |
93 | fn capture_index() { | |
94 | let re = regex!(r"^(?P<name>.+)$"); | |
95 | let cap = re.captures(t!("abc")).unwrap(); | |
96 | assert_eq!(&cap[0], t!("abc")); | |
97 | assert_eq!(&cap[1], t!("abc")); | |
98 | assert_eq!(&cap["name"], t!("abc")); | |
99 | } | |
100 | ||
101 | #[test] | |
102 | #[should_panic] | |
103 | #[cfg_attr(all(target_env = "msvc", target_pointer_width = "32"), ignore)] | |
104 | fn capture_index_panic_usize() { | |
105 | let re = regex!(r"^(?P<name>.+)$"); | |
106 | let cap = re.captures(t!("abc")).unwrap(); | |
107 | let _ = cap[2]; | |
108 | } | |
109 | ||
110 | #[test] | |
111 | #[should_panic] | |
112 | #[cfg_attr(all(target_env = "msvc", target_pointer_width = "32"), ignore)] | |
113 | fn capture_index_panic_name() { | |
114 | let re = regex!(r"^(?P<name>.+)$"); | |
115 | let cap = re.captures(t!("abc")).unwrap(); | |
116 | let _ = cap["bad name"]; | |
117 | } | |
118 | ||
119 | #[test] | |
120 | fn capture_index_lifetime() { | |
121 | // This is a test of whether the types on `caps["..."]` are general | |
122 | // enough. If not, this will fail to typecheck. | |
123 | fn inner(s: &str) -> usize { | |
f9f354fc | 124 | let re = regex!(r"(?P<number>[0-9]+)"); |
94b46f34 XL |
125 | let caps = re.captures(t!(s)).unwrap(); |
126 | caps["number"].len() | |
127 | } | |
128 | assert_eq!(3, inner("123")); | |
129 | } | |
130 | ||
131 | #[test] | |
132 | fn capture_misc() { | |
133 | let re = regex!(r"(.)(?P<a>a)?(.)(?P<b>.)"); | |
134 | let cap = re.captures(t!("abc")).unwrap(); | |
135 | ||
136 | assert_eq!(5, cap.len()); | |
137 | ||
f9f354fc XL |
138 | assert_eq!((0, 3), { |
139 | let m = cap.get(0).unwrap(); | |
140 | (m.start(), m.end()) | |
141 | }); | |
94b46f34 | 142 | assert_eq!(None, cap.get(2)); |
f9f354fc XL |
143 | assert_eq!((2, 3), { |
144 | let m = cap.get(4).unwrap(); | |
145 | (m.start(), m.end()) | |
146 | }); | |
94b46f34 XL |
147 | |
148 | assert_eq!(t!("abc"), match_text!(cap.get(0).unwrap())); | |
149 | assert_eq!(None, cap.get(2)); | |
150 | assert_eq!(t!("c"), match_text!(cap.get(4).unwrap())); | |
151 | ||
152 | assert_eq!(None, cap.name("a")); | |
153 | assert_eq!(t!("c"), match_text!(cap.name("b").unwrap())); | |
154 | } | |
155 | ||
156 | #[test] | |
157 | fn sub_capture_matches() { | |
158 | let re = regex!(r"([a-z])(([a-z])|([0-9]))"); | |
159 | let cap = re.captures(t!("a5")).unwrap(); | |
160 | let subs: Vec<_> = cap.iter().collect(); | |
161 | ||
162 | assert_eq!(5, subs.len()); | |
163 | assert!(subs[0].is_some()); | |
164 | assert!(subs[1].is_some()); | |
165 | assert!(subs[2].is_some()); | |
166 | assert!(subs[3].is_none()); | |
167 | assert!(subs[4].is_some()); | |
168 | ||
169 | assert_eq!(t!("a5"), match_text!(subs[0].unwrap())); | |
170 | assert_eq!(t!("a"), match_text!(subs[1].unwrap())); | |
171 | assert_eq!(t!("5"), match_text!(subs[2].unwrap())); | |
172 | assert_eq!(t!("5"), match_text!(subs[4].unwrap())); | |
173 | } | |
174 | ||
f9f354fc XL |
175 | expand!(expand1, r"(?-u)(?P<foo>\w+)", "abc", "$foo", "abc"); |
176 | expand!(expand2, r"(?-u)(?P<foo>\w+)", "abc", "$0", "abc"); | |
177 | expand!(expand3, r"(?-u)(?P<foo>\w+)", "abc", "$1", "abc"); | |
178 | expand!(expand4, r"(?-u)(?P<foo>\w+)", "abc", "$$1", "$1"); | |
179 | expand!(expand5, r"(?-u)(?P<foo>\w+)", "abc", "$$foo", "$foo"); | |
180 | expand!(expand6, r"(?-u)(?P<a>\w+)\s+(?P<b>\d+)", "abc 123", "$b$a", "123abc"); | |
181 | expand!(expand7, r"(?-u)(?P<a>\w+)\s+(?P<b>\d+)", "abc 123", "z$bz$az", "z"); | |
182 | expand!( | |
183 | expand8, | |
184 | r"(?-u)(?P<a>\w+)\s+(?P<b>\d+)", | |
185 | "abc 123", | |
186 | ".$b.$a.", | |
187 | ".123.abc." | |
188 | ); | |
189 | expand!( | |
190 | expand9, | |
191 | r"(?-u)(?P<a>\w+)\s+(?P<b>\d+)", | |
192 | "abc 123", | |
193 | " $b $a ", | |
194 | " 123 abc " | |
195 | ); | |
196 | expand!(expand10, r"(?-u)(?P<a>\w+)\s+(?P<b>\d+)", "abc 123", "$bz$az", ""); | |
197 | ||
5869c6ff XL |
198 | expand!(expand_name1, r"%(?P<Z>[a-z]+)", "%abc", "$Z%", "abc%"); |
199 | expand!(expand_name2, r"\[(?P<Z>[a-z]+)", "[abc", "$Z[", "abc["); | |
200 | expand!(expand_name3, r"\{(?P<Z>[a-z]+)", "{abc", "$Z{", "abc{"); | |
201 | expand!(expand_name4, r"\}(?P<Z>[a-z]+)", "}abc", "$Z}", "abc}"); | |
202 | expand!(expand_name5, r"%([a-z]+)", "%abc", "$1a%", "%"); | |
203 | expand!(expand_name6, r"%([a-z]+)", "%abc", "${1}a%", "abca%"); | |
204 | expand!(expand_name7, r"\[(?P<Z[>[a-z]+)", "[abc", "${Z[}[", "abc["); | |
205 | expand!(expand_name8, r"\[(?P<Z[>[a-z]+)", "[abc", "${foo}[", "["); | |
206 | expand!(expand_name9, r"\[(?P<Z[>[a-z]+)", "[abc", "${1a}[", "["); | |
207 | expand!(expand_name10, r"\[(?P<Z[>[a-z]+)", "[abc", "${#}[", "["); | |
208 | expand!(expand_name11, r"\[(?P<Z[>[a-z]+)", "[abc", "${$$}[", "["); | |
209 | ||
f9f354fc XL |
210 | split!( |
211 | split1, | |
212 | r"(?-u)\s+", | |
213 | "a b\nc\td\n\t e", | |
214 | &[t!("a"), t!("b"), t!("c"), t!("d"), t!("e")] | |
215 | ); | |
216 | split!( | |
217 | split2, | |
218 | r"(?-u)\b", | |
219 | "a b c", | |
220 | &[t!(""), t!("a"), t!(" "), t!("b"), t!(" "), t!("c"), t!("")] | |
221 | ); | |
222 | split!(split3, r"a$", "a", &[t!(""), t!("")]); | |
223 | split!(split_none, r"-", r"a", &[t!("a")]); | |
224 | split!(split_trailing_blank, r"-", r"a-", &[t!("a"), t!("")]); | |
225 | split!(split_trailing_blanks, r"-", r"a--", &[t!("a"), t!(""), t!("")]); | |
226 | split!(split_empty, r"-", r"", &[t!("")]); | |
227 | ||
228 | splitn!(splitn_below_limit, r"-", r"a", 2, &[t!("a")]); | |
229 | splitn!(splitn_at_limit, r"-", r"a-b", 2, &[t!("a"), t!("b")]); | |
230 | splitn!(splitn_above_limit, r"-", r"a-b-c", 2, &[t!("a"), t!("b-c")]); | |
231 | splitn!(splitn_zero_limit, r"-", r"a-b", 0, empty_vec!()); | |
232 | splitn!(splitn_trailing_blank, r"-", r"a-", 2, &[t!("a"), t!("")]); | |
233 | splitn!(splitn_trailing_separator, r"-", r"a--", 2, &[t!("a"), t!("-")]); | |
234 | splitn!(splitn_empty, r"-", r"", 1, &[t!("")]); |