code_ownership 2.0.0.pre.1 → 2.0.0.pre.3

data/ext/cargo-vendor/rayon-1.10.0/tests/debug.rs

@@ -1,233 +0,0 @@
-use rayon::prelude::*;
-use std::fmt::Debug;
-
-fn check<I>(iter: I)
-where
-    I: ParallelIterator + Debug,
-{
-    println!("{:?}", iter);
-}
-
-#[test]
-fn debug_binary_heap() {
-    use std::collections::BinaryHeap;
-    let mut heap: BinaryHeap<_> = (0..10).collect();
-    check(heap.par_iter());
-    check(heap.par_drain());
-    check(heap.into_par_iter());
-}
-
-#[test]
-fn debug_btree_map() {
-    use std::collections::BTreeMap;
-    let mut map: BTreeMap<_, _> = (0..10).enumerate().collect();
-    check(map.par_iter());
-    check(map.par_iter_mut());
-    check(map.into_par_iter());
-}
-
-#[test]
-fn debug_btree_set() {
-    use std::collections::BTreeSet;
-    let set: BTreeSet<_> = (0..10).collect();
-    check(set.par_iter());
-    check(set.into_par_iter());
-}
-
-#[test]
-fn debug_hash_map() {
-    use std::collections::HashMap;
-    let mut map: HashMap<_, _> = (0..10).enumerate().collect();
-    check(map.par_iter());
-    check(map.par_iter_mut());
-    check(map.par_drain());
-    check(map.into_par_iter());
-}
-
-#[test]
-fn debug_hash_set() {
-    use std::collections::HashSet;
-    let mut set: HashSet<_> = (0..10).collect();
-    check(set.par_iter());
-    check(set.par_drain());
-    check(set.into_par_iter());
-}
-
-#[test]
-fn debug_linked_list() {
-    use std::collections::LinkedList;
-    let mut list: LinkedList<_> = (0..10).collect();
-    check(list.par_iter());
-    check(list.par_iter_mut());
-    check(list.into_par_iter());
-}
-
-#[test]
-fn debug_vec_deque() {
-    use std::collections::VecDeque;
-    let mut deque: VecDeque<_> = (0..10).collect();
-    check(deque.par_iter());
-    check(deque.par_iter_mut());
-    check(deque.par_drain(..));
-    check(deque.into_par_iter());
-}
-
-#[test]
-fn debug_option() {
-    let mut option = Some(0);
-    check(option.par_iter());
-    check(option.par_iter_mut());
-    check(option.into_par_iter());
-}
-
-#[test]
-fn debug_result() {
-    let mut result = Ok::<_, ()>(0);
-    check(result.par_iter());
-    check(result.par_iter_mut());
-    check(result.into_par_iter());
-}
-
-#[test]
-fn debug_range() {
-    check((0..10).into_par_iter());
-}
-
-#[test]
-fn debug_range_inclusive() {
-    check((0..=10).into_par_iter());
-}
-
-#[test]
-fn debug_str() {
-    let s = "a b c d\ne f g";
-    check(s.par_chars());
-    check(s.par_lines());
-    check(s.par_split('\n'));
-    check(s.par_split_inclusive('\n'));
-    check(s.par_split_terminator('\n'));
-    check(s.par_split_whitespace());
-    check(s.par_split_ascii_whitespace());
-}
-
-#[test]
-fn debug_string() {
-    let mut s = "a b c d\ne f g".to_string();
-    s.par_drain(..);
-}
-
-#[test]
-fn debug_vec() {
-    let mut v: Vec<_> = (0..10).collect();
-    check(v.par_iter());
-    check(v.par_iter_mut());
-    check(v.par_chunk_by(i32::eq));
-    check(v.par_chunk_by_mut(i32::eq));
-    check(v.par_chunks(42));
-    check(v.par_chunks_exact(42));
-    check(v.par_chunks_mut(42));
-    check(v.par_chunks_exact_mut(42));
-    check(v.par_rchunks(42));
-    check(v.par_rchunks_exact(42));
-    check(v.par_rchunks_mut(42));
-    check(v.par_rchunks_exact_mut(42));
-    check(v.par_windows(42));
-    check(v.par_split(|x| x % 3 == 0));
-    check(v.par_split_inclusive(|x| x % 3 == 0));
-    check(v.par_split_mut(|x| x % 3 == 0));
-    check(v.par_split_inclusive_mut(|x| x % 3 == 0));
-    check(v.par_drain(..));
-    check(v.into_par_iter());
-}
-
-#[test]
-fn debug_array() {
-    let a = [0i32; 10];
-    check(a.into_par_iter());
-}
-
-#[test]
-fn debug_adaptors() {
-    let v: Vec<_> = (0..10).collect();
-    check(v.par_iter().by_exponential_blocks());
-    check(v.par_iter().by_uniform_blocks(5));
-    check(v.par_iter().chain(&v));
-    check(v.par_iter().cloned());
-    check(v.par_iter().copied());
-    check(v.par_iter().enumerate());
-    check(v.par_iter().filter(|_| true));
-    check(v.par_iter().filter_map(Some));
-    check(v.par_iter().flat_map(Some));
-    check(v.par_iter().flat_map_iter(Some));
-    check(v.par_iter().map(Some).flatten());
-    check(v.par_iter().map(Some).flatten_iter());
-    check(v.par_iter().fold(|| 0, |x, _| x));
-    check(v.par_iter().fold_with(0, |x, _| x));
-    check(v.par_iter().fold_chunks(3, || 0, |x, _| x));
-    check(v.par_iter().fold_chunks_with(3, 0, |x, _| x));
-    check(v.par_iter().try_fold(|| 0, |x, _| Some(x)));
-    check(v.par_iter().try_fold_with(0, |x, _| Some(x)));
-    check(v.par_iter().inspect(|_| ()));
-    check(v.par_iter().update(|_| ()));
-    check(v.par_iter().interleave(&v));
-    check(v.par_iter().interleave_shortest(&v));
-    check(v.par_iter().intersperse(&-1));
-    check(v.par_iter().chunks(3));
-    check(v.par_iter().map(|x| x));
-    check(v.par_iter().map_with(0, |_, x| x));
-    check(v.par_iter().map_init(|| 0, |_, x| x));
-    check(v.par_iter().panic_fuse());
-    check(v.par_iter().positions(|_| true));
-    check(v.par_iter().rev());
-    check(v.par_iter().skip(1));
-    check(v.par_iter().skip_any(1));
-    check(v.par_iter().skip_any_while(|_| false));
-    check(v.par_iter().take(1));
-    check(v.par_iter().take_any(1));
-    check(v.par_iter().take_any_while(|_| true));
-    check(v.par_iter().map(Some).while_some());
-    check(v.par_iter().with_max_len(1));
-    check(v.par_iter().with_min_len(1));
-    check(v.par_iter().zip(&v));
-    check(v.par_iter().zip_eq(&v));
-    check(v.par_iter().step_by(2));
-}
-
-#[test]
-fn debug_empty() {
-    check(rayon::iter::empty::<i32>());
-}
-
-#[test]
-fn debug_once() {
-    check(rayon::iter::once(10));
-}
-
-#[test]
-fn debug_repeat() {
-    let x: Option<i32> = None;
-    check(rayon::iter::repeat(x));
-    check(rayon::iter::repeatn(x, 10));
-}
-
-#[test]
-fn debug_splitter() {
-    check(rayon::iter::split(0..10, |x| (x, None)));
-}
-
-#[test]
-fn debug_multizip() {
-    let v: &Vec<_> = &(0..10).collect();
-    check((v,).into_par_iter());
-    check((v, v).into_par_iter());
-    check((v, v, v).into_par_iter());
-    check((v, v, v, v).into_par_iter());
-    check((v, v, v, v, v).into_par_iter());
-    check((v, v, v, v, v, v).into_par_iter());
-    check((v, v, v, v, v, v, v).into_par_iter());
-    check((v, v, v, v, v, v, v, v).into_par_iter());
-    check((v, v, v, v, v, v, v, v, v).into_par_iter());
-    check((v, v, v, v, v, v, v, v, v, v).into_par_iter());
-    check((v, v, v, v, v, v, v, v, v, v, v).into_par_iter());
-    check((v, v, v, v, v, v, v, v, v, v, v, v).into_par_iter());
-}

data/ext/cargo-vendor/rayon-1.10.0/tests/named-threads.rs

@@ -1,25 +0,0 @@
-use std::collections::HashSet;
-
-use rayon::prelude::*;
-use rayon::*;
-
-#[test]
-#[cfg_attr(any(target_os = "emscripten", target_family = "wasm"), ignore)]
-fn named_threads() {
-    ThreadPoolBuilder::new()
-        .thread_name(|i| format!("hello-name-test-{}", i))
-        .build_global()
-        .unwrap();
-
-    const N: usize = 10000;
-
-    let thread_names = (0..N)
-        .into_par_iter()
-        .flat_map(|_| ::std::thread::current().name().map(str::to_owned))
-        .collect::<HashSet<String>>();
-
-    let all_contains_name = thread_names
-        .iter()
-        .all(|name| name.starts_with("hello-name-test-"));
-    assert!(all_contains_name);
-}

data/ext/cargo-vendor/rayon-1.10.0/tests/producer_split_at.rs

@@ -1,391 +0,0 @@
-use rayon::iter::plumbing::*;
-use rayon::prelude::*;
-
-/// Stress-test indexes for `Producer::split_at`.
-fn check<F, I>(expected: &[I::Item], mut f: F)
-where
-    F: FnMut() -> I,
-    I: IntoParallelIterator,
-    I::Iter: IndexedParallelIterator,
-    I::Item: PartialEq + std::fmt::Debug,
-{
-    map_triples(expected.len() + 1, |i, j, k| {
-        Split::forward(f(), i, j, k, expected);
-        Split::reverse(f(), i, j, k, expected);
-    });
-}
-
-fn map_triples<F>(end: usize, mut f: F)
-where
-    F: FnMut(usize, usize, usize),
-{
-    for i in 0..end {
-        for j in i..end {
-            for k in j..end {
-                f(i, j, k);
-            }
-        }
-    }
-}
-
-#[derive(Debug)]
-struct Split {
-    i: usize,
-    j: usize,
-    k: usize,
-    reverse: bool,
-}
-
-impl Split {
-    fn forward<I>(iter: I, i: usize, j: usize, k: usize, expected: &[I::Item])
-    where
-        I: IntoParallelIterator,
-        I::Iter: IndexedParallelIterator,
-        I::Item: PartialEq + std::fmt::Debug,
-    {
-        let result = iter.into_par_iter().with_producer(Split {
-            i,
-            j,
-            k,
-            reverse: false,
-        });
-        assert_eq!(result, expected);
-    }
-
-    fn reverse<I>(iter: I, i: usize, j: usize, k: usize, expected: &[I::Item])
-    where
-        I: IntoParallelIterator,
-        I::Iter: IndexedParallelIterator,
-        I::Item: PartialEq + std::fmt::Debug,
-    {
-        let result = iter.into_par_iter().with_producer(Split {
-            i,
-            j,
-            k,
-            reverse: true,
-        });
-        assert!(result.iter().eq(expected.iter().rev()));
-    }
-}
-
-impl<T> ProducerCallback<T> for Split {
-    type Output = Vec<T>;
-
-    fn callback<P>(self, producer: P) -> Self::Output
-    where
-        P: Producer<Item = T>,
-    {
-        println!("{:?}", self);
-
-        // Splitting the outer indexes first gets us an arbitrary mid section,
-        // which we then split further to get full test coverage.
-        let (left, d) = producer.split_at(self.k);
-        let (a, mid) = left.split_at(self.i);
-        let (b, c) = mid.split_at(self.j - self.i);
-
-        let a = a.into_iter();
-        let b = b.into_iter();
-        let c = c.into_iter();
-        let d = d.into_iter();
-
-        check_len(&a, self.i);
-        check_len(&b, self.j - self.i);
-        check_len(&c, self.k - self.j);
-
-        let chain = a.chain(b).chain(c).chain(d);
-        if self.reverse {
-            chain.rev().collect()
-        } else {
-            chain.collect()
-        }
-    }
-}
-
-fn check_len<I: ExactSizeIterator>(iter: &I, len: usize) {
-    assert_eq!(iter.size_hint(), (len, Some(len)));
-    assert_eq!(iter.len(), len);
-}
-
-// **** Base Producers ****
-
-#[test]
-fn array() {
-    let a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
-    check(&a, || a);
-}
-
-#[test]
-fn empty() {
-    check(&[], rayon::iter::empty::<i32>);
-}
-
-#[test]
-fn once() {
-    check(&[42], || rayon::iter::once(42));
-}
-
-#[test]
-fn option() {
-    check(&[42], || Some(42));
-}
-
-#[test]
-fn range() {
-    let v: Vec<_> = (0..10).collect();
-    check(&v, || 0..10);
-}
-
-#[test]
-fn range_inclusive() {
-    let v: Vec<_> = (0u16..=10).collect();
-    check(&v, || 0u16..=10);
-}
-
-#[test]
-fn repeatn() {
-    let v: Vec<_> = std::iter::repeat(1).take(5).collect();
-    check(&v, || rayon::iter::repeatn(1, 5));
-}
-
-#[test]
-fn slice_iter() {
-    let s: Vec<_> = (0..10).collect();
-    let v: Vec<_> = s.iter().collect();
-    check(&v, || &s);
-}
-
-#[test]
-fn slice_iter_mut() {
-    let mut s: Vec<_> = (0..10).collect();
-    let mut v: Vec<_> = s.clone();
-    let expected: Vec<_> = v.iter_mut().collect();
-
-    map_triples(expected.len() + 1, |i, j, k| {
-        Split::forward(s.par_iter_mut(), i, j, k, &expected);
-        Split::reverse(s.par_iter_mut(), i, j, k, &expected);
-    });
-}
-
-#[test]
-fn slice_chunks() {
-    let s: Vec<_> = (0..10).collect();
-    for len in 1..s.len() + 2 {
-        let v: Vec<_> = s.chunks(len).collect();
-        check(&v, || s.par_chunks(len));
-    }
-}
-
-#[test]
-fn slice_chunks_exact() {
-    let s: Vec<_> = (0..10).collect();
-    for len in 1..s.len() + 2 {
-        let v: Vec<_> = s.chunks_exact(len).collect();
-        check(&v, || s.par_chunks_exact(len));
-    }
-}
-
-#[test]
-fn slice_chunks_mut() {
-    let mut s: Vec<_> = (0..10).collect();
-    let mut v: Vec<_> = s.clone();
-    for len in 1..s.len() + 2 {
-        let expected: Vec<_> = v.chunks_mut(len).collect();
-        map_triples(expected.len() + 1, |i, j, k| {
-            Split::forward(s.par_chunks_mut(len), i, j, k, &expected);
-            Split::reverse(s.par_chunks_mut(len), i, j, k, &expected);
-        });
-    }
-}
-
-#[test]
-fn slice_chunks_exact_mut() {
-    let mut s: Vec<_> = (0..10).collect();
-    let mut v: Vec<_> = s.clone();
-    for len in 1..s.len() + 2 {
-        let expected: Vec<_> = v.chunks_exact_mut(len).collect();
-        map_triples(expected.len() + 1, |i, j, k| {
-            Split::forward(s.par_chunks_exact_mut(len), i, j, k, &expected);
-            Split::reverse(s.par_chunks_exact_mut(len), i, j, k, &expected);
-        });
-    }
-}
-
-#[test]
-fn slice_rchunks() {
-    let s: Vec<_> = (0..10).collect();
-    for len in 1..s.len() + 2 {
-        let v: Vec<_> = s.rchunks(len).collect();
-        check(&v, || s.par_rchunks(len));
-    }
-}
-
-#[test]
-fn slice_rchunks_exact() {
-    let s: Vec<_> = (0..10).collect();
-    for len in 1..s.len() + 2 {
-        let v: Vec<_> = s.rchunks_exact(len).collect();
-        check(&v, || s.par_rchunks_exact(len));
-    }
-}
-
-#[test]
-fn slice_rchunks_mut() {
-    let mut s: Vec<_> = (0..10).collect();
-    let mut v: Vec<_> = s.clone();
-    for len in 1..s.len() + 2 {
-        let expected: Vec<_> = v.rchunks_mut(len).collect();
-        map_triples(expected.len() + 1, |i, j, k| {
-            Split::forward(s.par_rchunks_mut(len), i, j, k, &expected);
-            Split::reverse(s.par_rchunks_mut(len), i, j, k, &expected);
-        });
-    }
-}
-
-#[test]
-fn slice_rchunks_exact_mut() {
-    let mut s: Vec<_> = (0..10).collect();
-    let mut v: Vec<_> = s.clone();
-    for len in 1..s.len() + 2 {
-        let expected: Vec<_> = v.rchunks_exact_mut(len).collect();
-        map_triples(expected.len() + 1, |i, j, k| {
-            Split::forward(s.par_rchunks_exact_mut(len), i, j, k, &expected);
-            Split::reverse(s.par_rchunks_exact_mut(len), i, j, k, &expected);
-        });
-    }
-}
-
-#[test]
-fn slice_windows() {
-    let s: Vec<_> = (0..10).collect();
-    let v: Vec<_> = s.windows(2).collect();
-    check(&v, || s.par_windows(2));
-}
-
-#[test]
-fn vec() {
-    let v: Vec<_> = (0..10).collect();
-    check(&v, || v.clone());
-}
-
-// **** Adaptors ****
-
-#[test]
-fn chain() {
-    let v: Vec<_> = (0..10).collect();
-    check(&v, || (0..5).into_par_iter().chain(5..10));
-}
-
-#[test]
-fn cloned() {
-    let v: Vec<_> = (0..10).collect();
-    check(&v, || v.par_iter().cloned());
-}
-
-#[test]
-fn copied() {
-    let v: Vec<_> = (0..10).collect();
-    check(&v, || v.par_iter().copied());
-}
-
-#[test]
-fn enumerate() {
-    let v: Vec<_> = (0..10).enumerate().collect();
-    check(&v, || (0..10).into_par_iter().enumerate());
-}
-
-#[test]
-fn step_by() {
-    let v: Vec<_> = (0..10).step_by(2).collect();
-    check(&v, || (0..10).into_par_iter().step_by(2))
-}
-
-#[test]
-fn step_by_unaligned() {
-    let v: Vec<_> = (0..10).step_by(3).collect();
-    check(&v, || (0..10).into_par_iter().step_by(3))
-}
-
-#[test]
-fn inspect() {
-    let v: Vec<_> = (0..10).collect();
-    check(&v, || (0..10).into_par_iter().inspect(|_| ()));
-}
-
-#[test]
-fn update() {
-    let v: Vec<_> = (0..10).collect();
-    check(&v, || (0..10).into_par_iter().update(|_| ()));
-}
-
-#[test]
-fn interleave() {
-    let v = [0, 10, 1, 11, 2, 12, 3, 4];
-    check(&v, || (0..5).into_par_iter().interleave(10..13));
-    check(&v[..6], || (0..3).into_par_iter().interleave(10..13));
-
-    let v = [0, 10, 1, 11, 2, 12, 13, 14];
-    check(&v, || (0..3).into_par_iter().interleave(10..15));
-}
-
-#[test]
-fn intersperse() {
-    let v = [0, -1, 1, -1, 2, -1, 3, -1, 4];
-    check(&v, || (0..5).into_par_iter().intersperse(-1));
-}
-
-#[test]
-fn chunks() {
-    let s: Vec<_> = (0..10).collect();
-    let v: Vec<_> = s.chunks(2).map(|c| c.to_vec()).collect();
-    check(&v, || s.par_iter().cloned().chunks(2));
-}
-
-#[test]
-fn map() {
-    let v: Vec<_> = (0..10).collect();
-    check(&v, || v.par_iter().map(Clone::clone));
-}
-
-#[test]
-fn map_with() {
-    let v: Vec<_> = (0..10).collect();
-    check(&v, || v.par_iter().map_with(vec![0], |_, &x| x));
-}
-
-#[test]
-fn map_init() {
-    let v: Vec<_> = (0..10).collect();
-    check(&v, || v.par_iter().map_init(|| vec![0], |_, &x| x));
-}
-
-#[test]
-fn panic_fuse() {
-    let v: Vec<_> = (0..10).collect();
-    check(&v, || (0..10).into_par_iter().panic_fuse());
-}
-
-#[test]
-fn rev() {
-    let v: Vec<_> = (0..10).rev().collect();
-    check(&v, || (0..10).into_par_iter().rev());
-}
-
-#[test]
-fn with_max_len() {
-    let v: Vec<_> = (0..10).collect();
-    check(&v, || (0..10).into_par_iter().with_max_len(1));
-}
-
-#[test]
-fn with_min_len() {
-    let v: Vec<_> = (0..10).collect();
-    check(&v, || (0..10).into_par_iter().with_min_len(1));
-}
-
-#[test]
-fn zip() {
-    let v: Vec<_> = (0..10).zip(10..20).collect();
-    check(&v, || (0..10).into_par_iter().zip(10..20));
-    check(&v[..5], || (0..5).into_par_iter().zip(10..20));
-    check(&v[..5], || (0..10).into_par_iter().zip(10..15));
-}