vendor/regex/tests/api.rs

   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
 198 split!(
 199     split1,
 200     r"(?-u)\s+",
 201     "a b\nc\td\n\t e",
 202     &[t!("a"), t!("b"), t!("c"), t!("d"), t!("e")]
 203 );
 204 split!(
 205     split2,
 206     r"(?-u)\b",
 207     "a b c",
 208     &[t!(""), t!("a"), t!(" "), t!("b"), t!(" "), t!("c"), t!("")]
 209 );
 210 split!(split3, r"a$", "a", &[t!(""), t!("")]);
 211 split!(split_none, r"-", r"a", &[t!("a")]);
 212 split!(split_trailing_blank, r"-", r"a-", &[t!("a"), t!("")]);
 213 split!(split_trailing_blanks, r"-", r"a--", &[t!("a"), t!(""), t!("")]);
 214 split!(split_empty, r"-", r"", &[t!("")]);
 215
 216 splitn!(splitn_below_limit, r"-", r"a", 2, &[t!("a")]);
 217 splitn!(splitn_at_limit, r"-", r"a-b", 2, &[t!("a"), t!("b")]);
 218 splitn!(splitn_above_limit, r"-", r"a-b-c", 2, &[t!("a"), t!("b-c")]);
 219 splitn!(splitn_zero_limit, r"-", r"a-b", 0, empty_vec!());
 220 splitn!(splitn_trailing_blank, r"-", r"a-", 2, &[t!("a"), t!("")]);
 221 splitn!(splitn_trailing_separator, r"-", r"a--", 2, &[t!("a"), t!("-")]);
 222 splitn!(splitn_empty, r"-", r"", 1, &[t!("")]);