Skip to content

Commit 30bb1f9

Browse files
JohnTitorJohnTitor
authored
Rollup merge of rust-lang#76718 - poliorcetics:vec-ui-to-unit-test, r=jyn514
Move Vec UI tests to unit tests when possible Helps with rust-lang#76268. I'm moving the tests using `Vec` or `VecDeque`. `@rustbot` modify labels: A-testsuite C-cleanup T-libs
2 parents 0fb0025 + 1bdee96 commit 30bb1f9

File tree

8 files changed

+193
-208
lines changed

8 files changed

+193
-208
lines changed

‎library/alloc/tests/slice.rs

+120
Original file line numberDiff line numberDiff line change
@@ -1,5 +1,6 @@
11
use std::cell::Cell;
22
use std::cmp::Ordering::{self, Equal, Greater, Less};
3+
use std::convert::identity;
34
use std::mem;
45
use std::panic;
56
use std::rc::Rc;
@@ -1778,3 +1779,122 @@ fn repeat_generic_slice() {
17781779
assert_eq!([1, 2, 3, 4].repeat(1), vec![1, 2, 3, 4]);
17791780
assert_eq!([1, 2, 3, 4].repeat(3), vec![1, 2, 3, 4, 1, 2, 3, 4, 1, 2, 3, 4]);
17801781
}
1782+
1783+
#[test]
1784+
#[allow(unreachable_patterns)]
1785+
fn subslice_patterns() {
1786+
// This test comprehensively checks the passing static and dynamic semantics
1787+
// of subslice patterns `..`, `x @ ..`, `ref x @ ..`, and `ref mut @ ..`
1788+
// in slice patterns `[$($pat), $(,)?]` .
1789+
1790+
#[derive(PartialEq, Debug, Clone)]
1791+
struct N(u8);
1792+
1793+
macro_rules! n {
1794+
($($e:expr),* $(,)?) => {
1795+
[$(N($e)),*]
1796+
}
1797+
}
1798+
1799+
macro_rules! c {
1800+
($inp:expr, $typ:ty, $out:expr $(,)?) => {
1801+
assert_eq!($out, identity::<$typ>($inp));
1802+
};
1803+
}
1804+
1805+
macro_rules! m {
1806+
($e:expr, $p:pat => $b:expr) => {
1807+
match $e {
1808+
$p => $b,
1809+
_ => panic!(),
1810+
}
1811+
};
1812+
}
1813+
1814+
// == Slices ==
1815+
1816+
// Matching slices using `ref` patterns:
1817+
let mut v = vec![N(0), N(1), N(2), N(3), N(4)];
1818+
let mut vc = (0..=4).collect::<Vec<u8>>();
1819+
1820+
let [..] = v[..]; // Always matches.
1821+
m!(v[..], [N(0), ref sub @ .., N(4)] => c!(sub, &[N], n![1, 2, 3]));
1822+
m!(v[..], [N(0), ref sub @ ..] => c!(sub, &[N], n![1, 2, 3, 4]));
1823+
m!(v[..], [ref sub @ .., N(4)] => c!(sub, &[N], n![0, 1, 2, 3]));
1824+
m!(v[..], [ref sub @ .., _, _, _, _, _] => c!(sub, &[N], &n![] as &[N]));
1825+
m!(v[..], [_, _, _, _, _, ref sub @ ..] => c!(sub, &[N], &n![] as &[N]));
1826+
m!(vc[..], [x, .., y] => c!((x, y), (u8, u8), (0, 4)));
1827+
1828+
// Matching slices using `ref mut` patterns:
1829+
let [..] = v[..]; // Always matches.
1830+
m!(v[..], [N(0), ref mut sub @ .., N(4)] => c!(sub, &mut [N], n![1, 2, 3]));
1831+
m!(v[..], [N(0), ref mut sub @ ..] => c!(sub, &mut [N], n![1, 2, 3, 4]));
1832+
m!(v[..], [ref mut sub @ .., N(4)] => c!(sub, &mut [N], n![0, 1, 2, 3]));
1833+
m!(v[..], [ref mut sub @ .., _, _, _, _, _] => c!(sub, &mut [N], &mut n![] as &mut [N]));
1834+
m!(v[..], [_, _, _, _, _, ref mut sub @ ..] => c!(sub, &mut [N], &mut n![] as &mut [N]));
1835+
m!(vc[..], [x, .., y] => c!((x, y), (u8, u8), (0, 4)));
1836+
1837+
// Matching slices using default binding modes (&):
1838+
let [..] = &v[..]; // Always matches.
1839+
m!(&v[..], [N(0), sub @ .., N(4)] => c!(sub, &[N], n![1, 2, 3]));
1840+
m!(&v[..], [N(0), sub @ ..] => c!(sub, &[N], n![1, 2, 3, 4]));
1841+
m!(&v[..], [sub @ .., N(4)] => c!(sub, &[N], n![0, 1, 2, 3]));
1842+
m!(&v[..], [sub @ .., _, _, _, _, _] => c!(sub, &[N], &n![] as &[N]));
1843+
m!(&v[..], [_, _, _, _, _, sub @ ..] => c!(sub, &[N], &n![] as &[N]));
1844+
m!(&vc[..], [x, .., y] => c!((x, y), (&u8, &u8), (&0, &4)));
1845+
1846+
// Matching slices using default binding modes (&mut):
1847+
let [..] = &mut v[..]; // Always matches.
1848+
m!(&mut v[..], [N(0), sub @ .., N(4)] => c!(sub, &mut [N], n![1, 2, 3]));
1849+
m!(&mut v[..], [N(0), sub @ ..] => c!(sub, &mut [N], n![1, 2, 3, 4]));
1850+
m!(&mut v[..], [sub @ .., N(4)] => c!(sub, &mut [N], n![0, 1, 2, 3]));
1851+
m!(&mut v[..], [sub @ .., _, _, _, _, _] => c!(sub, &mut [N], &mut n![] as &mut [N]));
1852+
m!(&mut v[..], [_, _, _, _, _, sub @ ..] => c!(sub, &mut [N], &mut n![] as &mut [N]));
1853+
m!(&mut vc[..], [x, .., y] => c!((x, y), (&mut u8, &mut u8), (&mut 0, &mut 4)));
1854+
1855+
// == Arrays ==
1856+
let mut v = n![0, 1, 2, 3, 4];
1857+
let vc = [0, 1, 2, 3, 4];
1858+
1859+
// Matching arrays by value:
1860+
m!(v.clone(), [N(0), sub @ .., N(4)] => c!(sub, [N; 3], n![1, 2, 3]));
1861+
m!(v.clone(), [N(0), sub @ ..] => c!(sub, [N; 4], n![1, 2, 3, 4]));
1862+
m!(v.clone(), [sub @ .., N(4)] => c!(sub, [N; 4], n![0, 1, 2, 3]));
1863+
m!(v.clone(), [sub @ .., _, _, _, _, _] => c!(sub, [N; 0], n![] as [N; 0]));
1864+
m!(v.clone(), [_, _, _, _, _, sub @ ..] => c!(sub, [N; 0], n![] as [N; 0]));
1865+
m!(v.clone(), [x, .., y] => c!((x, y), (N, N), (N(0), N(4))));
1866+
m!(v.clone(), [..] => ());
1867+
1868+
// Matching arrays by ref patterns:
1869+
m!(v, [N(0), ref sub @ .., N(4)] => c!(sub, &[N; 3], &n![1, 2, 3]));
1870+
m!(v, [N(0), ref sub @ ..] => c!(sub, &[N; 4], &n![1, 2, 3, 4]));
1871+
m!(v, [ref sub @ .., N(4)] => c!(sub, &[N; 4], &n![0, 1, 2, 3]));
1872+
m!(v, [ref sub @ .., _, _, _, _, _] => c!(sub, &[N; 0], &n![] as &[N; 0]));
1873+
m!(v, [_, _, _, _, _, ref sub @ ..] => c!(sub, &[N; 0], &n![] as &[N; 0]));
1874+
m!(vc, [x, .., y] => c!((x, y), (u8, u8), (0, 4)));
1875+
1876+
// Matching arrays by ref mut patterns:
1877+
m!(v, [N(0), ref mut sub @ .., N(4)] => c!(sub, &mut [N; 3], &mut n![1, 2, 3]));
1878+
m!(v, [N(0), ref mut sub @ ..] => c!(sub, &mut [N; 4], &mut n![1, 2, 3, 4]));
1879+
m!(v, [ref mut sub @ .., N(4)] => c!(sub, &mut [N; 4], &mut n![0, 1, 2, 3]));
1880+
m!(v, [ref mut sub @ .., _, _, _, _, _] => c!(sub, &mut [N; 0], &mut n![] as &mut [N; 0]));
1881+
m!(v, [_, _, _, _, _, ref mut sub @ ..] => c!(sub, &mut [N; 0], &mut n![] as &mut [N; 0]));
1882+
1883+
// Matching arrays by default binding modes (&):
1884+
m!(&v, [N(0), sub @ .., N(4)] => c!(sub, &[N; 3], &n![1, 2, 3]));
1885+
m!(&v, [N(0), sub @ ..] => c!(sub, &[N; 4], &n![1, 2, 3, 4]));
1886+
m!(&v, [sub @ .., N(4)] => c!(sub, &[N; 4], &n![0, 1, 2, 3]));
1887+
m!(&v, [sub @ .., _, _, _, _, _] => c!(sub, &[N; 0], &n![] as &[N; 0]));
1888+
m!(&v, [_, _, _, _, _, sub @ ..] => c!(sub, &[N; 0], &n![] as &[N; 0]));
1889+
m!(&v, [..] => ());
1890+
m!(&v, [x, .., y] => c!((x, y), (&N, &N), (&N(0), &N(4))));
1891+
1892+
// Matching arrays by default binding modes (&mut):
1893+
m!(&mut v, [N(0), sub @ .., N(4)] => c!(sub, &mut [N; 3], &mut n![1, 2, 3]));
1894+
m!(&mut v, [N(0), sub @ ..] => c!(sub, &mut [N; 4], &mut n![1, 2, 3, 4]));
1895+
m!(&mut v, [sub @ .., N(4)] => c!(sub, &mut [N; 4], &mut n![0, 1, 2, 3]));
1896+
m!(&mut v, [sub @ .., _, _, _, _, _] => c!(sub, &mut [N; 0], &mut n![] as &[N; 0]));
1897+
m!(&mut v, [_, _, _, _, _, sub @ ..] => c!(sub, &mut [N; 0], &mut n![] as &[N; 0]));
1898+
m!(&mut v, [..] => ());
1899+
m!(&mut v, [x, .., y] => c!((x, y), (&mut N, &mut N), (&mut N(0), &mut N(4))));
1900+
}

‎library/alloc/tests/vec.rs

+43-1
Original file line numberDiff line numberDiff line change
@@ -3,7 +3,7 @@ use std::cell::Cell;
33
use std::collections::TryReserveError::*;
44
use std::fmt::Debug;
55
use std::iter::InPlaceIterable;
6-
use std::mem::size_of;
6+
use std::mem::{size_of, swap};
77
use std::ops::Bound::*;
88
use std::panic::{catch_unwind, AssertUnwindSafe};
99
use std::rc::Rc;
@@ -1912,3 +1912,45 @@ fn test_vec_cycle_wrapped() {
19121912
c3.refs.v[0].set(Some(&c1));
19131913
c3.refs.v[1].set(Some(&c2));
19141914
}
1915+
1916+
#[test]
1917+
fn test_zero_sized_vec_push() {
1918+
const N: usize = 8;
1919+
1920+
for len in 0..N {
1921+
let mut tester = Vec::with_capacity(len);
1922+
assert_eq!(tester.len(), 0);
1923+
assert!(tester.capacity() >= len);
1924+
for _ in 0..len {
1925+
tester.push(());
1926+
}
1927+
assert_eq!(tester.len(), len);
1928+
assert_eq!(tester.iter().count(), len);
1929+
tester.clear();
1930+
}
1931+
}
1932+
1933+
#[test]
1934+
fn test_vec_macro_repeat() {
1935+
assert_eq!(vec![1; 3], vec![1, 1, 1]);
1936+
assert_eq!(vec![1; 2], vec![1, 1]);
1937+
assert_eq!(vec![1; 1], vec![1]);
1938+
assert_eq!(vec![1; 0], vec![]);
1939+
1940+
// from_elem syntax (see RFC 832)
1941+
let el = Box::new(1);
1942+
let n = 3;
1943+
assert_eq!(vec![el; n], vec![Box::new(1), Box::new(1), Box::new(1)]);
1944+
}
1945+
1946+
#[test]
1947+
fn test_vec_swap() {
1948+
let mut a: Vec<isize> = vec![0, 1, 2, 3, 4, 5, 6];
1949+
a.swap(2, 4);
1950+
assert_eq!(a[2], 4);
1951+
assert_eq!(a[4], 2);
1952+
let mut n = 42;
1953+
swap(&mut n, &mut a[0]);
1954+
assert_eq!(a[0], 42);
1955+
assert_eq!(n, 0);
1956+
}

‎library/alloc/tests/vec_deque.rs

+30
Original file line numberDiff line numberDiff line change
@@ -1698,3 +1698,33 @@ fn test_binary_search_by_key() {
16981698
assert_eq!(deque.binary_search_by_key(&3, |&(v,)| v), Ok(2));
16991699
assert_eq!(deque.binary_search_by_key(&4, |&(v,)| v), Err(3));
17001700
}
1701+
1702+
#[test]
1703+
fn test_zero_sized_push() {
1704+
const N: usize = 8;
1705+
1706+
// Zero sized type
1707+
struct Zst;
1708+
1709+
// Test that for all possible sequences of push_front / push_back,
1710+
// we end up with a deque of the correct size
1711+
1712+
for len in 0..N {
1713+
let mut tester = VecDeque::with_capacity(len);
1714+
assert_eq!(tester.len(), 0);
1715+
assert!(tester.capacity() >= len);
1716+
for case in 0..(1 << len) {
1717+
assert_eq!(tester.len(), 0);
1718+
for bit in 0..len {
1719+
if case & (1 << bit) != 0 {
1720+
tester.push_front(Zst);
1721+
} else {
1722+
tester.push_back(Zst);
1723+
}
1724+
}
1725+
assert_eq!(tester.len(), len);
1726+
assert_eq!(tester.iter().count(), len);
1727+
tester.clear();
1728+
}
1729+
}
1730+
}

‎src/test/ui/array-slice-vec/subslice-patterns-pass.rs

-126
This file was deleted.

‎src/test/ui/array-slice-vec/vec-macro-repeat.rs

-15
This file was deleted.

‎src/test/ui/swap-2.rs

-14
This file was deleted.

0 commit comments

Comments
 (0)