protocol/wire/test: Define `fn roundtrip` and macro — heartwood

In many tests we assert that encoding and decoding gives the same object. Let’s call that a “roundrip”, and also provide a proc macro to generate such tests.

 ]
 [[package]]
 name = "paste"
 version = "1.0.15"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "57c0d7b74b563b49d38dae00a0c37d4d6de9b432382b2892f0574ddcae73fd0a"
 [[package]]
 name = "pbkdf2"
 version = "0.12.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"

  "localtime",
  "log",
  "nonempty 0.9.0",
  "paste",
  "qcheck",
  "qcheck-macros",
  "radicle",

 thiserror = { workspace = true }
 [dev-dependencies]
 paste = "1.0.15"
 qcheck = { workspace = true }
 qcheck-macros = { workspace = true }
 radicle = { workspace = true, features = ["test"] }

 }
 #[cfg(test)]
 fn roundtrip<T>(value: T)
 where
     T: Encode + Decode + PartialEq + Debug,
 {
     let encoded = value.encode_to_vec();
     assert_eq!(T::decode_exact(&encoded).expect("roundtrip"), value);
 }
 #[cfg(test)]
 #[macro_export]
 macro_rules! prop_roundtrip {
     ($t:ty, $name:tt) => {
         paste::paste! {
             #[quickcheck]
             fn [< prop_roundtrip_ $name:lower >](v: $t) {
                 $crate::wire::roundtrip(v);
             }
         }
     };
     ($t:ty) => {
         paste::paste! {
             prop_roundtrip!($t, [< $t >]);
         }
     };
 }
 #[cfg(test)]
 mod tests {
     use super::*;
     use qcheck;
     use qcheck_macros::quickcheck;

     use radicle::crypto::Unverified;
     use radicle::storage::refs::SignedRefs;
     #[quickcheck]
     fn prop_u8(input: u8) {
         assert_eq!(u8::decode_exact(&input.encode_to_vec()).unwrap(), input);
     }
     #[quickcheck]
     fn prop_u16(input: u16) {
         assert_eq!(u16::decode_exact(&input.encode_to_vec()).unwrap(), input);
     }
     #[quickcheck]
     fn prop_u32(input: u32) {
         assert_eq!(u32::decode_exact(&input.encode_to_vec()).unwrap(), input);
     }
     #[quickcheck]
     fn prop_u64(input: u64) {
         assert_eq!(u64::decode_exact(&input.encode_to_vec()).unwrap(), input);
     }
     prop_roundtrip!(u16);
     prop_roundtrip!(u32);
     prop_roundtrip!(u64);
     prop_roundtrip!(BoundedVec<u8, 16>, vec);
     prop_roundtrip!(PublicKey);
     prop_roundtrip!(filter::Filter, filter);
     prop_roundtrip!(RepoId);
     prop_roundtrip!(Refs);
     prop_roundtrip!((String, String), tuple);
     prop_roundtrip!(SignedRefs<Unverified>, signed_refs);
     #[quickcheck]
     fn prop_string(input: String) -> qcheck::TestResult {
         if input.len() > u8::MAX as usize {
             return qcheck::TestResult::discard();
         }
         assert_eq!(String::decode_exact(&input.encode_to_vec()).unwrap(), input);
         qcheck::TestResult::passed()
     }
     #[quickcheck]
     fn prop_vec(input: BoundedVec<String, 16>) {
         assert_eq!(
             BoundedVec::<String, 16>::decode_exact(&input.encode_to_vec()).unwrap(),
             input
         );
     }
         roundtrip(input);
     #[quickcheck]
     fn prop_pubkey(input: PublicKey) {
         assert_eq!(
             PublicKey::decode_exact(&input.encode_to_vec()).unwrap(),
             input
         );
     }
     #[quickcheck]
     fn prop_filter(input: filter::Filter) {
         assert_eq!(
             filter::Filter::decode_exact(&input.encode_to_vec()).unwrap(),
             input
         );
     }
     #[quickcheck]
     fn prop_id(input: RepoId) {
         assert_eq!(RepoId::decode_exact(&input.encode_to_vec()).unwrap(), input);
     }
     #[quickcheck]
     fn prop_refs(input: Refs) {
         assert_eq!(Refs::decode_exact(&input.encode_to_vec()).unwrap(), input);
     }
     #[quickcheck]
     fn prop_tuple(input: (String, String)) {
         assert_eq!(
             <(String, String)>::decode_exact(&input.encode_to_vec()).unwrap(),
             input
         );
         qcheck::TestResult::passed()
     }
     #[quickcheck]
     fn prop_signature(input: [u8; 64]) {
         let signature = Signature::from(input);
         assert_eq!(
             Signature::decode_exact(&signature.encode_to_vec()).unwrap(),
             signature
         );
         roundtrip(Signature::from(input));
     }
     #[quickcheck]
     fn prop_oid(input: [u8; 20]) {
         let oid = git::Oid::try_from(input.as_slice()).unwrap();
         assert_eq!(git::Oid::decode_exact(&oid.encode_to_vec()).unwrap(), oid);
     }
     #[quickcheck]
     fn prop_signed_refs(input: SignedRefs<Unverified>) {
         assert_eq!(
             SignedRefs::<Unverified>::decode_exact(&input.encode_to_vec()).unwrap(),
             input
         );
         roundtrip(git::Oid::try_from(input.as_slice()).unwrap());
     }
     #[test]

 #[cfg(test)]
 mod tests {
     use super::*;
     use qcheck_macros::quickcheck;
     use radicle::node::device::Device;
     use radicle::node::UserAgent;
     use radicle::storage::refs::RefsAt;
     use radicle::test::arbitrary;
     use crate::deserializer::Deserializer;
     use crate::wire::{self, Decode, Encode};
     use radicle::test::arbitrary;
     use crate::prop_roundtrip;
     use crate::wire::{roundtrip, Encode as _};
     use super::*;
     prop_roundtrip!(Address);
     prop_roundtrip!(Message);
     #[test]
     fn test_refs_ann_max_size() {

         .encode_to_vec();
     }
     #[quickcheck]
     fn prop_message_encode_decode(message: Message) {
         let encoded = message.encode_to_vec();
         let decoded = Message::decode_exact(&encoded).unwrap();
         assert_eq!(message, decoded);
     }
     #[test]
     fn prop_message_decoder() {
         fn property(items: Vec<Message>) {

             .quickcheck(property as fn(items: Vec<Message>));
     }
     #[test]
     fn prop_zero_bytes_encode_decode() {
         fn property(zeroes: wire::Size) {
             if zeroes > Ping::MAX_PING_ZEROES {
                 return;
             }
             let zeroes = ZeroBytes::new(zeroes);
             assert_eq!(
                 ZeroBytes::decode_exact(&zeroes.encode_to_vec()).unwrap(),
                 zeroes
             );
     #[quickcheck]
     fn prop_zero_bytes_encode_decode(zeroes: wire::Size) -> qcheck::TestResult {
         if zeroes > Ping::MAX_PING_ZEROES {
             return qcheck::TestResult::discard();
         }
         qcheck::QuickCheck::new()
             .gen(qcheck::Gen::new(16))
             .quickcheck(property as fn(zeroes: wire::Size));
     }
         roundtrip(ZeroBytes::new(zeroes));
     #[quickcheck]
     fn prop_addr(addr: Address) {
         assert_eq!(Address::decode_exact(&addr.encode_to_vec()).unwrap(), addr);
         qcheck::TestResult::passed()
     }
 }

         }
     }
     #[quickcheck]
     fn prop_encode_decode(input: VarInt) {
         let encoded = input.encode_to_vec();
         let decoded: VarInt = VarInt::decode_exact(&encoded).unwrap();
         assert_eq!(decoded, input);
     }
     #[test]
     #[should_panic]
     #[should_panic(expected = "overflow")]
     fn test_encode_overflow() {
         VarInt(u64::MAX).encode_to_vec();
     }