#![no_main]

use libfuzzer_sys::fuzz_target;

use std::collections::{BTreeMap, BTreeSet, VecDeque};

use std::ffi::CString;

use std::net::{IpAddr, Ipv4Addr, Ipv6Addr, SocketAddr, SocketAddrV4, SocketAddrV6};

use std::num::{NonZeroI128, NonZeroI32, NonZeroU128, NonZeroU32};

use std::path::PathBuf;

use std::time::{Duration, SystemTime};

#[derive(

    bincode::Decode,

Unexecuted instantiation: <compat::AllTypes as bincode::de::BorrowDecode<_>>::borrow_decode::<_>

<compat::AllTypes as bincode::de::Decode<()>>::decode::<bincode::de::decoder::DecoderImpl<bincode::de::read::SliceReader, bincode::config::Configuration<bincode::config::LittleEndian, bincode::config::Fixint, bincode::config::Limit<1024>>, ()>>

Line

Count

Source

12

828

    bincode::Decode,

    bincode::Encode,

    PartialEq,

    Debug,

    serde::Serialize,

    serde::Deserialize,

Unexecuted instantiation: <<compat::AllTypes as serde::de::Deserialize>::deserialize::__FieldVisitor as serde::de::Visitor>::expecting

Unexecuted instantiation: <<compat::AllTypes as serde::de::Deserialize>::deserialize::__Visitor as serde::de::Visitor>::expecting

<<compat::AllTypes as serde::de::Deserialize>::deserialize::__Field as serde::de::Deserialize>::deserialize::<serde::de::value::U32Deserializer<alloc::boxed::Box<bincode::error::ErrorKind>>>

Line

Count

Source

17

41.8k

    serde::Deserialize,

    Eq,

    PartialOrd,

    Ord,

)]

enum AllTypes {

    BTreeMap(BTreeMap<u8, AllTypes>),

    BTreeSet(BTreeSet<AllTypes>),

    VecDeque(VecDeque<AllTypes>),

    Vec(Vec<u8>),

    String(String),

    Box(Box<u8>),

    BoxSlice(Box<[u8]>),

    CString(CString),

    SystemTime(SystemTime),

    Duration(Duration),

    PathBuf(PathBuf),

    IpAddr(IpAddr),

    Ipv4Addr(Ipv4Addr),

    Ipv6Addr(Ipv6Addr),

    SocketAddr(SocketAddr),

    SocketAddrV4(SocketAddrV4),

    SocketAddrV6(SocketAddrV6),

    NonZeroU32(NonZeroU32),

    NonZeroI32(NonZeroI32),

    NonZeroU128(NonZeroU128),

    NonZeroI128(NonZeroI128),

    I128(i128),

    I8(i8),

    U128(u128),

    U8(u8),

    // Cow(Cow<'static, [u8]>), Blocked, see comment on decode

}

fuzz_target!(|data: &[u8]| {

    let config = bincode::config::legacy().with_limit::<1024>();

    #[allow(deprecated)]

    let mut configv1 = bincodev1::config();

    configv1.limit(1024);

    let bincode_v1: Result<AllTypes, _> = configv1.deserialize_from(data);

    let bincode_v2: Result<(AllTypes, _), _> = bincode::decode_from_slice(data, config);

    match (&bincode_v1, &bincode_v2) {

        (Err(e), _) if e.to_string() == "the size limit has been reached" => {}

        (_, Err(bincode::error::DecodeError::LimitExceeded)) => {}

        (Ok(bincode_v1), Ok((bincode_v2, _))) if bincode_v1 != bincode_v2 => {

            println!("Bytes:      {:?}", data);

            println!("Bincode V1: {:?}", bincode_v1);

            println!("Bincode V2: {:?}", bincode_v2);

            panic!("failed equality check");

        }

        (Ok(_), Err(_)) | (Err(_), Ok(_)) => {

            println!("Bytes:      {:?}", data);

            println!("Bincode V1: {:?}", bincode_v1);

            println!("Bincode V2: {:?}", bincode_v2);

            panic!("failed equality check");

        }

        _ => {}

    }

});