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     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]
  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]
  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]
 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]
 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]
 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]
 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]
 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]
 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]
 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]
 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]
 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]
 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]
 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     r.advance_by(0).unwrap();
 304     r.advance_back_by(0).unwrap();
 305
 306     let mut r = 0u128..u128::MAX;
 307
 308     r.advance_by(usize::MAX).unwrap();
 309     r.advance_back_by(usize::MAX).unwrap();
 310
 311     assert_eq!((r.start, r.end), (0u128 + usize::MAX as u128, u128::MAX - usize::MAX as u128));
 312 }
 313
 314 #[test]
 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]);
 320 }
 321
 322 #[test]
 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);
 327
 328     assert_eq!((0..20).max(), Some(19));
 329     assert_eq!((-20..0).max(), Some(-1));
 330     assert_eq!((5..5).max(), None);
 331 }
 332
 333 #[test]
 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));
 338     let mut r = 10..=10;
 339     r.next();
 340     assert_eq!(r.last(), None);
 341
 342     assert_eq!((0..=20).max(), Some(20));
 343     assert_eq!((-20..=0).max(), Some(0));
 344     assert_eq!((5..=5).max(), Some(5));
 345     let mut r = 10..=10;
 346     r.next();
 347     assert_eq!(r.max(), None);
 348 }
 349
 350 #[test]
 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);
 355 }
 356
 357 #[test]
 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));
 362     let mut r = 10..=10;
 363     r.next();
 364     assert_eq!(r.min(), None);
 365 }
 366
 367 #[test]
 368 fn test_range_inclusive_folds() {
 369     assert_eq!((1..=10).sum::<i32>(), 55);
 370     assert_eq!((1..=10).rev().sum::<i32>(), 55);
 371
 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());
 381
 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());
 391
 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());
 397
 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());
 403 }
 404
 405 #[test]
 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)));
 410
 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));
 416
 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)));
 420
 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));
 427 }
 428
 429 #[test]
 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));
 436
 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));
 444
 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));
 450
 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));
 459 }
 460
 461 #[test]
 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");
 466     }
 467
 468     assert_eq!((11..14).rev().collect::<Vec<_>>(), [13, 12, 11]);
 469     for _ in (10..0).rev() {
 470         panic!("unreachable");
 471     }
 472 }