Chih-Hung Hsieh | e42c505 | 2020-04-16 10:44:21 -0700 | [diff] [blame] | 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() { |
| 15 | let re = regex!(r"[0-9]*"); |
| 16 | assert_eq!(vec![(0, 0), (1, 2), (3, 4)], findall!(re, "a1b2")); |
| 17 | } |
| 18 | |
| 19 | #[test] |
| 20 | fn many_zero_length_match() { |
| 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 | ); |
| 26 | } |
| 27 | |
| 28 | #[test] |
| 29 | fn many_sequential_zero_length_match() { |
| 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 | ); |
| 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".*?"); |
| 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(); |
| 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()); |
| 79 | assert_eq!( |
| 80 | vec![None, None, Some("a")], |
| 81 | re.capture_names().collect::<Vec<_>>() |
| 82 | ); |
| 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 { |
| 124 | let re = regex!(r"(?P<number>[0-9]+)"); |
| 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 | |
| 138 | assert_eq!((0, 3), { |
| 139 | let m = cap.get(0).unwrap(); |
| 140 | (m.start(), m.end()) |
| 141 | }); |
| 142 | assert_eq!(None, cap.get(2)); |
| 143 | assert_eq!((2, 3), { |
| 144 | let m = cap.get(4).unwrap(); |
| 145 | (m.start(), m.end()) |
| 146 | }); |
| 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 | |
| 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 | |
Chih-Hung Hsieh | 849e445 | 2020-10-26 13:16:47 -0700 | [diff] [blame] | 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 | |
Chih-Hung Hsieh | e42c505 | 2020-04-16 10:44:21 -0700 | [diff] [blame] | 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!("")]); |