serde_test/token.rs
1use std::fmt::{self, Debug, Display};
2
3#[derive(Copy, Clone, PartialEq, Debug)]
4pub 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
557impl Display for Token {
558 fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
559 Debug::fmt(self, formatter)
560 }
561}