1#[test] 2fn empty_regex_empty_match() { 3 let re = regex!(""); 4 assert_eq!(vec![(0, 0)], findall!(re, "")); 5} 6 7#[test] 8fn 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] 14fn 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] 20fn 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] 29fn 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] 38fn 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] 46fn 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] 52fn 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] 58fn 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] 64fn 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] 75fn 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] 86fn 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] 93fn 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)] 104fn 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)] 113fn 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] 120fn 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] 132fn 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] 157fn 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 175expand!(expand1, r"(?-u)(?P<foo>\w+)", "abc", "$foo", "abc"); 176expand!(expand2, r"(?-u)(?P<foo>\w+)", "abc", "$0", "abc"); 177expand!(expand3, r"(?-u)(?P<foo>\w+)", "abc", "$1", "abc"); 178expand!(expand4, r"(?-u)(?P<foo>\w+)", "abc", "$$1", "$1"); 179expand!(expand5, r"(?-u)(?P<foo>\w+)", "abc", "$$foo", "$foo"); 180expand!(expand6, r"(?-u)(?P<a>\w+)\s+(?P<b>\d+)", "abc 123", "$b$a", "123abc"); 181expand!(expand7, r"(?-u)(?P<a>\w+)\s+(?P<b>\d+)", "abc 123", "z$bz$az", "z"); 182expand!( 183 expand8, 184 r"(?-u)(?P<a>\w+)\s+(?P<b>\d+)", 185 "abc 123", 186 ".$b.$a.", 187 ".123.abc." 188); 189expand!( 190 expand9, 191 r"(?-u)(?P<a>\w+)\s+(?P<b>\d+)", 192 "abc 123", 193 " $b $a ", 194 " 123 abc " 195); 196expand!(expand10, r"(?-u)(?P<a>\w+)\s+(?P<b>\d+)", "abc 123", "$bz$az", ""); 197 198expand!(expand_name1, r"%(?P<Z>[a-z]+)", "%abc", "$Z%", "abc%"); 199expand!(expand_name2, r"\[(?P<Z>[a-z]+)", "[abc", "$Z[", "abc["); 200expand!(expand_name3, r"\{(?P<Z>[a-z]+)", "{abc", "$Z{", "abc{"); 201expand!(expand_name4, r"\}(?P<Z>[a-z]+)", "}abc", "$Z}", "abc}"); 202expand!(expand_name5, r"%([a-z]+)", "%abc", "$1a%", "%"); 203expand!(expand_name6, r"%([a-z]+)", "%abc", "${1}a%", "abca%"); 204expand!(expand_name7, r"\[(?P<Z[>[a-z]+)", "[abc", "${Z[}[", "abc["); 205expand!(expand_name8, r"\[(?P<Z[>[a-z]+)", "[abc", "${foo}[", "["); 206expand!(expand_name9, r"\[(?P<Z[>[a-z]+)", "[abc", "${1a}[", "["); 207expand!(expand_name10, r"\[(?P<Z[>[a-z]+)", "[abc", "${#}[", "["); 208expand!(expand_name11, r"\[(?P<Z[>[a-z]+)", "[abc", "${$$}[", "["); 209 210split!( 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); 216split!( 217 split2, 218 r"(?-u)\b", 219 "a b c", 220 &[t!(""), t!("a"), t!(" "), t!("b"), t!(" "), t!("c"), t!("")] 221); 222split!(split3, r"a$", "a", &[t!(""), t!("")]); 223split!(split_none, r"-", r"a", &[t!("a")]); 224split!(split_trailing_blank, r"-", r"a-", &[t!("a"), t!("")]); 225split!(split_trailing_blanks, r"-", r"a--", &[t!("a"), t!(""), t!("")]); 226split!(split_empty, r"-", r"", &[t!("")]); 227 228splitn!(splitn_below_limit, r"-", r"a", 2, &[t!("a")]); 229splitn!(splitn_at_limit, r"-", r"a-b", 2, &[t!("a"), t!("b")]); 230splitn!(splitn_above_limit, r"-", r"a-b-c", 2, &[t!("a"), t!("b-c")]); 231splitn!(splitn_zero_limit, r"-", r"a-b", 0, empty_vec!()); 232splitn!(splitn_trailing_blank, r"-", r"a-", 2, &[t!("a"), t!("")]); 233splitn!(splitn_trailing_separator, r"-", r"a--", 2, &[t!("a"), t!("-")]); 234splitn!(splitn_empty, r"-", r"", 1, &[t!("")]); 235