1 // Convenience macros.
2 
3 macro_rules! findall {
4     ($re:expr, $text:expr) => {{
5         $re.find_iter(text!($text))
6            .map(|m| (m.start(), m.end())).collect::<Vec<_>>()
7     }}
8 }
9 
10 // Macros for automatically producing tests.
11 
12 macro_rules! ismatch {
13     ($name:ident, $re:expr, $text:expr, $ismatch:expr) => {
14         #[test]
15         fn $name() {
16             let re = regex!($re);
17             assert_eq!($ismatch, re.is_match(text!($text)));
18         }
19     };
20 }
21 
22 macro_rules! mat(
23     ($name:ident, $re:expr, $text:expr, $($loc:tt)+) => (
24         #[test]
25         fn $name() {
26             let text = text!($text);
27             let expected: Vec<Option<_>> = vec![$($loc)+];
28             let r = regex!($re);
29             let got: Vec<Option<_>> = match r.captures(text) {
30                 Some(c) => {
31                     assert!(r.is_match(text));
32                     assert!(r.shortest_match(text).is_some());
33                     r.capture_names()
34                      .enumerate()
35                      .map(|(i, _)| c.get(i).map(|m| (m.start(), m.end())))
36                      .collect()
37                 }
38                 None => vec![None],
39             };
40             // The test set sometimes leave out capture groups, so truncate
41             // actual capture groups to match test set.
42             let mut sgot = &got[..];
43             if sgot.len() > expected.len() {
44                 sgot = &sgot[0..expected.len()]
45             }
46             if expected != sgot {
47                 panic!("For RE '{}' against '{:?}', \
48                         expected '{:?}' but got '{:?}'",
49                        $re, text, expected, sgot);
50             }
51         }
52     );
53 );
54 
55 macro_rules! matiter(
56     ($name:ident, $re:expr, $text:expr) => (
57         #[test]
58         fn $name() {
59             let text = text!($text);
60             let expected: Vec<(usize, usize)> = vec![];
61             let r = regex!($re);
62             let got: Vec<_> =
63                 r.find_iter(text).map(|m| (m.start(), m.end())).collect();
64             if expected != got {
65                 panic!("For RE '{}' against '{:?}', \
66                         expected '{:?}' but got '{:?}'",
67                        $re, text, expected, got);
68             }
69             let captures_got: Vec<_> =
70                 r.captures_iter(text)
71                  .map(|c| c.get(0).unwrap())
72                  .map(|m| (m.start(), m.end()))
73                  .collect();
74             if captures_got != got {
75                 panic!("For RE '{}' against '{:?}', \
76                         got '{:?}' using find_iter but got '{:?}' \
77                         using captures_iter",
78                        $re, text, got, captures_got);
79             }
80         }
81     );
82     ($name:ident, $re:expr, $text:expr, $($loc:tt)+) => (
83         #[test]
84         fn $name() {
85             let text = text!($text);
86             let expected: Vec<_> = vec![$($loc)+];
87             let r = regex!($re);
88             let got: Vec<_> =
89                 r.find_iter(text).map(|m| (m.start(), m.end())).collect();
90             if expected != got {
91                 panic!("For RE '{}' against '{:?}', \
92                         expected '{:?}' but got '{:?}'",
93                        $re, text, expected, got);
94             }
95             let captures_got: Vec<_> =
96                 r.captures_iter(text)
97                  .map(|c| c.get(0).unwrap())
98                  .map(|m| (m.start(), m.end()))
99                  .collect();
100             if captures_got != got {
101                 panic!("For RE '{}' against '{:?}', \
102                         got '{:?}' using find_iter but got '{:?}' \
103                         using captures_iter",
104                        $re, text, got, captures_got);
105             }
106         }
107     );
108 );
109 
110 macro_rules! matset {
111     ($name:ident, $res:expr, $text:expr, $($match_index:expr),*) => {
112         #[test]
113         fn $name() {
114             let text = text!($text);
115             let set = regex_set!($res);
116             assert!(set.is_match(text));
117             let expected = vec![$($match_index),*];
118             let matches = set.matches(text);
119             assert!(matches.matched_any());
120             let got: Vec<_> = matches.into_iter().collect();
121             assert_eq!(expected, got);
122         }
123     }
124 }
125 
126 macro_rules! nomatset {
127     ($name:ident, $res:expr, $text:expr) => {
128         #[test]
129         fn $name() {
130             let text = text!($text);
131             let set = regex_set!($res);
132             assert!(!set.is_match(text));
133             let matches = set.matches(text);
134             assert!(!matches.matched_any());
135             assert_eq!(0, matches.into_iter().count());
136         }
137     }
138 }
139 
140 macro_rules! split {
141     ($name:ident, $re:expr, $text:expr, $expected:expr) => {
142         #[test]
143         fn $name() {
144             let re = regex!($re);
145             let splitted: Vec<_> = re.split(t!($text)).collect();
146             assert_eq!($expected, &*splitted);
147         }
148     }
149 }
150 
151 macro_rules! splitn {
152     ($name:ident, $re:expr, $text:expr, $limit:expr, $expected:expr) => {
153         #[test]
154         fn $name() {
155             let re = regex!($re);
156             let splitted: Vec<_> = re.splitn(t!($text), $limit).collect();
157             assert_eq!($expected, &*splitted);
158         }
159     }
160 }
161