| use std::str::pattern::*; |
| |
| // This macro makes it easier to write |
| // tests that do a series of iterations |
| macro_rules! search_asserts { |
| ($haystack:expr, $needle:expr, $testname:expr, [$($func:ident),*], $result:expr) => { |
| let mut searcher = $needle.into_searcher($haystack); |
| let arr = [$( Step::from(searcher.$func()) ),+]; |
| assert_eq!(&arr[..], &$result, $testname); |
| } |
| } |
| |
| /// Combined enum for the results of next() and next_match()/next_reject() |
| #[derive(Debug, PartialEq, Eq)] |
| enum Step { |
| // variant names purposely chosen to |
| // be the same length for easy alignment |
| Matches(usize, usize), |
| Rejects(usize, usize), |
| InRange(usize, usize), |
| Done |
| } |
| |
| use self::Step::*; |
| |
| impl From<SearchStep> for Step { |
| fn from(x: SearchStep) -> Self { |
| match x { |
| SearchStep::Match(a, b) => Matches(a, b), |
| SearchStep::Reject(a, b) => Rejects(a, b), |
| SearchStep::Done => Done |
| } |
| } |
| } |
| |
| impl From<Option<(usize, usize)>> for Step { |
| fn from(x: Option<(usize, usize)>) -> Self { |
| match x { |
| Some((a, b)) => InRange(a, b), |
| None => Done |
| } |
| } |
| } |
| |
| // ignore-tidy-linelength |
| |
| // FIXME(Manishearth) these tests focus on single-character searching (CharSearcher) |
| // and on next()/next_match(), not next_reject(). This is because |
| // the memchr changes make next_match() for single chars complex, but next_reject() |
| // continues to use next() under the hood. We should add more test cases for all |
| // of these, as well as tests for StrSearcher and higher level tests for str::find() (etc) |
| |
| #[test] |
| fn test_simple_iteration() { |
| search_asserts! ("abcdeabcd", 'a', "forward iteration for ASCII string", |
| // a b c d e a b c d EOF |
| [next, next, next, next, next, next, next, next, next, next], |
| [Matches(0, 1), Rejects(1, 2), Rejects(2, 3), Rejects(3, 4), Rejects(4, 5), Matches(5, 6), Rejects(6, 7), Rejects(7, 8), Rejects(8, 9), Done] |
| ); |
| |
| search_asserts! ("abcdeabcd", 'a', "reverse iteration for ASCII string", |
| // d c b a e d c b a EOF |
| [next_back, next_back, next_back, next_back, next_back, next_back, next_back, next_back, next_back, next_back], |
| [Rejects(8, 9), Rejects(7, 8), Rejects(6, 7), Matches(5, 6), Rejects(4, 5), Rejects(3, 4), Rejects(2, 3), Rejects(1, 2), Matches(0, 1), Done] |
| ); |
| |
| search_asserts! ("我爱我的猫", '我', "forward iteration for Chinese string", |
| // 我 愛 我 的 貓 EOF |
| [next, next, next, next, next, next], |
| [Matches(0, 3), Rejects(3, 6), Matches(6, 9), Rejects(9, 12), Rejects(12, 15), Done] |
| ); |
| |
| search_asserts! ("我的猫说meow", 'm', "forward iteration for mixed string", |
| // 我 的 猫 说 m e o w EOF |
| [next, next, next, next, next, next, next, next, next], |
| [Rejects(0, 3), Rejects(3, 6), Rejects(6, 9), Rejects(9, 12), Matches(12, 13), Rejects(13, 14), Rejects(14, 15), Rejects(15, 16), Done] |
| ); |
| |
| search_asserts! ("我的猫说meow", '猫', "reverse iteration for mixed string", |
| // w o e m 说 猫 的 我 EOF |
| [next_back, next_back, next_back, next_back, next_back, next_back, next_back, next_back, next_back], |
| [Rejects(15, 16), Rejects(14, 15), Rejects(13, 14), Rejects(12, 13), Rejects(9, 12), Matches(6, 9), Rejects(3, 6), Rejects(0, 3), Done] |
| ); |
| } |
| |
| #[test] |
| fn test_simple_search() { |
| search_asserts!("abcdeabcdeabcde", 'a', "next_match for ASCII string", |
| [next_match, next_match, next_match, next_match], |
| [InRange(0, 1), InRange(5, 6), InRange(10, 11), Done] |
| ); |
| |
| search_asserts!("abcdeabcdeabcde", 'a', "next_match_back for ASCII string", |
| [next_match_back, next_match_back, next_match_back, next_match_back], |
| [InRange(10, 11), InRange(5, 6), InRange(0, 1), Done] |
| ); |
| |
| search_asserts!("abcdeab", 'a', "next_reject for ASCII string", |
| [next_reject, next_reject, next_match, next_reject, next_reject], |
| [InRange(1, 2), InRange(2, 3), InRange(5, 6), InRange(6, 7), Done] |
| ); |
| |
| search_asserts!("abcdeabcdeabcde", 'a', "next_reject_back for ASCII string", |
| [next_reject_back, next_reject_back, next_match_back, next_reject_back, next_reject_back, next_reject_back], |
| [InRange(14, 15), InRange(13, 14), InRange(10, 11), InRange(9, 10), InRange(8, 9), InRange(7, 8)] |
| ); |
| } |
| |
| // Á, 각, ก, 😀 all end in 0x81 |
| // 🁀, ᘀ do not end in 0x81 but contain the byte |
| // ꁁ has 0x81 as its second and third bytes. |
| // |
| // The memchr-using implementation of next_match |
| // and next_match_back temporarily violate |
| // the property that the search is always on a unicode boundary, |
| // which is fine as long as this never reaches next() or next_back(). |
| // So we test if next() is correct after each next_match() as well. |
| const STRESS: &str = "Áa🁀bÁꁁfg😁각กᘀ각aÁ각ꁁก😁a"; |
| |
| #[test] |
| fn test_stress_indices() { |
| // this isn't really a test, more of documentation on the indices of each character in the stresstest string |
| |
| search_asserts!(STRESS, 'x', "Indices of characters in stress test", |
| [next, next, next, next, next, next, next, next, next, next, next, next, next, next, next, next, next, next, next, next, next], |
| [Rejects(0, 2), // Á |
| Rejects(2, 3), // a |
| Rejects(3, 7), // 🁀 |
| Rejects(7, 8), // b |
| Rejects(8, 10), // Á |
| Rejects(10, 13), // ꁁ |
| Rejects(13, 14), // f |
| Rejects(14, 15), // g |
| Rejects(15, 19), // 😀 |
| Rejects(19, 22), // 각 |
| Rejects(22, 25), // ก |
| Rejects(25, 28), // ᘀ |
| Rejects(28, 31), // 각 |
| Rejects(31, 32), // a |
| Rejects(32, 34), // Á |
| Rejects(34, 37), // 각 |
| Rejects(37, 40), // ꁁ |
| Rejects(40, 43), // ก |
| Rejects(43, 47), // 😀 |
| Rejects(47, 48), // a |
| Done] |
| ); |
| } |
| |
| #[test] |
| fn test_forward_search_shared_bytes() { |
| search_asserts!(STRESS, 'Á', "Forward search for two-byte Latin character", |
| [next_match, next_match, next_match, next_match], |
| [InRange(0, 2), InRange(8, 10), InRange(32, 34), Done] |
| ); |
| |
| search_asserts!(STRESS, 'Á', "Forward search for two-byte Latin character; check if next() still works", |
| [next_match, next, next_match, next, next_match, next, next_match], |
| [InRange(0, 2), Rejects(2, 3), InRange(8, 10), Rejects(10, 13), InRange(32, 34), Rejects(34, 37), Done] |
| ); |
| |
| search_asserts!(STRESS, '각', "Forward search for three-byte Hangul character", |
| [next_match, next, next_match, next_match, next_match], |
| [InRange(19, 22), Rejects(22, 25), InRange(28, 31), InRange(34, 37), Done] |
| ); |
| |
| search_asserts!(STRESS, '각', "Forward search for three-byte Hangul character; check if next() still works", |
| [next_match, next, next_match, next, next_match, next, next_match], |
| [InRange(19, 22), Rejects(22, 25), InRange(28, 31), Rejects(31, 32), InRange(34, 37), Rejects(37, 40), Done] |
| ); |
| |
| search_asserts!(STRESS, 'ก', "Forward search for three-byte Thai character", |
| [next_match, next, next_match, next, next_match], |
| [InRange(22, 25), Rejects(25, 28), InRange(40, 43), Rejects(43, 47), Done] |
| ); |
| |
| search_asserts!(STRESS, 'ก', "Forward search for three-byte Thai character; check if next() still works", |
| [next_match, next, next_match, next, next_match], |
| [InRange(22, 25), Rejects(25, 28), InRange(40, 43), Rejects(43, 47), Done] |
| ); |
| |
| search_asserts!(STRESS, '😁', "Forward search for four-byte emoji", |
| [next_match, next, next_match, next, next_match], |
| [InRange(15, 19), Rejects(19, 22), InRange(43, 47), Rejects(47, 48), Done] |
| ); |
| |
| search_asserts!(STRESS, '😁', "Forward search for four-byte emoji; check if next() still works", |
| [next_match, next, next_match, next, next_match], |
| [InRange(15, 19), Rejects(19, 22), InRange(43, 47), Rejects(47, 48), Done] |
| ); |
| |
| search_asserts!(STRESS, 'ꁁ', "Forward search for three-byte Yi character with repeated bytes", |
| [next_match, next, next_match, next, next_match], |
| [InRange(10, 13), Rejects(13, 14), InRange(37, 40), Rejects(40, 43), Done] |
| ); |
| |
| search_asserts!(STRESS, 'ꁁ', "Forward search for three-byte Yi character with repeated bytes; check if next() still works", |
| [next_match, next, next_match, next, next_match], |
| [InRange(10, 13), Rejects(13, 14), InRange(37, 40), Rejects(40, 43), Done] |
| ); |
| } |
| |
| #[test] |
| fn test_reverse_search_shared_bytes() { |
| search_asserts!(STRESS, 'Á', "Reverse search for two-byte Latin character", |
| [next_match_back, next_match_back, next_match_back, next_match_back], |
| [InRange(32, 34), InRange(8, 10), InRange(0, 2), Done] |
| ); |
| |
| search_asserts!(STRESS, 'Á', "Reverse search for two-byte Latin character; check if next_back() still works", |
| [next_match_back, next_back, next_match_back, next_back, next_match_back, next_back], |
| [InRange(32, 34), Rejects(31, 32), InRange(8, 10), Rejects(7, 8), InRange(0, 2), Done] |
| ); |
| |
| search_asserts!(STRESS, '각', "Reverse search for three-byte Hangul character", |
| [next_match_back, next_back, next_match_back, next_match_back, next_match_back], |
| [InRange(34, 37), Rejects(32, 34), InRange(28, 31), InRange(19, 22), Done] |
| ); |
| |
| search_asserts!(STRESS, '각', "Reverse search for three-byte Hangul character; check if next_back() still works", |
| [next_match_back, next_back, next_match_back, next_back, next_match_back, next_back, next_match_back], |
| [InRange(34, 37), Rejects(32, 34), InRange(28, 31), Rejects(25, 28), InRange(19, 22), Rejects(15, 19), Done] |
| ); |
| |
| search_asserts!(STRESS, 'ก', "Reverse search for three-byte Thai character", |
| [next_match_back, next_back, next_match_back, next_back, next_match_back], |
| [InRange(40, 43), Rejects(37, 40), InRange(22, 25), Rejects(19, 22), Done] |
| ); |
| |
| search_asserts!(STRESS, 'ก', "Reverse search for three-byte Thai character; check if next_back() still works", |
| [next_match_back, next_back, next_match_back, next_back, next_match_back], |
| [InRange(40, 43), Rejects(37, 40), InRange(22, 25), Rejects(19, 22), Done] |
| ); |
| |
| search_asserts!(STRESS, '😁', "Reverse search for four-byte emoji", |
| [next_match_back, next_back, next_match_back, next_back, next_match_back], |
| [InRange(43, 47), Rejects(40, 43), InRange(15, 19), Rejects(14, 15), Done] |
| ); |
| |
| search_asserts!(STRESS, '😁', "Reverse search for four-byte emoji; check if next_back() still works", |
| [next_match_back, next_back, next_match_back, next_back, next_match_back], |
| [InRange(43, 47), Rejects(40, 43), InRange(15, 19), Rejects(14, 15), Done] |
| ); |
| |
| search_asserts!(STRESS, 'ꁁ', "Reverse search for three-byte Yi character with repeated bytes", |
| [next_match_back, next_back, next_match_back, next_back, next_match_back], |
| [InRange(37, 40), Rejects(34, 37), InRange(10, 13), Rejects(8, 10), Done] |
| ); |
| |
| search_asserts!(STRESS, 'ꁁ', "Reverse search for three-byte Yi character with repeated bytes; check if next_back() still works", |
| [next_match_back, next_back, next_match_back, next_back, next_match_back], |
| [InRange(37, 40), Rejects(34, 37), InRange(10, 13), Rejects(8, 10), Done] |
| ); |
| } |
| |
| #[test] |
| fn double_ended_regression_test() { |
| // https://github.com/rust-lang/rust/issues/47175 |
| // Ensures that double ended searching comes to a convergence |
| search_asserts!("abcdeabcdeabcde", 'a', "alternating double ended search", |
| [next_match, next_match_back, next_match, next_match_back], |
| [InRange(0, 1), InRange(10, 11), InRange(5, 6), Done] |
| ); |
| search_asserts!("abcdeabcdeabcde", 'a', "triple double ended search for a", |
| [next_match, next_match_back, next_match_back, next_match_back], |
| [InRange(0, 1), InRange(10, 11), InRange(5, 6), Done] |
| ); |
| search_asserts!("abcdeabcdeabcde", 'd', "triple double ended search for d", |
| [next_match, next_match_back, next_match_back, next_match_back], |
| [InRange(3, 4), InRange(13, 14), InRange(8, 9), Done] |
| ); |
| search_asserts!(STRESS, 'Á', "Double ended search for two-byte Latin character", |
| [next_match, next_match_back, next_match, next_match_back], |
| [InRange(0, 2), InRange(32, 34), InRange(8, 10), Done] |
| ); |
| search_asserts!(STRESS, '각', "Reverse double ended search for three-byte Hangul character", |
| [next_match_back, next_back, next_match, next, next_match_back, next_match], |
| [InRange(34, 37), Rejects(32, 34), InRange(19, 22), Rejects(22, 25), InRange(28, 31), Done] |
| ); |
| search_asserts!(STRESS, 'ก', "Double ended search for three-byte Thai character", |
| [next_match, next_back, next, next_match_back, next_match], |
| [InRange(22, 25), Rejects(47, 48), Rejects(25, 28), InRange(40, 43), Done] |
| ); |
| search_asserts!(STRESS, '😁', "Double ended search for four-byte emoji", |
| [next_match_back, next, next_match, next_back, next_match], |
| [InRange(43, 47), Rejects(0, 2), InRange(15, 19), Rejects(40, 43), Done] |
| ); |
| search_asserts!(STRESS, 'ꁁ', "Double ended search for three-byte Yi character with repeated bytes", |
| [next_match, next, next_match_back, next_back, next_match], |
| [InRange(10, 13), Rejects(13, 14), InRange(37, 40), Rejects(34, 37), Done] |
| ); |
| } |