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))
27 fn test_char_range() {
30 let from = if cfg!(miri) { char::from_u32(0xD800 - 10).unwrap() } else { '\0' };
31 let to = if cfg!(miri) { char::from_u32(0xDFFF + 10).unwrap() } else { char::MAX };
32 assert!((from..=to).eq((from as u32..=to as u32).filter_map(char::from_u32)));
33 assert!((from..=to).rev().eq((from as u32..=to as u32).filter_map(char::from_u32).rev()));
35 assert_eq!(('\u{D7FF}'..='\u{E000}').count(), 2);
36 assert_eq!(('\u{D7FF}'..='\u{E000}').size_hint(), (2, Some(2)));
37 assert_eq!(('\u{D7FF}'..'\u{E000}').count(), 1);
38 assert_eq!(('\u{D7FF}'..'\u{E000}').size_hint(), (1, Some(1)));
41 fn test_range_exhaustion() {
43 assert!(r.is_empty());
44 assert_eq!(r.next(), None);
45 assert_eq!(r.next_back(), None);
46 assert_eq!(r, 10..10);
49 assert_eq!(r.next(), Some(10));
50 assert_eq!(r.next(), Some(11));
51 assert!(r.is_empty());
52 assert_eq!(r, 12..12);
53 assert_eq!(r.next(), None);
56 assert_eq!(r.next_back(), Some(11));
57 assert_eq!(r.next_back(), Some(10));
58 assert!(r.is_empty());
59 assert_eq!(r, 10..10);
60 assert_eq!(r.next_back(), None);
63 assert!(r.is_empty());
64 assert_eq!(r.next(), None);
65 assert_eq!(r.next_back(), None);
66 assert_eq!(r, 100..10);
69 fn test_range_inclusive_exhaustion() {
71 assert_eq!(r.next(), Some(10));
72 assert!(r.is_empty());
73 assert_eq!(r.next(), None);
74 assert_eq!(r.next(), None);
76 assert_eq!(*r.start(), 10);
77 assert_eq!(*r.end(), 10);
78 assert_ne!(r, 10..=10);
81 assert_eq!(r.next_back(), Some(10));
82 assert!(r.is_empty());
83 assert_eq!(r.next_back(), None);
85 assert_eq!(*r.start(), 10);
86 assert_eq!(*r.end(), 10);
87 assert_ne!(r, 10..=10);
90 assert_eq!(r.next(), Some(10));
91 assert_eq!(r.next(), Some(11));
92 assert_eq!(r.next(), Some(12));
93 assert!(r.is_empty());
94 assert_eq!(r.next(), None);
97 assert_eq!(r.next_back(), Some(12));
98 assert_eq!(r.next_back(), Some(11));
99 assert_eq!(r.next_back(), Some(10));
100 assert!(r.is_empty());
101 assert_eq!(r.next_back(), None);
104 assert_eq!(r.nth(2), Some(12));
105 assert!(r.is_empty());
106 assert_eq!(r.next(), None);
109 assert_eq!(r.nth(5), None);
110 assert!(r.is_empty());
111 assert_eq!(r.next(), None);
113 let mut r = 100..=10;
114 assert_eq!(r.next(), None);
115 assert!(r.is_empty());
116 assert_eq!(r.next(), None);
117 assert_eq!(r.next(), None);
118 assert_eq!(r, 100..=10);
120 let mut r = 100..=10;
121 assert_eq!(r.next_back(), None);
122 assert!(r.is_empty());
123 assert_eq!(r.next_back(), None);
124 assert_eq!(r.next_back(), None);
125 assert_eq!(r, 100..=10);
128 fn test_range_nth() {
129 assert_eq!((10..15).nth(0), Some(10));
130 assert_eq!((10..15).nth(1), Some(11));
131 assert_eq!((10..15).nth(4), Some(14));
132 assert_eq!((10..15).nth(5), None);
135 assert_eq!(r.nth(2), Some(12));
136 assert_eq!(r, 13..20);
137 assert_eq!(r.nth(2), Some(15));
138 assert_eq!(r, 16..20);
139 assert_eq!(r.nth(10), None);
140 assert_eq!(r, 20..20);
143 fn test_range_nth_back() {
144 assert_eq!((10..15).nth_back(0), Some(14));
145 assert_eq!((10..15).nth_back(1), Some(13));
146 assert_eq!((10..15).nth_back(4), Some(10));
147 assert_eq!((10..15).nth_back(5), None);
148 assert_eq!((-120..80_i8).nth_back(199), Some(-120));
151 assert_eq!(r.nth_back(2), Some(17));
152 assert_eq!(r, 10..17);
153 assert_eq!(r.nth_back(2), Some(14));
154 assert_eq!(r, 10..14);
155 assert_eq!(r.nth_back(10), None);
156 assert_eq!(r, 10..10);
159 fn test_range_from_nth() {
160 assert_eq!((10..).nth(0), Some(10));
161 assert_eq!((10..).nth(1), Some(11));
162 assert_eq!((10..).nth(4), Some(14));
165 assert_eq!(r.nth(2), Some(12));
167 assert_eq!(r.nth(2), Some(15));
169 assert_eq!(r.nth(10), Some(26));
172 assert_eq!((0..).size_hint(), (usize::MAX, None));
175 fn test_range_from_take() {
176 let mut it = (0..).take(3);
177 assert_eq!(it.next(), Some(0));
178 assert_eq!(it.next(), Some(1));
179 assert_eq!(it.next(), Some(2));
180 assert_eq!(it.next(), None);
181 is_trusted_len((0..).take(3));
182 assert_eq!((0..).take(3).size_hint(), (3, Some(3)));
183 assert_eq!((0..).take(0).size_hint(), (0, Some(0)));
184 assert_eq!((0..).take(usize::MAX).size_hint(), (usize::MAX, Some(usize::MAX)));
187 fn test_range_from_take_collect() {
188 let v: Vec<_> = (0..).take(3).collect();
189 assert_eq!(v, vec![0, 1, 2]);
192 fn test_range_inclusive_nth() {
193 assert_eq!((10..=15).nth(0), Some(10));
194 assert_eq!((10..=15).nth(1), Some(11));
195 assert_eq!((10..=15).nth(5), Some(15));
196 assert_eq!((10..=15).nth(6), None);
198 let mut exhausted_via_next = 10_u8..=20;
199 while exhausted_via_next.next().is_some() {}
201 let mut r = 10_u8..=20;
202 assert_eq!(r.nth(2), Some(12));
203 assert_eq!(r, 13..=20);
204 assert_eq!(r.nth(2), Some(15));
205 assert_eq!(r, 16..=20);
206 assert_eq!(r.is_empty(), false);
207 assert_eq!(ExactSizeIterator::is_empty(&r), false);
208 assert_eq!(r.nth(10), None);
209 assert_eq!(r.is_empty(), true);
210 assert_eq!(r, exhausted_via_next);
211 assert_eq!(ExactSizeIterator::is_empty(&r), true);
214 fn test_range_inclusive_nth_back() {
215 assert_eq!((10..=15).nth_back(0), Some(15));
216 assert_eq!((10..=15).nth_back(1), Some(14));
217 assert_eq!((10..=15).nth_back(5), Some(10));
218 assert_eq!((10..=15).nth_back(6), None);
219 assert_eq!((-120..=80_i8).nth_back(200), Some(-120));
221 let mut exhausted_via_next_back = 10_u8..=20;
222 while exhausted_via_next_back.next_back().is_some() {}
224 let mut r = 10_u8..=20;
225 assert_eq!(r.nth_back(2), Some(18));
226 assert_eq!(r, 10..=17);
227 assert_eq!(r.nth_back(2), Some(15));
228 assert_eq!(r, 10..=14);
229 assert_eq!(r.is_empty(), false);
230 assert_eq!(ExactSizeIterator::is_empty(&r), false);
231 assert_eq!(r.nth_back(10), None);
232 assert_eq!(r.is_empty(), true);
233 assert_eq!(r, exhausted_via_next_back);
234 assert_eq!(ExactSizeIterator::is_empty(&r), true);
237 fn test_range_len() {
238 assert_eq!((0..10_u8).len(), 10);
239 assert_eq!((9..10_u8).len(), 1);
240 assert_eq!((10..10_u8).len(), 0);
241 assert_eq!((11..10_u8).len(), 0);
242 assert_eq!((100..10_u8).len(), 0);
245 fn test_range_inclusive_len() {
246 assert_eq!((0..=10_u8).len(), 11);
247 assert_eq!((9..=10_u8).len(), 2);
248 assert_eq!((10..=10_u8).len(), 1);
249 assert_eq!((11..=10_u8).len(), 0);
250 assert_eq!((100..=10_u8).len(), 0);
253 fn test_range_step() {
254 #![allow(deprecated)]
256 assert_eq!((0..20).step_by(5).collect::<Vec<isize>>(), [0, 5, 10, 15]);
257 assert_eq!((1..21).rev().step_by(5).collect::<Vec<isize>>(), [20, 15, 10, 5]);
258 assert_eq!((1..21).rev().step_by(6).collect::<Vec<isize>>(), [20, 14, 8, 2]);
259 assert_eq!((200..255).step_by(50).collect::<Vec<u8>>(), [200, 250]);
260 assert_eq!((200..-5).step_by(1).collect::<Vec<isize>>(), []);
261 assert_eq!((200..200).step_by(1).collect::<Vec<isize>>(), []);
263 assert_eq!((0..20).step_by(1).size_hint(), (20, Some(20)));
264 assert_eq!((0..20).step_by(21).size_hint(), (1, Some(1)));
265 assert_eq!((0..20).step_by(5).size_hint(), (4, Some(4)));
266 assert_eq!((1..21).rev().step_by(5).size_hint(), (4, Some(4)));
267 assert_eq!((1..21).rev().step_by(6).size_hint(), (4, Some(4)));
268 assert_eq!((20..-5).step_by(1).size_hint(), (0, Some(0)));
269 assert_eq!((20..20).step_by(1).size_hint(), (0, Some(0)));
270 assert_eq!((i8::MIN..i8::MAX).step_by(-(i8::MIN as i32) as usize).size_hint(), (2, Some(2)));
271 assert_eq!((i16::MIN..i16::MAX).step_by(i16::MAX as usize).size_hint(), (3, Some(3)));
272 assert_eq!((isize::MIN..isize::MAX).step_by(1).size_hint(), (usize::MAX, Some(usize::MAX)));
275 fn test_range_inclusive_step() {
276 assert_eq!((0..=50).step_by(10).collect::<Vec<_>>(), [0, 10, 20, 30, 40, 50]);
277 assert_eq!((0..=5).step_by(1).collect::<Vec<_>>(), [0, 1, 2, 3, 4, 5]);
278 assert_eq!((200..=255u8).step_by(10).collect::<Vec<_>>(), [200, 210, 220, 230, 240, 250]);
279 assert_eq!((250..=255u8).step_by(1).collect::<Vec<_>>(), [250, 251, 252, 253, 254, 255]);
282 fn test_range_last_max() {
283 assert_eq!((0..20).last(), Some(19));
284 assert_eq!((-20..0).last(), Some(-1));
285 assert_eq!((5..5).last(), None);
287 assert_eq!((0..20).max(), Some(19));
288 assert_eq!((-20..0).max(), Some(-1));
289 assert_eq!((5..5).max(), None);
292 fn test_range_inclusive_last_max() {
293 assert_eq!((0..=20).last(), Some(20));
294 assert_eq!((-20..=0).last(), Some(0));
295 assert_eq!((5..=5).last(), Some(5));
298 assert_eq!(r.last(), None);
300 assert_eq!((0..=20).max(), Some(20));
301 assert_eq!((-20..=0).max(), Some(0));
302 assert_eq!((5..=5).max(), Some(5));
305 assert_eq!(r.max(), None);
308 fn test_range_min() {
309 assert_eq!((0..20).min(), Some(0));
310 assert_eq!((-20..0).min(), Some(-20));
311 assert_eq!((5..5).min(), None);
314 fn test_range_inclusive_min() {
315 assert_eq!((0..=20).min(), Some(0));
316 assert_eq!((-20..=0).min(), Some(-20));
317 assert_eq!((5..=5).min(), Some(5));
320 assert_eq!(r.min(), None);
323 fn test_range_inclusive_folds() {
324 assert_eq!((1..=10).sum::<i32>(), 55);
325 assert_eq!((1..=10).rev().sum::<i32>(), 55);
327 let mut it = 44..=50;
328 assert_eq!(it.try_fold(0, i8::checked_add), None);
329 assert_eq!(it, 47..=50);
330 assert_eq!(it.try_fold(0, i8::checked_add), None);
331 assert_eq!(it, 50..=50);
332 assert_eq!(it.try_fold(0, i8::checked_add), Some(50));
333 assert!(it.is_empty());
334 assert_eq!(it.try_fold(0, i8::checked_add), Some(0));
335 assert!(it.is_empty());
337 let mut it = 40..=47;
338 assert_eq!(it.try_rfold(0, i8::checked_add), None);
339 assert_eq!(it, 40..=44);
340 assert_eq!(it.try_rfold(0, i8::checked_add), None);
341 assert_eq!(it, 40..=41);
342 assert_eq!(it.try_rfold(0, i8::checked_add), Some(81));
343 assert!(it.is_empty());
344 assert_eq!(it.try_rfold(0, i8::checked_add), Some(0));
345 assert!(it.is_empty());
347 let mut it = 10..=20;
348 assert_eq!(it.try_fold(0, |a, b| Some(a + b)), Some(165));
349 assert!(it.is_empty());
350 assert_eq!(it.try_fold(0, |a, b| Some(a + b)), Some(0));
351 assert!(it.is_empty());
353 let mut it = 10..=20;
354 assert_eq!(it.try_rfold(0, |a, b| Some(a + b)), Some(165));
355 assert!(it.is_empty());
356 assert_eq!(it.try_rfold(0, |a, b| Some(a + b)), Some(0));
357 assert!(it.is_empty());
360 fn test_range_size_hint() {
361 assert_eq!((0..0usize).size_hint(), (0, Some(0)));
362 assert_eq!((0..100usize).size_hint(), (100, Some(100)));
363 assert_eq!((0..usize::MAX).size_hint(), (usize::MAX, Some(usize::MAX)));
365 let umax = u128::try_from(usize::MAX).unwrap();
366 assert_eq!((0..0u128).size_hint(), (0, Some(0)));
367 assert_eq!((0..100u128).size_hint(), (100, Some(100)));
368 assert_eq!((0..umax).size_hint(), (usize::MAX, Some(usize::MAX)));
369 assert_eq!((0..umax + 1).size_hint(), (usize::MAX, None));
371 assert_eq!((0..0isize).size_hint(), (0, Some(0)));
372 assert_eq!((-100..100isize).size_hint(), (200, Some(200)));
373 assert_eq!((isize::MIN..isize::MAX).size_hint(), (usize::MAX, Some(usize::MAX)));
375 let imin = i128::try_from(isize::MIN).unwrap();
376 let imax = i128::try_from(isize::MAX).unwrap();
377 assert_eq!((0..0i128).size_hint(), (0, Some(0)));
378 assert_eq!((-100..100i128).size_hint(), (200, Some(200)));
379 assert_eq!((imin..imax).size_hint(), (usize::MAX, Some(usize::MAX)));
380 assert_eq!((imin..imax + 1).size_hint(), (usize::MAX, None));
383 fn test_range_inclusive_size_hint() {
384 assert_eq!((1..=0usize).size_hint(), (0, Some(0)));
385 assert_eq!((0..=0usize).size_hint(), (1, Some(1)));
386 assert_eq!((0..=100usize).size_hint(), (101, Some(101)));
387 assert_eq!((0..=usize::MAX - 1).size_hint(), (usize::MAX, Some(usize::MAX)));
388 assert_eq!((0..=usize::MAX).size_hint(), (usize::MAX, None));
390 let umax = u128::try_from(usize::MAX).unwrap();
391 assert_eq!((1..=0u128).size_hint(), (0, Some(0)));
392 assert_eq!((0..=0u128).size_hint(), (1, Some(1)));
393 assert_eq!((0..=100u128).size_hint(), (101, Some(101)));
394 assert_eq!((0..=umax - 1).size_hint(), (usize::MAX, Some(usize::MAX)));
395 assert_eq!((0..=umax).size_hint(), (usize::MAX, None));
396 assert_eq!((0..=umax + 1).size_hint(), (usize::MAX, None));
398 assert_eq!((0..=-1isize).size_hint(), (0, Some(0)));
399 assert_eq!((0..=0isize).size_hint(), (1, Some(1)));
400 assert_eq!((-100..=100isize).size_hint(), (201, Some(201)));
401 assert_eq!((isize::MIN..=isize::MAX - 1).size_hint(), (usize::MAX, Some(usize::MAX)));
402 assert_eq!((isize::MIN..=isize::MAX).size_hint(), (usize::MAX, None));
404 let imin = i128::try_from(isize::MIN).unwrap();
405 let imax = i128::try_from(isize::MAX).unwrap();
406 assert_eq!((0..=-1i128).size_hint(), (0, Some(0)));
407 assert_eq!((0..=0i128).size_hint(), (1, Some(1)));
408 assert_eq!((-100..=100i128).size_hint(), (201, Some(201)));
409 assert_eq!((imin..=imax - 1).size_hint(), (usize::MAX, Some(usize::MAX)));
410 assert_eq!((imin..=imax).size_hint(), (usize::MAX, None));
411 assert_eq!((imin..=imax + 1).size_hint(), (usize::MAX, None));