nordic-dev.net/rust
nordic-dev.net/rust
2
0
Fork 0
mirror of https://github.com/rust-lang/rust.git synced 2024-11-23 15:23:46 +00:00
Code Issues Packages Projects Releases Wiki Activity
24a1729566
rust/tests/ui/numbers-arithmetic/num-wrapping.rs

Ignoring revisions in .git-blame-ignore-revs. Click here to bypass and see the normal blame view.

449 lines
18 KiB
Rust
Raw Normal View History

Add `// run-pass` annotations to all the tests under `ui/run-pass/`. (I may have accidentally added it to some auxilliary crates as well; my emacs-macro-based methodology was pretty crude.)
2018-08-30 12:18:55 +00:00
//@ run-pass
Add `#![allow(..)]` as necessary to get re-migrated run-pass tests compiling with clean stderr again. Most were added mechanically.
2018-09-25 21:51:35 +00:00
#![allow(unused_macros)]
Add `// run-pass` annotations to all the tests under `ui/run-pass/`. (I may have accidentally added it to some auxilliary crates as well; my emacs-macro-based methodology was pretty crude.)
2018-08-30 12:18:55 +00:00
In the middle of the implementation
2016-01-01 12:28:26 +00:00
//@ compile-flags: -C debug-assertions
//
// Test std::num::Wrapping<T> for {uN, iN, usize, isize}
std: Clean out deprecated APIs Removes all unstable and deprecated APIs prior to the 1.8 release. All APIs that are deprecated in the 1.8 release are sticking around for the rest of this cycle. Some notable changes are: * The `dynamic_lib` module was moved into `rustc_back` as the compiler still relies on a few bits and pieces. * The `DebugTuple` formatter now special-cases an empty struct name with only one field to append a trailing comma.
2016-03-07 23:42:29 +00:00
#![feature(test)]
Finish test implementation
2016-01-02 22:36:28 +00:00
extern crate test;
In the middle of the implementation
2016-01-01 12:28:26 +00:00
use std::num::Wrapping;
use std::ops::{
Add, Sub, Mul, Div, Rem, BitXor, BitOr, BitAnd,
AddAssign, SubAssign, MulAssign, DivAssign, RemAssign, BitXorAssign, BitOrAssign, BitAndAssign,
Shl, Shr, ShlAssign, ShrAssign
};
Finish test implementation
2016-01-02 22:36:28 +00:00
use test::black_box;
In the middle of the implementation
2016-01-01 12:28:26 +00:00
std: Clean out deprecated APIs Removes all unstable and deprecated APIs prior to the 1.8 release. All APIs that are deprecated in the 1.8 release are sticking around for the rest of this cycle. Some notable changes are: * The `dynamic_lib` module was moved into `rustc_back` as the compiler still relies on a few bits and pieces. * The `DebugTuple` formatter now special-cases an empty struct name with only one field to append a trailing comma.
2016-03-07 23:42:29 +00:00
macro_rules! int_modules {
($(($name:ident, $size:expr),)*) => ($(
mod $name {
pub const BITS: usize = $size;
Update tests to remove old numeric constants Part of #68490. Care has been taken to leave the old consts where appropriate, for testing backcompat regressions, module shadowing, etc. The intrinsics docs were accidentally referring to some methods on f64 as std::f64, which I changed due to being contrary with how we normally disambiguate the shadow module from the primitive. In one other place I changed std::u8 to std::ops since it was just testing path handling in macros. For places which have legitimate uses of the old consts, deprecated attributes have been optimistically inserted. Although currently unnecessary, they exist to emphasize to any future deprecation effort the necessity of these specific symbols and prevent them from being accidentally removed.
2020-10-24 23:21:40 +00:00
pub const MAX: $name = $name::MAX;
pub const MIN: $name = $name::MIN;
std: Clean out deprecated APIs Removes all unstable and deprecated APIs prior to the 1.8 release. All APIs that are deprecated in the 1.8 release are sticking around for the rest of this cycle. Some notable changes are: * The `dynamic_lib` module was moved into `rustc_back` as the compiler still relies on a few bits and pieces. * The `DebugTuple` formatter now special-cases an empty struct name with only one field to append a trailing comma.
2016-03-07 23:42:29 +00:00
}
)*)
}
int_modules! {
(i8, 8),
(i16, 16),
(i32, 32),
(i64, 64),
(u8, 8),
(u16, 16),
(u32, 32),
(u64, 64),
}
#[cfg(target_pointer_width = "32")]
int_modules! {
(isize, 32),
(usize, 32),
}
#[cfg(target_pointer_width = "64")]
int_modules! {
(isize, 64),
(usize, 64),
}
In the middle of the implementation
2016-01-01 12:28:26 +00:00
fn main() {
test_ops();
test_op_assigns();
test_sh_ops();
test_sh_op_assigns();
}
fn test_ops() {
macro_rules! op_test {
($op:ident ($lhs:expr, $rhs:expr) == $ans:expr) => {
assert_eq!(black_box(Wrapping($lhs).$op(Wrapping($rhs))), Wrapping($ans));
Take out Op<T>/OpAssign<T> for Wrapping<T>
2016-01-02 23:34:55 +00:00
// FIXME(30524): uncomment this test when it's implemented
// assert_eq!(black_box(Wrapping($lhs).$op($rhs)), Wrapping($ans));
In the middle of the implementation
2016-01-01 12:28:26 +00:00
}
}
op_test!(add(i8::MAX, 1) == i8::MIN);
op_test!(add(i16::MAX, 1) == i16::MIN);
op_test!(add(i32::MAX, 1) == i32::MIN);
op_test!(add(i64::MAX, 1) == i64::MIN);
op_test!(add(isize::MAX, 1) == isize::MIN);
op_test!(add(u8::MAX, 1) == 0);
op_test!(add(u16::MAX, 1) == 0);
op_test!(add(u32::MAX, 1) == 0);
op_test!(add(u64::MAX, 1) == 0);
op_test!(add(usize::MAX, 1) == 0);
op_test!(sub(i8::MIN, 1) == i8::MAX);
op_test!(sub(i16::MIN, 1) == i16::MAX);
op_test!(sub(i32::MIN, 1) == i32::MAX);
op_test!(sub(i64::MIN, 1) == i64::MAX);
op_test!(sub(isize::MIN, 1) == isize::MAX);
op_test!(sub(0u8, 1) == u8::MAX);
op_test!(sub(0u16, 1) == u16::MAX);
op_test!(sub(0u32, 1) == u32::MAX);
op_test!(sub(0u64, 1) == u64::MAX);
op_test!(sub(0usize, 1) == usize::MAX);
op_test!(mul(i8::MAX, 2) == -2);
op_test!(mul(i16::MAX, 2) == -2);
op_test!(mul(i32::MAX, 2) == -2);
op_test!(mul(i64::MAX, 2) == -2);
op_test!(mul(isize::MAX, 2) == -2);
op_test!(mul(u8::MAX, 2) == u8::MAX - 1);
op_test!(mul(u16::MAX, 2) == u16::MAX - 1);
op_test!(mul(u32::MAX, 2) == u32::MAX - 1);
op_test!(mul(u64::MAX, 2) == u64::MAX - 1);
op_test!(mul(usize::MAX, 2) == usize::MAX - 1);
op_test!(div(i8::MIN, -1) == i8::MIN);
op_test!(div(i16::MIN, -1) == i16::MIN);
op_test!(div(i32::MIN, -1) == i32::MIN);
op_test!(div(i64::MIN, -1) == i64::MIN);
op_test!(div(isize::MIN, -1) == isize::MIN);
op_test!(rem(i8::MIN, -1) == 0);
op_test!(rem(i16::MIN, -1) == 0);
op_test!(rem(i32::MIN, -1) == 0);
op_test!(rem(i64::MIN, -1) == 0);
op_test!(rem(isize::MIN, -1) == 0);
// these are not that interesting, just testing to make sure they are implemented correctly
op_test!(bitxor(0b101010i8, 0b100110) == 0b001100);
op_test!(bitxor(0b101010i16, 0b100110) == 0b001100);
op_test!(bitxor(0b101010i32, 0b100110) == 0b001100);
op_test!(bitxor(0b101010i64, 0b100110) == 0b001100);
op_test!(bitxor(0b101010isize, 0b100110) == 0b001100);
op_test!(bitxor(0b101010u8, 0b100110) == 0b001100);
op_test!(bitxor(0b101010u16, 0b100110) == 0b001100);
op_test!(bitxor(0b101010u32, 0b100110) == 0b001100);
op_test!(bitxor(0b101010u64, 0b100110) == 0b001100);
op_test!(bitxor(0b101010usize, 0b100110) == 0b001100);
op_test!(bitor(0b101010i8, 0b100110) == 0b101110);
op_test!(bitor(0b101010i16, 0b100110) == 0b101110);
op_test!(bitor(0b101010i32, 0b100110) == 0b101110);
op_test!(bitor(0b101010i64, 0b100110) == 0b101110);
op_test!(bitor(0b101010isize, 0b100110) == 0b101110);
op_test!(bitor(0b101010u8, 0b100110) == 0b101110);
op_test!(bitor(0b101010u16, 0b100110) == 0b101110);
op_test!(bitor(0b101010u32, 0b100110) == 0b101110);
op_test!(bitor(0b101010u64, 0b100110) == 0b101110);
op_test!(bitor(0b101010usize, 0b100110) == 0b101110);
op_test!(bitand(0b101010i8, 0b100110) == 0b100010);
op_test!(bitand(0b101010i16, 0b100110) == 0b100010);
op_test!(bitand(0b101010i32, 0b100110) == 0b100010);
op_test!(bitand(0b101010i64, 0b100110) == 0b100010);
op_test!(bitand(0b101010isize, 0b100110) == 0b100010);
op_test!(bitand(0b101010u8, 0b100110) == 0b100010);
op_test!(bitand(0b101010u16, 0b100110) == 0b100010);
op_test!(bitand(0b101010u32, 0b100110) == 0b100010);
op_test!(bitand(0b101010u64, 0b100110) == 0b100010);
op_test!(bitand(0b101010usize, 0b100110) == 0b100010);
}
fn test_op_assigns() {
macro_rules! op_assign_test {
($op:ident ($initial:expr, $rhs:expr) == $ans:expr) => {
{
let mut tmp = Wrapping($initial);
tmp = black_box(tmp);
tmp.$op(Wrapping($rhs));
assert_eq!(black_box(tmp), Wrapping($ans));
}
Manuall rebase of @Migi pull/41336
2017-09-03 02:50:01 +00:00
// also test that a &Wrapping<T> right-hand side is possible
{
let mut tmp = Wrapping($initial);
tmp = black_box(tmp);
tmp.$op(&Wrapping($rhs));
assert_eq!(black_box(tmp), Wrapping($ans));
}
tests: doc comments
2019-02-09 21:23:30 +00:00
// FIXME(30524): uncomment this test
Take out Op<T>/OpAssign<T> for Wrapping<T>
2016-01-02 23:34:55 +00:00
/*
In the middle of the implementation
2016-01-01 12:28:26 +00:00
{
let mut tmp = Wrapping($initial);
tmp = black_box(tmp);
tmp.$op($rhs);
assert_eq!(black_box(tmp), Wrapping($ans));
}
Take out Op<T>/OpAssign<T> for Wrapping<T>
2016-01-02 23:34:55 +00:00
*/
In the middle of the implementation
2016-01-01 12:28:26 +00:00
}
}
op_assign_test!(add_assign(i8::MAX, 1) == i8::MIN);
op_assign_test!(add_assign(i16::MAX, 1) == i16::MIN);
op_assign_test!(add_assign(i32::MAX, 1) == i32::MIN);
op_assign_test!(add_assign(i64::MAX, 1) == i64::MIN);
op_assign_test!(add_assign(isize::MAX, 1) == isize::MIN);
op_assign_test!(add_assign(u8::MAX, 1) == u8::MIN);
op_assign_test!(add_assign(u16::MAX, 1) == u16::MIN);
op_assign_test!(add_assign(u32::MAX, 1) == u32::MIN);
op_assign_test!(add_assign(u64::MAX, 1) == u64::MIN);
op_assign_test!(add_assign(usize::MAX, 1) == usize::MIN);
op_assign_test!(sub_assign(i8::MIN, 1) == i8::MAX);
op_assign_test!(sub_assign(i16::MIN, 1) == i16::MAX);
op_assign_test!(sub_assign(i32::MIN, 1) == i32::MAX);
op_assign_test!(sub_assign(i64::MIN, 1) == i64::MAX);
op_assign_test!(sub_assign(isize::MIN, 1) == isize::MAX);
op_assign_test!(sub_assign(u8::MIN, 1) == u8::MAX);
op_assign_test!(sub_assign(u16::MIN, 1) == u16::MAX);
op_assign_test!(sub_assign(u32::MIN, 1) == u32::MAX);
op_assign_test!(sub_assign(u64::MIN, 1) == u64::MAX);
op_assign_test!(sub_assign(usize::MIN, 1) == usize::MAX);
op_assign_test!(mul_assign(i8::MAX, 2) == -2);
op_assign_test!(mul_assign(i16::MAX, 2) == -2);
op_assign_test!(mul_assign(i32::MAX, 2) == -2);
op_assign_test!(mul_assign(i64::MAX, 2) == -2);
op_assign_test!(mul_assign(isize::MAX, 2) == -2);
op_assign_test!(mul_assign(u8::MAX, 2) == u8::MAX - 1);
op_assign_test!(mul_assign(u16::MAX, 2) == u16::MAX - 1);
op_assign_test!(mul_assign(u32::MAX, 2) == u32::MAX - 1);
op_assign_test!(mul_assign(u64::MAX, 2) == u64::MAX - 1);
op_assign_test!(mul_assign(usize::MAX, 2) == usize::MAX - 1);
op_assign_test!(div_assign(i8::MIN, -1) == i8::MIN);
op_assign_test!(div_assign(i16::MIN, -1) == i16::MIN);
op_assign_test!(div_assign(i32::MIN, -1) == i32::MIN);
op_assign_test!(div_assign(i64::MIN, -1) == i64::MIN);
op_assign_test!(div_assign(isize::MIN, -1) == isize::MIN);
op_assign_test!(rem_assign(i8::MIN, -1) == 0);
op_assign_test!(rem_assign(i16::MIN, -1) == 0);
op_assign_test!(rem_assign(i32::MIN, -1) == 0);
op_assign_test!(rem_assign(i64::MIN, -1) == 0);
op_assign_test!(rem_assign(isize::MIN, -1) == 0);
// these are not that interesting, just testing to make sure they are implemented correctly
op_assign_test!(bitxor_assign(0b101010i8, 0b100110) == 0b001100);
op_assign_test!(bitxor_assign(0b101010i16, 0b100110) == 0b001100);
op_assign_test!(bitxor_assign(0b101010i32, 0b100110) == 0b001100);
op_assign_test!(bitxor_assign(0b101010i64, 0b100110) == 0b001100);
op_assign_test!(bitxor_assign(0b101010isize, 0b100110) == 0b001100);
op_assign_test!(bitxor_assign(0b101010u8, 0b100110) == 0b001100);
op_assign_test!(bitxor_assign(0b101010u16, 0b100110) == 0b001100);
op_assign_test!(bitxor_assign(0b101010u32, 0b100110) == 0b001100);
op_assign_test!(bitxor_assign(0b101010u64, 0b100110) == 0b001100);
op_assign_test!(bitxor_assign(0b101010usize, 0b100110) == 0b001100);
op_assign_test!(bitor_assign(0b101010i8, 0b100110) == 0b101110);
op_assign_test!(bitor_assign(0b101010i16, 0b100110) == 0b101110);
op_assign_test!(bitor_assign(0b101010i32, 0b100110) == 0b101110);
op_assign_test!(bitor_assign(0b101010i64, 0b100110) == 0b101110);
op_assign_test!(bitor_assign(0b101010isize, 0b100110) == 0b101110);
op_assign_test!(bitor_assign(0b101010u8, 0b100110) == 0b101110);
op_assign_test!(bitor_assign(0b101010u16, 0b100110) == 0b101110);
op_assign_test!(bitor_assign(0b101010u32, 0b100110) == 0b101110);
op_assign_test!(bitor_assign(0b101010u64, 0b100110) == 0b101110);
op_assign_test!(bitor_assign(0b101010usize, 0b100110) == 0b101110);
op_assign_test!(bitand_assign(0b101010i8, 0b100110) == 0b100010);
op_assign_test!(bitand_assign(0b101010i16, 0b100110) == 0b100010);
op_assign_test!(bitand_assign(0b101010i32, 0b100110) == 0b100010);
op_assign_test!(bitand_assign(0b101010i64, 0b100110) == 0b100010);
op_assign_test!(bitand_assign(0b101010isize, 0b100110) == 0b100010);
op_assign_test!(bitand_assign(0b101010u8, 0b100110) == 0b100010);
op_assign_test!(bitand_assign(0b101010u16, 0b100110) == 0b100010);
op_assign_test!(bitand_assign(0b101010u32, 0b100110) == 0b100010);
op_assign_test!(bitand_assign(0b101010u64, 0b100110) == 0b100010);
op_assign_test!(bitand_assign(0b101010usize, 0b100110) == 0b100010);
}
fn test_sh_ops() {
macro_rules! sh_test {
($op:ident ($lhs:expr, $rhs:expr) == $ans:expr) => {
assert_eq!(black_box(Wrapping($lhs).$op($rhs)), Wrapping($ans));
}
}
Finish test implementation
2016-01-02 22:36:28 +00:00
// NOTE: This will break for i8 if we ever get i/u128
macro_rules! sh_test_all {
($t:ty) => {
sh_test!(shl(i8::MAX, (i8::BITS + 1) as $t) == -2);
sh_test!(shl(i16::MAX, (i16::BITS + 1) as $t) == -2);
sh_test!(shl(i32::MAX, (i32::BITS + 1) as $t) == -2);
sh_test!(shl(i64::MAX, (i64::BITS + 1) as $t) == -2);
sh_test!(shl(isize::MAX, (isize::BITS + 1) as $t) == -2);
sh_test!(shl(u8::MAX, (u8::BITS + 1) as $t) == u8::MAX - 1);
sh_test!(shl(u16::MAX, (u16::BITS + 1) as $t) == u16::MAX - 1);
sh_test!(shl(u32::MAX, (u32::BITS + 1) as $t) == u32::MAX - 1);
sh_test!(shl(u64::MAX, (u64::BITS + 1) as $t) == u64::MAX - 1);
sh_test!(shl(usize::MAX, (usize::BITS + 1) as $t) == usize::MAX - 1);
sh_test!(shr(i8::MAX, (i8::BITS + 1) as $t) == i8::MAX / 2);
sh_test!(shr(i16::MAX, (i16::BITS + 1) as $t) == i16::MAX / 2);
sh_test!(shr(i32::MAX, (i32::BITS + 1) as $t) == i32::MAX / 2);
sh_test!(shr(i64::MAX, (i64::BITS + 1) as $t) == i64::MAX / 2);
sh_test!(shr(isize::MAX, (isize::BITS + 1) as $t) == isize::MAX / 2);
sh_test!(shr(u8::MAX, (u8::BITS + 1) as $t) == u8::MAX / 2);
sh_test!(shr(u16::MAX, (u16::BITS + 1) as $t) == u16::MAX / 2);
sh_test!(shr(u32::MAX, (u32::BITS + 1) as $t) == u32::MAX / 2);
sh_test!(shr(u64::MAX, (u64::BITS + 1) as $t) == u64::MAX / 2);
sh_test!(shr(usize::MAX, (usize::BITS + 1) as $t) == usize::MAX / 2);
}
}
macro_rules! sh_test_negative_all {
($t:ty) => {
sh_test!(shr(i8::MAX, -((i8::BITS + 1) as $t)) == -2);
sh_test!(shr(i16::MAX, -((i16::BITS + 1) as $t)) == -2);
sh_test!(shr(i32::MAX, -((i32::BITS + 1) as $t)) == -2);
sh_test!(shr(i64::MAX, -((i64::BITS + 1) as $t)) == -2);
sh_test!(shr(isize::MAX, -((isize::BITS + 1) as $t)) == -2);
sh_test!(shr(u8::MAX, -((u8::BITS + 1) as $t)) == u8::MAX - 1);
sh_test!(shr(u16::MAX, -((u16::BITS + 1) as $t)) == u16::MAX - 1);
sh_test!(shr(u32::MAX, -((u32::BITS + 1) as $t)) == u32::MAX - 1);
sh_test!(shr(u64::MAX, -((u64::BITS + 1) as $t)) == u64::MAX - 1);
sh_test!(shr(usize::MAX, -((usize::BITS + 1) as $t)) == usize::MAX - 1);
sh_test!(shl(i8::MAX, -((i8::BITS + 1) as $t)) == i8::MAX / 2);
sh_test!(shl(i16::MAX, -((i16::BITS + 1) as $t)) == i16::MAX / 2);
sh_test!(shl(i32::MAX, -((i32::BITS + 1) as $t)) == i32::MAX / 2);
sh_test!(shl(i64::MAX, -((i64::BITS + 1) as $t)) == i64::MAX / 2);
sh_test!(shl(isize::MAX, -((isize::BITS + 1) as $t)) == isize::MAX / 2);
sh_test!(shl(u8::MAX, -((u8::BITS + 1) as $t)) == u8::MAX / 2);
sh_test!(shl(u16::MAX, -((u16::BITS + 1) as $t)) == u16::MAX / 2);
sh_test!(shl(u32::MAX, -((u32::BITS + 1) as $t)) == u32::MAX / 2);
sh_test!(shl(u64::MAX, -((u64::BITS + 1) as $t)) == u64::MAX / 2);
sh_test!(shl(usize::MAX, -((usize::BITS + 1) as $t)) == usize::MAX / 2);
}
}
Fix a breaking change in #30523 While this does fix a breaking change, it is also, technically, a [breaking-change] to go back to our original way
2016-01-06 06:16:03 +00:00
// FIXME(#23545): Uncomment the remaining tests
//sh_test_all!(i8);
//sh_test_all!(u8);
//sh_test_all!(i16);
//sh_test_all!(u16);
//sh_test_all!(i32);
//sh_test_all!(u32);
//sh_test_all!(i64);
//sh_test_all!(u64);
//sh_test_all!(isize);
Finish test implementation
2016-01-02 22:36:28 +00:00
sh_test_all!(usize);
Fix a breaking change in #30523 While this does fix a breaking change, it is also, technically, a [breaking-change] to go back to our original way
2016-01-06 06:16:03 +00:00
//sh_test_negative_all!(i8);
//sh_test_negative_all!(i16);
//sh_test_negative_all!(i32);
//sh_test_negative_all!(i64);
//sh_test_negative_all!(isize);
In the middle of the implementation
2016-01-01 12:28:26 +00:00
}
fn test_sh_op_assigns() {
macro_rules! sh_assign_test {
($op:ident ($initial:expr, $rhs:expr) == $ans:expr) => {{
let mut tmp = Wrapping($initial);
tmp = black_box(tmp);
tmp.$op($rhs);
assert_eq!(black_box(tmp), Wrapping($ans));
}}
}
Finish test implementation
2016-01-02 22:36:28 +00:00
macro_rules! sh_assign_test_all {
($t:ty) => {
sh_assign_test!(shl_assign(i8::MAX, (i8::BITS + 1) as $t) == -2);
sh_assign_test!(shl_assign(i16::MAX, (i16::BITS + 1) as $t) == -2);
sh_assign_test!(shl_assign(i32::MAX, (i32::BITS + 1) as $t) == -2);
sh_assign_test!(shl_assign(i64::MAX, (i64::BITS + 1) as $t) == -2);
sh_assign_test!(shl_assign(isize::MAX, (isize::BITS + 1) as $t) == -2);
sh_assign_test!(shl_assign(u8::MAX, (u8::BITS + 1) as $t) == u8::MAX - 1);
sh_assign_test!(shl_assign(u16::MAX, (u16::BITS + 1) as $t) == u16::MAX - 1);
sh_assign_test!(shl_assign(u32::MAX, (u32::BITS + 1) as $t) == u32::MAX - 1);
sh_assign_test!(shl_assign(u64::MAX, (u64::BITS + 1) as $t) == u64::MAX - 1);
sh_assign_test!(shl_assign(usize::MAX, (usize::BITS + 1) as $t) == usize::MAX - 1);
sh_assign_test!(shr_assign(i8::MAX, (i8::BITS + 1) as $t) == i8::MAX / 2);
sh_assign_test!(shr_assign(i16::MAX, (i16::BITS + 1) as $t) == i16::MAX / 2);
sh_assign_test!(shr_assign(i32::MAX, (i32::BITS + 1) as $t) == i32::MAX / 2);
sh_assign_test!(shr_assign(i64::MAX, (i64::BITS + 1) as $t) == i64::MAX / 2);
sh_assign_test!(shr_assign(isize::MAX, (isize::BITS + 1) as $t) == isize::MAX / 2);
sh_assign_test!(shr_assign(u8::MAX, (u8::BITS + 1) as $t) == u8::MAX / 2);
sh_assign_test!(shr_assign(u16::MAX, (u16::BITS + 1) as $t) == u16::MAX / 2);
sh_assign_test!(shr_assign(u32::MAX, (u32::BITS + 1) as $t) == u32::MAX / 2);
sh_assign_test!(shr_assign(u64::MAX, (u64::BITS + 1) as $t) == u64::MAX / 2);
sh_assign_test!(shr_assign(usize::MAX, (usize::BITS + 1) as $t) == usize::MAX / 2);
}
}
macro_rules! sh_assign_test_negative_all {
($t:ty) => {
sh_assign_test!(shr_assign(i8::MAX, -((i8::BITS + 1) as $t)) == -2);
sh_assign_test!(shr_assign(i16::MAX, -((i16::BITS + 1) as $t)) == -2);
sh_assign_test!(shr_assign(i32::MAX, -((i32::BITS + 1) as $t)) == -2);
sh_assign_test!(shr_assign(i64::MAX, -((i64::BITS + 1) as $t)) == -2);
sh_assign_test!(shr_assign(isize::MAX, -((isize::BITS + 1) as $t)) == -2);
sh_assign_test!(shr_assign(u8::MAX, -((u8::BITS + 1) as $t)) == u8::MAX - 1);
sh_assign_test!(shr_assign(u16::MAX, -((u16::BITS + 1) as $t)) == u16::MAX - 1);
sh_assign_test!(shr_assign(u32::MAX, -((u32::BITS + 1) as $t)) == u32::MAX - 1);
sh_assign_test!(shr_assign(u64::MAX, -((u64::BITS + 1) as $t)) == u64::MAX - 1);
sh_assign_test!(shr_assign(usize::MAX, -((usize::BITS + 1) as $t)) == usize::MAX - 1);
sh_assign_test!(shl_assign(i8::MAX, -((i8::BITS + 1) as $t)) == i8::MAX / 2);
sh_assign_test!(shl_assign(i16::MAX, -((i16::BITS + 1) as $t)) == i16::MAX / 2);
sh_assign_test!(shl_assign(i32::MAX, -((i32::BITS + 1) as $t)) == i32::MAX / 2);
sh_assign_test!(shl_assign(i64::MAX, -((i64::BITS + 1) as $t)) == i64::MAX / 2);
sh_assign_test!(shl_assign(isize::MAX, -((isize::BITS + 1) as $t)) == isize::MAX / 2);
sh_assign_test!(shl_assign(u8::MAX, -((u8::BITS + 1) as $t)) == u8::MAX / 2);
sh_assign_test!(shl_assign(u16::MAX, -((u16::BITS + 1) as $t)) == u16::MAX / 2);
sh_assign_test!(shl_assign(u32::MAX, -((u32::BITS + 1) as $t)) == u32::MAX / 2);
sh_assign_test!(shl_assign(u64::MAX, -((u64::BITS + 1) as $t)) == u64::MAX / 2);
sh_assign_test!(shl_assign(usize::MAX, -((usize::BITS + 1) as $t)) == usize::MAX / 2);
}
}
Fix a breaking change in #30523 While this does fix a breaking change, it is also, technically, a [breaking-change] to go back to our original way
2016-01-06 06:16:03 +00:00
// FIXME(#23545): Uncomment the remaining tests
//sh_assign_test_all!(i8);
//sh_assign_test_all!(u8);
//sh_assign_test_all!(i16);
//sh_assign_test_all!(u16);
//sh_assign_test_all!(i32);
//sh_assign_test_all!(u32);
//sh_assign_test_all!(i64);
//sh_assign_test_all!(u64);
//sh_assign_test_all!(isize);
Finish test implementation
2016-01-02 22:36:28 +00:00
sh_assign_test_all!(usize);
Fix a breaking change in #30523 While this does fix a breaking change, it is also, technically, a [breaking-change] to go back to our original way
2016-01-06 06:16:03 +00:00
//sh_assign_test_negative_all!(i8);
//sh_assign_test_negative_all!(i16);
//sh_assign_test_negative_all!(i32);
//sh_assign_test_negative_all!(i64);
//sh_assign_test_negative_all!(isize);
In the middle of the implementation
2016-01-01 12:28:26 +00:00
}
Reference in New Issue Copy Permalink