rsomeip_bytes/length.rs
1//! Length field.
2//!
3//! This module provides the definition of the SOME/IP length that is used to encode the length of
4//! dynamically sized payloads.
5
6use crate::{Deserialize, DeserializeError, Serialize, SerializeError};
7use bytes::{Buf, BufMut};
8use core::marker::PhantomData;
9
10/// Length of a value.
11///
12/// Encodes the length of a dynamically sized type in the SOME/IP on-wire format.
13pub trait Length: Sealed {
14 /// Serializes the `value` into the given `buffer` with a length field.
15 ///
16 /// Returns the size of the serialized data in bytes, including the length field itself.
17 ///
18 /// # Errors
19 ///
20 /// Returns a [`SerializeError`] if the serialization fails. Some data may still be written to
21 /// the buffer if an error occurs.
22 ///
23 /// # Panics
24 ///
25 /// Panics if the buffer doesn't have enough capacity for the serialized type. It's advised to
26 /// ensure that the buffer has at least [`Serialize::size`] capacity.
27 ///
28 /// # Examples
29 ///
30 /// ```rust
31 /// # fn main() -> Result<(), Box<dyn std::error::Error>> {
32 /// use rsomeip_bytes::{LengthU32, Length as _, BytesMut};
33 ///
34 /// let mut buffer = BytesMut::with_capacity(6);
35 ///
36 /// // Serialize a value with a 32-bit length field into the buffer.
37 /// let size = LengthU32::serialize(&0x0102_u16, &mut buffer)?;
38 ///
39 /// // Size includes length and value.
40 /// assert_eq!(size, 6);
41 ///
42 /// // Length field comes before the value.
43 /// assert_eq!(&buffer.freeze(), [0_u8, 0, 0, 2, 1, 2].as_slice());
44 /// # Ok(()) }
45 /// ```
46 fn serialize<Buffer, Value>(
47 value: &Value,
48 buffer: &mut Buffer,
49 ) -> Result<usize, SerializeError>
50 where
51 Buffer: BufMut + ?Sized,
52 Value: Serialize;
53
54 /// Serializes the `value` into the `buffer` with a length field using the given functions.
55 ///
56 /// Returns the size of the serialized data in bytes, including the length field itself.
57 ///
58 /// # Errors
59 ///
60 /// Returns a [`SerializeError`] if the serialization fails. Some data may still be written to
61 /// the buffer if an error occurs.
62 ///
63 /// # Panics
64 ///
65 /// Panics if the buffer doesn't have enough capacity for the serialized type. It's advised to
66 /// ensure that the buffer has at least [`Serialize::size`] capacity.
67 ///
68 /// # Examples
69 ///
70 /// ```rust
71 /// # fn main() -> Result<(), Box<dyn std::error::Error>> {
72 /// use rsomeip_bytes::{LengthU32, Length as _, BytesMut, Serialize as _};
73 ///
74 /// // Type requiring custom serialization.
75 /// struct Foo {
76 /// bar: u8,
77 /// baz: u16,
78 /// }
79 ///
80 /// let mut buffer = BytesMut::with_capacity(7);
81 ///
82 /// // Serialize a value with a 32-bit length field into the buffer.
83 /// let size = LengthU32::serialize_with(
84 /// |value, mut buffer| Ok(value.bar.serialize(buffer)? + value.baz.serialize(buffer)?),
85 /// |value| Some(value.bar.size()? + value.baz.size()?),
86 /// Foo { bar: 1_u8, baz: 0x0203_u16 },
87 /// &mut buffer)?;
88 ///
89 /// // Size includes length and value.
90 /// assert_eq!(size, 7);
91 ///
92 /// // Length field comes before the value.
93 /// assert_eq!(&buffer.freeze(), [0_u8, 0, 0, 3, 1, 2, 3].as_slice());
94 /// # Ok(()) }
95 /// ```
96 fn serialize_with<Buffer, Value, SerializeFn, SizeFn>(
97 serialize: SerializeFn,
98 size: SizeFn,
99 value: Value,
100 buffer: &mut Buffer,
101 ) -> Result<usize, SerializeError>
102 where
103 Buffer: BufMut + ?Sized,
104 for<'any> SerializeFn: Fn(&Value, &mut dyn BufMut) -> Result<usize, SerializeError>,
105 for<'any> SizeFn: Fn(&Value) -> Option<usize>;
106
107 /// Deserializes a value from the given `buffer` with a preceding length field.
108 ///
109 /// The value in the length field is used to limit the deserialization of the value from the
110 /// buffer.
111 ///
112 /// # Errors
113 ///
114 /// Returns a [`DeserializeError`] if the deserialization fails.
115 ///
116 /// # Examples
117 ///
118 /// ```rust
119 /// # fn main() -> Result<(), Box<dyn std::error::Error>> {
120 /// use rsomeip_bytes::{Deserialize as _, LengthU32, Length as _};
121 ///
122 /// // The buffer can be any type that implements `Buf`.
123 /// let buffer = [0_u8, 0, 0, 2, 1, 2];
124 ///
125 /// // Deserialize a value with a 32-bit length field from the buffer.
126 /// let value = LengthU32::deserialize::<_, u16>(&mut buffer.as_slice())?;
127 /// assert_eq!(value, 0x0102_u16);
128 /// # Ok(()) }
129 /// ```
130 fn deserialize<Buffer, Value>(buffer: &mut Buffer) -> Result<Value::Output, DeserializeError>
131 where
132 Buffer: Buf + ?Sized,
133 Value: Deserialize;
134
135 /// Deserializes a value from the `buffer` with a preceding length field using the given
136 /// `function`.
137 ///
138 /// The value in the length field is used to limit the deserialization of the value from the
139 /// buffer.
140 ///
141 /// # Errors
142 ///
143 /// Returns a [`DeserializeError`] if the deserialization fails.
144 ///
145 /// # Examples
146 ///
147 /// ```rust
148 /// # fn main() -> Result<(), Box<dyn std::error::Error>> {
149 /// use rsomeip_bytes::{Deserialize as _, LengthU32, Length as _};
150 ///
151 /// // Type requiring custom deerialization.
152 /// #[derive(Debug, PartialEq, Eq)]
153 /// struct Foo {
154 /// bar: u8,
155 /// baz: u16,
156 /// }
157 ///
158 /// // The buffer can be any type that implements `Buf`.
159 /// let buffer = [0_u8, 0, 0, 3, 1, 2, 3];
160 ///
161 /// // Deserialize a value with a 32-bit length field from the buffer.
162 /// let value = LengthU32::deserialize_with::<_, Foo, _>(
163 /// |mut buffer| {
164 /// Ok(Foo {
165 /// bar: u8::deserialize(buffer)?,
166 /// baz: u16::deserialize(buffer)?,
167 /// })
168 /// },
169 /// &mut buffer.as_slice())?;
170 /// assert_eq!(value, Foo { bar: 1_u8, baz: 0x0203_u16 });
171 /// # Ok(()) }
172 /// ```
173 fn deserialize_with<Buffer, Value, Function>(
174 function: Function,
175 buffer: &mut Buffer,
176 ) -> Result<Value, DeserializeError>
177 where
178 Buffer: Buf + ?Sized,
179 for<'any> Function: Fn(&mut dyn Buf) -> Result<Value, DeserializeError>;
180
181 /// Returns the size of the length field in bytes.
182 ///
183 /// # Examples
184 ///
185 /// ```rust
186 /// use rsomeip_bytes::{Length as _, LengthZero, LengthU8, LengthU16, LengthU32};
187 ///
188 /// assert_eq!(LengthZero::size(), 0);
189 /// assert_eq!(LengthU8::size(), 1);
190 /// assert_eq!(LengthU16::size(), 2);
191 /// assert_eq!(LengthU32::size(), 4);
192 /// ```
193 #[must_use]
194 fn size() -> usize;
195
196 /// Returns the capacity of the length field.
197 ///
198 /// This is the maximum value that the field can represent.
199 ///
200 /// Returns [`None`] is the capacity is greater than [`usize::MAX`].
201 ///
202 /// # Examples
203 ///
204 /// ```rust
205 /// use rsomeip_bytes::{Length as _, LengthZero, LengthU8, LengthU16, LengthU32};
206 ///
207 /// assert_eq!(LengthZero::capacity(), Some(usize::MAX));
208 /// assert_eq!(LengthU8::capacity(), Some(0xff));
209 /// assert_eq!(LengthU16::capacity(), Some(0xffff));
210 /// assert_eq!(LengthU32::capacity(), Some(0xffff_ffff));
211 /// ```
212 #[must_use]
213 fn capacity() -> Option<usize>;
214}
215
216/// Sealed trait to prevent external implementations.
217pub trait Sealed {}
218
219/// Implementation details common among length fields.
220macro_rules! impl_length_field {
221 ($name:ident, $repr:ident) => {
222 impl $name {
223 /// Minimum value of the length field.
224 pub const MIN: $repr = <$repr>::MIN;
225
226 /// Maximum value of the length field.
227 pub const MAX: $repr = <$repr>::MAX;
228 }
229
230 impl Length for $name {
231 fn serialize<Buffer, Value>(
232 value: &Value,
233 buffer: &mut Buffer,
234 ) -> Result<usize, $crate::SerializeError>
235 where
236 Value: $crate::Serialize,
237 Buffer: ::bytes::BufMut + ?Sized,
238 {
239 value
240 .size()
241 .ok_or($crate::SerializeError::SizeOverflow)
242 .and_then(|size| {
243 // Check if the size fits inside of the length field.
244 let Ok(length) = <$repr>::try_from(size) else {
245 return Err($crate::SerializeError::LengthOverflow);
246 };
247 // Serialize the length.
248 length.serialize(buffer)?;
249 // Serialize the value.
250 let actual_size = value.serialize(buffer)?;
251 // Checks if the sizes differ.
252 if actual_size != size {
253 return Err($crate::SerializeError::SizeMismatch);
254 }
255 // Add the length field to the total length.
256 actual_size
257 .checked_add(Self::size())
258 .ok_or($crate::SerializeError::SizeOverflow)
259 })
260 }
261
262 fn serialize_with<Buffer, Value, SerializeFn, SizeFn>(
263 serialize: SerializeFn,
264 size: SizeFn,
265 value: Value,
266 mut buffer: &mut Buffer,
267 ) -> Result<usize, SerializeError>
268 where
269 Buffer: BufMut + ?Sized,
270 for<'any> SerializeFn: Fn(&Value, &mut dyn BufMut) -> Result<usize, SerializeError>,
271 for<'any> SizeFn: Fn(&Value) -> Option<usize>,
272 {
273 size(&value)
274 .ok_or($crate::SerializeError::SizeOverflow)
275 .and_then(|size| {
276 // Check if the size fits inside of the length field.
277 let Ok(length) = <$repr>::try_from(size) else {
278 return Err($crate::SerializeError::LengthOverflow);
279 };
280 // Serialize the length.
281 length.serialize(buffer)?;
282 // Serialize the value.
283 let actual_size = serialize(&value, &mut buffer)?;
284 // Checks if the sizes differ.
285 if actual_size != size {
286 return Err($crate::SerializeError::SizeMismatch);
287 }
288 // Add the length field to the total length.
289 actual_size
290 .checked_add(Self::size())
291 .ok_or($crate::SerializeError::SizeOverflow)
292 })
293 }
294
295 fn deserialize<Buffer, Value>(
296 buffer: &mut Buffer,
297 ) -> Result<Value::Output, DeserializeError>
298 where
299 Buffer: Buf + ?Sized,
300 Value: Deserialize,
301 {
302 <$repr>::deserialize(buffer).and_then(|length| {
303 usize::try_from(length)
304 .map_err(|_| DeserializeError::LengthOverflow)
305 .and_then(|length| {
306 if length > buffer.remaining() {
307 return Err(DeserializeError::InsufficientData);
308 }
309 let mut take = buffer.take(length);
310 Value::deserialize(&mut take)
311 })
312 })
313 }
314
315 fn deserialize_with<Buffer, Value, Function>(
316 function: Function,
317 buffer: &mut Buffer,
318 ) -> Result<Value, DeserializeError>
319 where
320 Buffer: Buf + ?Sized,
321 for<'any> Function: Fn(&mut dyn Buf) -> Result<Value, DeserializeError>,
322 {
323 <$repr>::deserialize(buffer).and_then(|length| {
324 usize::try_from(length)
325 .map_err(|_| DeserializeError::LengthOverflow)
326 .and_then(|length| {
327 if length > buffer.remaining() {
328 return Err(DeserializeError::InsufficientData);
329 }
330 let mut take = buffer.take(length);
331 function(&mut take)
332 })
333 })
334 }
335
336 #[inline]
337 fn size() -> usize {
338 ::core::mem::size_of::<$repr>()
339 }
340
341 #[inline]
342 fn capacity() -> Option<usize> {
343 usize::try_from(Self::MAX).ok()
344 }
345 }
346
347 impl Sealed for $name {}
348 };
349}
350
351/// 8-bit length field.
352///
353/// Used to encode lengths between 0 and 255 bytes long.
354///
355/// Normally used together with [`DynamicArray`] and [`DynamicString`].
356///
357/// [`DynamicArray`]: crate::DynamicArray
358/// [`DynamicString`]: crate::DynamicString
359#[derive(Debug, Clone, Copy, PartialEq, Eq)]
360pub struct LengthU8;
361
362impl_length_field!(LengthU8, u8);
363
364/// 16-bit length field.
365///
366/// Used to encode lengths between 0 and 65'535 bytes long.
367///
368/// Normally used together with [`DynamicArray`] and [`DynamicString`].
369///
370/// [`DynamicArray`]: crate::DynamicArray
371/// [`DynamicString`]: crate::DynamicString
372#[derive(Debug, Clone, Copy, PartialEq, Eq)]
373pub struct LengthU16;
374
375impl_length_field!(LengthU16, u16);
376
377/// 32-bit length field.
378///
379/// Used to encode lengths between 0 and 4'294'967'295 bytes long.
380///
381/// Normally used together with [`DynamicArray`] and [`DynamicString`].
382///
383/// [`DynamicArray`]: crate::DynamicArray
384/// [`DynamicString`]: crate::DynamicString
385#[derive(Debug, Clone, Copy, PartialEq, Eq)]
386pub struct LengthU32;
387
388impl_length_field!(LengthU32, u32);
389
390/// 0-bit length field.
391///
392/// Used to skip length encoding.
393///
394/// Normally used together with [`DynamicArray`] and [`DynamicString`].
395///
396/// [`DynamicArray`]: crate::DynamicArray
397/// [`DynamicString`]: crate::DynamicString
398#[derive(Debug, Clone, Copy, PartialEq, Eq)]
399pub struct LengthZero;
400
401impl Length for LengthZero {
402 #[inline]
403 fn serialize<Buffer, Value>(value: &Value, buffer: &mut Buffer) -> Result<usize, SerializeError>
404 where
405 Buffer: BufMut + ?Sized,
406 Value: Serialize,
407 {
408 value.serialize(buffer)
409 }
410
411 #[inline]
412 fn serialize_with<Buffer, Value, SerializeFn, SizeFn>(
413 serialize: SerializeFn,
414 _size: SizeFn,
415 value: Value,
416 mut buffer: &mut Buffer,
417 ) -> Result<usize, SerializeError>
418 where
419 Buffer: BufMut + ?Sized,
420 for<'any> SerializeFn: Fn(&Value, &mut dyn BufMut) -> Result<usize, SerializeError>,
421 for<'any> SizeFn: Fn(&Value) -> Option<usize>,
422 {
423 (serialize)(&value, &mut buffer)
424 }
425
426 #[inline]
427 fn deserialize<Buffer, Value>(buffer: &mut Buffer) -> Result<Value::Output, DeserializeError>
428 where
429 Buffer: Buf + ?Sized,
430 Value: Deserialize,
431 {
432 Value::deserialize(buffer)
433 }
434
435 #[inline]
436 fn deserialize_with<Buffer, Value, Function>(
437 function: Function,
438 mut buffer: &mut Buffer,
439 ) -> Result<Value, DeserializeError>
440 where
441 Buffer: Buf + ?Sized,
442 for<'any> Function: Fn(&mut dyn Buf) -> Result<Value, DeserializeError>,
443 {
444 (function)(&mut buffer)
445 }
446
447 #[inline]
448 fn size() -> usize {
449 0
450 }
451
452 #[inline]
453 fn capacity() -> Option<usize> {
454 Some(usize::MAX)
455 }
456}
457
458impl Sealed for LengthZero {}
459
460/// Wrapper for serializing a value with a preceding length field.
461///
462/// See also [`Length::serialize`].
463///
464/// # Examples
465///
466/// ```rust
467/// # fn main() -> Result<(), Box<dyn std::error::Error>> {
468/// use rsomeip_bytes::{SerializeWithLength, LengthU32, Serialize as _};
469///
470/// let wrapper = SerializeWithLength::<LengthU32, _>::from(&1_u16);
471/// assert_eq!(Some(6), wrapper.size());
472///
473/// let bytes = wrapper.to_bytes()?;
474/// assert_eq!(&bytes, [0_u8, 0, 0, 2, 0, 1].as_slice());
475/// # Ok(()) }
476/// ```
477pub struct SerializeWithLength<'value, Length, Value> {
478 /// Value to serialize.
479 value: &'value Value,
480 /// Length to serialize before the value.
481 _length: PhantomData<Length>,
482}
483
484impl<'value, Length, Value> From<&'value Value> for SerializeWithLength<'value, Length, Value>
485where
486 Length: crate::Length,
487 Value: Serialize,
488{
489 fn from(value: &'value Value) -> Self {
490 Self {
491 value,
492 _length: PhantomData,
493 }
494 }
495}
496
497impl<Length, Value> Serialize for SerializeWithLength<'_, Length, Value>
498where
499 Length: crate::Length,
500 Value: Serialize,
501{
502 fn serialize<Buffer>(&self, buffer: &mut Buffer) -> Result<usize, SerializeError>
503 where
504 Buffer: BufMut + ?Sized,
505 {
506 Length::serialize(self.value, buffer)
507 }
508
509 fn size(&self) -> Option<usize> {
510 self.value
511 .size()
512 .and_then(|size| size.checked_add(Length::size()))
513 }
514}
515
516/// Wrapper for deserializing a value with a preceding length field.
517///
518/// See also [`Length::deserialize`].
519///
520/// # Examples
521///
522/// ```rust
523/// # fn main() -> Result<(), Box<dyn std::error::Error>> {
524/// use rsomeip_bytes::{DeserializeWithLength, LengthU32, Deserialize as _};
525///
526/// // Size hint includes the length field.
527/// assert_eq!(Some(4), DeserializeWithLength::<LengthU32, u16>::size_hint());
528///
529/// let mut buffer = [0_u8, 0, 0, 2, 0, 1];
530/// let value = DeserializeWithLength::<LengthU32, u16>::deserialize(&mut buffer.as_slice())?;
531/// assert_eq!(value, 1_u16);
532/// # Ok(()) }
533/// ```
534pub struct DeserializeWithLength<Length, Value> {
535 /// Length to deserialize before the value.
536 _length: PhantomData<Length>,
537 /// Value to deserialize.
538 _value: PhantomData<Value>,
539}
540
541impl<Length, Value> Deserialize for DeserializeWithLength<Length, Value>
542where
543 Length: crate::Length,
544 Value: Deserialize,
545{
546 type Output = Value::Output;
547
548 fn deserialize<Buffer>(buffer: &mut Buffer) -> Result<Self::Output, DeserializeError>
549 where
550 Buffer: Buf + ?Sized,
551 {
552 Length::deserialize::<_, Value>(buffer)
553 }
554
555 fn size_hint() -> Option<usize> {
556 Some(Length::size())
557 }
558}
559
560#[cfg(test)]
561#[expect(clippy::inline_modules, reason = "rust-clippy#17342")]
562mod tests {
563 use super::*;
564 use crate::Serialize;
565 use bytes::{Bytes, BytesMut};
566
567 #[test]
568 fn serialize_length_overflow() {
569 let mut buffer = BytesMut::new();
570 let value = BytesMut::zeroed(0x1_0000_0000_usize).freeze();
571 assert_eq!(
572 LengthU8::serialize(&value, &mut buffer),
573 Err(SerializeError::LengthOverflow)
574 );
575 assert_eq!(
576 LengthU16::serialize(&value, &mut buffer),
577 Err(SerializeError::LengthOverflow)
578 );
579 assert_eq!(
580 LengthU32::serialize(&value, &mut buffer),
581 Err(SerializeError::LengthOverflow)
582 );
583 assert_eq!(
584 LengthU8::serialize_with(
585 |value, buffer| value.serialize(buffer),
586 Serialize::size,
587 value.clone(),
588 &mut buffer
589 ),
590 Err(SerializeError::LengthOverflow)
591 );
592 assert_eq!(
593 LengthU16::serialize_with(
594 |value, buffer| value.serialize(buffer),
595 Serialize::size,
596 value.clone(),
597 &mut buffer
598 ),
599 Err(SerializeError::LengthOverflow)
600 );
601 assert_eq!(
602 LengthU32::serialize_with(
603 |value, buffer| value.serialize(buffer),
604 Serialize::size,
605 value,
606 &mut buffer
607 ),
608 Err(SerializeError::LengthOverflow)
609 );
610 }
611
612 #[test]
613 fn serialize_size_mismatch() {
614 // Custom type with incorrect Serialize impl.
615 struct Foo;
616 impl Serialize for Foo {
617 fn serialize<Buffer>(&self, _buffer: &mut Buffer) -> Result<usize, SerializeError>
618 where
619 Buffer: BufMut + ?Sized,
620 {
621 Ok(2)
622 }
623
624 fn size(&self) -> Option<usize> {
625 Some(1)
626 }
627 }
628
629 let mut buffer = BytesMut::new();
630 assert_eq!(
631 LengthU8::serialize(&Foo, &mut buffer),
632 Err(SerializeError::SizeMismatch)
633 );
634 assert_eq!(
635 LengthU16::serialize(&Foo, &mut buffer),
636 Err(SerializeError::SizeMismatch)
637 );
638 assert_eq!(
639 LengthU32::serialize(&Foo, &mut buffer),
640 Err(SerializeError::SizeMismatch)
641 );
642 assert_eq!(
643 LengthU8::serialize_with(|_value, _buffer| Ok(2), |_value| Some(1), 0_u8, &mut buffer),
644 Err(SerializeError::SizeMismatch)
645 );
646 assert_eq!(
647 LengthU16::serialize_with(|_value, _buffer| Ok(2), |_value| Some(1), 0_u8, &mut buffer),
648 Err(SerializeError::SizeMismatch)
649 );
650 assert_eq!(
651 LengthU32::serialize_with(|_value, _buffer| Ok(2), |_value| Some(1), 0_u8, &mut buffer),
652 Err(SerializeError::SizeMismatch)
653 );
654 }
655
656 #[test]
657 fn deserialize_insufficient_data() {
658 let mut buffer = Bytes::copy_from_slice(&[0xff_u8, 0xff, 0xff, 0xff, 1]);
659 assert_eq!(
660 LengthU8::deserialize::<_, u8>(&mut buffer.clone()),
661 Err(DeserializeError::InsufficientData)
662 );
663 assert_eq!(
664 LengthU16::deserialize::<_, u8>(&mut buffer.clone()),
665 Err(DeserializeError::InsufficientData)
666 );
667 assert_eq!(
668 LengthU32::deserialize::<_, u8>(&mut buffer.clone()),
669 Err(DeserializeError::InsufficientData)
670 );
671 assert_eq!(
672 LengthU8::deserialize_with::<_, u8, _>(
673 |buffer| u8::deserialize(buffer),
674 &mut buffer.clone()
675 ),
676 Err(DeserializeError::InsufficientData)
677 );
678 assert_eq!(
679 LengthU16::deserialize_with::<_, u8, _>(
680 |buffer| u8::deserialize(buffer),
681 &mut buffer.clone()
682 ),
683 Err(DeserializeError::InsufficientData)
684 );
685 assert_eq!(
686 LengthU32::deserialize_with::<_, u8, _>(|buffer| u8::deserialize(buffer), &mut buffer),
687 Err(DeserializeError::InsufficientData)
688 );
689 }
690
691 #[test]
692 fn serialize_length_zero() {
693 let mut buffer = BytesMut::with_capacity(2);
694 assert_eq!(Ok(1), LengthZero::serialize(&1_u8, &mut buffer));
695 assert_eq!(
696 Ok(1),
697 LengthZero::serialize_with(
698 |value, buffer| value.serialize(buffer),
699 Serialize::size,
700 2_u8,
701 &mut buffer
702 )
703 );
704 assert_eq!(&buffer.freeze(), [1_u8, 2_u8].as_slice());
705 }
706
707 #[test]
708 fn deserialize_length_zero() {
709 let mut buffer = Bytes::copy_from_slice(&[1_u8, 2]);
710 assert_eq!(Ok(1_u8), LengthZero::deserialize::<_, u8>(&mut buffer));
711 assert_eq!(
712 Ok(2_u8),
713 LengthZero::deserialize_with::<_, u8, _>(|buffer| u8::deserialize(buffer), &mut buffer)
714 );
715 }
716}