1 use super::*;
2 
3 #[test]
test_range()4 fn test_range() {
5     assert_eq!((0..5).collect::<Vec<_>>(), [0, 1, 2, 3, 4]);
6     assert_eq!((-10..-1).collect::<Vec<_>>(), [-10, -9, -8, -7, -6, -5, -4, -3, -2]);
7     assert_eq!((0..5).rev().collect::<Vec<_>>(), [4, 3, 2, 1, 0]);
8     assert_eq!((200..-5).count(), 0);
9     assert_eq!((200..-5).rev().count(), 0);
10     assert_eq!((200..200).count(), 0);
11     assert_eq!((200..200).rev().count(), 0);
12 
13     assert_eq!((0..100).size_hint(), (100, Some(100)));
14     // this test is only meaningful when sizeof usize < sizeof u64
15     assert_eq!((usize::MAX - 1..usize::MAX).size_hint(), (1, Some(1)));
16     assert_eq!((-10..-1).size_hint(), (9, Some(9)));
17     assert_eq!((-1..-10).size_hint(), (0, Some(0)));
18 
19     assert_eq!((-70..58).size_hint(), (128, Some(128)));
20     assert_eq!((-128..127).size_hint(), (255, Some(255)));
21     assert_eq!(
22         (-2..isize::MAX).size_hint(),
23         (isize::MAX as usize + 2, Some(isize::MAX as usize + 2))
24     );
25 }
26 
27 #[test]
test_char_range()28 fn test_char_range() {
29     use std::char;
30     // Miri is too slow
31     let from = if cfg!(miri) { char::from_u32(0xD800 - 10).unwrap() } else { '\0' };
32     let to = if cfg!(miri) { char::from_u32(0xDFFF + 10).unwrap() } else { char::MAX };
33     assert!((from..=to).eq((from as u32..=to as u32).filter_map(char::from_u32)));
34     assert!((from..=to).rev().eq((from as u32..=to as u32).filter_map(char::from_u32).rev()));
35 
36     assert_eq!(('\u{D7FF}'..='\u{E000}').count(), 2);
37     assert_eq!(('\u{D7FF}'..='\u{E000}').size_hint(), (2, Some(2)));
38     assert_eq!(('\u{D7FF}'..'\u{E000}').count(), 1);
39     assert_eq!(('\u{D7FF}'..'\u{E000}').size_hint(), (1, Some(1)));
40 }
41 
42 #[test]
test_range_exhaustion()43 fn test_range_exhaustion() {
44     let mut r = 10..10;
45     assert!(r.is_empty());
46     assert_eq!(r.next(), None);
47     assert_eq!(r.next_back(), None);
48     assert_eq!(r, 10..10);
49 
50     let mut r = 10..12;
51     assert_eq!(r.next(), Some(10));
52     assert_eq!(r.next(), Some(11));
53     assert!(r.is_empty());
54     assert_eq!(r, 12..12);
55     assert_eq!(r.next(), None);
56 
57     let mut r = 10..12;
58     assert_eq!(r.next_back(), Some(11));
59     assert_eq!(r.next_back(), Some(10));
60     assert!(r.is_empty());
61     assert_eq!(r, 10..10);
62     assert_eq!(r.next_back(), None);
63 
64     let mut r = 100..10;
65     assert!(r.is_empty());
66     assert_eq!(r.next(), None);
67     assert_eq!(r.next_back(), None);
68     assert_eq!(r, 100..10);
69 }
70 
71 #[test]
test_range_inclusive_exhaustion()72 fn test_range_inclusive_exhaustion() {
73     let mut r = 10..=10;
74     assert_eq!(r.next(), Some(10));
75     assert!(r.is_empty());
76     assert_eq!(r.next(), None);
77     assert_eq!(r.next(), None);
78 
79     assert_eq!(*r.start(), 10);
80     assert_eq!(*r.end(), 10);
81     assert_ne!(r, 10..=10);
82 
83     let mut r = 10..=10;
84     assert_eq!(r.next_back(), Some(10));
85     assert!(r.is_empty());
86     assert_eq!(r.next_back(), None);
87 
88     assert_eq!(*r.start(), 10);
89     assert_eq!(*r.end(), 10);
90     assert_ne!(r, 10..=10);
91 
92     let mut r = 10..=12;
93     assert_eq!(r.next(), Some(10));
94     assert_eq!(r.next(), Some(11));
95     assert_eq!(r.next(), Some(12));
96     assert!(r.is_empty());
97     assert_eq!(r.next(), None);
98 
99     let mut r = 10..=12;
100     assert_eq!(r.next_back(), Some(12));
101     assert_eq!(r.next_back(), Some(11));
102     assert_eq!(r.next_back(), Some(10));
103     assert!(r.is_empty());
104     assert_eq!(r.next_back(), None);
105 
106     let mut r = 10..=12;
107     assert_eq!(r.nth(2), Some(12));
108     assert!(r.is_empty());
109     assert_eq!(r.next(), None);
110 
111     let mut r = 10..=12;
112     assert_eq!(r.nth(5), None);
113     assert!(r.is_empty());
114     assert_eq!(r.next(), None);
115 
116     let mut r = 100..=10;
117     assert_eq!(r.next(), None);
118     assert!(r.is_empty());
119     assert_eq!(r.next(), None);
120     assert_eq!(r.next(), None);
121     assert_eq!(r, 100..=10);
122 
123     let mut r = 100..=10;
124     assert_eq!(r.next_back(), None);
125     assert!(r.is_empty());
126     assert_eq!(r.next_back(), None);
127     assert_eq!(r.next_back(), None);
128     assert_eq!(r, 100..=10);
129 }
130 
131 #[test]
test_range_nth()132 fn test_range_nth() {
133     assert_eq!((10..15).nth(0), Some(10));
134     assert_eq!((10..15).nth(1), Some(11));
135     assert_eq!((10..15).nth(4), Some(14));
136     assert_eq!((10..15).nth(5), None);
137 
138     let mut r = 10..20;
139     assert_eq!(r.nth(2), Some(12));
140     assert_eq!(r, 13..20);
141     assert_eq!(r.nth(2), Some(15));
142     assert_eq!(r, 16..20);
143     assert_eq!(r.nth(10), None);
144     assert_eq!(r, 20..20);
145 }
146 
147 #[test]
test_range_nth_back()148 fn test_range_nth_back() {
149     assert_eq!((10..15).nth_back(0), Some(14));
150     assert_eq!((10..15).nth_back(1), Some(13));
151     assert_eq!((10..15).nth_back(4), Some(10));
152     assert_eq!((10..15).nth_back(5), None);
153     assert_eq!((-120..80_i8).nth_back(199), Some(-120));
154 
155     let mut r = 10..20;
156     assert_eq!(r.nth_back(2), Some(17));
157     assert_eq!(r, 10..17);
158     assert_eq!(r.nth_back(2), Some(14));
159     assert_eq!(r, 10..14);
160     assert_eq!(r.nth_back(10), None);
161     assert_eq!(r, 10..10);
162 }
163 
164 #[test]
test_range_from_nth()165 fn test_range_from_nth() {
166     assert_eq!((10..).nth(0), Some(10));
167     assert_eq!((10..).nth(1), Some(11));
168     assert_eq!((10..).nth(4), Some(14));
169 
170     let mut r = 10..;
171     assert_eq!(r.nth(2), Some(12));
172     assert_eq!(r, 13..);
173     assert_eq!(r.nth(2), Some(15));
174     assert_eq!(r, 16..);
175     assert_eq!(r.nth(10), Some(26));
176     assert_eq!(r, 27..);
177 
178     assert_eq!((0..).size_hint(), (usize::MAX, None));
179 }
180 
181 #[test]
test_range_from_take()182 fn test_range_from_take() {
183     let mut it = (0..).take(3);
184     assert_eq!(it.next(), Some(0));
185     assert_eq!(it.next(), Some(1));
186     assert_eq!(it.next(), Some(2));
187     assert_eq!(it.next(), None);
188     is_trusted_len((0..).take(3));
189     assert_eq!((0..).take(3).size_hint(), (3, Some(3)));
190     assert_eq!((0..).take(0).size_hint(), (0, Some(0)));
191     assert_eq!((0..).take(usize::MAX).size_hint(), (usize::MAX, Some(usize::MAX)));
192 }
193 
194 #[test]
test_range_from_take_collect()195 fn test_range_from_take_collect() {
196     let v: Vec<_> = (0..).take(3).collect();
197     assert_eq!(v, vec![0, 1, 2]);
198 }
199 
200 #[test]
test_range_inclusive_nth()201 fn test_range_inclusive_nth() {
202     assert_eq!((10..=15).nth(0), Some(10));
203     assert_eq!((10..=15).nth(1), Some(11));
204     assert_eq!((10..=15).nth(5), Some(15));
205     assert_eq!((10..=15).nth(6), None);
206 
207     let mut exhausted_via_next = 10_u8..=20;
208     while exhausted_via_next.next().is_some() {}
209 
210     let mut r = 10_u8..=20;
211     assert_eq!(r.nth(2), Some(12));
212     assert_eq!(r, 13..=20);
213     assert_eq!(r.nth(2), Some(15));
214     assert_eq!(r, 16..=20);
215     assert_eq!(r.is_empty(), false);
216     assert_eq!(ExactSizeIterator::is_empty(&r), false);
217     assert_eq!(r.nth(10), None);
218     assert_eq!(r.is_empty(), true);
219     assert_eq!(r, exhausted_via_next);
220     assert_eq!(ExactSizeIterator::is_empty(&r), true);
221 }
222 
223 #[test]
test_range_inclusive_nth_back()224 fn test_range_inclusive_nth_back() {
225     assert_eq!((10..=15).nth_back(0), Some(15));
226     assert_eq!((10..=15).nth_back(1), Some(14));
227     assert_eq!((10..=15).nth_back(5), Some(10));
228     assert_eq!((10..=15).nth_back(6), None);
229     assert_eq!((-120..=80_i8).nth_back(200), Some(-120));
230 
231     let mut exhausted_via_next_back = 10_u8..=20;
232     while exhausted_via_next_back.next_back().is_some() {}
233 
234     let mut r = 10_u8..=20;
235     assert_eq!(r.nth_back(2), Some(18));
236     assert_eq!(r, 10..=17);
237     assert_eq!(r.nth_back(2), Some(15));
238     assert_eq!(r, 10..=14);
239     assert_eq!(r.is_empty(), false);
240     assert_eq!(ExactSizeIterator::is_empty(&r), false);
241     assert_eq!(r.nth_back(10), None);
242     assert_eq!(r.is_empty(), true);
243     assert_eq!(r, exhausted_via_next_back);
244     assert_eq!(ExactSizeIterator::is_empty(&r), true);
245 }
246 
247 #[test]
test_range_len()248 fn test_range_len() {
249     assert_eq!((0..10_u8).len(), 10);
250     assert_eq!((9..10_u8).len(), 1);
251     assert_eq!((10..10_u8).len(), 0);
252     assert_eq!((11..10_u8).len(), 0);
253     assert_eq!((100..10_u8).len(), 0);
254 }
255 
256 #[test]
test_range_inclusive_len()257 fn test_range_inclusive_len() {
258     assert_eq!((0..=10_u8).len(), 11);
259     assert_eq!((9..=10_u8).len(), 2);
260     assert_eq!((10..=10_u8).len(), 1);
261     assert_eq!((11..=10_u8).len(), 0);
262     assert_eq!((100..=10_u8).len(), 0);
263 }
264 
265 #[test]
test_range_step()266 fn test_range_step() {
267     #![allow(deprecated)]
268 
269     assert_eq!((0..20).step_by(5).collect::<Vec<isize>>(), [0, 5, 10, 15]);
270     assert_eq!((1..21).rev().step_by(5).collect::<Vec<isize>>(), [20, 15, 10, 5]);
271     assert_eq!((1..21).rev().step_by(6).collect::<Vec<isize>>(), [20, 14, 8, 2]);
272     assert_eq!((200..255).step_by(50).collect::<Vec<u8>>(), [200, 250]);
273     assert_eq!((200..-5).step_by(1).collect::<Vec<isize>>(), []);
274     assert_eq!((200..200).step_by(1).collect::<Vec<isize>>(), []);
275 
276     assert_eq!((0..20).step_by(1).size_hint(), (20, Some(20)));
277     assert_eq!((0..20).step_by(21).size_hint(), (1, Some(1)));
278     assert_eq!((0..20).step_by(5).size_hint(), (4, Some(4)));
279     assert_eq!((1..21).rev().step_by(5).size_hint(), (4, Some(4)));
280     assert_eq!((1..21).rev().step_by(6).size_hint(), (4, Some(4)));
281     assert_eq!((20..-5).step_by(1).size_hint(), (0, Some(0)));
282     assert_eq!((20..20).step_by(1).size_hint(), (0, Some(0)));
283     assert_eq!((i8::MIN..i8::MAX).step_by(-(i8::MIN as i32) as usize).size_hint(), (2, Some(2)));
284     assert_eq!((i16::MIN..i16::MAX).step_by(i16::MAX as usize).size_hint(), (3, Some(3)));
285     assert_eq!((isize::MIN..isize::MAX).step_by(1).size_hint(), (usize::MAX, Some(usize::MAX)));
286 }
287 
288 #[test]
test_range_advance_by()289 fn test_range_advance_by() {
290     let mut r = 0..usize::MAX;
291     r.advance_by(0).unwrap();
292     r.advance_back_by(0).unwrap();
293 
294     assert_eq!(r.len(), usize::MAX);
295 
296     r.advance_by(1).unwrap();
297     r.advance_back_by(1).unwrap();
298 
299     assert_eq!((r.start, r.end), (1, usize::MAX - 1));
300 
301     assert_eq!(r.advance_by(usize::MAX), Err(usize::MAX - 2));
302 
303     let mut r = 0u128..u128::MAX;
304 
305     r.advance_by(usize::MAX).unwrap();
306     r.advance_back_by(usize::MAX).unwrap();
307 
308     assert_eq!((r.start, r.end), (0u128 + usize::MAX as u128, u128::MAX - usize::MAX as u128));
309 }
310 
311 #[test]
test_range_inclusive_step()312 fn test_range_inclusive_step() {
313     assert_eq!((0..=50).step_by(10).collect::<Vec<_>>(), [0, 10, 20, 30, 40, 50]);
314     assert_eq!((0..=5).step_by(1).collect::<Vec<_>>(), [0, 1, 2, 3, 4, 5]);
315     assert_eq!((200..=255u8).step_by(10).collect::<Vec<_>>(), [200, 210, 220, 230, 240, 250]);
316     assert_eq!((250..=255u8).step_by(1).collect::<Vec<_>>(), [250, 251, 252, 253, 254, 255]);
317 }
318 
319 #[test]
test_range_last_max()320 fn test_range_last_max() {
321     assert_eq!((0..20).last(), Some(19));
322     assert_eq!((-20..0).last(), Some(-1));
323     assert_eq!((5..5).last(), None);
324 
325     assert_eq!((0..20).max(), Some(19));
326     assert_eq!((-20..0).max(), Some(-1));
327     assert_eq!((5..5).max(), None);
328 }
329 
330 #[test]
test_range_inclusive_last_max()331 fn test_range_inclusive_last_max() {
332     assert_eq!((0..=20).last(), Some(20));
333     assert_eq!((-20..=0).last(), Some(0));
334     assert_eq!((5..=5).last(), Some(5));
335     let mut r = 10..=10;
336     r.next();
337     assert_eq!(r.last(), None);
338 
339     assert_eq!((0..=20).max(), Some(20));
340     assert_eq!((-20..=0).max(), Some(0));
341     assert_eq!((5..=5).max(), Some(5));
342     let mut r = 10..=10;
343     r.next();
344     assert_eq!(r.max(), None);
345 }
346 
347 #[test]
test_range_min()348 fn test_range_min() {
349     assert_eq!((0..20).min(), Some(0));
350     assert_eq!((-20..0).min(), Some(-20));
351     assert_eq!((5..5).min(), None);
352 }
353 
354 #[test]
test_range_inclusive_min()355 fn test_range_inclusive_min() {
356     assert_eq!((0..=20).min(), Some(0));
357     assert_eq!((-20..=0).min(), Some(-20));
358     assert_eq!((5..=5).min(), Some(5));
359     let mut r = 10..=10;
360     r.next();
361     assert_eq!(r.min(), None);
362 }
363 
364 #[test]
test_range_inclusive_folds()365 fn test_range_inclusive_folds() {
366     assert_eq!((1..=10).sum::<i32>(), 55);
367     assert_eq!((1..=10).rev().sum::<i32>(), 55);
368 
369     let mut it = 44..=50;
370     assert_eq!(it.try_fold(0, i8::checked_add), None);
371     assert_eq!(it, 47..=50);
372     assert_eq!(it.try_fold(0, i8::checked_add), None);
373     assert_eq!(it, 50..=50);
374     assert_eq!(it.try_fold(0, i8::checked_add), Some(50));
375     assert!(it.is_empty());
376     assert_eq!(it.try_fold(0, i8::checked_add), Some(0));
377     assert!(it.is_empty());
378 
379     let mut it = 40..=47;
380     assert_eq!(it.try_rfold(0, i8::checked_add), None);
381     assert_eq!(it, 40..=44);
382     assert_eq!(it.try_rfold(0, i8::checked_add), None);
383     assert_eq!(it, 40..=41);
384     assert_eq!(it.try_rfold(0, i8::checked_add), Some(81));
385     assert!(it.is_empty());
386     assert_eq!(it.try_rfold(0, i8::checked_add), Some(0));
387     assert!(it.is_empty());
388 
389     let mut it = 10..=20;
390     assert_eq!(it.try_fold(0, |a, b| Some(a + b)), Some(165));
391     assert!(it.is_empty());
392     assert_eq!(it.try_fold(0, |a, b| Some(a + b)), Some(0));
393     assert!(it.is_empty());
394 
395     let mut it = 10..=20;
396     assert_eq!(it.try_rfold(0, |a, b| Some(a + b)), Some(165));
397     assert!(it.is_empty());
398     assert_eq!(it.try_rfold(0, |a, b| Some(a + b)), Some(0));
399     assert!(it.is_empty());
400 }
401 
402 #[test]
test_range_size_hint()403 fn test_range_size_hint() {
404     assert_eq!((0..0usize).size_hint(), (0, Some(0)));
405     assert_eq!((0..100usize).size_hint(), (100, Some(100)));
406     assert_eq!((0..usize::MAX).size_hint(), (usize::MAX, Some(usize::MAX)));
407 
408     let umax = u128::try_from(usize::MAX).unwrap();
409     assert_eq!((0..0u128).size_hint(), (0, Some(0)));
410     assert_eq!((0..100u128).size_hint(), (100, Some(100)));
411     assert_eq!((0..umax).size_hint(), (usize::MAX, Some(usize::MAX)));
412     assert_eq!((0..umax + 1).size_hint(), (usize::MAX, None));
413 
414     assert_eq!((0..0isize).size_hint(), (0, Some(0)));
415     assert_eq!((-100..100isize).size_hint(), (200, Some(200)));
416     assert_eq!((isize::MIN..isize::MAX).size_hint(), (usize::MAX, Some(usize::MAX)));
417 
418     let imin = i128::try_from(isize::MIN).unwrap();
419     let imax = i128::try_from(isize::MAX).unwrap();
420     assert_eq!((0..0i128).size_hint(), (0, Some(0)));
421     assert_eq!((-100..100i128).size_hint(), (200, Some(200)));
422     assert_eq!((imin..imax).size_hint(), (usize::MAX, Some(usize::MAX)));
423     assert_eq!((imin..imax + 1).size_hint(), (usize::MAX, None));
424 }
425 
426 #[test]
test_range_inclusive_size_hint()427 fn test_range_inclusive_size_hint() {
428     assert_eq!((1..=0usize).size_hint(), (0, Some(0)));
429     assert_eq!((0..=0usize).size_hint(), (1, Some(1)));
430     assert_eq!((0..=100usize).size_hint(), (101, Some(101)));
431     assert_eq!((0..=usize::MAX - 1).size_hint(), (usize::MAX, Some(usize::MAX)));
432     assert_eq!((0..=usize::MAX).size_hint(), (usize::MAX, None));
433 
434     let umax = u128::try_from(usize::MAX).unwrap();
435     assert_eq!((1..=0u128).size_hint(), (0, Some(0)));
436     assert_eq!((0..=0u128).size_hint(), (1, Some(1)));
437     assert_eq!((0..=100u128).size_hint(), (101, Some(101)));
438     assert_eq!((0..=umax - 1).size_hint(), (usize::MAX, Some(usize::MAX)));
439     assert_eq!((0..=umax).size_hint(), (usize::MAX, None));
440     assert_eq!((0..=umax + 1).size_hint(), (usize::MAX, None));
441 
442     assert_eq!((0..=-1isize).size_hint(), (0, Some(0)));
443     assert_eq!((0..=0isize).size_hint(), (1, Some(1)));
444     assert_eq!((-100..=100isize).size_hint(), (201, Some(201)));
445     assert_eq!((isize::MIN..=isize::MAX - 1).size_hint(), (usize::MAX, Some(usize::MAX)));
446     assert_eq!((isize::MIN..=isize::MAX).size_hint(), (usize::MAX, None));
447 
448     let imin = i128::try_from(isize::MIN).unwrap();
449     let imax = i128::try_from(isize::MAX).unwrap();
450     assert_eq!((0..=-1i128).size_hint(), (0, Some(0)));
451     assert_eq!((0..=0i128).size_hint(), (1, Some(1)));
452     assert_eq!((-100..=100i128).size_hint(), (201, Some(201)));
453     assert_eq!((imin..=imax - 1).size_hint(), (usize::MAX, Some(usize::MAX)));
454     assert_eq!((imin..=imax).size_hint(), (usize::MAX, None));
455     assert_eq!((imin..=imax + 1).size_hint(), (usize::MAX, None));
456 }
457 
458 #[test]
test_double_ended_range()459 fn test_double_ended_range() {
460     assert_eq!((11..14).rev().collect::<Vec<_>>(), [13, 12, 11]);
461     for _ in (10..0).rev() {
462         panic!("unreachable");
463     }
464 
465     assert_eq!((11..14).rev().collect::<Vec<_>>(), [13, 12, 11]);
466     for _ in (10..0).rev() {
467         panic!("unreachable");
468     }
469 }
470