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);
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)));
19 assert_eq!((-70..58).size_hint(), (128, Some(128)));
20 assert_eq!((-128..127).size_hint(), (255, Some(255)));
22 (-2..isize::MAX).size_hint(),
23 (isize::MAX as usize + 2, Some(isize::MAX as usize + 2))
28 fn test_char_range() {
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()));
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)));
43 fn test_range_exhaustion() {
45 assert!(r.is_empty());
46 assert_eq!(r.next(), None);
47 assert_eq!(r.next_back(), None);
48 assert_eq!(r, 10..10);
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);
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);
65 assert!(r.is_empty());
66 assert_eq!(r.next(), None);
67 assert_eq!(r.next_back(), None);
68 assert_eq!(r, 100..10);
72 fn test_range_inclusive_exhaustion() {
74 assert_eq!(r.next(), Some(10));
75 assert!(r.is_empty());
76 assert_eq!(r.next(), None);
77 assert_eq!(r.next(), None);
79 assert_eq!(*r.start(), 10);
80 assert_eq!(*r.end(), 10);
81 assert_ne!(r, 10..=10);
84 assert_eq!(r.next_back(), Some(10));
85 assert!(r.is_empty());
86 assert_eq!(r.next_back(), None);
88 assert_eq!(*r.start(), 10);
89 assert_eq!(*r.end(), 10);
90 assert_ne!(r, 10..=10);
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);
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);
107 assert_eq!(r.nth(2), Some(12));
108 assert!(r.is_empty());
109 assert_eq!(r.next(), None);
112 assert_eq!(r.nth(5), None);
113 assert!(r.is_empty());
114 assert_eq!(r.next(), None);
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);
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);
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);
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);
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));
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);
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));
171 assert_eq!(r.nth(2), Some(12));
173 assert_eq!(r.nth(2), Some(15));
175 assert_eq!(r.nth(10), Some(26));
178 assert_eq!((0..).size_hint(), (usize::MAX, None));
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)));
195 fn test_range_from_take_collect() {
196 let v: Vec<_> = (0..).take(3).collect();
197 assert_eq!(v, vec![0, 1, 2]);
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);
207 let mut exhausted_via_next = 10_u8..=20;
208 while exhausted_via_next.next().is_some() {}
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);
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));
231 let mut exhausted_via_next_back = 10_u8..=20;
232 while exhausted_via_next_back.next_back().is_some() {}
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);
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);
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);
266 fn test_range_step() {
267 #![allow(deprecated)]
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>>(), []);
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)));
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();
294 assert_eq!(r.len(), usize::MAX);
296 r.advance_by(1).unwrap();
297 r.advance_back_by(1).unwrap();
299 assert_eq!((r.start, r.end), (1, usize::MAX - 1));
301 assert_eq!(r.advance_by(usize::MAX), Err(usize::MAX - 2));
303 r.advance_by(0).unwrap();
304 r.advance_back_by(0).unwrap();
306 let mut r = 0u128..u128::MAX;
308 r.advance_by(usize::MAX).unwrap();
309 r.advance_back_by(usize::MAX).unwrap();
311 assert_eq!((r.start, r.end), (0u128 + usize::MAX as u128, u128::MAX - usize::MAX as u128));
315 fn test_range_inclusive_step() {
316 assert_eq!((0..=50).step_by(10).collect::<Vec<_>>(), [0, 10, 20, 30, 40, 50]);
317 assert_eq!((0..=5).step_by(1).collect::<Vec<_>>(), [0, 1, 2, 3, 4, 5]);
318 assert_eq!((200..=255u8).step_by(10).collect::<Vec<_>>(), [200, 210, 220, 230, 240, 250]);
319 assert_eq!((250..=255u8).step_by(1).collect::<Vec<_>>(), [250, 251, 252, 253, 254, 255]);
323 fn test_range_last_max() {
324 assert_eq!((0..20).last(), Some(19));
325 assert_eq!((-20..0).last(), Some(-1));
326 assert_eq!((5..5).last(), None);
328 assert_eq!((0..20).max(), Some(19));
329 assert_eq!((-20..0).max(), Some(-1));
330 assert_eq!((5..5).max(), None);
334 fn test_range_inclusive_last_max() {
335 assert_eq!((0..=20).last(), Some(20));
336 assert_eq!((-20..=0).last(), Some(0));
337 assert_eq!((5..=5).last(), Some(5));
340 assert_eq!(r.last(), None);
342 assert_eq!((0..=20).max(), Some(20));
343 assert_eq!((-20..=0).max(), Some(0));
344 assert_eq!((5..=5).max(), Some(5));
347 assert_eq!(r.max(), None);
351 fn test_range_min() {
352 assert_eq!((0..20).min(), Some(0));
353 assert_eq!((-20..0).min(), Some(-20));
354 assert_eq!((5..5).min(), None);
358 fn test_range_inclusive_min() {
359 assert_eq!((0..=20).min(), Some(0));
360 assert_eq!((-20..=0).min(), Some(-20));
361 assert_eq!((5..=5).min(), Some(5));
364 assert_eq!(r.min(), None);
368 fn test_range_inclusive_folds() {
369 assert_eq!((1..=10).sum::<i32>(), 55);
370 assert_eq!((1..=10).rev().sum::<i32>(), 55);
372 let mut it = 44..=50;
373 assert_eq!(it.try_fold(0, i8::checked_add), None);
374 assert_eq!(it, 47..=50);
375 assert_eq!(it.try_fold(0, i8::checked_add), None);
376 assert_eq!(it, 50..=50);
377 assert_eq!(it.try_fold(0, i8::checked_add), Some(50));
378 assert!(it.is_empty());
379 assert_eq!(it.try_fold(0, i8::checked_add), Some(0));
380 assert!(it.is_empty());
382 let mut it = 40..=47;
383 assert_eq!(it.try_rfold(0, i8::checked_add), None);
384 assert_eq!(it, 40..=44);
385 assert_eq!(it.try_rfold(0, i8::checked_add), None);
386 assert_eq!(it, 40..=41);
387 assert_eq!(it.try_rfold(0, i8::checked_add), Some(81));
388 assert!(it.is_empty());
389 assert_eq!(it.try_rfold(0, i8::checked_add), Some(0));
390 assert!(it.is_empty());
392 let mut it = 10..=20;
393 assert_eq!(it.try_fold(0, |a, b| Some(a + b)), Some(165));
394 assert!(it.is_empty());
395 assert_eq!(it.try_fold(0, |a, b| Some(a + b)), Some(0));
396 assert!(it.is_empty());
398 let mut it = 10..=20;
399 assert_eq!(it.try_rfold(0, |a, b| Some(a + b)), Some(165));
400 assert!(it.is_empty());
401 assert_eq!(it.try_rfold(0, |a, b| Some(a + b)), Some(0));
402 assert!(it.is_empty());
406 fn test_range_size_hint() {
407 assert_eq!((0..0usize).size_hint(), (0, Some(0)));
408 assert_eq!((0..100usize).size_hint(), (100, Some(100)));
409 assert_eq!((0..usize::MAX).size_hint(), (usize::MAX, Some(usize::MAX)));
411 let umax = u128::try_from(usize::MAX).unwrap();
412 assert_eq!((0..0u128).size_hint(), (0, Some(0)));
413 assert_eq!((0..100u128).size_hint(), (100, Some(100)));
414 assert_eq!((0..umax).size_hint(), (usize::MAX, Some(usize::MAX)));
415 assert_eq!((0..umax + 1).size_hint(), (usize::MAX, None));
417 assert_eq!((0..0isize).size_hint(), (0, Some(0)));
418 assert_eq!((-100..100isize).size_hint(), (200, Some(200)));
419 assert_eq!((isize::MIN..isize::MAX).size_hint(), (usize::MAX, Some(usize::MAX)));
421 let imin = i128::try_from(isize::MIN).unwrap();
422 let imax = i128::try_from(isize::MAX).unwrap();
423 assert_eq!((0..0i128).size_hint(), (0, Some(0)));
424 assert_eq!((-100..100i128).size_hint(), (200, Some(200)));
425 assert_eq!((imin..imax).size_hint(), (usize::MAX, Some(usize::MAX)));
426 assert_eq!((imin..imax + 1).size_hint(), (usize::MAX, None));
430 fn test_range_inclusive_size_hint() {
431 assert_eq!((1..=0usize).size_hint(), (0, Some(0)));
432 assert_eq!((0..=0usize).size_hint(), (1, Some(1)));
433 assert_eq!((0..=100usize).size_hint(), (101, Some(101)));
434 assert_eq!((0..=usize::MAX - 1).size_hint(), (usize::MAX, Some(usize::MAX)));
435 assert_eq!((0..=usize::MAX).size_hint(), (usize::MAX, None));
437 let umax = u128::try_from(usize::MAX).unwrap();
438 assert_eq!((1..=0u128).size_hint(), (0, Some(0)));
439 assert_eq!((0..=0u128).size_hint(), (1, Some(1)));
440 assert_eq!((0..=100u128).size_hint(), (101, Some(101)));
441 assert_eq!((0..=umax - 1).size_hint(), (usize::MAX, Some(usize::MAX)));
442 assert_eq!((0..=umax).size_hint(), (usize::MAX, None));
443 assert_eq!((0..=umax + 1).size_hint(), (usize::MAX, None));
445 assert_eq!((0..=-1isize).size_hint(), (0, Some(0)));
446 assert_eq!((0..=0isize).size_hint(), (1, Some(1)));
447 assert_eq!((-100..=100isize).size_hint(), (201, Some(201)));
448 assert_eq!((isize::MIN..=isize::MAX - 1).size_hint(), (usize::MAX, Some(usize::MAX)));
449 assert_eq!((isize::MIN..=isize::MAX).size_hint(), (usize::MAX, None));
451 let imin = i128::try_from(isize::MIN).unwrap();
452 let imax = i128::try_from(isize::MAX).unwrap();
453 assert_eq!((0..=-1i128).size_hint(), (0, Some(0)));
454 assert_eq!((0..=0i128).size_hint(), (1, Some(1)));
455 assert_eq!((-100..=100i128).size_hint(), (201, Some(201)));
456 assert_eq!((imin..=imax - 1).size_hint(), (usize::MAX, Some(usize::MAX)));
457 assert_eq!((imin..=imax).size_hint(), (usize::MAX, None));
458 assert_eq!((imin..=imax + 1).size_hint(), (usize::MAX, None));
462 fn test_double_ended_range() {
463 assert_eq!((11..14).rev().collect::<Vec<_>>(), [13, 12, 11]);
464 for _ in (10..0).rev() {
465 panic!("unreachable");
468 assert_eq!((11..14).rev().collect::<Vec<_>>(), [13, 12, 11]);
469 for _ in (10..0).rev() {
470 panic!("unreachable");