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 23:34:48 +00:00
Code Issues Packages Projects Releases Wiki Activity
c3e182cf43
rust/src/test/run-pass/numbers-arithmetic/num-wrapping.rs

448 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;
pub use std::$name::*;
}
)*)
}
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));
}
Take out Op<T>/OpAssign<T> for Wrapping<T>
2016-01-02 23:34:55 +00:00
// FIXME(30524): Uncomment this test
/*
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