26         load!(col, "fowler/repetition-long.toml");
30         load!(col, "no-unicode.toml");
49     #[serde(default)]
52     #[serde(with = "serde_bytes")]
54     #[serde(rename = "matches")]
56     #[serde(default)]
58     #[serde(default)]
63 #[serde(rename_all = "kebab-case")]
69     #[serde(rename = "invalid-utf8")]
80     fn new() -> RegexTestCollection {  in new()
85         for test in tests.tests {  in extend()
86             let name = test.name.clone();  in extend()
88                 panic!("found duplicate test {}", name);  in extend()
90             self.by_name.insert(name, test);  in extend()
94     pub fn tests(&self) -> Vec<&RegexTest> {  in tests()
100     fn load(path: &str, slice: &[u8]) -> RegexTests {  in load()
103         for test in &mut data.tests {  in load()
104             if test.options.contains(&RegexTestOption::Escaped) {  in load()
105                 test.input = unescape_bytes(&test.input);  in load()
123         // If we haven't asserted yet, then the test is probably buggy, so  in drop()
125         // engine), then don't double-panic, which causes an immediate abort.  in drop()
127             panic!("must call RegexTester::assert at end of test");  in drop()
133     pub fn new() -> RegexTester {  in new()
146             if x.starts_with("-") {  in new()
155     pub fn skip_expensive(mut self) -> RegexTester {  in skip_expensive()
160     pub fn whitelist(mut self, name: &str) -> RegexTester {  in whitelist()
165     pub fn blacklist(mut self, name: &str) -> RegexTester {  in blacklist()
178         test: &RegexTest,  in build_regex()
179     ) -> Option<Regex<DenseDFA<Vec<S>, S>>> {  in build_regex()
180         if self.skip(test) {  in build_regex()
183         self.apply_options(test, &mut builder);  in build_regex()
185         match builder.build_with_size::<S>(&test.pattern) {  in build_regex()
193                         test.name, test.pattern, err  in build_regex()
205         for test in tests {  in test_all()
207             let re: Regex = match self.build_regex(builder, test) {  in test_all()
211             self.test(test, &re);  in test_all()
215     pub fn test<'a, D: DFA>(&mut self, test: &RegexTest, re: &Regex<D>) {  in test()  method
216         self.test_is_match(test, re);  in test()
217         self.test_find(test, re);  in test()
220         // end, we only test match iteration when the number of matches  in test()
221         // expected is not 1, or if the test name has 'iter' in it.  in test()
222         if test.name.contains("iter") || test.matches.len() != 1 {  in test()
223             self.test_find_iter(test, re);  in test()
229         test: &RegexTest,  in test_is_match()
234         let got = re.is_match(&test.input);  in test_is_match()
235         let expected = test.matches.len() >= 1;  in test_is_match()
237             self.results.succeeded.push(test.clone());  in test_is_match()
241             test: test.clone(),  in test_is_match()
246     pub fn test_find<'a, D: DFA>(&mut self, test: &RegexTest, re: &Regex<D>) {  in test_find()
250             re.find(&test.input).map(|(start, end)| Match { start, end });  in test_find()
251         if got == test.matches.get(0).map(|&m| m) {  in test_find()
252             self.results.succeeded.push(test.clone());  in test_find()
256             test: test.clone(),  in test_find()
263         test: &RegexTest,  in test_find_iter()
269             .find_iter(&test.input)  in test_find_iter()
272         if got == test.matches {  in test_find_iter()
273             self.results.succeeded.push(test.clone());  in test_find_iter()
277             test: test.clone(),  in test_find_iter()
282     fn skip(&self, test: &RegexTest) -> bool {  in skip()
284             if test.name.starts_with("repetition-long") {  in skip()
289             if self.blacklist.iter().any(|re| re.is_match(&test.name)) {  in skip()
294             if !self.whitelist.iter().any(|re| re.is_match(&test.name)) {  in skip()
301     fn apply_options(&self, test: &RegexTest, builder: &mut RegexBuilder) {  in apply_options()
302         for opt in &test.options {  in apply_options()
332     test: RegexTest,  field
357              e.g., REGEX_TEST=crazy-misc,-crazy-misc2 runs every test \n\  in assert()
358              whose name contains crazy-misc but not crazy-misc2\n\n",  in assert()
368     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {  in fmt()
378             self.test.name,  in fmt()
379             self.kind.fmt(&self.test)?,  in fmt()
380             self.test.options,  in fmt()
381             self.test.pattern,  in fmt()
382             escape_default(&self.test.pattern),  in fmt()
383             nice_raw_bytes(&self.test.input),  in fmt()
384             escape_bytes(&self.test.input),  in fmt()
385             hex_bytes(&self.test.input)  in fmt()
391     fn fmt(&self, test: &RegexTest) -> Result<String, fmt::Error> {  in fmt()
395                 if let Some(&m) = test.matches.get(0) {  in fmt()
404                 test.matches.get(0),  in fmt()
410                 test.matches, got  in fmt()
418     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {  in fmt()
424     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {  in fmt()
429 fn nice_raw_bytes(bytes: &[u8]) -> String {  in nice_raw_bytes()
438 fn escape_bytes(bytes: &[u8]) -> String {  in escape_bytes()
448 fn hex_bytes(bytes: &[u8]) -> String {  in hex_bytes()
452 fn escape_default(s: &str) -> String {  in escape_default()
456 fn unescape_bytes(bytes: &[u8]) -> Vec<u8> {  in unescape_bytes()
460     unescape(&str::from_utf8(bytes).expect("all input must be valid UTF-8"))  in unescape_bytes()