1238 lines
81 KiB
Rust
1238 lines
81 KiB
Rust
#[cfg(feature = "format")]
|
|
use core::num;
|
|
|
|
use lexical_parse_float::{FromLexical, FromLexicalWithOptions, Options};
|
|
use lexical_util::error::Error;
|
|
#[cfg(feature = "format")]
|
|
use lexical_util::format;
|
|
#[cfg(any(feature = "format", feature = "power-of-two"))]
|
|
use lexical_util::format::NumberFormatBuilder;
|
|
use lexical_util::format::STANDARD;
|
|
|
|
#[test]
|
|
fn special_bytes_test() {
|
|
const FORMAT: u128 = STANDARD;
|
|
|
|
// Test serializing and deserializing special strings.
|
|
assert!(f32::from_lexical(b"NaN").unwrap().is_nan());
|
|
assert!(f32::from_lexical(b"nan").unwrap().is_nan());
|
|
assert!(f32::from_lexical(b"NAN").unwrap().is_nan());
|
|
assert!(f32::from_lexical(b"inf").unwrap().is_infinite());
|
|
assert!(f32::from_lexical(b"INF").unwrap().is_infinite());
|
|
assert!(f32::from_lexical(b"Infinity").unwrap().is_infinite());
|
|
|
|
const OPTIONS: Options =
|
|
Options::builder().nan_string(Some(b"nan")).inf_string(Some(b"Infinity")).build_strict();
|
|
|
|
// The error message depends on whether the radix feature is enabled.
|
|
assert!(f32::from_lexical_with_options::<FORMAT>(b"inf", &OPTIONS).is_err());
|
|
assert!(f32::from_lexical_with_options::<FORMAT>(b"Infinity", &OPTIONS).unwrap().is_infinite());
|
|
}
|
|
|
|
#[test]
|
|
#[cfg(feature = "power-of-two")]
|
|
fn invalid_format_test() {
|
|
const FORMAT: u128 = NumberFormatBuilder::from_radix(40);
|
|
const OPTIONS: Options = Options::new();
|
|
let res = f32::from_lexical_with_options::<FORMAT>(b"inf", &OPTIONS);
|
|
assert!(res.is_err());
|
|
assert_eq!(res, Err(Error::InvalidMantissaRadix));
|
|
}
|
|
|
|
#[test]
|
|
#[cfg(all(feature = "power-of-two", feature = "format"))]
|
|
fn invalid_punctuation_test() {
|
|
const FORMAT: u128 = NumberFormatBuilder::new()
|
|
.digit_separator(num::NonZeroU8::new(b'h'))
|
|
.base_prefix(num::NonZeroU8::new(b'h'))
|
|
.integer_internal_digit_separator(true)
|
|
.build_unchecked();
|
|
const OPTIONS: Options = Options::new();
|
|
let res = f32::from_lexical_with_options::<FORMAT>(b"inf", &OPTIONS);
|
|
assert!(res.is_err());
|
|
assert_eq!(res, Err(Error::InvalidPunctuation));
|
|
}
|
|
|
|
#[test]
|
|
fn f32_decimal_test() {
|
|
// integer test
|
|
assert_eq!(0.0, f32::from_lexical(b"0").unwrap());
|
|
assert_eq!(1.0, f32::from_lexical(b"1").unwrap());
|
|
assert_eq!(12.0, f32::from_lexical(b"12").unwrap());
|
|
assert_eq!(123.0, f32::from_lexical(b"123").unwrap());
|
|
assert_eq!(1234.0, f32::from_lexical(b"1234").unwrap());
|
|
assert_eq!(12345.0, f32::from_lexical(b"12345").unwrap());
|
|
assert_eq!(123456.0, f32::from_lexical(b"123456").unwrap());
|
|
assert_eq!(1234567.0, f32::from_lexical(b"1234567").unwrap());
|
|
assert_eq!(12345678.0, f32::from_lexical(b"12345678").unwrap());
|
|
|
|
// No fraction after decimal point test
|
|
assert_eq!(1.0, f32::from_lexical(b"1.").unwrap());
|
|
assert_eq!(12.0, f32::from_lexical(b"12.").unwrap());
|
|
assert_eq!(1234567.0, f32::from_lexical(b"1234567.").unwrap());
|
|
|
|
// No integer before decimal point test
|
|
assert_eq!(0.1, f32::from_lexical(b".1").unwrap());
|
|
assert_eq!(0.12, f32::from_lexical(b".12").unwrap());
|
|
assert_eq!(0.1234567, f32::from_lexical(b".1234567").unwrap());
|
|
|
|
// decimal test
|
|
assert_eq!(123.1, f32::from_lexical(b"123.1").unwrap());
|
|
assert_eq!(123.12, f32::from_lexical(b"123.12").unwrap());
|
|
assert_eq!(123.123, f32::from_lexical(b"123.123").unwrap());
|
|
assert_eq!(123.1234, f32::from_lexical(b"123.1234").unwrap());
|
|
assert_eq!(123.12345, f32::from_lexical(b"123.12345").unwrap());
|
|
|
|
// rounding test
|
|
assert_eq!(123456790.0, f32::from_lexical(b"123456789").unwrap());
|
|
assert_eq!(123456790.0, f32::from_lexical(b"123456789.1").unwrap());
|
|
assert_eq!(123456790.0, f32::from_lexical(b"123456789.12").unwrap());
|
|
assert_eq!(123456790.0, f32::from_lexical(b"123456789.123").unwrap());
|
|
assert_eq!(123456790.0, f32::from_lexical(b"123456789.1234").unwrap());
|
|
assert_eq!(123456790.0, f32::from_lexical(b"123456789.12345").unwrap());
|
|
|
|
// exponent test
|
|
assert_eq!(123456789.12345, f32::from_lexical(b"1.2345678912345e8").unwrap());
|
|
assert_eq!(123450000.0, f32::from_lexical(b"1.2345e+8").unwrap());
|
|
assert_eq!(1.2345e+11, f32::from_lexical(b"1.2345e+11").unwrap());
|
|
assert_eq!(1.2345e+11, f32::from_lexical(b"123450000000").unwrap());
|
|
assert_eq!(1.2345e+38, f32::from_lexical(b"1.2345e+38").unwrap());
|
|
assert_eq!(1.2345e+38, f32::from_lexical(b"123450000000000000000000000000000000000").unwrap());
|
|
assert_eq!(1.2345e-8, f32::from_lexical(b"1.2345e-8").unwrap());
|
|
assert_eq!(1.2345e-8, f32::from_lexical(b"0.000000012345").unwrap());
|
|
assert_eq!(1.2345e-38, f32::from_lexical(b"1.2345e-38").unwrap());
|
|
assert_eq!(
|
|
1.2345e-38,
|
|
f32::from_lexical(b"0.000000000000000000000000000000000000012345").unwrap()
|
|
);
|
|
|
|
assert!(f32::from_lexical(b"NaN").unwrap().is_nan());
|
|
assert!(f32::from_lexical(b"nan").unwrap().is_nan());
|
|
assert!(f32::from_lexical(b"NAN").unwrap().is_nan());
|
|
assert!(f32::from_lexical(b"inf").unwrap().is_infinite());
|
|
assert!(f32::from_lexical(b"INF").unwrap().is_infinite());
|
|
assert!(f32::from_lexical(b"+inf").unwrap().is_infinite());
|
|
assert!(f32::from_lexical(b"-inf").unwrap().is_infinite());
|
|
|
|
// Check various expected failures.
|
|
assert_eq!(Err(Error::Empty(0)), f32::from_lexical(b""));
|
|
assert_eq!(Err(Error::EmptyMantissa(0)), f32::from_lexical(b"e"));
|
|
assert_eq!(Err(Error::EmptyMantissa(0)), f32::from_lexical(b"E"));
|
|
assert_eq!(Err(Error::EmptyMantissa(1)), f32::from_lexical(b".e1"));
|
|
assert_eq!(Err(Error::EmptyMantissa(1)), f32::from_lexical(b".e-1"));
|
|
assert_eq!(Err(Error::EmptyMantissa(0)), f32::from_lexical(b"e1"));
|
|
assert_eq!(Err(Error::EmptyMantissa(0)), f32::from_lexical(b"e-1"));
|
|
assert_eq!(Err(Error::Empty(1)), f32::from_lexical(b"+"));
|
|
assert_eq!(Err(Error::Empty(1)), f32::from_lexical(b"-"));
|
|
|
|
// Bug fix for Issue #8
|
|
assert_eq!(Ok(5.002868148396374), f32::from_lexical(b"5.002868148396374"));
|
|
|
|
// Other bug fixes
|
|
assert_eq!(Ok(7.2625224e+37), f32::from_lexical(b"72625224000000000000000000000000000000"));
|
|
assert_eq!(Ok(7.2625224e+37), f32::from_lexical(b"72625224000000000000000000000000000000.0"));
|
|
assert_eq!(Ok(-7.2625224e+37), f32::from_lexical(b"-72625224000000000000000000000000000000"));
|
|
assert_eq!(Ok(-7.2625224e+37), f32::from_lexical(b"-72625224000000000000000000000000000000.0"));
|
|
}
|
|
|
|
#[test]
|
|
#[cfg(feature = "radix")]
|
|
fn f32_radix_test() {
|
|
const BASE36: u128 = NumberFormatBuilder::from_radix(36);
|
|
const CUSTOM: Options = Options::builder().exponent(b'^').build_strict();
|
|
assert_eq!(1234.0, f32::from_lexical_with_options::<BASE36>(b"YA", &CUSTOM).unwrap());
|
|
const OPTIONS: Options = CUSTOM.rebuild().lossy(true).build_strict();
|
|
assert_eq!(1234.0, f32::from_lexical_with_options::<BASE36>(b"YA", &OPTIONS).unwrap());
|
|
|
|
const BASE21: u128 = NumberFormatBuilder::from_radix(21);
|
|
assert_eq!(
|
|
2879628700000000000000000.0,
|
|
f32::from_lexical_with_options::<BASE21>(b"4.BHJ97^I", &OPTIONS).unwrap()
|
|
);
|
|
assert_eq!(
|
|
48205230000000000000000000000000000000.0,
|
|
f32::from_lexical_with_options::<BASE21>(b"4.C4407^17", &OPTIONS).unwrap()
|
|
);
|
|
assert_eq!(
|
|
105861930000000000000000000000000000000.0,
|
|
f32::from_lexical_with_options::<BASE21>(b"A.15A^17", &OPTIONS).unwrap()
|
|
);
|
|
assert_eq!(
|
|
63900540000000000000000000000000000000.0,
|
|
f32::from_lexical_with_options::<BASE21>(b"6.1AK^17", &OPTIONS).unwrap()
|
|
);
|
|
assert_eq!(
|
|
48205210000000000000000000000000000000.0,
|
|
f32::from_lexical_with_options::<BASE21>(b"4.C44^17", &OPTIONS).unwrap()
|
|
);
|
|
assert_eq!(
|
|
48205230000000000000000000000000000000.0,
|
|
f32::from_lexical_with_options::<BASE21>(b"4C440700000000000000000000000.0", &OPTIONS)
|
|
.unwrap()
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn parse_f32_test() {
|
|
let parse = move |x| f32::from_lexical_partial(x);
|
|
|
|
assert_eq!(Ok((0.0, 1)), parse(b"0"));
|
|
assert_eq!(Ok((1.2345, 6)), parse(b"1.2345"));
|
|
assert_eq!(Ok((12.345, 6)), parse(b"12.345"));
|
|
assert_eq!(Ok((12345.6789, 10)), parse(b"12345.6789"));
|
|
assert_eq!(Ok((1.2345e10, 9)), parse(b"1.2345e10"));
|
|
assert_eq!(Ok((1.2345e-38, 10)), parse(b"1.2345e-38"));
|
|
|
|
// Check expected rounding, using borderline cases.
|
|
// Round-down, halfway
|
|
assert_eq!(Ok((16777216.0, 8)), parse(b"16777216"));
|
|
assert_eq!(Ok((16777216.0, 8)), parse(b"16777217"));
|
|
assert_eq!(Ok((16777218.0, 8)), parse(b"16777218"));
|
|
assert_eq!(Ok((33554432.0, 8)), parse(b"33554432"));
|
|
assert_eq!(Ok((33554432.0, 8)), parse(b"33554434"));
|
|
assert_eq!(Ok((33554436.0, 8)), parse(b"33554436"));
|
|
assert_eq!(Ok((17179869184.0, 11)), parse(b"17179869184"));
|
|
assert_eq!(Ok((17179869184.0, 11)), parse(b"17179870208"));
|
|
assert_eq!(Ok((17179871232.0, 11)), parse(b"17179871232"));
|
|
|
|
// Round-up, halfway
|
|
assert_eq!(Ok((16777218.0, 8)), parse(b"16777218"));
|
|
assert_eq!(Ok((16777220.0, 8)), parse(b"16777219"));
|
|
assert_eq!(Ok((16777220.0, 8)), parse(b"16777220"));
|
|
assert_eq!(Ok((33554436.0, 8)), parse(b"33554436"));
|
|
assert_eq!(Ok((33554440.0, 8)), parse(b"33554438"));
|
|
assert_eq!(Ok((33554440.0, 8)), parse(b"33554440"));
|
|
assert_eq!(Ok((17179871232.0, 11)), parse(b"17179871232"));
|
|
assert_eq!(Ok((17179873280.0, 11)), parse(b"17179872256"));
|
|
assert_eq!(Ok((17179873280.0, 11)), parse(b"17179873280"));
|
|
|
|
// Round-up, above halfway
|
|
assert_eq!(Ok((33554436.0, 8)), parse(b"33554435"));
|
|
assert_eq!(Ok((17179871232.0, 11)), parse(b"17179870209"));
|
|
|
|
// Check exactly halfway, round-up at halfway
|
|
assert_eq!(Ok((1.0000001, 28)), parse(b"1.00000017881393432617187499"));
|
|
assert_eq!(Ok((1.0000002, 26)), parse(b"1.000000178813934326171875"));
|
|
assert_eq!(Ok((1.0000002, 28)), parse(b"1.00000017881393432617187501"));
|
|
|
|
// Invalid or partially-parsed
|
|
assert_eq!(Err(Error::EmptyMantissa(0)), parse(b"e10"));
|
|
assert_eq!(Err(Error::EmptyMantissa(1)), parse(b"."));
|
|
assert_eq!(Err(Error::EmptyMantissa(1)), parse(b".e10"));
|
|
assert_eq!(Err(Error::EmptyExponent(2)), parse(b"0e"));
|
|
assert_eq!(Ok((1.23, 4)), parse(b"1.23/"));
|
|
|
|
// Errors identified via test-parse-random.
|
|
assert_eq!(Ok((0.0, 21)), parse(b"1.565385248817619e-82"));
|
|
assert_eq!(Ok((5.483634359675252e34, 20)), parse(b"5.483634359675252e34"));
|
|
|
|
// Test a case from fast_float basictest.
|
|
assert_eq!(Ok((1.1754941e-38, 1118)), parse(b"1.17549414062751785924617589866280818433124586473279624003138594271817467598606476997247227700427174568176269531250000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-38"));
|
|
assert_eq!(Ok((f32::INFINITY, 6)), parse(b"1e1000"));
|
|
|
|
// Errors identified via test-parse-golang.
|
|
assert_eq!(Ok((0, 25)), parse(b"1.00000000001e-2147483638").map(|(x, y)| (x.to_bits(), y)));
|
|
}
|
|
|
|
#[test]
|
|
fn parse_f64_test() {
|
|
let parse = move |x| f64::from_lexical_partial(x);
|
|
|
|
#[cfg(feature = "power-of-two")]
|
|
let parse_binary = move |x| {
|
|
const BINARY: u128 = NumberFormatBuilder::from_radix(2);
|
|
const OPTIONS: Options = Options::builder().exponent(b'^').build_strict();
|
|
f64::from_lexical_partial_with_options::<BINARY>(x, &OPTIONS)
|
|
};
|
|
|
|
assert_eq!(Ok((0.0, 1)), parse(b"0"));
|
|
assert_eq!(Ok((1.2345, 6)), parse(b"1.2345"));
|
|
assert_eq!(Ok((12.345, 6)), parse(b"12.345"));
|
|
assert_eq!(Ok((12345.6789, 10)), parse(b"12345.6789"));
|
|
assert_eq!(Ok((1.2345e10, 9)), parse(b"1.2345e10"));
|
|
assert_eq!(Ok((1e-323, 6)), parse(b"1e-323"));
|
|
assert_eq!(Ok((1.2345e-308, 11)), parse(b"1.2345e-308"));
|
|
|
|
// Check expected rounding, using borderline cases.
|
|
// Round-down, halfway
|
|
assert_eq!(Ok((9007199254740992.0, 16)), parse(b"9007199254740992"));
|
|
assert_eq!(Ok((9007199254740992.0, 16)), parse(b"9007199254740993"));
|
|
assert_eq!(Ok((9007199254740994.0, 16)), parse(b"9007199254740994"));
|
|
assert_eq!(Ok((18014398509481984.0, 17)), parse(b"18014398509481984"));
|
|
assert_eq!(Ok((18014398509481984.0, 17)), parse(b"18014398509481986"));
|
|
assert_eq!(Ok((18014398509481988.0, 17)), parse(b"18014398509481988"));
|
|
assert_eq!(Ok((9223372036854775808.0, 19)), parse(b"9223372036854775808"));
|
|
assert_eq!(Ok((9223372036854775808.0, 19)), parse(b"9223372036854776832"));
|
|
assert_eq!(Ok((9223372036854777856.0, 19)), parse(b"9223372036854777856"));
|
|
assert_eq!(
|
|
Ok((11417981541647679048466287755595961091061972992.0, 47)),
|
|
parse(b"11417981541647679048466287755595961091061972992")
|
|
);
|
|
assert_eq!(
|
|
Ok((11417981541647679048466287755595961091061972992.0, 47)),
|
|
parse(b"11417981541647680316116887983825362587765178368")
|
|
);
|
|
assert_eq!(
|
|
Ok((11417981541647681583767488212054764084468383744.0, 47)),
|
|
parse(b"11417981541647681583767488212054764084468383744")
|
|
);
|
|
|
|
// Round-up, halfway
|
|
assert_eq!(Ok((9007199254740994.0, 16)), parse(b"9007199254740994"));
|
|
assert_eq!(Ok((9007199254740996.0, 16)), parse(b"9007199254740995"));
|
|
assert_eq!(Ok((9007199254740996.0, 16)), parse(b"9007199254740996"));
|
|
assert_eq!(Ok((18014398509481988.0, 17)), parse(b"18014398509481988"));
|
|
assert_eq!(Ok((18014398509481992.0, 17)), parse(b"18014398509481990"));
|
|
assert_eq!(Ok((18014398509481992.0, 17)), parse(b"18014398509481992"));
|
|
assert_eq!(Ok((9223372036854777856.0, 19)), parse(b"9223372036854777856"));
|
|
assert_eq!(Ok((9223372036854779904.0, 19)), parse(b"9223372036854778880"));
|
|
assert_eq!(Ok((9223372036854779904.0, 19)), parse(b"9223372036854779904"));
|
|
assert_eq!(
|
|
Ok((11417981541647681583767488212054764084468383744.0, 47)),
|
|
parse(b"11417981541647681583767488212054764084468383744")
|
|
);
|
|
assert_eq!(
|
|
Ok((11417981541647684119068688668513567077874794496.0, 47)),
|
|
parse(b"11417981541647682851418088440284165581171589120")
|
|
);
|
|
assert_eq!(
|
|
Ok((11417981541647684119068688668513567077874794496.0, 47)),
|
|
parse(b"11417981541647684119068688668513567077874794496")
|
|
);
|
|
|
|
// Round-up, above halfway
|
|
assert_eq!(Ok((9223372036854777856.0, 19)), parse(b"9223372036854776833"));
|
|
assert_eq!(
|
|
Ok((11417981541647681583767488212054764084468383744.0, 47)),
|
|
parse(b"11417981541647680316116887983825362587765178369")
|
|
);
|
|
|
|
// Rounding error
|
|
// Adapted from failures in strtod.
|
|
assert_eq!(Ok((2.2250738585072014e-308, 23)), parse(b"2.2250738585072014e-308"));
|
|
assert_eq!(Ok((2.225073858507201e-308, 776)), parse(b"2.2250738585072011360574097967091319759348195463516456480234261097248222220210769455165295239081350879141491589130396211068700864386945946455276572074078206217433799881410632673292535522868813721490129811224514518898490572223072852551331557550159143974763979834118019993239625482890171070818506906306666559949382757725720157630626906633326475653000092458883164330377797918696120494973903778297049050510806099407302629371289589500035837999672072543043602840788957717961509455167482434710307026091446215722898802581825451803257070188608721131280795122334262883686223215037756666225039825343359745688844239002654981983854879482922068947216898310996983658468140228542433306603398508864458040010349339704275671864433837704860378616227717385456230658746790140867233276367187499e-308"));
|
|
assert_eq!(Ok((2.2250738585072014e-308, 774)), parse(b"2.22507385850720113605740979670913197593481954635164564802342610972482222202107694551652952390813508791414915891303962110687008643869459464552765720740782062174337998814106326732925355228688137214901298112245145188984905722230728525513315575501591439747639798341180199932396254828901710708185069063066665599493827577257201576306269066333264756530000924588831643303777979186961204949739037782970490505108060994073026293712895895000358379996720725430436028407889577179615094551674824347103070260914462157228988025818254518032570701886087211312807951223342628836862232150377566662250398253433597456888442390026549819838548794829220689472168983109969836584681402285424333066033985088644580400103493397042756718644338377048603786162277173854562306587467901408672332763671875e-308"));
|
|
assert_eq!(Ok((2.2250738585072014e-308, 776)), parse(b"2.2250738585072011360574097967091319759348195463516456480234261097248222220210769455165295239081350879141491589130396211068700864386945946455276572074078206217433799881410632673292535522868813721490129811224514518898490572223072852551331557550159143974763979834118019993239625482890171070818506906306666559949382757725720157630626906633326475653000092458883164330377797918696120494973903778297049050510806099407302629371289589500035837999672072543043602840788957717961509455167482434710307026091446215722898802581825451803257070188608721131280795122334262883686223215037756666225039825343359745688844239002654981983854879482922068947216898310996983658468140228542433306603398508864458040010349339704275671864433837704860378616227717385456230658746790140867233276367187501e-308"));
|
|
assert_eq!(Ok((1.7976931348623157e+308, 380)), parse(b"179769313486231580793728971405303415079934132710037826936173778980444968292764750946649017977587207096330286416692887910946555547851940402630657488671505820681908902000708383676273854845817711531764475730270069855571366959622842914819860834936475292719074168444365510704342711559699508093042880177904174497791.9999999999999999999999999999999999999999999999999999999999999999999999"));
|
|
assert_eq!(Ok((5e-324, 761)), parse(b"7.4109846876186981626485318930233205854758970392148714663837852375101326090531312779794975454245398856969484704316857659638998506553390969459816219401617281718945106978546710679176872575177347315553307795408549809608457500958111373034747658096871009590975442271004757307809711118935784838675653998783503015228055934046593739791790738723868299395818481660169122019456499931289798411362062484498678713572180352209017023903285791732520220528974020802906854021606612375549983402671300035812486479041385743401875520901590172592547146296175134159774938718574737870961645638908718119841271673056017045493004705269590165763776884908267986972573366521765567941072508764337560846003984904972149117463085539556354188641513168478436313080237596295773983001708984374999e-324"));
|
|
assert_eq!(Ok((1e-323, 758)), parse(b"7.4109846876186981626485318930233205854758970392148714663837852375101326090531312779794975454245398856969484704316857659638998506553390969459816219401617281718945106978546710679176872575177347315553307795408549809608457500958111373034747658096871009590975442271004757307809711118935784838675653998783503015228055934046593739791790738723868299395818481660169122019456499931289798411362062484498678713572180352209017023903285791732520220528974020802906854021606612375549983402671300035812486479041385743401875520901590172592547146296175134159774938718574737870961645638908718119841271673056017045493004705269590165763776884908267986972573366521765567941072508764337560846003984904972149117463085539556354188641513168478436313080237596295773983001708984375e-324"));
|
|
assert_eq!(Ok((1e-323, 761)), parse(b"7.4109846876186981626485318930233205854758970392148714663837852375101326090531312779794975454245398856969484704316857659638998506553390969459816219401617281718945106978546710679176872575177347315553307795408549809608457500958111373034747658096871009590975442271004757307809711118935784838675653998783503015228055934046593739791790738723868299395818481660169122019456499931289798411362062484498678713572180352209017023903285791732520220528974020802906854021606612375549983402671300035812486479041385743401875520901590172592547146296175134159774938718574737870961645638908718119841271673056017045493004705269590165763776884908267986972573366521765567941072508764337560846003984904972149117463085539556354188641513168478436313080237596295773983001708984375001e-324"));
|
|
assert_eq!(Ok((1e-320, 6)), parse(b"1e-320"));
|
|
// Highest denormal float.
|
|
assert_eq!(Ok((2.2250738585072009e-308, 23)), parse(b"2.2250738585072009e-308"));
|
|
|
|
// Rounding error
|
|
// Adapted from:
|
|
// https://www.exploringbinary.com/glibc-strtod-incorrectly-converts-2-to-the-negative-1075/
|
|
#[cfg(feature = "power-of-two")]
|
|
assert_eq!(Ok((5e-324, 14)), parse_binary(b"1^-10000110010"));
|
|
|
|
#[cfg(feature = "power-of-two")]
|
|
assert_eq!(Ok((0.0, 14)), parse_binary(b"1^-10000110011"));
|
|
assert_eq!(Ok((0.0, 1077)), parse(b"0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000024703282292062327208828439643411068618252990130716238221279284125033775363510437593264991818081799618989828234772285886546332835517796989819938739800539093906315035659515570226392290858392449105184435931802849936536152500319370457678249219365623669863658480757001585769269903706311928279558551332927834338409351978015531246597263579574622766465272827220056374006485499977096599470454020828166226237857393450736339007967761930577506740176324673600968951340535537458516661134223766678604162159680461914467291840300530057530849048765391711386591646239524912623653881879636239373280423891018672348497668235089863388587925628302755995657524455507255189313690836254779186948667994968324049705821028513185451396213837722826145437693412532098591327667236328125"));
|
|
assert_eq!(Ok((5e-324, 1081)), parse(b"0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000247032822920623272088284396434110686182529901307162382212792841250337753635104375932649918180817996189898282347722858865463328355177969898199387398005390939063150356595155702263922908583924491051844359318028499365361525003193704576782492193656236698636584807570015857692699037063119282795585513329278343384093519780155312465972635795746227664652728272200563740064854999770965994704540208281662262378573934507363390079677619305775067401763246736009689513405355374585166611342237666786041621596804619144672918403005300575308490487653917113865916462395249126236538818796362393732804238910186723484976682350898633885879256283027559956575244555072551893136908362547791869486679949683240497058210285131854513962138377228261454376934125320985913276672363281250001"));
|
|
assert_eq!(Ok((5e-324, 1078)), parse(b"0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000247032822920623272088284396434110686182529901307162382212792841250337753635104375932649918180817996189898282347722858865463328355177969898199387398005390939063150356595155702263922908583924491051844359318028499365361525003193704576782492193656236698636584807570015857692699037063119282795585513329278343384093519780155312465972635795746227664652728272200563740064854999770965994704540208281662262378573934507363390079677619305775067401763246736009689513405355374585166611342237666786041621596804619144672918403005300575308490487653917113865916462395249126236538818796362393732804238910186723484976682350898633885879256283027559956575244555072551893136908362547791869486679949683240497058210285131854513962138377228261454376934125320985913276672363281251"));
|
|
|
|
// Check with trailing zeros too, before the max number.
|
|
assert_eq!(Ok((0.0, 1024)), parse(b"0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000247032822920623272088284396434110686182529901307162382212792841250337753635104375932649918180817996189898282347722858865463328355177969898199387398005390939063150356595155702263922908583924491051844359318028499365361525003193704576782492193656236698636584807570015857692699037063119282795585513329278343384093519780155312465972635795746227664652728272200563740064854999770965994704540208281662262378573934507363390079677619305775067401763246736009689513405355374585166611342237666786041621596804619144672918403005300575308490487653917113865916462395249126236538818796362393732804238910186723484976682350898633885879256283027559956575244555072551893136908362547791869486679949683240497058210200000000"));
|
|
assert_eq!(Ok((5e-324, 1024)), parse(b"0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000247032822920623272088284396434110686182529901307162382212792841250337753635104375932649918180817996189898282347722858865463328355177969898199387398005390939063150356595155702263922908583924491051844359318028499365361525003193704576782492193656236698636584807570015857692699037063119282795585513329278343384093519780155312465972635795746227664652728272200563740064854999770965994704540208281662262378573934507363390079677619305775067401763246736009689513405355374585166611342237666786041621596804619144672918403005300575308490487653917113865916462395249126236538818796362393732804238910186723484976682350898633885879256283027559956575244555072551893136908362547791869486679949683240497058210300000000"));
|
|
assert_eq!(Ok((5e-324, 1024)), parse(b"0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000247032822920623272088284396434110686182529901307162382212792841250337753635104375932649918180817996189898282347722858865463328355177969898199387398005390939063150356595155702263922908583924491051844359318028499365361525003193704576782492193656236698636584807570015857692699037063119282795585513329278343384093519780155312465972635795746227664652728272200563740064854999770965994704540208281662262378573934507363390079677619305775067401763246736009689513405355374585166611342237666786041621596804619144672918403005300575308490487653917113865916462395249126236538818796362393732804238910186723484976682350898633885879256283027559956575244555072551893136908362547791869486679949683240497058210310000000"));
|
|
assert_eq!(Ok((0.0, 705)), parse(b"2.47032822920623272088284396434110686182529901307162382212792841250337753635104375932649918180817996189898282347722858865463328355177969898199387398005390939063150356595155702263922908583924491051844359318028499365361525003193704576782492193656236698636584807570015857692699037063119282795585513329278343384093519780155312465972635795746227664652728272200563740064854999770965994704540208281662262378573934507363390079677619305775067401763246736009689513405355374585166611342237666786041621596804619144672918403005300575308490487653917113865916462395249126236538818796362393732804238910186723484976682350898633885879256283027559956575244555072551893136908362547791869486679949683240497058210200000000e-324"));
|
|
assert_eq!(Ok((5e-324, 705)), parse(b"2.47032822920623272088284396434110686182529901307162382212792841250337753635104375932649918180817996189898282347722858865463328355177969898199387398005390939063150356595155702263922908583924491051844359318028499365361525003193704576782492193656236698636584807570015857692699037063119282795585513329278343384093519780155312465972635795746227664652728272200563740064854999770965994704540208281662262378573934507363390079677619305775067401763246736009689513405355374585166611342237666786041621596804619144672918403005300575308490487653917113865916462395249126236538818796362393732804238910186723484976682350898633885879256283027559956575244555072551893136908362547791869486679949683240497058210300000000e-324"));
|
|
assert_eq!(Ok((5e-324, 705)), parse(b"2.47032822920623272088284396434110686182529901307162382212792841250337753635104375932649918180817996189898282347722858865463328355177969898199387398005390939063150356595155702263922908583924491051844359318028499365361525003193704576782492193656236698636584807570015857692699037063119282795585513329278343384093519780155312465972635795746227664652728272200563740064854999770965994704540208281662262378573934507363390079677619305775067401763246736009689513405355374585166611342237666786041621596804619144672918403005300575308490487653917113865916462395249126236538818796362393732804238910186723484976682350898633885879256283027559956575244555072551893136908362547791869486679949683240497058210310000000e-324"));
|
|
|
|
// Rounding error
|
|
// Adapted from:
|
|
// https://www.exploringbinary.com/how-glibc-strtod-works/
|
|
assert_eq!(Ok((2.2250738585072011e-308, 1076)), parse(b"0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072008890245868760858598876504231122409594654935248025624400092282356951787758888037591552642309780950434312085877387158357291821993020294379224223559819827501242041788969571311791082261043971979604000454897391938079198936081525613113376149842043271751033627391549782731594143828136275113838604094249464942286316695429105080201815926642134996606517803095075913058719846423906068637102005108723282784678843631944515866135041223479014792369585208321597621066375401613736583044193603714778355306682834535634005074073040135602968046375918583163124224521599262546494300836851861719422417646455137135420132217031370496583210154654068035397417906022589503023501937519773030945763173210852507299305089761582519159720757232455434770912461317493580281734466552734375"));
|
|
|
|
// Rounding error
|
|
// Adapted from test-parse-random failures.
|
|
assert_eq!(Ok((1.009e-28, 8)), parse(b"1009e-31"));
|
|
assert_eq!(Ok((f64::INFINITY, 9)), parse(b"18294e304"));
|
|
|
|
// Rounding error
|
|
// Adapted from a @dangrabcad's issue #20.
|
|
assert_eq!(Ok((7.689539722041643e164, 21)), parse(b"7.689539722041643e164"));
|
|
assert_eq!(Ok((7.689539722041643e164, 165)), parse(b"768953972204164300000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"));
|
|
assert_eq!(Ok((7.689539722041643e164, 167)), parse(b"768953972204164300000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0"));
|
|
|
|
// Check other cases similar to @dangrabcad's issue #20.
|
|
assert_eq!(Ok((9223372036854777856.0, 21)), parse(b"9223372036854776833.0"));
|
|
assert_eq!(
|
|
Ok((11417981541647681583767488212054764084468383744.0, 49)),
|
|
parse(b"11417981541647680316116887983825362587765178369.0")
|
|
);
|
|
assert_eq!(Ok((9007199254740996.0, 18)), parse(b"9007199254740995.0"));
|
|
assert_eq!(Ok((18014398509481992.0, 19)), parse(b"18014398509481990.0"));
|
|
assert_eq!(Ok((9223372036854779904.0, 21)), parse(b"9223372036854778880.0"));
|
|
assert_eq!(
|
|
Ok((11417981541647684119068688668513567077874794496.0, 49)),
|
|
parse(b"11417981541647682851418088440284165581171589120.0")
|
|
);
|
|
|
|
// Check other cases ostensibly identified via proptest.
|
|
assert_eq!(Ok((71610528364411830000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0, 310)), parse(b"71610528364411830000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0"));
|
|
assert_eq!(Ok((126769393745745060000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0, 311)), parse(b"126769393745745060000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0"));
|
|
assert_eq!(Ok((38652960461239320000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0, 310)), parse(b"38652960461239320000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0"));
|
|
|
|
// Round-trip for base2.
|
|
#[cfg(feature = "power-of-two")]
|
|
{
|
|
assert_eq!(
|
|
Ok((f64::from_bits(0x3bcd261840000000), 33)),
|
|
parse_binary(b"1.1101001001100001100001^-1000011")
|
|
);
|
|
}
|
|
|
|
// Check other bugs in Golang.
|
|
assert_eq!(Ok((1.0905441441816094e+30, 31)), parse(b"1090544144181609348835077142190"));
|
|
|
|
// Errors identified via test-parse-random.
|
|
assert_eq!(Ok((-7.014172639932773e-283, 23)), parse(b"-7.014172639932773e-283"));
|
|
assert_eq!(Ok((1.565385248817619e-82, 21)), parse(b"1.565385248817619e-82"));
|
|
|
|
// Errors identified in fast_float
|
|
assert_eq!(Ok((1.0905441441816094e+30, 31)), parse(b"1090544144181609348835077142190"));
|
|
assert_eq!(Ok((f64::INFINITY, 6)), parse(b"1e1000"));
|
|
assert_eq!(
|
|
Ok((-2.2400841322710136e+18, 57)),
|
|
parse(b"-2240084132271013504.131248280843119943687942846658579428")
|
|
);
|
|
|
|
// Errors identified via test-parse-golang.
|
|
assert_eq!(Ok((0.0, 25)), parse(b"1.00000000001e-2147483638"));
|
|
assert_eq!(Ok((0, 25)), parse(b"1.00000000001e-2147483638").map(|(x, y)| (x.to_bits(), y)));
|
|
}
|
|
|
|
#[test]
|
|
fn f64_decimal_test() {
|
|
// integer test
|
|
assert_eq!(0.0, f64::from_lexical(b"0").unwrap());
|
|
assert_eq!(1.0, f64::from_lexical(b"1").unwrap());
|
|
assert_eq!(12.0, f64::from_lexical(b"12").unwrap());
|
|
assert_eq!(123.0, f64::from_lexical(b"123").unwrap());
|
|
assert_eq!(1234.0, f64::from_lexical(b"1234").unwrap());
|
|
assert_eq!(12345.0, f64::from_lexical(b"12345").unwrap());
|
|
assert_eq!(123456.0, f64::from_lexical(b"123456").unwrap());
|
|
assert_eq!(1234567.0, f64::from_lexical(b"1234567").unwrap());
|
|
assert_eq!(12345678.0, f64::from_lexical(b"12345678").unwrap());
|
|
|
|
// No fraction after decimal point test
|
|
assert_eq!(1.0, f64::from_lexical(b"1.").unwrap());
|
|
assert_eq!(12.0, f64::from_lexical(b"12.").unwrap());
|
|
assert_eq!(1234567.0, f64::from_lexical(b"1234567.").unwrap());
|
|
|
|
// No integer before decimal point test
|
|
assert_eq!(0.1, f64::from_lexical(b".1").unwrap());
|
|
assert_eq!(0.12, f64::from_lexical(b".12").unwrap());
|
|
assert_eq!(0.1234567, f64::from_lexical(b".1234567").unwrap());
|
|
|
|
// decimal test
|
|
assert_eq!(123456789.0, f64::from_lexical(b"123456789").unwrap());
|
|
assert_eq!(123456789.1, f64::from_lexical(b"123456789.1").unwrap());
|
|
assert_eq!(123456789.12, f64::from_lexical(b"123456789.12").unwrap());
|
|
assert_eq!(123456789.123, f64::from_lexical(b"123456789.123").unwrap());
|
|
assert_eq!(123456789.1234, f64::from_lexical(b"123456789.1234").unwrap());
|
|
assert_eq!(123456789.12345, f64::from_lexical(b"123456789.12345").unwrap());
|
|
assert_eq!(123456789.123456, f64::from_lexical(b"123456789.123456").unwrap());
|
|
assert_eq!(123456789.1234567, f64::from_lexical(b"123456789.1234567").unwrap());
|
|
assert_eq!(123456789.12345678, f64::from_lexical(b"123456789.12345678").unwrap());
|
|
|
|
// rounding test
|
|
assert_eq!(123456789.12345679, f64::from_lexical(b"123456789.123456789").unwrap());
|
|
assert_eq!(123456789.12345679, f64::from_lexical(b"123456789.1234567890").unwrap());
|
|
assert_eq!(123456789.12345679, f64::from_lexical(b"123456789.123456789012").unwrap());
|
|
assert_eq!(123456789.12345679, f64::from_lexical(b"123456789.1234567890123").unwrap());
|
|
assert_eq!(123456789.12345679, f64::from_lexical(b"123456789.12345678901234").unwrap());
|
|
|
|
// exponent test
|
|
assert_eq!(123456789.12345, f64::from_lexical(b"1.2345678912345e8").unwrap());
|
|
assert_eq!(123450000.0, f64::from_lexical(b"1.2345e+8").unwrap());
|
|
assert_eq!(1.2345e+11, f64::from_lexical(b"123450000000").unwrap());
|
|
assert_eq!(1.2345e+11, f64::from_lexical(b"1.2345e+11").unwrap());
|
|
assert_eq!(1.2345e+38, f64::from_lexical(b"1.2345e+38").unwrap());
|
|
assert_eq!(1.2345e+38, f64::from_lexical(b"123450000000000000000000000000000000000").unwrap());
|
|
assert_eq!(1.2345e+308, f64::from_lexical(b"1.2345e+308").unwrap());
|
|
assert_eq!(1.2345e+308, f64::from_lexical(b"123450000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000").unwrap());
|
|
assert_eq!(0.000000012345, f64::from_lexical(b"1.2345e-8").unwrap());
|
|
assert_eq!(1.2345e-8, f64::from_lexical(b"0.000000012345").unwrap());
|
|
assert_eq!(1.2345e-38, f64::from_lexical(b"1.2345e-38").unwrap());
|
|
assert_eq!(
|
|
1.2345e-38,
|
|
f64::from_lexical(b"0.000000000000000000000000000000000000012345").unwrap()
|
|
);
|
|
|
|
// denormalized (try extremely low values)
|
|
assert_eq!(1.2345e-308, f64::from_lexical(b"1.2345e-308").unwrap());
|
|
|
|
// due to issues in how the data is parsed, manually extracting
|
|
// non-exponents of 1.<e-299 is prone to error
|
|
// test the limit of our ability
|
|
// We tend to get relative errors of 1e-16, even at super low values.
|
|
assert_eq!(1.2345e-299, f64::from_lexical(b"0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000012345").unwrap());
|
|
|
|
// Keep pushing from -300 to -324
|
|
assert_eq!(1.2345e-300, f64::from_lexical(b"0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000012345").unwrap());
|
|
|
|
assert_eq!(1.2345e-310, f64::from_lexical(b"0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000012345").unwrap());
|
|
assert_eq!(1.2345e-320, f64::from_lexical(b"0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000012345").unwrap());
|
|
assert_eq!(1.2345e-321, f64::from_lexical(b"0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000012345").unwrap());
|
|
assert_eq!(1.24e-322, f64::from_lexical(b"0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000124").unwrap());
|
|
assert_eq!(Ok(1e-323), f64::from_lexical(b"0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001"));
|
|
assert_eq!(Ok(5e-324), f64::from_lexical(b"0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005"));
|
|
|
|
assert!(f64::from_lexical(b"NaN").unwrap().is_nan());
|
|
assert!(f64::from_lexical(b"nan").unwrap().is_nan());
|
|
assert!(f64::from_lexical(b"NAN").unwrap().is_nan());
|
|
assert!(f64::from_lexical(b"inf").unwrap().is_infinite());
|
|
assert!(f64::from_lexical(b"INF").unwrap().is_infinite());
|
|
assert!(f64::from_lexical(b"+inf").unwrap().is_infinite());
|
|
assert!(f64::from_lexical(b"-inf").unwrap().is_infinite());
|
|
|
|
// Check various expected failures.
|
|
assert_eq!(Err(Error::Empty(0)), f64::from_lexical(b""));
|
|
assert_eq!(Err(Error::EmptyMantissa(0)), f64::from_lexical(b"e"));
|
|
assert_eq!(Err(Error::EmptyMantissa(0)), f64::from_lexical(b"E"));
|
|
assert_eq!(Err(Error::EmptyMantissa(1)), f64::from_lexical(b".e1"));
|
|
assert_eq!(Err(Error::EmptyMantissa(1)), f64::from_lexical(b".e-1"));
|
|
assert_eq!(Err(Error::EmptyMantissa(0)), f64::from_lexical(b"e1"));
|
|
assert_eq!(Err(Error::EmptyMantissa(0)), f64::from_lexical(b"e-1"));
|
|
|
|
// Check various reports from a fuzzer.
|
|
assert_eq!(Err(Error::EmptyExponent(2)), f64::from_lexical(b"0e"));
|
|
assert_eq!(Err(Error::EmptyExponent(4)), f64::from_lexical(b"0.0e"));
|
|
assert_eq!(Err(Error::EmptyMantissa(1)), f64::from_lexical(b".E"));
|
|
assert_eq!(Err(Error::EmptyMantissa(1)), f64::from_lexical(b".e"));
|
|
assert_eq!(Err(Error::EmptyMantissa(0)), f64::from_lexical(b"E2252525225"));
|
|
assert_eq!(Err(Error::EmptyMantissa(0)), f64::from_lexical(b"e2252525225"));
|
|
assert_eq!(Ok(f64::INFINITY), f64::from_lexical(b"2E200000000000"));
|
|
|
|
// Add various unittests from proptests.
|
|
assert_eq!(Err(Error::EmptyExponent(2)), f64::from_lexical(b"0e"));
|
|
assert_eq!(Err(Error::EmptyMantissa(1)), f64::from_lexical(b"."));
|
|
assert_eq!(Err(Error::EmptyMantissa(2)), f64::from_lexical(b"+."));
|
|
assert_eq!(Err(Error::EmptyMantissa(2)), f64::from_lexical(b"-."));
|
|
assert_eq!(Err(Error::Empty(1)), f64::from_lexical(b"+"));
|
|
assert_eq!(Err(Error::Empty(1)), f64::from_lexical(b"-"));
|
|
|
|
// Bug fix for Issue #8
|
|
assert_eq!(Ok(5.002868148396374), f64::from_lexical(b"5.002868148396374"));
|
|
|
|
// Other bug fixes
|
|
assert_eq!(Ok(1.620515050981309e+308), f64::from_lexical(b"162051505098130900000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"));
|
|
assert_eq!(Ok(1.620515050981309e+308), f64::from_lexical(b"162051505098130900000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0"));
|
|
assert_eq!(Ok(-1.620515050981309e+308), f64::from_lexical(b"-162051505098130900000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"));
|
|
assert_eq!(Ok(-1.620515050981309e+308), f64::from_lexical(b"-162051505098130900000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0"));
|
|
}
|
|
|
|
#[test]
|
|
#[cfg(feature = "radix")]
|
|
fn f64_radix_test() {
|
|
const FORMAT: u128 = NumberFormatBuilder::from_radix(36);
|
|
const CUSTOM: Options = Options::builder().exponent(b'^').build_strict();
|
|
assert_eq!(1234.0, f64::from_lexical_with_options::<FORMAT>(b"YA", &CUSTOM).unwrap());
|
|
const OPTIONS: Options = CUSTOM.rebuild().lossy(true).build_strict();
|
|
assert_eq!(1234.0, f64::from_lexical_with_options::<FORMAT>(b"YA", &OPTIONS).unwrap());
|
|
}
|
|
|
|
#[test]
|
|
fn parse_f64_large_zeros_test() {
|
|
// Test numbers with a massive number of 0s in the integer component.
|
|
let parse = move |x| f64::from_lexical_partial(x);
|
|
assert_eq!(Ok((71610528364411830000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0, 308)), parse(b"71610528364411830000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"));
|
|
assert_eq!(Ok((126769393745745060000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0, 309)), parse(b"126769393745745060000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"));
|
|
assert_eq!(Ok((38652960461239320000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0, 308)), parse(b"38652960461239320000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"));
|
|
}
|
|
|
|
#[test]
|
|
#[cfg(feature = "power-of-two")]
|
|
fn parse_binary_f64_test() {
|
|
#[cfg(feature = "power-of-two")]
|
|
let parse_binary = move |x| {
|
|
const BINARY: u128 = NumberFormatBuilder::from_radix(2);
|
|
const OPTIONS: Options = Options::builder().exponent(b'^').build_strict();
|
|
f64::from_lexical_partial_with_options::<BINARY>(x, &OPTIONS)
|
|
};
|
|
|
|
// Test a wide variety of denormal floats here.
|
|
|
|
// Halfway, round-up.
|
|
assert_eq!(
|
|
Ok((2.2250738585072009e-308, 65)),
|
|
parse_binary(b"1111111111111111111111111111111111111111111111111111^-10000110010")
|
|
);
|
|
assert_eq!(
|
|
Ok((2.2250738585072014e-308, 66)),
|
|
parse_binary(b"10000000000000000000000000000000000000000000000000000^-10000110010")
|
|
);
|
|
assert_eq!(
|
|
Ok((2.2250738585072009e-308, 66)),
|
|
parse_binary(b"11111111111111111111111111111111111111111111111111110^-10000110011")
|
|
);
|
|
assert_eq!(
|
|
Ok((2.2250738585072014e-308, 66)),
|
|
parse_binary(b"11111111111111111111111111111111111111111111111111111^-10000110011")
|
|
);
|
|
|
|
// Halfway, round-down.
|
|
assert_eq!(
|
|
Ok((2.2250738585072004e-308, 65)),
|
|
parse_binary(b"1111111111111111111111111111111111111111111111111110^-10000110010")
|
|
);
|
|
assert_eq!(
|
|
Ok((2.2250738585072004e-308, 66)),
|
|
parse_binary(b"11111111111111111111111111111111111111111111111111101^-10000110011")
|
|
);
|
|
|
|
// Force the moderate path (round-up).
|
|
assert_eq!(
|
|
Ok((2.2250738585072009e-308, 70)),
|
|
parse_binary(b"111111111111111111111111111111111111111111111111111100000^-10000110111")
|
|
);
|
|
assert_eq!(
|
|
Ok((2.2250738585072009e-308, 70)),
|
|
parse_binary(b"111111111111111111111111111111111111111111111111111101000^-10000110111")
|
|
);
|
|
assert_eq!(
|
|
Ok((2.2250738585072009e-308, 70)),
|
|
parse_binary(b"111111111111111111111111111111111111111111111111111101111^-10000110111")
|
|
);
|
|
assert_eq!(
|
|
Ok((2.2250738585072014e-308, 70)),
|
|
parse_binary(b"111111111111111111111111111111111111111111111111111110000^-10000110111")
|
|
);
|
|
assert_eq!(
|
|
Ok((2.2250738585072014e-308, 70)),
|
|
parse_binary(b"111111111111111111111111111111111111111111111111111111111^-10000110111")
|
|
);
|
|
assert_eq!(
|
|
Ok((2.2250738585072014e-308, 70)),
|
|
parse_binary(b"100000000000000000000000000000000000000000000000000000000^-10000110110")
|
|
);
|
|
|
|
// Force the moderate path (round-down).
|
|
assert_eq!(
|
|
Ok((2.2250738585072004e-308, 70)),
|
|
parse_binary(b"111111111111111111111111111111111111111111111111111000000^-10000110111")
|
|
);
|
|
assert_eq!(
|
|
Ok((2.2250738585072004e-308, 70)),
|
|
parse_binary(b"111111111111111111111111111111111111111111111111111001000^-10000110111")
|
|
);
|
|
assert_eq!(
|
|
Ok((2.2250738585072004e-308, 70)),
|
|
parse_binary(b"111111111111111111111111111111111111111111111111111001111^-10000110111")
|
|
);
|
|
assert_eq!(
|
|
Ok((2.2250738585072004e-308, 70)),
|
|
parse_binary(b"111111111111111111111111111111111111111111111111111010000^-10000110111")
|
|
);
|
|
assert_eq!(
|
|
Ok((2.2250738585072009e-308, 70)),
|
|
parse_binary(b"111111111111111111111111111111111111111111111111111010001^-10000110111")
|
|
);
|
|
assert_eq!(
|
|
Ok((2.2250738585072009e-308, 70)),
|
|
parse_binary(b"111111111111111111111111111111111111111111111111111011111^-10000110111")
|
|
);
|
|
|
|
// Let's test comically long digits (round-up).
|
|
assert_eq!(Ok((2.225073858507201e-308, 170)), parse_binary(b"1111111111111111111111111111111111111111111111111111000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000^-10010011011"));
|
|
assert_eq!(Ok((2.225073858507201e-308, 170)), parse_binary(b"1111111111111111111111111111111111111111111111111111011111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111^-10010011011"));
|
|
assert_eq!(Ok((2.2250738585072014e-308, 170)), parse_binary(b"1111111111111111111111111111111111111111111111111111100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000^-10010011011"));
|
|
assert_eq!(Ok((2.2250738585072014e-308, 170)), parse_binary(b"1111111111111111111111111111111111111111111111111111111111111111111111000000000000000000000000000000000000000000000000000000000000000000000000000000000000000^-10010011011"));
|
|
}
|
|
|
|
#[test]
|
|
fn parse_f32_lossy_test() {
|
|
const FORMAT: u128 = STANDARD;
|
|
const OPTIONS: Options = Options::builder().lossy(true).build_strict();
|
|
let parse = move |x| f32::from_lexical_partial_with_options::<FORMAT>(x, &OPTIONS);
|
|
|
|
assert_eq!(Ok((1.2345, 6)), parse(b"1.2345"));
|
|
assert_eq!(Ok((12.345, 6)), parse(b"12.345"));
|
|
assert_eq!(Ok((12345.6789, 10)), parse(b"12345.6789"));
|
|
assert_eq!(Ok((1.2345e10, 9)), parse(b"1.2345e10"));
|
|
}
|
|
|
|
#[test]
|
|
fn parse_f64_lossy_test() {
|
|
const FORMAT: u128 = STANDARD;
|
|
const OPTIONS: Options = Options::builder().lossy(true).build_strict();
|
|
let parse = move |x| f64::from_lexical_partial_with_options::<FORMAT>(x, &OPTIONS);
|
|
|
|
assert_eq!(Ok((1.2345, 6)), parse(b"1.2345"));
|
|
assert_eq!(Ok((12.345, 6)), parse(b"12.345"));
|
|
assert_eq!(Ok((12345.6789, 10)), parse(b"12345.6789"));
|
|
assert_eq!(Ok((1.2345e10, 9)), parse(b"1.2345e10"));
|
|
}
|
|
|
|
#[test]
|
|
fn f32_lossy_decimal_test() {
|
|
const FORMAT: u128 = STANDARD;
|
|
|
|
const OPTIONS: Options = Options::builder().lossy(true).build_strict();
|
|
assert_eq!(
|
|
Err(Error::EmptyMantissa(1)),
|
|
f32::from_lexical_with_options::<FORMAT>(b".", &OPTIONS)
|
|
);
|
|
assert_eq!(Err(Error::Empty(0)), f32::from_lexical_with_options::<FORMAT>(b"", &OPTIONS));
|
|
assert_eq!(Ok(0.0), f32::from_lexical_with_options::<FORMAT>(b"0.0", &OPTIONS));
|
|
assert_eq!(
|
|
Err((Error::InvalidDigit(1)).into()),
|
|
f32::from_lexical_with_options::<FORMAT>(b"1a", &OPTIONS)
|
|
);
|
|
|
|
// Bug fix for Issue #8
|
|
assert_eq!(
|
|
Ok(5.002868148396374),
|
|
f32::from_lexical_with_options::<FORMAT>(b"5.002868148396374", &OPTIONS)
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn f64_lossy_decimal_test() {
|
|
const FORMAT: u128 = STANDARD;
|
|
|
|
const OPTIONS: Options = Options::builder().lossy(true).build_strict();
|
|
assert_eq!(
|
|
Err(Error::EmptyMantissa(1)),
|
|
f64::from_lexical_with_options::<FORMAT>(b".", &OPTIONS)
|
|
);
|
|
assert_eq!(Err(Error::Empty(0)), f64::from_lexical_with_options::<FORMAT>(b"", &OPTIONS));
|
|
assert_eq!(Ok(0.0), f64::from_lexical_with_options::<FORMAT>(b"0.0", &OPTIONS));
|
|
assert_eq!(
|
|
Err((Error::InvalidDigit(1)).into()),
|
|
f64::from_lexical_with_options::<FORMAT>(b"1a", &OPTIONS)
|
|
);
|
|
|
|
// Bug fix for Issue #8
|
|
assert_eq!(
|
|
Ok(5.002868148396374),
|
|
f64::from_lexical_with_options::<FORMAT>(b"5.002868148396374", &OPTIONS)
|
|
);
|
|
}
|
|
|
|
#[cfg(feature = "format")]
|
|
const fn rebuild(format: u128) -> NumberFormatBuilder {
|
|
NumberFormatBuilder::rebuild(format)
|
|
}
|
|
|
|
#[test]
|
|
#[cfg(feature = "format")]
|
|
fn f64_special_test() {
|
|
// Comments match (no_special, case_sensitive, has_sep)
|
|
const F1: u128 = STANDARD;
|
|
const F2: u128 = format::IGNORE;
|
|
const F3: u128 = rebuild(F1).no_special(true).build_strict();
|
|
const F4: u128 = rebuild(F1).case_sensitive_special(true).build_strict();
|
|
const F5: u128 = rebuild(F2).case_sensitive_special(true).build_strict();
|
|
|
|
const OPTIONS: Options = Options::new();
|
|
|
|
// Easy NaN
|
|
assert!(f64::from_lexical_with_options::<F1>(b"NaN", &OPTIONS).unwrap().is_nan());
|
|
assert!(f64::from_lexical_with_options::<F2>(b"NaN", &OPTIONS).unwrap().is_nan());
|
|
assert!(f64::from_lexical_with_options::<F3>(b"NaN", &OPTIONS).is_err());
|
|
assert!(f64::from_lexical_with_options::<F4>(b"NaN", &OPTIONS).unwrap().is_nan());
|
|
assert!(f64::from_lexical_with_options::<F5>(b"NaN", &OPTIONS).unwrap().is_nan());
|
|
|
|
// Case-sensitive NaN.
|
|
assert!(f64::from_lexical_with_options::<F1>(b"nan", &OPTIONS).unwrap().is_nan());
|
|
assert!(f64::from_lexical_with_options::<F2>(b"nan", &OPTIONS).unwrap().is_nan());
|
|
assert!(f64::from_lexical_with_options::<F3>(b"nan", &OPTIONS).is_err());
|
|
assert!(f64::from_lexical_with_options::<F4>(b"nan", &OPTIONS).is_err());
|
|
assert!(f64::from_lexical_with_options::<F5>(b"nan", &OPTIONS).is_err());
|
|
|
|
// Digit-separator NaN.
|
|
assert!(f64::from_lexical_with_options::<F1>(b"N_aN", &OPTIONS).is_err());
|
|
assert!(f64::from_lexical_with_options::<F2>(b"N_aN", &OPTIONS).unwrap().is_nan());
|
|
assert!(f64::from_lexical_with_options::<F3>(b"N_aN", &OPTIONS).is_err());
|
|
assert!(f64::from_lexical_with_options::<F4>(b"N_aN", &OPTIONS).is_err());
|
|
assert!(f64::from_lexical_with_options::<F5>(b"N_aN", &OPTIONS).unwrap().is_nan());
|
|
|
|
// Digit-separator + case-sensitive NaN.
|
|
assert!(f64::from_lexical_with_options::<F1>(b"n_an", &OPTIONS).is_err());
|
|
assert!(f64::from_lexical_with_options::<F2>(b"n_an", &OPTIONS).unwrap().is_nan());
|
|
assert!(f64::from_lexical_with_options::<F3>(b"n_an", &OPTIONS).is_err());
|
|
assert!(f64::from_lexical_with_options::<F4>(b"n_an", &OPTIONS).is_err());
|
|
assert!(f64::from_lexical_with_options::<F5>(b"n_an", &OPTIONS).is_err());
|
|
|
|
// Leading digit separator + case-sensitive NaN.
|
|
assert!(f64::from_lexical_with_options::<F1>(b"_n_a_n", &OPTIONS).is_err());
|
|
assert!(f64::from_lexical_with_options::<F2>(b"_n_a_n", &OPTIONS).unwrap().is_nan());
|
|
assert!(f64::from_lexical_with_options::<F3>(b"_n_a_n", &OPTIONS).is_err());
|
|
assert!(f64::from_lexical_with_options::<F4>(b"_n_a_n", &OPTIONS).is_err());
|
|
assert!(f64::from_lexical_with_options::<F5>(b"_n_a_n", &OPTIONS).is_err());
|
|
|
|
// Trailing digit separator + case-sensitive NaN.
|
|
assert!(f64::from_lexical_with_options::<F1>(b"n_a_n_", &OPTIONS).is_err());
|
|
assert!(f64::from_lexical_with_options::<F2>(b"n_a_n_", &OPTIONS).unwrap().is_nan());
|
|
assert!(f64::from_lexical_with_options::<F3>(b"n_a_n_", &OPTIONS).is_err());
|
|
assert!(f64::from_lexical_with_options::<F4>(b"n_a_n_", &OPTIONS).is_err());
|
|
assert!(f64::from_lexical_with_options::<F5>(b"n_a_n_", &OPTIONS).is_err());
|
|
}
|
|
|
|
#[test]
|
|
#[cfg(feature = "format")]
|
|
fn case_sensitive_exponent_test() {
|
|
const FORMAT: u128 = NumberFormatBuilder::new().case_sensitive_exponent(true).build_strict();
|
|
const OPTIONS: Options = Options::new();
|
|
assert!(f64::from_lexical_with_options::<FORMAT>(b"+3.0", &OPTIONS).is_ok());
|
|
assert!(f64::from_lexical_with_options::<FORMAT>(b"+3.0e+300", &OPTIONS).is_ok());
|
|
assert!(f64::from_lexical_with_options::<FORMAT>(b"+3.0E+300", &OPTIONS).is_err());
|
|
|
|
assert!(f64::from_lexical(b"+3.0e+300").is_ok());
|
|
assert!(f64::from_lexical(b"+3.0E+300").is_ok());
|
|
}
|
|
|
|
#[test]
|
|
#[cfg(feature = "format")]
|
|
fn f64_required_integer_digits_test() {
|
|
const FORMAT: u128 = rebuild(format::PERMISSIVE).required_integer_digits(true).build_strict();
|
|
const OPTIONS: Options = Options::new();
|
|
assert!(f64::from_lexical_with_options::<FORMAT>(b"+3.0", &OPTIONS).is_ok());
|
|
assert!(f64::from_lexical_with_options::<FORMAT>(b"3.0", &OPTIONS).is_ok());
|
|
assert!(f64::from_lexical_with_options::<FORMAT>(b".0", &OPTIONS).is_err());
|
|
}
|
|
|
|
#[test]
|
|
#[cfg(feature = "format")]
|
|
fn f64_required_fraction_digits_test() {
|
|
const FORMAT: u128 = rebuild(format::PERMISSIVE).required_fraction_digits(true).build_strict();
|
|
const OPTIONS: Options = Options::new();
|
|
assert!(f64::from_lexical_with_options::<FORMAT>(b"+3.0", &OPTIONS).is_ok());
|
|
assert!(f64::from_lexical_with_options::<FORMAT>(b"3.0", &OPTIONS).is_ok());
|
|
assert!(f64::from_lexical_with_options::<FORMAT>(b"3.", &OPTIONS).is_err());
|
|
assert!(f64::from_lexical_with_options::<FORMAT>(b"3", &OPTIONS).is_ok());
|
|
}
|
|
|
|
#[test]
|
|
#[cfg(feature = "format")]
|
|
fn f64_required_digits_test() {
|
|
const FORMAT: u128 = rebuild(format::PERMISSIVE).required_digits(true).build_strict();
|
|
const OPTIONS: Options = Options::new();
|
|
assert!(f64::from_lexical_with_options::<FORMAT>(b"+3.0", &OPTIONS).is_ok());
|
|
assert!(f64::from_lexical_with_options::<FORMAT>(b"3.0", &OPTIONS).is_ok());
|
|
assert!(f64::from_lexical_with_options::<FORMAT>(b"3.", &OPTIONS).is_err());
|
|
assert!(f64::from_lexical_with_options::<FORMAT>(b"3", &OPTIONS).is_ok());
|
|
assert!(f64::from_lexical_with_options::<FORMAT>(b".0", &OPTIONS).is_err());
|
|
}
|
|
|
|
#[test]
|
|
#[cfg(feature = "format")]
|
|
fn f64_no_positive_mantissa_sign_test() {
|
|
const FORMAT: u128 = rebuild(format::PERMISSIVE).no_positive_mantissa_sign(true).build_strict();
|
|
const OPTIONS: Options = Options::new();
|
|
assert!(f64::from_lexical_with_options::<FORMAT>(b"+3.0", &OPTIONS).is_err());
|
|
assert!(f64::from_lexical_with_options::<FORMAT>(b"-3.0", &OPTIONS).is_ok());
|
|
assert!(f64::from_lexical_with_options::<FORMAT>(b"3.0", &OPTIONS).is_ok());
|
|
}
|
|
|
|
#[test]
|
|
#[cfg(feature = "format")]
|
|
fn f64_required_mantissa_sign_test() {
|
|
const FORMAT: u128 = rebuild(format::PERMISSIVE).required_mantissa_sign(true).build_strict();
|
|
const OPTIONS: Options = Options::new();
|
|
assert!(f64::from_lexical_with_options::<FORMAT>(b"+3.0", &OPTIONS).is_ok());
|
|
assert!(f64::from_lexical_with_options::<FORMAT>(b"-3.0", &OPTIONS).is_ok());
|
|
assert!(f64::from_lexical_with_options::<FORMAT>(b"3.0", &OPTIONS).is_err());
|
|
}
|
|
|
|
#[test]
|
|
#[cfg(feature = "format")]
|
|
fn f64_no_exponent_notation_test() {
|
|
const FORMAT: u128 = rebuild(format::PERMISSIVE).no_exponent_notation(true).build_strict();
|
|
const OPTIONS: Options = Options::new();
|
|
assert!(f64::from_lexical_with_options::<FORMAT>(b"+3.0e7", &OPTIONS).is_err());
|
|
assert!(f64::from_lexical_with_options::<FORMAT>(b"+3.0e-7", &OPTIONS).is_err());
|
|
assert!(f64::from_lexical_with_options::<FORMAT>(b"+3e", &OPTIONS).is_err());
|
|
assert!(f64::from_lexical_with_options::<FORMAT>(b"+3e-", &OPTIONS).is_err());
|
|
assert!(f64::from_lexical_with_options::<FORMAT>(b"+3.0", &OPTIONS).is_ok());
|
|
assert!(f64::from_lexical_with_options::<FORMAT>(b"+3", &OPTIONS).is_ok());
|
|
}
|
|
|
|
#[test]
|
|
#[cfg(feature = "format")]
|
|
fn f64_optional_exponent_test() {
|
|
const FORMAT: u128 = format::PERMISSIVE;
|
|
const OPTIONS: Options = Options::new();
|
|
assert!(f64::from_lexical_with_options::<FORMAT>(b"+3.0e7", &OPTIONS).is_ok());
|
|
assert!(f64::from_lexical_with_options::<FORMAT>(b"+3.0e-7", &OPTIONS).is_ok());
|
|
assert!(f64::from_lexical_with_options::<FORMAT>(b"+3.0e", &OPTIONS).is_ok());
|
|
assert!(f64::from_lexical_with_options::<FORMAT>(b"+3.0e-", &OPTIONS).is_ok());
|
|
assert!(f64::from_lexical_with_options::<FORMAT>(b"+3.0", &OPTIONS).is_ok());
|
|
}
|
|
|
|
#[test]
|
|
#[cfg(feature = "format")]
|
|
fn f64_required_exponent_test() {
|
|
const FORMAT: u128 = rebuild(format::PERMISSIVE).required_exponent_digits(true).build_strict();
|
|
const OPTIONS: Options = Options::new();
|
|
assert!(f64::from_lexical_with_options::<FORMAT>(b"+3.0e7", &OPTIONS).is_ok());
|
|
assert!(f64::from_lexical_with_options::<FORMAT>(b"+3.0e-7", &OPTIONS).is_ok());
|
|
assert!(f64::from_lexical_with_options::<FORMAT>(b"+3.0e", &OPTIONS).is_err());
|
|
assert!(f64::from_lexical_with_options::<FORMAT>(b"+3.0e-", &OPTIONS).is_err());
|
|
assert!(f64::from_lexical_with_options::<FORMAT>(b"+3.0", &OPTIONS).is_ok());
|
|
}
|
|
|
|
#[test]
|
|
#[cfg(feature = "format")]
|
|
fn f64_no_positive_exponent_sign_test() {
|
|
const FORMAT: u128 = rebuild(format::PERMISSIVE).no_positive_exponent_sign(true).build_strict();
|
|
const OPTIONS: Options = Options::new();
|
|
assert!(f64::from_lexical_with_options::<FORMAT>(b"3.0e7", &OPTIONS).is_ok());
|
|
assert!(f64::from_lexical_with_options::<FORMAT>(b"3.0e+7", &OPTIONS).is_err());
|
|
assert!(f64::from_lexical_with_options::<FORMAT>(b"3.0e-7", &OPTIONS).is_ok());
|
|
}
|
|
|
|
#[test]
|
|
#[cfg(feature = "format")]
|
|
fn f64_required_exponent_sign_test() {
|
|
const FORMAT: u128 = rebuild(format::PERMISSIVE).required_exponent_sign(true).build_strict();
|
|
const OPTIONS: Options = Options::new();
|
|
assert!(f64::from_lexical_with_options::<FORMAT>(b"3.0e7", &OPTIONS).is_err());
|
|
assert!(f64::from_lexical_with_options::<FORMAT>(b"3.0e+7", &OPTIONS).is_ok());
|
|
assert!(f64::from_lexical_with_options::<FORMAT>(b"3.0e-7", &OPTIONS).is_ok());
|
|
}
|
|
|
|
#[test]
|
|
#[cfg(feature = "format")]
|
|
fn f64_no_exponent_without_fraction_test() {
|
|
const F1: u128 = rebuild(format::PERMISSIVE).no_exponent_without_fraction(true).build_strict();
|
|
const OPTIONS: Options = Options::new();
|
|
assert!(f64::from_lexical_with_options::<F1>(b"3.0e7", &OPTIONS).is_ok());
|
|
assert!(f64::from_lexical_with_options::<F1>(b"3.e7", &OPTIONS).is_ok());
|
|
assert!(f64::from_lexical_with_options::<F1>(b"3e7", &OPTIONS).is_err());
|
|
|
|
const F2: u128 = rebuild(F1).required_fraction_digits(true).build_strict();
|
|
assert!(f64::from_lexical_with_options::<F2>(b"3.0e7", &OPTIONS).is_ok());
|
|
assert!(f64::from_lexical_with_options::<F2>(b"3.e7", &OPTIONS).is_err());
|
|
assert!(f64::from_lexical_with_options::<F2>(b"3e7", &OPTIONS).is_err());
|
|
}
|
|
|
|
#[test]
|
|
#[cfg(feature = "format")]
|
|
fn f64_no_leading_zeros_test() {
|
|
const FORMAT: u128 = rebuild(format::PERMISSIVE).no_float_leading_zeros(true).build_strict();
|
|
const OPTIONS: Options = Options::new();
|
|
assert!(f64::from_lexical_with_options::<FORMAT>(b"1.0", &OPTIONS).is_ok());
|
|
assert!(f64::from_lexical_with_options::<FORMAT>(b"0.0", &OPTIONS).is_ok());
|
|
assert!(f64::from_lexical_with_options::<FORMAT>(b"01.0", &OPTIONS).is_err());
|
|
assert!(f64::from_lexical_with_options::<FORMAT>(b"10.0", &OPTIONS).is_ok());
|
|
assert!(f64::from_lexical_with_options::<FORMAT>(b"010.0", &OPTIONS).is_err());
|
|
}
|
|
|
|
#[test]
|
|
#[cfg(feature = "format")]
|
|
fn f64_required_exponent_notation_test() {
|
|
const FORMAT: u128 = rebuild(format::PERMISSIVE)
|
|
.required_exponent_digits(false)
|
|
.required_exponent_notation(true)
|
|
.build_strict();
|
|
const OPTIONS: Options = Options::new();
|
|
assert!(f64::from_lexical_with_options::<FORMAT>(b"+3.0", &OPTIONS).is_err());
|
|
assert!(f64::from_lexical_with_options::<FORMAT>(b"3.0e", &OPTIONS).is_ok());
|
|
assert!(f64::from_lexical_with_options::<FORMAT>(b"0.e", &OPTIONS).is_ok());
|
|
}
|
|
|
|
#[test]
|
|
#[cfg(feature = "format")]
|
|
fn f64_integer_internal_digit_separator_test() {
|
|
const FORMAT: u128 = rebuild(format::PERMISSIVE)
|
|
.integer_internal_digit_separator(true)
|
|
.digit_separator(num::NonZeroU8::new(b'_'))
|
|
.build_strict();
|
|
const OPTIONS: Options = Options::new();
|
|
assert!(f64::from_lexical_with_options::<FORMAT>(b"3_1.0e7", &OPTIONS).is_ok());
|
|
assert!(f64::from_lexical_with_options::<FORMAT>(b"_31.0e7", &OPTIONS).is_err());
|
|
assert!(f64::from_lexical_with_options::<FORMAT>(b"31_.0e7", &OPTIONS).is_err());
|
|
}
|
|
|
|
#[test]
|
|
#[cfg(feature = "format")]
|
|
fn f64_fraction_internal_digit_separator_test() {
|
|
const FORMAT: u128 = rebuild(format::PERMISSIVE)
|
|
.fraction_internal_digit_separator(true)
|
|
.digit_separator(num::NonZeroU8::new(b'_'))
|
|
.build_strict();
|
|
const OPTIONS: Options = Options::new();
|
|
assert!(f64::from_lexical_with_options::<FORMAT>(b"31.0_1e7", &OPTIONS).is_ok());
|
|
assert!(f64::from_lexical_with_options::<FORMAT>(b"31._01e7", &OPTIONS).is_err());
|
|
assert!(f64::from_lexical_with_options::<FORMAT>(b"31.01_e7", &OPTIONS).is_err());
|
|
}
|
|
|
|
#[test]
|
|
#[cfg(feature = "format")]
|
|
fn f64_exponent_internal_digit_separator_test() {
|
|
const FORMAT: u128 = rebuild(format::PERMISSIVE)
|
|
.exponent_internal_digit_separator(true)
|
|
.digit_separator(num::NonZeroU8::new(b'_'))
|
|
.build_strict();
|
|
const OPTIONS: Options = Options::new();
|
|
assert!(f64::from_lexical_with_options::<FORMAT>(b"31.01e7_1", &OPTIONS).is_ok());
|
|
assert!(f64::from_lexical_with_options::<FORMAT>(b"31.01e_71", &OPTIONS).is_err());
|
|
assert!(f64::from_lexical_with_options::<FORMAT>(b"31.01e71_", &OPTIONS).is_err());
|
|
}
|
|
|
|
#[test]
|
|
#[cfg(feature = "format")]
|
|
fn f64_integer_leading_digit_separator_test() {
|
|
const FORMAT: u128 = rebuild(format::PERMISSIVE)
|
|
.integer_leading_digit_separator(true)
|
|
.digit_separator(num::NonZeroU8::new(b'_'))
|
|
.build_strict();
|
|
const OPTIONS: Options = Options::new();
|
|
assert!(f64::from_lexical_with_options::<FORMAT>(b"3_1.0e7", &OPTIONS).is_err());
|
|
assert!(f64::from_lexical_with_options::<FORMAT>(b"_31.0e7", &OPTIONS).is_ok());
|
|
assert!(f64::from_lexical_with_options::<FORMAT>(b"31_.0e7", &OPTIONS).is_err());
|
|
}
|
|
|
|
#[test]
|
|
#[cfg(feature = "format")]
|
|
fn f64_fraction_leading_digit_separator_test() {
|
|
const FORMAT: u128 = rebuild(format::PERMISSIVE)
|
|
.fraction_leading_digit_separator(true)
|
|
.digit_separator(num::NonZeroU8::new(b'_'))
|
|
.build_strict();
|
|
const OPTIONS: Options = Options::new();
|
|
assert!(f64::from_lexical_with_options::<FORMAT>(b"31.0_1e7", &OPTIONS).is_err());
|
|
assert!(f64::from_lexical_with_options::<FORMAT>(b"31._01e7", &OPTIONS).is_ok());
|
|
assert!(f64::from_lexical_with_options::<FORMAT>(b"31.01_e7", &OPTIONS).is_err());
|
|
}
|
|
|
|
#[test]
|
|
#[cfg(feature = "format")]
|
|
fn f64_exponent_leading_digit_separator_test() {
|
|
const FORMAT: u128 = rebuild(format::PERMISSIVE)
|
|
.exponent_leading_digit_separator(true)
|
|
.digit_separator(num::NonZeroU8::new(b'_'))
|
|
.build_strict();
|
|
const OPTIONS: Options = Options::new();
|
|
assert!(f64::from_lexical_with_options::<FORMAT>(b"31.01e7_1", &OPTIONS).is_err());
|
|
assert!(f64::from_lexical_with_options::<FORMAT>(b"31.01e_71", &OPTIONS).is_ok());
|
|
assert!(f64::from_lexical_with_options::<FORMAT>(b"31.01e71_", &OPTIONS).is_err());
|
|
}
|
|
|
|
#[test]
|
|
#[cfg(feature = "format")]
|
|
fn f64_integer_trailing_digit_separator_test() {
|
|
const FORMAT: u128 = rebuild(format::PERMISSIVE)
|
|
.integer_trailing_digit_separator(true)
|
|
.digit_separator(num::NonZeroU8::new(b'_'))
|
|
.build_strict();
|
|
const OPTIONS: Options = Options::new();
|
|
assert!(f64::from_lexical_with_options::<FORMAT>(b"3_1.0e7", &OPTIONS).is_err());
|
|
assert!(f64::from_lexical_with_options::<FORMAT>(b"_31.0e7", &OPTIONS).is_err());
|
|
assert!(f64::from_lexical_with_options::<FORMAT>(b"31_.0e7", &OPTIONS).is_ok());
|
|
}
|
|
|
|
#[test]
|
|
#[cfg(feature = "format")]
|
|
fn f64_fraction_trailing_digit_separator_test() {
|
|
const FORMAT: u128 = rebuild(format::PERMISSIVE)
|
|
.fraction_trailing_digit_separator(true)
|
|
.digit_separator(num::NonZeroU8::new(b'_'))
|
|
.build_strict();
|
|
const OPTIONS: Options = Options::new();
|
|
assert!(f64::from_lexical_with_options::<FORMAT>(b"31.0_1e7", &OPTIONS).is_err());
|
|
assert!(f64::from_lexical_with_options::<FORMAT>(b"31._01e7", &OPTIONS).is_err());
|
|
assert!(f64::from_lexical_with_options::<FORMAT>(b"31.01_e7", &OPTIONS).is_ok());
|
|
}
|
|
|
|
#[test]
|
|
#[cfg(feature = "format")]
|
|
fn f64_exponent_trailing_digit_separator_test() {
|
|
const FORMAT: u128 = rebuild(format::PERMISSIVE)
|
|
.exponent_trailing_digit_separator(true)
|
|
.digit_separator(num::NonZeroU8::new(b'_'))
|
|
.build_strict();
|
|
const OPTIONS: Options = Options::new();
|
|
assert!(f64::from_lexical_with_options::<FORMAT>(b"31.01e7_1", &OPTIONS).is_err());
|
|
assert!(f64::from_lexical_with_options::<FORMAT>(b"31.01e_71", &OPTIONS).is_err());
|
|
assert!(f64::from_lexical_with_options::<FORMAT>(b"31.01e71_", &OPTIONS).is_ok());
|
|
}
|
|
|
|
#[test]
|
|
#[cfg(feature = "format")]
|
|
fn f64_integer_consecutive_digit_separator_test() {
|
|
const FORMAT: u128 = rebuild(format::PERMISSIVE)
|
|
.integer_internal_digit_separator(true)
|
|
.integer_consecutive_digit_separator(true)
|
|
.digit_separator(num::NonZeroU8::new(b'_'))
|
|
.build_strict();
|
|
const OPTIONS: Options = Options::new();
|
|
assert!(f64::from_lexical_with_options::<FORMAT>(b"3__1.0e7", &OPTIONS).is_ok());
|
|
assert!(f64::from_lexical_with_options::<FORMAT>(b"_31.0e7", &OPTIONS).is_err());
|
|
assert!(f64::from_lexical_with_options::<FORMAT>(b"31_.0e7", &OPTIONS).is_err());
|
|
}
|
|
|
|
#[test]
|
|
#[cfg(feature = "format")]
|
|
fn f64_fraction_consecutive_digit_separator_test() {
|
|
const FORMAT: u128 = rebuild(format::PERMISSIVE)
|
|
.fraction_internal_digit_separator(true)
|
|
.fraction_consecutive_digit_separator(true)
|
|
.digit_separator(num::NonZeroU8::new(b'_'))
|
|
.build_strict();
|
|
const OPTIONS: Options = Options::new();
|
|
assert!(f64::from_lexical_with_options::<FORMAT>(b"31.0__1e7", &OPTIONS).is_ok());
|
|
assert!(f64::from_lexical_with_options::<FORMAT>(b"31._01e7", &OPTIONS).is_err());
|
|
assert!(f64::from_lexical_with_options::<FORMAT>(b"31.01_e7", &OPTIONS).is_err());
|
|
}
|
|
|
|
#[test]
|
|
#[cfg(feature = "format")]
|
|
fn f64_exponent_consecutive_digit_separator_test() {
|
|
const FORMAT: u128 = rebuild(format::PERMISSIVE)
|
|
.exponent_internal_digit_separator(true)
|
|
.exponent_consecutive_digit_separator(true)
|
|
.digit_separator(num::NonZeroU8::new(b'_'))
|
|
.build_strict();
|
|
const OPTIONS: Options = Options::new();
|
|
assert!(f64::from_lexical_with_options::<FORMAT>(b"31.01e7__1", &OPTIONS).is_ok());
|
|
assert!(f64::from_lexical_with_options::<FORMAT>(b"31.01e_71", &OPTIONS).is_err());
|
|
assert!(f64::from_lexical_with_options::<FORMAT>(b"31.01e71_", &OPTIONS).is_err());
|
|
}
|
|
|
|
#[test]
|
|
#[cfg(feature = "format")]
|
|
fn f64_json_exponent_without_dot() {
|
|
// Tests courtesy of @ijl:
|
|
// https://github.com/Alexhuszagh/rust-lexical/issues/24#issuecomment-578153783
|
|
const FORMAT: u128 = format::JSON;
|
|
const OPTIONS: Options = Options::new();
|
|
// JSONTestSuite/test_parsing/y_number_0e1.json
|
|
assert!(f64::from_lexical_with_options::<FORMAT>(b"0e1", &OPTIONS).is_ok());
|
|
// JSONTestSuite/test_parsing/y_number_int_with_exp.json
|
|
assert!(f64::from_lexical_with_options::<FORMAT>(b"20e1", &OPTIONS).is_ok());
|
|
// JSONTestSuite/test_parsing/y_number_real_capital_e_pos_exp.json
|
|
assert!(f64::from_lexical_with_options::<FORMAT>(b"1E+2", &OPTIONS).is_ok());
|
|
// JSONTestSuite/test_transform/number_1e-999.json
|
|
assert!(f64::from_lexical_with_options::<FORMAT>(b"1E-999", &OPTIONS).is_ok());
|
|
// nativejson-benchmark/data/jsonchecker/pass01.json
|
|
assert!(f64::from_lexical_with_options::<FORMAT>(b"23456789012E66", &OPTIONS).is_ok());
|
|
}
|
|
|
|
#[test]
|
|
#[cfg(feature = "format")]
|
|
fn f64_json_exponent_requires_digit() {
|
|
// Tests courtesy of @ijl:
|
|
// https://github.com/Alexhuszagh/rust-lexical/issues/24#issuecomment-578153783
|
|
const FORMAT: u128 = format::JSON;
|
|
const OPTIONS: Options = Options::new();
|
|
assert!(f64::from_lexical_with_options::<FORMAT>(b"1e", &OPTIONS).is_err());
|
|
// JSONTestSuite/test_parsing/n_number_9.e+.json
|
|
assert!(f64::from_lexical_with_options::<FORMAT>(b"9.e+", &OPTIONS).is_err());
|
|
// JSONTestSuite/test_parsing/n_number_2.e-3.json
|
|
assert!(f64::from_lexical_with_options::<FORMAT>(b"2.e-3", &OPTIONS).is_err());
|
|
// JSONTestSuite/test_parsing/n_number_real_without_fractional_part.json
|
|
assert!(f64::from_lexical_with_options::<FORMAT>(b"1.", &OPTIONS).is_err());
|
|
}
|
|
|
|
#[test]
|
|
#[cfg(feature = "format")]
|
|
fn f64_json_no_leading_zero() {
|
|
const FORMAT: u128 = format::JSON;
|
|
const OPTIONS: Options = Options::new();
|
|
assert!(f64::from_lexical_with_options::<FORMAT>(b"12.0", &OPTIONS).is_ok());
|
|
assert!(f64::from_lexical_with_options::<FORMAT>(b"-12.0", &OPTIONS).is_ok());
|
|
assert!(f64::from_lexical_with_options::<FORMAT>(b"012.0", &OPTIONS).is_err());
|
|
assert!(f64::from_lexical_with_options::<FORMAT>(b"-012.0", &OPTIONS).is_err());
|
|
}
|
|
|
|
#[test]
|
|
#[cfg(all(feature = "power-of-two", feature = "format"))]
|
|
fn base_prefix_test() {
|
|
const FORMAT: u128 =
|
|
NumberFormatBuilder::new().base_prefix(num::NonZeroU8::new(b'x')).build_strict();
|
|
const OPTIONS: Options = Options::new();
|
|
assert!(f64::from_lexical_with_options::<FORMAT>(b"+0x", &OPTIONS).is_err());
|
|
assert!(f64::from_lexical_with_options::<FORMAT>(b"+0x ", &OPTIONS).is_err());
|
|
assert!(f64::from_lexical_with_options::<FORMAT>(b"+0x3", &OPTIONS).is_ok());
|
|
assert!(f64::from_lexical_with_options::<FORMAT>(b"+3.0", &OPTIONS).is_ok());
|
|
assert!(f64::from_lexical_with_options::<FORMAT>(b"+0x3.0", &OPTIONS).is_ok());
|
|
assert!(f64::from_lexical_with_options::<FORMAT>(b"+0x3.0e+300", &OPTIONS).is_ok());
|
|
assert!(f64::from_lexical_with_options::<FORMAT>(b"+0x3.0e+300", &OPTIONS).is_ok());
|
|
assert!(f64::from_lexical_with_options::<FORMAT>(b"+0x3.0e+300 ", &OPTIONS).is_err());
|
|
|
|
assert!(f64::from_lexical_partial_with_options::<FORMAT>(b"+0x", &OPTIONS).is_err());
|
|
assert!(f64::from_lexical_partial_with_options::<FORMAT>(b"+0x ", &OPTIONS).is_err());
|
|
assert!(f64::from_lexical_partial_with_options::<FORMAT>(b"+0x3", &OPTIONS).is_ok());
|
|
assert!(f64::from_lexical_partial_with_options::<FORMAT>(b"+3.0", &OPTIONS).is_ok());
|
|
assert!(f64::from_lexical_partial_with_options::<FORMAT>(b"+0x3.0e+300", &OPTIONS).is_ok());
|
|
assert!(f64::from_lexical_partial_with_options::<FORMAT>(b"+0x3.0e+300", &OPTIONS).is_ok());
|
|
assert!(f64::from_lexical_partial_with_options::<FORMAT>(b"+0x3.0e+300 ", &OPTIONS).is_ok());
|
|
}
|
|
|
|
#[test]
|
|
#[cfg(all(feature = "power-of-two", feature = "format"))]
|
|
fn base_suffix_test() {
|
|
const FORMAT: u128 =
|
|
NumberFormatBuilder::new().base_suffix(num::NonZeroU8::new(b'h')).build_strict();
|
|
const OPTIONS: Options = Options::new();
|
|
assert!(f64::from_lexical_with_options::<FORMAT>(b"h", &OPTIONS).is_err());
|
|
assert!(f64::from_lexical_with_options::<FORMAT>(b"-h ", &OPTIONS).is_err());
|
|
assert!(f64::from_lexical_with_options::<FORMAT>(b"+h ", &OPTIONS).is_err());
|
|
assert!(f64::from_lexical_with_options::<FORMAT>(b"+3h", &OPTIONS).is_ok());
|
|
assert!(f64::from_lexical_with_options::<FORMAT>(b"+3.0", &OPTIONS).is_ok());
|
|
assert!(f64::from_lexical_with_options::<FORMAT>(b"+3.0h", &OPTIONS).is_ok());
|
|
assert!(f64::from_lexical_with_options::<FORMAT>(b"+3.0e+300h", &OPTIONS).is_ok());
|
|
assert!(f64::from_lexical_with_options::<FORMAT>(b"+3.0e+300h", &OPTIONS).is_ok());
|
|
assert!(f64::from_lexical_with_options::<FORMAT>(b"+3.0e+300h ", &OPTIONS).is_err());
|
|
|
|
assert!(f64::from_lexical_partial_with_options::<FORMAT>(b"+h", &OPTIONS).is_err());
|
|
assert!(f64::from_lexical_partial_with_options::<FORMAT>(b"+h ", &OPTIONS).is_err());
|
|
assert!(f64::from_lexical_partial_with_options::<FORMAT>(b"+3h", &OPTIONS).is_ok());
|
|
assert!(f64::from_lexical_partial_with_options::<FORMAT>(b"+3.0", &OPTIONS).is_ok());
|
|
assert!(f64::from_lexical_partial_with_options::<FORMAT>(b"+3.0h", &OPTIONS).is_ok());
|
|
assert!(f64::from_lexical_partial_with_options::<FORMAT>(b"+3.0e+300h", &OPTIONS).is_ok());
|
|
assert!(f64::from_lexical_partial_with_options::<FORMAT>(b"+3.0e+300h", &OPTIONS).is_ok());
|
|
assert!(f64::from_lexical_partial_with_options::<FORMAT>(b"+3.0e+300h ", &OPTIONS).is_ok());
|
|
}
|
|
|
|
#[test]
|
|
#[cfg(all(feature = "power-of-two", feature = "format"))]
|
|
fn base_prefix_and_suffix_test() {
|
|
const FORMAT: u128 = NumberFormatBuilder::new()
|
|
.base_prefix(num::NonZeroU8::new(b'x'))
|
|
.base_suffix(num::NonZeroU8::new(b'h'))
|
|
.build_strict();
|
|
const OPTIONS: Options = Options::new();
|
|
assert!(f64::from_lexical_with_options::<FORMAT>(b"+3h", &OPTIONS).is_ok());
|
|
assert!(f64::from_lexical_with_options::<FORMAT>(b"+0x3", &OPTIONS).is_ok());
|
|
assert!(f64::from_lexical_with_options::<FORMAT>(b"+0x3h", &OPTIONS).is_ok());
|
|
assert!(f64::from_lexical_with_options::<FORMAT>(b"+0xh", &OPTIONS).is_err());
|
|
assert!(f64::from_lexical_with_options::<FORMAT>(b"+0x3.0e+300h", &OPTIONS).is_ok());
|
|
assert!(f64::from_lexical_with_options::<FORMAT>(b"+0x3.0e+300h ", &OPTIONS).is_err());
|
|
}
|
|
|
|
#[test]
|
|
#[cfg(feature = "format")]
|
|
fn issue66_test() {
|
|
const RUST: u128 = format::RUST_LITERAL;
|
|
const JSON: u128 = format::JSON;
|
|
const CXX: u128 = format::CXX17_LITERAL;
|
|
|
|
const OPTIONS: Options = Options::new();
|
|
|
|
assert_eq!(f64::from_lexical_with_options::<JSON>(b"42.0", &OPTIONS), Ok(42.0));
|
|
assert_eq!(f64::from_lexical_with_options::<RUST>(b"42.0", &OPTIONS), Ok(42.0));
|
|
assert_eq!(f64::from_lexical_with_options::<RUST>(b"4_2.0", &OPTIONS), Ok(42.0));
|
|
assert_eq!(f64::from_lexical_with_options::<CXX>(b"42.0", &OPTIONS), Ok(42.0));
|
|
assert_eq!(f64::from_lexical_with_options::<CXX>(b"4'2.0", &OPTIONS), Ok(42.0));
|
|
}
|
|
|
|
#[test]
|
|
#[cfg(feature = "power-of-two")]
|
|
fn issue68_test() {
|
|
const FORMAT: u128 = NumberFormatBuilder::from_radix(16);
|
|
const OPTIONS: Options = Options::builder().exponent(b'^').build_strict();
|
|
|
|
// Roughly 2^1375, 15 1s.
|
|
let hex = b"1111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111";
|
|
assert_eq!(f32::INFINITY, f32::from_lexical_with_options::<FORMAT>(hex, &OPTIONS).unwrap());
|
|
assert_eq!(f64::INFINITY, f64::from_lexical_with_options::<FORMAT>(hex, &OPTIONS).unwrap());
|
|
}
|