]>
Commit | Line | Data |
---|---|---|
5869c6ff | 1 | use super::*; |
136023e0 | 2 | use core::array; |
5869c6ff XL |
3 | use core::iter::*; |
4 | ||
5 | #[test] | |
6 | fn test_iterator_flatten() { | |
7 | let xs = [0, 3, 6]; | |
8 | let ys = [0, 1, 2, 3, 4, 5, 6, 7, 8]; | |
9 | let it = xs.iter().map(|&x| (x..).step_by(1).take(3)).flatten(); | |
10 | let mut i = 0; | |
11 | for x in it { | |
12 | assert_eq!(x, ys[i]); | |
13 | i += 1; | |
14 | } | |
15 | assert_eq!(i, ys.len()); | |
16 | } | |
17 | ||
18 | /// Tests `Flatten::fold` with items already picked off the front and back, | |
19 | /// to make sure all parts of the `Flatten` are folded correctly. | |
20 | #[test] | |
21 | fn test_iterator_flatten_fold() { | |
22 | let xs = [0, 3, 6]; | |
23 | let ys = [1, 2, 3, 4, 5, 6, 7]; | |
24 | let mut it = xs.iter().map(|&x| x..x + 3).flatten(); | |
25 | assert_eq!(it.next(), Some(0)); | |
26 | assert_eq!(it.next_back(), Some(8)); | |
27 | let i = it.fold(0, |i, x| { | |
28 | assert_eq!(x, ys[i]); | |
29 | i + 1 | |
30 | }); | |
31 | assert_eq!(i, ys.len()); | |
32 | ||
33 | let mut it = xs.iter().map(|&x| x..x + 3).flatten(); | |
34 | assert_eq!(it.next(), Some(0)); | |
35 | assert_eq!(it.next_back(), Some(8)); | |
36 | let i = it.rfold(ys.len(), |i, x| { | |
37 | assert_eq!(x, ys[i - 1]); | |
38 | i - 1 | |
39 | }); | |
40 | assert_eq!(i, 0); | |
41 | } | |
42 | ||
43 | #[test] | |
44 | fn test_flatten_try_folds() { | |
45 | let f = &|acc, x| i32::checked_add(acc * 2 / 3, x); | |
46 | let mr = &|x| (5 * x)..(5 * x + 5); | |
47 | assert_eq!((0..10).map(mr).flatten().try_fold(7, f), (0..50).try_fold(7, f)); | |
48 | assert_eq!((0..10).map(mr).flatten().try_rfold(7, f), (0..50).try_rfold(7, f)); | |
49 | let mut iter = (0..10).map(mr).flatten(); | |
50 | iter.next(); | |
51 | iter.next_back(); // have front and back iters in progress | |
52 | assert_eq!(iter.try_rfold(7, f), (1..49).try_rfold(7, f)); | |
53 | ||
54 | let mut iter = (0..10).map(|x| (4 * x)..(4 * x + 4)).flatten(); | |
55 | assert_eq!(iter.try_fold(0, i8::checked_add), None); | |
56 | assert_eq!(iter.next(), Some(17)); | |
57 | assert_eq!(iter.try_rfold(0, i8::checked_add), None); | |
58 | assert_eq!(iter.next_back(), Some(35)); | |
59 | } | |
60 | ||
61 | #[test] | |
62 | fn test_flatten_non_fused_outer() { | |
63 | let mut iter = NonFused::new(once(0..2)).flatten(); | |
64 | ||
65 | assert_eq!(iter.next_back(), Some(1)); | |
66 | assert_eq!(iter.next(), Some(0)); | |
67 | assert_eq!(iter.next(), None); | |
68 | assert_eq!(iter.next(), None); | |
69 | ||
70 | let mut iter = NonFused::new(once(0..2)).flatten(); | |
71 | ||
72 | assert_eq!(iter.next(), Some(0)); | |
73 | assert_eq!(iter.next_back(), Some(1)); | |
74 | assert_eq!(iter.next_back(), None); | |
75 | assert_eq!(iter.next_back(), None); | |
76 | } | |
77 | ||
78 | #[test] | |
79 | fn test_flatten_non_fused_inner() { | |
80 | let mut iter = once(0..1).chain(once(1..3)).flat_map(NonFused::new); | |
81 | ||
82 | assert_eq!(iter.next_back(), Some(2)); | |
83 | assert_eq!(iter.next(), Some(0)); | |
84 | assert_eq!(iter.next(), Some(1)); | |
85 | assert_eq!(iter.next(), None); | |
86 | assert_eq!(iter.next(), None); | |
87 | ||
88 | let mut iter = once(0..1).chain(once(1..3)).flat_map(NonFused::new); | |
89 | ||
90 | assert_eq!(iter.next(), Some(0)); | |
91 | assert_eq!(iter.next_back(), Some(2)); | |
92 | assert_eq!(iter.next_back(), Some(1)); | |
93 | assert_eq!(iter.next_back(), None); | |
94 | assert_eq!(iter.next_back(), None); | |
95 | } | |
96 | ||
97 | #[test] | |
98 | fn test_double_ended_flatten() { | |
99 | let u = [0, 1]; | |
100 | let v = [5, 6, 7, 8]; | |
101 | let mut it = u.iter().map(|x| &v[*x..v.len()]).flatten(); | |
102 | assert_eq!(it.next_back().unwrap(), &8); | |
103 | assert_eq!(it.next().unwrap(), &5); | |
104 | assert_eq!(it.next_back().unwrap(), &7); | |
105 | assert_eq!(it.next_back().unwrap(), &6); | |
106 | assert_eq!(it.next_back().unwrap(), &8); | |
107 | assert_eq!(it.next().unwrap(), &6); | |
108 | assert_eq!(it.next_back().unwrap(), &7); | |
109 | assert_eq!(it.next_back(), None); | |
110 | assert_eq!(it.next(), None); | |
111 | assert_eq!(it.next_back(), None); | |
112 | } | |
136023e0 XL |
113 | |
114 | #[test] | |
115 | fn test_trusted_len_flatten() { | |
116 | fn assert_trusted_len<T: TrustedLen>(_: &T) {} | |
117 | let mut iter = array::IntoIter::new([[0; 3]; 4]).flatten(); | |
118 | assert_trusted_len(&iter); | |
119 | ||
120 | assert_eq!(iter.size_hint(), (12, Some(12))); | |
121 | iter.next(); | |
122 | assert_eq!(iter.size_hint(), (11, Some(11))); | |
123 | iter.next_back(); | |
124 | assert_eq!(iter.size_hint(), (10, Some(10))); | |
125 | ||
126 | let iter = array::IntoIter::new([[(); usize::MAX]; 1]).flatten(); | |
127 | assert_eq!(iter.size_hint(), (usize::MAX, Some(usize::MAX))); | |
128 | ||
129 | let iter = array::IntoIter::new([[(); usize::MAX]; 2]).flatten(); | |
130 | assert_eq!(iter.size_hint(), (usize::MAX, None)); | |
131 | ||
132 | let mut a = [(); 10]; | |
133 | let mut b = [(); 10]; | |
134 | ||
135 | let iter = array::IntoIter::new([&mut a, &mut b]).flatten(); | |
136 | assert_trusted_len(&iter); | |
137 | assert_eq!(iter.size_hint(), (20, Some(20))); | |
138 | core::mem::drop(iter); | |
139 | ||
140 | let iter = array::IntoIter::new([&a, &b]).flatten(); | |
141 | assert_trusted_len(&iter); | |
142 | assert_eq!(iter.size_hint(), (20, Some(20))); | |
143 | ||
144 | let iter = [(), (), ()].iter().flat_map(|_| [(); 1000]); | |
145 | assert_trusted_len(&iter); | |
146 | assert_eq!(iter.size_hint(), (3000, Some(3000))); | |
147 | ||
148 | let iter = [(), ()].iter().flat_map(|_| &a); | |
149 | assert_trusted_len(&iter); | |
150 | assert_eq!(iter.size_hint(), (20, Some(20))); | |
151 | } |