aboutsummaryrefslogtreecommitdiff
path: root/vendor/serde_json/tests/lexical
diff options
context:
space:
mode:
Diffstat (limited to 'vendor/serde_json/tests/lexical')
-rw-r--r--vendor/serde_json/tests/lexical/algorithm.rs110
-rw-r--r--vendor/serde_json/tests/lexical/exponent.rs54
-rw-r--r--vendor/serde_json/tests/lexical/float.rs581
-rw-r--r--vendor/serde_json/tests/lexical/math.rs211
-rw-r--r--vendor/serde_json/tests/lexical/num.rs76
-rw-r--r--vendor/serde_json/tests/lexical/parse.rs204
-rw-r--r--vendor/serde_json/tests/lexical/rounding.rs316
7 files changed, 0 insertions, 1552 deletions
diff --git a/vendor/serde_json/tests/lexical/algorithm.rs b/vendor/serde_json/tests/lexical/algorithm.rs
deleted file mode 100644
index 7f3a2c6..0000000
--- a/vendor/serde_json/tests/lexical/algorithm.rs
+++ /dev/null
@@ -1,110 +0,0 @@
-// Adapted from https://github.com/Alexhuszagh/rust-lexical.
-
-use crate::lexical::algorithm::*;
-use crate::lexical::num::Float;
-
-#[test]
-fn float_fast_path_test() {
- // valid
- let mantissa = (1 << f32::MANTISSA_SIZE) - 1;
- let (min_exp, max_exp) = f32::exponent_limit();
- for exp in min_exp..=max_exp {
- let f = fast_path::<f32>(mantissa, exp);
- assert!(f.is_some(), "should be valid {:?}.", (mantissa, exp));
- }
-
- // Check slightly above valid exponents
- let f = fast_path::<f32>(123, 15);
- assert_eq!(f, Some(1.23e+17));
-
- // Exponent is 1 too high, pushes over the mantissa.
- let f = fast_path::<f32>(123, 16);
- assert!(f.is_none());
-
- // Mantissa is too large, checked_mul should overflow.
- let f = fast_path::<f32>(mantissa, 11);
- assert!(f.is_none());
-
- // invalid exponents
- let (min_exp, max_exp) = f32::exponent_limit();
- let f = fast_path::<f32>(mantissa, min_exp - 1);
- assert!(f.is_none(), "exponent under min_exp");
-
- let f = fast_path::<f32>(mantissa, max_exp + 1);
- assert!(f.is_none(), "exponent above max_exp");
-}
-
-#[test]
-fn double_fast_path_test() {
- // valid
- let mantissa = (1 << f64::MANTISSA_SIZE) - 1;
- let (min_exp, max_exp) = f64::exponent_limit();
- for exp in min_exp..=max_exp {
- let f = fast_path::<f64>(mantissa, exp);
- assert!(f.is_some(), "should be valid {:?}.", (mantissa, exp));
- }
-
- // invalid exponents
- let (min_exp, max_exp) = f64::exponent_limit();
- let f = fast_path::<f64>(mantissa, min_exp - 1);
- assert!(f.is_none(), "exponent under min_exp");
-
- let f = fast_path::<f64>(mantissa, max_exp + 1);
- assert!(f.is_none(), "exponent above max_exp");
-
- assert_eq!(
- Some(0.04628372940652459),
- fast_path::<f64>(4628372940652459, -17)
- );
- assert_eq!(None, fast_path::<f64>(26383446160308229, -272));
-}
-
-#[test]
-fn moderate_path_test() {
- let (f, valid) = moderate_path::<f64>(1234567890, -1, false);
- assert!(valid, "should be valid");
- assert_eq!(f.into_float::<f64>(), 123456789.0);
-
- let (f, valid) = moderate_path::<f64>(1234567891, -1, false);
- assert!(valid, "should be valid");
- assert_eq!(f.into_float::<f64>(), 123456789.1);
-
- let (f, valid) = moderate_path::<f64>(12345678912, -2, false);
- assert!(valid, "should be valid");
- assert_eq!(f.into_float::<f64>(), 123456789.12);
-
- let (f, valid) = moderate_path::<f64>(123456789123, -3, false);
- assert!(valid, "should be valid");
- assert_eq!(f.into_float::<f64>(), 123456789.123);
-
- let (f, valid) = moderate_path::<f64>(1234567891234, -4, false);
- assert!(valid, "should be valid");
- assert_eq!(f.into_float::<f64>(), 123456789.1234);
-
- let (f, valid) = moderate_path::<f64>(12345678912345, -5, false);
- assert!(valid, "should be valid");
- assert_eq!(f.into_float::<f64>(), 123456789.12345);
-
- let (f, valid) = moderate_path::<f64>(123456789123456, -6, false);
- assert!(valid, "should be valid");
- assert_eq!(f.into_float::<f64>(), 123456789.123456);
-
- let (f, valid) = moderate_path::<f64>(1234567891234567, -7, false);
- assert!(valid, "should be valid");
- assert_eq!(f.into_float::<f64>(), 123456789.1234567);
-
- let (f, valid) = moderate_path::<f64>(12345678912345679, -8, false);
- assert!(valid, "should be valid");
- assert_eq!(f.into_float::<f64>(), 123456789.12345679);
-
- let (f, valid) = moderate_path::<f64>(4628372940652459, -17, false);
- assert!(valid, "should be valid");
- assert_eq!(f.into_float::<f64>(), 0.04628372940652459);
-
- let (f, valid) = moderate_path::<f64>(26383446160308229, -272, false);
- assert!(valid, "should be valid");
- assert_eq!(f.into_float::<f64>(), 2.6383446160308229e-256);
-
- let (_, valid) = moderate_path::<f64>(26383446160308230, -272, false);
- assert!(!valid, "should be invalid");
-}
diff --git a/vendor/serde_json/tests/lexical/exponent.rs b/vendor/serde_json/tests/lexical/exponent.rs
deleted file mode 100644
index f7a847b..0000000
--- a/vendor/serde_json/tests/lexical/exponent.rs
+++ /dev/null
@@ -1,54 +0,0 @@
-// Adapted from https://github.com/Alexhuszagh/rust-lexical.
-
-use crate::lexical::exponent::*;
-
-#[test]
-fn scientific_exponent_test() {
- // 0 digits in the integer
- assert_eq!(scientific_exponent(0, 0, 5), -6);
- assert_eq!(scientific_exponent(10, 0, 5), 4);
- assert_eq!(scientific_exponent(-10, 0, 5), -16);
-
- // >0 digits in the integer
- assert_eq!(scientific_exponent(0, 1, 5), 0);
- assert_eq!(scientific_exponent(0, 2, 5), 1);
- assert_eq!(scientific_exponent(0, 2, 20), 1);
- assert_eq!(scientific_exponent(10, 2, 20), 11);
- assert_eq!(scientific_exponent(-10, 2, 20), -9);
-
- // Underflow
- assert_eq!(
- scientific_exponent(i32::min_value(), 0, 0),
- i32::min_value()
- );
- assert_eq!(
- scientific_exponent(i32::min_value(), 0, 5),
- i32::min_value()
- );
-
- // Overflow
- assert_eq!(
- scientific_exponent(i32::max_value(), 0, 0),
- i32::max_value() - 1
- );
- assert_eq!(
- scientific_exponent(i32::max_value(), 5, 0),
- i32::max_value()
- );
-}
-
-#[test]
-fn mantissa_exponent_test() {
- assert_eq!(mantissa_exponent(10, 5, 0), 5);
- assert_eq!(mantissa_exponent(0, 5, 0), -5);
- assert_eq!(
- mantissa_exponent(i32::max_value(), 5, 0),
- i32::max_value() - 5
- );
- assert_eq!(mantissa_exponent(i32::max_value(), 0, 5), i32::max_value());
- assert_eq!(mantissa_exponent(i32::min_value(), 5, 0), i32::min_value());
- assert_eq!(
- mantissa_exponent(i32::min_value(), 0, 5),
- i32::min_value() + 5
- );
-}
diff --git a/vendor/serde_json/tests/lexical/float.rs b/vendor/serde_json/tests/lexical/float.rs
deleted file mode 100644
index c87e7e1..0000000
--- a/vendor/serde_json/tests/lexical/float.rs
+++ /dev/null
@@ -1,581 +0,0 @@
-// Adapted from https://github.com/Alexhuszagh/rust-lexical.
-
-use crate::lexical::float::ExtendedFloat;
-use crate::lexical::rounding::round_nearest_tie_even;
-use std::{f32, f64};
-
-// NORMALIZE
-
-fn check_normalize(mant: u64, exp: i32, shift: u32, r_mant: u64, r_exp: i32) {
- let mut x = ExtendedFloat { mant, exp };
- assert_eq!(x.normalize(), shift);
- assert_eq!(
- x,
- ExtendedFloat {
- mant: r_mant,
- exp: r_exp
- }
- );
-}
-
-#[test]
-fn normalize_test() {
- // F32
- // 0
- check_normalize(0, 0, 0, 0, 0);
-
- // min value
- check_normalize(1, -149, 63, 9223372036854775808, -212);
-
- // 1.0e-40
- check_normalize(71362, -149, 47, 10043308644012916736, -196);
-
- // 1.0e-20
- check_normalize(12379400, -90, 40, 13611294244890214400, -130);
-
- // 1.0
- check_normalize(8388608, -23, 40, 9223372036854775808, -63);
-
- // 1e20
- check_normalize(11368684, 43, 40, 12500000250510966784, 3);
-
- // max value
- check_normalize(16777213, 104, 40, 18446740775174668288, 64);
-
- // F64
-
- // min value
- check_normalize(1, -1074, 63, 9223372036854775808, -1137);
-
- // 1.0e-250
- check_normalize(6448907850777164, -883, 11, 13207363278391631872, -894);
-
- // 1.0e-150
- check_normalize(7371020360979573, -551, 11, 15095849699286165504, -562);
-
- // 1.0e-45
- check_normalize(6427752177035961, -202, 11, 13164036458569648128, -213);
-
- // 1.0e-40
- check_normalize(4903985730770844, -185, 11, 10043362776618688512, -196);
-
- // 1.0e-20
- check_normalize(6646139978924579, -119, 11, 13611294676837537792, -130);
-
- // 1.0
- check_normalize(4503599627370496, -52, 11, 9223372036854775808, -63);
-
- // 1e20
- check_normalize(6103515625000000, 14, 11, 12500000000000000000, 3);
-
- // 1e40
- check_normalize(8271806125530277, 80, 11, 16940658945086007296, 69);
-
- // 1e150
- check_normalize(5503284107318959, 446, 11, 11270725851789228032, 435);
-
- // 1e250
- check_normalize(6290184345309700, 778, 11, 12882297539194265600, 767);
-
- // max value
- check_normalize(9007199254740991, 971, 11, 18446744073709549568, 960);
-}
-
-// ROUND
-
-fn check_round_to_f32(mant: u64, exp: i32, r_mant: u64, r_exp: i32) {
- let mut x = ExtendedFloat { mant, exp };
- x.round_to_native::<f32, _>(round_nearest_tie_even);
- assert_eq!(
- x,
- ExtendedFloat {
- mant: r_mant,
- exp: r_exp
- }
- );
-}
-
-#[test]
-fn round_to_f32_test() {
- // This is lossy, so some of these values are **slightly** rounded.
-
- // underflow
- check_round_to_f32(9223372036854775808, -213, 0, -149);
-
- // min value
- check_round_to_f32(9223372036854775808, -212, 1, -149);
-
- // 1.0e-40
- check_round_to_f32(10043308644012916736, -196, 71362, -149);
-
- // 1.0e-20
- check_round_to_f32(13611294244890214400, -130, 12379400, -90);
-
- // 1.0
- check_round_to_f32(9223372036854775808, -63, 8388608, -23);
-
- // 1e20
- check_round_to_f32(12500000250510966784, 3, 11368684, 43);
-
- // max value
- check_round_to_f32(18446740775174668288, 64, 16777213, 104);
-
- // overflow
- check_round_to_f32(18446740775174668288, 65, 16777213, 105);
-}
-
-fn check_round_to_f64(mant: u64, exp: i32, r_mant: u64, r_exp: i32) {
- let mut x = ExtendedFloat { mant, exp };
- x.round_to_native::<f64, _>(round_nearest_tie_even);
- assert_eq!(
- x,
- ExtendedFloat {
- mant: r_mant,
- exp: r_exp
- }
- );
-}
-
-#[test]
-fn round_to_f64_test() {
- // This is lossy, so some of these values are **slightly** rounded.
-
- // underflow
- check_round_to_f64(9223372036854775808, -1138, 0, -1074);
-
- // min value
- check_round_to_f64(9223372036854775808, -1137, 1, -1074);
-
- // 1.0e-250
- check_round_to_f64(15095849699286165504, -562, 7371020360979573, -551);
-
- // 1.0e-150
- check_round_to_f64(15095849699286165504, -562, 7371020360979573, -551);
-
- // 1.0e-45
- check_round_to_f64(13164036458569648128, -213, 6427752177035961, -202);
-
- // 1.0e-40
- check_round_to_f64(10043362776618688512, -196, 4903985730770844, -185);
-
- // 1.0e-20
- check_round_to_f64(13611294676837537792, -130, 6646139978924579, -119);
-
- // 1.0
- check_round_to_f64(9223372036854775808, -63, 4503599627370496, -52);
-
- // 1e20
- check_round_to_f64(12500000000000000000, 3, 6103515625000000, 14);
-
- // 1e40
- check_round_to_f64(16940658945086007296, 69, 8271806125530277, 80);
-
- // 1e150
- check_round_to_f64(11270725851789228032, 435, 5503284107318959, 446);
-
- // 1e250
- check_round_to_f64(12882297539194265600, 767, 6290184345309700, 778);
-
- // max value
- check_round_to_f64(18446744073709549568, 960, 9007199254740991, 971);
-
- // Bug fixes
- // 1.2345e-308
- check_round_to_f64(10234494226754558294, -1086, 2498655817078750, -1074);
-}
-
-fn assert_normalized_eq(mut x: ExtendedFloat, mut y: ExtendedFloat) {
- x.normalize();
- y.normalize();
- assert_eq!(x, y);
-}
-
-#[test]
-fn from_float() {
- let values: [f32; 26] = [
- 1e-40, 2e-40, 1e-35, 2e-35, 1e-30, 2e-30, 1e-25, 2e-25, 1e-20, 2e-20, 1e-15, 2e-15, 1e-10,
- 2e-10, 1e-5, 2e-5, 1.0, 2.0, 1e5, 2e5, 1e10, 2e10, 1e15, 2e15, 1e20, 2e20,
- ];
- for value in &values {
- assert_normalized_eq(
- ExtendedFloat::from_float(*value),
- ExtendedFloat::from_float(*value as f64),
- );
- }
-}
-
-// TO
-
-// Sample of interesting numbers to check during standard test builds.
-const INTEGERS: [u64; 32] = [
- 0, // 0x0
- 1, // 0x1
- 7, // 0x7
- 15, // 0xF
- 112, // 0x70
- 119, // 0x77
- 127, // 0x7F
- 240, // 0xF0
- 247, // 0xF7
- 255, // 0xFF
- 2032, // 0x7F0
- 2039, // 0x7F7
- 2047, // 0x7FF
- 4080, // 0xFF0
- 4087, // 0xFF7
- 4095, // 0xFFF
- 65520, // 0xFFF0
- 65527, // 0xFFF7
- 65535, // 0xFFFF
- 1048560, // 0xFFFF0
- 1048567, // 0xFFFF7
- 1048575, // 0xFFFFF
- 16777200, // 0xFFFFF0
- 16777207, // 0xFFFFF7
- 16777215, // 0xFFFFFF
- 268435440, // 0xFFFFFF0
- 268435447, // 0xFFFFFF7
- 268435455, // 0xFFFFFFF
- 4294967280, // 0xFFFFFFF0
- 4294967287, // 0xFFFFFFF7
- 4294967295, // 0xFFFFFFFF
- 18446744073709551615, // 0xFFFFFFFFFFFFFFFF
-];
-
-#[test]
-fn to_f32_test() {
- // underflow
- let x = ExtendedFloat {
- mant: 9223372036854775808,
- exp: -213,
- };
- assert_eq!(x.into_float::<f32>(), 0.0);
-
- // min value
- let x = ExtendedFloat {
- mant: 9223372036854775808,
- exp: -212,
- };
- assert_eq!(x.into_float::<f32>(), 1e-45);
-
- // 1.0e-40
- let x = ExtendedFloat {
- mant: 10043308644012916736,
- exp: -196,
- };
- assert_eq!(x.into_float::<f32>(), 1e-40);
-
- // 1.0e-20
- let x = ExtendedFloat {
- mant: 13611294244890214400,
- exp: -130,
- };
- assert_eq!(x.into_float::<f32>(), 1e-20);
-
- // 1.0
- let x = ExtendedFloat {
- mant: 9223372036854775808,
- exp: -63,
- };
- assert_eq!(x.into_float::<f32>(), 1.0);
-
- // 1e20
- let x = ExtendedFloat {
- mant: 12500000250510966784,
- exp: 3,
- };
- assert_eq!(x.into_float::<f32>(), 1e20);
-
- // max value
- let x = ExtendedFloat {
- mant: 18446740775174668288,
- exp: 64,
- };
- assert_eq!(x.into_float::<f32>(), 3.402823e38);
-
- // almost max, high exp
- let x = ExtendedFloat {
- mant: 1048575,
- exp: 108,
- };
- assert_eq!(x.into_float::<f32>(), 3.4028204e38);
-
- // max value + 1
- let x = ExtendedFloat {
- mant: 16777216,
- exp: 104,
- };
- assert_eq!(x.into_float::<f32>(), f32::INFINITY);
-
- // max value + 1
- let x = ExtendedFloat {
- mant: 1048576,
- exp: 108,
- };
- assert_eq!(x.into_float::<f32>(), f32::INFINITY);
-
- // 1e40
- let x = ExtendedFloat {
- mant: 16940658945086007296,
- exp: 69,
- };
- assert_eq!(x.into_float::<f32>(), f32::INFINITY);
-
- // Integers.
- for int in &INTEGERS {
- let fp = ExtendedFloat { mant: *int, exp: 0 };
- assert_eq!(fp.into_float::<f32>(), *int as f32, "{:?} as f32", *int);
- }
-}
-
-#[test]
-fn to_f64_test() {
- // underflow
- let x = ExtendedFloat {
- mant: 9223372036854775808,
- exp: -1138,
- };
- assert_eq!(x.into_float::<f64>(), 0.0);
-
- // min value
- let x = ExtendedFloat {
- mant: 9223372036854775808,
- exp: -1137,
- };
- assert_eq!(x.into_float::<f64>(), 5e-324);
-
- // 1.0e-250
- let x = ExtendedFloat {
- mant: 13207363278391631872,
- exp: -894,
- };
- assert_eq!(x.into_float::<f64>(), 1e-250);
-
- // 1.0e-150
- let x = ExtendedFloat {
- mant: 15095849699286165504,
- exp: -562,
- };
- assert_eq!(x.into_float::<f64>(), 1e-150);
-
- // 1.0e-45
- let x = ExtendedFloat {
- mant: 13164036458569648128,
- exp: -213,
- };
- assert_eq!(x.into_float::<f64>(), 1e-45);
-
- // 1.0e-40
- let x = ExtendedFloat {
- mant: 10043362776618688512,
- exp: -196,
- };
- assert_eq!(x.into_float::<f64>(), 1e-40);
-
- // 1.0e-20
- let x = ExtendedFloat {
- mant: 13611294676837537792,
- exp: -130,
- };
- assert_eq!(x.into_float::<f64>(), 1e-20);
-
- // 1.0
- let x = ExtendedFloat {
- mant: 9223372036854775808,
- exp: -63,
- };
- assert_eq!(x.into_float::<f64>(), 1.0);
-
- // 1e20
- let x = ExtendedFloat {
- mant: 12500000000000000000,
- exp: 3,
- };
- assert_eq!(x.into_float::<f64>(), 1e20);
-
- // 1e40
- let x = ExtendedFloat {
- mant: 16940658945086007296,
- exp: 69,
- };
- assert_eq!(x.into_float::<f64>(), 1e40);
-
- // 1e150
- let x = ExtendedFloat {
- mant: 11270725851789228032,
- exp: 435,
- };
- assert_eq!(x.into_float::<f64>(), 1e150);
-
- // 1e250
- let x = ExtendedFloat {
- mant: 12882297539194265600,
- exp: 767,
- };
- assert_eq!(x.into_float::<f64>(), 1e250);
-
- // max value
- let x = ExtendedFloat {
- mant: 9007199254740991,
- exp: 971,
- };
- assert_eq!(x.into_float::<f64>(), 1.7976931348623157e308);
-
- // max value
- let x = ExtendedFloat {
- mant: 18446744073709549568,
- exp: 960,
- };
- assert_eq!(x.into_float::<f64>(), 1.7976931348623157e308);
-
- // overflow
- let x = ExtendedFloat {
- mant: 9007199254740992,
- exp: 971,
- };
- assert_eq!(x.into_float::<f64>(), f64::INFINITY);
-
- // overflow
- let x = ExtendedFloat {
- mant: 18446744073709549568,
- exp: 961,
- };
- assert_eq!(x.into_float::<f64>(), f64::INFINITY);
-
- // Underflow
- // Adapted from failures in strtod.
- let x = ExtendedFloat {
- exp: -1139,
- mant: 18446744073709550712,
- };
- assert_eq!(x.into_float::<f64>(), 0.0);
-
- let x = ExtendedFloat {
- exp: -1139,
- mant: 18446744073709551460,
- };
- assert_eq!(x.into_float::<f64>(), 0.0);
-
- let x = ExtendedFloat {
- exp: -1138,
- mant: 9223372036854776103,
- };
- assert_eq!(x.into_float::<f64>(), 5e-324);
-
- // Integers.
- for int in &INTEGERS {
- let fp = ExtendedFloat { mant: *int, exp: 0 };
- assert_eq!(fp.into_float::<f64>(), *int as f64, "{:?} as f64", *int);
- }
-}
-
-// OPERATIONS
-
-fn check_mul(a: ExtendedFloat, b: ExtendedFloat, c: ExtendedFloat) {
- let r = a.mul(&b);
- assert_eq!(r, c);
-}
-
-#[test]
-fn mul_test() {
- // Normalized (64-bit mantissa)
- let a = ExtendedFloat {
- mant: 13164036458569648128,
- exp: -213,
- };
- let b = ExtendedFloat {
- mant: 9223372036854775808,
- exp: -62,
- };
- let c = ExtendedFloat {
- mant: 6582018229284824064,
- exp: -211,
- };
- check_mul(a, b, c);
-
- // Check with integers
- // 64-bit mantissa
- let mut a = ExtendedFloat { mant: 10, exp: 0 };
- let mut b = ExtendedFloat { mant: 10, exp: 0 };
- a.normalize();
- b.normalize();
- assert_eq!(a.mul(&b).into_float::<f64>(), 100.0);
-
- // Check both values need high bits set.
- let a = ExtendedFloat {
- mant: 1 << 32,
- exp: -31,
- };
- let b = ExtendedFloat {
- mant: 1 << 32,
- exp: -31,
- };
- assert_eq!(a.mul(&b).into_float::<f64>(), 4.0);
-
- // Check both values need high bits set.
- let a = ExtendedFloat {
- mant: 10 << 31,
- exp: -31,
- };
- let b = ExtendedFloat {
- mant: 10 << 31,
- exp: -31,
- };
- assert_eq!(a.mul(&b).into_float::<f64>(), 100.0);
-}
-
-fn check_imul(mut a: ExtendedFloat, b: ExtendedFloat, c: ExtendedFloat) {
- a.imul(&b);
- assert_eq!(a, c);
-}
-
-#[test]
-fn imul_test() {
- // Normalized (64-bit mantissa)
- let a = ExtendedFloat {
- mant: 13164036458569648128,
- exp: -213,
- };
- let b = ExtendedFloat {
- mant: 9223372036854775808,
- exp: -62,
- };
- let c = ExtendedFloat {
- mant: 6582018229284824064,
- exp: -211,
- };
- check_imul(a, b, c);
-
- // Check with integers
- // 64-bit mantissa
- let mut a = ExtendedFloat { mant: 10, exp: 0 };
- let mut b = ExtendedFloat { mant: 10, exp: 0 };
- a.normalize();
- b.normalize();
- a.imul(&b);
- assert_eq!(a.into_float::<f64>(), 100.0);
-
- // Check both values need high bits set.
- let mut a = ExtendedFloat {
- mant: 1 << 32,
- exp: -31,
- };
- let b = ExtendedFloat {
- mant: 1 << 32,
- exp: -31,
- };
- a.imul(&b);
- assert_eq!(a.into_float::<f64>(), 4.0);
-
- // Check both values need high bits set.
- let mut a = ExtendedFloat {
- mant: 10 << 31,
- exp: -31,
- };
- let b = ExtendedFloat {
- mant: 10 << 31,
- exp: -31,
- };
- a.imul(&b);
- assert_eq!(a.into_float::<f64>(), 100.0);
-}
diff --git a/vendor/serde_json/tests/lexical/math.rs b/vendor/serde_json/tests/lexical/math.rs
deleted file mode 100644
index 79d3ef3..0000000
--- a/vendor/serde_json/tests/lexical/math.rs
+++ /dev/null
@@ -1,211 +0,0 @@
-// Adapted from https://github.com/Alexhuszagh/rust-lexical.
-
-use crate::lexical::math::{Limb, Math};
-use std::cmp;
-
-#[derive(Clone, Default)]
-struct Bigint {
- data: Vec<Limb>,
-}
-
-impl Math for Bigint {
- fn data(&self) -> &Vec<Limb> {
- &self.data
- }
-
- fn data_mut(&mut self) -> &mut Vec<Limb> {
- &mut self.data
- }
-}
-
-#[cfg(limb_width_32)]
-pub(crate) fn from_u32(x: &[u32]) -> Vec<Limb> {
- x.iter().cloned().collect()
-}
-
-#[cfg(limb_width_64)]
-pub(crate) fn from_u32(x: &[u32]) -> Vec<Limb> {
- let mut v = Vec::<Limb>::default();
- for xi in x.chunks(2) {
- match xi.len() {
- 1 => v.push(xi[0] as u64),
- 2 => v.push(((xi[1] as u64) << 32) | (xi[0] as u64)),
- _ => unreachable!(),
- }
- }
-
- v
-}
-
-#[test]
-fn compare_test() {
- // Simple
- let x = Bigint {
- data: from_u32(&[1]),
- };
- let y = Bigint {
- data: from_u32(&[2]),
- };
- assert_eq!(x.compare(&y), cmp::Ordering::Less);
- assert_eq!(x.compare(&x), cmp::Ordering::Equal);
- assert_eq!(y.compare(&x), cmp::Ordering::Greater);
-
- // Check asymmetric
- let x = Bigint {
- data: from_u32(&[5, 1]),
- };
- let y = Bigint {
- data: from_u32(&[2]),
- };
- assert_eq!(x.compare(&y), cmp::Ordering::Greater);
- assert_eq!(x.compare(&x), cmp::Ordering::Equal);
- assert_eq!(y.compare(&x), cmp::Ordering::Less);
-
- // Check when we use reverse ordering properly.
- let x = Bigint {
- data: from_u32(&[5, 1, 9]),
- };
- let y = Bigint {
- data: from_u32(&[6, 2, 8]),
- };
- assert_eq!(x.compare(&y), cmp::Ordering::Greater);
- assert_eq!(x.compare(&x), cmp::Ordering::Equal);
- assert_eq!(y.compare(&x), cmp::Ordering::Less);
-
- // Complex scenario, check it properly uses reverse ordering.
- let x = Bigint {
- data: from_u32(&[0, 1, 9]),
- };
- let y = Bigint {
- data: from_u32(&[4294967295, 0, 9]),
- };
- assert_eq!(x.compare(&y), cmp::Ordering::Greater);
- assert_eq!(x.compare(&x), cmp::Ordering::Equal);
- assert_eq!(y.compare(&x), cmp::Ordering::Less);
-}
-
-#[test]
-fn hi64_test() {
- assert_eq!(Bigint::from_u64(0xA).hi64(), (0xA000000000000000, false));
- assert_eq!(Bigint::from_u64(0xAB).hi64(), (0xAB00000000000000, false));
- assert_eq!(
- Bigint::from_u64(0xAB00000000).hi64(),
- (0xAB00000000000000, false)
- );
- assert_eq!(
- Bigint::from_u64(0xA23456789A).hi64(),
- (0xA23456789A000000, false)
- );
-}
-
-#[test]
-fn bit_length_test() {
- let x = Bigint {
- data: from_u32(&[0, 0, 0, 1]),
- };
- assert_eq!(x.bit_length(), 97);
-
- let x = Bigint {
- data: from_u32(&[0, 0, 0, 3]),
- };
- assert_eq!(x.bit_length(), 98);
-
- let x = Bigint {
- data: from_u32(&[1 << 31]),
- };
- assert_eq!(x.bit_length(), 32);
-}
-
-#[test]
-fn iadd_small_test() {
- // Overflow check (single)
- // This should set all the internal data values to 0, the top
- // value to (1<<31), and the bottom value to (4>>1).
- // This is because the max_value + 1 leads to all 0s, we set the
- // topmost bit to 1.
- let mut x = Bigint {
- data: from_u32(&[4294967295]),
- };
- x.iadd_small(5);
- assert_eq!(x.data, from_u32(&[4, 1]));
-
- // No overflow, single value
- let mut x = Bigint {
- data: from_u32(&[5]),
- };
- x.iadd_small(7);
- assert_eq!(x.data, from_u32(&[12]));
-
- // Single carry, internal overflow
- let mut x = Bigint::from_u64(0x80000000FFFFFFFF);
- x.iadd_small(7);
- assert_eq!(x.data, from_u32(&[6, 0x80000001]));
-
- // Double carry, overflow
- let mut x = Bigint::from_u64(0xFFFFFFFFFFFFFFFF);
- x.iadd_small(7);
- assert_eq!(x.data, from_u32(&[6, 0, 1]));
-}
-
-#[test]
-fn imul_small_test() {
- // No overflow check, 1-int.
- let mut x = Bigint {
- data: from_u32(&[5]),
- };
- x.imul_small(7);
- assert_eq!(x.data, from_u32(&[35]));
-
- // No overflow check, 2-ints.
- let mut x = Bigint::from_u64(0x4000000040000);
- x.imul_small(5);
- assert_eq!(x.data, from_u32(&[0x00140000, 0x140000]));
-
- // Overflow, 1 carry.
- let mut x = Bigint {
- data: from_u32(&[0x33333334]),
- };
- x.imul_small(5);
- assert_eq!(x.data, from_u32(&[4, 1]));
-
- // Overflow, 1 carry, internal.
- let mut x = Bigint::from_u64(0x133333334);
- x.imul_small(5);
- assert_eq!(x.data, from_u32(&[4, 6]));
-
- // Overflow, 2 carries.
- let mut x = Bigint::from_u64(0x3333333333333334);
- x.imul_small(5);
- assert_eq!(x.data, from_u32(&[4, 0, 1]));
-}
-
-#[test]
-fn shl_test() {
- // Pattern generated via `''.join(["1" +"0"*i for i in range(20)])`
- let mut big = Bigint {
- data: from_u32(&[0xD2210408]),
- };
- big.ishl(5);
- assert_eq!(big.data, from_u32(&[0x44208100, 0x1A]));
- big.ishl(32);
- assert_eq!(big.data, from_u32(&[0, 0x44208100, 0x1A]));
- big.ishl(27);
- assert_eq!(big.data, from_u32(&[0, 0, 0xD2210408]));
-
- // 96-bits of previous pattern
- let mut big = Bigint {
- data: from_u32(&[0x20020010, 0x8040100, 0xD2210408]),
- };
- big.ishl(5);
- assert_eq!(big.data, from_u32(&[0x400200, 0x802004, 0x44208101, 0x1A]));
- big.ishl(32);
- assert_eq!(
- big.data,
- from_u32(&[0, 0x400200, 0x802004, 0x44208101, 0x1A])
- );
- big.ishl(27);
- assert_eq!(
- big.data,
- from_u32(&[0, 0, 0x20020010, 0x8040100, 0xD2210408])
- );
-}
diff --git a/vendor/serde_json/tests/lexical/num.rs b/vendor/serde_json/tests/lexical/num.rs
deleted file mode 100644
index 1a94be0..0000000
--- a/vendor/serde_json/tests/lexical/num.rs
+++ /dev/null
@@ -1,76 +0,0 @@
-// Adapted from https://github.com/Alexhuszagh/rust-lexical.
-
-use crate::lexical::num::{AsPrimitive, Float, Integer, Number};
-
-fn check_as_primitive<T: AsPrimitive>(t: T) {
- let _: u32 = t.as_u32();
- let _: u64 = t.as_u64();
- let _: u128 = t.as_u128();
- let _: usize = t.as_usize();
- let _: f32 = t.as_f32();
- let _: f64 = t.as_f64();
-}
-
-#[test]
-fn as_primitive_test() {
- check_as_primitive(1u32);
- check_as_primitive(1u64);
- check_as_primitive(1u128);
- check_as_primitive(1usize);
- check_as_primitive(1f32);
- check_as_primitive(1f64);
-}
-
-fn check_number<T: Number>(x: T, y: T) {
- // Copy, partialeq, partialord
- let _ = x;
- assert!(x < y);
- assert!(x != y);
-
- // Operations
- let _ = y + x;
-
- // Conversions already tested.
-}
-
-#[test]
-fn number_test() {
- check_number(1u32, 5);
- check_number(1u64, 5);
- check_number(1u128, 5);
- check_number(1usize, 5);
- check_number(1f32, 5.0);
- check_number(1f64, 5.0);
-}
-
-fn check_integer<T: Integer>(x: T) {
- // Bitwise operations
- let _ = x & T::ZERO;
-}
-
-#[test]
-fn integer_test() {
- check_integer(65u32);
- check_integer(65u64);
- check_integer(65u128);
- check_integer(65usize);
-}
-
-fn check_float<T: Float>(x: T) {
- // Check functions
- let _ = x.pow10(5);
- let _ = x.to_bits();
- assert!(T::from_bits(x.to_bits()) == x);
-
- // Check properties
- let _ = x.to_bits() & T::SIGN_MASK;
- let _ = x.to_bits() & T::EXPONENT_MASK;
- let _ = x.to_bits() & T::HIDDEN_BIT_MASK;
- let _ = x.to_bits() & T::MANTISSA_MASK;
-}
-
-#[test]
-fn float_test() {
- check_float(123f32);
- check_float(123f64);
-}
diff --git a/vendor/serde_json/tests/lexical/parse.rs b/vendor/serde_json/tests/lexical/parse.rs
deleted file mode 100644
index 03ec1a9..0000000
--- a/vendor/serde_json/tests/lexical/parse.rs
+++ /dev/null
@@ -1,204 +0,0 @@
-// Adapted from https://github.com/Alexhuszagh/rust-lexical.
-
-use crate::lexical::num::Float;
-use crate::lexical::{parse_concise_float, parse_truncated_float};
-use core::f64;
-use core::fmt::Debug;
-
-fn check_concise_float<F>(mantissa: u64, exponent: i32, expected: F)
-where
- F: Float + Debug,
-{
- assert_eq!(parse_concise_float::<F>(mantissa, exponent), expected);
-}
-
-fn check_truncated_float<F>(integer: &str, fraction: &str, exponent: i32, expected: F)
-where
- F: Float + Debug,
-{
- let integer = integer.as_bytes();
- let fraction = fraction.as_bytes();
- assert_eq!(
- parse_truncated_float::<F>(integer, fraction, exponent),
- expected,
- );
-}
-
-#[test]
-fn parse_f32_test() {
- check_concise_float(0, 0, 0.0_f32);
- check_concise_float(12345, -4, 1.2345_f32);
- check_concise_float(12345, -3, 12.345_f32);
- check_concise_float(123456789, -4, 12345.6789_f32);
- check_concise_float(12345, 6, 1.2345e10_f32);
- check_concise_float(12345, -42, 1.2345e-38_f32);
-
- // Check expected rounding, using borderline cases.
- // Round-down, halfway
- check_concise_float(16777216, 0, 16777216.0_f32);
- check_concise_float(16777217, 0, 16777216.0_f32);
- check_concise_float(16777218, 0, 16777218.0_f32);
- check_concise_float(33554432, 0, 33554432.0_f32);
- check_concise_float(33554434, 0, 33554432.0_f32);
- check_concise_float(33554436, 0, 33554436.0_f32);
- check_concise_float(17179869184, 0, 17179869184.0_f32);
- check_concise_float(17179870208, 0, 17179869184.0_f32);
- check_concise_float(17179871232, 0, 17179871232.0_f32);
-
- // Round-up, halfway
- check_concise_float(16777218, 0, 16777218.0_f32);
- check_concise_float(16777219, 0, 16777220.0_f32);
- check_concise_float(16777220, 0, 16777220.0_f32);
-
- check_concise_float(33554436, 0, 33554436.0_f32);
- check_concise_float(33554438, 0, 33554440.0_f32);
- check_concise_float(33554440, 0, 33554440.0_f32);
-
- check_concise_float(17179871232, 0, 17179871232.0_f32);
- check_concise_float(17179872256, 0, 17179873280.0_f32);
- check_concise_float(17179873280, 0, 17179873280.0_f32);
-
- // Round-up, above halfway
- check_concise_float(33554435, 0, 33554436.0_f32);
- check_concise_float(17179870209, 0, 17179871232.0_f32);
-
- // Check exactly halfway, round-up at halfway
- check_truncated_float("1", "00000017881393432617187499", 0, 1.0000001_f32);
- check_truncated_float("1", "000000178813934326171875", 0, 1.0000002_f32);
- check_truncated_float("1", "00000017881393432617187501", 0, 1.0000002_f32);
-}
-
-#[test]
-fn parse_f64_test() {
- check_concise_float(0, 0, 0.0_f64);
- check_concise_float(12345, -4, 1.2345_f64);
- check_concise_float(12345, -3, 12.345_f64);
- check_concise_float(123456789, -4, 12345.6789_f64);
- check_concise_float(12345, 6, 1.2345e10_f64);
- check_concise_float(12345, -312, 1.2345e-308_f64);
-
- // Check expected rounding, using borderline cases.
- // Round-down, halfway
- check_concise_float(9007199254740992, 0, 9007199254740992.0_f64);
- check_concise_float(9007199254740993, 0, 9007199254740992.0_f64);
- check_concise_float(9007199254740994, 0, 9007199254740994.0_f64);
-
- check_concise_float(18014398509481984, 0, 18014398509481984.0_f64);
- check_concise_float(18014398509481986, 0, 18014398509481984.0_f64);
- check_concise_float(18014398509481988, 0, 18014398509481988.0_f64);
-
- check_concise_float(9223372036854775808, 0, 9223372036854775808.0_f64);
- check_concise_float(9223372036854776832, 0, 9223372036854775808.0_f64);
- check_concise_float(9223372036854777856, 0, 9223372036854777856.0_f64);
-
- check_truncated_float(
- "11417981541647679048466287755595961091061972992",
- "",
- 0,
- 11417981541647679048466287755595961091061972992.0_f64,
- );
- check_truncated_float(
- "11417981541647680316116887983825362587765178368",
- "",
- 0,
- 11417981541647679048466287755595961091061972992.0_f64,
- );
- check_truncated_float(
- "11417981541647681583767488212054764084468383744",
- "",
- 0,
- 11417981541647681583767488212054764084468383744.0_f64,
- );
-
- // Round-up, halfway
- check_concise_float(9007199254740994, 0, 9007199254740994.0_f64);
- check_concise_float(9007199254740995, 0, 9007199254740996.0_f64);
- check_concise_float(9007199254740996, 0, 9007199254740996.0_f64);
-
- check_concise_float(18014398509481988, 0, 18014398509481988.0_f64);
- check_concise_float(18014398509481990, 0, 18014398509481992.0_f64);
- check_concise_float(18014398509481992, 0, 18014398509481992.0_f64);
-
- check_concise_float(9223372036854777856, 0, 9223372036854777856.0_f64);
- check_concise_float(9223372036854778880, 0, 9223372036854779904.0_f64);
- check_concise_float(9223372036854779904, 0, 9223372036854779904.0_f64);
-
- check_truncated_float(
- "11417981541647681583767488212054764084468383744",
- "",
- 0,
- 11417981541647681583767488212054764084468383744.0_f64,
- );
- check_truncated_float(
- "11417981541647682851418088440284165581171589120",
- "",
- 0,
- 11417981541647684119068688668513567077874794496.0_f64,
- );
- check_truncated_float(
- "11417981541647684119068688668513567077874794496",
- "",
- 0,
- 11417981541647684119068688668513567077874794496.0_f64,
- );
-
- // Round-up, above halfway
- check_concise_float(9223372036854776833, 0, 9223372036854777856.0_f64);
- check_truncated_float(
- "11417981541647680316116887983825362587765178369",
- "",
- 0,
- 11417981541647681583767488212054764084468383744.0_f64,
- );
-
- // Rounding error
- // Adapted from failures in strtod.
- check_concise_float(22250738585072014, -324, 2.2250738585072014e-308_f64);
- check_truncated_float("2", "2250738585072011360574097967091319759348195463516456480234261097248222220210769455165295239081350879141491589130396211068700864386945946455276572074078206217433799881410632673292535522868813721490129811224514518898490572223072852551331557550159143974763979834118019993239625482890171070818506906306666559949382757725720157630626906633326475653000092458883164330377797918696120494973903778297049050510806099407302629371289589500035837999672072543043602840788957717961509455167482434710307026091446215722898802581825451803257070188608721131280795122334262883686223215037756666225039825343359745688844239002654981983854879482922068947216898310996983658468140228542433306603398508864458040010349339704275671864433837704860378616227717385456230658746790140867233276367187499", -308, 2.225073858507201e-308_f64);
- check_truncated_float("2", "22507385850720113605740979670913197593481954635164564802342610972482222202107694551652952390813508791414915891303962110687008643869459464552765720740782062174337998814106326732925355228688137214901298112245145188984905722230728525513315575501591439747639798341180199932396254828901710708185069063066665599493827577257201576306269066333264756530000924588831643303777979186961204949739037782970490505108060994073026293712895895000358379996720725430436028407889577179615094551674824347103070260914462157228988025818254518032570701886087211312807951223342628836862232150377566662250398253433597456888442390026549819838548794829220689472168983109969836584681402285424333066033985088644580400103493397042756718644338377048603786162277173854562306587467901408672332763671875", -308, 2.2250738585072014e-308_f64);
- check_truncated_float("2", "2250738585072011360574097967091319759348195463516456480234261097248222220210769455165295239081350879141491589130396211068700864386945946455276572074078206217433799881410632673292535522868813721490129811224514518898490572223072852551331557550159143974763979834118019993239625482890171070818506906306666559949382757725720157630626906633326475653000092458883164330377797918696120494973903778297049050510806099407302629371289589500035837999672072543043602840788957717961509455167482434710307026091446215722898802581825451803257070188608721131280795122334262883686223215037756666225039825343359745688844239002654981983854879482922068947216898310996983658468140228542433306603398508864458040010349339704275671864433837704860378616227717385456230658746790140867233276367187501", -308, 2.2250738585072014e-308_f64);
- check_truncated_float("179769313486231580793728971405303415079934132710037826936173778980444968292764750946649017977587207096330286416692887910946555547851940402630657488671505820681908902000708383676273854845817711531764475730270069855571366959622842914819860834936475292719074168444365510704342711559699508093042880177904174497791", "9999999999999999999999999999999999999999999999999999999999999999999999", 0, 1.7976931348623157e+308_f64);
- check_truncated_float("7", "4109846876186981626485318930233205854758970392148714663837852375101326090531312779794975454245398856969484704316857659638998506553390969459816219401617281718945106978546710679176872575177347315553307795408549809608457500958111373034747658096871009590975442271004757307809711118935784838675653998783503015228055934046593739791790738723868299395818481660169122019456499931289798411362062484498678713572180352209017023903285791732520220528974020802906854021606612375549983402671300035812486479041385743401875520901590172592547146296175134159774938718574737870961645638908718119841271673056017045493004705269590165763776884908267986972573366521765567941072508764337560846003984904972149117463085539556354188641513168478436313080237596295773983001708984374999", -324, 5.0e-324_f64);
- check_truncated_float("7", "4109846876186981626485318930233205854758970392148714663837852375101326090531312779794975454245398856969484704316857659638998506553390969459816219401617281718945106978546710679176872575177347315553307795408549809608457500958111373034747658096871009590975442271004757307809711118935784838675653998783503015228055934046593739791790738723868299395818481660169122019456499931289798411362062484498678713572180352209017023903285791732520220528974020802906854021606612375549983402671300035812486479041385743401875520901590172592547146296175134159774938718574737870961645638908718119841271673056017045493004705269590165763776884908267986972573366521765567941072508764337560846003984904972149117463085539556354188641513168478436313080237596295773983001708984375", -324, 1.0e-323_f64);
- check_truncated_float("7", "4109846876186981626485318930233205854758970392148714663837852375101326090531312779794975454245398856969484704316857659638998506553390969459816219401617281718945106978546710679176872575177347315553307795408549809608457500958111373034747658096871009590975442271004757307809711118935784838675653998783503015228055934046593739791790738723868299395818481660169122019456499931289798411362062484498678713572180352209017023903285791732520220528974020802906854021606612375549983402671300035812486479041385743401875520901590172592547146296175134159774938718574737870961645638908718119841271673056017045493004705269590165763776884908267986972573366521765567941072508764337560846003984904972149117463085539556354188641513168478436313080237596295773983001708984375001", -324, 1.0e-323_f64);
- check_truncated_float("", "0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000024703282292062327208828439643411068618252990130716238221279284125033775363510437593264991818081799618989828234772285886546332835517796989819938739800539093906315035659515570226392290858392449105184435931802849936536152500319370457678249219365623669863658480757001585769269903706311928279558551332927834338409351978015531246597263579574622766465272827220056374006485499977096599470454020828166226237857393450736339007967761930577506740176324673600968951340535537458516661134223766678604162159680461914467291840300530057530849048765391711386591646239524912623653881879636239373280423891018672348497668235089863388587925628302755995657524455507255189313690836254779186948667994968324049705821028513185451396213837722826145437693412532098591327667236328125", 0, 0.0_f64);
-
- // Rounding error
- // Adapted from:
- // https://www.exploringbinary.com/how-glibc-strtod-works/
- check_truncated_float("", "000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000022250738585072008890245868760858598876504231122409594654935248025624400092282356951787758888037591552642309780950434312085877387158357291821993020294379224223559819827501242041788969571311791082261043971979604000454897391938079198936081525613113376149842043271751033627391549782731594143828136275113838604094249464942286316695429105080201815926642134996606517803095075913058719846423906068637102005108723282784678843631944515866135041223479014792369585208321597621066375401613736583044193603714778355306682834535634005074073040135602968046375918583163124224521599262546494300836851861719422417646455137135420132217031370496583210154654068035397417906022589503023501937519773030945763173210852507299305089761582519159720757232455434770912461317493580281734466552734375", 0, 2.2250738585072011e-308_f64);
-
- // Rounding error
- // Adapted from test-parse-random failures.
- check_concise_float(1009, -31, 1.009e-28_f64);
- check_concise_float(18294, 304, f64::INFINITY);
-
- // Rounding error
- // Adapted from a @dangrabcad's issue #20.
- check_concise_float(7689539722041643, 149, 7.689539722041643e164_f64);
- check_truncated_float("768953972204164300000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "", 0, 7.689539722041643e164_f64);
- check_truncated_float("768953972204164300000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "0", 0, 7.689539722041643e164_f64);
-
- // Check other cases similar to @dangrabcad's issue #20.
- check_truncated_float("9223372036854776833", "0", 0, 9223372036854777856.0_f64);
- check_truncated_float(
- "11417981541647680316116887983825362587765178369",
- "0",
- 0,
- 11417981541647681583767488212054764084468383744.0_f64,
- );
- check_concise_float(90071992547409950, -1, 9007199254740996.0_f64);
- check_concise_float(180143985094819900, -1, 18014398509481992.0_f64);
- check_truncated_float("9223372036854778880", "0", 0, 9223372036854779904.0_f64);
- check_truncated_float(
- "11417981541647682851418088440284165581171589120",
- "0",
- 0,
- 11417981541647684119068688668513567077874794496.0_f64,
- );
-
- // Check other cases ostensibly identified via proptest.
- check_truncated_float("71610528364411830000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "0", 0, 71610528364411830000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0_f64);
- check_truncated_float("126769393745745060000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "0", 0, 126769393745745060000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0_f64);
- check_truncated_float("38652960461239320000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "0", 0, 38652960461239320000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0_f64);
-}
diff --git a/vendor/serde_json/tests/lexical/rounding.rs b/vendor/serde_json/tests/lexical/rounding.rs
deleted file mode 100644
index 7ea1771..0000000
--- a/vendor/serde_json/tests/lexical/rounding.rs
+++ /dev/null
@@ -1,316 +0,0 @@
-// Adapted from https://github.com/Alexhuszagh/rust-lexical.
-
-use crate::lexical::float::ExtendedFloat;
-use crate::lexical::num::Float;
-use crate::lexical::rounding::*;
-
-// MASKS
-
-#[test]
-fn lower_n_mask_test() {
- assert_eq!(lower_n_mask(0u64), 0b0);
- assert_eq!(lower_n_mask(1u64), 0b1);
- assert_eq!(lower_n_mask(2u64), 0b11);
- assert_eq!(lower_n_mask(10u64), 0b1111111111);
- assert_eq!(lower_n_mask(32u64), 0b11111111111111111111111111111111);
-}
-
-#[test]
-fn lower_n_halfway_test() {
- assert_eq!(lower_n_halfway(0u64), 0b0);
- assert_eq!(lower_n_halfway(1u64), 0b1);
- assert_eq!(lower_n_halfway(2u64), 0b10);
- assert_eq!(lower_n_halfway(10u64), 0b1000000000);
- assert_eq!(lower_n_halfway(32u64), 0b10000000000000000000000000000000);
-}
-
-#[test]
-fn nth_bit_test() {
- assert_eq!(nth_bit(0u64), 0b1);
- assert_eq!(nth_bit(1u64), 0b10);
- assert_eq!(nth_bit(2u64), 0b100);
- assert_eq!(nth_bit(10u64), 0b10000000000);
- assert_eq!(nth_bit(31u64), 0b10000000000000000000000000000000);
-}
-
-#[test]
-fn internal_n_mask_test() {
- assert_eq!(internal_n_mask(1u64, 0u64), 0b0);
- assert_eq!(internal_n_mask(1u64, 1u64), 0b1);
- assert_eq!(internal_n_mask(2u64, 1u64), 0b10);
- assert_eq!(internal_n_mask(4u64, 2u64), 0b1100);
- assert_eq!(internal_n_mask(10u64, 2u64), 0b1100000000);
- assert_eq!(internal_n_mask(10u64, 4u64), 0b1111000000);
- assert_eq!(
- internal_n_mask(32u64, 4u64),
- 0b11110000000000000000000000000000
- );
-}
-
-// NEAREST ROUNDING
-
-#[test]
-fn round_nearest_test() {
- // Check exactly halfway (b'1100000')
- let mut fp = ExtendedFloat { mant: 0x60, exp: 0 };
- let (above, halfway) = round_nearest(&mut fp, 6);
- assert!(!above);
- assert!(halfway);
- assert_eq!(fp.mant, 1);
-
- // Check above halfway (b'1100001')
- let mut fp = ExtendedFloat { mant: 0x61, exp: 0 };
- let (above, halfway) = round_nearest(&mut fp, 6);
- assert!(above);
- assert!(!halfway);
- assert_eq!(fp.mant, 1);
-
- // Check below halfway (b'1011111')
- let mut fp = ExtendedFloat { mant: 0x5F, exp: 0 };
- let (above, halfway) = round_nearest(&mut fp, 6);
- assert!(!above);
- assert!(!halfway);
- assert_eq!(fp.mant, 1);
-}
-
-// DIRECTED ROUNDING
-
-#[test]
-fn round_downward_test() {
- // b0000000
- let mut fp = ExtendedFloat { mant: 0x00, exp: 0 };
- round_downward(&mut fp, 6);
- assert_eq!(fp.mant, 0);
-
- // b1000000
- let mut fp = ExtendedFloat { mant: 0x40, exp: 0 };
- round_downward(&mut fp, 6);
- assert_eq!(fp.mant, 1);
-
- // b1100000
- let mut fp = ExtendedFloat { mant: 0x60, exp: 0 };
- round_downward(&mut fp, 6);
- assert_eq!(fp.mant, 1);
-
- // b1110000
- let mut fp = ExtendedFloat { mant: 0x70, exp: 0 };
- round_downward(&mut fp, 6);
- assert_eq!(fp.mant, 1);
-}
-
-#[test]
-fn round_nearest_tie_even_test() {
- // Check round-up, halfway
- let mut fp = ExtendedFloat { mant: 0x60, exp: 0 };
- round_nearest_tie_even(&mut fp, 6);
- assert_eq!(fp.mant, 2);
-
- // Check round-down, halfway
- let mut fp = ExtendedFloat { mant: 0x20, exp: 0 };
- round_nearest_tie_even(&mut fp, 6);
- assert_eq!(fp.mant, 0);
-
- // Check round-up, above halfway
- let mut fp = ExtendedFloat { mant: 0x61, exp: 0 };
- round_nearest_tie_even(&mut fp, 6);
- assert_eq!(fp.mant, 2);
-
- let mut fp = ExtendedFloat { mant: 0x21, exp: 0 };
- round_nearest_tie_even(&mut fp, 6);
- assert_eq!(fp.mant, 1);
-
- // Check round-down, below halfway
- let mut fp = ExtendedFloat { mant: 0x5F, exp: 0 };
- round_nearest_tie_even(&mut fp, 6);
- assert_eq!(fp.mant, 1);
-
- let mut fp = ExtendedFloat { mant: 0x1F, exp: 0 };
- round_nearest_tie_even(&mut fp, 6);
- assert_eq!(fp.mant, 0);
-}
-
-// HIGH-LEVEL
-
-#[test]
-fn round_to_float_test() {
- // Denormal
- let mut fp = ExtendedFloat {
- mant: 1 << 63,
- exp: f64::DENORMAL_EXPONENT - 15,
- };
- round_to_float::<f64, _>(&mut fp, round_nearest_tie_even);
- assert_eq!(fp.mant, 1 << 48);
- assert_eq!(fp.exp, f64::DENORMAL_EXPONENT);
-
- // Halfway, round-down (b'1000000000000000000000000000000000000000000000000000010000000000')
- let mut fp = ExtendedFloat {
- mant: 0x8000000000000400,
- exp: -63,
- };
- round_to_float::<f64, _>(&mut fp, round_nearest_tie_even);
- assert_eq!(fp.mant, 1 << 52);
- assert_eq!(fp.exp, -52);
-
- // Halfway, round-up (b'1000000000000000000000000000000000000000000000000000110000000000')
- let mut fp = ExtendedFloat {
- mant: 0x8000000000000C00,
- exp: -63,
- };
- round_to_float::<f64, _>(&mut fp, round_nearest_tie_even);
- assert_eq!(fp.mant, (1 << 52) + 2);
- assert_eq!(fp.exp, -52);
-
- // Above halfway
- let mut fp = ExtendedFloat {
- mant: 0x8000000000000401,
- exp: -63,
- };
- round_to_float::<f64, _>(&mut fp, round_nearest_tie_even);
- assert_eq!(fp.mant, (1 << 52) + 1);
- assert_eq!(fp.exp, -52);
-
- let mut fp = ExtendedFloat {
- mant: 0x8000000000000C01,
- exp: -63,
- };
- round_to_float::<f64, _>(&mut fp, round_nearest_tie_even);
- assert_eq!(fp.mant, (1 << 52) + 2);
- assert_eq!(fp.exp, -52);
-
- // Below halfway
- let mut fp = ExtendedFloat {
- mant: 0x80000000000003FF,
- exp: -63,
- };
- round_to_float::<f64, _>(&mut fp, round_nearest_tie_even);
- assert_eq!(fp.mant, 1 << 52);
- assert_eq!(fp.exp, -52);
-
- let mut fp = ExtendedFloat {
- mant: 0x8000000000000BFF,
- exp: -63,
- };
- round_to_float::<f64, _>(&mut fp, round_nearest_tie_even);
- assert_eq!(fp.mant, (1 << 52) + 1);
- assert_eq!(fp.exp, -52);
-}
-
-#[test]
-fn avoid_overflow_test() {
- // Avoid overflow, fails by 1
- let mut fp = ExtendedFloat {
- mant: 0xFFFFFFFFFFFF,
- exp: f64::MAX_EXPONENT + 5,
- };
- avoid_overflow::<f64>(&mut fp);
- assert_eq!(fp.mant, 0xFFFFFFFFFFFF);
- assert_eq!(fp.exp, f64::MAX_EXPONENT + 5);
-
- // Avoid overflow, succeeds
- let mut fp = ExtendedFloat {
- mant: 0xFFFFFFFFFFFF,
- exp: f64::MAX_EXPONENT + 4,
- };
- avoid_overflow::<f64>(&mut fp);
- assert_eq!(fp.mant, 0x1FFFFFFFFFFFE0);
- assert_eq!(fp.exp, f64::MAX_EXPONENT - 1);
-}
-
-#[test]
-fn round_to_native_test() {
- // Overflow
- let mut fp = ExtendedFloat {
- mant: 0xFFFFFFFFFFFF,
- exp: f64::MAX_EXPONENT + 4,
- };
- round_to_native::<f64, _>(&mut fp, round_nearest_tie_even);
- assert_eq!(fp.mant, 0x1FFFFFFFFFFFE0);
- assert_eq!(fp.exp, f64::MAX_EXPONENT - 1);
-
- // Need denormal
- let mut fp = ExtendedFloat {
- mant: 1,
- exp: f64::DENORMAL_EXPONENT + 48,
- };
- round_to_native::<f64, _>(&mut fp, round_nearest_tie_even);
- assert_eq!(fp.mant, 1 << 48);
- assert_eq!(fp.exp, f64::DENORMAL_EXPONENT);
-
- // Halfway, round-down (b'10000000000000000000000000000000000000000000000000000100000')
- let mut fp = ExtendedFloat {
- mant: 0x400000000000020,
- exp: -58,
- };
- round_to_native::<f64, _>(&mut fp, round_nearest_tie_even);
- assert_eq!(fp.mant, 1 << 52);
- assert_eq!(fp.exp, -52);
-
- // Halfway, round-up (b'10000000000000000000000000000000000000000000000000001100000')
- let mut fp = ExtendedFloat {
- mant: 0x400000000000060,
- exp: -58,
- };
- round_to_native::<f64, _>(&mut fp, round_nearest_tie_even);
- assert_eq!(fp.mant, (1 << 52) + 2);
- assert_eq!(fp.exp, -52);
-
- // Above halfway
- let mut fp = ExtendedFloat {
- mant: 0x400000000000021,
- exp: -58,
- };
- round_to_native::<f64, _>(&mut fp, round_nearest_tie_even);
- assert_eq!(fp.mant, (1 << 52) + 1);
- assert_eq!(fp.exp, -52);
-
- let mut fp = ExtendedFloat {
- mant: 0x400000000000061,
- exp: -58,
- };
- round_to_native::<f64, _>(&mut fp, round_nearest_tie_even);
- assert_eq!(fp.mant, (1 << 52) + 2);
- assert_eq!(fp.exp, -52);
-
- // Below halfway
- let mut fp = ExtendedFloat {
- mant: 0x40000000000001F,
- exp: -58,
- };
- round_to_native::<f64, _>(&mut fp, round_nearest_tie_even);
- assert_eq!(fp.mant, 1 << 52);
- assert_eq!(fp.exp, -52);
-
- let mut fp = ExtendedFloat {
- mant: 0x40000000000005F,
- exp: -58,
- };
- round_to_native::<f64, _>(&mut fp, round_nearest_tie_even);
- assert_eq!(fp.mant, (1 << 52) + 1);
- assert_eq!(fp.exp, -52);
-
- // Underflow
- // Adapted from failures in strtod.
- let mut fp = ExtendedFloat {
- exp: -1139,
- mant: 18446744073709550712,
- };
- round_to_native::<f64, _>(&mut fp, round_nearest_tie_even);
- assert_eq!(fp.mant, 0);
- assert_eq!(fp.exp, 0);
-
- let mut fp = ExtendedFloat {
- exp: -1139,
- mant: 18446744073709551460,
- };
- round_to_native::<f64, _>(&mut fp, round_nearest_tie_even);
- assert_eq!(fp.mant, 0);
- assert_eq!(fp.exp, 0);
-
- let mut fp = ExtendedFloat {
- exp: -1138,
- mant: 9223372036854776103,
- };
- round_to_native::<f64, _>(&mut fp, round_nearest_tie_even);
- assert_eq!(fp.mant, 1);
- assert_eq!(fp.exp, -1074);
-}