summaryrefslogtreecommitdiffstats
path: root/vendor/itertools/tests/test_std.rs
diff options
context:
space:
mode:
Diffstat (limited to 'vendor/itertools/tests/test_std.rs')
-rw-r--r--vendor/itertools/tests/test_std.rs557
1 files changed, 428 insertions, 129 deletions
diff --git a/vendor/itertools/tests/test_std.rs b/vendor/itertools/tests/test_std.rs
index 77207d87e..732be7b7d 100644
--- a/vendor/itertools/tests/test_std.rs
+++ b/vendor/itertools/tests/test_std.rs
@@ -1,19 +1,25 @@
-use quickcheck as qc;
-use rand::{distributions::{Distribution, Standard}, Rng, SeedableRng, rngs::StdRng};
-use rand::{seq::SliceRandom, thread_rng};
-use std::{cmp::min, fmt::Debug, marker::PhantomData};
-use itertools as it;
-use crate::it::Itertools;
-use crate::it::ExactlyOneError;
-use crate::it::multizip;
-use crate::it::multipeek;
-use crate::it::peek_nth;
-use crate::it::free::rciter;
-use crate::it::free::put_back_n;
-use crate::it::FoldWhile;
+#![allow(unstable_name_collisions)]
+
use crate::it::cloned;
+use crate::it::free::put_back_n;
+use crate::it::free::rciter;
use crate::it::iproduct;
use crate::it::izip;
+use crate::it::multipeek;
+use crate::it::multizip;
+use crate::it::peek_nth;
+use crate::it::ExactlyOneError;
+use crate::it::FoldWhile;
+use crate::it::Itertools;
+use itertools as it;
+use quickcheck as qc;
+use rand::{
+ distributions::{Distribution, Standard},
+ rngs::StdRng,
+ Rng, SeedableRng,
+};
+use rand::{seq::SliceRandom, thread_rng};
+use std::{cmp::min, fmt::Debug, marker::PhantomData};
#[test]
fn product3() {
@@ -27,9 +33,7 @@ fn product3() {
}
}
}
- for (_, _, _, _) in iproduct!(0..3, 0..2, 0..2, 0..3) {
- /* test compiles */
- }
+ for (_, _, _, _) in iproduct!(0..3, 0..2, 0..2, 0..3) { /* test compiles */ }
}
#[test]
@@ -62,9 +66,15 @@ fn duplicates_by() {
let xs = ["aaa", "bbbbb", "aa", "ccc", "bbbb", "aaaaa", "cccc"];
let ys = ["aa", "bbbb", "cccc"];
it::assert_equal(ys.iter(), xs.iter().duplicates_by(|x| x[..2].to_string()));
- it::assert_equal(ys.iter(), xs.iter().rev().duplicates_by(|x| x[..2].to_string()).rev());
+ it::assert_equal(
+ ys.iter(),
+ xs.iter().rev().duplicates_by(|x| x[..2].to_string()).rev(),
+ );
let ys_rev = ["ccc", "aa", "bbbbb"];
- it::assert_equal(ys_rev.iter(), xs.iter().duplicates_by(|x| x[..2].to_string()).rev());
+ it::assert_equal(
+ ys_rev.iter(),
+ xs.iter().duplicates_by(|x| x[..2].to_string()).rev(),
+ );
}
#[test]
@@ -86,7 +96,10 @@ fn duplicates() {
let xs = vec![0, 1, 2, 1, 2];
let ys = vec![1, 2];
assert_eq!(ys, xs.iter().duplicates().cloned().collect_vec());
- assert_eq!(ys, xs.iter().rev().duplicates().rev().cloned().collect_vec());
+ assert_eq!(
+ ys,
+ xs.iter().rev().duplicates().rev().cloned().collect_vec()
+ );
let ys_rev = vec![2, 1];
assert_eq!(ys_rev, xs.iter().duplicates().rev().cloned().collect_vec());
}
@@ -96,9 +109,15 @@ fn unique_by() {
let xs = ["aaa", "bbbbb", "aa", "ccc", "bbbb", "aaaaa", "cccc"];
let ys = ["aaa", "bbbbb", "ccc"];
it::assert_equal(ys.iter(), xs.iter().unique_by(|x| x[..2].to_string()));
- it::assert_equal(ys.iter(), xs.iter().rev().unique_by(|x| x[..2].to_string()).rev());
+ it::assert_equal(
+ ys.iter(),
+ xs.iter().rev().unique_by(|x| x[..2].to_string()).rev(),
+ );
let ys_rev = ["cccc", "aaaaa", "bbbb"];
- it::assert_equal(ys_rev.iter(), xs.iter().unique_by(|x| x[..2].to_string()).rev());
+ it::assert_equal(
+ ys_rev.iter(),
+ xs.iter().unique_by(|x| x[..2].to_string()).rev(),
+ );
}
#[test]
@@ -149,13 +168,13 @@ fn dedup() {
#[test]
fn coalesce() {
let data = vec![-1., -2., -3., 3., 1., 0., -1.];
- let it = data.iter().cloned().coalesce(|x, y|
+ let it = data.iter().cloned().coalesce(|x, y| {
if (x >= 0.) == (y >= 0.) {
Ok(x + y)
} else {
Err((x, y))
}
- );
+ });
itertools::assert_equal(it.clone(), vec![-6., 4., -1.]);
assert_eq!(
it.fold(vec![], |mut v, n| {
@@ -168,17 +187,37 @@ fn coalesce() {
#[test]
fn dedup_by() {
- let xs = [(0, 0), (0, 1), (1, 1), (2, 1), (0, 2), (3, 1), (0, 3), (1, 3)];
+ let xs = [
+ (0, 0),
+ (0, 1),
+ (1, 1),
+ (2, 1),
+ (0, 2),
+ (3, 1),
+ (0, 3),
+ (1, 3),
+ ];
let ys = [(0, 0), (0, 1), (0, 2), (3, 1), (0, 3)];
- it::assert_equal(ys.iter(), xs.iter().dedup_by(|x, y| x.1==y.1));
+ it::assert_equal(ys.iter(), xs.iter().dedup_by(|x, y| x.1 == y.1));
let xs = [(0, 1), (0, 2), (0, 3), (0, 4), (0, 5)];
let ys = [(0, 1)];
- it::assert_equal(ys.iter(), xs.iter().dedup_by(|x, y| x.0==y.0));
-
- let xs = [(0, 0), (0, 1), (1, 1), (2, 1), (0, 2), (3, 1), (0, 3), (1, 3)];
+ it::assert_equal(ys.iter(), xs.iter().dedup_by(|x, y| x.0 == y.0));
+
+ let xs = [
+ (0, 0),
+ (0, 1),
+ (1, 1),
+ (2, 1),
+ (0, 2),
+ (3, 1),
+ (0, 3),
+ (1, 3),
+ ];
let ys = [(0, 0), (0, 1), (0, 2), (3, 1), (0, 3)];
let mut xs_d = Vec::new();
- xs.iter().dedup_by(|x, y| x.1==y.1).fold((), |(), &elt| xs_d.push(elt));
+ xs.iter()
+ .dedup_by(|x, y| x.1 == y.1)
+ .fold((), |(), &elt| xs_d.push(elt));
assert_eq!(&xs_d, &ys);
}
@@ -195,18 +234,38 @@ fn dedup_with_count() {
it::assert_equal(ys.iter().cloned(), xs.iter().dedup_with_count());
}
-
#[test]
fn dedup_by_with_count() {
- let xs = [(0, 0), (0, 1), (1, 1), (2, 1), (0, 2), (3, 1), (0, 3), (1, 3)];
- let ys = [(1, &(0, 0)), (3, &(0, 1)), (1, &(0, 2)), (1, &(3, 1)), (2, &(0, 3))];
+ let xs = [
+ (0, 0),
+ (0, 1),
+ (1, 1),
+ (2, 1),
+ (0, 2),
+ (3, 1),
+ (0, 3),
+ (1, 3),
+ ];
+ let ys = [
+ (1, &(0, 0)),
+ (3, &(0, 1)),
+ (1, &(0, 2)),
+ (1, &(3, 1)),
+ (2, &(0, 3)),
+ ];
- it::assert_equal(ys.iter().cloned(), xs.iter().dedup_by_with_count(|x, y| x.1==y.1));
+ it::assert_equal(
+ ys.iter().cloned(),
+ xs.iter().dedup_by_with_count(|x, y| x.1 == y.1),
+ );
let xs = [(0, 1), (0, 2), (0, 3), (0, 4), (0, 5)];
- let ys = [( 5, &(0, 1))];
+ let ys = [(5, &(0, 1))];
- it::assert_equal(ys.iter().cloned(), xs.iter().dedup_by_with_count(|x, y| x.0==y.0));
+ it::assert_equal(
+ ys.iter().cloned(),
+ xs.iter().dedup_by_with_count(|x, y| x.0 == y.0),
+ );
}
#[test]
@@ -227,7 +286,7 @@ fn all_equal_value() {
assert_eq!("AABBCCC".chars().all_equal_value(), Err(Some(('A', 'B'))));
assert_eq!("AAAAAAA".chars().all_equal_value(), Ok('A'));
{
- let mut it = [1,2,3].iter().copied();
+ let mut it = [1, 2, 3].iter().copied();
let result = it.all_equal_value();
assert_eq!(result, Err(Some((1, 2))));
let remaining = it.next();
@@ -256,7 +315,7 @@ fn test_put_back_n() {
#[test]
fn tee() {
- let xs = [0, 1, 2, 3];
+ let xs = [0, 1, 2, 3];
let (mut t1, mut t2) = xs.iter().cloned().tee();
assert_eq!(t1.next(), Some(0));
assert_eq!(t2.next(), Some(0));
@@ -280,7 +339,6 @@ fn tee() {
it::assert_equal(t1.zip(t2), xs.iter().cloned().zip(xs.iter().cloned()));
}
-
#[test]
fn test_rciter() {
let xs = [0, 1, 1, 1, 2, 1, 3, 5, 6];
@@ -304,19 +362,19 @@ fn test_rciter() {
#[allow(deprecated)]
#[test]
fn trait_pointers() {
- struct ByRef<'r, I: ?Sized>(&'r mut I) ;
+ struct ByRef<'r, I: ?Sized>(&'r mut I);
- impl<'r, X, I: ?Sized> Iterator for ByRef<'r, I> where
- I: 'r + Iterator<Item=X>
+ impl<'r, X, I: ?Sized> Iterator for ByRef<'r, I>
+ where
+ I: 'r + Iterator<Item = X>,
{
type Item = X;
- fn next(&mut self) -> Option<Self::Item>
- {
+ fn next(&mut self) -> Option<Self::Item> {
self.0.next()
}
}
- let mut it = Box::new(0..10) as Box<dyn Iterator<Item=i32>>;
+ let mut it = Box::new(0..10) as Box<dyn Iterator<Item = i32>>;
assert_eq!(it.next(), Some(0));
{
@@ -336,9 +394,16 @@ fn trait_pointers() {
#[test]
fn merge_by() {
- let odd : Vec<(u32, &str)> = vec![(1, "hello"), (3, "world"), (5, "!")];
+ let odd: Vec<(u32, &str)> = vec![(1, "hello"), (3, "world"), (5, "!")];
let even = vec![(2, "foo"), (4, "bar"), (6, "baz")];
- let expected = vec![(1, "hello"), (2, "foo"), (3, "world"), (4, "bar"), (5, "!"), (6, "baz")];
+ let expected = vec![
+ (1, "hello"),
+ (2, "foo"),
+ (3, "world"),
+ (4, "bar"),
+ (5, "!"),
+ (6, "baz"),
+ ];
let results = odd.iter().merge_by(even.iter(), |a, b| a.0 <= b.0);
it::assert_equal(results, expected.iter());
}
@@ -352,7 +417,7 @@ fn merge_by_btree() {
let mut bt2 = BTreeMap::new();
bt2.insert("foo", 2);
bt2.insert("bar", 4);
- let results = bt1.into_iter().merge_by(bt2.into_iter(), |a, b| a.0 <= b.0 );
+ let results = bt1.into_iter().merge_by(bt2.into_iter(), |a, b| a.0 <= b.0);
let expected = vec![("bar", 4), ("foo", 2), ("hello", 1), ("world", 3)];
it::assert_equal(results, expected.into_iter());
}
@@ -394,19 +459,17 @@ fn kmerge_empty_size_hint() {
#[test]
fn join() {
let many = [1, 2, 3];
- let one = [1];
+ let one = [1];
let none: Vec<i32> = vec![];
assert_eq!(many.iter().join(", "), "1, 2, 3");
- assert_eq!( one.iter().join(", "), "1");
+ assert_eq!(one.iter().join(", "), "1");
assert_eq!(none.iter().join(", "), "");
}
#[test]
fn sorted_unstable_by() {
- let sc = [3, 4, 1, 2].iter().cloned().sorted_by(|&a, &b| {
- a.cmp(&b)
- });
+ let sc = [3, 4, 1, 2].iter().cloned().sorted_by(|&a, &b| a.cmp(&b));
it::assert_equal(sc, vec![1, 2, 3, 4]);
let v = (0..5).sorted_unstable_by(|&a, &b| a.cmp(&b).reverse());
@@ -424,9 +487,7 @@ fn sorted_unstable_by_key() {
#[test]
fn sorted_by() {
- let sc = [3, 4, 1, 2].iter().cloned().sorted_by(|&a, &b| {
- a.cmp(&b)
- });
+ let sc = [3, 4, 1, 2].iter().cloned().sorted_by(|&a, &b| a.cmp(&b));
it::assert_equal(sc, vec![1, 2, 3, 4]);
let v = (0..5).sorted_by(|&a, &b| a.cmp(&b).reverse());
@@ -459,11 +520,13 @@ struct RandIter<T: 'static + Clone + Send, R: 'static + Clone + Rng + SeedableRn
idx: usize,
len: usize,
rng: R,
- _t: PhantomData<T>
+ _t: PhantomData<T>,
}
impl<T: Clone + Send, R: Clone + Rng + SeedableRng + Send> Iterator for RandIter<T, R>
-where Standard: Distribution<T> {
+where
+ Standard: Distribution<T>,
+{
type Item = T;
fn next(&mut self) -> Option<T> {
if self.idx == self.len {
@@ -481,7 +544,7 @@ impl<T: Clone + Send, R: Clone + Rng + SeedableRng + Send> qc::Arbitrary for Ran
idx: 0,
len: g.size(),
rng: R::seed_from_u64(g.next_u64()),
- _t : PhantomData{},
+ _t: PhantomData {},
}
}
}
@@ -495,10 +558,7 @@ where
{
let j = i.clone();
let k = k as usize;
- it::assert_equal(
- i.k_smallest(k),
- j.sorted().take(k)
- )
+ it::assert_equal(i.k_smallest(k), j.sorted().take(k))
}
macro_rules! generic_test {
@@ -550,7 +610,7 @@ fn sorted_by_cached_key() {
#[test]
fn test_multipeek() {
- let nums = vec![1u8,2,3,4,5];
+ let nums = vec![1u8, 2, 3, 4, 5];
let mp = multipeek(nums.iter().copied());
assert_eq!(nums, mp.collect::<Vec<_>>());
@@ -591,7 +651,7 @@ fn test_multipeek_reset() {
#[test]
fn test_multipeek_peeking_next() {
use crate::it::PeekingNext;
- let nums = vec![1u8,2,3,4,5,6,7];
+ let nums = vec![1u8, 2, 3, 4, 5, 6, 7];
let mut mp = multipeek(nums.iter().copied());
assert_eq!(mp.peeking_next(|&x| x != 0), Some(1));
@@ -616,7 +676,7 @@ fn test_multipeek_peeking_next() {
#[test]
fn test_peek_nth() {
- let nums = vec![1u8,2,3,4,5];
+ let nums = vec![1u8, 2, 3, 4, 5];
let iter = peek_nth(nums.iter().copied());
assert_eq!(nums, iter.collect::<Vec<_>>());
@@ -651,7 +711,7 @@ fn test_peek_nth() {
#[test]
fn test_peek_nth_peeking_next() {
use it::PeekingNext;
- let nums = vec![1u8,2,3,4,5,6,7];
+ let nums = vec![1u8, 2, 3, 4, 5, 6, 7];
let mut iter = peek_nth(nums.iter().copied());
assert_eq!(iter.peeking_next(|&x| x != 0), Some(1));
@@ -679,6 +739,35 @@ fn test_peek_nth_peeking_next() {
}
#[test]
+fn test_peek_nth_next_if() {
+ let nums = vec![1u8, 2, 3, 4, 5, 6, 7];
+ let mut iter = peek_nth(nums.iter().copied());
+
+ assert_eq!(iter.next_if(|&x| x != 0), Some(1));
+ assert_eq!(iter.next(), Some(2));
+
+ assert_eq!(iter.peek_nth(0), Some(&3));
+ assert_eq!(iter.peek_nth(1), Some(&4));
+ assert_eq!(iter.next_if_eq(&3), Some(3));
+ assert_eq!(iter.peek(), Some(&4));
+
+ assert_eq!(iter.next_if(|&x| x != 4), None);
+ assert_eq!(iter.next_if_eq(&4), Some(4));
+ assert_eq!(iter.peek_nth(0), Some(&5));
+ assert_eq!(iter.peek_nth(1), Some(&6));
+
+ assert_eq!(iter.next_if(|&x| x != 5), None);
+ assert_eq!(iter.peek(), Some(&5));
+
+ assert_eq!(iter.next_if(|&x| x % 2 == 1), Some(5));
+ assert_eq!(iter.next_if_eq(&6), Some(6));
+ assert_eq!(iter.peek_nth(0), Some(&7));
+ assert_eq!(iter.peek_nth(1), None);
+ assert_eq!(iter.next(), Some(7));
+ assert_eq!(iter.peek(), None);
+}
+
+#[test]
fn pad_using() {
it::assert_equal((0..0).pad_using(1, |_| 1), 1..2);
@@ -717,11 +806,11 @@ fn group_by() {
for &idx in &indices[..] {
let (key, text) = match idx {
- 0 => ('A', "Aaa".chars()),
- 1 => ('B', "Bbb".chars()),
- 2 => ('C', "ccCc".chars()),
- 3 => ('D', "DDDD".chars()),
- _ => unreachable!(),
+ 0 => ('A', "Aaa".chars()),
+ 1 => ('B', "Bbb".chars()),
+ 2 => ('C', "ccCc".chars()),
+ 3 => ('D', "DDDD".chars()),
+ _ => unreachable!(),
};
assert_eq!(key, subs[idx].0);
it::assert_equal(&mut subs[idx].1, text);
@@ -746,9 +835,11 @@ fn group_by() {
{
let mut ntimes = 0;
let text = "AABCCC";
- for (_, sub) in &text.chars().group_by(|&x| { ntimes += 1; x}) {
- for _ in sub {
- }
+ for (_, sub) in &text.chars().group_by(|&x| {
+ ntimes += 1;
+ x
+ }) {
+ for _ in sub {}
}
assert_eq!(ntimes, text.len());
}
@@ -756,8 +847,10 @@ fn group_by() {
{
let mut ntimes = 0;
let text = "AABCCC";
- for _ in &text.chars().group_by(|&x| { ntimes += 1; x}) {
- }
+ for _ in &text.chars().group_by(|&x| {
+ ntimes += 1;
+ x
+ }) {}
assert_eq!(ntimes, text.len());
}
@@ -797,8 +890,7 @@ fn group_by_lazy_2() {
if i < 2 {
groups.push(group);
} else if i < 4 {
- for _ in group {
- }
+ for _ in group {}
} else {
groups.push(group);
}
@@ -810,7 +902,11 @@ fn group_by_lazy_2() {
// use groups as chunks
let data = vec![0, 0, 0, 1, 1, 0, 0, 2, 2, 3, 3];
let mut i = 0;
- let grouper = data.iter().group_by(move |_| { let k = i / 3; i += 1; k });
+ let grouper = data.iter().group_by(move |_| {
+ let k = i / 3;
+ i += 1;
+ k
+ });
for (i, group) in &grouper {
match i {
0 => it::assert_equal(group, &[0, 0, 0]),
@@ -861,8 +957,8 @@ fn concat_empty() {
#[test]
fn concat_non_empty() {
- let data = vec![vec![1,2,3], vec![4,5,6], vec![7,8,9]];
- assert_eq!(data.into_iter().concat(), vec![1,2,3,4,5,6,7,8,9])
+ let data = vec![vec![1, 2, 3], vec![4, 5, 6], vec![7, 8, 9]];
+ assert_eq!(data.into_iter().concat(), vec![1, 2, 3, 4, 5, 6, 7, 8, 9])
}
#[test]
@@ -870,19 +966,20 @@ fn combinations() {
assert!((1..3).combinations(5).next().is_none());
let it = (1..3).combinations(2);
- it::assert_equal(it, vec![
- vec![1, 2],
- ]);
+ it::assert_equal(it, vec![vec![1, 2]]);
let it = (1..5).combinations(2);
- it::assert_equal(it, vec![
- vec![1, 2],
- vec![1, 3],
- vec![1, 4],
- vec![2, 3],
- vec![2, 4],
- vec![3, 4],
- ]);
+ it::assert_equal(
+ it,
+ vec![
+ vec![1, 2],
+ vec![1, 3],
+ vec![1, 4],
+ vec![2, 3],
+ vec![2, 4],
+ vec![3, 4],
+ ],
+ );
it::assert_equal((0..0).tuple_combinations::<(_, _)>(), <Vec<_>>::new());
it::assert_equal((0..1).tuple_combinations::<(_, _)>(), <Vec<_>>::new());
@@ -902,13 +999,88 @@ fn combinations_of_too_short() {
}
}
-
#[test]
fn combinations_zero() {
it::assert_equal((1..3).combinations(0), vec![vec![]]);
it::assert_equal((0..0).combinations(0), vec![vec![]]);
}
+fn binomial(n: usize, k: usize) -> usize {
+ if k > n {
+ 0
+ } else {
+ (n - k + 1..=n).product::<usize>() / (1..=k).product::<usize>()
+ }
+}
+
+#[test]
+fn combinations_range_count() {
+ for n in 0..=10 {
+ for k in 0..=10 {
+ let len = binomial(n, k);
+ let mut it = (0..n).combinations(k);
+ assert_eq!(len, it.clone().count());
+ assert_eq!(len, it.size_hint().0);
+ assert_eq!(Some(len), it.size_hint().1);
+ for count in (0..len).rev() {
+ let elem = it.next();
+ assert!(elem.is_some());
+ assert_eq!(count, it.clone().count());
+ assert_eq!(count, it.size_hint().0);
+ assert_eq!(Some(count), it.size_hint().1);
+ }
+ let should_be_none = it.next();
+ assert!(should_be_none.is_none());
+ }
+ }
+}
+
+#[test]
+fn combinations_inexact_size_hints() {
+ for k in 0..=10 {
+ let mut numbers = (0..18).filter(|i| i % 2 == 0); // 9 elements
+ let mut it = numbers.clone().combinations(k);
+ let real_n = numbers.clone().count();
+ let len = binomial(real_n, k);
+ assert_eq!(len, it.clone().count());
+
+ let mut nb_loaded = 0;
+ let sh = numbers.size_hint();
+ assert_eq!(binomial(sh.0 + nb_loaded, k), it.size_hint().0);
+ assert_eq!(sh.1.map(|n| binomial(n + nb_loaded, k)), it.size_hint().1);
+
+ for next_count in 1..=len {
+ let elem = it.next();
+ assert!(elem.is_some());
+ assert_eq!(len - next_count, it.clone().count());
+ if next_count == 1 {
+ // The very first time, the lazy buffer is prefilled.
+ nb_loaded = numbers.by_ref().take(k).count();
+ } else {
+ // Then it loads one item each time until exhausted.
+ let nb = numbers.next();
+ if nb.is_some() {
+ nb_loaded += 1;
+ }
+ }
+ let sh = numbers.size_hint();
+ if next_count > real_n - k + 1 {
+ assert_eq!(0, sh.0);
+ assert_eq!(Some(0), sh.1);
+ assert_eq!(real_n, nb_loaded);
+ // Once it's fully loaded, size hints of `it` are exacts.
+ }
+ assert_eq!(binomial(sh.0 + nb_loaded, k) - next_count, it.size_hint().0);
+ assert_eq!(
+ sh.1.map(|n| binomial(n + nb_loaded, k) - next_count),
+ it.size_hint().1
+ );
+ }
+ let should_be_none = it.next();
+ assert!(should_be_none.is_none());
+ }
+}
+
#[test]
fn permutations_zero() {
it::assert_equal((1..3).permutations(0), vec![vec![]]);
@@ -916,6 +1088,40 @@ fn permutations_zero() {
}
#[test]
+fn permutations_range_count() {
+ for n in 0..=7 {
+ for k in 0..=7 {
+ let len = if k <= n { (n - k + 1..=n).product() } else { 0 };
+ let mut it = (0..n).permutations(k);
+ assert_eq!(len, it.clone().count());
+ assert_eq!(len, it.size_hint().0);
+ assert_eq!(Some(len), it.size_hint().1);
+ for count in (0..len).rev() {
+ let elem = it.next();
+ assert!(elem.is_some());
+ assert_eq!(count, it.clone().count());
+ assert_eq!(count, it.size_hint().0);
+ assert_eq!(Some(count), it.size_hint().1);
+ }
+ let should_be_none = it.next();
+ assert!(should_be_none.is_none());
+ }
+ }
+}
+
+#[test]
+fn permutations_overflowed_size_hints() {
+ let mut it = std::iter::repeat(()).permutations(2);
+ assert_eq!(it.size_hint().0, usize::MAX);
+ assert_eq!(it.size_hint().1, None);
+ for nb_generated in 1..=1000 {
+ it.next();
+ assert!(it.size_hint().0 >= usize::MAX - nb_generated);
+ assert_eq!(it.size_hint().1, None);
+ }
+}
+
+#[test]
fn combinations_with_replacement() {
// Pool smaller than n
it::assert_equal((0..1).combinations_with_replacement(2), vec![vec![0, 0]]);
@@ -932,15 +1138,9 @@ fn combinations_with_replacement() {
],
);
// Zero size
- it::assert_equal(
- (0..3).combinations_with_replacement(0),
- vec![vec![]],
- );
+ it::assert_equal((0..3).combinations_with_replacement(0), vec![vec![]]);
// Zero size on empty pool
- it::assert_equal(
- (0..0).combinations_with_replacement(0),
- vec![vec![]],
- );
+ it::assert_equal((0..0).combinations_with_replacement(0), vec![vec![]]);
// Empty pool
it::assert_equal(
(0..0).combinations_with_replacement(2),
@@ -949,20 +1149,69 @@ fn combinations_with_replacement() {
}
#[test]
+fn combinations_with_replacement_range_count() {
+ for n in 0..=7 {
+ for k in 0..=7 {
+ let len = binomial(usize::saturating_sub(n + k, 1), k);
+ let mut it = (0..n).combinations_with_replacement(k);
+ assert_eq!(len, it.clone().count());
+ assert_eq!(len, it.size_hint().0);
+ assert_eq!(Some(len), it.size_hint().1);
+ for count in (0..len).rev() {
+ let elem = it.next();
+ assert!(elem.is_some());
+ assert_eq!(count, it.clone().count());
+ assert_eq!(count, it.size_hint().0);
+ assert_eq!(Some(count), it.size_hint().1);
+ }
+ let should_be_none = it.next();
+ assert!(should_be_none.is_none());
+ }
+ }
+}
+
+#[test]
fn powerset() {
it::assert_equal((0..0).powerset(), vec![vec![]]);
it::assert_equal((0..1).powerset(), vec![vec![], vec![0]]);
- it::assert_equal((0..2).powerset(), vec![vec![], vec![0], vec![1], vec![0, 1]]);
- it::assert_equal((0..3).powerset(), vec![
- vec![],
- vec![0], vec![1], vec![2],
- vec![0, 1], vec![0, 2], vec![1, 2],
- vec![0, 1, 2]
- ]);
+ it::assert_equal(
+ (0..2).powerset(),
+ vec![vec![], vec![0], vec![1], vec![0, 1]],
+ );
+ it::assert_equal(
+ (0..3).powerset(),
+ vec![
+ vec![],
+ vec![0],
+ vec![1],
+ vec![2],
+ vec![0, 1],
+ vec![0, 2],
+ vec![1, 2],
+ vec![0, 1, 2],
+ ],
+ );
assert_eq!((0..4).powerset().count(), 1 << 4);
assert_eq!((0..8).powerset().count(), 1 << 8);
assert_eq!((0..16).powerset().count(), 1 << 16);
+
+ for n in 0..=10 {
+ let mut it = (0..n).powerset();
+ let len = 2_usize.pow(n);
+ assert_eq!(len, it.clone().count());
+ assert_eq!(len, it.size_hint().0);
+ assert_eq!(Some(len), it.size_hint().1);
+ for count in (0..len).rev() {
+ let elem = it.next();
+ assert!(elem.is_some());
+ assert_eq!(count, it.clone().count());
+ assert_eq!(count, it.size_hint().0);
+ assert_eq!(Some(count), it.size_hint().1);
+ }
+ let should_be_none = it.next();
+ assert!(should_be_none.is_none());
+ }
}
#[test]
@@ -987,8 +1236,7 @@ fn diff_longer() {
let diff = it::diff_with(a.iter(), b_map, |a, b| *a == b);
assert!(match diff {
- Some(it::Diff::Longer(_, remaining)) =>
- remaining.collect::<Vec<_>>() == vec![5, 6],
+ Some(it::Diff::Longer(_, remaining)) => remaining.collect::<Vec<_>>() == vec![5, 6],
_ => false,
});
}
@@ -1056,8 +1304,8 @@ fn extrema_set() {
#[test]
fn minmax() {
- use std::cmp::Ordering;
use crate::it::MinMaxResult;
+ use std::cmp::Ordering;
// A peculiar type: Equality compares both tuple items, but ordering only the
// first item. This is so we can check the stability property easily.
@@ -1076,7 +1324,10 @@ fn minmax() {
}
}
- assert_eq!(None::<Option<u32>>.iter().minmax(), MinMaxResult::NoElements);
+ assert_eq!(
+ None::<Option<u32>>.iter().minmax(),
+ MinMaxResult::NoElements
+ );
assert_eq!(Some(1u32).iter().minmax(), MinMaxResult::OneElement(&1));
@@ -1089,7 +1340,11 @@ fn minmax() {
assert_eq!(min, &Val(2, 0));
assert_eq!(max, &Val(0, 2));
- let (min, max) = data.iter().minmax_by(|x, y| x.1.cmp(&y.1)).into_option().unwrap();
+ let (min, max) = data
+ .iter()
+ .minmax_by(|x, y| x.1.cmp(&y.1))
+ .into_option()
+ .unwrap();
assert_eq!(min, &Val(2, 0));
assert_eq!(max, &Val(0, 2));
}
@@ -1112,8 +1367,9 @@ fn format() {
#[test]
fn while_some() {
- let ns = (1..10).map(|x| if x % 5 != 0 { Some(x) } else { None })
- .while_some();
+ let ns = (1..10)
+ .map(|x| if x % 5 != 0 { Some(x) } else { None })
+ .while_some();
it::assert_equal(ns, vec![1, 2, 3, 4]);
}
@@ -1122,15 +1378,18 @@ fn while_some() {
fn fold_while() {
let mut iterations = 0;
let vec = vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
- let sum = vec.into_iter().fold_while(0, |acc, item| {
- iterations += 1;
- let new_sum = acc + item;
- if new_sum <= 20 {
- FoldWhile::Continue(new_sum)
- } else {
- FoldWhile::Done(acc)
- }
- }).into_inner();
+ let sum = vec
+ .into_iter()
+ .fold_while(0, |acc, item| {
+ iterations += 1;
+ let new_sum = acc + item;
+ if new_sum <= 20 {
+ FoldWhile::Continue(new_sum)
+ } else {
+ FoldWhile::Done(acc)
+ }
+ })
+ .into_inner();
assert_eq!(iterations, 6);
assert_eq!(sum, 15);
}
@@ -1157,7 +1416,11 @@ fn tree_fold1() {
"0 1 x 2 3 x x 4 5 x 6 7 x x x 8 9 x 10 11 x x 12 13 x 14 15 x x x x",
];
for (i, &s) in x.iter().enumerate() {
- let expected = if s.is_empty() { None } else { Some(s.to_string()) };
+ let expected = if s.is_empty() {
+ None
+ } else {
+ Some(s.to_string())
+ };
let num_strings = (0..i).map(|x| x.to_string());
let actual = num_strings.tree_fold1(|a, b| format!("{} {} x", a, b));
assert_eq!(actual, expected);
@@ -1169,16 +1432,52 @@ fn exactly_one_question_mark_syntax_works() {
exactly_one_question_mark_return().unwrap_err();
}
-fn exactly_one_question_mark_return() -> Result<(), ExactlyOneError<std::slice::Iter<'static, ()>>> {
+fn exactly_one_question_mark_return() -> Result<(), ExactlyOneError<std::slice::Iter<'static, ()>>>
+{
[].iter().exactly_one()?;
Ok(())
}
#[test]
fn multiunzip() {
- let (a, b, c): (Vec<_>, Vec<_>, Vec<_>) = [(0, 1, 2), (3, 4, 5), (6, 7, 8)].iter().cloned().multiunzip();
+ let (a, b, c): (Vec<_>, Vec<_>, Vec<_>) = [(0, 1, 2), (3, 4, 5), (6, 7, 8)]
+ .iter()
+ .cloned()
+ .multiunzip();
assert_eq!((a, b, c), (vec![0, 3, 6], vec![1, 4, 7], vec![2, 5, 8]));
let (): () = [(), (), ()].iter().cloned().multiunzip();
- let t: (Vec<_>, Vec<_>, Vec<_>, Vec<_>, Vec<_>, Vec<_>, Vec<_>, Vec<_>, Vec<_>, Vec<_>, Vec<_>, Vec<_>) = [(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11)].iter().cloned().multiunzip();
- assert_eq!(t, (vec![0], vec![1], vec![2], vec![3], vec![4], vec![5], vec![6], vec![7], vec![8], vec![9], vec![10], vec![11]));
+ let t: (
+ Vec<_>,
+ Vec<_>,
+ Vec<_>,
+ Vec<_>,
+ Vec<_>,
+ Vec<_>,
+ Vec<_>,
+ Vec<_>,
+ Vec<_>,
+ Vec<_>,
+ Vec<_>,
+ Vec<_>,
+ ) = [(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11)]
+ .iter()
+ .cloned()
+ .multiunzip();
+ assert_eq!(
+ t,
+ (
+ vec![0],
+ vec![1],
+ vec![2],
+ vec![3],
+ vec![4],
+ vec![5],
+ vec![6],
+ vec![7],
+ vec![8],
+ vec![9],
+ vec![10],
+ vec![11]
+ )
+ );
}
generated by cgit v1.2.3 (git 2.39.1) at 2024-09-06 18:02:10 +0000