1 use alloc::collections::BTreeMap; 2 use alloc::string::String; 3 use alloc::vec::Vec; 4 5 use super::rwyw::NonNullString; 6 use flexbuffers::*; 7 use quickcheck::{Arbitrary, Gen}; 8 9 #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)] 10 enum Enum { 11 Unit, 12 U8(u8), 13 U16(u16), 14 U32(u32), 15 U64(u64), 16 Us(u8, u16, u32, u64), 17 I8(i8), 18 I16(i16), 19 I32(i32), 20 I64(i64), 21 Is(i8, i16, i32, i64), 22 F32(f32), 23 F64(f64), 24 Fs(f32, f64), 25 String(String), 26 Strings(String, String), 27 Everything(u8, u16, u32, u64, i8, i16, i32, i64, f32, f64, String), 28 Arrays { 29 a: Array3<u16>, 30 b: Array4<i32>, 31 c: Array2<f64>, 32 }, 33 Blobs(#[serde(with = "serde_bytes")] Vec<u8>), 34 } 35 36 // There is some upstream bug in deriving Arbitrary for Enum so we manually implement it here. 37 impl Arbitrary for Enum { arbitrary<G: Gen>(g: &mut G) -> Self38 fn arbitrary<G: Gen>(g: &mut G) -> Self { 39 match g.gen_range(0, 18) { 40 0 => Enum::Unit, 41 1 => Enum::U8(<u8>::arbitrary(g)), 42 2 => Enum::U16(<u16>::arbitrary(g)), 43 3 => Enum::U32(<u32>::arbitrary(g)), 44 4 => Enum::U64(<u64>::arbitrary(g)), 45 5 => { 46 let (a, b, c, d) = <(u8, u16, u32, u64)>::arbitrary(g); 47 Enum::Us(a, b, c, d) 48 } 49 6 => Enum::I8(<i8>::arbitrary(g)), 50 7 => Enum::I16(<i16>::arbitrary(g)), 51 8 => Enum::I32(<i32>::arbitrary(g)), 52 9 => Enum::I64(<i64>::arbitrary(g)), 53 10 => { 54 let (a, b, c, d) = <(i8, i16, i32, i64)>::arbitrary(g); 55 Enum::Is(a, b, c, d) 56 } 57 11 => Enum::F32(<f32>::arbitrary(g)), 58 12 => Enum::F64(<f64>::arbitrary(g)), 59 13 => { 60 let (a, b) = <(f32, f64)>::arbitrary(g); 61 Enum::Fs(a, b) 62 } 63 14 => Enum::String(String::arbitrary(g)), 64 15 => { 65 let (a, b) = <(String, String)>::arbitrary(g); 66 Enum::Strings(a, b) 67 } 68 16 => Enum::Everything( 69 <u8>::arbitrary(g), 70 <u16>::arbitrary(g), 71 <u32>::arbitrary(g), 72 <u64>::arbitrary(g), 73 <i8>::arbitrary(g), 74 <i16>::arbitrary(g), 75 <i32>::arbitrary(g), 76 <i64>::arbitrary(g), 77 <f32>::arbitrary(g), 78 <f64>::arbitrary(g), 79 <String>::arbitrary(g), 80 ), 81 17 => { 82 let a = Array3::arbitrary(g); 83 let b = Array4::arbitrary(g); 84 let c = Array2::arbitrary(g); 85 Enum::Arrays { a, b, c } 86 } 87 _ => unreachable!(), 88 } 89 } 90 } 91 92 #[derive(Debug, Clone, Arbitrary, PartialEq, Serialize, Deserialize)] 93 struct Unit; 94 95 #[derive(Debug, Clone, Arbitrary, PartialEq, Serialize, Deserialize)] 96 struct NewType(bool); 97 98 #[derive(Debug, Clone, Arbitrary, PartialEq, Serialize, Deserialize)] 99 struct Tuple(bool, u8, i16, f32, String); 100 101 #[derive(Debug, Clone, Arbitrary, PartialEq, Serialize, Deserialize)] 102 struct Struct { 103 a: Vec<Enum>, 104 b: BTreeMap<NonNullString, Enum>, 105 c: Tuple, 106 d: (Unit, Unit), 107 e: Array4<NewType>, 108 } 109 110 #[derive(Debug, Clone, PartialOrd, Ord, PartialEq, Eq, Serialize, Deserialize)] 111 struct Array2<A: Arbitrary>([A; 2]); 112 #[derive(Debug, Clone, PartialOrd, Ord, PartialEq, Eq, Serialize, Deserialize)] 113 struct Array3<A: Arbitrary>([A; 3]); 114 #[derive(Debug, Clone, PartialOrd, Ord, PartialEq, Eq, Serialize, Deserialize)] 115 struct Array4<A: Arbitrary>([A; 4]); 116 117 impl<A: Arbitrary> Arbitrary for Array2<A> { arbitrary<G: Gen>(g: &mut G) -> Self118 fn arbitrary<G: Gen>(g: &mut G) -> Self { 119 Array2([A::arbitrary(g), A::arbitrary(g)]) 120 } 121 } 122 impl<A: Arbitrary> Arbitrary for Array3<A> { arbitrary<G: Gen>(g: &mut G) -> Self123 fn arbitrary<G: Gen>(g: &mut G) -> Self { 124 Array3([A::arbitrary(g), A::arbitrary(g), A::arbitrary(g)]) 125 } 126 } 127 impl<A: Arbitrary> Arbitrary for Array4<A> { arbitrary<G: Gen>(g: &mut G) -> Self128 fn arbitrary<G: Gen>(g: &mut G) -> Self { 129 Array4([ 130 A::arbitrary(g), 131 A::arbitrary(g), 132 A::arbitrary(g), 133 A::arbitrary(g), 134 ]) 135 } 136 } 137 138 quickcheck! { 139 fn qc_serious(original: Struct) -> bool { 140 let struct_buf = flexbuffers::to_vec(&original).unwrap(); 141 let root = Reader::get_root(&*struct_buf).unwrap(); 142 let reader_buf = flexbuffers::to_vec(&root).unwrap(); 143 let deserialized: Struct = flexbuffers::from_slice(&struct_buf).unwrap(); 144 let reserialized: Struct = flexbuffers::from_slice(&reader_buf).unwrap(); 145 146 original == deserialized && original == reserialized 147 } 148 } 149