1#![cfg_attr(feature = "bitcode", allow(clippy::assign_op_pattern))]
2
3mod generate;
4
5#[cfg(any(feature = "model_map", feature = "model_map_string_key"))]
6use std::collections::HashMap;
7
8use core::ops::Range;
9
10#[cfg(feature = "model_cstring")]
11use alloc::ffi::CString;
12use alloc::string::String;
13use alloc::vec::Vec;
14
15#[cfg(feature = "musli-zerocopy")]
16use musli_zerocopy::ZeroCopy;
17
18#[cfg(feature = "musli")]
19use musli::{Decode, Encode};
20use musli_macros::Generate;
21#[cfg(feature = "serde")]
22use serde::{Deserialize, Serialize};
23
24#[cfg(feature = "musli")]
25use crate::mode::Packed;
26
27pub use self::generate::Generate;
28pub use rand::prelude::*;
29
30miri! {
31 const PRIMITIVES_RANGE: Range<usize> = 10..100, 1..3;
32 const MEDIUM_RANGE: Range<usize> = 10..100, 1..3;
33}
34
35#[derive(Debug, Clone, PartialEq, Generate)]
36#[cfg_attr(feature = "musli-zerocopy", derive(ZeroCopy))]
37#[cfg_attr(feature = "musli", derive(Encode, Decode))]
38#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
39#[cfg_attr(feature = "bitcode", derive(bitcode::Encode, bitcode::Decode))]
40#[cfg_attr(
41 feature = "rkyv",
42 derive(rkyv::Archive, rkyv::Deserialize, rkyv::Serialize),
43 archive(compare(PartialEq), check_bytes),
44 archive_attr(derive(Debug))
45)]
46#[cfg_attr(feature = "musli", musli(mode = Packed, packed))]
47#[cfg_attr(feature = "musli-zerocopy", repr(C))]
48pub struct Primitives {
49 boolean: bool,
50 character: char,
51 unsigned8: u8,
52 unsigned16: u16,
53 unsigned32: u32,
54 unsigned64: u64,
55 #[cfg(feature = "model_128")]
56 unsigned128: u128,
57 signed8: i8,
58 signed16: i16,
59 signed32: i32,
60 signed64: i64,
61 #[cfg(feature = "model_128")]
62 signed128: i128,
63 #[cfg(feature = "model_usize")]
64 unsignedsize: usize,
65 #[cfg(feature = "model_usize")]
66 signedsize: isize,
67 #[cfg(feature = "model_float")]
68 float32: f32,
69 #[cfg(feature = "model_float")]
70 float64: f64,
71}
72
73#[cfg(feature = "rkyv")]
74impl PartialEq<Primitives> for &ArchivedPrimitives {
75 #[inline]
76 fn eq(&self, other: &Primitives) -> bool {
77 *other == **self
78 }
79}
80
81impl PartialEq<Primitives> for &Primitives {
82 #[inline]
83 fn eq(&self, other: &Primitives) -> bool {
84 *other == **self
85 }
86}
87
88#[derive(Debug, Clone, PartialEq, Generate)]
89#[cfg_attr(feature = "musli", derive(Encode, Decode))]
90#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
91#[cfg_attr(feature = "bitcode", derive(bitcode::Encode, bitcode::Decode))]
92#[cfg_attr(
93 feature = "rkyv",
94 derive(rkyv::Archive, rkyv::Deserialize, rkyv::Serialize),
95 archive(compare(PartialEq), check_bytes),
96 archive_attr(derive(Debug))
97)]
98#[cfg_attr(feature = "musli", musli(mode = Packed, packed))]
99pub struct Allocated {
100 string: String,
101 bytes: Vec<u8>,
102 #[cfg(feature = "model_cstring")]
103 c_string: CString,
104}
105
106#[cfg(feature = "rkyv")]
107impl PartialEq<Allocated> for &ArchivedAllocated {
108 #[inline]
109 fn eq(&self, other: &Allocated) -> bool {
110 *other == **self
111 }
112}
113
114impl PartialEq<Allocated> for &Allocated {
115 #[inline]
116 fn eq(&self, other: &Allocated) -> bool {
117 *other == **self
118 }
119}
120
121#[derive(Debug, Clone, PartialEq, Generate)]
122#[cfg_attr(feature = "musli", derive(Encode, Decode))]
123#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
124#[cfg_attr(feature = "bitcode", derive(bitcode::Encode, bitcode::Decode))]
125#[cfg_attr(feature = "musli", musli(mode = Packed, packed))]
126pub struct Tuples {
127 u0: (),
128 u1: (bool,),
129 u2: (bool, u8),
130 u3: (bool, u8, u32),
131 u4: (bool, u8, u32, u64),
132 #[cfg(feature = "model_float")]
133 u5: (bool, u8, u32, u64, f32),
134 #[cfg(feature = "model_float")]
135 u6: (bool, u8, u32, u64, f32, f64),
136 i0: (),
137 i1: (bool,),
138 i2: (bool, i8),
139 i3: (bool, i8, i32),
140 i4: (bool, i8, i32, i64),
141 #[cfg(feature = "model_float")]
142 i5: (bool, i8, i32, i64, f32),
143 #[cfg(feature = "model_float")]
144 i6: (bool, i8, i32, i64, f32, f64),
145}
146
147impl PartialEq<Tuples> for &Tuples {
148 #[inline]
149 fn eq(&self, other: &Tuples) -> bool {
150 *other == **self
151 }
152}
153
154#[derive(Debug, Clone, PartialEq, Generate)]
155#[cfg_attr(feature = "musli", derive(Encode, Decode))]
156#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
157#[cfg_attr(feature = "bitcode", derive(bitcode::Encode, bitcode::Decode))]
158#[cfg_attr(
159 feature = "rkyv",
160 derive(rkyv::Archive, rkyv::Deserialize, rkyv::Serialize),
161 archive(compare(PartialEq), check_bytes),
162 archive_attr(derive(Debug))
163)]
164#[cfg_attr(feature = "musli", musli(mode = Packed))]
165pub enum MediumEnum {
166 #[cfg_attr(feature = "musli", musli(transparent))]
167 StringVariant(String),
168 #[cfg_attr(feature = "musli", musli(transparent))]
169 NumberedVariant(u64),
170 EmptyTupleVariant(),
171 NamedEmptyVariant {},
172 NamedVariant {
173 a: u32,
174 primitives: Primitives,
175 b: u64,
176 },
177 UnnamedVariant,
178}
179
180#[cfg(feature = "rkyv")]
181impl PartialEq<MediumEnum> for &ArchivedMediumEnum {
182 #[inline]
183 fn eq(&self, other: &MediumEnum) -> bool {
184 *other == **self
185 }
186}
187
188impl PartialEq<MediumEnum> for &MediumEnum {
189 #[inline]
190 fn eq(&self, other: &MediumEnum) -> bool {
191 *other == **self
192 }
193}
194
195#[derive(Debug, Clone, PartialEq, Generate)]
196#[cfg_attr(feature = "musli", derive(Encode, Decode))]
197#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
198#[cfg_attr(feature = "bitcode", derive(bitcode::Encode, bitcode::Decode))]
199#[cfg_attr(
200 feature = "rkyv",
201 derive(rkyv::Archive, rkyv::Deserialize, rkyv::Serialize),
202 archive(compare(PartialEq), check_bytes),
203 archive_attr(derive(Debug))
204)]
205#[cfg_attr(feature = "musli", musli(mode = Packed, packed))]
206pub struct LargeStruct {
207 #[generate(range = PRIMITIVES_RANGE)]
208 primitives: Vec<Primitives>,
209 #[cfg(all(feature = "model_vec", feature = "model_tuple"))]
210 #[generate(range = PRIMITIVES_RANGE)]
211 tuples: Vec<(Tuples, Tuples)>,
212 #[generate(range = MEDIUM_RANGE)]
213 medium_vec: Vec<MediumEnum>,
214 #[cfg(feature = "model_map_string_key")]
215 #[generate(range = MEDIUM_RANGE)]
216 medium_map: HashMap<String, MediumEnum>,
217 #[cfg(feature = "model_map_string_key")]
218 string_keys: HashMap<String, u64>,
219 #[cfg(all(feature = "model_map", feature = "model_tuple"))]
220 number_keys: HashMap<u32, u64>,
221 #[cfg(feature = "model_tuple")]
222 number_vec: Vec<(u32, u64)>,
223}
224
225#[cfg(feature = "rkyv")]
226impl PartialEq<LargeStruct> for &ArchivedLargeStruct {
227 #[inline]
228 fn eq(&self, other: &LargeStruct) -> bool {
229 *other == **self
230 }
231}
232
233impl PartialEq<LargeStruct> for &LargeStruct {
234 #[inline]
235 fn eq(&self, other: &LargeStruct) -> bool {
236 *other == **self
237 }
238}