Revert round trip test (add recursion to it too)

fuzz/Cargo.toml

@@ -25,3 +25,9 @@ name = "roundtrip"
 path = "fuzz_targets/roundtrip.rs"
 test = false
 doc = false
+
+[[bin]]
+name = "compat"
+path = "fuzz_targets/compat.rs"
+test = false
+doc = false

fuzz/fuzz_targets/compat.rs

@@ -0,0 +1,57 @@
+#![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, bincode::Encode, PartialEq, Debug, serde::Serialize, 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 result: Result<(AllTypes, _), _> = bincode::decode_from_slice(data, config);
+
+    if let Ok((before, _)) = result {
+        let v1: Result<AllTypes, _> = configv1.deserialize(&data);
+        if v1.as_ref().ok() != Some(&before) {
+            println!("Bytes:      {:?}", data);
+            println!("Bincode V2: {:?}", before);
+            println!("Bincode V1: {:?}", v1);
+            panic!("failed round trip");
+        }
+    }
+});

fuzz/fuzz_targets/roundtrip.rs

@@ -6,19 +6,22 @@ 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::rc::Rc;
+use std::sync::Arc;
 use std::time::{Duration, SystemTime};
 
-use bincodev1::Options;
-
-#[derive(bincode::Decode, bincode::Encode, PartialEq, Debug, serde::Serialize, serde::Deserialize, Eq, PartialOrd, Ord)]
+#[derive(bincode::Decode, bincode::Encode, PartialEq, Debug)]
 enum AllTypes {
-    BTreeMap(BTreeMap<u8, AllTypes>),
-    BTreeSet(BTreeSet<AllTypes>),
+    BTreeMap(BTreeMap<u8, u8>),
+    HashMap(HashMap<u8, u8>),
+    BTreeSet(BTreeSet<u8>),
     VecDeque(VecDeque<AllTypes>),
-    Vec(Vec<u8>),
+    Vec(Vec<AllTypes>),
     String(String),
-    Box(Box<u8>),
-    BoxSlice(Box<[u8]>),
+    Box(Box<AllTypes>),
+    BoxSlice(Box<[AllTypes]>),
+    Rc(Rc<AllTypes>),
+    Arc(Arc<AllTypes>),
     CString(CString),
     SystemTime(SystemTime),
     Duration(Duration),
@@ -37,23 +40,12 @@ enum AllTypes {
 }
 
 fuzz_target!(|data: &[u8]| {
-    let config = bincode::config::legacy().with_limit::<1024>();
-    let mut configv1 = bincodev1::config();
-    configv1.limit(1024);
+    let config = bincode::config::standard().with_limit::<1024>();
     let result: Result<(AllTypes, _), _> = bincode::decode_from_slice(data, config);
 
     if let Ok((before, _)) = result {
         let encoded = bincode::encode_to_vec(&before, config).expect("round trip");
         let (after, _) = bincode::decode_from_slice(&encoded, config).unwrap();
-
         assert_eq!(before, after);
-
-        match configv1.deserialize(&data) {
-            Ok(v1_decoded) => assert_eq!(before, v1_decoded),
-            Err(e) => {
-                dbg!(before);
-                panic!("failed to deserialize: {:?}", e);
-            }
-        }
     }
 });