Deleted vendor folder

1 files changed, 0 insertions, 211 deletions

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])
-    );
-}