rust/library/core/tests/array.rs

377 lines
9.6 KiB
Rust
Raw Normal View History

2020-09-22 21:35:43 +02:00
use core::array::{self, FixedSizeArray, IntoIter};
use core::convert::TryFrom;
#[test]
fn fixed_size_array() {
let mut array = [0; 64];
let mut zero_sized = [(); 64];
let mut empty_array = [0; 0];
let mut empty_zero_sized = [(); 0];
assert_eq!(FixedSizeArray::as_slice(&array).len(), 64);
assert_eq!(FixedSizeArray::as_slice(&zero_sized).len(), 64);
assert_eq!(FixedSizeArray::as_slice(&empty_array).len(), 0);
assert_eq!(FixedSizeArray::as_slice(&empty_zero_sized).len(), 0);
assert_eq!(FixedSizeArray::as_mut_slice(&mut array).len(), 64);
assert_eq!(FixedSizeArray::as_mut_slice(&mut zero_sized).len(), 64);
assert_eq!(FixedSizeArray::as_mut_slice(&mut empty_array).len(), 0);
assert_eq!(FixedSizeArray::as_mut_slice(&mut empty_zero_sized).len(), 0);
}
2020-09-22 21:35:43 +02:00
#[test]
fn array_from_ref() {
let value: String = "Hello World!".into();
let arr: &[String; 1] = array::from_ref(&value);
assert_eq!(&[value.clone()], arr);
}
#[test]
fn array_from_mut() {
let mut value: String = "Hello World".into();
let arr: &mut [String; 1] = array::from_mut(&mut value);
arr[0].push_str("!");
assert_eq!(&value, "Hello World!");
}
#[test]
fn array_try_from() {
macro_rules! test {
($($N:expr)+) => {
$({
type Array = [u8; $N];
let array: Array = [0; $N];
let slice: &[u8] = &array[..];
let result = <&Array>::try_from(slice);
2017-09-24 20:54:04 +02:00
assert_eq!(&array, result.unwrap());
})+
}
}
test! {
0 1 2 3 4 5 6 7 8 9
10 11 12 13 14 15 16 17 18 19
20 21 22 23 24 25 26 27 28 29
30 31 32
}
}
#[test]
fn iterator_collect() {
let arr = [0, 1, 2, 5, 9];
let v: Vec<_> = IntoIter::new(arr.clone()).collect();
assert_eq!(&arr[..], &v[..]);
}
#[test]
fn iterator_rev_collect() {
let arr = [0, 1, 2, 5, 9];
let v: Vec<_> = IntoIter::new(arr.clone()).rev().collect();
assert_eq!(&v[..], &[9, 5, 2, 1, 0]);
}
#[test]
fn iterator_nth() {
let v = [0, 1, 2, 3, 4];
for i in 0..v.len() {
assert_eq!(IntoIter::new(v.clone()).nth(i).unwrap(), v[i]);
}
assert_eq!(IntoIter::new(v.clone()).nth(v.len()), None);
let mut iter = IntoIter::new(v);
assert_eq!(iter.nth(2).unwrap(), v[2]);
assert_eq!(iter.nth(1).unwrap(), v[4]);
}
#[test]
fn iterator_last() {
let v = [0, 1, 2, 3, 4];
assert_eq!(IntoIter::new(v).last().unwrap(), 4);
assert_eq!(IntoIter::new([0]).last().unwrap(), 0);
let mut it = IntoIter::new([0, 9, 2, 4]);
assert_eq!(it.next_back(), Some(4));
assert_eq!(it.last(), Some(2));
}
#[test]
fn iterator_clone() {
let mut it = IntoIter::new([0, 2, 4, 6, 8]);
assert_eq!(it.next(), Some(0));
assert_eq!(it.next_back(), Some(8));
let mut clone = it.clone();
assert_eq!(it.next_back(), Some(6));
assert_eq!(clone.next_back(), Some(6));
assert_eq!(it.next_back(), Some(4));
assert_eq!(clone.next_back(), Some(4));
assert_eq!(it.next(), Some(2));
assert_eq!(clone.next(), Some(2));
}
#[test]
fn iterator_fused() {
let mut it = IntoIter::new([0, 9, 2]);
assert_eq!(it.next(), Some(0));
assert_eq!(it.next(), Some(9));
assert_eq!(it.next(), Some(2));
assert_eq!(it.next(), None);
assert_eq!(it.next(), None);
assert_eq!(it.next(), None);
assert_eq!(it.next(), None);
assert_eq!(it.next(), None);
}
#[test]
fn iterator_len() {
let mut it = IntoIter::new([0, 1, 2, 5, 9]);
assert_eq!(it.size_hint(), (5, Some(5)));
assert_eq!(it.len(), 5);
assert_eq!(it.is_empty(), false);
assert_eq!(it.next(), Some(0));
assert_eq!(it.size_hint(), (4, Some(4)));
assert_eq!(it.len(), 4);
assert_eq!(it.is_empty(), false);
assert_eq!(it.next_back(), Some(9));
assert_eq!(it.size_hint(), (3, Some(3)));
assert_eq!(it.len(), 3);
assert_eq!(it.is_empty(), false);
// Empty
let it = IntoIter::new([] as [String; 0]);
assert_eq!(it.size_hint(), (0, Some(0)));
assert_eq!(it.len(), 0);
assert_eq!(it.is_empty(), true);
}
#[test]
fn iterator_count() {
let v = [0, 1, 2, 3, 4];
assert_eq!(IntoIter::new(v.clone()).count(), 5);
let mut iter2 = IntoIter::new(v);
iter2.next();
iter2.next();
assert_eq!(iter2.count(), 3);
}
#[test]
fn iterator_flat_map() {
assert!((0..5).flat_map(|i| IntoIter::new([2 * i, 2 * i + 1])).eq(0..10));
}
#[test]
fn iterator_debug() {
let arr = [0, 1, 2, 5, 9];
assert_eq!(format!("{:?}", IntoIter::new(arr)), "IntoIter([0, 1, 2, 5, 9])",);
}
#[test]
fn iterator_drops() {
use core::cell::Cell;
// This test makes sure the correct number of elements are dropped. The `R`
// type is just a reference to a `Cell` that is incremented when an `R` is
// dropped.
#[derive(Clone)]
struct Foo<'a>(&'a Cell<usize>);
impl Drop for Foo<'_> {
fn drop(&mut self) {
self.0.set(self.0.get() + 1);
}
}
fn five(i: &Cell<usize>) -> [Foo<'_>; 5] {
// This is somewhat verbose because `Foo` does not implement `Copy`
// since it implements `Drop`. Consequently, we cannot write
// `[Foo(i); 5]`.
[Foo(i), Foo(i), Foo(i), Foo(i), Foo(i)]
}
// Simple: drop new iterator.
let i = Cell::new(0);
{
IntoIter::new(five(&i));
}
assert_eq!(i.get(), 5);
// Call `next()` once.
let i = Cell::new(0);
{
let mut iter = IntoIter::new(five(&i));
let _x = iter.next();
assert_eq!(i.get(), 0);
assert_eq!(iter.count(), 4);
assert_eq!(i.get(), 4);
}
assert_eq!(i.get(), 5);
// Check `clone` and calling `next`/`next_back`.
let i = Cell::new(0);
{
let mut iter = IntoIter::new(five(&i));
iter.next();
assert_eq!(i.get(), 1);
iter.next_back();
assert_eq!(i.get(), 2);
let mut clone = iter.clone();
assert_eq!(i.get(), 2);
iter.next();
assert_eq!(i.get(), 3);
clone.next();
assert_eq!(i.get(), 4);
assert_eq!(clone.count(), 2);
assert_eq!(i.get(), 6);
}
assert_eq!(i.get(), 8);
// Check via `nth`.
let i = Cell::new(0);
{
let mut iter = IntoIter::new(five(&i));
let _x = iter.nth(2);
assert_eq!(i.get(), 2);
let _y = iter.last();
assert_eq!(i.get(), 3);
}
assert_eq!(i.get(), 5);
// Check every element.
let i = Cell::new(0);
for (index, _x) in IntoIter::new(five(&i)).enumerate() {
assert_eq!(i.get(), index);
}
assert_eq!(i.get(), 5);
let i = Cell::new(0);
for (index, _x) in IntoIter::new(five(&i)).rev().enumerate() {
assert_eq!(i.get(), index);
}
assert_eq!(i.get(), 5);
}
// This test does not work on targets without panic=unwind support.
// To work around this problem, test is marked is should_panic, so it will
// be automagically skipped on unsuitable targets, such as
// wasm32-unknown-unkown.
//
// It means that we use panic for indicating success.
#[test]
#[should_panic(expected = "test succeeded")]
fn array_default_impl_avoids_leaks_on_panic() {
use core::sync::atomic::{AtomicUsize, Ordering::Relaxed};
static COUNTER: AtomicUsize = AtomicUsize::new(0);
#[derive(Debug)]
struct Bomb(usize);
impl Default for Bomb {
fn default() -> Bomb {
if COUNTER.load(Relaxed) == 3 {
panic!("bomb limit exceeded");
}
COUNTER.fetch_add(1, Relaxed);
Bomb(COUNTER.load(Relaxed))
}
}
impl Drop for Bomb {
fn drop(&mut self) {
COUNTER.fetch_sub(1, Relaxed);
}
}
let res = std::panic::catch_unwind(|| <[Bomb; 5]>::default());
let panic_msg = match res {
Ok(_) => unreachable!(),
Err(p) => p.downcast::<&'static str>().unwrap(),
};
assert_eq!(*panic_msg, "bomb limit exceeded");
// check that all bombs are successfully dropped
assert_eq!(COUNTER.load(Relaxed), 0);
panic!("test succeeded")
}
#[test]
fn empty_array_is_always_default() {
struct DoesNotImplDefault;
let _arr = <[DoesNotImplDefault; 0]>::default();
}
#[test]
fn array_map() {
let a = [1, 2, 3];
let b = a.map(|v| v + 1);
assert_eq!(b, [2, 3, 4]);
let a = [1u8, 2, 3];
let b = a.map(|v| v as u64);
assert_eq!(b, [1, 2, 3]);
}
// See note on above test for why `should_panic` is used.
#[test]
#[should_panic(expected = "test succeeded")]
fn array_map_drop_safety() {
use core::sync::atomic::AtomicUsize;
use core::sync::atomic::Ordering;
static DROPPED: AtomicUsize = AtomicUsize::new(0);
struct DropCounter;
impl Drop for DropCounter {
fn drop(&mut self) {
DROPPED.fetch_add(1, Ordering::SeqCst);
}
}
let num_to_create = 5;
let success = std::panic::catch_unwind(|| {
let items = [0; 10];
let mut nth = 0;
items.map(|_| {
assert!(nth < num_to_create);
nth += 1;
DropCounter
});
});
assert!(success.is_err());
assert_eq!(DROPPED.load(Ordering::SeqCst), num_to_create);
panic!("test succeeded")
}
2020-09-10 15:27:48 +02:00
#[test]
fn cell_allows_array_cycle() {
use core::cell::Cell;
#[derive(Debug)]
struct B<'a> {
a: [Cell<Option<&'a B<'a>>>; 2],
}
impl<'a> B<'a> {
fn new() -> B<'a> {
B { a: [Cell::new(None), Cell::new(None)] }
}
}
let b1 = B::new();
let b2 = B::new();
let b3 = B::new();
b1.a[0].set(Some(&b2));
b1.a[1].set(Some(&b3));
b2.a[0].set(Some(&b2));
b2.a[1].set(Some(&b3));
b3.a[0].set(Some(&b1));
b3.a[1].set(Some(&b2));
}