1 files changed, 0 insertions, 316 deletions
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);
-}