musli_tests/utils/
mod.rs

1#[macro_use]
2mod macros;
3
4pub use self::full::*;
5mod full;
6
7pub use self::extra::*;
8mod extra;
9
10#[cfg(feature = "musli-json")]
11pub mod musli_json {
12    use alloc::vec::Vec;
13
14    use ::musli_json::Encoding;
15    use ::musli_json::Error;
16    use musli::{Decode, Encode};
17
18    const ENCODING: Encoding = Encoding::new();
19
20    benchmarker! {
21        'buf
22
23        pub fn buffer() -> Vec<u8> {
24            Vec::with_capacity(4096)
25        }
26
27        pub fn reset<T>(&mut self, _size_hint: usize, _value: &T) {
28            self.buffer.clear();
29        }
30
31        pub fn encode<T>(&mut self, value: &T) -> Result<&'buf [u8], Error>
32        where
33            T: Encode,
34        {
35            ENCODING.encode(&mut *self.buffer, value)?;
36            Ok(self.buffer.as_slice())
37        }
38
39        pub fn decode<T>(&self) -> Result<T, Error>
40        where
41            T: Decode<'buf>,
42        {
43            ENCODING.from_slice(self.buffer)
44        }
45    }
46}
47
48#[cfg(feature = "musli-storage")]
49pub mod musli_storage_packed {
50    use alloc::vec::Vec;
51
52    use ::musli_storage::int::{Fixed, Variable};
53    use ::musli_storage::Encoding;
54    use ::musli_storage::Error;
55    use musli::{Decode, Encode};
56
57    use crate::mode::Packed;
58
59    const ENCODING: Encoding<Packed, Fixed, Variable> =
60        Encoding::new().with_fixed_integers().with_mode();
61
62    benchmarker! {
63        'buf
64
65        pub fn buffer() -> Vec<u8> {
66            Vec::with_capacity(4096)
67        }
68
69        pub fn reset<T>(&mut self, _size_hint: usize, _value: &T) {
70            self.buffer.clear();
71        }
72
73        pub fn encode<T>(&mut self, value: &T) -> Result<&'buf [u8], Error>
74        where
75            T: Encode<Packed>,
76        {
77            ENCODING.encode(&mut *self.buffer, value)?;
78            Ok(self.buffer.as_slice())
79        }
80
81        pub fn decode<T>(&self) -> Result<T, Error>
82        where
83            T: Decode<'buf, Packed>,
84        {
85            ENCODING.from_slice(self.buffer)
86        }
87    }
88}
89
90#[cfg(feature = "musli-storage")]
91pub mod musli_storage {
92    use alloc::vec::Vec;
93
94    use ::musli_storage::int::{Fixed, Variable};
95    use ::musli_storage::Encoding;
96    use ::musli_storage::Error;
97    use musli::mode::DefaultMode;
98    use musli::{Decode, Encode};
99
100    const ENCODING: Encoding<DefaultMode, Fixed, Variable> = Encoding::new().with_fixed_integers();
101
102    benchmarker! {
103        'buf
104
105        pub fn buffer() -> Vec<u8> {
106            Vec::with_capacity(4096)
107        }
108
109        pub fn reset<T>(&mut self, _: usize, _: &T) {
110            self.buffer.clear();
111        }
112
113        pub fn encode<T>(&mut self, value: &T) -> Result<&'buf [u8], Error>
114        where
115            T: Encode,
116        {
117            ENCODING.encode(&mut *self.buffer, value)?;
118            Ok(self.buffer.as_slice())
119        }
120
121        pub fn decode<T>(&self) -> Result<T, Error>
122        where
123            T: Decode<'buf>,
124        {
125            ENCODING.from_slice(self.buffer)
126        }
127    }
128}
129
130#[cfg(feature = "musli-wire")]
131pub mod musli_wire {
132    use alloc::vec::Vec;
133
134    use ::musli_wire::int::Variable;
135    use ::musli_wire::Encoding;
136    use ::musli_wire::Error;
137    use musli::mode::DefaultMode;
138    use musli::{Decode, Encode};
139
140    const ENCODING: Encoding<DefaultMode, Variable, Variable> = Encoding::new();
141
142    benchmarker! {
143        'buf
144
145        pub fn buffer() -> Vec<u8> {
146            Vec::with_capacity(4096)
147        }
148
149        pub fn reset<T>(&mut self, _: usize, _: &T) {
150            self.buffer.clear();
151        }
152
153        pub fn encode<T>(&mut self, value: &T) -> Result<&'buf [u8], Error>
154        where
155            T: Encode,
156        {
157            ENCODING.encode(&mut *self.buffer, value)?;
158            Ok(self.buffer.as_slice())
159        }
160
161        pub fn decode<T>(&self) -> Result<T, Error>
162        where
163            T: Decode<'buf>,
164        {
165            ENCODING.from_slice(self.buffer)
166        }
167    }
168}
169
170#[cfg(feature = "musli-descriptive")]
171pub mod musli_descriptive {
172    use alloc::vec::Vec;
173
174    use ::musli_descriptive::Encoding;
175    use musli::mode::DefaultMode;
176    use musli::{Decode, Encode};
177    use musli_descriptive::Error;
178
179    const ENCODING: Encoding<DefaultMode> = Encoding::new();
180
181    benchmarker! {
182        'buf
183
184        pub fn buffer() -> Vec<u8> {
185            Vec::with_capacity(4096)
186        }
187
188        pub fn reset<T>(&mut self, _: usize, _: &T) {
189            self.buffer.clear();
190        }
191
192        pub fn encode<T>(&mut self, value: &T) -> Result<&'buf [u8], Error>
193        where
194            T: Encode,
195        {
196            ENCODING.encode(&mut *self.buffer, value)?;
197            Ok(self.buffer.as_slice())
198        }
199
200        pub fn decode<T>(&self) -> Result<T, Error>
201        where
202            T: Decode<'buf>,
203        {
204            ENCODING.from_slice(self.buffer)
205        }
206    }
207}
208
209#[cfg(feature = "musli-value")]
210pub mod musli_value {
211    use ::musli_value::Value;
212    use musli::{Decode, Encode};
213
214    benchmarker! {
215        'buf {@nolen}
216
217        pub fn buffer() -> () {}
218
219        pub fn reset<T>(&mut self, _: usize, _: &T) {}
220
221        pub fn encode<T>(&mut self, value: &T) -> Result<Value, musli_value::Error>
222        where
223            T: Encode,
224        {
225            musli_value::encode(value)
226        }
227
228        pub fn decode<T>(&self) -> Result<T, musli_value::Error>
229        where
230            for<'a> T: Decode<'a>,
231        {
232            musli_value::decode(&self.buffer)
233        }
234    }
235}
236
237#[cfg(feature = "musli-zerocopy")]
238pub mod musli_zerocopy {
239    use musli_zerocopy::pointer::{DefaultSize, Ref};
240    use musli_zerocopy::{Buf, Error, OwnedBuf, ZeroCopy};
241
242    pub struct Benchmarker {
243        buf: OwnedBuf,
244    }
245
246    #[inline(always)]
247    pub fn new() -> Benchmarker {
248        Benchmarker {
249            buf: OwnedBuf::with_capacity(4096),
250        }
251    }
252
253    impl Benchmarker {
254        #[inline(always)]
255        pub fn with<T, O>(&mut self, with: T) -> O
256        where
257            T: FnOnce(State) -> O,
258        {
259            with(State { buf: &mut self.buf })
260        }
261    }
262
263    pub struct State<'buf> {
264        buf: &'buf mut OwnedBuf,
265    }
266
267    pub struct DecodeState<'buf> {
268        buf: &'buf Buf,
269        offset: usize,
270    }
271
272    impl<'buf> DecodeState<'buf> {
273        #[inline(always)]
274        pub fn len(&self) -> usize {
275            self.buf.len()
276        }
277
278        #[inline(always)]
279        pub fn decode<T>(&self) -> Result<&'buf T, Error>
280        where
281            T: ZeroCopy,
282        {
283            self.buf.load(Ref::<T, DefaultSize>::new(self.offset))
284        }
285    }
286
287    impl<'buf> State<'buf> {
288        #[inline(always)]
289        pub fn reset<T>(&mut self, reserve: usize, _: &T) {
290            self.buf.clear();
291            self.buf.reserve(reserve);
292        }
293
294        #[inline(always)]
295        pub fn encode<T>(&mut self, value: &T) -> Result<DecodeState<'_>, Error>
296        where
297            T: ZeroCopy,
298        {
299            let offset = self.buf.store(value).offset();
300
301            Ok(DecodeState {
302                buf: self.buf.as_ref(),
303                offset,
304            })
305        }
306    }
307
308    #[inline(always)]
309    pub fn decode<'de, T>(bytes: &'de [u8]) -> Result<&'de T, Error>
310    where
311        T: ZeroCopy,
312    {
313        Buf::new(bytes).load(Ref::<T>::zero())
314    }
315}
musli_tests/utils/mod.rs

musli_tests/utils/
mod.rs
