1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
|
//! Note
//! ----
//! You're probably viewing this file because you're adding a test (or you might
//! just be browsing, in that case, hey there!).
//!
//! The iter test suite is split into two big modules, and some miscellaneous
//! smaller modules. The two big modules are `adapters` and `traits`.
//!
//! `adapters` are for methods on `Iterator` that adapt the data inside the
//! iterator, whether it be by emitting another iterator or returning an item
//! from inside the iterator after executing a closure on each item.
//!
//! `traits` are for trait's that extend an `Iterator` (and the `Iterator`
//! trait itself, mostly containing miscellaneous methods). For the most part,
//! if a test in `traits` uses a specific adapter, then it should be moved to
//! that adapter's test file in `adapters`.
mod adapters;
mod range;
mod sources;
mod traits;
use core::cell::Cell;
use core::convert::TryFrom;
use core::iter::*;
pub fn is_trusted_len<I: TrustedLen>(_: I) {}
#[test]
fn test_multi_iter() {
let xs = [1, 2, 3, 4];
let ys = [4, 3, 2, 1];
assert!(xs.iter().eq(ys.iter().rev()));
assert!(xs.iter().lt(xs.iter().skip(2)));
}
#[test]
fn test_counter_from_iter() {
let it = (0..).step_by(5).take(10);
let xs: Vec<isize> = FromIterator::from_iter(it);
assert_eq!(xs, [0, 5, 10, 15, 20, 25, 30, 35, 40, 45]);
}
#[test]
fn test_functor_laws() {
// identity:
fn identity<T>(x: T) -> T {
x
}
assert_eq!((0..10).map(identity).sum::<usize>(), (0..10).sum());
// composition:
fn f(x: usize) -> usize {
x + 3
}
fn g(x: usize) -> usize {
x * 2
}
fn h(x: usize) -> usize {
g(f(x))
}
assert_eq!((0..10).map(f).map(g).sum::<usize>(), (0..10).map(h).sum());
}
#[test]
fn test_monad_laws_left_identity() {
fn f(x: usize) -> impl Iterator<Item = usize> {
(0..10).map(move |y| x * y)
}
assert_eq!(once(42).flat_map(f.clone()).sum::<usize>(), f(42).sum());
}
#[test]
fn test_monad_laws_right_identity() {
assert_eq!((0..10).flat_map(|x| once(x)).sum::<usize>(), (0..10).sum());
}
#[test]
fn test_monad_laws_associativity() {
fn f(x: usize) -> impl Iterator<Item = usize> {
0..x
}
fn g(x: usize) -> impl Iterator<Item = usize> {
(0..x).rev()
}
assert_eq!(
(0..10).flat_map(f).flat_map(g).sum::<usize>(),
(0..10).flat_map(|x| f(x).flat_map(g)).sum::<usize>()
);
}
#[test]
pub fn extend_for_unit() {
let mut x = 0;
{
let iter = (0..5).map(|_| {
x += 1;
});
().extend(iter);
}
assert_eq!(x, 5);
}
|
