Initial vendor packages

Signed-off-by: Valentin Popov <valentin@popov.link>

1 files changed, 316 insertions, 0 deletions

diff --git a/vendor/serde_json/tests/lexical/rounding.rs b/vendor/serde_json/tests/lexical/rounding.rs
new file mode 100644
index 0000000..7ea1771
--- /dev/null
+++ b/vendor/serde_json/tests/lexical/rounding.rs
@@ -0,0 +1,316 @@
+// 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);
+}