serde_assert/
ser.rs

1//! Testing serialization implementations.
2//!
3//! This module provides a [`Serializer`] struct for testing serialization. Construction of this
4//! struct uses the builder pattern through the [`Builder`] struct, allowing configuration of the
5//! behavior of the `Serializer`.
6//!
7//! # Example
8//!
9//! ``` rust
10//! use claims::assert_ok_eq;
11//! use serde::Serialize;
12//! use serde_assert::{
13//!     Serializer,
14//!     Token,
15//! };
16//!
17//! let serializer = Serializer::builder().build();
18//!
19//! assert_ok_eq!(true.serialize(&serializer), [Token::Bool(true)]);
20//! ```
21
22use crate::token::{
23    CanonicalToken,
24    Tokens,
25};
26use alloc::{
27    borrow::ToOwned,
28    string::{
29        String,
30        ToString,
31    },
32    vec,
33};
34use core::{
35    fmt,
36    fmt::Display,
37};
38use serde::{
39    ser,
40    ser::{
41        SerializeMap,
42        SerializeSeq,
43        SerializeStructVariant,
44        SerializeTuple,
45        SerializeTupleStruct,
46        SerializeTupleVariant,
47    },
48    Serialize,
49};
50
51/// Configuration for serializing `struct`s.
52///
53/// Can be passed to a [`Builder`] to determine how `struct`s should be serialized by the
54/// [`Serializer`].
55///
56/// # Example
57/// ``` rust
58/// use claims::assert_ok_eq;
59/// use serde::Serialize;
60/// use serde_assert::{
61///     ser::SerializeStructAs,
62///     Serializer,
63///     Token,
64/// };
65/// # use serde_derive::Serialize;
66///
67/// #[derive(Serialize)]
68/// struct Struct {
69///     foo: bool,
70///     bar: u32,
71/// }
72///
73/// let some_struct = Struct {
74///     foo: false,
75///     bar: 42,
76/// };
77/// let serializer = Serializer::builder()
78///     .serialize_struct_as(SerializeStructAs::Seq)
79///     .build();
80///
81/// assert_ok_eq!(
82///     some_struct.serialize(&serializer),
83///     [
84///         Token::Seq { len: Some(2) },
85///         Token::Bool(false),
86///         Token::U32(42),
87///         Token::SeqEnd,
88///     ]
89/// );
90/// ```
91#[derive(Clone, Copy, Debug)]
92pub enum SerializeStructAs {
93    /// Serialize structs using [`Token::Struct`].
94    ///
95    /// [`Token::Struct`]: crate::Token::Struct
96    Struct,
97    /// Serialize structs using [`Token::Seq`].
98    ///
99    /// This type of serialization is often done by compact serialization formats. Using this
100    /// setting simulates those serializers.
101    ///
102    /// [`Token::Seq`]: crate::Token::Seq
103    Seq,
104}
105
106/// Serializer for testing [`Serialize`] implementations.
107///
108/// This serializer outputs [`Tokens`] representing the serialized value. The `Tokens` can be
109/// compared against an expected sequence of [`Token`]s to ensure the serialization is correct.
110///
111/// # Configuration
112/// The following options can be configured on the [`Builder`]:
113///
114/// - [`is_human_readable()`]: Determines whether the serializer will serialize values in a readable
115///   format or a compact format. Useful for complicated structs wishing to provide different
116///   outputs depending on the readability of the serialization type.
117/// - [`serialize_struct_as()`]: Specifies how the serializer should serialize structs. Compact
118///   formats often serialize structs as sequences. By enabling this setting, tokens can be produced
119///   in this format, and can then be deserialized to ensure structs deserialized as sequences are
120///   deserialized correctly.
121///
122/// # Example
123///
124/// ``` rust
125/// use claims::assert_ok_eq;
126/// use serde::Serialize;
127/// use serde_assert::{
128///     Serializer,
129///     Token,
130/// };
131///
132/// let serializer = Serializer::builder().build();
133///
134/// assert_ok_eq!(true.serialize(&serializer), [Token::Bool(true)]);
135/// ```
136///
137/// [`is_human_readable()`]: Builder::is_human_readable()
138/// [`serialize_struct_as()`]: Builder::serialize_struct_as()
139/// [`Serialize`]: serde::Serialize
140/// [`Token`]: crate::Token
141#[derive(Debug)]
142pub struct Serializer {
143    is_human_readable: bool,
144    serialize_struct_as: SerializeStructAs,
145}
146
147impl<'a> ser::Serializer for &'a Serializer {
148    type Ok = Tokens;
149    type Error = Error;
150
151    type SerializeSeq = CompoundSerializer<'a>;
152    type SerializeTuple = CompoundSerializer<'a>;
153    type SerializeTupleStruct = CompoundSerializer<'a>;
154    type SerializeTupleVariant = CompoundSerializer<'a>;
155    type SerializeMap = CompoundSerializer<'a>;
156    type SerializeStruct = SerializeStruct<'a>;
157    type SerializeStructVariant = CompoundSerializer<'a>;
158
159    fn serialize_bool(self, v: bool) -> Result<Tokens, Error> {
160        Ok(Tokens(vec![CanonicalToken::Bool(v)]))
161    }
162
163    fn serialize_i8(self, v: i8) -> Result<Tokens, Error> {
164        Ok(Tokens(vec![CanonicalToken::I8(v)]))
165    }
166
167    fn serialize_i16(self, v: i16) -> Result<Tokens, Error> {
168        Ok(Tokens(vec![CanonicalToken::I16(v)]))
169    }
170
171    fn serialize_i32(self, v: i32) -> Result<Tokens, Error> {
172        Ok(Tokens(vec![CanonicalToken::I32(v)]))
173    }
174
175    fn serialize_i64(self, v: i64) -> Result<Tokens, Error> {
176        Ok(Tokens(vec![CanonicalToken::I64(v)]))
177    }
178
179    fn serialize_i128(self, v: i128) -> Result<Tokens, Error> {
180        Ok(Tokens(vec![CanonicalToken::I128(v)]))
181    }
182
183    fn serialize_u8(self, v: u8) -> Result<Tokens, Error> {
184        Ok(Tokens(vec![CanonicalToken::U8(v)]))
185    }
186
187    fn serialize_u16(self, v: u16) -> Result<Tokens, Error> {
188        Ok(Tokens(vec![CanonicalToken::U16(v)]))
189    }
190
191    fn serialize_u32(self, v: u32) -> Result<Tokens, Error> {
192        Ok(Tokens(vec![CanonicalToken::U32(v)]))
193    }
194
195    fn serialize_u64(self, v: u64) -> Result<Tokens, Error> {
196        Ok(Tokens(vec![CanonicalToken::U64(v)]))
197    }
198
199    fn serialize_u128(self, v: u128) -> Result<Tokens, Error> {
200        Ok(Tokens(vec![CanonicalToken::U128(v)]))
201    }
202
203    fn serialize_f32(self, v: f32) -> Result<Tokens, Error> {
204        Ok(Tokens(vec![CanonicalToken::F32(v)]))
205    }
206
207    fn serialize_f64(self, v: f64) -> Result<Tokens, Error> {
208        Ok(Tokens(vec![CanonicalToken::F64(v)]))
209    }
210
211    fn serialize_char(self, v: char) -> Result<Tokens, Error> {
212        Ok(Tokens(vec![CanonicalToken::Char(v)]))
213    }
214
215    fn serialize_str(self, v: &str) -> Result<Tokens, Error> {
216        Ok(Tokens(vec![CanonicalToken::Str(v.to_owned())]))
217    }
218
219    fn serialize_bytes(self, v: &[u8]) -> Result<Tokens, Error> {
220        Ok(Tokens(vec![CanonicalToken::Bytes(v.to_owned())]))
221    }
222
223    fn serialize_none(self) -> Result<Tokens, Error> {
224        Ok(Tokens(vec![CanonicalToken::None]))
225    }
226
227    fn serialize_some<T>(self, value: &T) -> Result<Tokens, Error>
228    where
229        T: Serialize + ?Sized,
230    {
231        let mut tokens = Tokens(vec![CanonicalToken::Some]);
232        tokens.0.extend(value.serialize(self)?.0);
233        Ok(tokens)
234    }
235
236    fn serialize_unit(self) -> Result<Tokens, Error> {
237        Ok(Tokens(vec![CanonicalToken::Unit]))
238    }
239
240    fn serialize_unit_struct(self, name: &'static str) -> Result<Tokens, Error> {
241        Ok(Tokens(vec![CanonicalToken::UnitStruct { name }]))
242    }
243
244    fn serialize_unit_variant(
245        self,
246        name: &'static str,
247        variant_index: u32,
248        variant: &'static str,
249    ) -> Result<Tokens, Error> {
250        Ok(Tokens(vec![CanonicalToken::UnitVariant {
251            name,
252            variant_index,
253            variant,
254        }]))
255    }
256
257    fn serialize_newtype_struct<T>(self, name: &'static str, value: &T) -> Result<Tokens, Error>
258    where
259        T: Serialize + ?Sized,
260    {
261        let mut tokens = Tokens(vec![CanonicalToken::NewtypeStruct { name }]);
262        tokens.0.extend(value.serialize(self)?.0);
263        Ok(tokens)
264    }
265
266    fn serialize_newtype_variant<T>(
267        self,
268        name: &'static str,
269        variant_index: u32,
270        variant: &'static str,
271        value: &T,
272    ) -> Result<Tokens, Error>
273    where
274        T: Serialize + ?Sized,
275    {
276        let mut tokens = Tokens(vec![CanonicalToken::NewtypeVariant {
277            name,
278            variant_index,
279            variant,
280        }]);
281        tokens.0.extend(value.serialize(self)?.0);
282        Ok(tokens)
283    }
284
285    fn serialize_seq(self, len: Option<usize>) -> Result<CompoundSerializer<'a>, Error> {
286        Ok(CompoundSerializer {
287            tokens: Tokens(vec![CanonicalToken::Seq { len }]),
288
289            serializer: self,
290        })
291    }
292
293    fn serialize_tuple(self, len: usize) -> Result<CompoundSerializer<'a>, Error> {
294        Ok(CompoundSerializer {
295            tokens: Tokens(vec![CanonicalToken::Tuple { len }]),
296
297            serializer: self,
298        })
299    }
300
301    fn serialize_tuple_struct(
302        self,
303        name: &'static str,
304        len: usize,
305    ) -> Result<CompoundSerializer<'a>, Error> {
306        Ok(CompoundSerializer {
307            tokens: Tokens(vec![CanonicalToken::TupleStruct { name, len }]),
308
309            serializer: self,
310        })
311    }
312
313    fn serialize_tuple_variant(
314        self,
315        name: &'static str,
316        variant_index: u32,
317        variant: &'static str,
318        len: usize,
319    ) -> Result<CompoundSerializer<'a>, Error> {
320        Ok(CompoundSerializer {
321            tokens: Tokens(vec![CanonicalToken::TupleVariant {
322                name,
323                variant_index,
324                variant,
325                len,
326            }]),
327
328            serializer: self,
329        })
330    }
331
332    fn serialize_map(self, len: Option<usize>) -> Result<CompoundSerializer<'a>, Error> {
333        Ok(CompoundSerializer {
334            tokens: Tokens(vec![CanonicalToken::Map { len }]),
335
336            serializer: self,
337        })
338    }
339
340    fn serialize_struct(
341        self,
342        name: &'static str,
343        len: usize,
344    ) -> Result<SerializeStruct<'a>, Error> {
345        match self.serialize_struct_as {
346            SerializeStructAs::Struct => Ok(SerializeStruct {
347                tokens: Tokens(vec![CanonicalToken::Struct { name, len }]),
348
349                serializer: self,
350
351                serialize_struct_as: self.serialize_struct_as,
352            }),
353            SerializeStructAs::Seq => Ok(SerializeStruct {
354                tokens: Tokens(vec![CanonicalToken::Seq { len: Some(len) }]),
355
356                serializer: self,
357
358                serialize_struct_as: self.serialize_struct_as,
359            }),
360        }
361    }
362
363    fn serialize_struct_variant(
364        self,
365        name: &'static str,
366        variant_index: u32,
367        variant: &'static str,
368        len: usize,
369    ) -> Result<CompoundSerializer<'a>, Error> {
370        Ok(CompoundSerializer {
371            tokens: Tokens(vec![CanonicalToken::StructVariant {
372                name,
373                variant_index,
374                variant,
375                len,
376            }]),
377
378            serializer: self,
379        })
380    }
381
382    fn collect_str<T>(self, value: &T) -> Result<Tokens, Error>
383    where
384        T: Display + ?Sized,
385    {
386        Ok(Tokens(vec![CanonicalToken::Str(value.to_string())]))
387    }
388
389    fn is_human_readable(&self) -> bool {
390        self.is_human_readable
391    }
392}
393
394impl Serializer {
395    /// Returns a [`Builder`] for a [`Serializer`].
396    ///
397    /// # Example
398    /// ``` rust
399    /// use serde_assert::Serializer;
400    ///
401    /// let serializer = Serializer::builder().is_human_readable(false).build();
402    /// ```
403    #[must_use]
404    pub fn builder() -> Builder {
405        Builder::default()
406    }
407}
408
409/// A builder for a [`Serializer`].
410///
411/// Construction of a `Serializer` follows the builder pattern. Configuration options can be set on
412/// the `Builder`, and then the actual `Serializer` is constructed by calling [`build()`].
413///
414/// # Example
415/// ``` rust
416/// use serde_assert::Serializer;
417///
418/// let serializer = Serializer::builder().is_human_readable(false).build();
419/// ```
420///
421/// [`build()`]: Builder::build()
422#[derive(Debug)]
423pub struct Builder {
424    is_human_readable: bool,
425    serialize_struct_as: SerializeStructAs,
426}
427
428impl Builder {
429    /// Determines whether the serializer will serialize values in a readable format or a compact
430    /// format.
431    ///
432    /// Useful for complicated structs wishing to provide different outputs depending on
433    /// the readability of the serialization type.
434    ///
435    /// If not set, the default value is `true`.
436    ///
437    /// # Example
438    /// ``` rust
439    /// use serde_assert::Serializer;
440    ///
441    /// let serializer = Serializer::builder().is_human_readable(false).build();
442    /// ```
443    pub fn is_human_readable(&mut self, is_human_readable: bool) -> &mut Self {
444        self.is_human_readable = is_human_readable;
445        self
446    }
447
448    /// Specifies how the serializer should serialize structs.
449    ///
450    /// Compact formats often serialize structs as sequences. By enabling this setting, tokens can
451    /// be produced in this format, and can then be deserialized to ensure structs deserialized as
452    /// sequences are deserialized correctly.
453    ///
454    /// If not set, the default value is [`SerializeStructAs::Struct`].
455    ///
456    /// # Example
457    /// ``` rust
458    /// use claims::assert_ok_eq;
459    /// use serde::Serialize;
460    /// use serde_assert::{
461    ///     ser::SerializeStructAs,
462    ///     Serializer,
463    ///     Token,
464    /// };
465    /// # use serde_derive::Serialize;
466    ///
467    /// #[derive(Serialize)]
468    /// struct Struct {
469    ///     foo: bool,
470    ///     bar: u32,
471    /// }
472    ///
473    /// let some_struct = Struct {
474    ///     foo: false,
475    ///     bar: 42,
476    /// };
477    /// let serializer = Serializer::builder()
478    ///     .serialize_struct_as(SerializeStructAs::Seq)
479    ///     .build();
480    ///
481    /// assert_ok_eq!(
482    ///     some_struct.serialize(&serializer),
483    ///     [
484    ///         Token::Seq { len: Some(2) },
485    ///         Token::Bool(false),
486    ///         Token::U32(42),
487    ///         Token::SeqEnd,
488    ///     ]
489    /// );
490    /// ```
491    pub fn serialize_struct_as(&mut self, serialize_struct_as: SerializeStructAs) -> &mut Self {
492        self.serialize_struct_as = serialize_struct_as;
493        self
494    }
495
496    /// Build a new [`Serializer`] using this `Builder`.
497    ///
498    /// Constructs a new `Serializer` using the configuration options set on this `Builder`.
499    ///
500    /// # Example
501    /// ``` rust
502    /// use serde_assert::Serializer;
503    ///
504    /// let serializer = Serializer::builder().is_human_readable(false).build();
505    /// ```
506    pub fn build(&mut self) -> Serializer {
507        Serializer {
508            is_human_readable: self.is_human_readable,
509            serialize_struct_as: self.serialize_struct_as,
510        }
511    }
512}
513
514impl Default for Builder {
515    fn default() -> Self {
516        Self {
517            is_human_readable: true,
518            serialize_struct_as: SerializeStructAs::Struct,
519        }
520    }
521}
522
523/// Serializer for serializing compound types.
524///
525/// This type implements [`SerializeSeq`], [`SerializeTuple`], [`SerializeTupleStruct`],
526/// [`SerializeTupleVariant`], [`SerializeMap`], [`SerializeStruct`], and
527/// [`SerializeStructVariant`], and is used by [`Serializer`] for serialization of each of those
528/// compound data types.
529///
530/// Users normally will not need to interact with this type directly. It is primarily used by
531/// [`Serialize`] implementations through the various traits it implements.
532#[derive(Debug)]
533pub struct CompoundSerializer<'a> {
534    tokens: Tokens,
535
536    serializer: &'a Serializer,
537}
538
539impl SerializeSeq for CompoundSerializer<'_> {
540    type Ok = Tokens;
541    type Error = Error;
542
543    fn serialize_element<T>(&mut self, value: &T) -> Result<(), Error>
544    where
545        T: Serialize + ?Sized,
546    {
547        self.tokens.0.extend(value.serialize(self.serializer)?.0);
548        Ok(())
549    }
550
551    fn end(mut self) -> Result<Tokens, Error> {
552        self.tokens.0.push(CanonicalToken::SeqEnd);
553        Ok(self.tokens)
554    }
555}
556
557impl SerializeTuple for CompoundSerializer<'_> {
558    type Ok = Tokens;
559    type Error = Error;
560
561    fn serialize_element<T>(&mut self, value: &T) -> Result<(), Error>
562    where
563        T: Serialize + ?Sized,
564    {
565        self.tokens.0.extend(value.serialize(self.serializer)?.0);
566        Ok(())
567    }
568
569    fn end(mut self) -> Result<Tokens, Error> {
570        self.tokens.0.push(CanonicalToken::TupleEnd);
571        Ok(self.tokens)
572    }
573}
574
575impl SerializeTupleStruct for CompoundSerializer<'_> {
576    type Ok = Tokens;
577    type Error = Error;
578
579    fn serialize_field<T>(&mut self, value: &T) -> Result<(), Error>
580    where
581        T: Serialize + ?Sized,
582    {
583        self.tokens.0.extend(value.serialize(self.serializer)?.0);
584        Ok(())
585    }
586
587    fn end(mut self) -> Result<Tokens, Error> {
588        self.tokens.0.push(CanonicalToken::TupleStructEnd);
589        Ok(self.tokens)
590    }
591}
592
593impl SerializeTupleVariant for CompoundSerializer<'_> {
594    type Ok = Tokens;
595    type Error = Error;
596
597    fn serialize_field<T>(&mut self, value: &T) -> Result<(), Error>
598    where
599        T: Serialize + ?Sized,
600    {
601        self.tokens.0.extend(value.serialize(self.serializer)?.0);
602        Ok(())
603    }
604
605    fn end(mut self) -> Result<Tokens, Error> {
606        self.tokens.0.push(CanonicalToken::TupleVariantEnd);
607        Ok(self.tokens)
608    }
609}
610
611impl SerializeMap for CompoundSerializer<'_> {
612    type Ok = Tokens;
613    type Error = Error;
614
615    fn serialize_key<T>(&mut self, value: &T) -> Result<(), Error>
616    where
617        T: Serialize + ?Sized,
618    {
619        self.tokens.0.extend(value.serialize(self.serializer)?.0);
620        Ok(())
621    }
622
623    fn serialize_value<T>(&mut self, value: &T) -> Result<(), Error>
624    where
625        T: Serialize + ?Sized,
626    {
627        self.tokens.0.extend(value.serialize(self.serializer)?.0);
628        Ok(())
629    }
630
631    fn end(mut self) -> Result<Tokens, Error> {
632        self.tokens.0.push(CanonicalToken::MapEnd);
633        Ok(self.tokens)
634    }
635}
636
637impl SerializeStructVariant for CompoundSerializer<'_> {
638    type Ok = Tokens;
639    type Error = Error;
640
641    fn serialize_field<T>(&mut self, key: &'static str, value: &T) -> Result<(), Error>
642    where
643        T: Serialize + ?Sized,
644    {
645        self.tokens.0.push(CanonicalToken::Field(key));
646        self.tokens.0.extend(value.serialize(self.serializer)?.0);
647        Ok(())
648    }
649
650    fn skip_field(&mut self, key: &'static str) -> Result<(), Error> {
651        self.tokens.0.push(CanonicalToken::SkippedField(key));
652        Ok(())
653    }
654
655    fn end(mut self) -> Result<Tokens, Error> {
656        self.tokens.0.push(CanonicalToken::StructVariantEnd);
657        Ok(self.tokens)
658    }
659}
660
661/// Serializer for serializing `struct`s.
662///
663/// Users normally will not need to interact with this type directly. It is primarily used by
664/// [`Serialize`] implementations through the [`serde::ser::SerializeStruct`] trait it implements.
665pub struct SerializeStruct<'a> {
666    tokens: Tokens,
667
668    serializer: &'a Serializer,
669
670    serialize_struct_as: SerializeStructAs,
671}
672
673impl ser::SerializeStruct for SerializeStruct<'_> {
674    type Ok = Tokens;
675    type Error = Error;
676
677    fn serialize_field<T>(&mut self, key: &'static str, value: &T) -> Result<(), Error>
678    where
679        T: Serialize + ?Sized,
680    {
681        if matches!(self.serialize_struct_as, SerializeStructAs::Struct) {
682            self.tokens.0.push(CanonicalToken::Field(key));
683        }
684        self.tokens.0.extend(value.serialize(self.serializer)?.0);
685        Ok(())
686    }
687
688    fn skip_field(&mut self, key: &'static str) -> Result<(), Error> {
689        self.tokens.0.push(CanonicalToken::SkippedField(key));
690        Ok(())
691    }
692
693    fn end(mut self) -> Result<Tokens, Error> {
694        self.tokens.0.push(match self.serialize_struct_as {
695            SerializeStructAs::Struct => CanonicalToken::StructEnd,
696            SerializeStructAs::Seq => CanonicalToken::SeqEnd,
697        });
698        Ok(self.tokens)
699    }
700}
701
702/// An error encountered during serialization.
703///
704/// # Example
705/// ```rust
706/// use serde::ser::Error as _;
707/// use serde_assert::ser::Error;
708///
709/// assert_eq!(format!("{}", Error::custom("foo")), "foo");
710/// ```
711#[derive(Debug, Eq, PartialEq)]
712pub struct Error(pub String);
713
714impl Display for Error {
715    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
716        self.0.fmt(formatter)
717    }
718}
719
720impl ser::StdError for Error {}
721
722impl ser::Error for Error {
723    fn custom<T>(msg: T) -> Self
724    where
725        T: Display,
726    {
727        Self(msg.to_string())
728    }
729}
730
731#[cfg(test)]
732mod tests {
733    use super::{
734        Error,
735        SerializeStructAs,
736        Serializer,
737    };
738    use crate::Token;
739    use alloc::{
740        borrow::ToOwned,
741        format,
742        string::String,
743        vec,
744    };
745    use claims::assert_ok_eq;
746    use serde::ser::{
747        Error as _,
748        Serialize,
749        Serializer as _,
750    };
751    use serde_bytes::Bytes;
752    use serde_derive::Serialize;
753    use std::collections::{
754        HashMap,
755        HashSet,
756    };
757
758    #[test]
759    fn serialize_bool() {
760        let serializer = Serializer::builder().build();
761
762        assert_ok_eq!(true.serialize(&serializer), [Token::Bool(true)]);
763    }
764
765    #[test]
766    fn serialize_i8() {
767        let serializer = Serializer::builder().build();
768
769        assert_ok_eq!(42i8.serialize(&serializer), [Token::I8(42)]);
770    }
771
772    #[test]
773    fn serialize_i16() {
774        let serializer = Serializer::builder().build();
775
776        assert_ok_eq!(42i16.serialize(&serializer), [Token::I16(42)]);
777    }
778
779    #[test]
780    fn serialize_i32() {
781        let serializer = Serializer::builder().build();
782
783        assert_ok_eq!(42i32.serialize(&serializer), [Token::I32(42)]);
784    }
785
786    #[test]
787    fn serialize_i64() {
788        let serializer = Serializer::builder().build();
789
790        assert_ok_eq!(42i64.serialize(&serializer), [Token::I64(42)]);
791    }
792
793    #[test]
794    fn serialize_i128() {
795        let serializer = Serializer::builder().build();
796
797        assert_ok_eq!(42i128.serialize(&serializer), [Token::I128(42)]);
798    }
799
800    #[test]
801    fn serialize_u8() {
802        let serializer = Serializer::builder().build();
803
804        assert_ok_eq!(42u8.serialize(&serializer), [Token::U8(42)]);
805    }
806
807    #[test]
808    fn serialize_u16() {
809        let serializer = Serializer::builder().build();
810
811        assert_ok_eq!(42u16.serialize(&serializer), [Token::U16(42)]);
812    }
813
814    #[test]
815    fn serialize_u32() {
816        let serializer = Serializer::builder().build();
817
818        assert_ok_eq!(42u32.serialize(&serializer), [Token::U32(42)]);
819    }
820
821    #[test]
822    fn serialize_u64() {
823        let serializer = Serializer::builder().build();
824
825        assert_ok_eq!(42u64.serialize(&serializer), [Token::U64(42)]);
826    }
827
828    #[test]
829    fn serialize_u128() {
830        let serializer = Serializer::builder().build();
831
832        assert_ok_eq!(42u128.serialize(&serializer), [Token::U128(42)]);
833    }
834
835    #[test]
836    fn serialize_f32() {
837        let serializer = Serializer::builder().build();
838
839        assert_ok_eq!(42f32.serialize(&serializer), [Token::F32(42.)]);
840    }
841
842    #[test]
843    fn serialize_f64() {
844        let serializer = Serializer::builder().build();
845
846        assert_ok_eq!(42f64.serialize(&serializer), [Token::F64(42.)]);
847    }
848
849    #[test]
850    fn serialize_char() {
851        let serializer = Serializer::builder().build();
852
853        assert_ok_eq!('a'.serialize(&serializer), [Token::Char('a')]);
854    }
855
856    #[test]
857    fn serialize_str() {
858        let serializer = Serializer::builder().build();
859
860        assert_ok_eq!("a".serialize(&serializer), [Token::Str("a".to_owned())]);
861    }
862
863    #[test]
864    fn serialize_bytes() {
865        let serializer = Serializer::builder().build();
866
867        assert_ok_eq!(
868            Bytes::new(b"a").serialize(&serializer),
869            [Token::Bytes(b"a".to_vec())]
870        );
871    }
872
873    #[test]
874    fn serialize_none() {
875        let serializer = Serializer::builder().build();
876
877        assert_ok_eq!(Option::<()>::None.serialize(&serializer), [Token::None]);
878    }
879
880    #[test]
881    fn serialize_some() {
882        let serializer = Serializer::builder().build();
883
884        assert_ok_eq!(
885            Some(true).serialize(&serializer),
886            [Token::Some, Token::Bool(true)]
887        );
888    }
889
890    #[test]
891    fn serialize_unit() {
892        let serializer = Serializer::builder().build();
893
894        assert_ok_eq!(().serialize(&serializer), [Token::Unit]);
895    }
896
897    #[test]
898    fn serialize_unit_struct() {
899        #[derive(Serialize)]
900        struct Unit;
901
902        let serializer = Serializer::builder().build();
903
904        assert_ok_eq!(
905            Unit.serialize(&serializer),
906            [Token::UnitStruct { name: "Unit" }]
907        );
908    }
909
910    #[test]
911    fn serialize_unit_variant() {
912        #[derive(Serialize)]
913        enum Unit {
914            Variant,
915        }
916
917        let serializer = Serializer::builder().build();
918
919        assert_ok_eq!(
920            Unit::Variant.serialize(&serializer),
921            [Token::UnitVariant {
922                name: "Unit",
923                variant_index: 0,
924                variant: "Variant"
925            }]
926        );
927    }
928
929    #[test]
930    fn serialize_newtype_struct() {
931        #[derive(Serialize)]
932        struct Newtype(bool);
933
934        let serializer = Serializer::builder().build();
935
936        assert_ok_eq!(
937            Newtype(false).serialize(&serializer),
938            [Token::NewtypeStruct { name: "Newtype" }, Token::Bool(false)]
939        );
940    }
941
942    #[test]
943    fn serialize_newtype_variant() {
944        #[derive(Serialize)]
945        enum Newtype {
946            Variant(bool),
947        }
948
949        let serializer = Serializer::builder().build();
950
951        assert_ok_eq!(
952            Newtype::Variant(false).serialize(&serializer),
953            [
954                Token::NewtypeVariant {
955                    name: "Newtype",
956                    variant_index: 0,
957                    variant: "Variant"
958                },
959                Token::Bool(false)
960            ]
961        );
962    }
963
964    #[test]
965    fn serialize_seq() {
966        let serializer = Serializer::builder().build();
967
968        assert_ok_eq!(
969            vec![1i8, 2i8, 3i8].serialize(&serializer),
970            [
971                Token::Seq { len: Some(3) },
972                Token::I8(1),
973                Token::I8(2),
974                Token::I8(3),
975                Token::SeqEnd
976            ],
977        );
978    }
979
980    #[test]
981    fn serialize_seq_unordered() {
982        let serializer = Serializer::builder().build();
983
984        let mut set = HashSet::new();
985        set.insert('a');
986        set.insert('b');
987        set.insert('c');
988
989        assert_ok_eq!(
990            set.serialize(&serializer),
991            [
992                Token::Seq { len: Some(3) },
993                Token::Unordered(&[
994                    &[Token::Char('a')],
995                    &[Token::Char('b')],
996                    &[Token::Char('c')],
997                ]),
998                Token::SeqEnd,
999            ]
1000        );
1001    }
1002
1003    #[test]
1004    fn serialize_tuple() {
1005        let serializer = Serializer::builder().build();
1006
1007        assert_ok_eq!(
1008            (1i8, 2i16, 3i32).serialize(&serializer),
1009            [
1010                Token::Tuple { len: 3 },
1011                Token::I8(1),
1012                Token::I16(2),
1013                Token::I32(3),
1014                Token::TupleEnd
1015            ],
1016        );
1017    }
1018
1019    #[test]
1020    fn serialize_tuple_struct() {
1021        #[derive(Serialize)]
1022        struct TupleStruct(i8, i16, i32);
1023
1024        let serializer = Serializer::builder().build();
1025
1026        assert_ok_eq!(
1027            TupleStruct(1i8, 2i16, 3i32).serialize(&serializer),
1028            [
1029                Token::TupleStruct {
1030                    name: "TupleStruct",
1031                    len: 3
1032                },
1033                Token::I8(1),
1034                Token::I16(2),
1035                Token::I32(3),
1036                Token::TupleStructEnd
1037            ],
1038        );
1039    }
1040
1041    #[test]
1042    fn serialize_tuple_variant() {
1043        #[derive(Serialize)]
1044        enum Tuple {
1045            Variant(i8, i16, i32),
1046        }
1047
1048        let serializer = Serializer::builder().build();
1049
1050        assert_ok_eq!(
1051            Tuple::Variant(1i8, 2i16, 3i32).serialize(&serializer),
1052            [
1053                Token::TupleVariant {
1054                    name: "Tuple",
1055                    variant_index: 0,
1056                    variant: "Variant",
1057                    len: 3
1058                },
1059                Token::I8(1),
1060                Token::I16(2),
1061                Token::I32(3),
1062                Token::TupleVariantEnd
1063            ],
1064        );
1065    }
1066
1067    #[test]
1068    fn serialize_map() {
1069        let serializer = Serializer::builder().build();
1070
1071        let mut map = HashMap::new();
1072        map.insert(1i8, 'a');
1073        map.insert(2i8, 'b');
1074        map.insert(3i8, 'c');
1075
1076        assert_ok_eq!(
1077            map.serialize(&serializer),
1078            [
1079                Token::Map { len: Some(3) },
1080                Token::Unordered(&[
1081                    &[Token::I8(1), Token::Char('a')],
1082                    &[Token::I8(2), Token::Char('b')],
1083                    &[Token::I8(3), Token::Char('c')],
1084                ]),
1085                Token::MapEnd,
1086            ]
1087        );
1088    }
1089
1090    #[test]
1091    fn serialize_struct() {
1092        #[derive(Serialize)]
1093        struct Struct {
1094            a: bool,
1095            b: u16,
1096            c: String,
1097        }
1098
1099        let serializer = Serializer::builder().build();
1100
1101        assert_ok_eq!(
1102            Struct {
1103                a: true,
1104                b: 42,
1105                c: "foo".to_owned(),
1106            }
1107            .serialize(&serializer),
1108            [
1109                Token::Struct {
1110                    name: "Struct",
1111                    len: 3,
1112                },
1113                Token::Field("a"),
1114                Token::Bool(true),
1115                Token::Field("b"),
1116                Token::U16(42),
1117                Token::Field("c"),
1118                Token::Str("foo".to_owned()),
1119                Token::StructEnd,
1120            ]
1121        );
1122    }
1123
1124    #[test]
1125    fn serialize_struct_skipped_field() {
1126        fn skip<T>(_: &T) -> bool {
1127            true
1128        }
1129
1130        #[derive(Serialize)]
1131        struct Struct {
1132            a: bool,
1133            #[serde(skip_serializing_if = "skip")]
1134            b: u16,
1135            c: String,
1136        }
1137
1138        let serializer = Serializer::builder().build();
1139
1140        assert_ok_eq!(
1141            Struct {
1142                a: true,
1143                b: 42,
1144                c: "foo".to_owned(),
1145            }
1146            .serialize(&serializer),
1147            [
1148                Token::Struct {
1149                    name: "Struct",
1150                    len: 2,
1151                },
1152                Token::Field("a"),
1153                Token::Bool(true),
1154                Token::SkippedField("b"),
1155                Token::Field("c"),
1156                Token::Str("foo".to_owned()),
1157                Token::StructEnd,
1158            ]
1159        );
1160    }
1161
1162    #[test]
1163    fn serialize_struct_as_seq() {
1164        #[derive(Serialize)]
1165        struct Struct {
1166            foo: bool,
1167            bar: u32,
1168        }
1169
1170        let some_struct = Struct {
1171            foo: false,
1172            bar: 42,
1173        };
1174        let serializer = Serializer::builder()
1175            .serialize_struct_as(SerializeStructAs::Seq)
1176            .build();
1177
1178        assert_ok_eq!(
1179            some_struct.serialize(&serializer),
1180            [
1181                Token::Seq { len: Some(2) },
1182                Token::Bool(false),
1183                Token::U32(42),
1184                Token::SeqEnd,
1185            ]
1186        );
1187    }
1188
1189    #[test]
1190    fn serialize_struct_variant() {
1191        #[derive(Serialize)]
1192        enum Struct {
1193            Variant { a: bool, b: u16, c: String },
1194        }
1195
1196        let serializer = Serializer::builder().build();
1197
1198        assert_ok_eq!(
1199            Struct::Variant {
1200                a: true,
1201                b: 42,
1202                c: "foo".to_owned(),
1203            }
1204            .serialize(&serializer),
1205            [
1206                Token::StructVariant {
1207                    name: "Struct",
1208                    variant_index: 0,
1209                    variant: "Variant",
1210                    len: 3,
1211                },
1212                Token::Field("a"),
1213                Token::Bool(true),
1214                Token::Field("b"),
1215                Token::U16(42),
1216                Token::Field("c"),
1217                Token::Str("foo".to_owned()),
1218                Token::StructVariantEnd,
1219            ]
1220        );
1221    }
1222
1223    #[test]
1224    fn serialize_struct_variant_skipped_field() {
1225        fn skip<T>(_: &T) -> bool {
1226            true
1227        }
1228
1229        #[derive(Serialize)]
1230        enum Struct {
1231            Variant {
1232                a: bool,
1233                #[serde(skip_serializing_if = "skip")]
1234                b: u16,
1235                c: String,
1236            },
1237        }
1238
1239        let serializer = Serializer::builder().build();
1240
1241        assert_ok_eq!(
1242            Struct::Variant {
1243                a: true,
1244                b: 42,
1245                c: "foo".to_owned(),
1246            }
1247            .serialize(&serializer),
1248            [
1249                Token::StructVariant {
1250                    name: "Struct",
1251                    variant_index: 0,
1252                    variant: "Variant",
1253                    len: 2,
1254                },
1255                Token::Field("a"),
1256                Token::Bool(true),
1257                Token::SkippedField("b"),
1258                Token::Field("c"),
1259                Token::Str("foo".to_owned()),
1260                Token::StructVariantEnd,
1261            ]
1262        );
1263    }
1264
1265    #[test]
1266    fn collect_str() {
1267        struct CollectedString(String);
1268
1269        impl Serialize for CollectedString {
1270            fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
1271            where
1272                S: serde::Serializer,
1273            {
1274                serializer.collect_str(&self.0)
1275            }
1276        }
1277
1278        let serializer = Serializer::builder().build();
1279
1280        assert_ok_eq!(
1281            CollectedString("foo".to_owned()).serialize(&serializer),
1282            [Token::Str("foo".to_owned())]
1283        );
1284    }
1285
1286    #[test]
1287    fn is_human_readable_default() {
1288        let serializer = Serializer::builder().build();
1289
1290        assert!((&serializer).is_human_readable());
1291    }
1292
1293    #[test]
1294    fn is_human_readable_false() {
1295        let serializer = Serializer::builder().is_human_readable(false).build();
1296
1297        assert!(!(&serializer).is_human_readable());
1298    }
1299
1300    #[test]
1301    fn is_human_readable_true() {
1302        let serializer = Serializer::builder().is_human_readable(true).build();
1303
1304        assert!((&serializer).is_human_readable());
1305    }
1306
1307    #[test]
1308    fn custom_error() {
1309        let error = Error::custom("foo");
1310
1311        assert_eq!(error.0, "foo");
1312    }
1313
1314    #[test]
1315    fn display_error() {
1316        let formatted = format!("{}", Error::custom("foo"));
1317
1318        assert_eq!(formatted, "foo");
1319    }
1320}
serde_assert/ser.rs

serde_assert/
ser.rs
