Merge rayon-rs#560

560: Parity with std::str iterators r=nikomatsakis a=cuviper

This mimics the rest of the iterators in `std::str` with methods on the
`ParallelString` trait.

Closes rayon-rs#559, as `par_char_indices` is the closest we can do for that.

Co-authored-by: Josh Stone <[email protected]>

Author: bors[bot]

src/iter/test.rs

@@ -50,78 +50,6 @@ pub fn execute_unindexed_range() {
     assert_eq!(b, c);
 }
 
-#[test]
-pub fn execute_strings() {
-    let mut rng = XorShiftRng::from_seed([14159, 26535, 89793, 23846]);
-    let s: String = rng.gen_iter::<char>().take(1024).collect();
-
-    let par_chars: String = s.par_chars().collect();
-    assert_eq!(s, par_chars);
-
-    let par_even: String = s.par_chars().filter(|&c| (c as u32) & 1 == 0).collect();
-    let ser_even: String = s.chars().filter(|&c| (c as u32) & 1 == 0).collect();
-    assert_eq!(par_even, ser_even);
-
-    // test `FromParallelIterator<&char> for String`
-    let vchars: Vec<char> = s.par_chars().collect();
-    let par_chars: String = vchars.par_iter().collect();
-    assert_eq!(s, par_chars);
-}
-
-#[test]
-pub fn execute_strings_split() {
-    // char testcases from examples in `str::split` etc.,
-    // plus a large self-test for good measure.
-    let tests = vec![("Mary had a little lamb", ' '),
-                     ("", 'X'),
-                     ("lionXXtigerXleopard", 'X'),
-                     ("||||a||b|c", '|'),
-                     ("(///)", '/'),
-                     ("010", '0'),
-                     ("    a  b c", ' '),
-                     ("A.B.", '.'),
-                     ("A..B..", '.'),
-                     ("foo\r\nbar\n\nbaz\n", '\n'),
-                     ("foo\nbar\n\r\nbaz", '\n'),
-                     ("A few words", ' '),
-                     (" Mary   had\ta\u{2009}little  \n\t lamb", ' '),
-                     (include_str!("test.rs"), ' ')];
-
-    for &(string, separator) in &tests {
-        let serial: Vec<_> = string.split(separator).collect();
-        let parallel: Vec<_> = string.par_split(separator).collect();
-        assert_eq!(serial, parallel);
-
-        let serial_fn: Vec<_> = string.split(|c| c == separator).collect();
-        let parallel_fn: Vec<_> = string.par_split(|c| c == separator).collect();
-        assert_eq!(serial_fn, parallel_fn);
-    }
-
-    for &(string, separator) in &tests {
-        let serial: Vec<_> = string.split_terminator(separator).collect();
-        let parallel: Vec<_> = string.par_split_terminator(separator).collect();
-        assert_eq!(serial, parallel);
-    }
-
-    for &(string, separator) in &tests {
-        let serial: Vec<_> = string.split_terminator(|c| c == separator).collect();
-        let parallel: Vec<_> = string.par_split_terminator(|c| c == separator).collect();
-        assert_eq!(serial, parallel);
-    }
-
-    for &(string, _) in &tests {
-        let serial: Vec<_> = string.lines().collect();
-        let parallel: Vec<_> = string.par_lines().collect();
-        assert_eq!(serial, parallel);
-    }
-
-    for &(string, _) in &tests {
-        let serial: Vec<_> = string.split_whitespace().collect();
-        let parallel: Vec<_> = string.par_split_whitespace().collect();
-        assert_eq!(serial, parallel);
-    }
-}
-
 #[test]
 pub fn check_map_indexed() {
     let a = [1, 2, 3];