Initial vendor packages

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

7 files changed, 1552 insertions, 0 deletions

diff --git a/vendor/serde_json/tests/lexical/algorithm.rs b/vendor/serde_json/tests/lexical/algorithm.rs
new file mode 100644
index 0000000..7f3a2c6
--- /dev/null
+++ b/vendor/serde_json/tests/lexical/algorithm.rs
@@ -0,0 +1,110 @@
+// 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
new file mode 100644
index 0000000..f7a847b
--- /dev/null
+++ b/vendor/serde_json/tests/lexical/exponent.rs
@@ -0,0 +1,54 @@
+// 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
new file mode 100644
index 0000000..c87e7e1
--- /dev/null
+++ b/vendor/serde_json/tests/lexical/float.rs
@@ -0,0 +1,581 @@
+// 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
new file mode 100644
index 0000000..79d3ef3
--- /dev/null
+++ b/vendor/serde_json/tests/lexical/math.rs
@@ -0,0 +1,211 @@
+// 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
new file mode 100644
index 0000000..1a94be0
--- /dev/null
+++ b/vendor/serde_json/tests/lexical/num.rs
@@ -0,0 +1,76 @@
+// 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
new file mode 100644
index 0000000..03ec1a9
--- /dev/null
+++ b/vendor/serde_json/tests/lexical/parse.rs
@@ -0,0 +1,204 @@
+// 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
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);
+}