//! Tests that are working similarly in parallel and serial modeuse git_features::parallel; mod in_order_iter; #[derive(Default)]struct Adder { count: usize,} impl parallel::Reduce for Adder { type Input = usize; type FeedProduce = usize; type Output = usize; type Error = (); fn feed(&mut self, item: Self::Input) -> Result<Self::FeedProduce, Self::Error> { self.count += item; Ok(item) } fn finalize(self) -> Result<Self::Output, Self::Error> { Ok(self.count) }} #[test]fn in_parallel() { let res = parallel::in_parallel( std::iter::from_fn(|| Some(1)).take(100), None, |_n| (), |input, _state| input, Adder::default(), ) .expect("successful computation"); assert_eq!(res, 100);} #[test]fn in_parallel_with_mut_slice_in_chunks() { let num_items = 33; let input: Vec<_> = std::iter::repeat(1).take(num_items).collect(); let counts = parallel::in_parallel_with_slice( &input, None, |_| 0usize, |item, acc| { *acc += *item; Ok::<_, ()>(()) }, || Some(std::time::Duration::from_millis(10)), ) .unwrap(); assert_eq!( counts.iter().sum::<usize>(), std::iter::repeat(1).take(num_items).sum::<usize>() );} #[test]fn stepped_reduce_next() { let mut iter = parallel::reduce::Stepwise::new( std::iter::from_fn(|| Some(1)).take(100), None, |_n| (), |input, _state| input, Adder::default(), ); let mut aggregate = 0; for value in iter.by_ref() { aggregate += value.expect("success"); } assert_eq!(aggregate, 100);} #[test]fn stepped_reduce_ref_input_and_consume() { let seq = std::sync::Arc::new(vec![0usize, 1, 2]); struct ArcIter(std::sync::Arc<Vec<usize>>, usize); impl Iterator for ArcIter { type Item = usize; fn next(&mut self) -> Option<Self::Item> { let n = self.0.get(self.1).copied(); self.1 += 1; n } } let mut iter = parallel::reduce::Stepwise::new( ArcIter(seq.clone(), 0).enumerate(), None, { let seq = std::sync::Arc::clone(&seq); move |_n| seq.len() }, { let seq = std::sync::Arc::clone(&seq); move |(idx, ref_val): (usize, usize), _state| seq[idx] * ref_val }, Adder::default(), ); let mut aggregate = 0; for value in iter.by_ref() { aggregate += value.expect("success"); } assert_eq!(aggregate, 5);} #[test]fn stepped_reduce_finalize() { let iter = parallel::reduce::Stepwise::new( std::iter::from_fn(|| Some(1)).take(100), None, |_n| (), |input, _state| input, Adder::default(), ); assert_eq!(iter.finalize().expect("success"), 100);}
//! Tests that are working similarly in parallel and serial mode
use git_features::parallel;
mod in_order_iter;
#[derive(Default)]
struct Adder {
count: usize,
}
impl parallel::Reduce for Adder {
type Input = usize;
type FeedProduce = usize;
type Output = usize;
type Error = ();
fn feed(&mut self, item: Self::Input) -> Result<Self::FeedProduce, Self::Error> {
self.count += item;
Ok(item)
}
fn finalize(self) -> Result<Self::Output, Self::Error> {
Ok(self.count)
}
}
#[test]
fn in_parallel() {
let res = parallel::in_parallel(
std::iter::from_fn(|| Some(1)).take(100),
None,
|_n| (),
|input, _state| input,
Adder::default(),
)
.expect("successful computation");
assert_eq!(res, 100);
}
#[test]
fn in_parallel_with_mut_slice_in_chunks() {
let num_items = 33;
let input: Vec<_> = std::iter::repeat(1).take(num_items).collect();
let counts = parallel::in_parallel_with_slice(
&input,
None,
|_| 0usize,
|item, acc| {
*acc += *item;
Ok::<_, ()>(())
},
|| Some(std::time::Duration::from_millis(10)),
)
.unwrap();
assert_eq!(
counts.iter().sum::<usize>(),
std::iter::repeat(1).take(num_items).sum::<usize>()
);
}
#[test]
fn stepped_reduce_next() {
let mut iter = parallel::reduce::Stepwise::new(
std::iter::from_fn(|| Some(1)).take(100),
None,
|_n| (),
|input, _state| input,
Adder::default(),
);
let mut aggregate = 0;
for value in iter.by_ref() {
aggregate += value.expect("success");
}
assert_eq!(aggregate, 100);
}
#[test]
fn stepped_reduce_ref_input_and_consume() {
let seq = std::sync::Arc::new(vec![0usize, 1, 2]);
struct ArcIter(std::sync::Arc<Vec<usize>>, usize);
impl Iterator for ArcIter {
type Item = usize;
fn next(&mut self) -> Option<Self::Item> {
let n = self.0.get(self.1).copied();
self.1 += 1;
n
}
}
let mut iter = parallel::reduce::Stepwise::new(
ArcIter(seq.clone(), 0).enumerate(),
None,
{
let seq = std::sync::Arc::clone(&seq);
move |_n| seq.len()
},
{
let seq = std::sync::Arc::clone(&seq);
move |(idx, ref_val): (usize, usize), _state| seq[idx] * ref_val
},
Adder::default(),
);
let mut aggregate = 0;
for value in iter.by_ref() {
aggregate += value.expect("success");
}
assert_eq!(aggregate, 5);
}
#[test]
fn stepped_reduce_finalize() {
let iter = parallel::reduce::Stepwise::new(
std::iter::from_fn(|| Some(1)).take(100),
None,
|_n| (),
|input, _state| input,
Adder::default(),
);
assert_eq!(iter.finalize().expect("success"), 100);
}