5 fn test_iterator_peekable() {
6 let xs = vec![0, 1, 2, 3, 4, 5];
8 let mut it = xs.iter().cloned().peekable();
9 assert_eq!(it.len(), 6);
10 assert_eq!(it.peek().unwrap(), &0);
11 assert_eq!(it.len(), 6);
12 assert_eq!(it.next().unwrap(), 0);
13 assert_eq!(it.len(), 5);
14 assert_eq!(it.next().unwrap(), 1);
15 assert_eq!(it.len(), 4);
16 assert_eq!(it.next().unwrap(), 2);
17 assert_eq!(it.len(), 3);
18 assert_eq!(it.peek().unwrap(), &3);
19 assert_eq!(it.len(), 3);
20 assert_eq!(it.peek().unwrap(), &3);
21 assert_eq!(it.len(), 3);
22 assert_eq!(it.next().unwrap(), 3);
23 assert_eq!(it.len(), 2);
24 assert_eq!(it.next().unwrap(), 4);
25 assert_eq!(it.len(), 1);
26 assert_eq!(it.peek().unwrap(), &5);
27 assert_eq!(it.len(), 1);
28 assert_eq!(it.next().unwrap(), 5);
29 assert_eq!(it.len(), 0);
30 assert!(it.peek().is_none());
31 assert_eq!(it.len(), 0);
32 assert!(it.next().is_none());
33 assert_eq!(it.len(), 0);
35 let mut it = xs.iter().cloned().peekable();
36 assert_eq!(it.len(), 6);
37 assert_eq!(it.peek().unwrap(), &0);
38 assert_eq!(it.len(), 6);
39 assert_eq!(it.next_back().unwrap(), 5);
40 assert_eq!(it.len(), 5);
41 assert_eq!(it.next_back().unwrap(), 4);
42 assert_eq!(it.len(), 4);
43 assert_eq!(it.next_back().unwrap(), 3);
44 assert_eq!(it.len(), 3);
45 assert_eq!(it.peek().unwrap(), &0);
46 assert_eq!(it.len(), 3);
47 assert_eq!(it.peek().unwrap(), &0);
48 assert_eq!(it.len(), 3);
49 assert_eq!(it.next_back().unwrap(), 2);
50 assert_eq!(it.len(), 2);
51 assert_eq!(it.next_back().unwrap(), 1);
52 assert_eq!(it.len(), 1);
53 assert_eq!(it.peek().unwrap(), &0);
54 assert_eq!(it.len(), 1);
55 assert_eq!(it.next_back().unwrap(), 0);
56 assert_eq!(it.len(), 0);
57 assert!(it.peek().is_none());
58 assert_eq!(it.len(), 0);
59 assert!(it.next_back().is_none());
60 assert_eq!(it.len(), 0);
63 fn test_iterator_peekable_count() {
64 let xs = [0, 1, 2, 3, 4, 5];
66 let zs: [i32; 0] = [];
68 assert_eq!(xs.iter().peekable().count(), 6);
70 let mut it = xs.iter().peekable();
71 assert_eq!(it.peek(), Some(&&0));
72 assert_eq!(it.count(), 6);
74 assert_eq!(ys.iter().peekable().count(), 1);
76 let mut it = ys.iter().peekable();
77 assert_eq!(it.peek(), Some(&&10));
78 assert_eq!(it.count(), 1);
80 assert_eq!(zs.iter().peekable().count(), 0);
82 let mut it = zs.iter().peekable();
83 assert_eq!(it.peek(), None);
86 fn test_iterator_peekable_nth() {
87 let xs = [0, 1, 2, 3, 4, 5];
88 let mut it = xs.iter().peekable();
90 assert_eq!(it.peek(), Some(&&0));
91 assert_eq!(it.nth(0), Some(&0));
92 assert_eq!(it.peek(), Some(&&1));
93 assert_eq!(it.nth(1), Some(&2));
94 assert_eq!(it.peek(), Some(&&3));
95 assert_eq!(it.nth(2), Some(&5));
96 assert_eq!(it.next(), None);
99 fn test_iterator_peekable_last() {
100 let xs = [0, 1, 2, 3, 4, 5];
103 let mut it = xs.iter().peekable();
104 assert_eq!(it.peek(), Some(&&0));
105 assert_eq!(it.last(), Some(&5));
107 let mut it = ys.iter().peekable();
108 assert_eq!(it.peek(), Some(&&0));
109 assert_eq!(it.last(), Some(&0));
111 let mut it = ys.iter().peekable();
112 assert_eq!(it.next(), Some(&0));
113 assert_eq!(it.peek(), None);
114 assert_eq!(it.last(), None);
117 fn test_iterator_peekable_fold() {
118 let xs = [0, 1, 2, 3, 4, 5];
119 let mut it = xs.iter().peekable();
120 assert_eq!(it.peek(), Some(&&0));
121 let i = it.fold(0, |i, &x| {
122 assert_eq!(x, xs[i]);
125 assert_eq!(i, xs.len());
128 fn test_iterator_peekable_rfold() {
129 let xs = [0, 1, 2, 3, 4, 5];
130 let mut it = xs.iter().peekable();
131 assert_eq!(it.peek(), Some(&&0));
132 let i = it.rfold(0, |i, &x| {
133 assert_eq!(x, xs[xs.len() - 1 - i]);
136 assert_eq!(i, xs.len());
139 fn test_iterator_peekable_next_if_eq() {
140 // first, try on references
141 let xs = vec!["Heart", "of", "Gold"];
142 let mut it = xs.into_iter().peekable();
143 // try before `peek()`
144 assert_eq!(it.next_if_eq(&"trillian"), None);
145 assert_eq!(it.next_if_eq(&"Heart"), Some("Heart"));
147 assert_eq!(it.peek(), Some(&"of"));
148 assert_eq!(it.next_if_eq(&"of"), Some("of"));
149 assert_eq!(it.next_if_eq(&"zaphod"), None);
150 // make sure `next()` still behaves
151 assert_eq!(it.next(), Some("Gold"));
153 // make sure comparison works for owned values
154 let xs = vec![String::from("Ludicrous"), "speed".into()];
155 let mut it = xs.into_iter().peekable();
156 // make sure basic functionality works
157 assert_eq!(it.next_if_eq("Ludicrous"), Some("Ludicrous".into()));
158 assert_eq!(it.next_if_eq("speed"), Some("speed".into()));
159 assert_eq!(it.next_if_eq(""), None);
162 fn test_iterator_peekable_mut() {
163 let mut it = vec![1, 2, 3].into_iter().peekable();
164 if let Some(p) = it.peek_mut() {
169 assert_eq!(it.collect::<Vec<_>>(), vec![5, 2, 3]);
172 fn test_iterator_peekable_remember_peek_none_1() {
173 // Check that the loop using .peek() terminates
174 let data = [1, 2, 3];
175 let mut iter = CycleIter::new(&data).peekable();
178 while let Some(_) = iter.next() {
179 let is_the_last = iter.peek().is_none();
180 assert_eq!(is_the_last, n == data.len() - 1);
186 assert_eq!(n, data.len());
189 fn test_iterator_peekable_remember_peek_none_2() {
191 let mut iter = CycleIter::new(&data).peekable();
193 assert_eq!(iter.peek(), None);
194 assert_eq!(iter.last(), None);
197 fn test_iterator_peekable_remember_peek_none_3() {
199 let mut iter = CycleIter::new(&data).peekable();
201 assert_eq!(iter.nth(0), Some(&0));
203 let mut iter = CycleIter::new(&data).peekable();
205 assert_eq!(iter.peek(), None);
206 assert_eq!(iter.nth(0), None);
209 fn test_peek_try_folds() {
210 let f = &|acc, x| i32::checked_add(2 * acc, x);
212 assert_eq!((1..20).peekable().try_fold(7, f), (1..20).try_fold(7, f));
213 assert_eq!((1..20).peekable().try_rfold(7, f), (1..20).try_rfold(7, f));
215 let mut iter = (1..20).peekable();
216 assert_eq!(iter.peek(), Some(&1));
217 assert_eq!(iter.try_fold(7, f), (1..20).try_fold(7, f));
219 let mut iter = (1..20).peekable();
220 assert_eq!(iter.peek(), Some(&1));
221 assert_eq!(iter.try_rfold(7, f), (1..20).try_rfold(7, f));
223 let mut iter = [100, 20, 30, 40, 50, 60, 70].iter().cloned().peekable();
224 assert_eq!(iter.peek(), Some(&100));
225 assert_eq!(iter.try_fold(0, i8::checked_add), None);
226 assert_eq!(iter.peek(), Some(&40));
228 let mut iter = [100, 20, 30, 40, 50, 60, 70].iter().cloned().peekable();
229 assert_eq!(iter.peek(), Some(&100));
230 assert_eq!(iter.try_rfold(0, i8::checked_add), None);
231 assert_eq!(iter.peek(), Some(&100));
232 assert_eq!(iter.next_back(), Some(50));
234 let mut iter = (2..5).peekable();
235 assert_eq!(iter.peek(), Some(&2));
236 assert_eq!(iter.try_for_each(Err), Err(2));
237 assert_eq!(iter.peek(), Some(&3));
238 assert_eq!(iter.try_for_each(Err), Err(3));
239 assert_eq!(iter.peek(), Some(&4));
240 assert_eq!(iter.try_for_each(Err), Err(4));
241 assert_eq!(iter.peek(), None);
242 assert_eq!(iter.try_for_each(Err), Ok(()));
244 let mut iter = (2..5).peekable();
245 assert_eq!(iter.peek(), Some(&2));
246 assert_eq!(iter.try_rfold((), |(), x| Err(x)), Err(4));
247 assert_eq!(iter.peek(), Some(&2));
248 assert_eq!(iter.try_rfold((), |(), x| Err(x)), Err(3));
249 assert_eq!(iter.peek(), Some(&2));
250 assert_eq!(iter.try_rfold((), |(), x| Err(x)), Err(2));
251 assert_eq!(iter.peek(), None);
252 assert_eq!(iter.try_rfold((), |(), x| Err(x)), Ok(()));
255 fn test_peekable_non_fused() {
256 let mut iter = NonFused::new(empty::<i32>()).peekable();
258 assert_eq!(iter.peek(), None);
259 assert_eq!(iter.next_back(), None);