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