Source code
Revision control
Copy as Markdown
Other Tools
use std::hash::Hash;
use crate::{
IntErrorKind, OptionRangedI128, OptionRangedI16, OptionRangedI32, OptionRangedI64,
OptionRangedI8, OptionRangedIsize, OptionRangedU128, OptionRangedU16, OptionRangedU32,
OptionRangedU64, OptionRangedU8, OptionRangedUsize, ParseIntError, RangedI128, RangedI16,
RangedI32, RangedI64, RangedI8, RangedIsize, RangedU128, RangedU16, RangedU32, RangedU64,
RangedU8, RangedUsize, TryFromIntError,
};
macro_rules! if_signed {
(signed $($x:tt)*) => { $($x)* };
(unsigned $($x:tt)*) => {};
}
macro_rules! if_unsigned {
(signed $($x:tt)*) => {};
(unsigned $($x:tt)*) => { $($x)* };
}
#[test]
fn errors() {
assert_eq!(
TryFromIntError.to_string(),
"out of range integral type conversion attempted"
);
assert_eq!(TryFromIntError.clone(), TryFromIntError);
assert_eq!(format!("{TryFromIntError:?}"), "TryFromIntError");
assert_eq!(
ParseIntError {
kind: IntErrorKind::Empty,
}
.to_string(),
"cannot parse integer from empty string"
);
assert_eq!(
ParseIntError {
kind: IntErrorKind::InvalidDigit,
}
.to_string(),
"invalid digit found in string"
);
assert_eq!(
ParseIntError {
kind: IntErrorKind::PosOverflow,
}
.to_string(),
"number too large to fit in target type"
);
assert_eq!(
ParseIntError {
kind: IntErrorKind::NegOverflow,
}
.to_string(),
"number too small to fit in target type"
);
assert_eq!(
ParseIntError {
kind: IntErrorKind::Zero,
}
.to_string(),
"number would be zero for non-zero type"
);
assert_eq!(
format!(
"{:?}",
ParseIntError {
kind: IntErrorKind::Empty
}
),
"ParseIntError { kind: Empty }"
);
assert_eq!(
ParseIntError {
kind: IntErrorKind::Empty
}
.clone(),
ParseIntError {
kind: IntErrorKind::Empty
}
);
assert_eq!(
ParseIntError {
kind: IntErrorKind::Empty
}
.kind(),
&IntErrorKind::Empty
);
}
macro_rules! tests {
($($signed:ident $opt:ident $t:ident $inner:ident),* $(,)?) => {
#[test]
fn derives() {$(
assert_eq!($t::<5, 10>::MIN.clone(), $t::<5, 10>::MIN);
let mut hasher = std::collections::hash_map::DefaultHasher::new();
$t::<5, 10>::MIN.hash(&mut hasher);
assert_eq!(
$t::<5, 10>::MIN.cmp(&$t::<5, 10>::MAX),
std::cmp::Ordering::Less
);
assert_eq!($opt::<5, 10>::None.clone(), $opt::<5, 10>::None);
$opt::<5, 10>::None.hash(&mut hasher);
)*}
#[test]
fn expand() {$(
let expanded: $t::<0, 20> = $t::<5, 10>::MAX.expand();
assert_eq!(expanded, $t::<0, 20>::new_static::<10>());
)*}
#[test]
fn narrow() {$(
let narrowed: Option<$t::<10, 20>> = $t::<0, 20>::new_static::<10>().narrow();
assert_eq!(narrowed, Some($t::<10, 20>::MIN));
)*}
#[test]
fn new() {$(
assert!($t::<5, 10>::new(10).is_some());
assert!($t::<5, 10>::new(11).is_none());
)*}
#[test]
fn new_static() {$(
let six: $t::<5, 10> = $t::<5, 10>::new_static::<6>();
assert_eq!(Some(six), $t::<5, 10>::new(6));
)*}
#[test]
fn some_unchecked() {$(
// Safety: The value is in range.
unsafe {
assert_eq!($opt::<5, 10>::some_unchecked(10), $opt::Some($t::<5, 10>::MAX));
}
)*}
#[test]
fn is_some() {$(
assert!($opt::<5, 10>::Some($t::<5, 10>::MAX).is_some());
)*}
#[test]
fn is_none() {$(
assert!($opt::<5, 10>::None.is_none());
)*}
#[test]
fn default() {$(
assert_eq!($opt::<5, 10>::default(), $opt::<5, 10>::None);
)*}
#[test]
fn get() {$(
assert_eq!($t::<5, 10>::MAX.get(), 10);
assert_eq!($opt::<5, 10>::None.get(), None);
assert_eq!($opt::Some($t::<5, 10>::MAX).get(), Some($t::<5, 10>::MAX));
)*}
#[test]
fn get_primitive() {$(
assert_eq!($opt::Some($t::<5, 10>::MAX).get_primitive(), Some(10));
assert_eq!($opt::<5, 10>::None.get_primitive(), None);
)*}
#[test]
fn get_ref() {$(
assert_eq!($t::<5, 10>::MAX.get_ref(), &10);
)*}
#[test]
fn new_saturating() {$(
assert_eq!($t::<5, 10>::new_saturating(11), $t::<5, 10>::MAX);
assert_eq!($t::<5, 10>::new_saturating(0), $t::<5, 10>::MIN);
assert_eq!($t::<5, 10>::new_saturating(9), $t::<5, 10>::new_static::<9>());
)*}
#[test]
fn from_str_radix() {$(
assert_eq!($t::<5, 10>::from_str_radix("10", 10), Ok($t::<5, 10>::MAX));
assert_eq!($t::<5, 10>::from_str_radix("5", 10), Ok($t::<5, 10>::MIN));
assert_eq!(
$t::<5, 10>::from_str_radix("4", 10),
Err(ParseIntError { kind: IntErrorKind::NegOverflow }),
);
assert_eq!(
$t::<5, 10>::from_str_radix("11", 10),
Err(ParseIntError { kind: IntErrorKind::PosOverflow }),
);
assert_eq!(
$t::<5, 10>::from_str_radix("", 10),
Err(ParseIntError { kind: IntErrorKind::Empty }),
);
)*}
#[test]
fn checked_add() {$(
assert_eq!($t::<5, 10>::MAX.checked_add(1), None);
assert_eq!($t::<5, 10>::MAX.checked_add(0), Some($t::<5, 10>::MAX));
)*}
#[test]
fn unchecked_add() {$(
// Safety: The result is in range.
unsafe {
assert_eq!($t::<5, 10>::MIN.unchecked_add(5), $t::<5, 10>::MAX);
}
)*}
#[test]
fn checked_sub() {$(
assert_eq!($t::<5, 10>::MIN.checked_sub(1), None);
assert_eq!($t::<5, 10>::MIN.checked_sub(0), Some($t::<5, 10>::MIN));
)*}
#[test]
fn unchecked_sub() {$(
// Safety: The result is in range.
unsafe {
assert_eq!($t::<5, 10>::MAX.unchecked_sub(5), $t::<5, 10>::MIN);
}
)*}
#[test]
fn checked_mul() {$(
assert_eq!($t::<5, 10>::MAX.checked_mul(2), None);
assert_eq!($t::<5, 10>::MAX.checked_mul(1), Some($t::<5, 10>::MAX));
)*}
#[test]
fn unchecked_mul() {$(
// Safety: The result is in range.
unsafe {
assert_eq!($t::<5, 10>::MAX.unchecked_mul(1), $t::<5, 10>::MAX);
}
)*}
#[test]
fn checked_div() {$(
assert_eq!($t::<5, 10>::MAX.checked_div(3), None);
assert_eq!($t::<5, 10>::MAX.checked_div(2), $t::<5, 10>::new(5));
assert_eq!($t::<5, 10>::MAX.checked_div(1), Some($t::<5, 10>::MAX));
assert_eq!($t::<5, 10>::MAX.checked_div(0), None);
)*}
#[test]
fn unchecked_div() {$(
// Safety: The result is in range.
unsafe {
assert_eq!($t::<5, 10>::MAX.unchecked_div(1), $t::<5, 10>::MAX);
}
)*}
#[test]
fn checked_div_euclid() {$(
assert_eq!($t::<5, 10>::MAX.checked_div_euclid(3), None);
assert_eq!($t::<5, 10>::MAX.checked_div_euclid(2), $t::<5, 10>::new(5));
assert_eq!($t::<5, 10>::MAX.checked_div_euclid(1), Some($t::<5, 10>::MAX));
assert_eq!($t::<5, 10>::MAX.checked_div_euclid(0), None);
)*}
#[test]
fn unchecked_div_euclid() {$(
// Safety: The result is in range.
unsafe {
assert_eq!($t::<5, 10>::MAX.unchecked_div_euclid(1), $t::<5, 10>::MAX);
}
)*}
#[test]
fn rem() {$(if_unsigned! { $signed
assert_eq!($t::<5, 10>::MAX.rem($t::exact::<3>()), $t::<0, 3>::new_static::<1>());
assert_eq!($t::<5, 10>::MAX.rem($t::exact::<5>()), $t::<0, 5>::MIN);
})*}
#[test]
fn checked_rem() {$(
assert_eq!($t::<5, 10>::MAX.checked_rem(11), Some($t::<5, 10>::MAX));
assert_eq!($t::<5, 10>::MAX.checked_rem(5), None);
)*}
#[test]
fn unchecked_rem() {$(
// Safety: The result is in range.
unsafe {
assert_eq!($t::<5, 10>::MAX.unchecked_rem(11), $t::<5, 10>::MAX);
}
)*}
#[test]
fn checked_rem_euclid() {$(
assert_eq!($t::<5, 10>::MAX.checked_rem_euclid(11), Some($t::<5, 10>::MAX));
assert_eq!($t::<5, 10>::MAX.checked_rem_euclid(5), None);
)*}
#[test]
fn unchecked_rem_euclid() {$(
// Safety: The result is in range.
unsafe {
assert_eq!($t::<5, 10>::MAX.unchecked_rem_euclid(11), $t::<5, 10>::MAX);
}
)*}
#[test]
fn checked_neg() {$(
assert_eq!($t::<5, 10>::MIN.checked_neg(), None);
assert_eq!($t::<0, 10>::MIN.checked_neg(), Some($t::<0, 10>::MIN));
)*}
#[test]
fn unchecked_neg() {$(
// Safety: The result is in range.
unsafe {
assert_eq!($t::<0, 10>::MIN.unchecked_neg(), $t::<0, 10>::MIN);
}
)*}
#[test]
fn neg() {$( if_signed! { $signed
assert_eq!($t::<-10, 10>::MIN.neg(), $t::<-10, 10>::MAX);
})*}
#[test]
fn checked_shl() {$(
assert_eq!($t::<5, 10>::MAX.checked_shl(1), None);
assert_eq!($t::<5, 10>::MAX.checked_shl(0), Some($t::<5, 10>::MAX));
assert_eq!($t::<5, 10>::MIN.checked_shl(1), Some($t::<5, 10>::MAX));
)*}
#[test]
fn unchecked_shl() {$(
// Safety: The result is in range.
unsafe {
assert_eq!($t::<5, 10>::MAX.unchecked_shl(0), $t::<5, 10>::MAX);
assert_eq!($t::<5, 10>::MIN.unchecked_shl(1), $t::<5, 10>::MAX);
}
)*}
#[test]
fn checked_shr() {$(
assert_eq!($t::<5, 10>::MAX.checked_shr(2), None);
assert_eq!($t::<5, 10>::MAX.checked_shr(1), Some($t::<5, 10>::MIN));
assert_eq!($t::<5, 10>::MAX.checked_shr(0), Some($t::<5, 10>::MAX));
)*}
#[test]
fn unchecked_shr() {$(
// Safety: The result is in range.
unsafe {
assert_eq!($t::<5, 10>::MAX.unchecked_shr(1), $t::<5, 10>::MIN);
assert_eq!($t::<5, 10>::MAX.unchecked_shr(0), $t::<5, 10>::MAX);
}
)*}
#[test]
fn checked_abs() {$( if_signed! { $signed
assert_eq!($t::<5, 10>::MAX.checked_abs(), Some($t::<5, 10>::MAX));
assert_eq!($t::<-10, 10>::MIN.checked_abs(), Some($t::<-10, 10>::MAX));
assert_eq!($t::<-10, 0>::MIN.checked_abs(), None);
})*}
#[test]
fn unchecked_abs() { $(if_signed! { $signed
// Safety: The result is in range.
unsafe {
assert_eq!($t::<5, 10>::MAX.unchecked_abs(), $t::<5, 10>::MAX);
assert_eq!($t::<-10, 10>::MIN.unchecked_abs(), $t::<-10, 10>::MAX);
}
})*}
#[test]
fn abs() { $(if_signed! { $signed
assert_eq!($t::<-5, 10>::MIN.abs().get(), 5);
})*}
#[test]
fn checked_pow() {$(
assert_eq!($t::<5, 10>::MAX.checked_pow(0), None);
assert_eq!($t::<5, 10>::MAX.checked_pow(1), Some($t::<5, 10>::MAX));
assert_eq!($t::<5, 10>::MAX.checked_pow(2), None);
)*}
#[test]
fn unchecked_pow() {$(
// Safety: The result is in range.
unsafe {
assert_eq!($t::<5, 10>::MAX.unchecked_pow(1), $t::<5, 10>::MAX);
}
)*}
#[test]
fn saturating_add() {$(
assert_eq!($t::<5, 10>::MAX.saturating_add(0), $t::<5, 10>::MAX);
assert_eq!($t::<5, 10>::MAX.saturating_add(1), $t::<5, 10>::MAX);
)*}
#[test]
fn wrapping_add() {
$(
assert_eq!($t::<5, 10>::MAX.wrapping_add(0), $t::<5, 10>::MAX);
assert_eq!($t::<5, 10>::MAX.wrapping_add(1), $t::<5, 10>::MIN);
assert_eq!($t::<{ $inner::MIN }, { $inner::MAX }>::MAX.wrapping_add(1),
$t::<{ $inner::MIN }, { $inner::MAX }>::MIN);
for i in 1..127 {
assert_eq!(
$t::<{ $inner::MIN}, { $inner::MAX - 1 }>::MAX.wrapping_add(i),
$t::<{ $inner::MIN}, { $inner::MAX - 1 }>::new($inner::MIN + i - 1).unwrap_or_else(|| panic!("adding {i}+{} does not yield {}", $inner::MIN, $inner::MAX + i ))
);
}
)*
$(if_signed! { $signed
for i in 1..=127 {
assert_eq!($t::<-5, 126>::MIN.wrapping_add(-i), $t::<-5,126>::new(126-i+1).unwrap_or_else(|| panic!("adding {i}+{} does not yield {}", $inner::MIN, 126-i+1)));
assert_eq!($t::<-5, 126>::MIN.wrapping_add(i), $t::<-5,126>::new(-5+i).unwrap_or_else(|| panic!("adding {i}+{} does not yield {}", $inner::MIN, 126-i+1)));
}
for i in -127..=-1 {
assert_eq!($t::<-5, 126>::MIN.wrapping_add(i), $t::<-5,126>::new(126+i+1).unwrap_or_else(|| panic!("adding {i}+{} does not yield {}", $inner::MIN, 126-i+1)));
assert_eq!($t::<-5, 126>::MIN.wrapping_add(-i), $t::<-5,126>::new(-5-i).unwrap_or_else(|| panic!("adding {i}+{} does not yield {}", $inner::MIN, 126-i+1)));
}
assert_eq!($t::<-5, 126>::MIN.wrapping_add(-128), $t::<-5,126>::new(-1).unwrap_or_else(|| panic!("adding 128+{} does not yield -1", $inner::MIN)));
assert_eq!($t::<-5, 10>::MAX.wrapping_add(0), $t::<-5, 10>::MAX);
assert_eq!($t::<-5, -3>::MIN.wrapping_add(-1-3), $t::<-5, -3>::MAX);
assert_eq!($t::<-5, -3>::MIN.wrapping_add(-1-30), $t::<-5, -3>::MAX);
assert_eq!($t::<-5, -3>::MIN.wrapping_add(30), $t::<-5, -3>::MIN);
assert_eq!($t::<-5, -3>::MIN.wrapping_add(-30), $t::<-5, -3>::MIN);
assert_eq!($t::<-5, 10>::MAX.wrapping_add(25), $t::<-5, 10>::MIN.wrapping_add(24));
assert_eq!($t::<-5, 10>::MIN.wrapping_add(24), $t::<-5, 10>::MIN.wrapping_add(8));
assert_eq!($t::<-5, 10>::MAX.wrapping_add(1), $t::<-5, 10>::MIN);
assert_eq!($t::<-5, 10>::MIN.wrapping_add(-1), $t::<-5, 10>::MAX);
assert_eq!($t::<-5, 127>::MIN.wrapping_add(-1), $t::<-5, 127>::MAX);
assert_eq!($t::<-127, 126>::MIN.wrapping_add(-1), $t::<-127, 126>::MAX);
assert_eq!($t::<{ $inner::MIN }, { $inner::MAX }>::MIN.wrapping_add(-1),
$t::<{ $inner::MIN }, { $inner::MAX }>::MAX);
})*
}
#[test]
fn wrapping_sub() {
$(
assert_eq!($t::<5, 10>::MIN.wrapping_sub(0), $t::<5, 10>::MIN);
assert_eq!($t::<5, 10>::MIN.wrapping_sub(1), $t::<5, 10>::MAX);
assert_eq!($t::<5, 10>::new(5 + 1).unwrap().wrapping_sub(1), $t::<5, 10>::MIN);
assert_eq!($t::<5, 10>::MAX.wrapping_sub(1), $t::<5, 10>::new(10 - 1).unwrap());
assert_eq!($t::<{ $inner::MIN }, { $inner::MAX }>::MIN.wrapping_sub(1),
$t::<{ $inner::MIN }, { $inner::MAX }>::MAX);
for i in 1..127 {
assert_eq!(
$t::<{ $inner::MIN + 1 }, { $inner::MAX }>::MIN.wrapping_sub(i),
$t::<{ $inner::MIN + 1 }, { $inner::MAX }>::new($inner::MAX - i + 1).unwrap_or_else(|| panic!("failed test at iteration {i}"))
);
}
)*
$(if_signed! { $signed
for i in -127..=127 {
assert_eq!($t::<-5, 126>::MIN.wrapping_add(i), $t::<-5,126>::MIN.wrapping_sub(-i), "failed test at {i}");
assert_eq!($t::<-5, 126>::MIN.wrapping_add(-i), $t::<-5,126>::MIN.wrapping_sub(i), "failed test at {i}");
}
assert_eq!(
$t::<-5, 126>::MIN.wrapping_add(127).wrapping_add(1),
$t::<-5,126>::MIN.wrapping_sub(-128)
);
assert_eq!(
$t::<-5, 126>::MIN.wrapping_add(-128),
$t::<-5,126>::MIN.wrapping_sub(127).wrapping_sub(1)
);
})*
}
#[test]
fn saturating_sub() {$(
assert_eq!($t::<5, 10>::MIN.saturating_sub(0), $t::<5, 10>::MIN);
assert_eq!($t::<5, 10>::MIN.saturating_sub(1), $t::<5, 10>::MIN);
)*}
#[test]
fn saturating_neg() {$(if_signed! { $signed
assert_eq!($t::<5, 10>::MIN.saturating_neg(), $t::<5, 10>::MIN);
assert_eq!($t::<5, 10>::MAX.saturating_neg(), $t::<5, 10>::MIN);
assert_eq!($t::<-10, 0>::MIN.saturating_neg(), $t::<-10, 0>::MAX);
assert_eq!($t::<-10, 0>::MAX.saturating_neg(), $t::<-10, 0>::MAX);
})*}
#[test]
fn saturating_abs() {$(if_signed! { $signed
assert_eq!($t::<5, 10>::MIN.saturating_abs(), $t::<5, 10>::MIN);
assert_eq!($t::<5, 10>::MAX.saturating_abs(), $t::<5, 10>::MAX);
assert_eq!($t::<-10, 0>::MIN.saturating_abs(), $t::<-10, 0>::MAX);
assert_eq!($t::<-10, 0>::MAX.saturating_abs(), $t::<-10, 0>::MAX);
})*}
#[test]
fn saturating_mul() {$(
assert_eq!($t::<5, 10>::MIN.saturating_mul(0), $t::<5, 10>::MIN);
assert_eq!($t::<5, 10>::MIN.saturating_mul(1), $t::<5, 10>::MIN);
assert_eq!($t::<5, 10>::MIN.saturating_mul(2), $t::<5, 10>::MAX);
assert_eq!($t::<5, 10>::MIN.saturating_mul(3), $t::<5, 10>::MAX);
)*}
#[test]
fn saturating_pow() {$(
assert_eq!($t::<5, 10>::MIN.saturating_pow(0), $t::<5, 10>::MIN);
assert_eq!($t::<5, 10>::MIN.saturating_pow(1), $t::<5, 10>::MIN);
assert_eq!($t::<5, 10>::MIN.saturating_pow(2), $t::<5, 10>::MAX);
assert_eq!($t::<5, 10>::MIN.saturating_pow(3), $t::<5, 10>::MAX);
)*}
#[test]
fn as_ref() {$(
assert_eq!($t::<5, 10>::MIN.as_ref(), &5);
assert_eq!($t::<5, 10>::MAX.as_ref(), &10);
)*}
#[test]
fn borrow() {
use std::borrow::Borrow;
$(
assert_eq!(Borrow::<$inner>::borrow(&$t::<5, 10>::MIN), &5);
assert_eq!(Borrow::<$inner>::borrow(&$t::<5, 10>::MAX), &10);
)*
}
#[test]
fn formatting() {$(
let val = $t::<5, 10>::MAX;
assert_eq!(format!("{}", val), "10");
assert_eq!(format!("{:?}", val), "10");
assert_eq!(format!("{:b}", val), "1010");
assert_eq!(format!("{:o}", val), "12");
assert_eq!(format!("{:x}", val), "a");
assert_eq!(format!("{:X}", val), "A");
assert_eq!(format!("{:e}", val), "1e1");
assert_eq!(format!("{:E}", val), "1E1");
assert_eq!(format!("{:?}", $opt::Some($t::<5, 10>::MAX)), "Some(10)");
assert_eq!(format!("{:?}", $opt::<5, 10>::None), "None");
)*}
#[test]
fn ord() {$(
assert!($t::<5, 10>::MIN < $t::<5, 10>::MAX);
assert!($t::<5, 10>::MIN <= $t::<5, 10>::MAX);
assert!($t::<5, 10>::MAX > $t::<5, 10>::MIN);
assert!($t::<5, 10>::MAX >= $t::<5, 10>::MIN);
let none = $opt::<5, 10>::None;
let five = $opt::Some($t::<5, 10>::MIN);
let ten = $opt::Some($t::<5, 10>::MAX);
assert_eq!(none.cmp(&none), std::cmp::Ordering::Equal);
assert_eq!(five.cmp(&five), std::cmp::Ordering::Equal);
assert_eq!(ten.cmp(&ten), std::cmp::Ordering::Equal);
assert_eq!(none.cmp(&five), std::cmp::Ordering::Less);
assert_eq!(five.cmp(&ten), std::cmp::Ordering::Less);
assert_eq!(none.cmp(&ten), std::cmp::Ordering::Less);
assert_eq!(ten.cmp(&none), std::cmp::Ordering::Greater);
let none = $opt::<0, 10>::None;
let zero = $opt::Some($t::<0, 10>::MIN);
let ten = $opt::Some($t::<0, 10>::MAX);
assert_eq!(none.partial_cmp(&none), Some(std::cmp::Ordering::Equal));
assert_eq!(none.partial_cmp(&zero), Some(std::cmp::Ordering::Less));
assert_eq!(zero.partial_cmp(&ten), Some(std::cmp::Ordering::Less));
assert_eq!(none.partial_cmp(&ten), Some(std::cmp::Ordering::Less));
assert_eq!(ten.partial_cmp(&none), Some(std::cmp::Ordering::Greater));
)*}
#[test]
fn from() {$(
assert_eq!($inner::from($t::<5, 10>::MAX), 10);
assert_eq!($inner::from($t::<5, 10>::MIN), 5);
assert_eq!($opt::from($t::<5, 10>::MAX), $opt::Some($t::<5, 10>::MAX));
assert_eq!($opt::from(Some($t::<5, 10>::MAX)), $opt::Some($t::<5, 10>::MAX));
assert_eq!($opt::<5, 10>::from(None), $opt::<5, 10>::None);
assert_eq!(Option::from($opt::Some($t::<5, 10>::MAX)), Some($t::<5, 10>::MAX));
assert_eq!(Option::<$t<5, 10>>::from($opt::<5, 10>::None), None);
)*}
#[test]
fn try_from() {$(
assert_eq!($t::<5, 10>::try_from(10), Ok($t::<5, 10>::MAX));
assert_eq!($t::<5, 10>::try_from(5), Ok($t::<5, 10>::MIN));
assert_eq!($t::<5, 10>::try_from(4), Err(TryFromIntError));
assert_eq!($t::<5, 10>::try_from(11), Err(TryFromIntError));
)*}
#[test]
fn from_str() {$(
assert_eq!("10".parse::<$t<5, 10>>(), Ok($t::<5, 10>::MAX));
assert_eq!("5".parse::<$t<5, 10>>(), Ok($t::<5, 10>::MIN));
assert_eq!("4".parse::<$t<5, 10>>(), Err(ParseIntError { kind: IntErrorKind::NegOverflow }));
assert_eq!("11".parse::<$t<5, 10>>(), Err(ParseIntError { kind: IntErrorKind::PosOverflow }));
assert_eq!("".parse::<$t<5, 10>>(), Err(ParseIntError { kind: IntErrorKind::Empty }));
)*}
#[cfg(feature = "serde")]
#[test]
fn serde() -> serde_json::Result<()> {
$(
let val = $t::<5, 10>::MAX;
let serialized = serde_json::to_string(&val)?;
assert_eq!(serialized, "10");
let deserialized: $t<5, 10> = serde_json::from_str(&serialized)?;
assert_eq!(deserialized, val);
assert!(serde_json::from_str::<$t<5, 10>>("").is_err());
assert!(serde_json::from_str::<$t<5, 10>>("4").is_err());
assert!(serde_json::from_str::<$t<5, 10>>("11").is_err());
let val = $opt::<5, 10>::Some($t::<5, 10>::MAX);
let serialized = serde_json::to_string(&val)?;
assert_eq!(serialized, "10");
let deserialized: $opt<5, 10> = serde_json::from_str(&serialized)?;
assert_eq!(deserialized, val);
assert!(serde_json::from_str::<$opt<5, 10>>("").is_err());
assert!(serde_json::from_str::<$opt<5, 10>>("4").is_err());
assert!(serde_json::from_str::<$opt<5, 10>>("11").is_err());
let val = $opt::<5, 10>::None;
let serialized = serde_json::to_string(&val)?;
assert_eq!(serialized, "null");
assert!(serde_json::from_str::<$opt<5, 10>>("").is_err());
assert!(serde_json::from_str::<$opt<5, 10>>("4").is_err());
assert!(serde_json::from_str::<$opt<5, 10>>("11").is_err());
)*
Ok(())
}
#[cfg(feature = "rand")]
#[test]
fn rand() {$(
let rand_val: $t<5, 10> = rand::random();
assert!(rand_val >= $t::<5, 10>::MIN);
assert!(rand_val <= $t::<5, 10>::MAX);
let rand: $opt<5, 10> = rand::random();
if let Some(rand) = rand.get() {
assert!(rand >= $t::<5, 10>::MIN);
assert!(rand <= $t::<5, 10>::MAX);
}
)*}
#[cfg(feature = "num")]
#[test]
fn num() {$(
assert_eq!(<$t<5, 10> as num_traits::Bounded>::min_value(), $t::<5, 10>::MIN);
assert_eq!(<$t<5, 10> as num_traits::Bounded>::max_value(), $t::<5, 10>::MAX);
)*}
#[cfg(feature = "quickcheck")]
#[test]
fn quickcheck() {$(
#[allow(trivial_casts)]
quickcheck::quickcheck((|val| {
val >= $t::<5, 10>::MIN && val <= $t::<5, 10>::MAX
}) as fn($t<5, 10>) -> bool);
#[allow(trivial_casts)]
quickcheck::quickcheck((|val| {
if let Some(val) = val.get() {
val >= $t::<5, 10>::MIN && val <= $t::<5, 10>::MAX
} else {
true
}
}) as fn($opt<5, 10>) -> bool);
)*}
};
}
tests![
signed OptionRangedI8 RangedI8 i8,
signed OptionRangedI16 RangedI16 i16,
signed OptionRangedI32 RangedI32 i32,
signed OptionRangedI64 RangedI64 i64,
signed OptionRangedI128 RangedI128 i128,
signed OptionRangedIsize RangedIsize isize,
unsigned OptionRangedU8 RangedU8 u8,
unsigned OptionRangedU16 RangedU16 u16,
unsigned OptionRangedU32 RangedU32 u32,
unsigned OptionRangedU64 RangedU64 u64,
unsigned OptionRangedU128 RangedU128 u128,
unsigned OptionRangedUsize RangedUsize usize,
];