vendor/arrayvec-0.5.2/tests/tests.rs

   1 extern crate arrayvec;
   2 #[macro_use] extern crate matches;
   3
   4 use arrayvec::ArrayVec;
   5 use arrayvec::ArrayString;
   6 use std::mem;
   7 use arrayvec::CapacityError;
   8
   9 use std::collections::HashMap;
  10
  11
  12 #[test]
  13 fn test_simple() {
  14     use std::ops::Add;
  15
  16     let mut vec: ArrayVec<[Vec<i32>; 3]> = ArrayVec::new();
  17
  18     vec.push(vec![1, 2, 3, 4]);
  19     vec.push(vec![10]);
  20     vec.push(vec![-1, 13, -2]);
  21
  22     for elt in &vec {
  23         assert_eq!(elt.iter().fold(0, Add::add), 10);
  24     }
  25
  26     let sum_len = vec.into_iter().map(|x| x.len()).fold(0, Add::add);
  27     assert_eq!(sum_len, 8);
  28 }
  29
  30 #[test]
  31 fn test_capacity_left() {
  32     let mut vec: ArrayVec<[usize; 4]> = ArrayVec::new();
  33     assert_eq!(vec.remaining_capacity(), 4);
  34     vec.push(1);
  35     assert_eq!(vec.remaining_capacity(), 3);
  36     vec.push(2);
  37     assert_eq!(vec.remaining_capacity(), 2);
  38     vec.push(3);
  39     assert_eq!(vec.remaining_capacity(), 1);
  40     vec.push(4);
  41     assert_eq!(vec.remaining_capacity(), 0);
  42 }
  43
  44 #[test]
  45 fn test_extend_from_slice() {
  46     let mut vec: ArrayVec<[usize; 10]> = ArrayVec::new();
  47
  48     vec.try_extend_from_slice(&[1, 2, 3]).unwrap();
  49     assert_eq!(vec.len(), 3);
  50     assert_eq!(&vec[..], &[1, 2, 3]);
  51     assert_eq!(vec.pop(), Some(3));
  52     assert_eq!(&vec[..], &[1, 2]);
  53 }
  54
  55 #[test]
  56 fn test_extend_from_slice_error() {
  57     let mut vec: ArrayVec<[usize; 10]> = ArrayVec::new();
  58
  59     vec.try_extend_from_slice(&[1, 2, 3]).unwrap();
  60     let res = vec.try_extend_from_slice(&[0; 8]);
  61     assert_matches!(res, Err(_));
  62
  63     let mut vec: ArrayVec<[usize; 0]> = ArrayVec::new();
  64     let res = vec.try_extend_from_slice(&[0; 1]);
  65     assert_matches!(res, Err(_));
  66 }
  67
  68 #[test]
  69 fn test_try_from_slice_error() {
  70     use arrayvec::ArrayVec;
  71     use std::convert::TryInto as _;
  72
  73     let res: Result<ArrayVec<[_; 2]>, _> = (&[1, 2, 3] as &[_]).try_into();
  74     assert_matches!(res, Err(_));
  75 }
  76
  77 #[test]
  78 fn test_u16_index() {
  79     const N: usize = 4096;
  80     let mut vec: ArrayVec<[_; N]> = ArrayVec::new();
  81     for _ in 0..N {
  82         assert!(vec.try_push(1u8).is_ok());
  83     }
  84     assert!(vec.try_push(0).is_err());
  85     assert_eq!(vec.len(), N);
  86 }
  87
  88 #[test]
  89 fn test_iter() {
  90     let mut iter = ArrayVec::from([1, 2, 3]).into_iter();
  91     assert_eq!(iter.size_hint(), (3, Some(3)));
  92     assert_eq!(iter.next_back(), Some(3));
  93     assert_eq!(iter.next(), Some(1));
  94     assert_eq!(iter.next_back(), Some(2));
  95     assert_eq!(iter.size_hint(), (0, Some(0)));
  96     assert_eq!(iter.next_back(), None);
  97 }
  98
  99 #[test]
 100 fn test_drop() {
 101     use std::cell::Cell;
 102
 103     let flag = &Cell::new(0);
 104
 105     #[derive(Clone)]
 106     struct Bump<'a>(&'a Cell<i32>);
 107
 108     impl<'a> Drop for Bump<'a> {
 109         fn drop(&mut self) {
 110             let n = self.0.get();
 111             self.0.set(n + 1);
 112         }
 113     }
 114
 115     {
 116         let mut array = ArrayVec::<[Bump; 128]>::new();
 117         array.push(Bump(flag));
 118         array.push(Bump(flag));
 119     }
 120     assert_eq!(flag.get(), 2);
 121
 122     // test something with the nullable pointer optimization
 123     flag.set(0);
 124
 125     {
 126         let mut array = ArrayVec::<[_; 3]>::new();
 127         array.push(vec![Bump(flag)]);
 128         array.push(vec![Bump(flag), Bump(flag)]);
 129         array.push(vec![]);
 130         let push4 = array.try_push(vec![Bump(flag)]);
 131         assert_eq!(flag.get(), 0);
 132         drop(push4);
 133         assert_eq!(flag.get(), 1);
 134         drop(array.pop());
 135         assert_eq!(flag.get(), 1);
 136         drop(array.pop());
 137         assert_eq!(flag.get(), 3);
 138     }
 139
 140     assert_eq!(flag.get(), 4);
 141
 142     // test into_inner
 143     flag.set(0);
 144     {
 145         let mut array = ArrayVec::<[_; 3]>::new();
 146         array.push(Bump(flag));
 147         array.push(Bump(flag));
 148         array.push(Bump(flag));
 149         let inner = array.into_inner();
 150         assert!(inner.is_ok());
 151         assert_eq!(flag.get(), 0);
 152         drop(inner);
 153         assert_eq!(flag.get(), 3);
 154     }
 155
 156     // test cloning into_iter
 157     flag.set(0);
 158     {
 159         let mut array = ArrayVec::<[_; 3]>::new();
 160         array.push(Bump(flag));
 161         array.push(Bump(flag));
 162         array.push(Bump(flag));
 163         let mut iter = array.into_iter();
 164         assert_eq!(flag.get(), 0);
 165         iter.next();
 166         assert_eq!(flag.get(), 1);
 167         let clone = iter.clone();
 168         assert_eq!(flag.get(), 1);
 169         drop(clone);
 170         assert_eq!(flag.get(), 3);
 171         drop(iter);
 172         assert_eq!(flag.get(), 5);
 173     }
 174 }
 175
 176 #[test]
 177 fn test_drop_panics() {
 178     use std::cell::Cell;
 179     use std::panic::catch_unwind;
 180     use std::panic::AssertUnwindSafe;
 181
 182     let flag = &Cell::new(0);
 183
 184     struct Bump<'a>(&'a Cell<i32>);
 185
 186     // Panic in the first drop
 187     impl<'a> Drop for Bump<'a> {
 188         fn drop(&mut self) {
 189             let n = self.0.get();
 190             self.0.set(n + 1);
 191             if n == 0 {
 192                 panic!("Panic in Bump's drop");
 193             }
 194         }
 195     }
 196     // check if rust is new enough
 197     flag.set(0);
 198     {
 199         let array = vec![Bump(flag), Bump(flag)];
 200         let res = catch_unwind(AssertUnwindSafe(|| {
 201             drop(array);
 202         }));
 203         assert!(res.is_err());
 204     }
 205
 206     if flag.get() != 2 {
 207         println!("test_drop_panics: skip, this version of Rust doesn't continue in drop_in_place");
 208         return;
 209     }
 210
 211     flag.set(0);
 212     {
 213         let mut array = ArrayVec::<[Bump; 128]>::new();
 214         array.push(Bump(flag));
 215         array.push(Bump(flag));
 216         array.push(Bump(flag));
 217
 218         let res = catch_unwind(AssertUnwindSafe(|| {
 219             drop(array);
 220         }));
 221         assert!(res.is_err());
 222     }
 223     // Check that all the elements drop, even if the first drop panics.
 224     assert_eq!(flag.get(), 3);
 225
 226
 227     flag.set(0);
 228     {
 229         let mut array = ArrayVec::<[Bump; 16]>::new();
 230         array.push(Bump(flag));
 231         array.push(Bump(flag));
 232         array.push(Bump(flag));
 233         array.push(Bump(flag));
 234         array.push(Bump(flag));
 235
 236         let i = 2;
 237         let tail_len = array.len() - i;
 238
 239         let res = catch_unwind(AssertUnwindSafe(|| {
 240             array.truncate(i);
 241         }));
 242         assert!(res.is_err());
 243         // Check that all the tail elements drop, even if the first drop panics.
 244         assert_eq!(flag.get(), tail_len as i32);
 245     }
 246
 247
 248 }
 249
 250 #[test]
 251 fn test_extend() {
 252     let mut range = 0..10;
 253
 254     let mut array: ArrayVec<[_; 5]> = range.by_ref().collect();
 255     assert_eq!(&array[..], &[0, 1, 2, 3, 4]);
 256     assert_eq!(range.next(), Some(5));
 257
 258     array.extend(range.by_ref());
 259     assert_eq!(range.next(), Some(6));
 260
 261     let mut array: ArrayVec<[_; 10]> = (0..3).collect();
 262     assert_eq!(&array[..], &[0, 1, 2]);
 263     array.extend(3..5);
 264     assert_eq!(&array[..], &[0, 1, 2, 3, 4]);
 265 }
 266
 267 #[test]
 268 fn test_is_send_sync() {
 269     let data = ArrayVec::<[Vec<i32>; 5]>::new();
 270     &data as &dyn Send;
 271     &data as &dyn Sync;
 272 }
 273
 274 #[test]
 275 fn test_compact_size() {
 276     // Future rust will kill these drop flags!
 277     // 4 elements size + 1 len + 1 enum tag + [1 drop flag]
 278     type ByteArray = ArrayVec<[u8; 4]>;
 279     println!("{}", mem::size_of::<ByteArray>());
 280     assert!(mem::size_of::<ByteArray>() <= 8);
 281
 282     // 1 enum tag + 1 drop flag
 283     type EmptyArray = ArrayVec<[u8; 0]>;
 284     println!("{}", mem::size_of::<EmptyArray>());
 285     assert!(mem::size_of::<EmptyArray>() <= 2);
 286
 287     // 12 element size + 1 enum tag + 3 padding + 1 len + 1 drop flag + 2 padding
 288     type QuadArray = ArrayVec<[u32; 3]>;
 289     println!("{}", mem::size_of::<QuadArray>());
 290     assert!(mem::size_of::<QuadArray>() <= 24);
 291 }
 292
 293 #[test]
 294 fn test_still_works_with_option_arrayvec() {
 295     type RefArray = ArrayVec<[&'static i32; 2]>;
 296     let array = Some(RefArray::new());
 297     assert!(array.is_some());
 298     println!("{:?}", array);
 299 }
 300
 301 #[test]
 302 fn test_drain() {
 303     let mut v = ArrayVec::from([0; 8]);
 304     v.pop();
 305     v.drain(0..7);
 306     assert_eq!(&v[..], &[]);
 307
 308     v.extend(0..);
 309     v.drain(1..4);
 310     assert_eq!(&v[..], &[0, 4, 5, 6, 7]);
 311     let u: ArrayVec<[_; 3]> = v.drain(1..4).rev().collect();
 312     assert_eq!(&u[..], &[6, 5, 4]);
 313     assert_eq!(&v[..], &[0, 7]);
 314     v.drain(..);
 315     assert_eq!(&v[..], &[]);
 316 }
 317
 318 #[test]
 319 fn test_drain_range_inclusive() {
 320     let mut v = ArrayVec::from([0; 8]);
 321     v.drain(0..=7);
 322     assert_eq!(&v[..], &[]);
 323
 324     v.extend(0..);
 325     v.drain(1..=4);
 326     assert_eq!(&v[..], &[0, 5, 6, 7]);
 327     let u: ArrayVec<[_; 3]> = v.drain(1..=2).rev().collect();
 328     assert_eq!(&u[..], &[6, 5]);
 329     assert_eq!(&v[..], &[0, 7]);
 330     v.drain(..);
 331     assert_eq!(&v[..], &[]);
 332 }
 333
 334 #[test]
 335 #[should_panic]
 336 fn test_drain_range_inclusive_oob() {
 337     let mut v = ArrayVec::from([0; 0]);
 338     v.drain(0..=0);
 339 }
 340
 341 #[test]
 342 fn test_retain() {
 343     let mut v = ArrayVec::from([0; 8]);
 344     for (i, elt) in v.iter_mut().enumerate() {
 345         *elt = i;
 346     }
 347     v.retain(|_| true);
 348     assert_eq!(&v[..], &[0, 1, 2, 3, 4, 5, 6, 7]);
 349     v.retain(|elt| {
 350         *elt /= 2;
 351         *elt % 2 == 0
 352     });
 353     assert_eq!(&v[..], &[0, 0, 2, 2]);
 354     v.retain(|_| false);
 355     assert_eq!(&v[..], &[]);
 356 }
 357
 358 #[test]
 359 #[should_panic]
 360 fn test_drain_oob() {
 361     let mut v = ArrayVec::from([0; 8]);
 362     v.pop();
 363     v.drain(0..8);
 364 }
 365
 366 #[test]
 367 #[should_panic]
 368 fn test_drop_panic() {
 369     struct DropPanic;
 370
 371     impl Drop for DropPanic {
 372         fn drop(&mut self) {
 373             panic!("drop");
 374         }
 375     }
 376
 377     let mut array = ArrayVec::<[DropPanic; 1]>::new();
 378     array.push(DropPanic);
 379 }
 380
 381 #[test]
 382 #[should_panic]
 383 fn test_drop_panic_into_iter() {
 384     struct DropPanic;
 385
 386     impl Drop for DropPanic {
 387         fn drop(&mut self) {
 388             panic!("drop");
 389         }
 390     }
 391
 392     let mut array = ArrayVec::<[DropPanic; 1]>::new();
 393     array.push(DropPanic);
 394     array.into_iter();
 395 }
 396
 397 #[test]
 398 fn test_insert() {
 399     let mut v = ArrayVec::from([]);
 400     assert_matches!(v.try_push(1), Err(_));
 401
 402     let mut v = ArrayVec::<[_; 3]>::new();
 403     v.insert(0, 0);
 404     v.insert(1, 1);
 405     //let ret1 = v.try_insert(3, 3);
 406     //assert_matches!(ret1, Err(InsertError::OutOfBounds(_)));
 407     assert_eq!(&v[..], &[0, 1]);
 408     v.insert(2, 2);
 409     assert_eq!(&v[..], &[0, 1, 2]);
 410
 411     let ret2 = v.try_insert(1, 9);
 412     assert_eq!(&v[..], &[0, 1, 2]);
 413     assert_matches!(ret2, Err(_));
 414
 415     let mut v = ArrayVec::from([2]);
 416     assert_matches!(v.try_insert(0, 1), Err(CapacityError { .. }));
 417     assert_matches!(v.try_insert(1, 1), Err(CapacityError { .. }));
 418     //assert_matches!(v.try_insert(2, 1), Err(CapacityError { .. }));
 419 }
 420
 421 #[test]
 422 fn test_into_inner_1() {
 423     let mut v = ArrayVec::from([1, 2]);
 424     v.pop();
 425     let u = v.clone();
 426     assert_eq!(v.into_inner(), Err(u));
 427 }
 428
 429 #[test]
 430 fn test_into_inner_2() {
 431     let mut v = ArrayVec::<[String; 4]>::new();
 432     v.push("a".into());
 433     v.push("b".into());
 434     v.push("c".into());
 435     v.push("d".into());
 436     assert_eq!(v.into_inner().unwrap(), ["a", "b", "c", "d"]);
 437 }
 438
 439 #[test]
 440 fn test_into_inner_3_() {
 441     let mut v = ArrayVec::<[i32; 4]>::new();
 442     v.extend(1..);
 443     assert_eq!(v.into_inner().unwrap(), [1, 2, 3, 4]);
 444 }
 445
 446 #[cfg(feature="std")]
 447 #[test]
 448 fn test_write() {
 449     use std::io::Write;
 450     let mut v = ArrayVec::<[_; 8]>::new();
 451     write!(&mut v, "\x01\x02\x03").unwrap();
 452     assert_eq!(&v[..], &[1, 2, 3]);
 453     let r = v.write(&[9; 16]).unwrap();
 454     assert_eq!(r, 5);
 455     assert_eq!(&v[..], &[1, 2, 3, 9, 9, 9, 9, 9]);
 456 }
 457
 458 #[test]
 459 fn array_clone_from() {
 460     let mut v = ArrayVec::<[_; 4]>::new();
 461     v.push(vec![1, 2]);
 462     v.push(vec![3, 4, 5]);
 463     v.push(vec![6]);
 464     let reference = v.to_vec();
 465     let mut u = ArrayVec::<[_; 4]>::new();
 466     u.clone_from(&v);
 467     assert_eq!(&u, &reference[..]);
 468
 469     let mut t = ArrayVec::<[_; 4]>::new();
 470     t.push(vec![97]);
 471     t.push(vec![]);
 472     t.push(vec![5, 6, 2]);
 473     t.push(vec![2]);
 474     t.clone_from(&v);
 475     assert_eq!(&t, &reference[..]);
 476     t.clear();
 477     t.clone_from(&v);
 478     assert_eq!(&t, &reference[..]);
 479 }
 480
 481 #[cfg(feature="std")]
 482 #[test]
 483 fn test_string() {
 484     use std::error::Error;
 485
 486     let text = "hello world";
 487     let mut s = ArrayString::<[_; 16]>::new();
 488     s.try_push_str(text).unwrap();
 489     assert_eq!(&s, text);
 490     assert_eq!(text, &s);
 491
 492     // Make sure Hash / Eq / Borrow match up so we can use HashMap
 493     let mut map = HashMap::new();
 494     map.insert(s, 1);
 495     assert_eq!(map[text], 1);
 496
 497     let mut t = ArrayString::<[_; 2]>::new();
 498     assert!(t.try_push_str(text).is_err());
 499     assert_eq!(&t, "");
 500
 501     t.push_str("ab");
 502     // DerefMut
 503     let tmut: &mut str = &mut t;
 504     assert_eq!(tmut, "ab");
 505
 506     // Test Error trait / try
 507     let t = || -> Result<(), Box<dyn Error>> {
 508         let mut t = ArrayString::<[_; 2]>::new();
 509         t.try_push_str(text)?;
 510         Ok(())
 511     }();
 512     assert!(t.is_err());
 513 }
 514
 515 #[test]
 516 fn test_string_from() {
 517     let text = "hello world";
 518         // Test `from` constructor
 519     let u = ArrayString::<[_; 11]>::from(text).unwrap();
 520     assert_eq!(&u, text);
 521     assert_eq!(u.len(), text.len());
 522 }
 523
 524 #[test]
 525 fn test_string_parse_from_str() {
 526     let text = "hello world";
 527     let u: ArrayString<[_; 11]> = text.parse().unwrap();
 528     assert_eq!(&u, text);
 529     assert_eq!(u.len(), text.len());
 530 }
 531
 532 #[test]
 533 fn test_string_from_bytes() {
 534     let text = "hello world";
 535     let u = ArrayString::from_byte_string(b"hello world").unwrap();
 536     assert_eq!(&u, text);
 537     assert_eq!(u.len(), text.len());
 538 }
 539
 540 #[test]
 541 fn test_string_clone() {
 542     let text = "hi";
 543     let mut s = ArrayString::<[_; 4]>::new();
 544     s.push_str("abcd");
 545     let t = ArrayString::<[_; 4]>::from(text).unwrap();
 546     s.clone_from(&t);
 547     assert_eq!(&t, &s);
 548 }
 549
 550 #[test]
 551 fn test_string_push() {
 552     let text = "abcαβγ";
 553     let mut s = ArrayString::<[_; 8]>::new();
 554     for c in text.chars() {
 555         if let Err(_) = s.try_push(c) {
 556             break;
 557         }
 558     }
 559     assert_eq!("abcαβ", &s[..]);
 560     s.push('x');
 561     assert_eq!("abcαβx", &s[..]);
 562     assert!(s.try_push('x').is_err());
 563 }
 564
 565
 566 #[test]
 567 fn test_insert_at_length() {
 568     let mut v = ArrayVec::<[_; 8]>::new();
 569     let result1 = v.try_insert(0, "a");
 570     let result2 = v.try_insert(1, "b");
 571     assert!(result1.is_ok() && result2.is_ok());
 572     assert_eq!(&v[..], &["a", "b"]);
 573 }
 574
 575 #[should_panic]
 576 #[test]
 577 fn test_insert_out_of_bounds() {
 578     let mut v = ArrayVec::<[_; 8]>::new();
 579     let _ = v.try_insert(1, "test");
 580 }
 581
 582 /*
 583  * insert that pushes out the last
 584     let mut u = ArrayVec::from([1, 2, 3, 4]);
 585     let ret = u.try_insert(3, 99);
 586     assert_eq!(&u[..], &[1, 2, 3, 99]);
 587     assert_matches!(ret, Err(_));
 588     let ret = u.try_insert(4, 77);
 589     assert_eq!(&u[..], &[1, 2, 3, 99]);
 590     assert_matches!(ret, Err(_));
 591 */
 592
 593 #[test]
 594 fn test_drop_in_insert() {
 595     use std::cell::Cell;
 596
 597     let flag = &Cell::new(0);
 598
 599     struct Bump<'a>(&'a Cell<i32>);
 600
 601     impl<'a> Drop for Bump<'a> {
 602         fn drop(&mut self) {
 603             let n = self.0.get();
 604             self.0.set(n + 1);
 605         }
 606     }
 607
 608     flag.set(0);
 609
 610     {
 611         let mut array = ArrayVec::<[_; 2]>::new();
 612         array.push(Bump(flag));
 613         array.insert(0, Bump(flag));
 614         assert_eq!(flag.get(), 0);
 615         let ret = array.try_insert(1, Bump(flag));
 616         assert_eq!(flag.get(), 0);
 617         assert_matches!(ret, Err(_));
 618         drop(ret);
 619         assert_eq!(flag.get(), 1);
 620     }
 621     assert_eq!(flag.get(), 3);
 622 }
 623
 624 #[test]
 625 fn test_pop_at() {
 626     let mut v = ArrayVec::<[String; 4]>::new();
 627     let s = String::from;
 628     v.push(s("a"));
 629     v.push(s("b"));
 630     v.push(s("c"));
 631     v.push(s("d"));
 632
 633     assert_eq!(v.pop_at(4), None);
 634     assert_eq!(v.pop_at(1), Some(s("b")));
 635     assert_eq!(v.pop_at(1), Some(s("c")));
 636     assert_eq!(v.pop_at(2), None);
 637     assert_eq!(&v[..], &["a", "d"]);
 638 }
 639
 640 #[test]
 641 fn test_sizes() {
 642     let v = ArrayVec::from([0u8; 1 << 16]);
 643     assert_eq!(vec![0u8; v.len()], &v[..]);
 644 }
 645
 646 #[test]
 647 fn test_default() {
 648     use std::net;
 649     let s: ArrayString<[u8; 4]> = Default::default();
 650     // Something without `Default` implementation.
 651     let v: ArrayVec<[net::TcpStream; 4]> = Default::default();
 652     assert_eq!(s.len(), 0);
 653     assert_eq!(v.len(), 0);
 654 }
 655
 656 #[cfg(feature="array-sizes-33-128")]
 657 #[test]
 658 fn test_sizes_33_128() {
 659     ArrayVec::from([0u8; 52]);
 660     ArrayVec::from([0u8; 127]);
 661 }
 662
 663 #[cfg(feature="array-sizes-129-255")]
 664 #[test]
 665 fn test_sizes_129_255() {
 666     ArrayVec::from([0u8; 237]);
 667     ArrayVec::from([0u8; 255]);
 668 }
 669
 670 #[test]
 671 fn test_extend_zst() {
 672     let mut range = 0..10;
 673     #[derive(Copy, Clone, PartialEq, Debug)]
 674     struct Z; // Zero sized type
 675
 676     let mut array: ArrayVec<[_; 5]> = range.by_ref().map(|_| Z).collect();
 677     assert_eq!(&array[..], &[Z; 5]);
 678     assert_eq!(range.next(), Some(5));
 679
 680     array.extend(range.by_ref().map(|_| Z));
 681     assert_eq!(range.next(), Some(6));
 682
 683     let mut array: ArrayVec<[_; 10]> = (0..3).map(|_| Z).collect();
 684     assert_eq!(&array[..], &[Z; 3]);
 685     array.extend((3..5).map(|_| Z));
 686     assert_eq!(&array[..], &[Z; 5]);
 687     assert_eq!(array.len(), 5);
 688 }