fix some bugs and add some tests from from_str stuff
This commit is contained in:
parent
3a4a99a380
commit
5efb6f4f85
348
src/from_str.rs
348
src/from_str.rs
|
@ -23,55 +23,69 @@ use crate::{
|
||||||
use core::{
|
use core::{
|
||||||
cmp::{self, Ordering},
|
cmp::{self, Ordering},
|
||||||
fmt::{Display, Formatter, Result as FmtResult},
|
fmt::{Display, Formatter, Result as FmtResult},
|
||||||
ops::{Add, Shl},
|
ops::{Add, Shl, Shr},
|
||||||
str::FromStr,
|
str::FromStr,
|
||||||
};
|
};
|
||||||
|
|
||||||
fn bin_str_to_bin<I>(a: &str, dump_bits: u32) -> Option<I>
|
fn bin_str_to_bin<I>(a: &str, dump_bits: u32) -> Option<I>
|
||||||
where
|
where
|
||||||
I: SealedInt<IsSigned = False> + Shl<u32, Output = I> + Add<Output = I> + From<u8>,
|
I: SealedInt<IsSigned = False> + From<u8>,
|
||||||
|
I: Shl<u32, Output = I> + Shr<u32, Output = I> + Add<Output = I>,
|
||||||
{
|
{
|
||||||
debug_assert!(!a.is_empty());
|
debug_assert!(!a.is_empty());
|
||||||
let mut bits = I::NBITS - dump_bits;
|
let req_bits = I::NBITS - dump_bits;
|
||||||
|
let mut rem_bits = req_bits;
|
||||||
let mut acc = I::ZERO;
|
let mut acc = I::ZERO;
|
||||||
for &byte in a.as_bytes() {
|
for &byte in a.as_bytes() {
|
||||||
let val = byte - b'0';
|
let val = byte - b'0';
|
||||||
if bits < 1 {
|
if rem_bits < 1 {
|
||||||
// round
|
// round
|
||||||
return acc.checked_add(I::from(val));
|
acc = acc.checked_add(I::from(val))?;
|
||||||
|
if dump_bits != 0 && !(acc >> req_bits).is_zero() {
|
||||||
|
return None;
|
||||||
|
}
|
||||||
|
return Some(acc);
|
||||||
}
|
}
|
||||||
acc = (acc << 1) + I::from(val);
|
acc = (acc << 1) + I::from(val);
|
||||||
bits -= 1;
|
rem_bits -= 1;
|
||||||
}
|
}
|
||||||
Some(acc << bits)
|
Some(acc << rem_bits)
|
||||||
}
|
}
|
||||||
|
|
||||||
fn oct_str_to_bin<I>(a: &str, dump_bits: u32) -> Option<I>
|
fn oct_str_to_bin<I>(a: &str, dump_bits: u32) -> Option<I>
|
||||||
where
|
where
|
||||||
I: SealedInt<IsSigned = False> + Shl<u32, Output = I> + Add<Output = I> + From<u8>,
|
I: SealedInt<IsSigned = False> + From<u8>,
|
||||||
|
I: Shl<u32, Output = I> + Shr<u32, Output = I> + Add<Output = I>,
|
||||||
{
|
{
|
||||||
debug_assert!(!a.is_empty());
|
debug_assert!(!a.is_empty());
|
||||||
let mut bits = I::NBITS - dump_bits;
|
let req_bits = I::NBITS - dump_bits;
|
||||||
|
let mut rem_bits = req_bits;
|
||||||
let mut acc = I::ZERO;
|
let mut acc = I::ZERO;
|
||||||
for &byte in a.as_bytes() {
|
for &byte in a.as_bytes() {
|
||||||
let val = byte - b'0';
|
let val = byte - b'0';
|
||||||
if bits < 3 {
|
if rem_bits < 3 {
|
||||||
acc = (acc << bits) + I::from(val >> (3 - bits));
|
acc = (acc << rem_bits) + I::from(val >> (3 - rem_bits));
|
||||||
// round
|
// round
|
||||||
return acc.checked_add(I::from((val >> (2 - bits)) & 1));
|
acc = acc.checked_add(I::from((val >> (2 - rem_bits)) & 1))?;
|
||||||
|
if dump_bits != 0 && !(acc >> req_bits).is_zero() {
|
||||||
|
return None;
|
||||||
|
}
|
||||||
|
return Some(acc);
|
||||||
}
|
}
|
||||||
acc = (acc << 3) + I::from(val);
|
acc = (acc << 3) + I::from(val);
|
||||||
bits -= 3;
|
rem_bits -= 3;
|
||||||
}
|
}
|
||||||
Some(acc << bits)
|
Some(acc << rem_bits)
|
||||||
}
|
}
|
||||||
|
|
||||||
fn hex_str_to_bin<I>(a: &str, dump_bits: u32) -> Option<I>
|
fn hex_str_to_bin<I>(a: &str, dump_bits: u32) -> Option<I>
|
||||||
where
|
where
|
||||||
I: SealedInt<IsSigned = False> + Shl<u32, Output = I> + Add<Output = I> + From<u8>,
|
I: SealedInt<IsSigned = False> + From<u8>,
|
||||||
|
I: Shl<u32, Output = I> + Shr<u32, Output = I> + Add<Output = I>,
|
||||||
{
|
{
|
||||||
debug_assert!(!a.is_empty());
|
debug_assert!(!a.is_empty());
|
||||||
let mut bits = I::NBITS - dump_bits;
|
let req_bits = I::NBITS - dump_bits;
|
||||||
|
let mut rem_bits = req_bits;
|
||||||
let mut acc = I::ZERO;
|
let mut acc = I::ZERO;
|
||||||
for &byte in a.as_bytes() {
|
for &byte in a.as_bytes() {
|
||||||
// We know that byte is a valid hex:
|
// We know that byte is a valid hex:
|
||||||
|
@ -79,15 +93,19 @@ where
|
||||||
// * b'A'..=b'F' (0x41..=0x46) => val = byte & 0x0f + 9
|
// * b'A'..=b'F' (0x41..=0x46) => val = byte & 0x0f + 9
|
||||||
// * b'a'..=b'f' (0x61..=0x66) => val = byte & 0x0f + 9
|
// * b'a'..=b'f' (0x61..=0x66) => val = byte & 0x0f + 9
|
||||||
let val = (byte & 0x0f) + if byte >= 0x40 { 9 } else { 0 };
|
let val = (byte & 0x0f) + if byte >= 0x40 { 9 } else { 0 };
|
||||||
if bits < 4 {
|
if rem_bits < 4 {
|
||||||
acc = (acc << bits) + I::from(val >> (4 - bits));
|
acc = (acc << rem_bits) + I::from(val >> (4 - rem_bits));
|
||||||
// round
|
// round
|
||||||
return acc.checked_add(I::from((val >> (3 - bits)) & 1));
|
acc = acc.checked_add(I::from((val >> (3 - rem_bits)) & 1))?;
|
||||||
|
if dump_bits != 0 && !(acc >> req_bits).is_zero() {
|
||||||
|
return None;
|
||||||
|
}
|
||||||
|
return Some(acc);
|
||||||
}
|
}
|
||||||
acc = (acc << 4) + I::from(val);
|
acc = (acc << 4) + I::from(val);
|
||||||
bits -= 4;
|
rem_bits -= 4;
|
||||||
}
|
}
|
||||||
Some(acc << bits)
|
Some(acc << rem_bits)
|
||||||
}
|
}
|
||||||
|
|
||||||
// 5^3 × 2 < 2^8 => (10^3 - 1) × 2^(8-3+1) < 2^16
|
// 5^3 × 2 < 2^8 => (10^3 - 1) × 2^(8-3+1) < 2^16
|
||||||
|
@ -485,16 +503,17 @@ macro_rules! impl_from_str_unsigned_not128 {
|
||||||
if frac.is_empty() {
|
if frac.is_empty() {
|
||||||
return Some(0);
|
return Some(0);
|
||||||
}
|
}
|
||||||
|
let int_nbits = <$Bits as SealedInt>::NBITS - nbits;
|
||||||
match radix {
|
match radix {
|
||||||
2 => bin_str_to_bin(frac, nbits),
|
2 => bin_str_to_bin(frac, int_nbits),
|
||||||
8 => oct_str_to_bin(frac, nbits),
|
8 => oct_str_to_bin(frac, int_nbits),
|
||||||
16 => hex_str_to_bin(frac, nbits),
|
16 => hex_str_to_bin(frac, int_nbits),
|
||||||
10 => {
|
10 => {
|
||||||
let end = cmp::min(frac.len(), $dec_frac_digits);
|
let end = cmp::min(frac.len(), $dec_frac_digits);
|
||||||
let rem = $dec_frac_digits - end;
|
let rem = $dec_frac_digits - end;
|
||||||
let ten: $DoubleBits = 10;
|
let ten: $DoubleBits = 10;
|
||||||
let i = frac[..end].parse::<$DoubleBits>().unwrap() * ten.pow(rem as u32);
|
let i = frac[..end].parse::<$DoubleBits>().unwrap() * ten.pow(rem as u32);
|
||||||
$decode_frac(i, <$Bits as SealedInt>::NBITS - nbits)
|
$decode_frac(i, int_nbits)
|
||||||
}
|
}
|
||||||
_ => unreachable!(),
|
_ => unreachable!(),
|
||||||
}
|
}
|
||||||
|
@ -578,8 +597,11 @@ fn get_frac128(frac: &str, radix: u32, nbits: u32) -> Option<u128> {
|
||||||
if frac.is_empty() {
|
if frac.is_empty() {
|
||||||
return Some(0);
|
return Some(0);
|
||||||
}
|
}
|
||||||
|
let int_nbits = <u128 as SealedInt>::NBITS - nbits;
|
||||||
match radix {
|
match radix {
|
||||||
2 => bin_str_to_bin(frac, nbits),
|
2 => bin_str_to_bin(frac, int_nbits),
|
||||||
|
8 => oct_str_to_bin(frac, int_nbits),
|
||||||
|
16 => hex_str_to_bin(frac, int_nbits),
|
||||||
10 => {
|
10 => {
|
||||||
let (hi, lo) = if frac.len() <= 27 {
|
let (hi, lo) = if frac.len() <= 27 {
|
||||||
let rem = 27 - frac.len();
|
let rem = 27 - frac.len();
|
||||||
|
@ -592,7 +614,7 @@ fn get_frac128(frac: &str, radix: u32, nbits: u32) -> Option<u128> {
|
||||||
let lo = frac[27..lo_end].parse::<u128>().unwrap() * 10u128.pow(rem as u32);
|
let lo = frac[27..lo_end].parse::<u128>().unwrap() * 10u128.pow(rem as u32);
|
||||||
(hi, lo)
|
(hi, lo)
|
||||||
};
|
};
|
||||||
dec27_27_to_bin128(hi, lo, <u128 as SealedInt>::NBITS - nbits)
|
dec27_27_to_bin128(hi, lo, int_nbits)
|
||||||
}
|
}
|
||||||
_ => unreachable!(),
|
_ => unreachable!(),
|
||||||
}
|
}
|
||||||
|
@ -771,6 +793,26 @@ mod tests {
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
|
fn assert_ok_radix<F>(s: &str, radix: u32, bits: F::Bits)
|
||||||
|
where
|
||||||
|
F: Fixed + FromStrRadix<Err = ParseFixedError>,
|
||||||
|
F::Bits: Eq + Debug,
|
||||||
|
{
|
||||||
|
match <F as FromStrRadix>::from_str_radix(s, radix) {
|
||||||
|
Ok(f) => assert_eq!(f.to_bits(), bits),
|
||||||
|
Err(e) => panic!("could not parse {}: {}", s, e),
|
||||||
|
}
|
||||||
|
}
|
||||||
|
fn assert_err_radix<F>(s: &str, radix: u32, kind: ParseErrorKind)
|
||||||
|
where
|
||||||
|
F: Fixed + FromStrRadix<Err = ParseFixedError>,
|
||||||
|
{
|
||||||
|
match <F as FromStrRadix>::from_str_radix(s, radix) {
|
||||||
|
Ok(f) => panic!("incorrectly parsed {} as {}", s, f),
|
||||||
|
Err(ParseFixedError { kind: err }) => assert_eq!(err, kind),
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
#[test]
|
#[test]
|
||||||
fn check_i8_u8_from_str() {
|
fn check_i8_u8_from_str() {
|
||||||
use crate::types::*;
|
use crate::types::*;
|
||||||
|
@ -888,6 +930,123 @@ mod tests {
|
||||||
assert_err::<U32F0>("4294967295.5", ParseErrorKind::Overflow);
|
assert_err::<U32F0>("4294967295.5", ParseErrorKind::Overflow);
|
||||||
}
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn check_i16_u16_from_str_binary() {
|
||||||
|
use crate::types::*;
|
||||||
|
|
||||||
|
assert_err_radix::<I0F16>("-1", 2, ParseErrorKind::Overflow);
|
||||||
|
assert_err_radix::<I0F16>("-0.100000000000000010", 2, ParseErrorKind::Overflow);
|
||||||
|
assert_ok_radix::<I0F16>("-0.100000000000000001", 2, -0x8000);
|
||||||
|
assert_ok_radix::<I0F16>("0.011111111111111101", 2, 0x7FFF);
|
||||||
|
assert_err_radix::<I0F16>("0.011111111111111110", 2, ParseErrorKind::Overflow);
|
||||||
|
assert_err_radix::<I0F16>("1", 2, ParseErrorKind::Overflow);
|
||||||
|
|
||||||
|
assert_err_radix::<I8F8>("-10000000.0000000010", 2, ParseErrorKind::Overflow);
|
||||||
|
assert_ok_radix::<I8F8>("-10000000.0000000001", 2, -0x8000);
|
||||||
|
assert_ok_radix::<I8F8>("1111111.1111111101", 2, 0x7FFF);
|
||||||
|
assert_err_radix::<I8F8>("1111111.1111111110", 2, ParseErrorKind::Overflow);
|
||||||
|
|
||||||
|
assert_err_radix::<I16F0>("-1000000000000000.10", 2, ParseErrorKind::Overflow);
|
||||||
|
assert_ok_radix::<I16F0>("-1000000000000000.01", 2, -0x8000);
|
||||||
|
assert_ok_radix::<I16F0>("111111111111111.01", 2, 0x7FFF);
|
||||||
|
assert_err_radix::<I16F0>("111111111111111.10", 2, ParseErrorKind::Overflow);
|
||||||
|
|
||||||
|
assert_err_radix::<U0F16>("-0", 2, ParseErrorKind::InvalidDigit);
|
||||||
|
assert_ok_radix::<U0F16>("0.011111111111111101", 2, 0x7FFF);
|
||||||
|
assert_ok_radix::<U0F16>("0.011111111111111110", 2, 0x8000);
|
||||||
|
assert_ok_radix::<U0F16>("0.111111111111111101", 2, 0xFFFF);
|
||||||
|
assert_err_radix::<U0F16>("0.111111111111111110", 2, ParseErrorKind::Overflow);
|
||||||
|
assert_err_radix::<U0F16>("1", 2, ParseErrorKind::Overflow);
|
||||||
|
|
||||||
|
assert_ok_radix::<U8F8>("1111111.1111111101", 2, 0x7FFF);
|
||||||
|
assert_ok_radix::<U8F8>("1111111.1111111110", 2, 0x8000);
|
||||||
|
assert_ok_radix::<U8F8>("11111111.1111111101", 2, 0xFFFF);
|
||||||
|
assert_err_radix::<U8F8>("11111111.1111111110", 2, ParseErrorKind::Overflow);
|
||||||
|
|
||||||
|
assert_ok_radix::<U16F0>("111111111111111.01", 2, 0x7FFF);
|
||||||
|
assert_ok_radix::<U16F0>("111111111111111.10", 2, 0x8000);
|
||||||
|
assert_ok_radix::<U16F0>("1111111111111111.01", 2, 0xFFFF);
|
||||||
|
assert_err_radix::<U16F0>("1111111111111111.10", 2, ParseErrorKind::Overflow);
|
||||||
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn check_i16_u16_from_str_octal() {
|
||||||
|
use crate::types::*;
|
||||||
|
|
||||||
|
assert_err_radix::<I0F16>("-1", 8, ParseErrorKind::Overflow);
|
||||||
|
assert_err_radix::<I0F16>("-0.400002", 8, ParseErrorKind::Overflow);
|
||||||
|
assert_ok_radix::<I0F16>("-0.400001", 8, -0x8000);
|
||||||
|
assert_ok_radix::<I0F16>("0.377775", 8, 0x7FFF);
|
||||||
|
assert_err_radix::<I0F16>("0.377776", 8, ParseErrorKind::Overflow);
|
||||||
|
assert_err_radix::<I0F16>("1", 8, ParseErrorKind::Overflow);
|
||||||
|
|
||||||
|
assert_err_radix::<I8F8>("-2000.0010", 8, ParseErrorKind::Overflow);
|
||||||
|
assert_ok_radix::<I8F8>("-200.0007", 8, -0x8000);
|
||||||
|
assert_ok_radix::<I8F8>("177.7767", 8, 0x7FFF);
|
||||||
|
assert_err_radix::<I8F8>("177.7770", 8, ParseErrorKind::Overflow);
|
||||||
|
|
||||||
|
assert_err_radix::<I16F0>("-100000.4", 8, ParseErrorKind::Overflow);
|
||||||
|
assert_ok_radix::<I16F0>("-100000.3", 8, -0x8000);
|
||||||
|
assert_ok_radix::<I16F0>("77777.3", 8, 0x7FFF);
|
||||||
|
assert_err_radix::<I16F0>("77777.4", 8, ParseErrorKind::Overflow);
|
||||||
|
|
||||||
|
assert_err_radix::<U0F16>("-0", 8, ParseErrorKind::InvalidDigit);
|
||||||
|
assert_ok_radix::<U0F16>("0.377775", 8, 0x7FFF);
|
||||||
|
assert_ok_radix::<U0F16>("0.377776", 8, 0x8000);
|
||||||
|
assert_ok_radix::<U0F16>("0.777775", 8, 0xFFFF);
|
||||||
|
assert_err_radix::<U0F16>("0.777776", 8, ParseErrorKind::Overflow);
|
||||||
|
assert_err_radix::<U0F16>("1", 8, ParseErrorKind::Overflow);
|
||||||
|
|
||||||
|
assert_ok_radix::<U8F8>("177.7767", 8, 0x7FFF);
|
||||||
|
assert_ok_radix::<U8F8>("177.7770", 8, 0x8000);
|
||||||
|
assert_ok_radix::<U8F8>("377.7767", 8, 0xFFFF);
|
||||||
|
assert_err_radix::<U8F8>("377.7770", 8, ParseErrorKind::Overflow);
|
||||||
|
|
||||||
|
assert_ok_radix::<U16F0>("77777.3", 8, 0x7FFF);
|
||||||
|
assert_ok_radix::<U16F0>("77777.4", 8, 0x8000);
|
||||||
|
assert_ok_radix::<U16F0>("177777.3", 8, 0xFFFF);
|
||||||
|
assert_err_radix::<U16F0>("177777.4", 8, ParseErrorKind::Overflow);
|
||||||
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn check_i16_u16_from_str_hex() {
|
||||||
|
use crate::types::*;
|
||||||
|
|
||||||
|
assert_err_radix::<I0F16>("-1", 16, ParseErrorKind::Overflow);
|
||||||
|
assert_err_radix::<I0F16>("-0.80008", 16, ParseErrorKind::Overflow);
|
||||||
|
assert_ok_radix::<I0F16>("-0.80007", 16, -0x8000);
|
||||||
|
assert_ok_radix::<I0F16>("0.7FFF7", 16, 0x7FFF);
|
||||||
|
assert_err_radix::<I0F16>("0.7FFF8", 16, ParseErrorKind::Overflow);
|
||||||
|
assert_err_radix::<I0F16>("1", 16, ParseErrorKind::Overflow);
|
||||||
|
|
||||||
|
assert_err_radix::<I8F8>("-80.008", 16, ParseErrorKind::Overflow);
|
||||||
|
assert_ok_radix::<I8F8>("-80.007", 16, -0x8000);
|
||||||
|
assert_ok_radix::<I8F8>("7F.FF7", 16, 0x7FFF);
|
||||||
|
assert_err_radix::<I8F8>("7F.FF8", 16, ParseErrorKind::Overflow);
|
||||||
|
|
||||||
|
assert_err_radix::<I16F0>("-8000.8", 16, ParseErrorKind::Overflow);
|
||||||
|
assert_ok_radix::<I16F0>("-8000.7", 16, -0x8000);
|
||||||
|
assert_ok_radix::<I16F0>("7FFF.7", 16, 0x7FFF);
|
||||||
|
assert_err_radix::<I16F0>("7FFF.8", 16, ParseErrorKind::Overflow);
|
||||||
|
|
||||||
|
assert_err_radix::<U0F16>("-0", 16, ParseErrorKind::InvalidDigit);
|
||||||
|
assert_ok_radix::<U0F16>("0.7FFF7", 16, 0x7FFF);
|
||||||
|
assert_ok_radix::<U0F16>("0.7FFF8", 16, 0x8000);
|
||||||
|
assert_ok_radix::<U0F16>("0.FFFF7", 16, 0xFFFF);
|
||||||
|
assert_err_radix::<U0F16>("0.FFFF8", 16, ParseErrorKind::Overflow);
|
||||||
|
assert_err_radix::<U0F16>("1", 16, ParseErrorKind::Overflow);
|
||||||
|
|
||||||
|
assert_ok_radix::<U8F8>("7F.FF7", 16, 0x7FFF);
|
||||||
|
assert_ok_radix::<U8F8>("7F.FF8", 16, 0x8000);
|
||||||
|
assert_ok_radix::<U8F8>("FF.FF7", 16, 0xFFFF);
|
||||||
|
assert_err_radix::<U8F8>("FF.FF8", 16, ParseErrorKind::Overflow);
|
||||||
|
|
||||||
|
assert_ok_radix::<U16F0>("7FFF.7", 16, 0x7FFF);
|
||||||
|
assert_ok_radix::<U16F0>("7FFF.8", 16, 0x8000);
|
||||||
|
assert_ok_radix::<U16F0>("FFFF.7", 16, 0xFFFF);
|
||||||
|
assert_err_radix::<U16F0>("FFFF.8", 16, ParseErrorKind::Overflow);
|
||||||
|
}
|
||||||
|
|
||||||
#[test]
|
#[test]
|
||||||
fn check_i64_u64_from_str() {
|
fn check_i64_u64_from_str() {
|
||||||
use crate::types::*;
|
use crate::types::*;
|
||||||
|
@ -1049,4 +1208,139 @@ mod tests {
|
||||||
ParseErrorKind::Overflow,
|
ParseErrorKind::Overflow,
|
||||||
);
|
);
|
||||||
}
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn check_i128_u128_from_str_hex() {
|
||||||
|
use crate::types::*;
|
||||||
|
|
||||||
|
assert_err_radix::<I0F128>("-1", 16, ParseErrorKind::Overflow);
|
||||||
|
assert_err_radix::<I0F128>(
|
||||||
|
"-0.800000000000000000000000000000008",
|
||||||
|
16,
|
||||||
|
ParseErrorKind::Overflow,
|
||||||
|
);
|
||||||
|
assert_ok_radix::<I0F128>(
|
||||||
|
"-0.800000000000000000000000000000007",
|
||||||
|
16,
|
||||||
|
-0x8000_0000_0000_0000_0000_0000_0000_0000,
|
||||||
|
);
|
||||||
|
assert_ok_radix::<I0F128>(
|
||||||
|
"0.7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF7",
|
||||||
|
16,
|
||||||
|
0x7FFF_FFFF_FFFF_FFFF_FFFF_FFFF_FFFF_FFFF,
|
||||||
|
);
|
||||||
|
assert_err_radix::<I0F128>(
|
||||||
|
"0.7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF8",
|
||||||
|
16,
|
||||||
|
ParseErrorKind::Overflow,
|
||||||
|
);
|
||||||
|
assert_err_radix::<I0F128>("1", 16, ParseErrorKind::Overflow);
|
||||||
|
|
||||||
|
assert_err_radix::<I64F64>(
|
||||||
|
"-8000000000000000.00000000000000008",
|
||||||
|
16,
|
||||||
|
ParseErrorKind::Overflow,
|
||||||
|
);
|
||||||
|
assert_ok_radix::<I64F64>(
|
||||||
|
"-8000000000000000.00000000000000007",
|
||||||
|
16,
|
||||||
|
-0x8000_0000_0000_0000_0000_0000_0000_0000,
|
||||||
|
);
|
||||||
|
assert_ok_radix::<I64F64>(
|
||||||
|
"7FFFFFFFFFFFFFFF.FFFFFFFFFFFFFFFF7",
|
||||||
|
16,
|
||||||
|
0x7FFF_FFFF_FFFF_FFFF_FFFF_FFFF_FFFF_FFFF,
|
||||||
|
);
|
||||||
|
assert_err_radix::<I64F64>(
|
||||||
|
"7FFFFFFFFFFFFFFF.FFFFFFFFFFFFFFFF8",
|
||||||
|
16,
|
||||||
|
ParseErrorKind::Overflow,
|
||||||
|
);
|
||||||
|
|
||||||
|
assert_err_radix::<I128F0>(
|
||||||
|
"-80000000000000000000000000000000.8",
|
||||||
|
16,
|
||||||
|
ParseErrorKind::Overflow,
|
||||||
|
);
|
||||||
|
assert_ok_radix::<I128F0>(
|
||||||
|
"-80000000000000000000000000000000.7",
|
||||||
|
16,
|
||||||
|
-0x8000_0000_0000_0000_0000_0000_0000_0000,
|
||||||
|
);
|
||||||
|
assert_ok_radix::<I128F0>(
|
||||||
|
"7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF.7",
|
||||||
|
16,
|
||||||
|
0x7FFF_FFFF_FFFF_FFFF_FFFF_FFFF_FFFF_FFFF,
|
||||||
|
);
|
||||||
|
assert_err_radix::<I128F0>(
|
||||||
|
"7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF.8",
|
||||||
|
16,
|
||||||
|
ParseErrorKind::Overflow,
|
||||||
|
);
|
||||||
|
|
||||||
|
assert_err_radix::<U0F128>("-0", 16, ParseErrorKind::InvalidDigit);
|
||||||
|
assert_ok_radix::<U0F128>(
|
||||||
|
"0.7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF7",
|
||||||
|
16,
|
||||||
|
0x7FFF_FFFF_FFFF_FFFF_FFFF_FFFF_FFFF_FFFF,
|
||||||
|
);
|
||||||
|
assert_ok_radix::<U0F128>(
|
||||||
|
"0.7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF8",
|
||||||
|
16,
|
||||||
|
0x8000_0000_0000_0000_0000_0000_0000_0000,
|
||||||
|
);
|
||||||
|
assert_ok_radix::<U0F128>(
|
||||||
|
"0.FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF7",
|
||||||
|
16,
|
||||||
|
0xFFFF_FFFF_FFFF_FFFF_FFFF_FFFF_FFFF_FFFF,
|
||||||
|
);
|
||||||
|
assert_err_radix::<U0F128>(
|
||||||
|
"0.FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF8",
|
||||||
|
16,
|
||||||
|
ParseErrorKind::Overflow,
|
||||||
|
);
|
||||||
|
assert_err_radix::<U0F128>("1", 16, ParseErrorKind::Overflow);
|
||||||
|
|
||||||
|
assert_ok_radix::<U64F64>(
|
||||||
|
"7FFFFFFFFFFFFFFF.FFFFFFFFFFFFFFFF7",
|
||||||
|
16,
|
||||||
|
0x7FFF_FFFF_FFFF_FFFF_FFFF_FFFF_FFFF_FFFF,
|
||||||
|
);
|
||||||
|
assert_ok_radix::<U64F64>(
|
||||||
|
"7FFFFFFFFFFFFFFF.FFFFFFFFFFFFFFFF8",
|
||||||
|
16,
|
||||||
|
0x8000_0000_0000_0000_0000_0000_0000_0000,
|
||||||
|
);
|
||||||
|
assert_ok_radix::<U64F64>(
|
||||||
|
"FFFFFFFFFFFFFFFF.FFFFFFFFFFFFFFFF7",
|
||||||
|
16,
|
||||||
|
0xFFFF_FFFF_FFFF_FFFF_FFFF_FFFF_FFFF_FFFF,
|
||||||
|
);
|
||||||
|
assert_err_radix::<U64F64>(
|
||||||
|
"FFFFFFFFFFFFFFFF.FFFFFFFFFFFFFFFF8",
|
||||||
|
16,
|
||||||
|
ParseErrorKind::Overflow,
|
||||||
|
);
|
||||||
|
|
||||||
|
assert_ok_radix::<U128F0>(
|
||||||
|
"7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF.7",
|
||||||
|
16,
|
||||||
|
0x7FFF_FFFF_FFFF_FFFF_FFFF_FFFF_FFFF_FFFF,
|
||||||
|
);
|
||||||
|
assert_ok_radix::<U128F0>(
|
||||||
|
"7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF.8",
|
||||||
|
16,
|
||||||
|
0x8000_0000_0000_0000_0000_0000_0000_0000,
|
||||||
|
);
|
||||||
|
assert_ok_radix::<U128F0>(
|
||||||
|
"FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF.7",
|
||||||
|
16,
|
||||||
|
0xFFFF_FFFF_FFFF_FFFF_FFFF_FFFF_FFFF_FFFF,
|
||||||
|
);
|
||||||
|
assert_err_radix::<U128F0>(
|
||||||
|
"FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF.8",
|
||||||
|
16,
|
||||||
|
ParseErrorKind::Overflow,
|
||||||
|
);
|
||||||
|
}
|
||||||
}
|
}
|
||||||
|
|
Loading…
Reference in New Issue