library/core/tests/iter/range.rs

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