1 use std::fmt::{self, Debug, Display};
2 
3 #[derive(Copy, Clone, PartialEq, Debug)]
4 pub enum Token {
5     /// A serialized `bool`.
6     ///
7     /// ```
8     /// # use serde_test::{assert_tokens, Token};
9     /// #
10     /// assert_tokens(&true, &[Token::Bool(true)]);
11     /// ```
12     Bool(bool),
13 
14     /// A serialized `i8`.
15     ///
16     /// ```
17     /// # use serde_test::{assert_tokens, Token};
18     /// #
19     /// assert_tokens(&0i8, &[Token::I8(0)]);
20     /// ```
21     I8(i8),
22 
23     /// A serialized `i16`.
24     ///
25     /// ```
26     /// # use serde_test::{assert_tokens, Token};
27     /// #
28     /// assert_tokens(&0i16, &[Token::I16(0)]);
29     /// ```
30     I16(i16),
31 
32     /// A serialized `i32`.
33     ///
34     /// ```
35     /// # use serde_test::{assert_tokens, Token};
36     /// #
37     /// assert_tokens(&0i32, &[Token::I32(0)]);
38     /// ```
39     I32(i32),
40 
41     /// A serialized `i64`.
42     ///
43     /// ```
44     /// # use serde_test::{assert_tokens, Token};
45     /// #
46     /// assert_tokens(&0i64, &[Token::I64(0)]);
47     /// ```
48     I64(i64),
49 
50     /// A serialized `u8`.
51     ///
52     /// ```
53     /// # use serde_test::{assert_tokens, Token};
54     /// #
55     /// assert_tokens(&0u8, &[Token::U8(0)]);
56     /// ```
57     U8(u8),
58 
59     /// A serialized `u16`.
60     ///
61     /// ```
62     /// # use serde_test::{assert_tokens, Token};
63     /// #
64     /// assert_tokens(&0u16, &[Token::U16(0)]);
65     /// ```
66     U16(u16),
67 
68     /// A serialized `u32`.
69     ///
70     /// ```
71     /// # use serde_test::{assert_tokens, Token};
72     /// #
73     /// assert_tokens(&0u32, &[Token::U32(0)]);
74     /// ```
75     U32(u32),
76 
77     /// A serialized `u64`.
78     ///
79     /// ```
80     /// # use serde_test::{assert_tokens, Token};
81     /// #
82     /// assert_tokens(&0u64, &[Token::U64(0)]);
83     /// ```
84     U64(u64),
85 
86     /// A serialized `f32`.
87     ///
88     /// ```
89     /// # use serde_test::{assert_tokens, Token};
90     /// #
91     /// assert_tokens(&0f32, &[Token::F32(0.0)]);
92     /// ```
93     F32(f32),
94 
95     /// A serialized `f64`.
96     ///
97     /// ```
98     /// # use serde_test::{assert_tokens, Token};
99     /// #
100     /// assert_tokens(&0f64, &[Token::F64(0.0)]);
101     /// ```
102     F64(f64),
103 
104     /// A serialized `char`.
105     ///
106     /// ```
107     /// # use serde_test::{assert_tokens, Token};
108     /// #
109     /// assert_tokens(&'\n', &[Token::Char('\n')]);
110     /// ```
111     Char(char),
112 
113     /// A serialized `str`.
114     ///
115     /// ```
116     /// # use serde_test::{assert_tokens, Token};
117     /// #
118     /// let s = String::from("transient");
119     /// assert_tokens(&s, &[Token::Str("transient")]);
120     /// ```
121     Str(&'static str),
122 
123     /// A borrowed `str`.
124     ///
125     /// ```
126     /// # use serde_test::{assert_tokens, Token};
127     /// #
128     /// let s: &str = "borrowed";
129     /// assert_tokens(&s, &[Token::BorrowedStr("borrowed")]);
130     /// ```
131     BorrowedStr(&'static str),
132 
133     /// A serialized `String`.
134     ///
135     /// ```
136     /// # use serde_test::{assert_tokens, Token};
137     /// #
138     /// let s = String::from("owned");
139     /// assert_tokens(&s, &[Token::String("owned")]);
140     /// ```
141     String(&'static str),
142 
143     /// A serialized `[u8]`
144     Bytes(&'static [u8]),
145 
146     /// A borrowed `[u8]`.
147     BorrowedBytes(&'static [u8]),
148 
149     /// A serialized `ByteBuf`
150     ByteBuf(&'static [u8]),
151 
152     /// A serialized `Option<T>` containing none.
153     ///
154     /// ```
155     /// # use serde_test::{assert_tokens, Token};
156     /// #
157     /// let opt = None::<char>;
158     /// assert_tokens(&opt, &[Token::None]);
159     /// ```
160     None,
161 
162     /// The header to a serialized `Option<T>` containing some value.
163     ///
164     /// The tokens of the value follow after this header.
165     ///
166     /// ```
167     /// # use serde_test::{assert_tokens, Token};
168     /// #
169     /// let opt = Some('c');
170     /// assert_tokens(&opt, &[Token::Some, Token::Char('c')]);
171     /// ```
172     Some,
173 
174     /// A serialized `()`.
175     ///
176     /// ```
177     /// # use serde_test::{assert_tokens, Token};
178     /// #
179     /// assert_tokens(&(), &[Token::Unit]);
180     /// ```
181     Unit,
182 
183     /// A serialized unit struct of the given name.
184     ///
185     /// ```
186     /// # use serde_derive::{Deserialize, Serialize};
187     /// # use serde_test::{assert_tokens, Token};
188     /// #
189     /// # fn main() {
190     /// #[derive(Serialize, Deserialize, PartialEq, Debug)]
191     /// struct X;
192     ///
193     /// assert_tokens(&X, &[Token::UnitStruct { name: "X" }]);
194     /// # }
195     /// ```
196     UnitStruct { name: &'static str },
197 
198     /// A unit variant of an enum.
199     ///
200     /// ```
201     /// # use serde_derive::{Deserialize, Serialize};
202     /// # use serde_test::{assert_tokens, Token};
203     /// #
204     /// # fn main() {
205     /// #[derive(Serialize, Deserialize, PartialEq, Debug)]
206     /// enum E {
207     ///     A,
208     /// }
209     ///
210     /// let a = E::A;
211     /// assert_tokens(
212     ///     &a,
213     ///     &[Token::UnitVariant {
214     ///         name: "E",
215     ///         variant: "A",
216     ///     }],
217     /// );
218     /// # }
219     /// ```
220     UnitVariant {
221         name: &'static str,
222         variant: &'static str,
223     },
224 
225     /// The header to a serialized newtype struct of the given name.
226     ///
227     /// After this header is the value contained in the newtype struct.
228     ///
229     /// ```
230     /// # use serde_derive::{Deserialize, Serialize};
231     /// # use serde_test::{assert_tokens, Token};
232     /// #
233     /// # fn main() {
234     /// #[derive(Serialize, Deserialize, PartialEq, Debug)]
235     /// struct N(String);
236     ///
237     /// let n = N("newtype".to_owned());
238     /// assert_tokens(
239     ///     &n,
240     ///     &[Token::NewtypeStruct { name: "N" }, Token::String("newtype")],
241     /// );
242     /// # }
243     /// ```
244     NewtypeStruct { name: &'static str },
245 
246     /// The header to a newtype variant of an enum.
247     ///
248     /// After this header is the value contained in the newtype variant.
249     ///
250     /// ```
251     /// # use serde_derive::{Deserialize, Serialize};
252     /// # use serde_test::{assert_tokens, Token};
253     /// #
254     /// # fn main() {
255     /// #[derive(Serialize, Deserialize, PartialEq, Debug)]
256     /// enum E {
257     ///     B(u8),
258     /// }
259     ///
260     /// let b = E::B(0);
261     /// assert_tokens(
262     ///     &b,
263     ///     &[
264     ///         Token::NewtypeVariant {
265     ///             name: "E",
266     ///             variant: "B",
267     ///         },
268     ///         Token::U8(0),
269     ///     ],
270     /// );
271     /// # }
272     /// ```
273     NewtypeVariant {
274         name: &'static str,
275         variant: &'static str,
276     },
277 
278     /// The header to a sequence.
279     ///
280     /// After this header are the elements of the sequence, followed by
281     /// `SeqEnd`.
282     ///
283     /// ```
284     /// # use serde_test::{assert_tokens, Token};
285     /// #
286     /// let vec = vec!['a', 'b', 'c'];
287     /// assert_tokens(
288     ///     &vec,
289     ///     &[
290     ///         Token::Seq { len: Some(3) },
291     ///         Token::Char('a'),
292     ///         Token::Char('b'),
293     ///         Token::Char('c'),
294     ///         Token::SeqEnd,
295     ///     ],
296     /// );
297     /// ```
298     Seq { len: Option<usize> },
299 
300     /// An indicator of the end of a sequence.
301     SeqEnd,
302 
303     /// The header to a tuple.
304     ///
305     /// After this header are the elements of the tuple, followed by `TupleEnd`.
306     ///
307     /// ```
308     /// # use serde_test::{assert_tokens, Token};
309     /// #
310     /// let tuple = ('a', 100);
311     /// assert_tokens(
312     ///     &tuple,
313     ///     &[
314     ///         Token::Tuple { len: 2 },
315     ///         Token::Char('a'),
316     ///         Token::I32(100),
317     ///         Token::TupleEnd,
318     ///     ],
319     /// );
320     /// ```
321     Tuple { len: usize },
322 
323     /// An indicator of the end of a tuple.
324     TupleEnd,
325 
326     /// The header to a tuple struct.
327     ///
328     /// After this header are the fields of the tuple struct, followed by
329     /// `TupleStructEnd`.
330     ///
331     /// ```
332     /// # use serde_derive::{Deserialize, Serialize};
333     /// # use serde_test::{assert_tokens, Token};
334     /// #
335     /// # fn main() {
336     /// #[derive(Serialize, Deserialize, PartialEq, Debug)]
337     /// struct T(u8, u8);
338     ///
339     /// let t = T(0, 0);
340     /// assert_tokens(
341     ///     &t,
342     ///     &[
343     ///         Token::TupleStruct { name: "T", len: 2 },
344     ///         Token::U8(0),
345     ///         Token::U8(0),
346     ///         Token::TupleStructEnd,
347     ///     ],
348     /// );
349     /// # }
350     /// ```
351     TupleStruct { name: &'static str, len: usize },
352 
353     /// An indicator of the end of a tuple struct.
354     TupleStructEnd,
355 
356     /// The header to a tuple variant of an enum.
357     ///
358     /// After this header are the fields of the tuple variant, followed by
359     /// `TupleVariantEnd`.
360     ///
361     /// ```
362     /// # use serde_derive::{Deserialize, Serialize};
363     /// # use serde_test::{assert_tokens, Token};
364     /// #
365     /// # fn main() {
366     /// #[derive(Serialize, Deserialize, PartialEq, Debug)]
367     /// enum E {
368     ///     C(u8, u8),
369     /// }
370     ///
371     /// let c = E::C(0, 0);
372     /// assert_tokens(
373     ///     &c,
374     ///     &[
375     ///         Token::TupleVariant {
376     ///             name: "E",
377     ///             variant: "C",
378     ///             len: 2,
379     ///         },
380     ///         Token::U8(0),
381     ///         Token::U8(0),
382     ///         Token::TupleVariantEnd,
383     ///     ],
384     /// );
385     /// # }
386     /// ```
387     TupleVariant {
388         name: &'static str,
389         variant: &'static str,
390         len: usize,
391     },
392 
393     /// An indicator of the end of a tuple variant.
394     TupleVariantEnd,
395 
396     /// The header to a map.
397     ///
398     /// After this header are the entries of the map, followed by `MapEnd`.
399     ///
400     /// ```
401     /// # use serde_test::{assert_tokens, Token};
402     /// #
403     /// use std::collections::BTreeMap;
404     ///
405     /// let mut map = BTreeMap::new();
406     /// map.insert('A', 65);
407     /// map.insert('Z', 90);
408     ///
409     /// assert_tokens(
410     ///     &map,
411     ///     &[
412     ///         Token::Map { len: Some(2) },
413     ///         Token::Char('A'),
414     ///         Token::I32(65),
415     ///         Token::Char('Z'),
416     ///         Token::I32(90),
417     ///         Token::MapEnd,
418     ///     ],
419     /// );
420     /// ```
421     Map { len: Option<usize> },
422 
423     /// An indicator of the end of a map.
424     MapEnd,
425 
426     /// The header of a struct.
427     ///
428     /// After this header are the fields of the struct, followed by `StructEnd`.
429     ///
430     /// ```
431     /// # use serde_derive::{Deserialize, Serialize};
432     /// # use serde_test::{assert_tokens, Token};
433     /// #
434     /// # fn main() {
435     /// #[derive(Serialize, Deserialize, PartialEq, Debug)]
436     /// struct S {
437     ///     a: u8,
438     ///     b: u8,
439     /// }
440     ///
441     /// let s = S { a: 0, b: 0 };
442     /// assert_tokens(
443     ///     &s,
444     ///     &[
445     ///         Token::Struct { name: "S", len: 2 },
446     ///         Token::Str("a"),
447     ///         Token::U8(0),
448     ///         Token::Str("b"),
449     ///         Token::U8(0),
450     ///         Token::StructEnd,
451     ///     ],
452     /// );
453     /// # }
454     /// ```
455     Struct { name: &'static str, len: usize },
456 
457     /// An indicator of the end of a struct.
458     StructEnd,
459 
460     /// The header of a struct variant of an enum.
461     ///
462     /// After this header are the fields of the struct variant, followed by
463     /// `StructVariantEnd`.
464     ///
465     /// ```
466     /// # use serde_derive::{Deserialize, Serialize};
467     /// # use serde_test::{assert_tokens, Token};
468     /// #
469     /// # fn main() {
470     /// #[derive(Serialize, Deserialize, PartialEq, Debug)]
471     /// enum E {
472     ///     D { d: u8 },
473     /// }
474     ///
475     /// let d = E::D { d: 0 };
476     /// assert_tokens(
477     ///     &d,
478     ///     &[
479     ///         Token::StructVariant {
480     ///             name: "E",
481     ///             variant: "D",
482     ///             len: 1,
483     ///         },
484     ///         Token::Str("d"),
485     ///         Token::U8(0),
486     ///         Token::StructVariantEnd,
487     ///     ],
488     /// );
489     /// # }
490     /// ```
491     StructVariant {
492         name: &'static str,
493         variant: &'static str,
494         len: usize,
495     },
496 
497     /// An indicator of the end of a struct variant.
498     StructVariantEnd,
499 
500     /// The header to an enum of the given name.
501     ///
502     /// ```
503     /// # use serde_derive::{Deserialize, Serialize};
504     /// # use serde_test::{assert_tokens, Token};
505     /// #
506     /// # fn main() {
507     /// #[derive(Serialize, Deserialize, PartialEq, Debug)]
508     /// enum E {
509     ///     A,
510     ///     B(u8),
511     ///     C(u8, u8),
512     ///     D { d: u8 },
513     /// }
514     ///
515     /// let a = E::A;
516     /// assert_tokens(
517     ///     &a,
518     ///     &[Token::Enum { name: "E" }, Token::Str("A"), Token::Unit],
519     /// );
520     ///
521     /// let b = E::B(0);
522     /// assert_tokens(
523     ///     &b,
524     ///     &[Token::Enum { name: "E" }, Token::Str("B"), Token::U8(0)],
525     /// );
526     ///
527     /// let c = E::C(0, 0);
528     /// assert_tokens(
529     ///     &c,
530     ///     &[
531     ///         Token::Enum { name: "E" },
532     ///         Token::Str("C"),
533     ///         Token::Seq { len: Some(2) },
534     ///         Token::U8(0),
535     ///         Token::U8(0),
536     ///         Token::SeqEnd,
537     ///     ],
538     /// );
539     ///
540     /// let d = E::D { d: 0 };
541     /// assert_tokens(
542     ///     &d,
543     ///     &[
544     ///         Token::Enum { name: "E" },
545     ///         Token::Str("D"),
546     ///         Token::Map { len: Some(1) },
547     ///         Token::Str("d"),
548     ///         Token::U8(0),
549     ///         Token::MapEnd,
550     ///     ],
551     /// );
552     /// # }
553     /// ```
554     Enum { name: &'static str },
555 }
556 
557 impl Display for Token {
fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result558     fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
559         Debug::fmt(self, formatter)
560     }
561 }
562