1 //! Licensed under the Apache License, Version 2.0
2 //! https://www.apache.org/licenses/LICENSE-2.0 or the MIT license
3 //! https://opensource.org/licenses/MIT, at your
4 //! option. This file may not be copied, modified, or distributed
5 //! except according to those terms.
6 #![no_std]
7 #![allow(deprecated)]
8
9 use crate::it::chain;
10 use crate::it::free::put_back;
11 use crate::it::interleave;
12 use crate::it::intersperse;
13 use crate::it::intersperse_with;
14 use crate::it::iproduct;
15 use crate::it::izip;
16 use crate::it::multizip;
17 use crate::it::Itertools;
18 use core::iter;
19 use itertools as it;
20
21 #[allow(dead_code)]
get_esi_then_esi<I: ExactSizeIterator + Clone>(it: I)22 fn get_esi_then_esi<I: ExactSizeIterator + Clone>(it: I) {
23 fn is_esi(_: impl ExactSizeIterator) {}
24 is_esi(it.clone().get(1..4));
25 is_esi(it.clone().get(1..=4));
26 is_esi(it.clone().get(1..));
27 is_esi(it.clone().get(..4));
28 is_esi(it.clone().get(..=4));
29 is_esi(it.get(..));
30 }
31
32 #[allow(dead_code)]
get_dei_esi_then_dei_esi<I: DoubleEndedIterator + ExactSizeIterator + Clone>(it: I)33 fn get_dei_esi_then_dei_esi<I: DoubleEndedIterator + ExactSizeIterator + Clone>(it: I) {
34 fn is_dei_esi(_: impl DoubleEndedIterator + ExactSizeIterator) {}
35 is_dei_esi(it.clone().get(1..4));
36 is_dei_esi(it.clone().get(1..=4));
37 is_dei_esi(it.clone().get(1..));
38 is_dei_esi(it.clone().get(..4));
39 is_dei_esi(it.clone().get(..=4));
40 is_dei_esi(it.get(..));
41 }
42
43 #[test]
get_1_max()44 fn get_1_max() {
45 let mut it = (0..5).get(1..=usize::MAX);
46 assert_eq!(it.next(), Some(1));
47 assert_eq!(it.next_back(), Some(4));
48 }
49
50 #[test]
51 #[should_panic]
get_full_range_inclusive()52 fn get_full_range_inclusive() {
53 let _it = (0..5).get(0..=usize::MAX);
54 }
55
56 #[test]
product0()57 fn product0() {
58 let mut prod = iproduct!();
59 assert_eq!(prod.next(), Some(()));
60 assert!(prod.next().is_none());
61 }
62
63 #[test]
iproduct1()64 fn iproduct1() {
65 let s = "αβ";
66
67 let mut prod = iproduct!(s.chars());
68 assert_eq!(prod.next(), Some(('α',)));
69 assert_eq!(prod.next(), Some(('β',)));
70 assert!(prod.next().is_none());
71 }
72
73 #[test]
product2()74 fn product2() {
75 let s = "αβ";
76
77 let mut prod = iproduct!(s.chars(), 0..2);
78 assert!(prod.next() == Some(('α', 0)));
79 assert!(prod.next() == Some(('α', 1)));
80 assert!(prod.next() == Some(('β', 0)));
81 assert!(prod.next() == Some(('β', 1)));
82 assert!(prod.next().is_none());
83 }
84
85 #[test]
product_temporary()86 fn product_temporary() {
87 for (_x, _y, _z) in iproduct!(
88 [0, 1, 2].iter().cloned(),
89 [0, 1, 2].iter().cloned(),
90 [0, 1, 2].iter().cloned()
91 ) {
92 // ok
93 }
94 }
95
96 #[test]
izip_macro()97 fn izip_macro() {
98 let mut zip = izip!(2..3);
99 assert!(zip.next() == Some(2));
100 assert!(zip.next().is_none());
101
102 let mut zip = izip!(0..3, 0..2, 0..2i8);
103 for i in 0..2 {
104 assert!((i as usize, i, i as i8) == zip.next().unwrap());
105 }
106 assert!(zip.next().is_none());
107
108 let xs: [isize; 0] = [];
109 let mut zip = izip!(0..3, 0..2, 0..2i8, &xs);
110 assert!(zip.next().is_none());
111 }
112
113 #[test]
izip2()114 fn izip2() {
115 let _zip1: iter::Zip<_, _> = izip!(1.., 2..);
116 let _zip2: iter::Zip<_, _> = izip!(1.., 2..,);
117 }
118
119 #[test]
izip3()120 fn izip3() {
121 let mut zip: iter::Map<iter::Zip<_, _>, _> = izip!(0..3, 0..2, 0..2i8);
122 for i in 0..2 {
123 assert!((i as usize, i, i as i8) == zip.next().unwrap());
124 }
125 assert!(zip.next().is_none());
126 }
127
128 #[test]
multizip3()129 fn multizip3() {
130 let mut zip = multizip((0..3, 0..2, 0..2i8));
131 for i in 0..2 {
132 assert!((i as usize, i, i as i8) == zip.next().unwrap());
133 }
134 assert!(zip.next().is_none());
135
136 let xs: [isize; 0] = [];
137 let mut zip = multizip((0..3, 0..2, 0..2i8, xs.iter()));
138 assert!(zip.next().is_none());
139
140 for (_, _, _, _, _) in multizip((0..3, 0..2, xs.iter(), &xs, xs.to_vec())) {
141 /* test compiles */
142 }
143 }
144
145 #[test]
chain_macro()146 fn chain_macro() {
147 let mut chain = chain!(2..3);
148 assert!(chain.next() == Some(2));
149 assert!(chain.next().is_none());
150
151 let mut chain = chain!(0..2, 2..3, 3..5i8);
152 for i in 0..5i8 {
153 assert_eq!(Some(i), chain.next());
154 }
155 assert!(chain.next().is_none());
156
157 let mut chain = chain!();
158 assert_eq!(chain.next(), Option::<()>::None);
159 }
160
161 #[test]
chain2()162 fn chain2() {
163 let _ = chain!(1.., 2..);
164 let _ = chain!(1.., 2..,);
165 }
166
167 #[test]
write_to()168 fn write_to() {
169 let xs = [7, 9, 8];
170 let mut ys = [0; 5];
171 let cnt = ys.iter_mut().set_from(xs.iter().copied());
172 assert!(cnt == xs.len());
173 assert!(ys == [7, 9, 8, 0, 0]);
174
175 let cnt = ys.iter_mut().set_from(0..10);
176 assert!(cnt == ys.len());
177 assert!(ys == [0, 1, 2, 3, 4]);
178 }
179
180 #[test]
test_interleave()181 fn test_interleave() {
182 let xs: [u8; 0] = [];
183 let ys = [7u8, 9, 8, 10];
184 let zs = [2u8, 77];
185 let it = interleave(xs.iter(), ys.iter());
186 it::assert_equal(it, ys.iter());
187
188 let rs = [7u8, 2, 9, 77, 8, 10];
189 let it = interleave(ys.iter(), zs.iter());
190 it::assert_equal(it, rs.iter());
191 }
192
193 #[test]
test_intersperse()194 fn test_intersperse() {
195 let xs = [1u8, 2, 3];
196 let ys = [1u8, 0, 2, 0, 3];
197 let it = intersperse(&xs, &0);
198 it::assert_equal(it, ys.iter());
199 }
200
201 #[test]
test_intersperse_with()202 fn test_intersperse_with() {
203 let xs = [1u8, 2, 3];
204 let ys = [1u8, 10, 2, 10, 3];
205 let i = 10;
206 let it = intersperse_with(&xs, || &i);
207 it::assert_equal(it, ys.iter());
208 }
209
210 #[test]
dropping()211 fn dropping() {
212 let xs = [1, 2, 3];
213 let mut it = xs.iter().dropping(2);
214 assert_eq!(it.next(), Some(&3));
215 assert!(it.next().is_none());
216 let mut it = xs.iter().dropping(5);
217 assert!(it.next().is_none());
218 }
219
220 #[test]
batching()221 fn batching() {
222 let xs = [0, 1, 2, 1, 3];
223 let ys = [(0, 1), (2, 1)];
224
225 // An iterator that gathers elements up in pairs
226 let pit = xs
227 .iter()
228 .cloned()
229 .batching(|it| it.next().and_then(|x| it.next().map(|y| (x, y))));
230 it::assert_equal(pit, ys.iter().cloned());
231 }
232
233 #[test]
test_put_back()234 fn test_put_back() {
235 let xs = [0, 1, 1, 1, 2, 1, 3, 3];
236 let mut pb = put_back(xs.iter().cloned());
237 pb.next();
238 pb.put_back(1);
239 pb.put_back(0);
240 it::assert_equal(pb, xs.iter().cloned());
241 }
242
243 #[test]
merge()244 fn merge() {
245 it::assert_equal((0..10).step_by(2).merge((1..10).step_by(2)), 0..10);
246 }
247
248 #[test]
repeatn()249 fn repeatn() {
250 let s = "α";
251 let mut it = it::repeat_n(s, 3);
252 assert_eq!(it.len(), 3);
253 assert_eq!(it.next(), Some(s));
254 assert_eq!(it.next(), Some(s));
255 assert_eq!(it.next(), Some(s));
256 assert_eq!(it.next(), None);
257 assert_eq!(it.next(), None);
258 }
259
260 #[test]
count_clones()261 fn count_clones() {
262 // Check that RepeatN only clones N - 1 times.
263
264 use core::cell::Cell;
265 #[derive(PartialEq, Debug)]
266 struct Foo {
267 n: Cell<usize>,
268 }
269
270 impl Clone for Foo {
271 fn clone(&self) -> Self {
272 let n = self.n.get();
273 self.n.set(n + 1);
274 Self {
275 n: Cell::new(n + 1),
276 }
277 }
278 }
279
280 for n in 0..10 {
281 let f = Foo { n: Cell::new(0) };
282 let it = it::repeat_n(f, n);
283 // drain it
284 let last = it.last();
285 if n == 0 {
286 assert_eq!(last, None);
287 } else {
288 assert_eq!(
289 last,
290 Some(Foo {
291 n: Cell::new(n - 1)
292 })
293 );
294 }
295 }
296 }
297
298 #[test]
part()299 fn part() {
300 let mut data = [7, 1, 1, 9, 1, 1, 3];
301 let i = it::partition(&mut data, |elt| *elt >= 3);
302 assert_eq!(i, 3);
303 assert_eq!(data, [7, 3, 9, 1, 1, 1, 1]);
304
305 let i = it::partition(&mut data, |elt| *elt == 1);
306 assert_eq!(i, 4);
307 assert_eq!(data, [1, 1, 1, 1, 9, 3, 7]);
308
309 let mut data = [1, 2, 3, 4, 5, 6, 7, 8, 9];
310 let i = it::partition(&mut data, |elt| *elt % 3 == 0);
311 assert_eq!(i, 3);
312 assert_eq!(data, [9, 6, 3, 4, 5, 2, 7, 8, 1]);
313 }
314
315 #[test]
tree_reduce()316 fn tree_reduce() {
317 for i in 0..100 {
318 assert_eq!((0..i).tree_reduce(|x, y| x + y), (0..i).fold1(|x, y| x + y));
319 }
320 }
321
322 #[test]
exactly_one()323 fn exactly_one() {
324 assert_eq!((0..10).filter(|&x| x == 2).exactly_one().unwrap(), 2);
325 assert!((0..10)
326 .filter(|&x| x > 1 && x < 4)
327 .exactly_one()
328 .unwrap_err()
329 .eq(2..4));
330 assert!((0..10)
331 .filter(|&x| x > 1 && x < 5)
332 .exactly_one()
333 .unwrap_err()
334 .eq(2..5));
335 assert!((0..10)
336 .filter(|&_| false)
337 .exactly_one()
338 .unwrap_err()
339 .eq(0..0));
340 }
341
342 #[test]
at_most_one()343 fn at_most_one() {
344 assert_eq!((0..10).filter(|&x| x == 2).at_most_one().unwrap(), Some(2));
345 assert!((0..10)
346 .filter(|&x| x > 1 && x < 4)
347 .at_most_one()
348 .unwrap_err()
349 .eq(2..4));
350 assert!((0..10)
351 .filter(|&x| x > 1 && x < 5)
352 .at_most_one()
353 .unwrap_err()
354 .eq(2..5));
355 assert_eq!((0..10).filter(|&_| false).at_most_one().unwrap(), None);
356 }
357
358 #[test]
sum1()359 fn sum1() {
360 let v: &[i32] = &[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
361 assert_eq!(v[..0].iter().cloned().sum1::<i32>(), None);
362 assert_eq!(v[1..2].iter().cloned().sum1::<i32>(), Some(1));
363 assert_eq!(v[1..3].iter().cloned().sum1::<i32>(), Some(3));
364 assert_eq!(v.iter().cloned().sum1::<i32>(), Some(55));
365 }
366
367 #[test]
product1()368 fn product1() {
369 let v: &[i32] = &[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
370 assert_eq!(v[..0].iter().cloned().product1::<i32>(), None);
371 assert_eq!(v[..1].iter().cloned().product1::<i32>(), Some(0));
372 assert_eq!(v[1..3].iter().cloned().product1::<i32>(), Some(2));
373 assert_eq!(v[1..5].iter().cloned().product1::<i32>(), Some(24));
374 }
375
376 #[test]
next_array()377 fn next_array() {
378 let v = [1, 2, 3, 4, 5];
379 let mut iter = v.iter();
380 assert_eq!(iter.next_array(), Some([]));
381 assert_eq!(iter.next_array().map(|[&x, &y]| [x, y]), Some([1, 2]));
382 assert_eq!(iter.next_array().map(|[&x, &y]| [x, y]), Some([3, 4]));
383 assert_eq!(iter.next_array::<2>(), None);
384 }
385
386 #[test]
collect_array()387 fn collect_array() {
388 let v = [1, 2];
389 let iter = v.iter().cloned();
390 assert_eq!(iter.collect_array(), Some([1, 2]));
391
392 let v = [1];
393 let iter = v.iter().cloned();
394 assert_eq!(iter.collect_array::<2>(), None);
395
396 let v = [1, 2, 3];
397 let iter = v.iter().cloned();
398 assert_eq!(iter.collect_array::<2>(), None);
399 }
400