mirror of
https://github.com/rust-lang/rust.git
synced 2025-10-30 12:36:38 +00:00
994e712162
Repeat iterator always returns the same element and behaves the same way backwards and forwards. Take iterator can trivially implement backwards iteration over Repeat inner iterator by simply doing forwards iteration. DoubleEndedIterator is not currently implemented for Take<Repeat<T>> because Repeat doesn’t implement ExactSizeIterator which is a required bound on DEI implementation for Take. Similarly, since Repeat is an infinite iterator which never stops, Take can trivially know how many elements it’s going to return. This allows implementing ExactSizeIterator on Take<Repeat<T>>. While at it, observe that ExactSizeIterator can also be implemented for Take<RepeatWhile<F>> so add that implementation too. Since in contrast to Repeat, RepeatWhile doesn’t guarante to always return the same value, DoubleEndedIterator isn’t implemented. Those changes render core::iter::repeat_n somewhat redundant. Issue: https://github.com/rust-lang/rust/issues/104434 Issue: https://github.com/rust-lang/rust/issues/104729
263 lines
7.3 KiB
Rust
263 lines
7.3 KiB
Rust
use core::iter::*;
|
|
use core::num::NonZero;
|
|
|
|
#[test]
|
|
fn test_iterator_take() {
|
|
let xs = [0, 1, 2, 3, 5, 13, 15, 16, 17, 19];
|
|
let ys = [0, 1, 2, 3, 5];
|
|
|
|
let mut it = xs.iter().take(ys.len());
|
|
let mut i = 0;
|
|
assert_eq!(it.len(), ys.len());
|
|
while let Some(&x) = it.next() {
|
|
assert_eq!(x, ys[i]);
|
|
i += 1;
|
|
assert_eq!(it.len(), ys.len() - i);
|
|
}
|
|
assert_eq!(i, ys.len());
|
|
assert_eq!(it.len(), 0);
|
|
|
|
let mut it = xs.iter().take(ys.len());
|
|
let mut i = 0;
|
|
assert_eq!(it.len(), ys.len());
|
|
while let Some(&x) = it.next_back() {
|
|
i += 1;
|
|
assert_eq!(x, ys[ys.len() - i]);
|
|
assert_eq!(it.len(), ys.len() - i);
|
|
}
|
|
assert_eq!(i, ys.len());
|
|
assert_eq!(it.len(), 0);
|
|
}
|
|
|
|
#[test]
|
|
fn test_iterator_take_nth() {
|
|
let xs = [0, 1, 2, 4, 5];
|
|
let mut it = xs.iter();
|
|
{
|
|
let mut take = it.by_ref().take(3);
|
|
let mut i = 0;
|
|
while let Some(&x) = take.nth(0) {
|
|
assert_eq!(x, i);
|
|
i += 1;
|
|
}
|
|
}
|
|
assert_eq!(it.nth(1), Some(&5));
|
|
assert_eq!(it.nth(0), None);
|
|
|
|
let xs = [0, 1, 2, 3, 4];
|
|
let mut it = xs.iter().take(7);
|
|
let mut i = 1;
|
|
while let Some(&x) = it.nth(1) {
|
|
assert_eq!(x, i);
|
|
i += 2;
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn test_iterator_take_nth_back() {
|
|
let xs = [0, 1, 2, 4, 5];
|
|
let mut it = xs.iter();
|
|
{
|
|
let mut take = it.by_ref().take(3);
|
|
let mut i = 0;
|
|
while let Some(&x) = take.nth_back(0) {
|
|
i += 1;
|
|
assert_eq!(x, 3 - i);
|
|
}
|
|
}
|
|
assert_eq!(it.nth_back(0), None);
|
|
|
|
let xs = [0, 1, 2, 3, 4];
|
|
let mut it = xs.iter().take(7);
|
|
assert_eq!(it.nth_back(1), Some(&3));
|
|
assert_eq!(it.nth_back(1), Some(&1));
|
|
assert_eq!(it.nth_back(1), None);
|
|
}
|
|
|
|
#[test]
|
|
fn test_take_advance_by() {
|
|
let mut take = (0..10).take(3);
|
|
assert_eq!(take.advance_by(2), Ok(()));
|
|
assert_eq!(take.next(), Some(2));
|
|
assert_eq!(take.advance_by(1), Err(NonZero::new(1).unwrap()));
|
|
|
|
assert_eq!((0..0).take(10).advance_by(0), Ok(()));
|
|
assert_eq!((0..0).take(10).advance_by(1), Err(NonZero::new(1).unwrap()));
|
|
assert_eq!((0..10).take(4).advance_by(5), Err(NonZero::new(1).unwrap()));
|
|
|
|
let mut take = (0..10).take(3);
|
|
assert_eq!(take.advance_back_by(2), Ok(()));
|
|
assert_eq!(take.next(), Some(0));
|
|
assert_eq!(take.advance_back_by(1), Err(NonZero::new(1).unwrap()));
|
|
|
|
assert_eq!((0..2).take(1).advance_back_by(10), Err(NonZero::new(9).unwrap()));
|
|
assert_eq!((0..0).take(1).advance_back_by(1), Err(NonZero::new(1).unwrap()));
|
|
assert_eq!((0..0).take(1).advance_back_by(0), Ok(()));
|
|
assert_eq!(
|
|
(0..usize::MAX).take(100).advance_back_by(usize::MAX),
|
|
Err(NonZero::new(usize::MAX - 100).unwrap())
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn test_iterator_take_short() {
|
|
let xs = [0, 1, 2, 3];
|
|
|
|
let mut it = xs.iter().take(5);
|
|
let mut i = 0;
|
|
assert_eq!(it.len(), xs.len());
|
|
while let Some(&x) = it.next() {
|
|
assert_eq!(x, xs[i]);
|
|
i += 1;
|
|
assert_eq!(it.len(), xs.len() - i);
|
|
}
|
|
assert_eq!(i, xs.len());
|
|
assert_eq!(it.len(), 0);
|
|
|
|
let mut it = xs.iter().take(5);
|
|
let mut i = 0;
|
|
assert_eq!(it.len(), xs.len());
|
|
while let Some(&x) = it.next_back() {
|
|
i += 1;
|
|
assert_eq!(x, xs[xs.len() - i]);
|
|
assert_eq!(it.len(), xs.len() - i);
|
|
}
|
|
assert_eq!(i, xs.len());
|
|
assert_eq!(it.len(), 0);
|
|
}
|
|
|
|
#[test]
|
|
fn test_take_try_folds() {
|
|
let f = &|acc, x| i32::checked_add(2 * acc, x);
|
|
assert_eq!((10..30).take(10).try_fold(7, f), (10..20).try_fold(7, f));
|
|
assert_eq!((10..30).take(10).try_rfold(7, f), (10..20).try_rfold(7, f));
|
|
|
|
let mut iter = (10..30).take(20);
|
|
assert_eq!(iter.try_fold(0, i8::checked_add), None);
|
|
assert_eq!(iter.next(), Some(20));
|
|
assert_eq!(iter.try_rfold(0, i8::checked_add), None);
|
|
assert_eq!(iter.next_back(), Some(24));
|
|
|
|
let mut iter = (2..20).take(3);
|
|
assert_eq!(iter.try_for_each(Err), Err(2));
|
|
assert_eq!(iter.try_for_each(Err), Err(3));
|
|
assert_eq!(iter.try_for_each(Err), Err(4));
|
|
assert_eq!(iter.try_for_each(Err), Ok(()));
|
|
|
|
let mut iter = (2..20).take(3).rev();
|
|
assert_eq!(iter.try_for_each(Err), Err(4));
|
|
assert_eq!(iter.try_for_each(Err), Err(3));
|
|
assert_eq!(iter.try_for_each(Err), Err(2));
|
|
assert_eq!(iter.try_for_each(Err), Ok(()));
|
|
}
|
|
|
|
#[test]
|
|
fn test_byref_take_consumed_items() {
|
|
let mut inner = 10..90;
|
|
|
|
let mut count = 0;
|
|
inner.by_ref().take(0).for_each(|_| count += 1);
|
|
assert_eq!(count, 0);
|
|
assert_eq!(inner, 10..90);
|
|
|
|
let mut count = 0;
|
|
inner.by_ref().take(10).for_each(|_| count += 1);
|
|
assert_eq!(count, 10);
|
|
assert_eq!(inner, 20..90);
|
|
|
|
let mut count = 0;
|
|
inner.by_ref().take(100).for_each(|_| count += 1);
|
|
assert_eq!(count, 70);
|
|
assert_eq!(inner, 90..90);
|
|
}
|
|
|
|
#[test]
|
|
fn test_exact_size_take_repeat() {
|
|
let mut iter = core::iter::repeat(42).take(40);
|
|
assert_eq!((40, Some(40)), iter.size_hint());
|
|
assert_eq!(40, iter.len());
|
|
|
|
assert_eq!(Some(42), iter.next());
|
|
assert_eq!((39, Some(39)), iter.size_hint());
|
|
assert_eq!(39, iter.len());
|
|
|
|
assert_eq!(Some(42), iter.next_back());
|
|
assert_eq!((38, Some(38)), iter.size_hint());
|
|
assert_eq!(38, iter.len());
|
|
|
|
assert_eq!(Some(42), iter.nth(3));
|
|
assert_eq!((34, Some(34)), iter.size_hint());
|
|
assert_eq!(34, iter.len());
|
|
|
|
assert_eq!(Some(42), iter.nth_back(3));
|
|
assert_eq!((30, Some(30)), iter.size_hint());
|
|
assert_eq!(30, iter.len());
|
|
|
|
assert_eq!(Ok(()), iter.advance_by(10));
|
|
assert_eq!((20, Some(20)), iter.size_hint());
|
|
assert_eq!(20, iter.len());
|
|
|
|
assert_eq!(Ok(()), iter.advance_back_by(10));
|
|
assert_eq!((10, Some(10)), iter.size_hint());
|
|
assert_eq!(10, iter.len());
|
|
}
|
|
|
|
#[test]
|
|
fn test_exact_size_take_repeat_with() {
|
|
let mut counter = 0;
|
|
let mut iter = core::iter::repeat_with(move || {
|
|
counter += 1;
|
|
counter
|
|
})
|
|
.take(40);
|
|
assert_eq!((40, Some(40)), iter.size_hint());
|
|
assert_eq!(40, iter.len());
|
|
|
|
assert_eq!(Some(1), iter.next());
|
|
assert_eq!((39, Some(39)), iter.size_hint());
|
|
assert_eq!(39, iter.len());
|
|
|
|
assert_eq!(Some(5), iter.nth(3));
|
|
assert_eq!((35, Some(35)), iter.size_hint());
|
|
assert_eq!(35, iter.len());
|
|
|
|
assert_eq!(Ok(()), iter.advance_by(10));
|
|
assert_eq!((25, Some(25)), iter.size_hint());
|
|
assert_eq!(25, iter.len());
|
|
|
|
assert_eq!(Some(16), iter.next());
|
|
assert_eq!((24, Some(24)), iter.size_hint());
|
|
assert_eq!(24, iter.len());
|
|
}
|
|
|
|
// This is https://github.com/rust-lang/rust/issues/104729 with all uses of
|
|
// repeat(0) were replaced by repeat(0).take(20).
|
|
#[test]
|
|
fn test_reverse_on_zip() {
|
|
let vec_1 = [1; 10];
|
|
|
|
let zipped_iter = vec_1.iter().copied().zip(core::iter::repeat(0).take(20));
|
|
|
|
// Forward
|
|
for (one, zero) in zipped_iter {
|
|
assert_eq!((1, 0), (one, zero));
|
|
}
|
|
|
|
let rev_vec_iter = vec_1.iter().rev();
|
|
let rev_repeat_iter = std::iter::repeat(0).take(20).rev();
|
|
|
|
// Manual reversed zip
|
|
let rev_zipped_iter = rev_vec_iter.zip(rev_repeat_iter);
|
|
|
|
for (&one, zero) in rev_zipped_iter {
|
|
assert_eq!((1, 0), (one, zero));
|
|
}
|
|
|
|
let zipped_iter = vec_1.iter().zip(core::iter::repeat(0).take(20));
|
|
|
|
// Cannot call rev here for automatic reversed zip constuction
|
|
for (&one, zero) in zipped_iter.rev() {
|
|
assert_eq!((1, 0), (one, zero));
|
|
}
|
|
}
|