nordic-dev.net/rust
nordic-dev.net/rust
2
0
Fork 0
mirror of https://github.com/rust-lang/rust.git synced 2024-11-01 23:12:02 +00:00
Code Issues Packages Projects Releases Wiki Activity

Rollup merge of #79038 - CDirkx:move-ui-tests, r=dtolnay

Browse Source 
Change ui test that are run-pass and that do not test the compiler to library tests

Part of #76268, these are some of the relevant ui tests I found that can be replaced by library tests.

Note: this PR just moves the tests, I have not checked for any overlap between these tests and existing library tests. The only test I changed is `env_home_dir`, where I added code to restore the old home dir after testing.

All moved tests:

| ui test | library test file | test |
| --- | --- | --- |
| `const\ascii_ctype.rs` | `core\tests\ascii.rs` | `ascii_ctype_const` |
| `const\const-str-ptr.rs` | `alloc\tests\str.rs` | `const_str_ptr` |
| `assert-eq-trailing-comma.rs` | `core\tests\macros.rs` | `assert_eq_trailing_comma` |
| `assert-escape.rs` | `core\tests\macros.rs` | `assert_escape` |
| `assert-ne-trailing-comma.rs` | `core\tests\macros.rs` | `assert_ne_trailing_comma` |
| `atomic-access-bool.rs` | `core\tests\atomic.rs` | `atomic_access_bool` |
| `atomic-alignment.rs` | `core\tests\atomic.rs` | `atomic_alignment` |
| `atomic-compare_exchange.rs` | `core\tests\atomic.rs` | `atomic_compare_exchange` |
| ~~`atomic-print.rs`~~ | ~~`std\tests\process.rs`~~ | ~~`atomic_print`~~ |
| `bool.rs` | `core\tests\bool.rs` | `test_bool` |
| `bool_not.rs` | `core\tests\bool.rs` | `test_bool_not` |
| `char_unicode.rs` | `core\tests\unicode.rs` | `version` |
| `cmp-default.rs` | `core\tests\cmp.rs` | `cmp_default` |
| `deref-mut-on-ref.rs` | `core\tests\ops.rs` | `deref_mut_on_ref` |
| `deref-on-ref.rs` | `core\tests\ops.rs` | `deref_on_ref` |
| `env-home-dir.rs` | `std\tests\env.rs` | `env_home_dir` |
| ~~`env-vars.rs`~~ | ~~`std\tests\env.rs`~~ | ~~`env_vars`~~ |
| `extend-for-unit.rs` | `core\tests\iter.rs` | `extend_for_unit` |
| `offset_from.rs` | `core\tests\ptr.rs` | `offset_from` |
| `option-ext.rs` | `core\tests\option.rs` | `option_ext` |
| `result-opt-conversions.rs` | `core\tests\result.rs` | `result_opt_conversions` |
| `sleep.rs` | `std\tests\thread.rs` | `sleep` |
| ~~`try-wait.rs`~~ | ~~`std\tests\process.rs`~~ | ~~`try_wait`~~ |
| `utf8.rs` | `alloc\tests\str.rs` | `utf8` |
| `utf8_chars.rs` | `alloc\tests\str.rs` | `utf8_chars` |
| `wrapping-int-api.rs` | `core\tests\num\wrapping.rs` | `wrapping_int_api` |
This commit is contained in:
Mara Bos 2020-12-01 10:50:02 +00:00 committed by GitHub
commit b565fe241e
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
38 changed files with 812 additions and 820 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

96
library/alloc/tests/str.rs
View File

@ -1,6 +1,6 @@
use std::borrow::Cow;
use std::cmp::Ordering::{Equal, Greater, Less};
use std::str::from_utf8;
use std::str::{from_utf8, from_utf8_unchecked};
#[test]
fn test_le() {
@ -1971,3 +1971,97 @@ fn test_str_escapes() {
";
assert_eq!(x, r"\\"); // extraneous whitespace stripped
}
#[test]
fn const_str_ptr() {
const A: [u8; 2] = ['h' as u8, 'i' as u8];
const B: &'static [u8; 2] = &A;
const C: *const u8 = B as *const u8;
unsafe {
let foo = &A as *const u8;
assert_eq!(foo, C);
assert_eq!(from_utf8_unchecked(&A), "hi");
assert_eq!(*C, A[0]);
assert_eq!(*(&B[0] as *const u8), A[0]);
}
}
#[test]
fn utf8() {
let yen: char = '¥'; // 0xa5
let c_cedilla: char = 'ç'; // 0xe7
let thorn: char = 'þ'; // 0xfe
let y_diaeresis: char = 'ÿ'; // 0xff
let pi: char = 'Π'; // 0x3a0
assert_eq!(yen as isize, 0xa5);
assert_eq!(c_cedilla as isize, 0xe7);
assert_eq!(thorn as isize, 0xfe);
assert_eq!(y_diaeresis as isize, 0xff);
assert_eq!(pi as isize, 0x3a0);
assert_eq!(pi as isize, '\u{3a0}' as isize);
assert_eq!('\x0a' as isize, '\n' as isize);
let bhutan: String = "འབྲུག་ཡུལ།".to_string();
let japan: String = "日本".to_string();
let uzbekistan: String = "Ўзбекистон".to_string();
let austria: String = "Österreich".to_string();
let bhutan_e: String =
"\u{f60}\u{f56}\u{fb2}\u{f74}\u{f42}\u{f0b}\u{f61}\u{f74}\u{f63}\u{f0d}".to_string();
let japan_e: String = "\u{65e5}\u{672c}".to_string();
let uzbekistan_e: String =
"\u{40e}\u{437}\u{431}\u{435}\u{43a}\u{438}\u{441}\u{442}\u{43e}\u{43d}".to_string();
let austria_e: String = "\u{d6}sterreich".to_string();
let oo: char = 'Ö';
assert_eq!(oo as isize, 0xd6);
fn check_str_eq(a: String, b: String) {
let mut i: isize = 0;
for ab in a.bytes() {
println!("{}", i);
println!("{}", ab);
let bb: u8 = b.as_bytes()[i as usize];
println!("{}", bb);
assert_eq!(ab, bb);
i += 1;
}
}
check_str_eq(bhutan, bhutan_e);
check_str_eq(japan, japan_e);
check_str_eq(uzbekistan, uzbekistan_e);
check_str_eq(austria, austria_e);
}
#[test]
fn utf8_chars() {
// Chars of 1, 2, 3, and 4 bytes
let chs: Vec<char> = vec!['e', 'é', '€', '\u{10000}'];
let s: String = chs.iter().cloned().collect();
let schs: Vec<char> = s.chars().collect();
assert_eq!(s.len(), 10);
assert_eq!(s.chars().count(), 4);
assert_eq!(schs.len(), 4);
assert_eq!(schs.iter().cloned().collect::<String>(), s);
assert!((from_utf8(s.as_bytes()).is_ok()));
// invalid prefix
assert!((!from_utf8(&[0x80]).is_ok()));
// invalid 2 byte prefix
assert!((!from_utf8(&[0xc0]).is_ok()));
assert!((!from_utf8(&[0xc0, 0x10]).is_ok()));
// invalid 3 byte prefix
assert!((!from_utf8(&[0xe0]).is_ok()));
assert!((!from_utf8(&[0xe0, 0x10]).is_ok()));
assert!((!from_utf8(&[0xe0, 0xff, 0x10]).is_ok()));
// invalid 4 byte prefix
assert!((!from_utf8(&[0xf0]).is_ok()));
assert!((!from_utf8(&[0xf0, 0x10]).is_ok()));
assert!((!from_utf8(&[0xf0, 0xff, 0x10]).is_ok()));
assert!((!from_utf8(&[0xf0, 0xff, 0xff, 0x10]).is_ok()));
}

53
library/core/tests/ascii.rs
View File

@ -408,3 +408,56 @@ fn ascii_const() {
const BYTE_IS_ASCII: bool = 97u8.is_ascii();
assert!(BYTE_IS_ASCII);
}
#[test]
fn ascii_ctype_const() {
macro_rules! suite {
( $( $fn:ident => [$a:ident, $A:ident, $nine:ident, $dot:ident, $space:ident]; )* ) => {
$(
mod $fn {
const CHAR_A_LOWER: bool = 'a'.$fn();
const CHAR_A_UPPER: bool = 'A'.$fn();
const CHAR_NINE: bool = '9'.$fn();
const CHAR_DOT: bool = '.'.$fn();
const CHAR_SPACE: bool = ' '.$fn();
const U8_A_LOWER: bool = b'a'.$fn();
const U8_A_UPPER: bool = b'A'.$fn();
const U8_NINE: bool = b'9'.$fn();
const U8_DOT: bool = b'.'.$fn();
const U8_SPACE: bool = b' '.$fn();
pub fn run() {
assert_eq!(CHAR_A_LOWER, $a);
assert_eq!(CHAR_A_UPPER, $A);
assert_eq!(CHAR_NINE, $nine);
assert_eq!(CHAR_DOT, $dot);
assert_eq!(CHAR_SPACE, $space);
assert_eq!(U8_A_LOWER, $a);
assert_eq!(U8_A_UPPER, $A);
assert_eq!(U8_NINE, $nine);
assert_eq!(U8_DOT, $dot);
assert_eq!(U8_SPACE, $space);
}
}
)*
$( $fn::run(); )*
}
}
suite! {
// 'a' 'A' '9' '.' ' '
is_ascii_alphabetic => [true, true, false, false, false];
is_ascii_uppercase => [false, true, false, false, false];
is_ascii_lowercase => [true, false, false, false, false];
is_ascii_alphanumeric => [true, true, true, false, false];
is_ascii_digit => [false, false, true, false, false];
is_ascii_hexdigit => [true, true, true, false, false];
is_ascii_punctuation => [false, false, false, true, false];
is_ascii_graphic => [true, true, true, true, false];
is_ascii_whitespace => [false, false, false, false, true];
is_ascii_control => [false, false, false, false, false];
}
}

79
library/core/tests/atomic.rs
View File

@ -101,3 +101,82 @@ fn static_init() {
assert!(S_INT.fetch_add(1, SeqCst) == 0);
assert!(S_UINT.fetch_add(1, SeqCst) == 0);
}
#[test]
fn atomic_access_bool() {
static mut ATOMIC: AtomicBool = AtomicBool::new(false);
unsafe {
assert_eq!(*ATOMIC.get_mut(), false);
ATOMIC.store(true, SeqCst);
assert_eq!(*ATOMIC.get_mut(), true);
ATOMIC.fetch_or(false, SeqCst);
assert_eq!(*ATOMIC.get_mut(), true);
ATOMIC.fetch_and(false, SeqCst);
assert_eq!(*ATOMIC.get_mut(), false);
ATOMIC.fetch_nand(true, SeqCst);
assert_eq!(*ATOMIC.get_mut(), true);
ATOMIC.fetch_xor(true, SeqCst);
assert_eq!(*ATOMIC.get_mut(), false);
}
}
#[test]
fn atomic_alignment() {
use std::mem::{align_of, size_of};
#[cfg(target_has_atomic = "8")]
assert_eq!(align_of::<AtomicBool>(), size_of::<AtomicBool>());
#[cfg(target_has_atomic = "ptr")]
assert_eq!(align_of::<AtomicPtr<u8>>(), size_of::<AtomicPtr<u8>>());
#[cfg(target_has_atomic = "8")]
assert_eq!(align_of::<AtomicU8>(), size_of::<AtomicU8>());
#[cfg(target_has_atomic = "8")]
assert_eq!(align_of::<AtomicI8>(), size_of::<AtomicI8>());
#[cfg(target_has_atomic = "16")]
assert_eq!(align_of::<AtomicU16>(), size_of::<AtomicU16>());
#[cfg(target_has_atomic = "16")]
assert_eq!(align_of::<AtomicI16>(), size_of::<AtomicI16>());
#[cfg(target_has_atomic = "32")]
assert_eq!(align_of::<AtomicU32>(), size_of::<AtomicU32>());
#[cfg(target_has_atomic = "32")]
assert_eq!(align_of::<AtomicI32>(), size_of::<AtomicI32>());
#[cfg(target_has_atomic = "64")]
assert_eq!(align_of::<AtomicU64>(), size_of::<AtomicU64>());
#[cfg(target_has_atomic = "64")]
assert_eq!(align_of::<AtomicI64>(), size_of::<AtomicI64>());
#[cfg(target_has_atomic = "128")]
assert_eq!(align_of::<AtomicU128>(), size_of::<AtomicU128>());
#[cfg(target_has_atomic = "128")]
assert_eq!(align_of::<AtomicI128>(), size_of::<AtomicI128>());
#[cfg(target_has_atomic = "ptr")]
assert_eq!(align_of::<AtomicUsize>(), size_of::<AtomicUsize>());
#[cfg(target_has_atomic = "ptr")]
assert_eq!(align_of::<AtomicIsize>(), size_of::<AtomicIsize>());
}
#[test]
fn atomic_compare_exchange() {
use Ordering::*;
static ATOMIC: AtomicIsize = AtomicIsize::new(0);
ATOMIC.compare_exchange(0, 1, Relaxed, Relaxed).ok();
ATOMIC.compare_exchange(0, 1, Acquire, Relaxed).ok();
ATOMIC.compare_exchange(0, 1, Release, Relaxed).ok();
ATOMIC.compare_exchange(0, 1, AcqRel, Relaxed).ok();
ATOMIC.compare_exchange(0, 1, SeqCst, Relaxed).ok();
ATOMIC.compare_exchange(0, 1, Acquire, Acquire).ok();
ATOMIC.compare_exchange(0, 1, AcqRel, Acquire).ok();
ATOMIC.compare_exchange(0, 1, SeqCst, Acquire).ok();
ATOMIC.compare_exchange(0, 1, SeqCst, SeqCst).ok();
ATOMIC.compare_exchange_weak(0, 1, Relaxed, Relaxed).ok();
ATOMIC.compare_exchange_weak(0, 1, Acquire, Relaxed).ok();
ATOMIC.compare_exchange_weak(0, 1, Release, Relaxed).ok();
ATOMIC.compare_exchange_weak(0, 1, AcqRel, Relaxed).ok();
ATOMIC.compare_exchange_weak(0, 1, SeqCst, Relaxed).ok();
ATOMIC.compare_exchange_weak(0, 1, Acquire, Acquire).ok();
ATOMIC.compare_exchange_weak(0, 1, AcqRel, Acquire).ok();
ATOMIC.compare_exchange_weak(0, 1, SeqCst, Acquire).ok();
ATOMIC.compare_exchange_weak(0, 1, SeqCst, SeqCst).ok();
}

84
library/core/tests/bool.rs
View File

@ -1,3 +1,87 @@
use core::cmp::Ordering::{Equal, Greater, Less};
use core::ops::{BitAnd, BitOr, BitXor};
#[test]
fn test_bool() {
assert_eq!(false.eq(&true), false);
assert_eq!(false == false, true);
assert_eq!(false != true, true);
assert_eq!(false.ne(&false), false);
assert_eq!(false.bitand(false), false);
assert_eq!(true.bitand(false), false);
assert_eq!(false.bitand(true), false);
assert_eq!(true.bitand(true), true);
assert_eq!(false & false, false);
assert_eq!(true & false, false);
assert_eq!(false & true, false);
assert_eq!(true & true, true);
assert_eq!(false.bitor(false), false);
assert_eq!(true.bitor(false), true);
assert_eq!(false.bitor(true), true);
assert_eq!(true.bitor(true), true);
assert_eq!(false | false, false);
assert_eq!(true | false, true);
assert_eq!(false | true, true);
assert_eq!(true | true, true);
assert_eq!(false.bitxor(false), false);
assert_eq!(true.bitxor(false), true);
assert_eq!(false.bitxor(true), true);
assert_eq!(true.bitxor(true), false);
assert_eq!(false ^ false, false);
assert_eq!(true ^ false, true);
assert_eq!(false ^ true, true);
assert_eq!(true ^ true, false);
assert_eq!(!true, false);
assert_eq!(!false, true);
let s = false.to_string();
assert_eq!(s, "false");
let s = true.to_string();
assert_eq!(s, "true");
assert!(true > false);
assert!(!(false > true));
assert!(false < true);
assert!(!(true < false));
assert!(false <= false);
assert!(false >= false);
assert!(true <= true);
assert!(true >= true);
assert!(false <= true);
assert!(!(false >= true));
assert!(true >= false);
assert!(!(true <= false));
assert_eq!(true.cmp(&true), Equal);
assert_eq!(false.cmp(&false), Equal);
assert_eq!(true.cmp(&false), Greater);
assert_eq!(false.cmp(&true), Less);
}
#[test]
pub fn test_bool_not() {
if !false {
assert!((true));
} else {
assert!((false));
}
if !true {
assert!((false));
} else {
assert!((true));
}
}
#[test]
fn test_bool_to_option() {
assert_eq!(false.then_some(0), None);

71
library/core/tests/cmp.rs
View File

@ -132,3 +132,74 @@ fn ordering_const() {
const THEN: Ordering = Equal.then(ORDERING);
assert_eq!(THEN, Greater);
}
#[test]
fn cmp_default() {
// Test default methods in PartialOrd and PartialEq
#[derive(Debug)]
struct Fool(bool);
impl PartialEq for Fool {
fn eq(&self, other: &Fool) -> bool {
let Fool(this) = *self;
let Fool(other) = *other;
this != other
}
}
struct Int(isize);
impl PartialEq for Int {
fn eq(&self, other: &Int) -> bool {
let Int(this) = *self;
let Int(other) = *other;
this == other
}
}
impl PartialOrd for Int {
fn partial_cmp(&self, other: &Int) -> Option<Ordering> {
let Int(this) = *self;
let Int(other) = *other;
this.partial_cmp(&other)
}
}
struct RevInt(isize);
impl PartialEq for RevInt {
fn eq(&self, other: &RevInt) -> bool {
let RevInt(this) = *self;
let RevInt(other) = *other;
this == other
}
}
impl PartialOrd for RevInt {
fn partial_cmp(&self, other: &RevInt) -> Option<Ordering> {
let RevInt(this) = *self;
let RevInt(other) = *other;
other.partial_cmp(&this)
}
}
assert!(Int(2) > Int(1));
assert!(Int(2) >= Int(1));
assert!(Int(1) >= Int(1));
assert!(Int(1) < Int(2));
assert!(Int(1) <= Int(2));
assert!(Int(1) <= Int(1));
assert!(RevInt(2) < RevInt(1));
assert!(RevInt(2) <= RevInt(1));
assert!(RevInt(1) <= RevInt(1));
assert!(RevInt(1) > RevInt(2));
assert!(RevInt(1) >= RevInt(2));
assert!(RevInt(1) >= RevInt(1));
assert_eq!(Fool(true), Fool(false));
assert!(Fool(true) != Fool(true));
assert!(Fool(false) != Fool(false));
assert_eq!(Fool(false), Fool(true));
}

12
library/core/tests/iter.rs
View File

@ -3493,3 +3493,15 @@ fn test_flatten_non_fused_inner() {
assert_eq!(iter.next(), Some(1));
assert_eq!(iter.next(), None);
}
#[test]
pub fn extend_for_unit() {
let mut x = 0;
{
let iter = (0..5).map(|_| {
x += 1;
});
().extend(iter);
}
assert_eq!(x, 5);
}

4
library/core/tests/lib.rs
View File

@ -8,6 +8,7 @@
#![feature(bound_cloned)]
#![feature(box_syntax)]
#![feature(cell_update)]
#![feature(cfg_target_has_atomic)]
#![feature(const_assume)]
#![feature(const_cell_into_inner)]
#![feature(core_intrinsics)]
@ -63,6 +64,7 @@
#![feature(int_bits_const)]
#![feature(nonzero_leading_trailing_zeros)]
#![feature(const_option)]
#![feature(integer_atomics)]
#![deny(unsafe_op_in_unsafe_fn)]
extern crate test;
@ -82,6 +84,7 @@ mod hash;
mod intrinsics;
mod iter;
mod lazy;
mod macros;
mod manually_drop;
mod mem;
mod nonzero;
@ -98,3 +101,4 @@ mod str_lossy;
mod task;
mod time;
mod tuple;
mod unicode;

14
library/core/tests/macros.rs Normal file
View File

@ -0,0 +1,14 @@
#[test]
fn assert_eq_trailing_comma() {
assert_eq!(1, 1,);
}
#[test]
fn assert_escape() {
assert!(r#"☃\backslash"#.contains("\\"));
}
#[test]
fn assert_ne_trailing_comma() {
assert_ne!(1, 2,);
}

233
library/core/tests/num/wrapping.rs
View File

@ -74,3 +74,236 @@ wrapping_test!(u64, u64::MIN, u64::MAX);
#[cfg(not(target_os = "emscripten"))]
wrapping_test!(u128, u128::MIN, u128::MAX);
wrapping_test!(usize, usize::MIN, usize::MAX);
// Don't warn about overflowing ops on 32-bit platforms
#[cfg_attr(target_pointer_width = "32", allow(const_err))]
fn wrapping_int_api() {
assert_eq!(i8::MAX.wrapping_add(1), i8::MIN);
assert_eq!(i16::MAX.wrapping_add(1), i16::MIN);
assert_eq!(i32::MAX.wrapping_add(1), i32::MIN);
assert_eq!(i64::MAX.wrapping_add(1), i64::MIN);
assert_eq!(isize::MAX.wrapping_add(1), isize::MIN);
assert_eq!(i8::MIN.wrapping_sub(1), i8::MAX);
assert_eq!(i16::MIN.wrapping_sub(1), i16::MAX);
assert_eq!(i32::MIN.wrapping_sub(1), i32::MAX);
assert_eq!(i64::MIN.wrapping_sub(1), i64::MAX);
assert_eq!(isize::MIN.wrapping_sub(1), isize::MAX);
assert_eq!(u8::MAX.wrapping_add(1), u8::MIN);
assert_eq!(u16::MAX.wrapping_add(1), u16::MIN);
assert_eq!(u32::MAX.wrapping_add(1), u32::MIN);
assert_eq!(u64::MAX.wrapping_add(1), u64::MIN);
assert_eq!(usize::MAX.wrapping_add(1), usize::MIN);
assert_eq!(u8::MIN.wrapping_sub(1), u8::MAX);
assert_eq!(u16::MIN.wrapping_sub(1), u16::MAX);
assert_eq!(u32::MIN.wrapping_sub(1), u32::MAX);
assert_eq!(u64::MIN.wrapping_sub(1), u64::MAX);
assert_eq!(usize::MIN.wrapping_sub(1), usize::MAX);
assert_eq!((0xfe_u8 as i8).wrapping_mul(16), (0xe0_u8 as i8));
assert_eq!((0xfedc_u16 as i16).wrapping_mul(16), (0xedc0_u16 as i16));
assert_eq!((0xfedc_ba98_u32 as i32).wrapping_mul(16), (0xedcb_a980_u32 as i32));
assert_eq!(
(0xfedc_ba98_7654_3217_u64 as i64).wrapping_mul(16),
(0xedcb_a987_6543_2170_u64 as i64)
);
match () {
#[cfg(target_pointer_width = "32")]
() => {
assert_eq!((0xfedc_ba98_u32 as isize).wrapping_mul(16), (0xedcb_a980_u32 as isize));
}
#[cfg(target_pointer_width = "64")]
() => {
assert_eq!(
(0xfedc_ba98_7654_3217_u64 as isize).wrapping_mul(16),
(0xedcb_a987_6543_2170_u64 as isize)
);
}
}
assert_eq!((0xfe as u8).wrapping_mul(16), (0xe0 as u8));
assert_eq!((0xfedc as u16).wrapping_mul(16), (0xedc0 as u16));
assert_eq!((0xfedc_ba98 as u32).wrapping_mul(16), (0xedcb_a980 as u32));
assert_eq!((0xfedc_ba98_7654_3217 as u64).wrapping_mul(16), (0xedcb_a987_6543_2170 as u64));
match () {
#[cfg(target_pointer_width = "32")]
() => {
assert_eq!((0xfedc_ba98 as usize).wrapping_mul(16), (0xedcb_a980 as usize));
}
#[cfg(target_pointer_width = "64")]
() => {
assert_eq!(
(0xfedc_ba98_7654_3217 as usize).wrapping_mul(16),
(0xedcb_a987_6543_2170 as usize)
);
}
}
macro_rules! check_mul_no_wrap {
($e:expr, $f:expr) => {
assert_eq!(($e).wrapping_mul($f), ($e) * $f);
};
}
macro_rules! check_mul_wraps {
($e:expr, $f:expr) => {
assert_eq!(($e).wrapping_mul($f), $e);
};
}
check_mul_no_wrap!(0xfe_u8 as i8, -1);
check_mul_no_wrap!(0xfedc_u16 as i16, -1);
check_mul_no_wrap!(0xfedc_ba98_u32 as i32, -1);
check_mul_no_wrap!(0xfedc_ba98_7654_3217_u64 as i64, -1);
check_mul_no_wrap!(0xfedc_ba98_7654_3217_u64 as u64 as isize, -1);
check_mul_no_wrap!(0xfe_u8 as i8, -2);
check_mul_no_wrap!(0xfedc_u16 as i16, -2);
check_mul_no_wrap!(0xfedc_ba98_u32 as i32, -2);
check_mul_no_wrap!(0xfedc_ba98_7654_3217_u64 as i64, -2);
check_mul_no_wrap!(0xfedc_ba98_fedc_ba98_u64 as u64 as isize, -2);
check_mul_no_wrap!(0xfe_u8 as i8, 2);
check_mul_no_wrap!(0xfedc_u16 as i16, 2);
check_mul_no_wrap!(0xfedc_ba98_u32 as i32, 2);
check_mul_no_wrap!(0xfedc_ba98_7654_3217_u64 as i64, 2);
check_mul_no_wrap!(0xfedc_ba98_fedc_ba98_u64 as u64 as isize, 2);
check_mul_wraps!(0x80_u8 as i8, -1);
check_mul_wraps!(0x8000_u16 as i16, -1);
check_mul_wraps!(0x8000_0000_u32 as i32, -1);
check_mul_wraps!(0x8000_0000_0000_0000_u64 as i64, -1);
match () {
#[cfg(target_pointer_width = "32")]
() => {
check_mul_wraps!(0x8000_0000_u32 as isize, -1);
}
#[cfg(target_pointer_width = "64")]
() => {
check_mul_wraps!(0x8000_0000_0000_0000_u64 as isize, -1);
}
}
macro_rules! check_div_no_wrap {
($e:expr, $f:expr) => {
assert_eq!(($e).wrapping_div($f), ($e) / $f);
};
}
macro_rules! check_div_wraps {
($e:expr, $f:expr) => {
assert_eq!(($e).wrapping_div($f), $e);
};
}
check_div_no_wrap!(0xfe_u8 as i8, -1);
check_div_no_wrap!(0xfedc_u16 as i16, -1);
check_div_no_wrap!(0xfedc_ba98_u32 as i32, -1);
check_div_no_wrap!(0xfedc_ba98_7654_3217_u64 as i64, -1);
check_div_no_wrap!(0xfedc_ba98_7654_3217_u64 as u64 as isize, -1);
check_div_no_wrap!(0xfe_u8 as i8, -2);
check_div_no_wrap!(0xfedc_u16 as i16, -2);
check_div_no_wrap!(0xfedc_ba98_u32 as i32, -2);
check_div_no_wrap!(0xfedc_ba98_7654_3217_u64 as i64, -2);
check_div_no_wrap!(0xfedc_ba98_7654_3217_u64 as u64 as isize, -2);
check_div_no_wrap!(0xfe_u8 as i8, 2);
check_div_no_wrap!(0xfedc_u16 as i16, 2);
check_div_no_wrap!(0xfedc_ba98_u32 as i32, 2);
check_div_no_wrap!(0xfedc_ba98_7654_3217_u64 as i64, 2);
check_div_no_wrap!(0xfedc_ba98_7654_3217_u64 as u64 as isize, 2);
check_div_wraps!(-128 as i8, -1);
check_div_wraps!(0x8000_u16 as i16, -1);
check_div_wraps!(0x8000_0000_u32 as i32, -1);
check_div_wraps!(0x8000_0000_0000_0000_u64 as i64, -1);
match () {
#[cfg(target_pointer_width = "32")]
() => {
check_div_wraps!(0x8000_0000_u32 as isize, -1);
}
#[cfg(target_pointer_width = "64")]
() => {
check_div_wraps!(0x8000_0000_0000_0000_u64 as isize, -1);
}
}
macro_rules! check_rem_no_wrap {
($e:expr, $f:expr) => {
assert_eq!(($e).wrapping_rem($f), ($e) % $f);
};
}
macro_rules! check_rem_wraps {
($e:expr, $f:expr) => {
assert_eq!(($e).wrapping_rem($f), 0);
};
}
check_rem_no_wrap!(0xfe_u8 as i8, -1);
check_rem_no_wrap!(0xfedc_u16 as i16, -1);
check_rem_no_wrap!(0xfedc_ba98_u32 as i32, -1);
check_rem_no_wrap!(0xfedc_ba98_7654_3217_u64 as i64, -1);
check_rem_no_wrap!(0xfedc_ba98_7654_3217_u64 as u64 as isize, -1);
check_rem_no_wrap!(0xfe_u8 as i8, -2);
check_rem_no_wrap!(0xfedc_u16 as i16, -2);
check_rem_no_wrap!(0xfedc_ba98_u32 as i32, -2);
check_rem_no_wrap!(0xfedc_ba98_7654_3217_u64 as i64, -2);
check_rem_no_wrap!(0xfedc_ba98_7654_3217_u64 as u64 as isize, -2);
check_rem_no_wrap!(0xfe_u8 as i8, 2);
check_rem_no_wrap!(0xfedc_u16 as i16, 2);
check_rem_no_wrap!(0xfedc_ba98_u32 as i32, 2);
check_rem_no_wrap!(0xfedc_ba98_7654_3217_u64 as i64, 2);
check_rem_no_wrap!(0xfedc_ba98_7654_3217_u64 as u64 as isize, 2);
check_rem_wraps!(0x80_u8 as i8, -1);
check_rem_wraps!(0x8000_u16 as i16, -1);
check_rem_wraps!(0x8000_0000_u32 as i32, -1);
check_rem_wraps!(0x8000_0000_0000_0000_u64 as i64, -1);
match () {
#[cfg(target_pointer_width = "32")]
() => {
check_rem_wraps!(0x8000_0000_u32 as isize, -1);
}
#[cfg(target_pointer_width = "64")]
() => {
check_rem_wraps!(0x8000_0000_0000_0000_u64 as isize, -1);
}
}
macro_rules! check_neg_no_wrap {
($e:expr) => {
assert_eq!(($e).wrapping_neg(), -($e));
};
}
macro_rules! check_neg_wraps {
($e:expr) => {
assert_eq!(($e).wrapping_neg(), ($e));
};
}
check_neg_no_wrap!(0xfe_u8 as i8);
check_neg_no_wrap!(0xfedc_u16 as i16);
check_neg_no_wrap!(0xfedc_ba98_u32 as i32);
check_neg_no_wrap!(0xfedc_ba98_7654_3217_u64 as i64);
check_neg_no_wrap!(0xfedc_ba98_7654_3217_u64 as u64 as isize);
check_neg_wraps!(0x80_u8 as i8);
check_neg_wraps!(0x8000_u16 as i16);
check_neg_wraps!(0x8000_0000_u32 as i32);
check_neg_wraps!(0x8000_0000_0000_0000_u64 as i64);
match () {
#[cfg(target_pointer_width = "32")]
() => {
check_neg_wraps!(0x8000_0000_u32 as isize);
}
#[cfg(target_pointer_width = "64")]
() => {
check_neg_wraps!(0x8000_0000_0000_0000_u64 as isize);
}
}
}

33
library/core/tests/ops.rs
View File

@ -1,4 +1,5 @@
use core::ops::{Bound, Range, RangeFrom, RangeFull, RangeInclusive, RangeTo, RangeToInclusive};
use core::ops::{Deref, DerefMut};
// Test the Range structs and syntax.
@ -197,3 +198,35 @@ fn range_structural_match() {
_ => unreachable!(),
}
}
// Test Deref implementations
#[test]
fn deref_mut_on_ref() {
// Test that `&mut T` implements `DerefMut<T>`
fn inc<T: Deref<Target = isize> + DerefMut>(mut t: T) {
*t += 1;
}
let mut x: isize = 5;
inc(&mut x);
assert_eq!(x, 6);
}
#[test]
fn deref_on_ref() {
// Test that `&T` and `&mut T` implement `Deref<T>`
fn deref<U: Copy, T: Deref<Target = U>>(t: T) -> U {
*t
}
let x: isize = 3;
let y = deref(&x);
assert_eq!(y, 3);
let mut x: isize = 4;
let y = deref(&mut x);
assert_eq!(y, 4);
}

10
library/core/tests/option.rs
View File

@ -402,3 +402,13 @@ fn test_unwrap_drop() {
assert_eq!(x.get(), 0);
}
#[test]
pub fn option_ext() {
let thing = "{{ f }}";
let f = thing.find("{{");
if f.is_none() {
println!("None!");
}
}

13
library/core/tests/ptr.rs
View File

@ -400,3 +400,16 @@ fn align_offset_weird_strides() {
}
assert!(!x);
}
#[test]
fn offset_from() {
let mut a = [0; 5];
let ptr1: *mut i32 = &mut a[1];
let ptr2: *mut i32 = &mut a[3];
unsafe {
assert_eq!(ptr2.offset_from(ptr1), 2);
assert_eq!(ptr1.offset_from(ptr2), -2);
assert_eq!(ptr1.offset(2), ptr2);
assert_eq!(ptr2.offset(-2), ptr1);
}
}

38
library/core/tests/result.rs
View File

@ -320,3 +320,41 @@ fn result_const() {
const IS_ERR: bool = RESULT.is_err();
assert!(!IS_ERR)
}
#[test]
fn result_opt_conversions() {
#[derive(Copy, Clone, Debug, PartialEq)]
struct BadNumErr;
fn try_num(x: i32) -> Result<i32, BadNumErr> {
if x <= 5 { Ok(x + 1) } else { Err(BadNumErr) }
}
type ResOpt = Result<Option<i32>, BadNumErr>;
type OptRes = Option<Result<i32, BadNumErr>>;
let mut x: ResOpt = Ok(Some(5));
let mut y: OptRes = Some(Ok(5));
assert_eq!(x, y.transpose());
assert_eq!(x.transpose(), y);
x = Ok(None);
y = None;
assert_eq!(x, y.transpose());
assert_eq!(x.transpose(), y);
x = Err(BadNumErr);
y = Some(Err(BadNumErr));
assert_eq!(x, y.transpose());
assert_eq!(x.transpose(), y);
let res: Result<Vec<i32>, BadNumErr> = (0..10)
.map(|x| {
let y = try_num(x)?;
Ok(if y % 2 == 0 { Some(y - 1) } else { None })
})
.filter_map(Result::transpose)
.collect();
assert_eq!(res, Err(BadNumErr))
}

5
library/core/tests/unicode.rs Normal file
View File

@ -0,0 +1,5 @@
#[test]
pub fn version() {
let (major, _minor, _update) = core::unicode::UNICODE_VERSION;
assert!(major >= 10);
}

61
library/std/tests/env.rs
View File

@ -1,5 +1,6 @@
use std::env::*;
use std::ffi::{OsStr, OsString};
use std::path::PathBuf;
use rand::distributions::Alphanumeric;
use rand::{thread_rng, Rng};
@ -76,3 +77,63 @@ fn test_env_set_var() {
assert!(vars_os().any(|(k, v)| { &*k == &*n && &*v == "VALUE" }));
}
#[test]
#[cfg_attr(any(target_os = "emscripten", target_env = "sgx"), ignore)]
#[allow(deprecated)]
fn env_home_dir() {
fn var_to_os_string(var: Result<String, VarError>) -> Option<OsString> {
match var {
Ok(var) => Some(OsString::from(var)),
Err(VarError::NotUnicode(var)) => Some(var),
_ => None,
}
}
cfg_if::cfg_if! {
if #[cfg(unix)] {
let oldhome = var_to_os_string(var("HOME"));
set_var("HOME", "/home/MountainView");
assert_eq!(home_dir(), Some(PathBuf::from("/home/MountainView")));
remove_var("HOME");
if cfg!(target_os = "android") {
assert!(home_dir().is_none());
} else {
// When HOME is not set, some platforms return `None`,
// but others return `Some` with a default.
// Just check that it is not "/home/MountainView".
assert_ne!(home_dir(), Some(PathBuf::from("/home/MountainView")));
}
if let Some(oldhome) = oldhome { set_var("HOME", oldhome); }
} else if #[cfg(windows)] {
let oldhome = var_to_os_string(var("HOME"));
let olduserprofile = var_to_os_string(var("USERPROFILE"));
remove_var("HOME");
remove_var("USERPROFILE");
assert!(home_dir().is_some());
set_var("HOME", "/home/MountainView");
assert_eq!(home_dir(), Some(PathBuf::from("/home/MountainView")));
remove_var("HOME");
set_var("USERPROFILE", "/home/MountainView");
assert_eq!(home_dir(), Some(PathBuf::from("/home/MountainView")));
set_var("HOME", "/home/MountainView");
set_var("USERPROFILE", "/home/PaloAlto");
assert_eq!(home_dir(), Some(PathBuf::from("/home/MountainView")));
remove_var("HOME");
remove_var("USERPROFILE");
if let Some(oldhome) = oldhome { set_var("HOME", oldhome); }
if let Some(olduserprofile) = olduserprofile { set_var("USERPROFILE", olduserprofile); }
}
}
}

15
src/test/ui/sleep.rs → library/std/tests/thread.rs
View File

@ -1,17 +1,16 @@
// run-pass
// ignore-emscripten no threads support
use std::thread::{self, sleep};
use std::time::Duration;
use std::sync::{Arc, Mutex};
use std::thread;
use std::time::Duration;
fn main() {
#[test]
#[cfg_attr(target_os = "emscripten", ignore)]
fn sleep() {
let finished = Arc::new(Mutex::new(false));
let t_finished = finished.clone();
thread::spawn(move || {
sleep(Duration::new(u64::MAX, 0));
thread::sleep(Duration::new(u64::MAX, 0));
*t_finished.lock().unwrap() = true;
});
sleep(Duration::from_millis(100));
thread::sleep(Duration::from_millis(100));
assert_eq!(*finished.lock().unwrap(), false);
}

5
src/test/ui/assert-eq-trailing-comma.rs
View File

@ -1,5 +0,0 @@
// run-pass
fn main() {
assert_eq!(1, 1,);
}

5
src/test/ui/assert-escape.rs
View File

@ -1,5 +0,0 @@
// run-pass
fn main() {
assert!(r#"☃\backslash"#.contains("\\"));
}

5
src/test/ui/assert-ne-trailing-comma.rs
View File

@ -1,5 +0,0 @@
// run-pass
fn main() {
assert_ne!(1, 2,);
}

24
src/test/ui/atomic-access-bool.rs
View File

@ -1,24 +0,0 @@
// run-pass
#![allow(stable_features)]
#![feature(atomic_access)]
use std::sync::atomic::AtomicBool;
use std::sync::atomic::Ordering::*;
static mut ATOMIC: AtomicBool = AtomicBool::new(false);
fn main() {
unsafe {
assert_eq!(*ATOMIC.get_mut(), false);
ATOMIC.store(true, SeqCst);
assert_eq!(*ATOMIC.get_mut(), true);
ATOMIC.fetch_or(false, SeqCst);
assert_eq!(*ATOMIC.get_mut(), true);
ATOMIC.fetch_and(false, SeqCst);
assert_eq!(*ATOMIC.get_mut(), false);
ATOMIC.fetch_nand(true, SeqCst);
assert_eq!(*ATOMIC.get_mut(), true);
ATOMIC.fetch_xor(true, SeqCst);
assert_eq!(*ATOMIC.get_mut(), false);
}
}

38
src/test/ui/atomic-alignment.rs
View File

@ -1,38 +0,0 @@
// run-pass
#![feature(cfg_target_has_atomic)]
#![feature(integer_atomics)]
use std::mem::{align_of, size_of};
use std::sync::atomic::*;
fn main() {
#[cfg(target_has_atomic = "8")]
assert_eq!(align_of::<AtomicBool>(), size_of::<AtomicBool>());
#[cfg(target_has_atomic = "ptr")]
assert_eq!(align_of::<AtomicPtr<u8>>(), size_of::<AtomicPtr<u8>>());
#[cfg(target_has_atomic = "8")]
assert_eq!(align_of::<AtomicU8>(), size_of::<AtomicU8>());
#[cfg(target_has_atomic = "8")]
assert_eq!(align_of::<AtomicI8>(), size_of::<AtomicI8>());
#[cfg(target_has_atomic = "16")]
assert_eq!(align_of::<AtomicU16>(), size_of::<AtomicU16>());
#[cfg(target_has_atomic = "16")]
assert_eq!(align_of::<AtomicI16>(), size_of::<AtomicI16>());
#[cfg(target_has_atomic = "32")]
assert_eq!(align_of::<AtomicU32>(), size_of::<AtomicU32>());
#[cfg(target_has_atomic = "32")]
assert_eq!(align_of::<AtomicI32>(), size_of::<AtomicI32>());
#[cfg(target_has_atomic = "64")]
assert_eq!(align_of::<AtomicU64>(), size_of::<AtomicU64>());
#[cfg(target_has_atomic = "64")]
assert_eq!(align_of::<AtomicI64>(), size_of::<AtomicI64>());
#[cfg(target_has_atomic = "128")]
assert_eq!(align_of::<AtomicU128>(), size_of::<AtomicU128>());
#[cfg(target_has_atomic = "128")]
assert_eq!(align_of::<AtomicI128>(), size_of::<AtomicI128>());
#[cfg(target_has_atomic = "ptr")]
assert_eq!(align_of::<AtomicUsize>(), size_of::<AtomicUsize>());
#[cfg(target_has_atomic = "ptr")]
assert_eq!(align_of::<AtomicIsize>(), size_of::<AtomicIsize>());
}

31
src/test/ui/atomic-compare_exchange.rs
View File

@ -1,31 +0,0 @@
// run-pass
#![allow(stable_features)]
#![feature(extended_compare_and_swap)]
use std::sync::atomic::AtomicIsize;
use std::sync::atomic::Ordering::*;
static ATOMIC: AtomicIsize = AtomicIsize::new(0);
fn main() {
// Make sure codegen can emit all the intrinsics correctly
ATOMIC.compare_exchange(0, 1, Relaxed, Relaxed).ok();
ATOMIC.compare_exchange(0, 1, Acquire, Relaxed).ok();
ATOMIC.compare_exchange(0, 1, Release, Relaxed).ok();
ATOMIC.compare_exchange(0, 1, AcqRel, Relaxed).ok();
ATOMIC.compare_exchange(0, 1, SeqCst, Relaxed).ok();
ATOMIC.compare_exchange(0, 1, Acquire, Acquire).ok();
ATOMIC.compare_exchange(0, 1, AcqRel, Acquire).ok();
ATOMIC.compare_exchange(0, 1, SeqCst, Acquire).ok();
ATOMIC.compare_exchange(0, 1, SeqCst, SeqCst).ok();
ATOMIC.compare_exchange_weak(0, 1, Relaxed, Relaxed).ok();
ATOMIC.compare_exchange_weak(0, 1, Acquire, Relaxed).ok();
ATOMIC.compare_exchange_weak(0, 1, Release, Relaxed).ok();
ATOMIC.compare_exchange_weak(0, 1, AcqRel, Relaxed).ok();
ATOMIC.compare_exchange_weak(0, 1, SeqCst, Relaxed).ok();
ATOMIC.compare_exchange_weak(0, 1, Acquire, Acquire).ok();
ATOMIC.compare_exchange_weak(0, 1, AcqRel, Acquire).ok();
ATOMIC.compare_exchange_weak(0, 1, SeqCst, Acquire).ok();
ATOMIC.compare_exchange_weak(0, 1, SeqCst, SeqCst).ok();
}

6
src/test/ui/bool-not.rs
View File

@ -1,6 +0,0 @@
// run-pass
pub fn main() {
if !false { assert!((true)); } else { assert!((false)); }
if !true { assert!((false)); } else { assert!((true)); }
}

72
src/test/ui/bool.rs
View File

@ -1,72 +0,0 @@
// run-pass
// Basic boolean tests
use std::cmp::Ordering::{Equal, Greater, Less};
use std::ops::{BitAnd, BitOr, BitXor};
fn main() {
assert_eq!(false.eq(&true), false);
assert_eq!(false == false, true);
assert_eq!(false != true, true);
assert_eq!(false.ne(&false), false);
assert_eq!(false.bitand(false), false);
assert_eq!(true.bitand(false), false);
assert_eq!(false.bitand(true), false);
assert_eq!(true.bitand(true), true);
assert_eq!(false & false, false);
assert_eq!(true & false, false);
assert_eq!(false & true, false);
assert_eq!(true & true, true);
assert_eq!(false.bitor(false), false);
assert_eq!(true.bitor(false), true);
assert_eq!(false.bitor(true), true);
assert_eq!(true.bitor(true), true);
assert_eq!(false | false, false);
assert_eq!(true | false, true);
assert_eq!(false | true, true);
assert_eq!(true | true, true);
assert_eq!(false.bitxor(false), false);
assert_eq!(true.bitxor(false), true);
assert_eq!(false.bitxor(true), true);
assert_eq!(true.bitxor(true), false);
assert_eq!(false ^ false, false);
assert_eq!(true ^ false, true);
assert_eq!(false ^ true, true);
assert_eq!(true ^ true, false);
assert_eq!(!true, false);
assert_eq!(!false, true);
let s = false.to_string();
assert_eq!(s, "false");
let s = true.to_string();
assert_eq!(s, "true");
assert!(true > false);
assert!(!(false > true));
assert!(false < true);
assert!(!(true < false));
assert!(false <= false);
assert!(false >= false);
assert!(true <= true);
assert!(true >= true);
assert!(false <= true);
assert!(!(false >= true));
assert!(true >= false);
assert!(!(true <= false));
assert_eq!(true.cmp(&true), Equal);
assert_eq!(false.cmp(&false), Equal);
assert_eq!(true.cmp(&false), Greater);
assert_eq!(false.cmp(&true), Less);
}

10
src/test/ui/char_unicode.rs
View File

@ -1,10 +0,0 @@
// run-pass
/// Tests access to the Unicode version constant.
pub fn main() {
check(std::char::UNICODE_VERSION);
}
pub fn check(unicode_version: (u8, u8, u8)) {
assert!(unicode_version.0 >= 10);
}

73
src/test/ui/cmp-default.rs
View File

@ -1,73 +0,0 @@
// run-pass
use std::cmp::Ordering;
// Test default methods in PartialOrd and PartialEq
//
#[derive(Debug)]
struct Fool(bool);
impl PartialEq for Fool {
fn eq(&self, other: &Fool) -> bool {
let Fool(this) = *self;
let Fool(other) = *other;
this != other
}
}
struct Int(isize);
impl PartialEq for Int {
fn eq(&self, other: &Int) -> bool {
let Int(this) = *self;
let Int(other) = *other;
this == other
}
}
impl PartialOrd for Int {
fn partial_cmp(&self, other: &Int) -> Option<Ordering> {
let Int(this) = *self;
let Int(other) = *other;
this.partial_cmp(&other)
}
}
struct RevInt(isize);
impl PartialEq for RevInt {
fn eq(&self, other: &RevInt) -> bool {
let RevInt(this) = *self;
let RevInt(other) = *other;
this == other
}
}
impl PartialOrd for RevInt {
fn partial_cmp(&self, other: &RevInt) -> Option<Ordering> {
let RevInt(this) = *self;
let RevInt(other) = *other;
other.partial_cmp(&this)
}
}
pub fn main() {
assert!(Int(2) > Int(1));
assert!(Int(2) >= Int(1));
assert!(Int(1) >= Int(1));
assert!(Int(1) < Int(2));
assert!(Int(1) <= Int(2));
assert!(Int(1) <= Int(1));
assert!(RevInt(2) < RevInt(1));
assert!(RevInt(2) <= RevInt(1));
assert!(RevInt(1) <= RevInt(1));
assert!(RevInt(1) > RevInt(2));
assert!(RevInt(1) >= RevInt(2));
assert!(RevInt(1) >= RevInt(1));
assert_eq!(Fool(true), Fool(false));
assert!(Fool(true) != Fool(true));
assert!(Fool(false) != Fool(false));
assert_eq!(Fool(false), Fool(true));
}

53
src/test/ui/consts/ascii_ctype.rs
View File

@ -1,53 +0,0 @@
// run-pass
macro_rules! suite {
( $( $fn:ident => [$a:ident, $A:ident, $nine:ident, $dot:ident, $space:ident]; )* ) => {
$(
mod $fn {
const CHAR_A_LOWER: bool = 'a'.$fn();
const CHAR_A_UPPER: bool = 'A'.$fn();
const CHAR_NINE: bool = '9'.$fn();
const CHAR_DOT: bool = '.'.$fn();
const CHAR_SPACE: bool = ' '.$fn();
const U8_A_LOWER: bool = b'a'.$fn();
const U8_A_UPPER: bool = b'A'.$fn();
const U8_NINE: bool = b'9'.$fn();
const U8_DOT: bool = b'.'.$fn();
const U8_SPACE: bool = b' '.$fn();
pub fn run() {
assert_eq!(CHAR_A_LOWER, $a);
assert_eq!(CHAR_A_UPPER, $A);
assert_eq!(CHAR_NINE, $nine);
assert_eq!(CHAR_DOT, $dot);
assert_eq!(CHAR_SPACE, $space);
assert_eq!(U8_A_LOWER, $a);
assert_eq!(U8_A_UPPER, $A);
assert_eq!(U8_NINE, $nine);
assert_eq!(U8_DOT, $dot);
assert_eq!(U8_SPACE, $space);
}
}
)*
fn main() {
$( $fn::run(); )*
}
}
}
suite! {
// 'a' 'A' '9' '.' ' '
is_ascii_alphabetic => [true, true, false, false, false];
is_ascii_uppercase => [false, true, false, false, false];
is_ascii_lowercase => [true, false, false, false, false];
is_ascii_alphanumeric => [true, true, true, false, false];
is_ascii_digit => [false, false, true, false, false];
is_ascii_hexdigit => [true, true, true, false, false];
is_ascii_punctuation => [false, false, false, true, false];
is_ascii_graphic => [true, true, true, true, false];
is_ascii_whitespace => [false, false, false, false, true];
is_ascii_control => [false, false, false, false, false];
}

17
src/test/ui/consts/const-str-ptr.rs
View File

@ -1,17 +0,0 @@
// run-pass
#![allow(unused_imports)]
use std::{str, string};
const A: [u8; 2] = ['h' as u8, 'i' as u8];
const B: &'static [u8; 2] = &A;
const C: *const u8 = B as *const u8;
pub fn main() {
unsafe {
let foo = &A as *const u8;
assert_eq!(foo, C);
assert_eq!(str::from_utf8_unchecked(&A), "hi");
assert_eq!(*C, A[0]);
assert_eq!(*(&B[0] as *const u8), A[0]);
}
}

15
src/test/ui/deref-mut-on-ref.rs
View File

@ -1,15 +0,0 @@
// run-pass
// Test that `&mut T` implements `DerefMut<T>`
use std::ops::{Deref, DerefMut};
fn inc<T: Deref<Target=isize> + DerefMut>(mut t: T) {
*t += 1;
}
fn main() {
let mut x: isize = 5;
inc(&mut x);
assert_eq!(x, 6);
}

19
src/test/ui/deref-on-ref.rs
View File

@ -1,19 +0,0 @@
// run-pass
// Test that `&T` and `&mut T` implement `Deref<T>`
use std::ops::Deref;
fn deref<U:Copy,T:Deref<Target=U>>(t: T) -> U {
*t
}
fn main() {
let x: isize = 3;
let y = deref(&x);
assert_eq!(y, 3);
let mut x: isize = 4;
let y = deref(&mut x);
assert_eq!(y, 4);
}

50
src/test/ui/env-home-dir.rs
View File

@ -1,50 +0,0 @@
// run-pass
#![allow(unused_variables)]
#![allow(deprecated)]
// ignore-emscripten env vars don't work?
// ignore-sgx env vars cannot be modified
use std::env::*;
use std::path::PathBuf;
#[cfg(unix)]
fn main() {
let oldhome = var("HOME");
set_var("HOME", "/home/MountainView");
assert_eq!(home_dir(), Some(PathBuf::from("/home/MountainView")));
remove_var("HOME");
if cfg!(target_os = "android") {
assert!(home_dir().is_none());
} else {
// When HOME is not set, some platforms return `None`,
// but others return `Some` with a default.
// Just check that it is not "/home/MountainView".
assert_ne!(home_dir(), Some(PathBuf::from("/home/MountainView")));
}
}
#[cfg(windows)]
fn main() {
let oldhome = var("HOME");
let olduserprofile = var("USERPROFILE");
remove_var("HOME");
remove_var("USERPROFILE");
assert!(home_dir().is_some());
set_var("HOME", "/home/MountainView");
assert_eq!(home_dir(), Some(PathBuf::from("/home/MountainView")));
remove_var("HOME");
set_var("USERPROFILE", "/home/MountainView");
assert_eq!(home_dir(), Some(PathBuf::from("/home/MountainView")));
set_var("HOME", "/home/MountainView");
set_var("USERPROFILE", "/home/PaloAlto");
assert_eq!(home_dir(), Some(PathBuf::from("/home/MountainView")));
}

12
src/test/ui/extend-for-unit.rs
View File

@ -1,12 +0,0 @@
// run-pass
pub fn main() {
let mut x = 0;
{
let iter = (0..5).map(|_| {
x += 1;
});
().extend(iter);
}
assert_eq!(x, 5);
}

13
src/test/ui/offset_from.rs
View File

@ -1,13 +0,0 @@
// run-pass
fn main() {
let mut a = [0; 5];
let ptr1: *mut i32 = &mut a[1];
let ptr2: *mut i32 = &mut a[3];
unsafe {
assert_eq!(ptr2.offset_from(ptr1), 2);
assert_eq!(ptr1.offset_from(ptr2), -2);
assert_eq!(ptr1.offset(2), ptr2);
assert_eq!(ptr2.offset(-2), ptr1);
}
}

10
src/test/ui/option-ext.rs
View File

@ -1,10 +0,0 @@
// run-pass
pub fn main() {
let thing = "{{ f }}";
let f = thing.find("{{");
if f.is_none() {
println!("None!");
}
}

47
src/test/ui/result-opt-conversions.rs
View File

@ -1,47 +0,0 @@
// run-pass
#[derive(Copy, Clone, Debug, PartialEq)]
struct BadNumErr;
fn try_num(x: i32) -> Result<i32, BadNumErr> {
if x <= 5 {
Ok(x + 1)
} else {
Err(BadNumErr)
}
}
type ResOpt = Result<Option<i32>, BadNumErr>;
type OptRes = Option<Result<i32, BadNumErr>>;
fn main() {
let mut x: ResOpt = Ok(Some(5));
let mut y: OptRes = Some(Ok(5));
assert_eq!(x, y.transpose());
assert_eq!(x.transpose(), y);
x = Ok(None);
y = None;
assert_eq!(x, y.transpose());
assert_eq!(x.transpose(), y);
x = Err(BadNumErr);
y = Some(Err(BadNumErr));
assert_eq!(x, y.transpose());
assert_eq!(x.transpose(), y);
let res: Result<Vec<i32>, BadNumErr> =
(0..10)
.map(|x| {
let y = try_num(x)?;
Ok(if y % 2 == 0 {
Some(y - 1)
} else {
None
})
})
.filter_map(Result::transpose)
.collect();
assert_eq!(res, Err(BadNumErr))
}

50
src/test/ui/utf8.rs
View File

@ -1,50 +0,0 @@
// run-pass
pub fn main() {
let yen: char = '¥'; // 0xa5
let c_cedilla: char = 'ç'; // 0xe7
let thorn: char = 'þ'; // 0xfe
let y_diaeresis: char = 'ÿ'; // 0xff
let pi: char = 'Π'; // 0x3a0
assert_eq!(yen as isize, 0xa5);
assert_eq!(c_cedilla as isize, 0xe7);
assert_eq!(thorn as isize, 0xfe);
assert_eq!(y_diaeresis as isize, 0xff);
assert_eq!(pi as isize, 0x3a0);
assert_eq!(pi as isize, '\u{3a0}' as isize);
assert_eq!('\x0a' as isize, '\n' as isize);
let bhutan: String = "འབྲུག་ཡུལ།".to_string();
let japan: String = "日本".to_string();
let uzbekistan: String = "Ўзбекистон".to_string();
let austria: String = "Österreich".to_string();
let bhutan_e: String =
"\u{f60}\u{f56}\u{fb2}\u{f74}\u{f42}\u{f0b}\u{f61}\u{f74}\u{f63}\u{f0d}".to_string();
let japan_e: String = "\u{65e5}\u{672c}".to_string();
let uzbekistan_e: String =
"\u{40e}\u{437}\u{431}\u{435}\u{43a}\u{438}\u{441}\u{442}\u{43e}\u{43d}".to_string();
let austria_e: String = "\u{d6}sterreich".to_string();
let oo: char = 'Ö';
assert_eq!(oo as isize, 0xd6);
fn check_str_eq(a: String, b: String) {
let mut i: isize = 0;
for ab in a.bytes() {
println!("{}", i);
println!("{}", ab);
let bb: u8 = b.as_bytes()[i as usize];
println!("{}", bb);
assert_eq!(ab, bb);
i += 1;
}
}
check_str_eq(bhutan, bhutan_e);
check_str_eq(japan, japan_e);
check_str_eq(uzbekistan, uzbekistan_e);
check_str_eq(austria, austria_e);
}

31
src/test/ui/utf8_chars.rs
View File

@ -1,31 +0,0 @@
// run-pass
use std::str;
pub fn main() {
// Chars of 1, 2, 3, and 4 bytes
let chs: Vec<char> = vec!['e', 'é', '€', '\u{10000}'];
let s: String = chs.iter().cloned().collect();
let schs: Vec<char> = s.chars().collect();
assert_eq!(s.len(), 10);
assert_eq!(s.chars().count(), 4);
assert_eq!(schs.len(), 4);
assert_eq!(schs.iter().cloned().collect::<String>(), s);
assert!((str::from_utf8(s.as_bytes()).is_ok()));
// invalid prefix
assert!((!str::from_utf8(&[0x80]).is_ok()));
// invalid 2 byte prefix
assert!((!str::from_utf8(&[0xc0]).is_ok()));
assert!((!str::from_utf8(&[0xc0, 0x10]).is_ok()));
// invalid 3 byte prefix
assert!((!str::from_utf8(&[0xe0]).is_ok()));
assert!((!str::from_utf8(&[0xe0, 0x10]).is_ok()));
assert!((!str::from_utf8(&[0xe0, 0xff, 0x10]).is_ok()));
// invalid 4 byte prefix
assert!((!str::from_utf8(&[0xf0]).is_ok()));
assert!((!str::from_utf8(&[0xf0, 0x10]).is_ok()));
assert!((!str::from_utf8(&[0xf0, 0xff, 0x10]).is_ok()));
assert!((!str::from_utf8(&[0xf0, 0xff, 0xff, 0x10]).is_ok()));
}

225
src/test/ui/wrapping-int-api.rs
View File

@ -1,225 +0,0 @@
// run-pass
// Test inherent wrapping_* methods for {i,u}{size,8,16,32,64}.
// Don't warn about overflowing ops on 32-bit platforms
#![cfg_attr(target_pointer_width = "32", allow(const_err))]
fn main() {
assert_eq!( i8::MAX.wrapping_add(1), i8::MIN);
assert_eq!( i16::MAX.wrapping_add(1), i16::MIN);
assert_eq!( i32::MAX.wrapping_add(1), i32::MIN);
assert_eq!( i64::MAX.wrapping_add(1), i64::MIN);
assert_eq!(isize::MAX.wrapping_add(1), isize::MIN);
assert_eq!( i8::MIN.wrapping_sub(1), i8::MAX);
assert_eq!( i16::MIN.wrapping_sub(1), i16::MAX);
assert_eq!( i32::MIN.wrapping_sub(1), i32::MAX);
assert_eq!( i64::MIN.wrapping_sub(1), i64::MAX);
assert_eq!(isize::MIN.wrapping_sub(1), isize::MAX);
assert_eq!( u8::MAX.wrapping_add(1), u8::MIN);
assert_eq!( u16::MAX.wrapping_add(1), u16::MIN);
assert_eq!( u32::MAX.wrapping_add(1), u32::MIN);
assert_eq!( u64::MAX.wrapping_add(1), u64::MIN);
assert_eq!(usize::MAX.wrapping_add(1), usize::MIN);
assert_eq!( u8::MIN.wrapping_sub(1), u8::MAX);
assert_eq!( u16::MIN.wrapping_sub(1), u16::MAX);
assert_eq!( u32::MIN.wrapping_sub(1), u32::MAX);
assert_eq!( u64::MIN.wrapping_sub(1), u64::MAX);
assert_eq!(usize::MIN.wrapping_sub(1), usize::MAX);
assert_eq!((0xfe_u8 as i8).wrapping_mul(16),
(0xe0_u8 as i8));
assert_eq!((0xfedc_u16 as i16).wrapping_mul(16),
(0xedc0_u16 as i16));
assert_eq!((0xfedc_ba98_u32 as i32).wrapping_mul(16),
(0xedcb_a980_u32 as i32));
assert_eq!((0xfedc_ba98_7654_3217_u64 as i64).wrapping_mul(16),
(0xedcb_a987_6543_2170_u64 as i64));
match () {
#[cfg(target_pointer_width = "32")]
() => {
assert_eq!((0xfedc_ba98_u32 as isize).wrapping_mul(16),
(0xedcb_a980_u32 as isize));
}
#[cfg(target_pointer_width = "64")]
() => {
assert_eq!((0xfedc_ba98_7654_3217_u64 as isize).wrapping_mul(16),
(0xedcb_a987_6543_2170_u64 as isize));
}
}
assert_eq!((0xfe as u8).wrapping_mul(16),
(0xe0 as u8));
assert_eq!((0xfedc as u16).wrapping_mul(16),
(0xedc0 as u16));
assert_eq!((0xfedc_ba98 as u32).wrapping_mul(16),
(0xedcb_a980 as u32));
assert_eq!((0xfedc_ba98_7654_3217 as u64).wrapping_mul(16),
(0xedcb_a987_6543_2170 as u64));
match () {
#[cfg(target_pointer_width = "32")]
() => {
assert_eq!((0xfedc_ba98 as usize).wrapping_mul(16),
(0xedcb_a980 as usize));
}
#[cfg(target_pointer_width = "64")]
() => {
assert_eq!((0xfedc_ba98_7654_3217 as usize).wrapping_mul(16),
(0xedcb_a987_6543_2170 as usize));
}
}
macro_rules! check_mul_no_wrap {
($e:expr, $f:expr) => { assert_eq!(($e).wrapping_mul($f), ($e) * $f); }
}
macro_rules! check_mul_wraps {
($e:expr, $f:expr) => { assert_eq!(($e).wrapping_mul($f), $e); }
}
check_mul_no_wrap!(0xfe_u8 as i8, -1);
check_mul_no_wrap!(0xfedc_u16 as i16, -1);
check_mul_no_wrap!(0xfedc_ba98_u32 as i32, -1);
check_mul_no_wrap!(0xfedc_ba98_7654_3217_u64 as i64, -1);
check_mul_no_wrap!(0xfedc_ba98_7654_3217_u64 as u64 as isize, -1);
check_mul_no_wrap!(0xfe_u8 as i8, -2);
check_mul_no_wrap!(0xfedc_u16 as i16, -2);
check_mul_no_wrap!(0xfedc_ba98_u32 as i32, -2);
check_mul_no_wrap!(0xfedc_ba98_7654_3217_u64 as i64, -2);
check_mul_no_wrap!(0xfedc_ba98_fedc_ba98_u64 as u64 as isize, -2);
check_mul_no_wrap!(0xfe_u8 as i8, 2);
check_mul_no_wrap!(0xfedc_u16 as i16, 2);
check_mul_no_wrap!(0xfedc_ba98_u32 as i32, 2);
check_mul_no_wrap!(0xfedc_ba98_7654_3217_u64 as i64, 2);
check_mul_no_wrap!(0xfedc_ba98_fedc_ba98_u64 as u64 as isize, 2);
check_mul_wraps!(0x80_u8 as i8, -1);
check_mul_wraps!(0x8000_u16 as i16, -1);
check_mul_wraps!(0x8000_0000_u32 as i32, -1);
check_mul_wraps!(0x8000_0000_0000_0000_u64 as i64, -1);
match () {
#[cfg(target_pointer_width = "32")]
() => {
check_mul_wraps!(0x8000_0000_u32 as isize, -1);
}
#[cfg(target_pointer_width = "64")]
() => {
check_mul_wraps!(0x8000_0000_0000_0000_u64 as isize, -1);
}
}
macro_rules! check_div_no_wrap {
($e:expr, $f:expr) => { assert_eq!(($e).wrapping_div($f), ($e) / $f); }
}
macro_rules! check_div_wraps {
($e:expr, $f:expr) => { assert_eq!(($e).wrapping_div($f), $e); }
}
check_div_no_wrap!(0xfe_u8 as i8, -1);
check_div_no_wrap!(0xfedc_u16 as i16, -1);
check_div_no_wrap!(0xfedc_ba98_u32 as i32, -1);
check_div_no_wrap!(0xfedc_ba98_7654_3217_u64 as i64, -1);
check_div_no_wrap!(0xfedc_ba98_7654_3217_u64 as u64 as isize, -1);
check_div_no_wrap!(0xfe_u8 as i8, -2);
check_div_no_wrap!(0xfedc_u16 as i16, -2);
check_div_no_wrap!(0xfedc_ba98_u32 as i32, -2);
check_div_no_wrap!(0xfedc_ba98_7654_3217_u64 as i64, -2);
check_div_no_wrap!(0xfedc_ba98_7654_3217_u64 as u64 as isize, -2);
check_div_no_wrap!(0xfe_u8 as i8, 2);
check_div_no_wrap!(0xfedc_u16 as i16, 2);
check_div_no_wrap!(0xfedc_ba98_u32 as i32, 2);
check_div_no_wrap!(0xfedc_ba98_7654_3217_u64 as i64, 2);
check_div_no_wrap!(0xfedc_ba98_7654_3217_u64 as u64 as isize, 2);
check_div_wraps!(-128 as i8, -1);
check_div_wraps!(0x8000_u16 as i16, -1);
check_div_wraps!(0x8000_0000_u32 as i32, -1);
check_div_wraps!(0x8000_0000_0000_0000_u64 as i64, -1);
match () {
#[cfg(target_pointer_width = "32")]
() => {
check_div_wraps!(0x8000_0000_u32 as isize, -1);
}
#[cfg(target_pointer_width = "64")]
() => {
check_div_wraps!(0x8000_0000_0000_0000_u64 as isize, -1);
}
}
macro_rules! check_rem_no_wrap {
($e:expr, $f:expr) => { assert_eq!(($e).wrapping_rem($f), ($e) % $f); }
}
macro_rules! check_rem_wraps {
($e:expr, $f:expr) => { assert_eq!(($e).wrapping_rem($f), 0); }
}
check_rem_no_wrap!(0xfe_u8 as i8, -1);
check_rem_no_wrap!(0xfedc_u16 as i16, -1);
check_rem_no_wrap!(0xfedc_ba98_u32 as i32, -1);
check_rem_no_wrap!(0xfedc_ba98_7654_3217_u64 as i64, -1);
check_rem_no_wrap!(0xfedc_ba98_7654_3217_u64 as u64 as isize, -1);
check_rem_no_wrap!(0xfe_u8 as i8, -2);
check_rem_no_wrap!(0xfedc_u16 as i16, -2);
check_rem_no_wrap!(0xfedc_ba98_u32 as i32, -2);
check_rem_no_wrap!(0xfedc_ba98_7654_3217_u64 as i64, -2);
check_rem_no_wrap!(0xfedc_ba98_7654_3217_u64 as u64 as isize, -2);
check_rem_no_wrap!(0xfe_u8 as i8, 2);
check_rem_no_wrap!(0xfedc_u16 as i16, 2);
check_rem_no_wrap!(0xfedc_ba98_u32 as i32, 2);
check_rem_no_wrap!(0xfedc_ba98_7654_3217_u64 as i64, 2);
check_rem_no_wrap!(0xfedc_ba98_7654_3217_u64 as u64 as isize, 2);
check_rem_wraps!(0x80_u8 as i8, -1);
check_rem_wraps!(0x8000_u16 as i16, -1);
check_rem_wraps!(0x8000_0000_u32 as i32, -1);
check_rem_wraps!(0x8000_0000_0000_0000_u64 as i64, -1);
match () {
#[cfg(target_pointer_width = "32")]
() => {
check_rem_wraps!(0x8000_0000_u32 as isize, -1);
}
#[cfg(target_pointer_width = "64")]
() => {
check_rem_wraps!(0x8000_0000_0000_0000_u64 as isize, -1);
}
}
macro_rules! check_neg_no_wrap {
($e:expr) => { assert_eq!(($e).wrapping_neg(), -($e)); }
}
macro_rules! check_neg_wraps {
($e:expr) => { assert_eq!(($e).wrapping_neg(), ($e)); }
}
check_neg_no_wrap!(0xfe_u8 as i8);
check_neg_no_wrap!(0xfedc_u16 as i16);
check_neg_no_wrap!(0xfedc_ba98_u32 as i32);
check_neg_no_wrap!(0xfedc_ba98_7654_3217_u64 as i64);
check_neg_no_wrap!(0xfedc_ba98_7654_3217_u64 as u64 as isize);
check_neg_wraps!(0x80_u8 as i8);
check_neg_wraps!(0x8000_u16 as i16);
check_neg_wraps!(0x8000_0000_u32 as i32);
check_neg_wraps!(0x8000_0000_0000_0000_u64 as i64);
match () {
#[cfg(target_pointer_width = "32")]
() => {
check_neg_wraps!(0x8000_0000_u32 as isize);
}
#[cfg(target_pointer_width = "64")]
() => {
check_neg_wraps!(0x8000_0000_0000_0000_u64 as isize);
}
}
}