wasmtime 20.0.2 → 21.0.1

data/ext/cargo-vendor/bincode-1.3.3/tests/test.rs

@@ -1,899 +0,0 @@
-#[macro_use]
-extern crate serde_derive;
-
-extern crate bincode;
-#[macro_use]
-extern crate serde;
-extern crate serde_bytes;
-
-use std::borrow::Cow;
-use std::collections::HashMap;
-use std::fmt::{self, Debug};
-use std::result::Result as StdResult;
-
-use bincode::{
-    deserialize, deserialize_from, deserialize_in_place, serialize, serialized_size,
-    DefaultOptions, ErrorKind, Options, Result,
-};
-use serde::de::{Deserialize, DeserializeSeed, Deserializer, SeqAccess, Visitor};
-
-const LEN_SIZE: u64 = 8;
-
-fn the_same_impl<V, O>(element: V, options: &mut O)
-where
-    V: serde::Serialize + serde::de::DeserializeOwned + PartialEq + Debug + 'static,
-    O: Options,
-{
-    let size = options.serialized_size(&element).unwrap();
-
-    {
-        let encoded = options.serialize(&element).unwrap();
-        let decoded: V = options.deserialize(&encoded[..]).unwrap();
-        let decoded_reader = options.deserialize_from(&mut &encoded[..]).unwrap();
-
-        assert_eq!(element, decoded);
-        assert_eq!(element, decoded_reader);
-        assert_eq!(size, encoded.len() as u64);
-    }
-}
-
-fn the_same<V>(element: V)
-where
-    V: serde::Serialize + serde::de::DeserializeOwned + PartialEq + Debug + Clone + 'static,
-{
-    // add a new macro which calls the previous when you add a new option set
-    macro_rules! all_endians {
-        ($element:expr, $options:expr) => {
-            the_same_impl($element.clone(), &mut $options.with_native_endian());
-            the_same_impl($element.clone(), &mut $options.with_big_endian());
-            the_same_impl($element.clone(), &mut $options.with_little_endian());
-        };
-    }
-
-    macro_rules! all_integer_encodings {
-        ($element:expr, $options:expr) => {
-            all_endians!($element, $options.with_fixint_encoding());
-            all_endians!($element, $options.with_varint_encoding());
-        };
-    }
-
-    all_integer_encodings!(element, DefaultOptions::new());
-}
-
-#[test]
-fn test_numbers() {
-    // unsigned positive
-    the_same(5u8);
-    the_same(5u16);
-    the_same(5u32);
-    the_same(5u64);
-    the_same(5usize);
-    // signed positive
-    the_same(5i8);
-    the_same(5i16);
-    the_same(5i32);
-    the_same(5i64);
-    the_same(5isize);
-    // signed negative
-    the_same(-5i8);
-    the_same(-5i16);
-    the_same(-5i32);
-    the_same(-5i64);
-    the_same(-5isize);
-    // floating
-    the_same(-100f32);
-    the_same(0f32);
-    the_same(5f32);
-    the_same(-100f64);
-    the_same(5f64);
-}
-
-serde_if_integer128! {
-    #[test]
-    fn test_numbers_128bit() {
-        // unsigned positive
-        the_same(5u128);
-        the_same(u128::max_value());
-        // signed positive
-        the_same(5i128);
-        the_same(i128::max_value());
-        // signed negative
-        the_same(-5i128);
-        the_same(i128::min_value());
-    }
-}
-
-#[test]
-fn test_string() {
-    the_same("".to_string());
-    the_same("a".to_string());
-}
-
-#[test]
-fn test_tuple() {
-    the_same((1isize,));
-    the_same((1isize, 2isize, 3isize));
-    the_same((1isize, "foo".to_string(), ()));
-}
-
-#[test]
-fn test_basic_struct() {
-    #[derive(Serialize, Deserialize, PartialEq, Debug, Clone)]
-    struct Easy {
-        x: isize,
-        s: String,
-        y: usize,
-    }
-    the_same(Easy {
-        x: -4,
-        s: "foo".to_string(),
-        y: 10,
-    });
-}
-
-#[test]
-fn test_nested_struct() {
-    #[derive(Serialize, Deserialize, PartialEq, Debug, Clone)]
-    struct Easy {
-        x: isize,
-        s: String,
-        y: usize,
-    }
-    #[derive(Serialize, Deserialize, PartialEq, Debug, Clone)]
-    struct Nest {
-        f: Easy,
-        b: usize,
-        s: Easy,
-    }
-
-    the_same(Nest {
-        f: Easy {
-            x: -1,
-            s: "foo".to_string(),
-            y: 20,
-        },
-        b: 100,
-        s: Easy {
-            x: -100,
-            s: "bar".to_string(),
-            y: 20,
-        },
-    });
-}
-
-#[test]
-fn test_struct_newtype() {
-    #[derive(Serialize, Deserialize, PartialEq, Debug, Clone)]
-    struct NewtypeStr(usize);
-
-    the_same(NewtypeStr(5));
-}
-
-#[test]
-fn test_struct_tuple() {
-    #[derive(Serialize, Deserialize, PartialEq, Debug, Clone)]
-    struct TubStr(usize, String, f32);
-
-    the_same(TubStr(5, "hello".to_string(), 3.2));
-}
-
-#[test]
-fn test_option() {
-    the_same(Some(5usize));
-    the_same(Some("foo bar".to_string()));
-    the_same(None::<usize>);
-}
-
-#[test]
-fn test_enum() {
-    #[derive(Serialize, Deserialize, PartialEq, Debug, Clone)]
-    enum TestEnum {
-        NoArg,
-        OneArg(usize),
-        Args(usize, usize),
-        AnotherNoArg,
-        StructLike { x: usize, y: f32 },
-    }
-    the_same(TestEnum::NoArg);
-    the_same(TestEnum::OneArg(4));
-    //the_same(TestEnum::Args(4, 5));
-    the_same(TestEnum::AnotherNoArg);
-    the_same(TestEnum::StructLike { x: 4, y: 3.14159 });
-    the_same(vec![
-        TestEnum::NoArg,
-        TestEnum::OneArg(5),
-        TestEnum::AnotherNoArg,
-        TestEnum::StructLike { x: 4, y: 1.4 },
-    ]);
-}
-
-#[test]
-fn test_vec() {
-    let v: Vec<u8> = vec![];
-    the_same(v);
-    the_same(vec![1u64]);
-    the_same(vec![1u64, 2, 3, 4, 5, 6]);
-}
-
-#[test]
-fn test_map() {
-    let mut m = HashMap::new();
-    m.insert(4u64, "foo".to_string());
-    m.insert(0u64, "bar".to_string());
-    the_same(m);
-}
-
-#[test]
-fn test_bool() {
-    the_same(true);
-    the_same(false);
-}
-
-#[test]
-fn test_unicode() {
-    the_same("å".to_string());
-    the_same("aåååååååa".to_string());
-}
-
-#[test]
-fn test_fixed_size_array() {
-    the_same([24u32; 32]);
-    the_same([1u64, 2, 3, 4, 5, 6, 7, 8]);
-    the_same([0u8; 19]);
-}
-
-#[test]
-fn deserializing_errors() {
-    match *deserialize::<bool>(&vec![0xA][..]).unwrap_err() {
-        ErrorKind::InvalidBoolEncoding(0xA) => {}
-        _ => panic!(),
-    }
-
-    let invalid_str = vec![1, 0, 0, 0, 0, 0, 0, 0, 0xFF];
-
-    match *deserialize::<String>(&invalid_str[..]).unwrap_err() {
-        ErrorKind::InvalidUtf8Encoding(_) => {}
-        _ => panic!(),
-    }
-
-    // Out-of-bounds variant
-    #[derive(Serialize, Deserialize, Debug)]
-    enum Test {
-        One,
-        Two,
-    };
-
-    let invalid_enum = vec![0, 0, 0, 5];
-
-    match *deserialize::<Test>(&invalid_enum[..]).unwrap_err() {
-        // Error message comes from serde
-        ErrorKind::Custom(_) => {}
-        _ => panic!(),
-    }
-    match *deserialize::<Option<u8>>(&vec![5, 0][..]).unwrap_err() {
-        ErrorKind::InvalidTagEncoding(_) => {}
-        _ => panic!(),
-    }
-}
-
-#[test]
-fn trailing_bytes() {
-    match DefaultOptions::new()
-        .deserialize::<char>(b"1x")
-        .map_err(|e| *e)
-    {
-        Err(ErrorKind::Custom(_)) => {}
-        other => panic!("Expecting TrailingBytes, got {:?}", other),
-    }
-}
-
-#[test]
-fn too_big_deserialize() {
-    let serialized = vec![0, 0, 0, 3];
-    let deserialized: Result<u32> = DefaultOptions::new()
-        .with_fixint_encoding()
-        .with_limit(3)
-        .deserialize_from(&mut &serialized[..]);
-    assert!(deserialized.is_err());
-
-    let serialized = vec![0, 0, 0, 3];
-    let deserialized: Result<u32> = DefaultOptions::new()
-        .with_fixint_encoding()
-        .with_limit(4)
-        .deserialize_from(&mut &serialized[..]);
-    assert!(deserialized.is_ok());
-}
-
-#[test]
-fn char_serialization() {
-    let chars = "Aa\0☺♪";
-    for c in chars.chars() {
-        let encoded = DefaultOptions::new()
-            .with_limit(4)
-            .serialize(&c)
-            .expect("serializing char failed");
-        let decoded: char = deserialize(&encoded).expect("deserializing failed");
-        assert_eq!(decoded, c);
-    }
-}
-
-#[test]
-fn too_big_char_deserialize() {
-    let serialized = vec![0x41];
-    let deserialized: Result<char> = DefaultOptions::new()
-        .with_limit(1)
-        .deserialize_from(&mut &serialized[..]);
-    assert!(deserialized.is_ok());
-    assert_eq!(deserialized.unwrap(), 'A');
-}
-
-#[test]
-fn too_big_serialize() {
-    assert!(DefaultOptions::new()
-        .with_fixint_encoding()
-        .with_limit(3)
-        .serialize(&0u32)
-        .is_err());
-    assert!(DefaultOptions::new()
-        .with_fixint_encoding()
-        .with_limit(4)
-        .serialize(&0u32)
-        .is_ok());
-
-    assert!(DefaultOptions::new()
-        .with_fixint_encoding()
-        .with_limit(LEN_SIZE + 4)
-        .serialize(&"abcde")
-        .is_err());
-    assert!(DefaultOptions::new()
-        .with_fixint_encoding()
-        .with_limit(LEN_SIZE + 5)
-        .serialize(&"abcde")
-        .is_ok());
-}
-
-#[test]
-fn test_serialized_size() {
-    assert!(serialized_size(&0u8).unwrap() == 1);
-    assert!(serialized_size(&0u16).unwrap() == 2);
-    assert!(serialized_size(&0u32).unwrap() == 4);
-    assert!(serialized_size(&0u64).unwrap() == 8);
-
-    // length isize stored as u64
-    assert!(serialized_size(&"").unwrap() == LEN_SIZE);
-    assert!(serialized_size(&"a").unwrap() == LEN_SIZE + 1);
-
-    assert!(serialized_size(&vec![0u32, 1u32, 2u32]).unwrap() == LEN_SIZE + 3 * (4));
-}
-
-#[test]
-fn test_serialized_size_bounded() {
-    // JUST RIGHT
-    assert!(
-        DefaultOptions::new()
-            .with_fixint_encoding()
-            .with_limit(1)
-            .serialized_size(&0u8)
-            .unwrap()
-            == 1
-    );
-    assert!(
-        DefaultOptions::new()
-            .with_fixint_encoding()
-            .with_limit(2)
-            .serialized_size(&0u16)
-            .unwrap()
-            == 2
-    );
-    assert!(
-        DefaultOptions::new()
-            .with_fixint_encoding()
-            .with_limit(4)
-            .serialized_size(&0u32)
-            .unwrap()
-            == 4
-    );
-    assert!(
-        DefaultOptions::new()
-            .with_fixint_encoding()
-            .with_limit(8)
-            .serialized_size(&0u64)
-            .unwrap()
-            == 8
-    );
-    assert!(
-        DefaultOptions::new()
-            .with_fixint_encoding()
-            .with_limit(8)
-            .serialized_size(&"")
-            .unwrap()
-            == LEN_SIZE
-    );
-    assert!(
-        DefaultOptions::new()
-            .with_fixint_encoding()
-            .with_limit(8 + 1)
-            .serialized_size(&"a")
-            .unwrap()
-            == LEN_SIZE + 1
-    );
-    assert!(
-        DefaultOptions::new()
-            .with_fixint_encoding()
-            .with_limit(LEN_SIZE + 3 * 4)
-            .serialized_size(&vec![0u32, 1u32, 2u32])
-            .unwrap()
-            == LEN_SIZE + 3 * 4
-    );
-    // Below
-    assert!(DefaultOptions::new()
-        .with_fixint_encoding()
-        .with_limit(0)
-        .serialized_size(&0u8)
-        .is_err());
-    assert!(DefaultOptions::new()
-        .with_fixint_encoding()
-        .with_limit(1)
-        .serialized_size(&0u16)
-        .is_err());
-    assert!(DefaultOptions::new()
-        .with_fixint_encoding()
-        .with_limit(3)
-        .serialized_size(&0u32)
-        .is_err());
-    assert!(DefaultOptions::new()
-        .with_fixint_encoding()
-        .with_limit(7)
-        .serialized_size(&0u64)
-        .is_err());
-    assert!(DefaultOptions::new()
-        .with_fixint_encoding()
-        .with_limit(7)
-        .serialized_size(&"")
-        .is_err());
-    assert!(DefaultOptions::new()
-        .with_fixint_encoding()
-        .with_limit(8 + 0)
-        .serialized_size(&"a")
-        .is_err());
-    assert!(DefaultOptions::new()
-        .with_fixint_encoding()
-        .with_limit(8 + 3 * 4 - 1)
-        .serialized_size(&vec![0u32, 1u32, 2u32])
-        .is_err());
-}
-
-#[test]
-fn encode_box() {
-    the_same(Box::new(5));
-}
-
-#[test]
-fn test_cow_serialize() {
-    let large_object = vec![1u32, 2, 3, 4, 5, 6];
-    let mut large_map = HashMap::new();
-    large_map.insert(1, 2);
-
-    #[derive(Serialize, Deserialize, Debug)]
-    enum Message<'a> {
-        M1(Cow<'a, Vec<u32>>),
-        M2(Cow<'a, HashMap<u32, u32>>),
-    }
-
-    // Test 1
-    {
-        let serialized = serialize(&Message::M1(Cow::Borrowed(&large_object))).unwrap();
-        let deserialized: Message<'static> = deserialize_from(&mut &serialized[..]).unwrap();
-
-        match deserialized {
-            Message::M1(b) => assert!(&b.into_owned() == &large_object),
-            _ => assert!(false),
-        }
-    }
-
-    // Test 2
-    {
-        let serialized = serialize(&Message::M2(Cow::Borrowed(&large_map))).unwrap();
-        let deserialized: Message<'static> = deserialize_from(&mut &serialized[..]).unwrap();
-
-        match deserialized {
-            Message::M2(b) => assert!(&b.into_owned() == &large_map),
-            _ => assert!(false),
-        }
-    }
-}
-
-#[test]
-fn test_strbox_serialize() {
-    let strx: &'static str = "hello world";
-    let serialized = serialize(&Cow::Borrowed(strx)).unwrap();
-    let deserialized: Cow<'static, String> = deserialize_from(&mut &serialized[..]).unwrap();
-    let stringx: String = deserialized.into_owned();
-    assert!(strx == &stringx[..]);
-}
-
-#[test]
-fn test_slicebox_serialize() {
-    let slice = [1u32, 2, 3, 4, 5];
-    let serialized = serialize(&Cow::Borrowed(&slice[..])).unwrap();
-    println!("{:?}", serialized);
-    let deserialized: Cow<'static, Vec<u32>> = deserialize_from(&mut &serialized[..]).unwrap();
-    {
-        let sb: &[u32] = &deserialized;
-        assert!(slice == sb);
-    }
-    let vecx: Vec<u32> = deserialized.into_owned();
-    assert!(slice == &vecx[..]);
-}
-
-#[test]
-fn test_multi_strings_serialize() {
-    assert!(serialize(&("foo", "bar", "baz")).is_ok());
-}
-
-#[test]
-fn test_oom_protection() {
-    use std::io::Cursor;
-    #[derive(Serialize, Deserialize, PartialEq, Debug)]
-    struct FakeVec {
-        len: u64,
-        byte: u8,
-    }
-    let x = DefaultOptions::new()
-        .with_limit(10)
-        .serialize(&FakeVec {
-            len: 0xffffffffffffffffu64,
-            byte: 1,
-        })
-        .unwrap();
-    let y: Result<Vec<u8>> = DefaultOptions::new()
-        .with_limit(10)
-        .deserialize_from(&mut Cursor::new(&x[..]));
-    assert!(y.is_err());
-}
-
-#[test]
-fn path_buf() {
-    use std::path::{Path, PathBuf};
-    let path = Path::new("foo").to_path_buf();
-    let serde_encoded = serialize(&path).unwrap();
-    let decoded: PathBuf = deserialize(&serde_encoded).unwrap();
-    assert!(path.to_str() == decoded.to_str());
-}
-
-#[test]
-fn bytes() {
-    use serde_bytes::Bytes;
-
-    let data = b"abc\0123";
-    let s = serialize(&data[..]).unwrap();
-    let s2 = serialize(&Bytes::new(data)).unwrap();
-    assert_eq!(s[..], s2[..]);
-}
-
-#[test]
-fn serde_bytes() {
-    use serde_bytes::ByteBuf;
-    the_same(ByteBuf::from(vec![1, 2, 3, 4, 5]));
-}
-
-#[test]
-fn endian_difference() {
-    let x = 10u64;
-    let little = serialize(&x).unwrap();
-    let big = DefaultOptions::new()
-        .with_big_endian()
-        .serialize(&x)
-        .unwrap();
-    assert_ne!(little, big);
-}
-
-#[test]
-fn test_zero_copy_parse() {
-    #[derive(Serialize, Deserialize, Eq, PartialEq, Debug)]
-    struct Foo<'a> {
-        borrowed_str: &'a str,
-        borrowed_bytes: &'a [u8],
-    }
-
-    let f = Foo {
-        borrowed_str: "hi",
-        borrowed_bytes: &[0, 1, 2, 3],
-    };
-    {
-        let encoded = serialize(&f).unwrap();
-        let out: Foo = deserialize(&encoded[..]).unwrap();
-        assert_eq!(out, f);
-    }
-}
-
-#[test]
-fn test_zero_copy_parse_deserialize_into() {
-    use bincode::BincodeRead;
-    use std::io;
-
-    /// A BincodeRead implementation for byte slices
-    pub struct SliceReader<'storage> {
-        slice: &'storage [u8],
-    }
-
-    impl<'storage> SliceReader<'storage> {
-        #[inline(always)]
-        fn unexpected_eof() -> Box<::ErrorKind> {
-            return Box::new(::ErrorKind::Io(io::Error::new(
-                io::ErrorKind::UnexpectedEof,
-                "",
-            )));
-        }
-    }
-
-    impl<'storage> io::Read for SliceReader<'storage> {
-        #[inline(always)]
-        fn read(&mut self, out: &mut [u8]) -> io::Result<usize> {
-            (&mut self.slice).read(out)
-        }
-        #[inline(always)]
-        fn read_exact(&mut self, out: &mut [u8]) -> io::Result<()> {
-            (&mut self.slice).read_exact(out)
-        }
-    }
-
-    impl<'storage> BincodeRead<'storage> for SliceReader<'storage> {
-        #[inline(always)]
-        fn forward_read_str<V>(&mut self, length: usize, visitor: V) -> Result<V::Value>
-        where
-            V: serde::de::Visitor<'storage>,
-        {
-            use ErrorKind;
-            if length > self.slice.len() {
-                return Err(SliceReader::unexpected_eof());
-            }
-
-            let string = match ::std::str::from_utf8(&self.slice[..length]) {
-                Ok(s) => s,
-                Err(e) => return Err(ErrorKind::InvalidUtf8Encoding(e).into()),
-            };
-            let r = visitor.visit_borrowed_str(string);
-            self.slice = &self.slice[length..];
-            r
-        }
-
-        #[inline(always)]
-        fn get_byte_buffer(&mut self, length: usize) -> Result<Vec<u8>> {
-            if length > self.slice.len() {
-                return Err(SliceReader::unexpected_eof());
-            }
-
-            let r = &self.slice[..length];
-            self.slice = &self.slice[length..];
-            Ok(r.to_vec())
-        }
-
-        #[inline(always)]
-        fn forward_read_bytes<V>(&mut self, length: usize, visitor: V) -> Result<V::Value>
-        where
-            V: serde::de::Visitor<'storage>,
-        {
-            if length > self.slice.len() {
-                return Err(SliceReader::unexpected_eof());
-            }
-
-            let r = visitor.visit_borrowed_bytes(&self.slice[..length]);
-            self.slice = &self.slice[length..];
-            r
-        }
-    }
-
-    #[derive(Serialize, Deserialize, Eq, PartialEq, Debug)]
-    struct Foo<'a> {
-        borrowed_str: &'a str,
-        borrowed_bytes: &'a [u8],
-    }
-
-    let f = Foo {
-        borrowed_str: "hi",
-        borrowed_bytes: &[0, 1, 2, 3],
-    };
-
-    {
-        let encoded = serialize(&f).unwrap();
-        let mut target = Foo {
-            borrowed_str: "hello",
-            borrowed_bytes: &[10, 11, 12, 13],
-        };
-        deserialize_in_place(
-            SliceReader {
-                slice: &encoded[..],
-            },
-            &mut target,
-        )
-        .unwrap();
-        assert_eq!(target, f);
-    }
-}
-
-#[test]
-fn not_human_readable() {
-    use std::net::Ipv4Addr;
-    let ip = Ipv4Addr::new(1, 2, 3, 4);
-    the_same(ip);
-    assert_eq!(&ip.octets()[..], &serialize(&ip).unwrap()[..]);
-    assert_eq!(
-        ::std::mem::size_of::<Ipv4Addr>() as u64,
-        serialized_size(&ip).unwrap()
-    );
-}
-
-// The example is taken from serde::de::DeserializeSeed.
-struct ExtendVec<'a, T: 'a>(&'a mut Vec<T>);
-
-impl<'de, 'a, T> DeserializeSeed<'de> for ExtendVec<'a, T>
-where
-    T: Deserialize<'de>,
-{
-    // The return type of the `deserialize` method. This implementation
-    // appends onto an existing vector but does not create any new data
-    // structure, so the return type is ().
-    type Value = ();
-
-    fn deserialize<D>(self, deserializer: D) -> StdResult<Self::Value, D::Error>
-    where
-        D: Deserializer<'de>,
-    {
-        // Visitor implementation that will walk an inner array of the JSON
-        // input.
-        struct ExtendVecVisitor<'a, T: 'a>(&'a mut Vec<T>);
-
-        impl<'de, 'a, T> Visitor<'de> for ExtendVecVisitor<'a, T>
-        where
-            T: Deserialize<'de>,
-        {
-            type Value = ();
-
-            fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-                write!(formatter, "an array of integers")
-            }
-
-            fn visit_seq<A>(self, mut seq: A) -> StdResult<(), A::Error>
-            where
-                A: SeqAccess<'de>,
-            {
-                // Visit each element in the inner array and push it onto
-                // the existing vector.
-                while let Some(elem) = seq.next_element()? {
-                    self.0.push(elem);
-                }
-                Ok(())
-            }
-        }
-
-        deserializer.deserialize_seq(ExtendVecVisitor(self.0))
-    }
-}
-
-#[test]
-fn test_default_deserialize_seed() {
-    let config = DefaultOptions::new();
-
-    let data: Vec<_> = (10..100).collect();
-    let bytes = config.serialize(&data).expect("Config::serialize failed");
-
-    let mut seed_data: Vec<_> = (0..10).collect();
-    {
-        let seed = ExtendVec(&mut seed_data);
-        config
-            .deserialize_seed(seed, &bytes)
-            .expect("Config::deserialize_seed failed");
-    }
-
-    assert_eq!(seed_data, (0..100).collect::<Vec<_>>());
-}
-
-#[test]
-fn test_big_endian_deserialize_seed() {
-    let config = DefaultOptions::new().with_big_endian();
-
-    let data: Vec<_> = (10..100).collect();
-    let bytes = config.serialize(&data).expect("Config::serialize failed");
-
-    let mut seed_data: Vec<_> = (0..10).collect();
-    {
-        let seed = ExtendVec(&mut seed_data);
-        config
-            .deserialize_seed(seed, &bytes)
-            .expect("Config::deserialize_seed failed");
-    }
-
-    assert_eq!(seed_data, (0..100).collect::<Vec<_>>());
-}
-
-#[test]
-fn test_default_deserialize_from_seed() {
-    let config = DefaultOptions::new();
-
-    let data: Vec<_> = (10..100).collect();
-    let bytes = config.serialize(&data).expect("Config::serialize failed");
-
-    let mut seed_data: Vec<_> = (0..10).collect();
-    {
-        let seed = ExtendVec(&mut seed_data);
-        config
-            .deserialize_from_seed(seed, &mut &*bytes)
-            .expect("Config::deserialize_from_seed failed");
-    }
-
-    assert_eq!(seed_data, (0..100).collect::<Vec<_>>());
-}
-
-#[test]
-fn test_big_endian_deserialize_from_seed() {
-    let config = DefaultOptions::new().with_big_endian();
-
-    let data: Vec<_> = (10..100).collect();
-    let bytes = config.serialize(&data).expect("Config::serialize failed");
-
-    let mut seed_data: Vec<_> = (0..10).collect();
-    {
-        let seed = ExtendVec(&mut seed_data);
-        config
-            .deserialize_from_seed(seed, &mut &*bytes)
-            .expect("Config::deserialize_from_seed failed");
-    }
-
-    assert_eq!(seed_data, (0..100).collect::<Vec<_>>());
-}
-
-#[test]
-fn test_varint_length_prefixes() {
-    let a = vec![(); 127]; // should be a single byte
-    let b = vec![(); 250]; // also should be a single byte
-    let c = vec![(); 251];
-    let d = vec![(); u16::max_value() as usize + 1];
-
-    assert_eq!(
-        DefaultOptions::new()
-            .with_varint_encoding()
-            .serialized_size(&a[..])
-            .unwrap(),
-        1
-    ); // 2 ** 7 - 1
-    assert_eq!(
-        DefaultOptions::new()
-            .with_varint_encoding()
-            .serialized_size(&b[..])
-            .unwrap(),
-        1
-    ); // 250
-    assert_eq!(
-        DefaultOptions::new()
-            .with_varint_encoding()
-            .serialized_size(&c[..])
-            .unwrap(),
-        (1 + std::mem::size_of::<u16>()) as u64
-    ); // 251
-    assert_eq!(
-        DefaultOptions::new()
-            .with_varint_encoding()
-            .serialized_size(&d[..])
-            .unwrap(),
-        (1 + std::mem::size_of::<u32>()) as u64
-    ); // 2 ** 16 + 1
-}
-
-#[test]
-fn test_byte_vec_struct() {
-    #[derive(PartialEq, Eq, Clone, Serialize, Deserialize, Debug)]
-    struct ByteVecs {
-        a: Vec<u8>,
-        b: Vec<u8>,
-        c: Vec<u8>,
-    };
-
-    let byte_struct = ByteVecs {
-        a: vec![2; 20],
-        b: vec![3; 30],
-        c: vec![1; 10],
-    };
-
-    the_same(byte_struct);
-}