]>
Commit | Line | Data |
---|---|---|
1a4d82fc JJ |
1 | // Copyright 2014 The Rust Project Developers. See the COPYRIGHT |
2 | // file at the top-level directory of this distribution and at | |
3 | // http://rust-lang.org/COPYRIGHT. | |
4 | // | |
5 | // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or | |
6 | // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license | |
7 | // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your | |
8 | // option. This file may not be copied, modified, or distributed | |
9 | // except according to those terms. | |
10 | ||
11 | use core::iter::*; | |
12 | use core::iter::order::*; | |
13 | use core::iter::MinMaxResult::*; | |
c34b1796 | 14 | use core::usize; |
1a4d82fc JJ |
15 | use core::cmp; |
16 | ||
17 | use test::Bencher; | |
18 | ||
19 | #[test] | |
20 | fn test_lt() { | |
c34b1796 | 21 | let empty: [isize; 0] = []; |
85aaf69f SL |
22 | let xs = [1,2,3]; |
23 | let ys = [1,2,0]; | |
1a4d82fc JJ |
24 | |
25 | assert!(!lt(xs.iter(), ys.iter())); | |
26 | assert!(!le(xs.iter(), ys.iter())); | |
27 | assert!( gt(xs.iter(), ys.iter())); | |
28 | assert!( ge(xs.iter(), ys.iter())); | |
29 | ||
30 | assert!( lt(ys.iter(), xs.iter())); | |
31 | assert!( le(ys.iter(), xs.iter())); | |
32 | assert!(!gt(ys.iter(), xs.iter())); | |
33 | assert!(!ge(ys.iter(), xs.iter())); | |
34 | ||
35 | assert!( lt(empty.iter(), xs.iter())); | |
36 | assert!( le(empty.iter(), xs.iter())); | |
37 | assert!(!gt(empty.iter(), xs.iter())); | |
38 | assert!(!ge(empty.iter(), xs.iter())); | |
39 | ||
40 | // Sequence with NaN | |
41 | let u = [1.0f64, 2.0]; | |
42 | let v = [0.0f64/0.0, 3.0]; | |
43 | ||
44 | assert!(!lt(u.iter(), v.iter())); | |
45 | assert!(!le(u.iter(), v.iter())); | |
46 | assert!(!gt(u.iter(), v.iter())); | |
47 | assert!(!ge(u.iter(), v.iter())); | |
48 | ||
49 | let a = [0.0f64/0.0]; | |
50 | let b = [1.0f64]; | |
51 | let c = [2.0f64]; | |
52 | ||
53 | assert!(lt(a.iter(), b.iter()) == (a[0] < b[0])); | |
54 | assert!(le(a.iter(), b.iter()) == (a[0] <= b[0])); | |
55 | assert!(gt(a.iter(), b.iter()) == (a[0] > b[0])); | |
56 | assert!(ge(a.iter(), b.iter()) == (a[0] >= b[0])); | |
57 | ||
58 | assert!(lt(c.iter(), b.iter()) == (c[0] < b[0])); | |
59 | assert!(le(c.iter(), b.iter()) == (c[0] <= b[0])); | |
60 | assert!(gt(c.iter(), b.iter()) == (c[0] > b[0])); | |
61 | assert!(ge(c.iter(), b.iter()) == (c[0] >= b[0])); | |
62 | } | |
63 | ||
64 | #[test] | |
65 | fn test_multi_iter() { | |
85aaf69f SL |
66 | let xs = [1,2,3,4]; |
67 | let ys = [4,3,2,1]; | |
1a4d82fc JJ |
68 | assert!(eq(xs.iter(), ys.iter().rev())); |
69 | assert!(lt(xs.iter(), xs.iter().skip(2))); | |
70 | } | |
71 | ||
72 | #[test] | |
73 | fn test_counter_from_iter() { | |
c34b1796 AL |
74 | let it = (0..).step_by(5).take(10); |
75 | let xs: Vec<isize> = FromIterator::from_iter(it); | |
76 | assert_eq!(xs, [0, 5, 10, 15, 20, 25, 30, 35, 40, 45]); | |
1a4d82fc JJ |
77 | } |
78 | ||
79 | #[test] | |
80 | fn test_iterator_chain() { | |
85aaf69f SL |
81 | let xs = [0, 1, 2, 3, 4, 5]; |
82 | let ys = [30, 40, 50, 60]; | |
1a4d82fc | 83 | let expected = [0, 1, 2, 3, 4, 5, 30, 40, 50, 60]; |
c34b1796 | 84 | let it = xs.iter().chain(ys.iter()); |
1a4d82fc JJ |
85 | let mut i = 0; |
86 | for &x in it { | |
87 | assert_eq!(x, expected[i]); | |
88 | i += 1; | |
89 | } | |
90 | assert_eq!(i, expected.len()); | |
91 | ||
c34b1796 AL |
92 | let ys = (30..).step_by(10).take(4); |
93 | let it = xs.iter().cloned().chain(ys); | |
1a4d82fc JJ |
94 | let mut i = 0; |
95 | for x in it { | |
96 | assert_eq!(x, expected[i]); | |
97 | i += 1; | |
98 | } | |
99 | assert_eq!(i, expected.len()); | |
100 | } | |
101 | ||
102 | #[test] | |
103 | fn test_filter_map() { | |
c34b1796 | 104 | let it = (0..).step_by(1).take(10) |
1a4d82fc | 105 | .filter_map(|x| if x % 2 == 0 { Some(x*x) } else { None }); |
c34b1796 | 106 | assert_eq!(it.collect::<Vec<usize>>(), [0*0, 2*2, 4*4, 6*6, 8*8]); |
1a4d82fc JJ |
107 | } |
108 | ||
109 | #[test] | |
110 | fn test_iterator_enumerate() { | |
85aaf69f | 111 | let xs = [0, 1, 2, 3, 4, 5]; |
c34b1796 | 112 | let it = xs.iter().enumerate(); |
1a4d82fc JJ |
113 | for (i, &x) in it { |
114 | assert_eq!(i, x); | |
115 | } | |
116 | } | |
117 | ||
118 | #[test] | |
119 | fn test_iterator_peekable() { | |
85aaf69f SL |
120 | let xs = vec![0, 1, 2, 3, 4, 5]; |
121 | let mut it = xs.iter().cloned().peekable(); | |
122 | ||
123 | assert_eq!(it.len(), 6); | |
1a4d82fc | 124 | assert_eq!(it.peek().unwrap(), &0); |
85aaf69f | 125 | assert_eq!(it.len(), 6); |
1a4d82fc | 126 | assert_eq!(it.next().unwrap(), 0); |
85aaf69f | 127 | assert_eq!(it.len(), 5); |
1a4d82fc | 128 | assert_eq!(it.next().unwrap(), 1); |
85aaf69f | 129 | assert_eq!(it.len(), 4); |
1a4d82fc | 130 | assert_eq!(it.next().unwrap(), 2); |
85aaf69f | 131 | assert_eq!(it.len(), 3); |
1a4d82fc | 132 | assert_eq!(it.peek().unwrap(), &3); |
85aaf69f | 133 | assert_eq!(it.len(), 3); |
1a4d82fc | 134 | assert_eq!(it.peek().unwrap(), &3); |
85aaf69f | 135 | assert_eq!(it.len(), 3); |
1a4d82fc | 136 | assert_eq!(it.next().unwrap(), 3); |
85aaf69f | 137 | assert_eq!(it.len(), 2); |
1a4d82fc | 138 | assert_eq!(it.next().unwrap(), 4); |
85aaf69f | 139 | assert_eq!(it.len(), 1); |
1a4d82fc | 140 | assert_eq!(it.peek().unwrap(), &5); |
85aaf69f | 141 | assert_eq!(it.len(), 1); |
1a4d82fc | 142 | assert_eq!(it.next().unwrap(), 5); |
85aaf69f | 143 | assert_eq!(it.len(), 0); |
1a4d82fc | 144 | assert!(it.peek().is_none()); |
85aaf69f | 145 | assert_eq!(it.len(), 0); |
1a4d82fc | 146 | assert!(it.next().is_none()); |
85aaf69f | 147 | assert_eq!(it.len(), 0); |
1a4d82fc JJ |
148 | } |
149 | ||
150 | #[test] | |
151 | fn test_iterator_take_while() { | |
85aaf69f SL |
152 | let xs = [0, 1, 2, 3, 5, 13, 15, 16, 17, 19]; |
153 | let ys = [0, 1, 2, 3, 5, 13]; | |
c34b1796 | 154 | let it = xs.iter().take_while(|&x| *x < 15); |
1a4d82fc JJ |
155 | let mut i = 0; |
156 | for x in it { | |
157 | assert_eq!(*x, ys[i]); | |
158 | i += 1; | |
159 | } | |
160 | assert_eq!(i, ys.len()); | |
161 | } | |
162 | ||
163 | #[test] | |
164 | fn test_iterator_skip_while() { | |
85aaf69f | 165 | let xs = [0, 1, 2, 3, 5, 13, 15, 16, 17, 19]; |
1a4d82fc | 166 | let ys = [15, 16, 17, 19]; |
c34b1796 | 167 | let it = xs.iter().skip_while(|&x| *x < 15); |
1a4d82fc JJ |
168 | let mut i = 0; |
169 | for x in it { | |
170 | assert_eq!(*x, ys[i]); | |
171 | i += 1; | |
172 | } | |
173 | assert_eq!(i, ys.len()); | |
174 | } | |
175 | ||
176 | #[test] | |
177 | fn test_iterator_skip() { | |
85aaf69f | 178 | let xs = [0, 1, 2, 3, 5, 13, 15, 16, 17, 19, 20, 30]; |
1a4d82fc JJ |
179 | let ys = [13, 15, 16, 17, 19, 20, 30]; |
180 | let mut it = xs.iter().skip(5); | |
181 | let mut i = 0; | |
85aaf69f | 182 | while let Some(&x) = it.next() { |
1a4d82fc JJ |
183 | assert_eq!(x, ys[i]); |
184 | i += 1; | |
85aaf69f | 185 | assert_eq!(it.len(), xs.len()-5-i); |
1a4d82fc JJ |
186 | } |
187 | assert_eq!(i, ys.len()); | |
85aaf69f | 188 | assert_eq!(it.len(), 0); |
1a4d82fc JJ |
189 | } |
190 | ||
191 | #[test] | |
192 | fn test_iterator_take() { | |
85aaf69f SL |
193 | let xs = [0, 1, 2, 3, 5, 13, 15, 16, 17, 19]; |
194 | let ys = [0, 1, 2, 3, 5]; | |
1a4d82fc JJ |
195 | let mut it = xs.iter().take(5); |
196 | let mut i = 0; | |
85aaf69f SL |
197 | assert_eq!(it.len(), 5); |
198 | while let Some(&x) = it.next() { | |
199 | assert_eq!(x, ys[i]); | |
200 | i += 1; | |
201 | assert_eq!(it.len(), 5-i); | |
202 | } | |
203 | assert_eq!(i, ys.len()); | |
204 | assert_eq!(it.len(), 0); | |
205 | } | |
206 | ||
207 | #[test] | |
208 | fn test_iterator_take_short() { | |
209 | let xs = [0, 1, 2, 3]; | |
210 | let ys = [0, 1, 2, 3]; | |
211 | let mut it = xs.iter().take(5); | |
212 | let mut i = 0; | |
213 | assert_eq!(it.len(), 4); | |
214 | while let Some(&x) = it.next() { | |
1a4d82fc JJ |
215 | assert_eq!(x, ys[i]); |
216 | i += 1; | |
85aaf69f | 217 | assert_eq!(it.len(), 4-i); |
1a4d82fc JJ |
218 | } |
219 | assert_eq!(i, ys.len()); | |
85aaf69f | 220 | assert_eq!(it.len(), 0); |
1a4d82fc JJ |
221 | } |
222 | ||
223 | #[test] | |
224 | fn test_iterator_scan() { | |
225 | // test the type inference | |
c34b1796 AL |
226 | fn add(old: &mut isize, new: &usize) -> Option<f64> { |
227 | *old += *new as isize; | |
1a4d82fc JJ |
228 | Some(*old as f64) |
229 | } | |
85aaf69f | 230 | let xs = [0, 1, 2, 3, 4]; |
1a4d82fc JJ |
231 | let ys = [0f64, 1.0, 3.0, 6.0, 10.0]; |
232 | ||
c34b1796 | 233 | let it = xs.iter().scan(0, add); |
1a4d82fc JJ |
234 | let mut i = 0; |
235 | for x in it { | |
236 | assert_eq!(x, ys[i]); | |
237 | i += 1; | |
238 | } | |
239 | assert_eq!(i, ys.len()); | |
240 | } | |
241 | ||
242 | #[test] | |
243 | fn test_iterator_flat_map() { | |
85aaf69f SL |
244 | let xs = [0, 3, 6]; |
245 | let ys = [0, 1, 2, 3, 4, 5, 6, 7, 8]; | |
c34b1796 | 246 | let it = xs.iter().flat_map(|&x| (x..).step_by(1).take(3)); |
1a4d82fc JJ |
247 | let mut i = 0; |
248 | for x in it { | |
249 | assert_eq!(x, ys[i]); | |
250 | i += 1; | |
251 | } | |
252 | assert_eq!(i, ys.len()); | |
253 | } | |
254 | ||
255 | #[test] | |
256 | fn test_inspect() { | |
85aaf69f SL |
257 | let xs = [1, 2, 3, 4]; |
258 | let mut n = 0; | |
1a4d82fc JJ |
259 | |
260 | let ys = xs.iter() | |
85aaf69f | 261 | .cloned() |
1a4d82fc | 262 | .inspect(|_| n += 1) |
c34b1796 | 263 | .collect::<Vec<usize>>(); |
1a4d82fc JJ |
264 | |
265 | assert_eq!(n, xs.len()); | |
85aaf69f | 266 | assert_eq!(&xs[..], &ys[..]); |
1a4d82fc JJ |
267 | } |
268 | ||
269 | #[test] | |
270 | fn test_unfoldr() { | |
c34b1796 | 271 | fn count(st: &mut usize) -> Option<usize> { |
1a4d82fc JJ |
272 | if *st < 10 { |
273 | let ret = Some(*st); | |
274 | *st += 1; | |
275 | ret | |
276 | } else { | |
277 | None | |
278 | } | |
279 | } | |
280 | ||
c34b1796 | 281 | let it = Unfold::new(0, count); |
1a4d82fc JJ |
282 | let mut i = 0; |
283 | for counted in it { | |
284 | assert_eq!(counted, i); | |
285 | i += 1; | |
286 | } | |
287 | assert_eq!(i, 10); | |
288 | } | |
289 | ||
290 | #[test] | |
291 | fn test_cycle() { | |
292 | let cycle_len = 3; | |
c34b1796 AL |
293 | let it = (0..).step_by(1).take(cycle_len).cycle(); |
294 | assert_eq!(it.size_hint(), (usize::MAX, None)); | |
1a4d82fc JJ |
295 | for (i, x) in it.take(100).enumerate() { |
296 | assert_eq!(i % cycle_len, x); | |
297 | } | |
298 | ||
c34b1796 | 299 | let mut it = (0..).step_by(1).take(0).cycle(); |
1a4d82fc JJ |
300 | assert_eq!(it.size_hint(), (0, Some(0))); |
301 | assert_eq!(it.next(), None); | |
302 | } | |
303 | ||
304 | #[test] | |
305 | fn test_iterator_nth() { | |
85aaf69f SL |
306 | let v: &[_] = &[0, 1, 2, 3, 4]; |
307 | for i in 0..v.len() { | |
1a4d82fc JJ |
308 | assert_eq!(v.iter().nth(i).unwrap(), &v[i]); |
309 | } | |
310 | assert_eq!(v.iter().nth(v.len()), None); | |
311 | } | |
312 | ||
313 | #[test] | |
314 | fn test_iterator_last() { | |
85aaf69f | 315 | let v: &[_] = &[0, 1, 2, 3, 4]; |
1a4d82fc JJ |
316 | assert_eq!(v.iter().last().unwrap(), &4); |
317 | assert_eq!(v[..1].iter().last().unwrap(), &0); | |
318 | } | |
319 | ||
320 | #[test] | |
321 | fn test_iterator_len() { | |
85aaf69f | 322 | let v: &[_] = &[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]; |
1a4d82fc JJ |
323 | assert_eq!(v[..4].iter().count(), 4); |
324 | assert_eq!(v[..10].iter().count(), 10); | |
85aaf69f | 325 | assert_eq!(v[..0].iter().count(), 0); |
1a4d82fc JJ |
326 | } |
327 | ||
328 | #[test] | |
329 | fn test_iterator_sum() { | |
85aaf69f | 330 | let v: &[i32] = &[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]; |
9346a6ac AL |
331 | assert_eq!(v[..4].iter().cloned().sum::<i32>(), 6); |
332 | assert_eq!(v.iter().cloned().sum::<i32>(), 55); | |
333 | assert_eq!(v[..0].iter().cloned().sum::<i32>(), 0); | |
1a4d82fc JJ |
334 | } |
335 | ||
336 | #[test] | |
337 | fn test_iterator_product() { | |
85aaf69f | 338 | let v: &[i32] = &[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]; |
9346a6ac AL |
339 | assert_eq!(v[..4].iter().cloned().product::<i32>(), 0); |
340 | assert_eq!(v[1..5].iter().cloned().product::<i32>(), 24); | |
341 | assert_eq!(v[..0].iter().cloned().product::<i32>(), 1); | |
1a4d82fc JJ |
342 | } |
343 | ||
344 | #[test] | |
345 | fn test_iterator_max() { | |
85aaf69f SL |
346 | let v: &[_] = &[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]; |
347 | assert_eq!(v[..4].iter().cloned().max(), Some(3)); | |
348 | assert_eq!(v.iter().cloned().max(), Some(10)); | |
349 | assert_eq!(v[..0].iter().cloned().max(), None); | |
1a4d82fc JJ |
350 | } |
351 | ||
352 | #[test] | |
353 | fn test_iterator_min() { | |
85aaf69f SL |
354 | let v: &[_] = &[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]; |
355 | assert_eq!(v[..4].iter().cloned().min(), Some(0)); | |
356 | assert_eq!(v.iter().cloned().min(), Some(0)); | |
357 | assert_eq!(v[..0].iter().cloned().min(), None); | |
1a4d82fc JJ |
358 | } |
359 | ||
360 | #[test] | |
361 | fn test_iterator_size_hint() { | |
c34b1796 | 362 | let c = (0..).step_by(1); |
85aaf69f SL |
363 | let v: &[_] = &[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]; |
364 | let v2 = &[10, 11, 12]; | |
1a4d82fc JJ |
365 | let vi = v.iter(); |
366 | ||
c34b1796 | 367 | assert_eq!(c.size_hint(), (usize::MAX, None)); |
85aaf69f SL |
368 | assert_eq!(vi.clone().size_hint(), (10, Some(10))); |
369 | ||
370 | assert_eq!(c.clone().take(5).size_hint(), (5, Some(5))); | |
371 | assert_eq!(c.clone().skip(5).size_hint().1, None); | |
372 | assert_eq!(c.clone().take_while(|_| false).size_hint(), (0, None)); | |
373 | assert_eq!(c.clone().skip_while(|_| false).size_hint(), (0, None)); | |
c34b1796 AL |
374 | assert_eq!(c.clone().enumerate().size_hint(), (usize::MAX, None)); |
375 | assert_eq!(c.clone().chain(vi.clone().cloned()).size_hint(), (usize::MAX, None)); | |
85aaf69f SL |
376 | assert_eq!(c.clone().zip(vi.clone()).size_hint(), (10, Some(10))); |
377 | assert_eq!(c.clone().scan(0, |_,_| Some(0)).size_hint(), (0, None)); | |
378 | assert_eq!(c.clone().filter(|_| false).size_hint(), (0, None)); | |
c34b1796 | 379 | assert_eq!(c.clone().map(|_| 0).size_hint(), (usize::MAX, None)); |
85aaf69f SL |
380 | assert_eq!(c.filter_map(|_| Some(0)).size_hint(), (0, None)); |
381 | ||
382 | assert_eq!(vi.clone().take(5).size_hint(), (5, Some(5))); | |
383 | assert_eq!(vi.clone().take(12).size_hint(), (10, Some(10))); | |
384 | assert_eq!(vi.clone().skip(3).size_hint(), (7, Some(7))); | |
385 | assert_eq!(vi.clone().skip(12).size_hint(), (0, Some(0))); | |
386 | assert_eq!(vi.clone().take_while(|_| false).size_hint(), (0, Some(10))); | |
387 | assert_eq!(vi.clone().skip_while(|_| false).size_hint(), (0, Some(10))); | |
388 | assert_eq!(vi.clone().enumerate().size_hint(), (10, Some(10))); | |
389 | assert_eq!(vi.clone().chain(v2.iter()).size_hint(), (13, Some(13))); | |
390 | assert_eq!(vi.clone().zip(v2.iter()).size_hint(), (3, Some(3))); | |
391 | assert_eq!(vi.clone().scan(0, |_,_| Some(0)).size_hint(), (0, Some(10))); | |
392 | assert_eq!(vi.clone().filter(|_| false).size_hint(), (0, Some(10))); | |
393 | assert_eq!(vi.clone().map(|&i| i+1).size_hint(), (10, Some(10))); | |
394 | assert_eq!(vi.filter_map(|_| Some(0)).size_hint(), (0, Some(10))); | |
1a4d82fc JJ |
395 | } |
396 | ||
397 | #[test] | |
398 | fn test_collect() { | |
85aaf69f | 399 | let a = vec![1, 2, 3, 4, 5]; |
c34b1796 | 400 | let b: Vec<isize> = a.iter().cloned().collect(); |
1a4d82fc JJ |
401 | assert!(a == b); |
402 | } | |
403 | ||
404 | #[test] | |
405 | fn test_all() { | |
c34b1796 AL |
406 | // FIXME (#22405): Replace `Box::new` with `box` here when/if possible. |
407 | let v: Box<[isize]> = Box::new([1, 2, 3, 4, 5]); | |
1a4d82fc JJ |
408 | assert!(v.iter().all(|&x| x < 10)); |
409 | assert!(!v.iter().all(|&x| x % 2 == 0)); | |
410 | assert!(!v.iter().all(|&x| x > 100)); | |
85aaf69f | 411 | assert!(v[..0].iter().all(|_| panic!())); |
1a4d82fc JJ |
412 | } |
413 | ||
414 | #[test] | |
415 | fn test_any() { | |
c34b1796 AL |
416 | // FIXME (#22405): Replace `Box::new` with `box` here when/if possible. |
417 | let v: Box<[isize]> = Box::new([1, 2, 3, 4, 5]); | |
1a4d82fc JJ |
418 | assert!(v.iter().any(|&x| x < 10)); |
419 | assert!(v.iter().any(|&x| x % 2 == 0)); | |
420 | assert!(!v.iter().any(|&x| x > 100)); | |
85aaf69f | 421 | assert!(!v[..0].iter().any(|_| panic!())); |
1a4d82fc JJ |
422 | } |
423 | ||
424 | #[test] | |
425 | fn test_find() { | |
c34b1796 | 426 | let v: &[isize] = &[1, 3, 9, 27, 103, 14, 11]; |
1a4d82fc JJ |
427 | assert_eq!(*v.iter().find(|&&x| x & 1 == 0).unwrap(), 14); |
428 | assert_eq!(*v.iter().find(|&&x| x % 3 == 0).unwrap(), 3); | |
429 | assert!(v.iter().find(|&&x| x % 12 == 0).is_none()); | |
430 | } | |
431 | ||
432 | #[test] | |
433 | fn test_position() { | |
85aaf69f | 434 | let v = &[1, 3, 9, 27, 103, 14, 11]; |
1a4d82fc JJ |
435 | assert_eq!(v.iter().position(|x| *x & 1 == 0).unwrap(), 5); |
436 | assert_eq!(v.iter().position(|x| *x % 3 == 0).unwrap(), 1); | |
437 | assert!(v.iter().position(|x| *x % 12 == 0).is_none()); | |
438 | } | |
439 | ||
440 | #[test] | |
441 | fn test_count() { | |
85aaf69f | 442 | let xs = &[1, 2, 2, 1, 5, 9, 0, 2]; |
1a4d82fc JJ |
443 | assert_eq!(xs.iter().filter(|x| **x == 2).count(), 3); |
444 | assert_eq!(xs.iter().filter(|x| **x == 5).count(), 1); | |
445 | assert_eq!(xs.iter().filter(|x| **x == 95).count(), 0); | |
446 | } | |
447 | ||
448 | #[test] | |
449 | fn test_max_by() { | |
c34b1796 | 450 | let xs: &[isize] = &[-3, 0, 1, 5, -10]; |
1a4d82fc JJ |
451 | assert_eq!(*xs.iter().max_by(|x| x.abs()).unwrap(), -10); |
452 | } | |
453 | ||
454 | #[test] | |
455 | fn test_min_by() { | |
c34b1796 | 456 | let xs: &[isize] = &[-3, 0, 1, 5, -10]; |
1a4d82fc JJ |
457 | assert_eq!(*xs.iter().min_by(|x| x.abs()).unwrap(), 0); |
458 | } | |
459 | ||
460 | #[test] | |
461 | fn test_by_ref() { | |
85aaf69f | 462 | let mut xs = 0..10; |
1a4d82fc JJ |
463 | // sum the first five values |
464 | let partial_sum = xs.by_ref().take(5).fold(0, |a, b| a + b); | |
465 | assert_eq!(partial_sum, 10); | |
466 | assert_eq!(xs.next(), Some(5)); | |
467 | } | |
468 | ||
469 | #[test] | |
470 | fn test_rev() { | |
85aaf69f | 471 | let xs = [2, 4, 6, 8, 10, 12, 14, 16]; |
1a4d82fc JJ |
472 | let mut it = xs.iter(); |
473 | it.next(); | |
474 | it.next(); | |
c34b1796 | 475 | assert!(it.rev().cloned().collect::<Vec<isize>>() == |
1a4d82fc JJ |
476 | vec![16, 14, 12, 10, 8, 6]); |
477 | } | |
478 | ||
479 | #[test] | |
480 | fn test_cloned() { | |
481 | let xs = [2u8, 4, 6, 8]; | |
482 | ||
483 | let mut it = xs.iter().cloned(); | |
484 | assert_eq!(it.len(), 4); | |
485 | assert_eq!(it.next(), Some(2)); | |
486 | assert_eq!(it.len(), 3); | |
487 | assert_eq!(it.next(), Some(4)); | |
488 | assert_eq!(it.len(), 2); | |
489 | assert_eq!(it.next_back(), Some(8)); | |
490 | assert_eq!(it.len(), 1); | |
491 | assert_eq!(it.next_back(), Some(6)); | |
492 | assert_eq!(it.len(), 0); | |
493 | assert_eq!(it.next_back(), None); | |
494 | } | |
495 | ||
496 | #[test] | |
497 | fn test_double_ended_map() { | |
85aaf69f | 498 | let xs = [1, 2, 3, 4, 5, 6]; |
1a4d82fc JJ |
499 | let mut it = xs.iter().map(|&x| x * -1); |
500 | assert_eq!(it.next(), Some(-1)); | |
501 | assert_eq!(it.next(), Some(-2)); | |
502 | assert_eq!(it.next_back(), Some(-6)); | |
503 | assert_eq!(it.next_back(), Some(-5)); | |
504 | assert_eq!(it.next(), Some(-3)); | |
505 | assert_eq!(it.next_back(), Some(-4)); | |
506 | assert_eq!(it.next(), None); | |
507 | } | |
508 | ||
509 | #[test] | |
510 | fn test_double_ended_enumerate() { | |
85aaf69f SL |
511 | let xs = [1, 2, 3, 4, 5, 6]; |
512 | let mut it = xs.iter().cloned().enumerate(); | |
1a4d82fc JJ |
513 | assert_eq!(it.next(), Some((0, 1))); |
514 | assert_eq!(it.next(), Some((1, 2))); | |
515 | assert_eq!(it.next_back(), Some((5, 6))); | |
516 | assert_eq!(it.next_back(), Some((4, 5))); | |
517 | assert_eq!(it.next_back(), Some((3, 4))); | |
518 | assert_eq!(it.next_back(), Some((2, 3))); | |
519 | assert_eq!(it.next(), None); | |
520 | } | |
521 | ||
522 | #[test] | |
523 | fn test_double_ended_zip() { | |
85aaf69f SL |
524 | let xs = [1, 2, 3, 4, 5, 6]; |
525 | let ys = [1, 2, 3, 7]; | |
526 | let a = xs.iter().cloned(); | |
527 | let b = ys.iter().cloned(); | |
1a4d82fc JJ |
528 | let mut it = a.zip(b); |
529 | assert_eq!(it.next(), Some((1, 1))); | |
530 | assert_eq!(it.next(), Some((2, 2))); | |
531 | assert_eq!(it.next_back(), Some((4, 7))); | |
532 | assert_eq!(it.next_back(), Some((3, 3))); | |
533 | assert_eq!(it.next(), None); | |
534 | } | |
535 | ||
536 | #[test] | |
537 | fn test_double_ended_filter() { | |
85aaf69f | 538 | let xs = [1, 2, 3, 4, 5, 6]; |
1a4d82fc JJ |
539 | let mut it = xs.iter().filter(|&x| *x & 1 == 0); |
540 | assert_eq!(it.next_back().unwrap(), &6); | |
541 | assert_eq!(it.next_back().unwrap(), &4); | |
542 | assert_eq!(it.next().unwrap(), &2); | |
543 | assert_eq!(it.next_back(), None); | |
544 | } | |
545 | ||
546 | #[test] | |
547 | fn test_double_ended_filter_map() { | |
85aaf69f | 548 | let xs = [1, 2, 3, 4, 5, 6]; |
1a4d82fc JJ |
549 | let mut it = xs.iter().filter_map(|&x| if x & 1 == 0 { Some(x * 2) } else { None }); |
550 | assert_eq!(it.next_back().unwrap(), 12); | |
551 | assert_eq!(it.next_back().unwrap(), 8); | |
552 | assert_eq!(it.next().unwrap(), 4); | |
553 | assert_eq!(it.next_back(), None); | |
554 | } | |
555 | ||
556 | #[test] | |
557 | fn test_double_ended_chain() { | |
85aaf69f SL |
558 | let xs = [1, 2, 3, 4, 5]; |
559 | let ys = [7, 9, 11]; | |
1a4d82fc JJ |
560 | let mut it = xs.iter().chain(ys.iter()).rev(); |
561 | assert_eq!(it.next().unwrap(), &11); | |
562 | assert_eq!(it.next().unwrap(), &9); | |
563 | assert_eq!(it.next_back().unwrap(), &1); | |
564 | assert_eq!(it.next_back().unwrap(), &2); | |
565 | assert_eq!(it.next_back().unwrap(), &3); | |
566 | assert_eq!(it.next_back().unwrap(), &4); | |
567 | assert_eq!(it.next_back().unwrap(), &5); | |
568 | assert_eq!(it.next_back().unwrap(), &7); | |
569 | assert_eq!(it.next_back(), None); | |
570 | } | |
571 | ||
572 | #[test] | |
573 | fn test_rposition() { | |
c34b1796 AL |
574 | fn f(xy: &(isize, char)) -> bool { let (_x, y) = *xy; y == 'b' } |
575 | fn g(xy: &(isize, char)) -> bool { let (_x, y) = *xy; y == 'd' } | |
85aaf69f | 576 | let v = [(0, 'a'), (1, 'b'), (2, 'c'), (3, 'b')]; |
1a4d82fc | 577 | |
85aaf69f | 578 | assert_eq!(v.iter().rposition(f), Some(3)); |
1a4d82fc JJ |
579 | assert!(v.iter().rposition(g).is_none()); |
580 | } | |
581 | ||
582 | #[test] | |
c34b1796 | 583 | #[should_panic] |
1a4d82fc | 584 | fn test_rposition_panic() { |
c34b1796 AL |
585 | let v: [(Box<_>, Box<_>); 4] = |
586 | [(box 0, box 0), (box 0, box 0), | |
587 | (box 0, box 0), (box 0, box 0)]; | |
85aaf69f | 588 | let mut i = 0; |
1a4d82fc JJ |
589 | v.iter().rposition(|_elt| { |
590 | if i == 2 { | |
591 | panic!() | |
592 | } | |
593 | i += 1; | |
594 | false | |
595 | }); | |
596 | } | |
597 | ||
598 | ||
599 | #[cfg(test)] | |
c34b1796 | 600 | fn check_randacc_iter<A, T>(a: T, len: usize) where |
1a4d82fc JJ |
601 | A: PartialEq, |
602 | T: Clone + RandomAccessIterator + Iterator<Item=A>, | |
603 | { | |
604 | let mut b = a.clone(); | |
605 | assert_eq!(len, b.indexable()); | |
85aaf69f | 606 | let mut n = 0; |
1a4d82fc JJ |
607 | for (i, elt) in a.enumerate() { |
608 | assert!(Some(elt) == b.idx(i)); | |
609 | n += 1; | |
610 | } | |
611 | assert_eq!(n, len); | |
612 | assert!(None == b.idx(n)); | |
613 | // call recursively to check after picking off an element | |
614 | if len > 0 { | |
615 | b.next(); | |
616 | check_randacc_iter(b, len-1); | |
617 | } | |
618 | } | |
619 | ||
620 | ||
621 | #[test] | |
622 | fn test_double_ended_flat_map() { | |
85aaf69f SL |
623 | let u = [0,1]; |
624 | let v = [5,6,7,8]; | |
625 | let mut it = u.iter().flat_map(|x| v[*x..v.len()].iter()); | |
1a4d82fc JJ |
626 | assert_eq!(it.next_back().unwrap(), &8); |
627 | assert_eq!(it.next().unwrap(), &5); | |
628 | assert_eq!(it.next_back().unwrap(), &7); | |
629 | assert_eq!(it.next_back().unwrap(), &6); | |
630 | assert_eq!(it.next_back().unwrap(), &8); | |
631 | assert_eq!(it.next().unwrap(), &6); | |
632 | assert_eq!(it.next_back().unwrap(), &7); | |
633 | assert_eq!(it.next_back(), None); | |
634 | assert_eq!(it.next(), None); | |
635 | assert_eq!(it.next_back(), None); | |
636 | } | |
637 | ||
638 | #[test] | |
639 | fn test_random_access_chain() { | |
85aaf69f SL |
640 | let xs = [1, 2, 3, 4, 5]; |
641 | let ys = [7, 9, 11]; | |
1a4d82fc JJ |
642 | let mut it = xs.iter().chain(ys.iter()); |
643 | assert_eq!(it.idx(0).unwrap(), &1); | |
644 | assert_eq!(it.idx(5).unwrap(), &7); | |
645 | assert_eq!(it.idx(7).unwrap(), &11); | |
646 | assert!(it.idx(8).is_none()); | |
647 | ||
648 | it.next(); | |
649 | it.next(); | |
650 | it.next_back(); | |
651 | ||
652 | assert_eq!(it.idx(0).unwrap(), &3); | |
653 | assert_eq!(it.idx(4).unwrap(), &9); | |
654 | assert!(it.idx(6).is_none()); | |
655 | ||
656 | check_randacc_iter(it, xs.len() + ys.len() - 3); | |
657 | } | |
658 | ||
659 | #[test] | |
660 | fn test_random_access_enumerate() { | |
85aaf69f | 661 | let xs = [1, 2, 3, 4, 5]; |
1a4d82fc JJ |
662 | check_randacc_iter(xs.iter().enumerate(), xs.len()); |
663 | } | |
664 | ||
665 | #[test] | |
666 | fn test_random_access_rev() { | |
85aaf69f | 667 | let xs = [1, 2, 3, 4, 5]; |
1a4d82fc JJ |
668 | check_randacc_iter(xs.iter().rev(), xs.len()); |
669 | let mut it = xs.iter().rev(); | |
670 | it.next(); | |
671 | it.next_back(); | |
672 | it.next(); | |
673 | check_randacc_iter(it, xs.len() - 3); | |
674 | } | |
675 | ||
676 | #[test] | |
677 | fn test_random_access_zip() { | |
85aaf69f SL |
678 | let xs = [1, 2, 3, 4, 5]; |
679 | let ys = [7, 9, 11]; | |
1a4d82fc JJ |
680 | check_randacc_iter(xs.iter().zip(ys.iter()), cmp::min(xs.len(), ys.len())); |
681 | } | |
682 | ||
683 | #[test] | |
684 | fn test_random_access_take() { | |
85aaf69f | 685 | let xs = [1, 2, 3, 4, 5]; |
c34b1796 | 686 | let empty: &[isize] = &[]; |
1a4d82fc JJ |
687 | check_randacc_iter(xs.iter().take(3), 3); |
688 | check_randacc_iter(xs.iter().take(20), xs.len()); | |
689 | check_randacc_iter(xs.iter().take(0), 0); | |
690 | check_randacc_iter(empty.iter().take(2), 0); | |
691 | } | |
692 | ||
693 | #[test] | |
694 | fn test_random_access_skip() { | |
85aaf69f | 695 | let xs = [1, 2, 3, 4, 5]; |
c34b1796 | 696 | let empty: &[isize] = &[]; |
1a4d82fc JJ |
697 | check_randacc_iter(xs.iter().skip(2), xs.len() - 2); |
698 | check_randacc_iter(empty.iter().skip(2), 0); | |
699 | } | |
700 | ||
701 | #[test] | |
702 | fn test_random_access_inspect() { | |
85aaf69f | 703 | let xs = [1, 2, 3, 4, 5]; |
1a4d82fc JJ |
704 | |
705 | // test .map and .inspect that don't implement Clone | |
706 | let mut it = xs.iter().inspect(|_| {}); | |
707 | assert_eq!(xs.len(), it.indexable()); | |
708 | for (i, elt) in xs.iter().enumerate() { | |
709 | assert_eq!(Some(elt), it.idx(i)); | |
710 | } | |
711 | ||
712 | } | |
713 | ||
714 | #[test] | |
715 | fn test_random_access_map() { | |
85aaf69f | 716 | let xs = [1, 2, 3, 4, 5]; |
1a4d82fc | 717 | |
85aaf69f | 718 | let mut it = xs.iter().cloned(); |
1a4d82fc JJ |
719 | assert_eq!(xs.len(), it.indexable()); |
720 | for (i, elt) in xs.iter().enumerate() { | |
721 | assert_eq!(Some(*elt), it.idx(i)); | |
722 | } | |
723 | } | |
724 | ||
725 | #[test] | |
726 | fn test_random_access_cycle() { | |
85aaf69f | 727 | let xs = [1, 2, 3, 4, 5]; |
c34b1796 | 728 | let empty: &[isize] = &[]; |
1a4d82fc JJ |
729 | check_randacc_iter(xs.iter().cycle().take(27), 27); |
730 | check_randacc_iter(empty.iter().cycle(), 0); | |
731 | } | |
732 | ||
733 | #[test] | |
734 | fn test_double_ended_range() { | |
c34b1796 | 735 | assert_eq!((11..14).rev().collect::<Vec<_>>(), [13, 12, 11]); |
85aaf69f | 736 | for _ in (10..0).rev() { |
1a4d82fc JJ |
737 | panic!("unreachable"); |
738 | } | |
739 | ||
c34b1796 | 740 | assert_eq!((11..14).rev().collect::<Vec<_>>(), [13, 12, 11]); |
85aaf69f | 741 | for _ in (10..0).rev() { |
1a4d82fc JJ |
742 | panic!("unreachable"); |
743 | } | |
744 | } | |
745 | ||
746 | #[test] | |
747 | fn test_range() { | |
c34b1796 AL |
748 | assert_eq!((0..5).collect::<Vec<_>>(), [0, 1, 2, 3, 4]); |
749 | assert_eq!((-10..-1).collect::<Vec<_>>(), [-10, -9, -8, -7, -6, -5, -4, -3, -2]); | |
750 | assert_eq!((0..5).rev().collect::<Vec<_>>(), [4, 3, 2, 1, 0]); | |
85aaf69f SL |
751 | assert_eq!((200..-5).count(), 0); |
752 | assert_eq!((200..-5).rev().count(), 0); | |
753 | assert_eq!((200..200).count(), 0); | |
754 | assert_eq!((200..200).rev().count(), 0); | |
1a4d82fc | 755 | |
85aaf69f | 756 | assert_eq!((0..100).size_hint(), (100, Some(100))); |
c34b1796 AL |
757 | // this test is only meaningful when sizeof usize < sizeof u64 |
758 | assert_eq!((usize::MAX - 1..usize::MAX).size_hint(), (1, Some(1))); | |
85aaf69f SL |
759 | assert_eq!((-10..-1).size_hint(), (9, Some(9))); |
760 | assert_eq!((-1..-10).size_hint(), (0, Some(0))); | |
1a4d82fc JJ |
761 | } |
762 | ||
763 | #[test] | |
764 | fn test_range_inclusive() { | |
c34b1796 | 765 | assert!(range_inclusive(0, 5).collect::<Vec<isize>>() == |
85aaf69f | 766 | vec![0, 1, 2, 3, 4, 5]); |
c34b1796 | 767 | assert!(range_inclusive(0, 5).rev().collect::<Vec<isize>>() == |
85aaf69f SL |
768 | vec![5, 4, 3, 2, 1, 0]); |
769 | assert_eq!(range_inclusive(200, -5).count(), 0); | |
770 | assert_eq!(range_inclusive(200, -5).rev().count(), 0); | |
c34b1796 AL |
771 | assert_eq!(range_inclusive(200, 200).collect::<Vec<isize>>(), [200]); |
772 | assert_eq!(range_inclusive(200, 200).rev().collect::<Vec<isize>>(), [200]); | |
1a4d82fc JJ |
773 | } |
774 | ||
775 | #[test] | |
776 | fn test_range_step() { | |
c34b1796 AL |
777 | assert_eq!((0..20).step_by(5).collect::<Vec<isize>>(), [0, 5, 10, 15]); |
778 | assert_eq!((20..0).step_by(-5).collect::<Vec<isize>>(), [20, 15, 10, 5]); | |
779 | assert_eq!((20..0).step_by(-6).collect::<Vec<isize>>(), [20, 14, 8, 2]); | |
780 | assert_eq!((200..255).step_by(50).collect::<Vec<u8>>(), [200, 250]); | |
781 | assert_eq!((200..-5).step_by(1).collect::<Vec<isize>>(), []); | |
782 | assert_eq!((200..200).step_by(1).collect::<Vec<isize>>(), []); | |
1a4d82fc JJ |
783 | } |
784 | ||
1a4d82fc JJ |
785 | #[test] |
786 | fn test_reverse() { | |
85aaf69f | 787 | let mut ys = [1, 2, 3, 4, 5]; |
1a4d82fc JJ |
788 | ys.iter_mut().reverse_in_place(); |
789 | assert!(ys == [5, 4, 3, 2, 1]); | |
790 | } | |
791 | ||
792 | #[test] | |
793 | fn test_peekable_is_empty() { | |
85aaf69f | 794 | let a = [1]; |
1a4d82fc JJ |
795 | let mut it = a.iter().peekable(); |
796 | assert!( !it.is_empty() ); | |
797 | it.next(); | |
798 | assert!( it.is_empty() ); | |
799 | } | |
800 | ||
801 | #[test] | |
802 | fn test_min_max() { | |
c34b1796 | 803 | let v: [isize; 0] = []; |
1a4d82fc JJ |
804 | assert_eq!(v.iter().min_max(), NoElements); |
805 | ||
85aaf69f | 806 | let v = [1]; |
1a4d82fc JJ |
807 | assert!(v.iter().min_max() == OneElement(&1)); |
808 | ||
85aaf69f | 809 | let v = [1, 2, 3, 4, 5]; |
1a4d82fc JJ |
810 | assert!(v.iter().min_max() == MinMax(&1, &5)); |
811 | ||
85aaf69f | 812 | let v = [1, 2, 3, 4, 5, 6]; |
1a4d82fc JJ |
813 | assert!(v.iter().min_max() == MinMax(&1, &6)); |
814 | ||
85aaf69f | 815 | let v = [1, 1, 1, 1]; |
1a4d82fc JJ |
816 | assert!(v.iter().min_max() == MinMax(&1, &1)); |
817 | } | |
818 | ||
819 | #[test] | |
820 | fn test_min_max_result() { | |
c34b1796 | 821 | let r: MinMaxResult<isize> = NoElements; |
1a4d82fc JJ |
822 | assert_eq!(r.into_option(), None); |
823 | ||
85aaf69f | 824 | let r = OneElement(1); |
1a4d82fc JJ |
825 | assert_eq!(r.into_option(), Some((1,1))); |
826 | ||
85aaf69f | 827 | let r = MinMax(1,2); |
1a4d82fc JJ |
828 | assert_eq!(r.into_option(), Some((1,2))); |
829 | } | |
830 | ||
831 | #[test] | |
832 | fn test_iterate() { | |
85aaf69f SL |
833 | let mut it = iterate(1, |x| x * 2); |
834 | assert_eq!(it.next(), Some(1)); | |
835 | assert_eq!(it.next(), Some(2)); | |
836 | assert_eq!(it.next(), Some(4)); | |
837 | assert_eq!(it.next(), Some(8)); | |
1a4d82fc JJ |
838 | } |
839 | ||
840 | #[test] | |
841 | fn test_repeat() { | |
85aaf69f SL |
842 | let mut it = repeat(42); |
843 | assert_eq!(it.next(), Some(42)); | |
844 | assert_eq!(it.next(), Some(42)); | |
845 | assert_eq!(it.next(), Some(42)); | |
846 | } | |
847 | ||
848 | #[test] | |
849 | fn test_fuse() { | |
850 | let mut it = 0..3; | |
851 | assert_eq!(it.len(), 3); | |
852 | assert_eq!(it.next(), Some(0)); | |
853 | assert_eq!(it.len(), 2); | |
854 | assert_eq!(it.next(), Some(1)); | |
855 | assert_eq!(it.len(), 1); | |
856 | assert_eq!(it.next(), Some(2)); | |
857 | assert_eq!(it.len(), 0); | |
858 | assert_eq!(it.next(), None); | |
859 | assert_eq!(it.len(), 0); | |
860 | assert_eq!(it.next(), None); | |
861 | assert_eq!(it.len(), 0); | |
862 | assert_eq!(it.next(), None); | |
863 | assert_eq!(it.len(), 0); | |
1a4d82fc JJ |
864 | } |
865 | ||
866 | #[bench] | |
867 | fn bench_rposition(b: &mut Bencher) { | |
c34b1796 | 868 | let it: Vec<usize> = (0..300).collect(); |
1a4d82fc JJ |
869 | b.iter(|| { |
870 | it.iter().rposition(|&x| x <= 150); | |
871 | }); | |
872 | } | |
873 | ||
874 | #[bench] | |
875 | fn bench_skip_while(b: &mut Bencher) { | |
876 | b.iter(|| { | |
85aaf69f | 877 | let it = 0..100; |
1a4d82fc JJ |
878 | let mut sum = 0; |
879 | it.skip_while(|&x| { sum += x; sum < 4000 }).all(|_| true); | |
880 | }); | |
881 | } | |
882 | ||
883 | #[bench] | |
884 | fn bench_multiple_take(b: &mut Bencher) { | |
85aaf69f | 885 | let mut it = (0..42).cycle(); |
1a4d82fc JJ |
886 | b.iter(|| { |
887 | let n = it.next().unwrap(); | |
85aaf69f SL |
888 | for _ in 0..n { |
889 | it.clone().take(it.next().unwrap()).all(|_| true); | |
1a4d82fc JJ |
890 | } |
891 | }); | |
892 | } | |
9346a6ac AL |
893 | |
894 | fn scatter(x: i32) -> i32 { (x * 31) % 127 } | |
895 | ||
896 | #[bench] | |
897 | fn bench_max_by(b: &mut Bencher) { | |
898 | b.iter(|| { | |
899 | let it = 0..100; | |
900 | it.max_by(|&x| scatter(x)) | |
901 | }) | |
902 | } | |
903 | ||
904 | // http://www.reddit.com/r/rust/comments/31syce/using_iterators_to_find_the_index_of_the_min_or/ | |
905 | #[bench] | |
906 | fn bench_max_by2(b: &mut Bencher) { | |
907 | fn max_index_iter(array: &[i32]) -> usize { | |
908 | array.iter().enumerate().max_by(|&(_, item)| item).unwrap().0 | |
909 | } | |
910 | ||
911 | let mut data = vec![0i32; 1638]; | |
912 | data[514] = 9999; | |
913 | ||
914 | b.iter(|| max_index_iter(&data)); | |
915 | } | |
916 | ||
917 | #[bench] | |
918 | fn bench_max(b: &mut Bencher) { | |
919 | b.iter(|| { | |
920 | let it = 0..100; | |
921 | it.map(scatter).max() | |
922 | }) | |
923 | } |