1 #![allow(
2 clippy::cast_lossless,
3 clippy::from_over_into,
4 // Clippy bug: https://github.com/rust-lang/rust-clippy/issues/7422
5 clippy::nonstandard_macro_braces,
6 clippy::too_many_lines,
7 clippy::trivially_copy_pass_by_ref
8 )]
9
10 use serde::de::{self, MapAccess, Unexpected, Visitor};
11 use serde::{Deserialize, Deserializer, Serialize, Serializer};
12
13 use std::collections::{BTreeMap, HashMap};
14 use std::convert::TryFrom;
15 use std::fmt;
16 use std::marker::PhantomData;
17
18 use serde_test::{
19 assert_de_tokens, assert_de_tokens_error, assert_ser_tokens, assert_ser_tokens_error,
20 assert_tokens, Token,
21 };
22
23 trait MyDefault: Sized {
my_default() -> Self24 fn my_default() -> Self;
25 }
26
27 trait ShouldSkip: Sized {
should_skip(&self) -> bool28 fn should_skip(&self) -> bool;
29 }
30
31 trait SerializeWith: Sized {
serialize_with<S>(&self, ser: S) -> Result<S::Ok, S::Error> where S: Serializer32 fn serialize_with<S>(&self, ser: S) -> Result<S::Ok, S::Error>
33 where
34 S: Serializer;
35 }
36
37 trait DeserializeWith: Sized {
deserialize_with<'de, D>(de: D) -> Result<Self, D::Error> where D: Deserializer<'de>38 fn deserialize_with<'de, D>(de: D) -> Result<Self, D::Error>
39 where
40 D: Deserializer<'de>;
41 }
42
43 impl MyDefault for i32 {
my_default() -> Self44 fn my_default() -> Self {
45 123
46 }
47 }
48
49 impl ShouldSkip for i32 {
should_skip(&self) -> bool50 fn should_skip(&self) -> bool {
51 *self == 123
52 }
53 }
54
55 impl SerializeWith for i32 {
serialize_with<S>(&self, ser: S) -> Result<S::Ok, S::Error> where S: Serializer,56 fn serialize_with<S>(&self, ser: S) -> Result<S::Ok, S::Error>
57 where
58 S: Serializer,
59 {
60 if *self == 123 {
61 true.serialize(ser)
62 } else {
63 false.serialize(ser)
64 }
65 }
66 }
67
68 impl DeserializeWith for i32 {
deserialize_with<'de, D>(de: D) -> Result<Self, D::Error> where D: Deserializer<'de>,69 fn deserialize_with<'de, D>(de: D) -> Result<Self, D::Error>
70 where
71 D: Deserializer<'de>,
72 {
73 if Deserialize::deserialize(de)? {
74 Ok(123)
75 } else {
76 Ok(2)
77 }
78 }
79 }
80
81 #[derive(Debug, PartialEq, Serialize, Deserialize)]
82 struct DefaultStruct<A, B, C, D, E>
83 where
84 C: MyDefault,
85 E: MyDefault,
86 {
87 a1: A,
88 #[serde(default)]
89 a2: B,
90 #[serde(default = "MyDefault::my_default")]
91 a3: C,
92 #[serde(skip_deserializing)]
93 a4: D,
94 #[serde(skip_deserializing, default = "MyDefault::my_default")]
95 a5: E,
96 }
97
98 #[derive(Debug, PartialEq, Serialize, Deserialize)]
99 struct DefaultTupleStruct<A, B, C>(
100 A,
101 #[serde(default)] B,
102 #[serde(default = "MyDefault::my_default")] C,
103 )
104 where
105 C: MyDefault;
106
107 #[derive(Debug, PartialEq, Serialize, Deserialize)]
108 struct CollectOther {
109 a: u32,
110 b: u32,
111 #[serde(flatten)]
112 extra: HashMap<String, u32>,
113 }
114
115 #[derive(Debug, PartialEq, Serialize, Deserialize)]
116 struct FlattenStructEnumWrapper {
117 #[serde(flatten)]
118 data: FlattenStructEnum,
119 #[serde(flatten)]
120 extra: HashMap<String, String>,
121 }
122
123 #[derive(Debug, PartialEq, Serialize, Deserialize)]
124 #[serde(rename_all = "snake_case")]
125 enum FlattenStructEnum {
126 InsertInteger { index: u32, value: u32 },
127 }
128
129 #[derive(Debug, PartialEq, Serialize, Deserialize)]
130 struct FlattenStructTagContentEnumWrapper {
131 outer: u32,
132 #[serde(flatten)]
133 data: FlattenStructTagContentEnumNewtype,
134 }
135
136 #[derive(Debug, PartialEq, Serialize, Deserialize)]
137 struct FlattenStructTagContentEnumNewtype(pub FlattenStructTagContentEnum);
138
139 #[derive(Debug, PartialEq, Serialize, Deserialize)]
140 #[serde(rename_all = "snake_case", tag = "type", content = "value")]
141 enum FlattenStructTagContentEnum {
142 InsertInteger { index: u32, value: u32 },
143 NewtypeVariant(FlattenStructTagContentEnumNewtypeVariant),
144 }
145
146 #[derive(Debug, PartialEq, Serialize, Deserialize)]
147 struct FlattenStructTagContentEnumNewtypeVariant {
148 value: u32,
149 }
150
151 #[test]
test_default_struct()152 fn test_default_struct() {
153 assert_de_tokens(
154 &DefaultStruct {
155 a1: 1,
156 a2: 2,
157 a3: 3,
158 a4: 0,
159 a5: 123,
160 },
161 &[
162 Token::Struct {
163 name: "DefaultStruct",
164 len: 3,
165 },
166 Token::Str("a1"),
167 Token::I32(1),
168 Token::Str("a2"),
169 Token::I32(2),
170 Token::Str("a3"),
171 Token::I32(3),
172 Token::Str("a4"),
173 Token::I32(4),
174 Token::Str("a5"),
175 Token::I32(5),
176 Token::StructEnd,
177 ],
178 );
179
180 assert_de_tokens(
181 &DefaultStruct {
182 a1: 1,
183 a2: 0,
184 a3: 123,
185 a4: 0,
186 a5: 123,
187 },
188 &[
189 Token::Struct {
190 name: "DefaultStruct",
191 len: 3,
192 },
193 Token::Str("a1"),
194 Token::I32(1),
195 Token::StructEnd,
196 ],
197 );
198 }
199
200 #[test]
test_default_tuple()201 fn test_default_tuple() {
202 assert_de_tokens(
203 &DefaultTupleStruct(1, 2, 3),
204 &[
205 Token::TupleStruct {
206 name: "DefaultTupleStruct",
207 len: 3,
208 },
209 Token::I32(1),
210 Token::I32(2),
211 Token::I32(3),
212 Token::TupleStructEnd,
213 ],
214 );
215
216 assert_de_tokens(
217 &DefaultTupleStruct(1, 0, 123),
218 &[
219 Token::TupleStruct {
220 name: "DefaultTupleStruct",
221 len: 3,
222 },
223 Token::I32(1),
224 Token::TupleStructEnd,
225 ],
226 );
227 }
228
229 #[derive(Debug, PartialEq, Serialize, Deserialize)]
230 enum DefaultStructVariant<A, B, C, D, E>
231 where
232 C: MyDefault,
233 E: MyDefault,
234 {
235 Struct {
236 a1: A,
237 #[serde(default)]
238 a2: B,
239 #[serde(default = "MyDefault::my_default")]
240 a3: C,
241 #[serde(skip_deserializing)]
242 a4: D,
243 #[serde(skip_deserializing, default = "MyDefault::my_default")]
244 a5: E,
245 },
246 }
247
248 #[derive(Debug, PartialEq, Serialize, Deserialize)]
249 enum DefaultTupleVariant<A, B, C>
250 where
251 C: MyDefault,
252 {
253 Tuple(
254 A,
255 #[serde(default)] B,
256 #[serde(default = "MyDefault::my_default")] C,
257 ),
258 }
259
260 #[test]
test_default_struct_variant()261 fn test_default_struct_variant() {
262 assert_de_tokens(
263 &DefaultStructVariant::Struct {
264 a1: 1,
265 a2: 2,
266 a3: 3,
267 a4: 0,
268 a5: 123,
269 },
270 &[
271 Token::StructVariant {
272 name: "DefaultStructVariant",
273 variant: "Struct",
274 len: 3,
275 },
276 Token::Str("a1"),
277 Token::I32(1),
278 Token::Str("a2"),
279 Token::I32(2),
280 Token::Str("a3"),
281 Token::I32(3),
282 Token::Str("a4"),
283 Token::I32(4),
284 Token::Str("a5"),
285 Token::I32(5),
286 Token::StructVariantEnd,
287 ],
288 );
289
290 assert_de_tokens(
291 &DefaultStructVariant::Struct {
292 a1: 1,
293 a2: 0,
294 a3: 123,
295 a4: 0,
296 a5: 123,
297 },
298 &[
299 Token::StructVariant {
300 name: "DefaultStructVariant",
301 variant: "Struct",
302 len: 3,
303 },
304 Token::Str("a1"),
305 Token::I32(1),
306 Token::StructVariantEnd,
307 ],
308 );
309 }
310
311 #[test]
test_default_tuple_variant()312 fn test_default_tuple_variant() {
313 assert_de_tokens(
314 &DefaultTupleVariant::Tuple(1, 2, 3),
315 &[
316 Token::TupleVariant {
317 name: "DefaultTupleVariant",
318 variant: "Tuple",
319 len: 3,
320 },
321 Token::I32(1),
322 Token::I32(2),
323 Token::I32(3),
324 Token::TupleVariantEnd,
325 ],
326 );
327
328 assert_de_tokens(
329 &DefaultTupleVariant::Tuple(1, 0, 123),
330 &[
331 Token::TupleVariant {
332 name: "DefaultTupleVariant",
333 variant: "Tuple",
334 len: 3,
335 },
336 Token::I32(1),
337 Token::TupleVariantEnd,
338 ],
339 );
340 }
341
342 // Does not implement std::default::Default.
343 #[derive(Debug, PartialEq, Deserialize)]
344 struct NoStdDefault(i8);
345
346 impl MyDefault for NoStdDefault {
my_default() -> Self347 fn my_default() -> Self {
348 NoStdDefault(123)
349 }
350 }
351
352 #[derive(Debug, PartialEq, Deserialize)]
353 struct ContainsNoStdDefault<A: MyDefault> {
354 #[serde(default = "MyDefault::my_default")]
355 a: A,
356 }
357
358 // Tests that a struct field does not need to implement std::default::Default if
359 // it is annotated with `default=...`.
360 #[test]
test_no_std_default()361 fn test_no_std_default() {
362 assert_de_tokens(
363 &ContainsNoStdDefault {
364 a: NoStdDefault(123),
365 },
366 &[
367 Token::Struct {
368 name: "ContainsNoStdDefault",
369 len: 1,
370 },
371 Token::StructEnd,
372 ],
373 );
374
375 assert_de_tokens(
376 &ContainsNoStdDefault { a: NoStdDefault(8) },
377 &[
378 Token::Struct {
379 name: "ContainsNoStdDefault",
380 len: 1,
381 },
382 Token::Str("a"),
383 Token::NewtypeStruct {
384 name: "NoStdDefault",
385 },
386 Token::I8(8),
387 Token::StructEnd,
388 ],
389 );
390 }
391
392 // Does not implement Deserialize.
393 #[derive(Debug, PartialEq)]
394 struct NotDeserializeStruct(i8);
395
396 impl Default for NotDeserializeStruct {
default() -> Self397 fn default() -> Self {
398 NotDeserializeStruct(123)
399 }
400 }
401
402 impl DeserializeWith for NotDeserializeStruct {
deserialize_with<'de, D>(_: D) -> Result<Self, D::Error> where D: Deserializer<'de>,403 fn deserialize_with<'de, D>(_: D) -> Result<Self, D::Error>
404 where
405 D: Deserializer<'de>,
406 {
407 panic!()
408 }
409 }
410
411 // Does not implement Deserialize.
412 #[derive(Debug, PartialEq)]
413 enum NotDeserializeEnum {
414 Trouble,
415 }
416
417 impl MyDefault for NotDeserializeEnum {
my_default() -> Self418 fn my_default() -> Self {
419 NotDeserializeEnum::Trouble
420 }
421 }
422
423 #[derive(Debug, PartialEq, Deserialize)]
424 struct ContainsNotDeserialize<A, B, C: DeserializeWith, E: MyDefault> {
425 #[serde(skip_deserializing)]
426 a: A,
427 #[serde(skip_deserializing, default)]
428 b: B,
429 #[serde(deserialize_with = "DeserializeWith::deserialize_with", default)]
430 c: C,
431 #[serde(skip_deserializing, default = "MyDefault::my_default")]
432 e: E,
433 }
434
435 // Tests that a struct field does not need to implement Deserialize if it is
436 // annotated with skip_deserializing, whether using the std Default or a
437 // custom default.
438 #[test]
test_elt_not_deserialize()439 fn test_elt_not_deserialize() {
440 assert_de_tokens(
441 &ContainsNotDeserialize {
442 a: NotDeserializeStruct(123),
443 b: NotDeserializeStruct(123),
444 c: NotDeserializeStruct(123),
445 e: NotDeserializeEnum::Trouble,
446 },
447 &[
448 Token::Struct {
449 name: "ContainsNotDeserialize",
450 len: 1,
451 },
452 Token::StructEnd,
453 ],
454 );
455 }
456
457 #[derive(Debug, PartialEq, Serialize, Deserialize)]
458 #[serde(deny_unknown_fields)]
459 struct DenyUnknown {
460 a1: i32,
461 }
462
463 #[test]
test_ignore_unknown()464 fn test_ignore_unknown() {
465 // 'Default' allows unknown. Basic smoke test of ignore...
466 assert_de_tokens(
467 &DefaultStruct {
468 a1: 1,
469 a2: 2,
470 a3: 3,
471 a4: 0,
472 a5: 123,
473 },
474 &[
475 Token::Struct {
476 name: "DefaultStruct",
477 len: 3,
478 },
479 Token::Str("whoops1"),
480 Token::I32(2),
481 Token::Str("a1"),
482 Token::I32(1),
483 Token::Str("whoops2"),
484 Token::Seq { len: Some(1) },
485 Token::I32(2),
486 Token::SeqEnd,
487 Token::Str("a2"),
488 Token::I32(2),
489 Token::Str("whoops3"),
490 Token::I32(2),
491 Token::Str("a3"),
492 Token::I32(3),
493 Token::StructEnd,
494 ],
495 );
496
497 assert_de_tokens_error::<DenyUnknown>(
498 &[
499 Token::Struct {
500 name: "DenyUnknown",
501 len: 1,
502 },
503 Token::Str("a1"),
504 Token::I32(1),
505 Token::Str("whoops"),
506 ],
507 "unknown field `whoops`, expected `a1`",
508 );
509 }
510
511 #[derive(Debug, PartialEq, Serialize, Deserialize)]
512 #[serde(rename = "Superhero")]
513 struct RenameStruct {
514 a1: i32,
515 #[serde(rename = "a3")]
516 a2: i32,
517 }
518
519 #[derive(Debug, PartialEq, Serialize, Deserialize)]
520 #[serde(rename(serialize = "SuperheroSer", deserialize = "SuperheroDe"))]
521 struct RenameStructSerializeDeserialize {
522 a1: i32,
523 #[serde(rename(serialize = "a4", deserialize = "a5"))]
524 a2: i32,
525 }
526
527 #[derive(Debug, PartialEq, Deserialize)]
528 #[serde(deny_unknown_fields)]
529 struct AliasStruct {
530 a1: i32,
531 #[serde(alias = "a3")]
532 a2: i32,
533 #[serde(alias = "a5", rename = "a6")]
534 a4: i32,
535 }
536
537 #[test]
test_rename_struct()538 fn test_rename_struct() {
539 assert_tokens(
540 &RenameStruct { a1: 1, a2: 2 },
541 &[
542 Token::Struct {
543 name: "Superhero",
544 len: 2,
545 },
546 Token::Str("a1"),
547 Token::I32(1),
548 Token::Str("a3"),
549 Token::I32(2),
550 Token::StructEnd,
551 ],
552 );
553
554 assert_ser_tokens(
555 &RenameStructSerializeDeserialize { a1: 1, a2: 2 },
556 &[
557 Token::Struct {
558 name: "SuperheroSer",
559 len: 2,
560 },
561 Token::Str("a1"),
562 Token::I32(1),
563 Token::Str("a4"),
564 Token::I32(2),
565 Token::StructEnd,
566 ],
567 );
568
569 assert_de_tokens(
570 &RenameStructSerializeDeserialize { a1: 1, a2: 2 },
571 &[
572 Token::Struct {
573 name: "SuperheroDe",
574 len: 2,
575 },
576 Token::Str("a1"),
577 Token::I32(1),
578 Token::Str("a5"),
579 Token::I32(2),
580 Token::StructEnd,
581 ],
582 );
583
584 assert_de_tokens(
585 &AliasStruct {
586 a1: 1,
587 a2: 2,
588 a4: 3,
589 },
590 &[
591 Token::Struct {
592 name: "AliasStruct",
593 len: 3,
594 },
595 Token::Str("a1"),
596 Token::I32(1),
597 Token::Str("a2"),
598 Token::I32(2),
599 Token::Str("a5"),
600 Token::I32(3),
601 Token::StructEnd,
602 ],
603 );
604
605 assert_de_tokens(
606 &AliasStruct {
607 a1: 1,
608 a2: 2,
609 a4: 3,
610 },
611 &[
612 Token::Struct {
613 name: "AliasStruct",
614 len: 3,
615 },
616 Token::Str("a1"),
617 Token::I32(1),
618 Token::Str("a3"),
619 Token::I32(2),
620 Token::Str("a6"),
621 Token::I32(3),
622 Token::StructEnd,
623 ],
624 );
625 }
626
627 #[test]
test_unknown_field_rename_struct()628 fn test_unknown_field_rename_struct() {
629 assert_de_tokens_error::<AliasStruct>(
630 &[
631 Token::Struct {
632 name: "AliasStruct",
633 len: 3,
634 },
635 Token::Str("a1"),
636 Token::I32(1),
637 Token::Str("a3"),
638 Token::I32(2),
639 Token::Str("a4"),
640 Token::I32(3),
641 ],
642 "unknown field `a4`, expected one of `a1`, `a2`, `a6`",
643 );
644 }
645
646 #[derive(Debug, PartialEq, Serialize, Deserialize)]
647 #[serde(rename = "Superhero")]
648 enum RenameEnum {
649 #[serde(rename = "bruce_wayne")]
650 Batman,
651 #[serde(rename = "clark_kent")]
652 Superman(i8),
653 #[serde(rename = "diana_prince")]
654 WonderWoman(i8, i8),
655 #[serde(rename = "barry_allan")]
656 Flash {
657 #[serde(rename = "b")]
658 a: i32,
659 },
660 }
661
662 #[derive(Debug, PartialEq, Deserialize, Serialize)]
663 #[serde(rename(serialize = "SuperheroSer", deserialize = "SuperheroDe"))]
664 enum RenameEnumSerializeDeserialize<A> {
665 #[serde(rename(serialize = "dick_grayson", deserialize = "jason_todd"))]
666 Robin {
667 a: i8,
668 #[serde(rename(serialize = "c"))]
669 #[serde(rename(deserialize = "d"))]
670 b: A,
671 },
672 }
673
674 #[derive(Debug, PartialEq, Deserialize)]
675 #[serde(deny_unknown_fields)]
676 enum AliasEnum {
677 #[serde(rename = "sailor_moon", alias = "usagi_tsukino")]
678 SailorMoon {
679 a: i8,
680 #[serde(alias = "c")]
681 b: i8,
682 #[serde(alias = "e", rename = "f")]
683 d: i8,
684 },
685 }
686
687 #[test]
test_rename_enum()688 fn test_rename_enum() {
689 assert_tokens(
690 &RenameEnum::Batman,
691 &[Token::UnitVariant {
692 name: "Superhero",
693 variant: "bruce_wayne",
694 }],
695 );
696
697 assert_tokens(
698 &RenameEnum::Superman(0),
699 &[
700 Token::NewtypeVariant {
701 name: "Superhero",
702 variant: "clark_kent",
703 },
704 Token::I8(0),
705 ],
706 );
707
708 assert_tokens(
709 &RenameEnum::WonderWoman(0, 1),
710 &[
711 Token::TupleVariant {
712 name: "Superhero",
713 variant: "diana_prince",
714 len: 2,
715 },
716 Token::I8(0),
717 Token::I8(1),
718 Token::TupleVariantEnd,
719 ],
720 );
721
722 assert_tokens(
723 &RenameEnum::Flash { a: 1 },
724 &[
725 Token::StructVariant {
726 name: "Superhero",
727 variant: "barry_allan",
728 len: 1,
729 },
730 Token::Str("b"),
731 Token::I32(1),
732 Token::StructVariantEnd,
733 ],
734 );
735
736 assert_ser_tokens(
737 &RenameEnumSerializeDeserialize::Robin {
738 a: 0,
739 b: String::new(),
740 },
741 &[
742 Token::StructVariant {
743 name: "SuperheroSer",
744 variant: "dick_grayson",
745 len: 2,
746 },
747 Token::Str("a"),
748 Token::I8(0),
749 Token::Str("c"),
750 Token::Str(""),
751 Token::StructVariantEnd,
752 ],
753 );
754
755 assert_de_tokens(
756 &RenameEnumSerializeDeserialize::Robin {
757 a: 0,
758 b: String::new(),
759 },
760 &[
761 Token::StructVariant {
762 name: "SuperheroDe",
763 variant: "jason_todd",
764 len: 2,
765 },
766 Token::Str("a"),
767 Token::I8(0),
768 Token::Str("d"),
769 Token::Str(""),
770 Token::StructVariantEnd,
771 ],
772 );
773
774 assert_de_tokens(
775 &AliasEnum::SailorMoon { a: 0, b: 1, d: 2 },
776 &[
777 Token::StructVariant {
778 name: "AliasEnum",
779 variant: "sailor_moon",
780 len: 3,
781 },
782 Token::Str("a"),
783 Token::I8(0),
784 Token::Str("b"),
785 Token::I8(1),
786 Token::Str("e"),
787 Token::I8(2),
788 Token::StructVariantEnd,
789 ],
790 );
791
792 assert_de_tokens(
793 &AliasEnum::SailorMoon { a: 0, b: 1, d: 2 },
794 &[
795 Token::StructVariant {
796 name: "AliasEnum",
797 variant: "usagi_tsukino",
798 len: 3,
799 },
800 Token::Str("a"),
801 Token::I8(0),
802 Token::Str("c"),
803 Token::I8(1),
804 Token::Str("f"),
805 Token::I8(2),
806 Token::StructVariantEnd,
807 ],
808 );
809 }
810
811 #[test]
test_unknown_field_rename_enum()812 fn test_unknown_field_rename_enum() {
813 assert_de_tokens_error::<AliasEnum>(
814 &[Token::StructVariant {
815 name: "AliasEnum",
816 variant: "SailorMoon",
817 len: 3,
818 }],
819 "unknown variant `SailorMoon`, expected `sailor_moon`",
820 );
821
822 assert_de_tokens_error::<AliasEnum>(
823 &[
824 Token::StructVariant {
825 name: "AliasEnum",
826 variant: "usagi_tsukino",
827 len: 3,
828 },
829 Token::Str("a"),
830 Token::I8(0),
831 Token::Str("c"),
832 Token::I8(1),
833 Token::Str("d"),
834 Token::I8(2),
835 ],
836 "unknown field `d`, expected one of `a`, `b`, `f`",
837 );
838 }
839
840 #[derive(Debug, PartialEq, Serialize)]
841 struct SkipSerializingStruct<'a, B, C>
842 where
843 C: ShouldSkip,
844 {
845 a: &'a i8,
846 #[serde(skip_serializing)]
847 b: B,
848 #[serde(skip_serializing_if = "ShouldSkip::should_skip")]
849 c: C,
850 }
851
852 #[test]
test_skip_serializing_struct()853 fn test_skip_serializing_struct() {
854 let a = 1;
855 assert_ser_tokens(
856 &SkipSerializingStruct { a: &a, b: 2, c: 3 },
857 &[
858 Token::Struct {
859 name: "SkipSerializingStruct",
860 len: 2,
861 },
862 Token::Str("a"),
863 Token::I8(1),
864 Token::Str("c"),
865 Token::I32(3),
866 Token::StructEnd,
867 ],
868 );
869
870 assert_ser_tokens(
871 &SkipSerializingStruct {
872 a: &a,
873 b: 2,
874 c: 123,
875 },
876 &[
877 Token::Struct {
878 name: "SkipSerializingStruct",
879 len: 1,
880 },
881 Token::Str("a"),
882 Token::I8(1),
883 Token::StructEnd,
884 ],
885 );
886 }
887
888 #[derive(Debug, PartialEq, Serialize)]
889 struct SkipSerializingTupleStruct<'a, B, C>(
890 &'a i8,
891 #[serde(skip_serializing)] B,
892 #[serde(skip_serializing_if = "ShouldSkip::should_skip")] C,
893 )
894 where
895 C: ShouldSkip;
896
897 #[test]
test_skip_serializing_tuple_struct()898 fn test_skip_serializing_tuple_struct() {
899 let a = 1;
900 assert_ser_tokens(
901 &SkipSerializingTupleStruct(&a, 2, 3),
902 &[
903 Token::TupleStruct {
904 name: "SkipSerializingTupleStruct",
905 len: 2,
906 },
907 Token::I8(1),
908 Token::I32(3),
909 Token::TupleStructEnd,
910 ],
911 );
912
913 assert_ser_tokens(
914 &SkipSerializingTupleStruct(&a, 2, 123),
915 &[
916 Token::TupleStruct {
917 name: "SkipSerializingTupleStruct",
918 len: 1,
919 },
920 Token::I8(1),
921 Token::TupleStructEnd,
922 ],
923 );
924 }
925
926 #[derive(Debug, PartialEq, Serialize, Deserialize)]
927 struct SkipStruct<B> {
928 a: i8,
929 #[serde(skip)]
930 b: B,
931 }
932
933 #[test]
test_skip_struct()934 fn test_skip_struct() {
935 assert_ser_tokens(
936 &SkipStruct { a: 1, b: 2 },
937 &[
938 Token::Struct {
939 name: "SkipStruct",
940 len: 1,
941 },
942 Token::Str("a"),
943 Token::I8(1),
944 Token::StructEnd,
945 ],
946 );
947
948 assert_de_tokens(
949 &SkipStruct { a: 1, b: 0 },
950 &[
951 Token::Struct {
952 name: "SkipStruct",
953 len: 1,
954 },
955 Token::Str("a"),
956 Token::I8(1),
957 Token::StructEnd,
958 ],
959 );
960 }
961
962 #[derive(Debug, PartialEq, Serialize)]
963 enum SkipSerializingEnum<'a, B, C>
964 where
965 C: ShouldSkip,
966 {
967 Struct {
968 a: &'a i8,
969 #[serde(skip_serializing)]
970 _b: B,
971 #[serde(skip_serializing_if = "ShouldSkip::should_skip")]
972 c: C,
973 },
974 Tuple(
975 &'a i8,
976 #[serde(skip_serializing)] B,
977 #[serde(skip_serializing_if = "ShouldSkip::should_skip")] C,
978 ),
979 }
980
981 #[test]
test_skip_serializing_enum()982 fn test_skip_serializing_enum() {
983 let a = 1;
984 assert_ser_tokens(
985 &SkipSerializingEnum::Struct { a: &a, _b: 2, c: 3 },
986 &[
987 Token::StructVariant {
988 name: "SkipSerializingEnum",
989 variant: "Struct",
990 len: 2,
991 },
992 Token::Str("a"),
993 Token::I8(1),
994 Token::Str("c"),
995 Token::I32(3),
996 Token::StructVariantEnd,
997 ],
998 );
999
1000 assert_ser_tokens(
1001 &SkipSerializingEnum::Struct {
1002 a: &a,
1003 _b: 2,
1004 c: 123,
1005 },
1006 &[
1007 Token::StructVariant {
1008 name: "SkipSerializingEnum",
1009 variant: "Struct",
1010 len: 1,
1011 },
1012 Token::Str("a"),
1013 Token::I8(1),
1014 Token::StructVariantEnd,
1015 ],
1016 );
1017
1018 assert_ser_tokens(
1019 &SkipSerializingEnum::Tuple(&a, 2, 3),
1020 &[
1021 Token::TupleVariant {
1022 name: "SkipSerializingEnum",
1023 variant: "Tuple",
1024 len: 2,
1025 },
1026 Token::I8(1),
1027 Token::I32(3),
1028 Token::TupleVariantEnd,
1029 ],
1030 );
1031
1032 assert_ser_tokens(
1033 &SkipSerializingEnum::Tuple(&a, 2, 123),
1034 &[
1035 Token::TupleVariant {
1036 name: "SkipSerializingEnum",
1037 variant: "Tuple",
1038 len: 1,
1039 },
1040 Token::I8(1),
1041 Token::TupleVariantEnd,
1042 ],
1043 );
1044 }
1045
1046 #[derive(Debug, PartialEq)]
1047 struct NotSerializeStruct(i8);
1048
1049 #[derive(Debug, PartialEq)]
1050 enum NotSerializeEnum {
1051 Trouble,
1052 }
1053
1054 impl SerializeWith for NotSerializeEnum {
serialize_with<S>(&self, ser: S) -> Result<S::Ok, S::Error> where S: Serializer,1055 fn serialize_with<S>(&self, ser: S) -> Result<S::Ok, S::Error>
1056 where
1057 S: Serializer,
1058 {
1059 "trouble".serialize(ser)
1060 }
1061 }
1062
1063 #[derive(Debug, PartialEq, Serialize)]
1064 struct ContainsNotSerialize<'a, B, C, D>
1065 where
1066 B: 'a,
1067 D: SerializeWith,
1068 {
1069 a: &'a Option<i8>,
1070 #[serde(skip_serializing)]
1071 b: &'a B,
1072 #[serde(skip_serializing)]
1073 c: Option<C>,
1074 #[serde(serialize_with = "SerializeWith::serialize_with")]
1075 d: D,
1076 }
1077
1078 #[test]
test_elt_not_serialize()1079 fn test_elt_not_serialize() {
1080 let a = 1;
1081 assert_ser_tokens(
1082 &ContainsNotSerialize {
1083 a: &Some(a),
1084 b: &NotSerializeStruct(2),
1085 c: Some(NotSerializeEnum::Trouble),
1086 d: NotSerializeEnum::Trouble,
1087 },
1088 &[
1089 Token::Struct {
1090 name: "ContainsNotSerialize",
1091 len: 2,
1092 },
1093 Token::Str("a"),
1094 Token::Some,
1095 Token::I8(1),
1096 Token::Str("d"),
1097 Token::Str("trouble"),
1098 Token::StructEnd,
1099 ],
1100 );
1101 }
1102
1103 #[derive(Debug, PartialEq, Serialize)]
1104 struct SerializeWithStruct<'a, B>
1105 where
1106 B: SerializeWith,
1107 {
1108 a: &'a i8,
1109 #[serde(serialize_with = "SerializeWith::serialize_with")]
1110 b: B,
1111 }
1112
1113 #[test]
test_serialize_with_struct()1114 fn test_serialize_with_struct() {
1115 let a = 1;
1116 assert_ser_tokens(
1117 &SerializeWithStruct { a: &a, b: 2 },
1118 &[
1119 Token::Struct {
1120 name: "SerializeWithStruct",
1121 len: 2,
1122 },
1123 Token::Str("a"),
1124 Token::I8(1),
1125 Token::Str("b"),
1126 Token::Bool(false),
1127 Token::StructEnd,
1128 ],
1129 );
1130
1131 assert_ser_tokens(
1132 &SerializeWithStruct { a: &a, b: 123 },
1133 &[
1134 Token::Struct {
1135 name: "SerializeWithStruct",
1136 len: 2,
1137 },
1138 Token::Str("a"),
1139 Token::I8(1),
1140 Token::Str("b"),
1141 Token::Bool(true),
1142 Token::StructEnd,
1143 ],
1144 );
1145 }
1146
1147 #[derive(Debug, PartialEq, Serialize)]
1148 enum SerializeWithEnum<'a, B>
1149 where
1150 B: SerializeWith,
1151 {
1152 Struct {
1153 a: &'a i8,
1154 #[serde(serialize_with = "SerializeWith::serialize_with")]
1155 b: B,
1156 },
1157 }
1158
1159 #[test]
test_serialize_with_enum()1160 fn test_serialize_with_enum() {
1161 let a = 1;
1162 assert_ser_tokens(
1163 &SerializeWithEnum::Struct { a: &a, b: 2 },
1164 &[
1165 Token::StructVariant {
1166 name: "SerializeWithEnum",
1167 variant: "Struct",
1168 len: 2,
1169 },
1170 Token::Str("a"),
1171 Token::I8(1),
1172 Token::Str("b"),
1173 Token::Bool(false),
1174 Token::StructVariantEnd,
1175 ],
1176 );
1177
1178 assert_ser_tokens(
1179 &SerializeWithEnum::Struct { a: &a, b: 123 },
1180 &[
1181 Token::StructVariant {
1182 name: "SerializeWithEnum",
1183 variant: "Struct",
1184 len: 2,
1185 },
1186 Token::Str("a"),
1187 Token::I8(1),
1188 Token::Str("b"),
1189 Token::Bool(true),
1190 Token::StructVariantEnd,
1191 ],
1192 );
1193 }
1194
1195 #[derive(Debug, PartialEq, Serialize, Deserialize)]
1196 enum WithVariant {
1197 #[serde(serialize_with = "serialize_unit_variant_as_i8")]
1198 #[serde(deserialize_with = "deserialize_i8_as_unit_variant")]
1199 Unit,
1200
1201 #[serde(serialize_with = "SerializeWith::serialize_with")]
1202 #[serde(deserialize_with = "DeserializeWith::deserialize_with")]
1203 Newtype(i32),
1204
1205 #[serde(serialize_with = "serialize_variant_as_string")]
1206 #[serde(deserialize_with = "deserialize_string_as_variant")]
1207 Tuple(String, u8),
1208
1209 #[serde(serialize_with = "serialize_variant_as_string")]
1210 #[serde(deserialize_with = "deserialize_string_as_variant")]
1211 Struct { f1: String, f2: u8 },
1212 }
1213
serialize_unit_variant_as_i8<S>(serializer: S) -> Result<S::Ok, S::Error> where S: Serializer,1214 fn serialize_unit_variant_as_i8<S>(serializer: S) -> Result<S::Ok, S::Error>
1215 where
1216 S: Serializer,
1217 {
1218 serializer.serialize_i8(0)
1219 }
1220
deserialize_i8_as_unit_variant<'de, D>(deserializer: D) -> Result<(), D::Error> where D: Deserializer<'de>,1221 fn deserialize_i8_as_unit_variant<'de, D>(deserializer: D) -> Result<(), D::Error>
1222 where
1223 D: Deserializer<'de>,
1224 {
1225 let n = i8::deserialize(deserializer)?;
1226 match n {
1227 0 => Ok(()),
1228 _ => Err(de::Error::invalid_value(Unexpected::Signed(n as i64), &"0")),
1229 }
1230 }
1231
serialize_variant_as_string<S>(f1: &str, f2: &u8, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer,1232 fn serialize_variant_as_string<S>(f1: &str, f2: &u8, serializer: S) -> Result<S::Ok, S::Error>
1233 where
1234 S: Serializer,
1235 {
1236 serializer.serialize_str(format!("{};{:?}", f1, f2).as_str())
1237 }
1238
deserialize_string_as_variant<'de, D>(deserializer: D) -> Result<(String, u8), D::Error> where D: Deserializer<'de>,1239 fn deserialize_string_as_variant<'de, D>(deserializer: D) -> Result<(String, u8), D::Error>
1240 where
1241 D: Deserializer<'de>,
1242 {
1243 let s = String::deserialize(deserializer)?;
1244 let mut pieces = s.split(';');
1245 let f1 = match pieces.next() {
1246 Some(x) => x,
1247 None => return Err(de::Error::invalid_length(0, &"2")),
1248 };
1249 let f2 = match pieces.next() {
1250 Some(x) => x,
1251 None => return Err(de::Error::invalid_length(1, &"2")),
1252 };
1253 let f2 = match f2.parse() {
1254 Ok(n) => n,
1255 Err(_) => {
1256 return Err(de::Error::invalid_value(
1257 Unexpected::Str(f2),
1258 &"an 8-bit signed integer",
1259 ));
1260 }
1261 };
1262 Ok((f1.into(), f2))
1263 }
1264
1265 #[test]
test_serialize_with_variant()1266 fn test_serialize_with_variant() {
1267 assert_ser_tokens(
1268 &WithVariant::Unit,
1269 &[
1270 Token::NewtypeVariant {
1271 name: "WithVariant",
1272 variant: "Unit",
1273 },
1274 Token::I8(0),
1275 ],
1276 );
1277
1278 assert_ser_tokens(
1279 &WithVariant::Newtype(123),
1280 &[
1281 Token::NewtypeVariant {
1282 name: "WithVariant",
1283 variant: "Newtype",
1284 },
1285 Token::Bool(true),
1286 ],
1287 );
1288
1289 assert_ser_tokens(
1290 &WithVariant::Tuple("hello".into(), 0),
1291 &[
1292 Token::NewtypeVariant {
1293 name: "WithVariant",
1294 variant: "Tuple",
1295 },
1296 Token::Str("hello;0"),
1297 ],
1298 );
1299
1300 assert_ser_tokens(
1301 &WithVariant::Struct {
1302 f1: "world".into(),
1303 f2: 1,
1304 },
1305 &[
1306 Token::NewtypeVariant {
1307 name: "WithVariant",
1308 variant: "Struct",
1309 },
1310 Token::Str("world;1"),
1311 ],
1312 );
1313 }
1314
1315 #[test]
test_deserialize_with_variant()1316 fn test_deserialize_with_variant() {
1317 assert_de_tokens(
1318 &WithVariant::Unit,
1319 &[
1320 Token::NewtypeVariant {
1321 name: "WithVariant",
1322 variant: "Unit",
1323 },
1324 Token::I8(0),
1325 ],
1326 );
1327
1328 assert_de_tokens(
1329 &WithVariant::Newtype(123),
1330 &[
1331 Token::NewtypeVariant {
1332 name: "WithVariant",
1333 variant: "Newtype",
1334 },
1335 Token::Bool(true),
1336 ],
1337 );
1338
1339 assert_de_tokens(
1340 &WithVariant::Tuple("hello".into(), 0),
1341 &[
1342 Token::NewtypeVariant {
1343 name: "WithVariant",
1344 variant: "Tuple",
1345 },
1346 Token::Str("hello;0"),
1347 ],
1348 );
1349
1350 assert_de_tokens(
1351 &WithVariant::Struct {
1352 f1: "world".into(),
1353 f2: 1,
1354 },
1355 &[
1356 Token::NewtypeVariant {
1357 name: "WithVariant",
1358 variant: "Struct",
1359 },
1360 Token::Str("world;1"),
1361 ],
1362 );
1363 }
1364
1365 #[derive(Debug, PartialEq, Deserialize)]
1366 struct DeserializeWithStruct<B>
1367 where
1368 B: DeserializeWith,
1369 {
1370 a: i8,
1371 #[serde(deserialize_with = "DeserializeWith::deserialize_with")]
1372 b: B,
1373 }
1374
1375 #[test]
test_deserialize_with_struct()1376 fn test_deserialize_with_struct() {
1377 assert_de_tokens(
1378 &DeserializeWithStruct { a: 1, b: 2 },
1379 &[
1380 Token::Struct {
1381 name: "DeserializeWithStruct",
1382 len: 2,
1383 },
1384 Token::Str("a"),
1385 Token::I8(1),
1386 Token::Str("b"),
1387 Token::Bool(false),
1388 Token::StructEnd,
1389 ],
1390 );
1391
1392 assert_de_tokens(
1393 &DeserializeWithStruct { a: 1, b: 123 },
1394 &[
1395 Token::Struct {
1396 name: "DeserializeWithStruct",
1397 len: 2,
1398 },
1399 Token::Str("a"),
1400 Token::I8(1),
1401 Token::Str("b"),
1402 Token::Bool(true),
1403 Token::StructEnd,
1404 ],
1405 );
1406 }
1407
1408 #[derive(Debug, PartialEq, Deserialize)]
1409 enum DeserializeWithEnum<B>
1410 where
1411 B: DeserializeWith,
1412 {
1413 Struct {
1414 a: i8,
1415 #[serde(deserialize_with = "DeserializeWith::deserialize_with")]
1416 b: B,
1417 },
1418 }
1419
1420 #[test]
test_deserialize_with_enum()1421 fn test_deserialize_with_enum() {
1422 assert_de_tokens(
1423 &DeserializeWithEnum::Struct { a: 1, b: 2 },
1424 &[
1425 Token::StructVariant {
1426 name: "DeserializeWithEnum",
1427 variant: "Struct",
1428 len: 2,
1429 },
1430 Token::Str("a"),
1431 Token::I8(1),
1432 Token::Str("b"),
1433 Token::Bool(false),
1434 Token::StructVariantEnd,
1435 ],
1436 );
1437
1438 assert_de_tokens(
1439 &DeserializeWithEnum::Struct { a: 1, b: 123 },
1440 &[
1441 Token::StructVariant {
1442 name: "DeserializeWithEnum",
1443 variant: "Struct",
1444 len: 2,
1445 },
1446 Token::Str("a"),
1447 Token::I8(1),
1448 Token::Str("b"),
1449 Token::Bool(true),
1450 Token::StructVariantEnd,
1451 ],
1452 );
1453 }
1454
1455 #[test]
test_missing_renamed_field_struct()1456 fn test_missing_renamed_field_struct() {
1457 assert_de_tokens_error::<RenameStruct>(
1458 &[
1459 Token::Struct {
1460 name: "Superhero",
1461 len: 2,
1462 },
1463 Token::Str("a1"),
1464 Token::I32(1),
1465 Token::StructEnd,
1466 ],
1467 "missing field `a3`",
1468 );
1469
1470 assert_de_tokens_error::<RenameStructSerializeDeserialize>(
1471 &[
1472 Token::Struct {
1473 name: "SuperheroDe",
1474 len: 2,
1475 },
1476 Token::Str("a1"),
1477 Token::I32(1),
1478 Token::StructEnd,
1479 ],
1480 "missing field `a5`",
1481 );
1482 }
1483
1484 #[test]
test_missing_renamed_field_enum()1485 fn test_missing_renamed_field_enum() {
1486 assert_de_tokens_error::<RenameEnum>(
1487 &[
1488 Token::StructVariant {
1489 name: "Superhero",
1490 variant: "barry_allan",
1491 len: 1,
1492 },
1493 Token::StructVariantEnd,
1494 ],
1495 "missing field `b`",
1496 );
1497
1498 assert_de_tokens_error::<RenameEnumSerializeDeserialize<i8>>(
1499 &[
1500 Token::StructVariant {
1501 name: "SuperheroDe",
1502 variant: "jason_todd",
1503 len: 2,
1504 },
1505 Token::Str("a"),
1506 Token::I8(0),
1507 Token::StructVariantEnd,
1508 ],
1509 "missing field `d`",
1510 );
1511 }
1512
1513 #[derive(Debug, PartialEq, Deserialize)]
1514 enum InvalidLengthEnum {
1515 A(i32, i32, i32),
1516 B(#[serde(skip_deserializing)] i32, i32, i32),
1517 }
1518
1519 #[test]
test_invalid_length_enum()1520 fn test_invalid_length_enum() {
1521 assert_de_tokens_error::<InvalidLengthEnum>(
1522 &[
1523 Token::TupleVariant {
1524 name: "InvalidLengthEnum",
1525 variant: "A",
1526 len: 3,
1527 },
1528 Token::I32(1),
1529 Token::TupleVariantEnd,
1530 ],
1531 "invalid length 1, expected tuple variant InvalidLengthEnum::A with 3 elements",
1532 );
1533 assert_de_tokens_error::<InvalidLengthEnum>(
1534 &[
1535 Token::TupleVariant {
1536 name: "InvalidLengthEnum",
1537 variant: "B",
1538 len: 3,
1539 },
1540 Token::I32(1),
1541 Token::TupleVariantEnd,
1542 ],
1543 "invalid length 1, expected tuple variant InvalidLengthEnum::B with 2 elements",
1544 );
1545 }
1546
1547 #[derive(Clone, Serialize, Deserialize, PartialEq, Debug)]
1548 #[serde(into = "EnumToU32", from = "EnumToU32")]
1549 struct StructFromEnum(Option<u32>);
1550
1551 impl Into<EnumToU32> for StructFromEnum {
into(self) -> EnumToU321552 fn into(self) -> EnumToU32 {
1553 match self {
1554 StructFromEnum(v) => v.into(),
1555 }
1556 }
1557 }
1558
1559 impl From<EnumToU32> for StructFromEnum {
from(v: EnumToU32) -> Self1560 fn from(v: EnumToU32) -> Self {
1561 StructFromEnum(v.into())
1562 }
1563 }
1564
1565 #[derive(Clone, Serialize, Deserialize, PartialEq, Debug)]
1566 #[serde(into = "Option<u32>", from = "Option<u32>")]
1567 enum EnumToU32 {
1568 One,
1569 Two,
1570 Three,
1571 Four,
1572 Nothing,
1573 }
1574
1575 impl Into<Option<u32>> for EnumToU32 {
into(self) -> Option<u32>1576 fn into(self) -> Option<u32> {
1577 match self {
1578 EnumToU32::One => Some(1),
1579 EnumToU32::Two => Some(2),
1580 EnumToU32::Three => Some(3),
1581 EnumToU32::Four => Some(4),
1582 EnumToU32::Nothing => None,
1583 }
1584 }
1585 }
1586
1587 impl From<Option<u32>> for EnumToU32 {
from(v: Option<u32>) -> Self1588 fn from(v: Option<u32>) -> Self {
1589 match v {
1590 Some(1) => EnumToU32::One,
1591 Some(2) => EnumToU32::Two,
1592 Some(3) => EnumToU32::Three,
1593 Some(4) => EnumToU32::Four,
1594 _ => EnumToU32::Nothing,
1595 }
1596 }
1597 }
1598
1599 #[derive(Clone, Deserialize, PartialEq, Debug)]
1600 #[serde(try_from = "u32")]
1601 enum TryFromU32 {
1602 One,
1603 Two,
1604 }
1605
1606 impl TryFrom<u32> for TryFromU32 {
1607 type Error = String;
1608
try_from(value: u32) -> Result<Self, Self::Error>1609 fn try_from(value: u32) -> Result<Self, Self::Error> {
1610 match value {
1611 1 => Ok(TryFromU32::One),
1612 2 => Ok(TryFromU32::Two),
1613 _ => Err("out of range".to_owned()),
1614 }
1615 }
1616 }
1617
1618 #[test]
test_from_into_traits()1619 fn test_from_into_traits() {
1620 assert_ser_tokens(&EnumToU32::One, &[Token::Some, Token::U32(1)]);
1621 assert_ser_tokens(&EnumToU32::Nothing, &[Token::None]);
1622 assert_de_tokens(&EnumToU32::Two, &[Token::Some, Token::U32(2)]);
1623 assert_ser_tokens(&StructFromEnum(Some(5)), &[Token::None]);
1624 assert_ser_tokens(&StructFromEnum(None), &[Token::None]);
1625 assert_de_tokens(&StructFromEnum(Some(2)), &[Token::Some, Token::U32(2)]);
1626 assert_de_tokens(&TryFromU32::Two, &[Token::U32(2)]);
1627 assert_de_tokens_error::<TryFromU32>(&[Token::U32(5)], "out of range");
1628 }
1629
1630 #[test]
test_collect_other()1631 fn test_collect_other() {
1632 let mut extra = HashMap::new();
1633 extra.insert("c".into(), 3);
1634 assert_tokens(
1635 &CollectOther { a: 1, b: 2, extra },
1636 &[
1637 Token::Map { len: None },
1638 Token::Str("a"),
1639 Token::U32(1),
1640 Token::Str("b"),
1641 Token::U32(2),
1642 Token::Str("c"),
1643 Token::U32(3),
1644 Token::MapEnd,
1645 ],
1646 );
1647 }
1648
1649 #[test]
test_flatten_struct_enum()1650 fn test_flatten_struct_enum() {
1651 let mut extra = HashMap::new();
1652 extra.insert("extra_key".into(), "extra value".into());
1653 let change_request = FlattenStructEnumWrapper {
1654 data: FlattenStructEnum::InsertInteger {
1655 index: 0,
1656 value: 42,
1657 },
1658 extra,
1659 };
1660 assert_de_tokens(
1661 &change_request,
1662 &[
1663 Token::Map { len: None },
1664 Token::Str("insert_integer"),
1665 Token::Map { len: None },
1666 Token::Str("index"),
1667 Token::U32(0),
1668 Token::Str("value"),
1669 Token::U32(42),
1670 Token::MapEnd,
1671 Token::Str("extra_key"),
1672 Token::Str("extra value"),
1673 Token::MapEnd,
1674 ],
1675 );
1676 assert_ser_tokens(
1677 &change_request,
1678 &[
1679 Token::Map { len: None },
1680 Token::Str("insert_integer"),
1681 Token::Struct {
1682 len: 2,
1683 name: "insert_integer",
1684 },
1685 Token::Str("index"),
1686 Token::U32(0),
1687 Token::Str("value"),
1688 Token::U32(42),
1689 Token::StructEnd,
1690 Token::Str("extra_key"),
1691 Token::Str("extra value"),
1692 Token::MapEnd,
1693 ],
1694 );
1695 }
1696
1697 #[test]
test_flatten_struct_tag_content_enum()1698 fn test_flatten_struct_tag_content_enum() {
1699 let change_request = FlattenStructTagContentEnumWrapper {
1700 outer: 42,
1701 data: FlattenStructTagContentEnumNewtype(FlattenStructTagContentEnum::InsertInteger {
1702 index: 0,
1703 value: 42,
1704 }),
1705 };
1706 assert_de_tokens(
1707 &change_request,
1708 &[
1709 Token::Map { len: None },
1710 Token::Str("outer"),
1711 Token::U32(42),
1712 Token::Str("type"),
1713 Token::Str("insert_integer"),
1714 Token::Str("value"),
1715 Token::Map { len: None },
1716 Token::Str("index"),
1717 Token::U32(0),
1718 Token::Str("value"),
1719 Token::U32(42),
1720 Token::MapEnd,
1721 Token::MapEnd,
1722 ],
1723 );
1724 assert_ser_tokens(
1725 &change_request,
1726 &[
1727 Token::Map { len: None },
1728 Token::Str("outer"),
1729 Token::U32(42),
1730 Token::Str("type"),
1731 Token::Str("insert_integer"),
1732 Token::Str("value"),
1733 Token::Struct {
1734 len: 2,
1735 name: "insert_integer",
1736 },
1737 Token::Str("index"),
1738 Token::U32(0),
1739 Token::Str("value"),
1740 Token::U32(42),
1741 Token::StructEnd,
1742 Token::MapEnd,
1743 ],
1744 );
1745 }
1746
1747 #[test]
test_flatten_struct_tag_content_enum_newtype()1748 fn test_flatten_struct_tag_content_enum_newtype() {
1749 let change_request = FlattenStructTagContentEnumWrapper {
1750 outer: 42,
1751 data: FlattenStructTagContentEnumNewtype(FlattenStructTagContentEnum::NewtypeVariant(
1752 FlattenStructTagContentEnumNewtypeVariant { value: 23 },
1753 )),
1754 };
1755 assert_de_tokens(
1756 &change_request,
1757 &[
1758 Token::Map { len: None },
1759 Token::Str("outer"),
1760 Token::U32(42),
1761 Token::Str("type"),
1762 Token::Str("newtype_variant"),
1763 Token::Str("value"),
1764 Token::Map { len: None },
1765 Token::Str("value"),
1766 Token::U32(23),
1767 Token::MapEnd,
1768 Token::MapEnd,
1769 ],
1770 );
1771 assert_ser_tokens(
1772 &change_request,
1773 &[
1774 Token::Map { len: None },
1775 Token::Str("outer"),
1776 Token::U32(42),
1777 Token::Str("type"),
1778 Token::Str("newtype_variant"),
1779 Token::Str("value"),
1780 Token::Struct {
1781 len: 1,
1782 name: "FlattenStructTagContentEnumNewtypeVariant",
1783 },
1784 Token::Str("value"),
1785 Token::U32(23),
1786 Token::StructEnd,
1787 Token::MapEnd,
1788 ],
1789 );
1790 }
1791
1792 #[test]
test_unknown_field_in_flatten()1793 fn test_unknown_field_in_flatten() {
1794 #[derive(Debug, PartialEq, Serialize, Deserialize)]
1795 #[serde(deny_unknown_fields)]
1796 struct Outer {
1797 dummy: String,
1798 #[serde(flatten)]
1799 inner: Inner,
1800 }
1801
1802 #[derive(Debug, PartialEq, Serialize, Deserialize)]
1803 struct Inner {
1804 foo: HashMap<String, u32>,
1805 }
1806
1807 assert_de_tokens_error::<Outer>(
1808 &[
1809 Token::Struct {
1810 name: "Outer",
1811 len: 1,
1812 },
1813 Token::Str("dummy"),
1814 Token::Str("23"),
1815 Token::Str("foo"),
1816 Token::Map { len: None },
1817 Token::Str("a"),
1818 Token::U32(1),
1819 Token::Str("b"),
1820 Token::U32(2),
1821 Token::MapEnd,
1822 Token::Str("bar"),
1823 Token::U32(23),
1824 Token::StructEnd,
1825 ],
1826 "unknown field `bar`",
1827 );
1828 }
1829
1830 #[test]
test_complex_flatten()1831 fn test_complex_flatten() {
1832 #[derive(Debug, PartialEq, Serialize, Deserialize)]
1833 struct Outer {
1834 y: u32,
1835 #[serde(flatten)]
1836 first: First,
1837 #[serde(flatten)]
1838 second: Second,
1839 z: u32,
1840 }
1841
1842 #[derive(Debug, PartialEq, Serialize, Deserialize)]
1843 struct First {
1844 a: u32,
1845 b: bool,
1846 c: Vec<String>,
1847 d: String,
1848 e: Option<u64>,
1849 }
1850
1851 #[derive(Debug, PartialEq, Serialize, Deserialize)]
1852 struct Second {
1853 f: u32,
1854 }
1855
1856 assert_de_tokens(
1857 &Outer {
1858 y: 0,
1859 first: First {
1860 a: 1,
1861 b: true,
1862 c: vec!["a".into(), "b".into()],
1863 d: "c".into(),
1864 e: Some(2),
1865 },
1866 second: Second { f: 3 },
1867 z: 4,
1868 },
1869 &[
1870 Token::Map { len: None },
1871 Token::Str("y"),
1872 Token::U32(0),
1873 Token::Str("a"),
1874 Token::U32(1),
1875 Token::Str("b"),
1876 Token::Bool(true),
1877 Token::Str("c"),
1878 Token::Seq { len: Some(2) },
1879 Token::Str("a"),
1880 Token::Str("b"),
1881 Token::SeqEnd,
1882 Token::Str("d"),
1883 Token::Str("c"),
1884 Token::Str("e"),
1885 Token::U64(2),
1886 Token::Str("f"),
1887 Token::U32(3),
1888 Token::Str("z"),
1889 Token::U32(4),
1890 Token::MapEnd,
1891 ],
1892 );
1893
1894 assert_ser_tokens(
1895 &Outer {
1896 y: 0,
1897 first: First {
1898 a: 1,
1899 b: true,
1900 c: vec!["a".into(), "b".into()],
1901 d: "c".into(),
1902 e: Some(2),
1903 },
1904 second: Second { f: 3 },
1905 z: 4,
1906 },
1907 &[
1908 Token::Map { len: None },
1909 Token::Str("y"),
1910 Token::U32(0),
1911 Token::Str("a"),
1912 Token::U32(1),
1913 Token::Str("b"),
1914 Token::Bool(true),
1915 Token::Str("c"),
1916 Token::Seq { len: Some(2) },
1917 Token::Str("a"),
1918 Token::Str("b"),
1919 Token::SeqEnd,
1920 Token::Str("d"),
1921 Token::Str("c"),
1922 Token::Str("e"),
1923 Token::Some,
1924 Token::U64(2),
1925 Token::Str("f"),
1926 Token::U32(3),
1927 Token::Str("z"),
1928 Token::U32(4),
1929 Token::MapEnd,
1930 ],
1931 );
1932 }
1933
1934 #[test]
test_flatten_map_twice()1935 fn test_flatten_map_twice() {
1936 #[derive(Debug, PartialEq, Deserialize)]
1937 struct Outer {
1938 #[serde(flatten)]
1939 first: BTreeMap<String, String>,
1940 #[serde(flatten)]
1941 between: Inner,
1942 #[serde(flatten)]
1943 second: BTreeMap<String, String>,
1944 }
1945
1946 #[derive(Debug, PartialEq, Deserialize)]
1947 struct Inner {
1948 y: String,
1949 }
1950
1951 assert_de_tokens(
1952 &Outer {
1953 first: {
1954 let mut first = BTreeMap::new();
1955 first.insert("x".to_owned(), "X".to_owned());
1956 first.insert("y".to_owned(), "Y".to_owned());
1957 first
1958 },
1959 between: Inner { y: "Y".to_owned() },
1960 second: {
1961 let mut second = BTreeMap::new();
1962 second.insert("x".to_owned(), "X".to_owned());
1963 second
1964 },
1965 },
1966 &[
1967 Token::Map { len: None },
1968 Token::Str("x"),
1969 Token::Str("X"),
1970 Token::Str("y"),
1971 Token::Str("Y"),
1972 Token::MapEnd,
1973 ],
1974 );
1975 }
1976
1977 #[test]
test_flatten_unit()1978 fn test_flatten_unit() {
1979 #[derive(Debug, PartialEq, Serialize, Deserialize)]
1980 struct Response<T> {
1981 #[serde(flatten)]
1982 data: T,
1983 status: usize,
1984 }
1985
1986 assert_tokens(
1987 &Response {
1988 data: (),
1989 status: 0,
1990 },
1991 &[
1992 Token::Map { len: None },
1993 Token::Str("status"),
1994 Token::U64(0),
1995 Token::MapEnd,
1996 ],
1997 );
1998 }
1999
2000 #[test]
test_flatten_unsupported_type()2001 fn test_flatten_unsupported_type() {
2002 #[derive(Debug, PartialEq, Serialize, Deserialize)]
2003 struct Outer {
2004 outer: String,
2005 #[serde(flatten)]
2006 inner: String,
2007 }
2008
2009 assert_ser_tokens_error(
2010 &Outer {
2011 outer: "foo".into(),
2012 inner: "bar".into(),
2013 },
2014 &[
2015 Token::Map { len: None },
2016 Token::Str("outer"),
2017 Token::Str("foo"),
2018 ],
2019 "can only flatten structs and maps (got a string)",
2020 );
2021 assert_de_tokens_error::<Outer>(
2022 &[
2023 Token::Map { len: None },
2024 Token::Str("outer"),
2025 Token::Str("foo"),
2026 Token::Str("a"),
2027 Token::Str("b"),
2028 Token::MapEnd,
2029 ],
2030 "can only flatten structs and maps",
2031 );
2032 }
2033
2034 #[test]
test_non_string_keys()2035 fn test_non_string_keys() {
2036 #[derive(Debug, PartialEq, Serialize, Deserialize)]
2037 struct TestStruct {
2038 name: String,
2039 age: u32,
2040 #[serde(flatten)]
2041 mapping: HashMap<u32, u32>,
2042 }
2043
2044 let mut mapping = HashMap::new();
2045 mapping.insert(0, 42);
2046 assert_tokens(
2047 &TestStruct {
2048 name: "peter".into(),
2049 age: 3,
2050 mapping,
2051 },
2052 &[
2053 Token::Map { len: None },
2054 Token::Str("name"),
2055 Token::Str("peter"),
2056 Token::Str("age"),
2057 Token::U32(3),
2058 Token::U32(0),
2059 Token::U32(42),
2060 Token::MapEnd,
2061 ],
2062 );
2063 }
2064
2065 #[test]
test_lifetime_propagation_for_flatten()2066 fn test_lifetime_propagation_for_flatten() {
2067 #[derive(Deserialize, Serialize, Debug, PartialEq)]
2068 struct A<T> {
2069 #[serde(flatten)]
2070 t: T,
2071 }
2072
2073 #[derive(Deserialize, Serialize, Debug, PartialEq)]
2074 struct B<'a> {
2075 #[serde(flatten, borrow)]
2076 t: HashMap<&'a str, u32>,
2077 }
2078
2079 #[derive(Deserialize, Serialize, Debug, PartialEq)]
2080 struct C<'a> {
2081 #[serde(flatten, borrow)]
2082 t: HashMap<&'a [u8], u32>,
2083 }
2084
2085 let mut owned_map = HashMap::new();
2086 owned_map.insert("x".to_string(), 42u32);
2087 assert_tokens(
2088 &A { t: owned_map },
2089 &[
2090 Token::Map { len: None },
2091 Token::Str("x"),
2092 Token::U32(42),
2093 Token::MapEnd,
2094 ],
2095 );
2096
2097 let mut borrowed_map = HashMap::new();
2098 borrowed_map.insert("x", 42u32);
2099 assert_ser_tokens(
2100 &B {
2101 t: borrowed_map.clone(),
2102 },
2103 &[
2104 Token::Map { len: None },
2105 Token::BorrowedStr("x"),
2106 Token::U32(42),
2107 Token::MapEnd,
2108 ],
2109 );
2110
2111 assert_de_tokens(
2112 &B { t: borrowed_map },
2113 &[
2114 Token::Map { len: None },
2115 Token::BorrowedStr("x"),
2116 Token::U32(42),
2117 Token::MapEnd,
2118 ],
2119 );
2120
2121 let mut borrowed_map = HashMap::new();
2122 borrowed_map.insert(&b"x"[..], 42u32);
2123 assert_ser_tokens(
2124 &C {
2125 t: borrowed_map.clone(),
2126 },
2127 &[
2128 Token::Map { len: None },
2129 Token::Seq { len: Some(1) },
2130 Token::U8(120),
2131 Token::SeqEnd,
2132 Token::U32(42),
2133 Token::MapEnd,
2134 ],
2135 );
2136
2137 assert_de_tokens(
2138 &C { t: borrowed_map },
2139 &[
2140 Token::Map { len: None },
2141 Token::BorrowedBytes(b"x"),
2142 Token::U32(42),
2143 Token::MapEnd,
2144 ],
2145 );
2146 }
2147
2148 #[test]
test_flatten_enum_newtype()2149 fn test_flatten_enum_newtype() {
2150 #[derive(Serialize, Deserialize, PartialEq, Debug)]
2151 struct S {
2152 #[serde(flatten)]
2153 flat: E,
2154 }
2155
2156 #[derive(Serialize, Deserialize, PartialEq, Debug)]
2157 enum E {
2158 Q(HashMap<String, String>),
2159 }
2160
2161 let e = E::Q({
2162 let mut map = HashMap::new();
2163 map.insert("k".to_owned(), "v".to_owned());
2164 map
2165 });
2166 let s = S { flat: e };
2167
2168 assert_tokens(
2169 &s,
2170 &[
2171 Token::Map { len: None },
2172 Token::Str("Q"),
2173 Token::Map { len: Some(1) },
2174 Token::Str("k"),
2175 Token::Str("v"),
2176 Token::MapEnd,
2177 Token::MapEnd,
2178 ],
2179 );
2180 }
2181
2182 #[test]
test_flatten_internally_tagged()2183 fn test_flatten_internally_tagged() {
2184 #[derive(Serialize, Deserialize, PartialEq, Debug)]
2185 struct S {
2186 #[serde(flatten)]
2187 x: X,
2188 #[serde(flatten)]
2189 y: Y,
2190 }
2191
2192 #[derive(Serialize, Deserialize, PartialEq, Debug)]
2193 #[serde(tag = "typeX")]
2194 enum X {
2195 A { a: i32 },
2196 B { b: i32 },
2197 }
2198
2199 #[derive(Serialize, Deserialize, PartialEq, Debug)]
2200 #[serde(tag = "typeY")]
2201 enum Y {
2202 C { c: i32 },
2203 D { d: i32 },
2204 }
2205
2206 let s = S {
2207 x: X::B { b: 1 },
2208 y: Y::D { d: 2 },
2209 };
2210
2211 assert_tokens(
2212 &s,
2213 &[
2214 Token::Map { len: None },
2215 Token::Str("typeX"),
2216 Token::Str("B"),
2217 Token::Str("b"),
2218 Token::I32(1),
2219 Token::Str("typeY"),
2220 Token::Str("D"),
2221 Token::Str("d"),
2222 Token::I32(2),
2223 Token::MapEnd,
2224 ],
2225 );
2226 }
2227
2228 #[test]
test_externally_tagged_enum_containing_flatten()2229 fn test_externally_tagged_enum_containing_flatten() {
2230 #[derive(Serialize, Deserialize, PartialEq, Debug)]
2231 enum Data {
2232 A {
2233 a: i32,
2234 #[serde(flatten)]
2235 flat: Flat,
2236 },
2237 }
2238
2239 #[derive(Serialize, Deserialize, PartialEq, Debug)]
2240 struct Flat {
2241 b: i32,
2242 }
2243
2244 let data = Data::A {
2245 a: 0,
2246 flat: Flat { b: 0 },
2247 };
2248
2249 assert_tokens(
2250 &data,
2251 &[
2252 Token::NewtypeVariant {
2253 name: "Data",
2254 variant: "A",
2255 },
2256 Token::Map { len: None },
2257 Token::Str("a"),
2258 Token::I32(0),
2259 Token::Str("b"),
2260 Token::I32(0),
2261 Token::MapEnd,
2262 ],
2263 );
2264 }
2265
2266 #[test]
test_internally_tagged_enum_containing_flatten()2267 fn test_internally_tagged_enum_containing_flatten() {
2268 #[derive(Serialize, Deserialize, PartialEq, Debug)]
2269 #[serde(tag = "t")]
2270 enum Data {
2271 A {
2272 a: i32,
2273 #[serde(flatten)]
2274 flat: Flat,
2275 },
2276 }
2277
2278 #[derive(Serialize, Deserialize, PartialEq, Debug)]
2279 struct Flat {
2280 b: i32,
2281 }
2282
2283 let data = Data::A {
2284 a: 0,
2285 flat: Flat { b: 0 },
2286 };
2287
2288 assert_tokens(
2289 &data,
2290 &[
2291 Token::Map { len: None },
2292 Token::Str("t"),
2293 Token::Str("A"),
2294 Token::Str("a"),
2295 Token::I32(0),
2296 Token::Str("b"),
2297 Token::I32(0),
2298 Token::MapEnd,
2299 ],
2300 );
2301 }
2302
2303 #[test]
test_adjacently_tagged_enum_containing_flatten()2304 fn test_adjacently_tagged_enum_containing_flatten() {
2305 #[derive(Serialize, Deserialize, PartialEq, Debug)]
2306 #[serde(tag = "t", content = "c")]
2307 enum Data {
2308 A {
2309 a: i32,
2310 #[serde(flatten)]
2311 flat: Flat,
2312 },
2313 }
2314
2315 #[derive(Serialize, Deserialize, PartialEq, Debug)]
2316 struct Flat {
2317 b: i32,
2318 }
2319
2320 let data = Data::A {
2321 a: 0,
2322 flat: Flat { b: 0 },
2323 };
2324
2325 assert_tokens(
2326 &data,
2327 &[
2328 Token::Struct {
2329 name: "Data",
2330 len: 2,
2331 },
2332 Token::Str("t"),
2333 Token::Str("A"),
2334 Token::Str("c"),
2335 Token::Map { len: None },
2336 Token::Str("a"),
2337 Token::I32(0),
2338 Token::Str("b"),
2339 Token::I32(0),
2340 Token::MapEnd,
2341 Token::StructEnd,
2342 ],
2343 );
2344 }
2345
2346 #[test]
test_untagged_enum_containing_flatten()2347 fn test_untagged_enum_containing_flatten() {
2348 #[derive(Serialize, Deserialize, PartialEq, Debug)]
2349 #[serde(untagged)]
2350 enum Data {
2351 A {
2352 a: i32,
2353 #[serde(flatten)]
2354 flat: Flat,
2355 },
2356 }
2357
2358 #[derive(Serialize, Deserialize, PartialEq, Debug)]
2359 struct Flat {
2360 b: i32,
2361 }
2362
2363 let data = Data::A {
2364 a: 0,
2365 flat: Flat { b: 0 },
2366 };
2367
2368 assert_tokens(
2369 &data,
2370 &[
2371 Token::Map { len: None },
2372 Token::Str("a"),
2373 Token::I32(0),
2374 Token::Str("b"),
2375 Token::I32(0),
2376 Token::MapEnd,
2377 ],
2378 );
2379 }
2380
2381 #[test]
test_flatten_untagged_enum()2382 fn test_flatten_untagged_enum() {
2383 #[derive(Serialize, Deserialize, PartialEq, Debug)]
2384 struct Outer {
2385 #[serde(flatten)]
2386 inner: Inner,
2387 }
2388
2389 #[derive(Serialize, Deserialize, PartialEq, Debug)]
2390 #[serde(untagged)]
2391 enum Inner {
2392 Variant { a: i32 },
2393 }
2394
2395 let data = Outer {
2396 inner: Inner::Variant { a: 0 },
2397 };
2398
2399 assert_tokens(
2400 &data,
2401 &[
2402 Token::Map { len: None },
2403 Token::Str("a"),
2404 Token::I32(0),
2405 Token::MapEnd,
2406 ],
2407 );
2408 }
2409
2410 #[test]
test_flatten_option()2411 fn test_flatten_option() {
2412 #[derive(Serialize, Deserialize, PartialEq, Debug)]
2413 struct Outer {
2414 #[serde(flatten)]
2415 inner1: Option<Inner1>,
2416 #[serde(flatten)]
2417 inner2: Option<Inner2>,
2418 }
2419
2420 #[derive(Serialize, Deserialize, PartialEq, Debug)]
2421 struct Inner1 {
2422 inner1: i32,
2423 }
2424
2425 #[derive(Serialize, Deserialize, PartialEq, Debug)]
2426 struct Inner2 {
2427 inner2: i32,
2428 }
2429
2430 assert_tokens(
2431 &Outer {
2432 inner1: Some(Inner1 { inner1: 1 }),
2433 inner2: Some(Inner2 { inner2: 2 }),
2434 },
2435 &[
2436 Token::Map { len: None },
2437 Token::Str("inner1"),
2438 Token::I32(1),
2439 Token::Str("inner2"),
2440 Token::I32(2),
2441 Token::MapEnd,
2442 ],
2443 );
2444
2445 assert_tokens(
2446 &Outer {
2447 inner1: Some(Inner1 { inner1: 1 }),
2448 inner2: None,
2449 },
2450 &[
2451 Token::Map { len: None },
2452 Token::Str("inner1"),
2453 Token::I32(1),
2454 Token::MapEnd,
2455 ],
2456 );
2457
2458 assert_tokens(
2459 &Outer {
2460 inner1: None,
2461 inner2: Some(Inner2 { inner2: 2 }),
2462 },
2463 &[
2464 Token::Map { len: None },
2465 Token::Str("inner2"),
2466 Token::I32(2),
2467 Token::MapEnd,
2468 ],
2469 );
2470
2471 assert_tokens(
2472 &Outer {
2473 inner1: None,
2474 inner2: None,
2475 },
2476 &[Token::Map { len: None }, Token::MapEnd],
2477 );
2478 }
2479
2480 #[test]
test_transparent_struct()2481 fn test_transparent_struct() {
2482 #[derive(Serialize, Deserialize, PartialEq, Debug)]
2483 #[serde(transparent)]
2484 struct Transparent {
2485 #[serde(skip)]
2486 a: bool,
2487 b: u32,
2488 #[serde(skip)]
2489 c: bool,
2490 d: PhantomData<()>,
2491 }
2492
2493 assert_tokens(
2494 &Transparent {
2495 a: false,
2496 b: 1,
2497 c: false,
2498 d: PhantomData,
2499 },
2500 &[Token::U32(1)],
2501 );
2502 }
2503
2504 #[test]
test_transparent_tuple_struct()2505 fn test_transparent_tuple_struct() {
2506 #[derive(Serialize, Deserialize, PartialEq, Debug)]
2507 #[serde(transparent)]
2508 struct Transparent(
2509 #[serde(skip)] bool,
2510 u32,
2511 #[serde(skip)] bool,
2512 PhantomData<()>,
2513 );
2514
2515 assert_tokens(&Transparent(false, 1, false, PhantomData), &[Token::U32(1)]);
2516 }
2517
2518 #[test]
test_internally_tagged_unit_enum_with_unknown_fields()2519 fn test_internally_tagged_unit_enum_with_unknown_fields() {
2520 #[derive(Deserialize, PartialEq, Debug)]
2521 #[serde(tag = "t")]
2522 enum Data {
2523 A,
2524 }
2525
2526 let data = Data::A;
2527
2528 assert_de_tokens(
2529 &data,
2530 &[
2531 Token::Map { len: None },
2532 Token::Str("t"),
2533 Token::Str("A"),
2534 Token::Str("b"),
2535 Token::I32(0),
2536 Token::MapEnd,
2537 ],
2538 );
2539 }
2540
2541 #[test]
test_flattened_internally_tagged_unit_enum_with_unknown_fields()2542 fn test_flattened_internally_tagged_unit_enum_with_unknown_fields() {
2543 #[derive(Deserialize, PartialEq, Debug)]
2544 struct S {
2545 #[serde(flatten)]
2546 x: X,
2547 #[serde(flatten)]
2548 y: Y,
2549 }
2550
2551 #[derive(Deserialize, PartialEq, Debug)]
2552 #[serde(tag = "typeX")]
2553 enum X {
2554 A,
2555 }
2556
2557 #[derive(Deserialize, PartialEq, Debug)]
2558 #[serde(tag = "typeY")]
2559 enum Y {
2560 B { c: u32 },
2561 }
2562
2563 let s = S {
2564 x: X::A,
2565 y: Y::B { c: 0 },
2566 };
2567
2568 assert_de_tokens(
2569 &s,
2570 &[
2571 Token::Map { len: None },
2572 Token::Str("typeX"),
2573 Token::Str("A"),
2574 Token::Str("typeY"),
2575 Token::Str("B"),
2576 Token::Str("c"),
2577 Token::I32(0),
2578 Token::MapEnd,
2579 ],
2580 );
2581 }
2582
2583 #[test]
test_flatten_any_after_flatten_struct()2584 fn test_flatten_any_after_flatten_struct() {
2585 #[derive(PartialEq, Debug)]
2586 struct Any;
2587
2588 impl<'de> Deserialize<'de> for Any {
2589 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
2590 where
2591 D: Deserializer<'de>,
2592 {
2593 struct AnyVisitor;
2594
2595 impl<'de> Visitor<'de> for AnyVisitor {
2596 type Value = Any;
2597
2598 fn expecting(&self, _formatter: &mut fmt::Formatter) -> fmt::Result {
2599 unimplemented!()
2600 }
2601
2602 fn visit_map<M>(self, mut map: M) -> Result<Self::Value, M::Error>
2603 where
2604 M: MapAccess<'de>,
2605 {
2606 while let Some((Any, Any)) = map.next_entry()? {}
2607 Ok(Any)
2608 }
2609 }
2610
2611 deserializer.deserialize_any(AnyVisitor)
2612 }
2613 }
2614
2615 #[derive(Deserialize, PartialEq, Debug)]
2616 struct Outer {
2617 #[serde(flatten)]
2618 inner: Inner,
2619 #[serde(flatten)]
2620 extra: Any,
2621 }
2622
2623 #[derive(Deserialize, PartialEq, Debug)]
2624 struct Inner {
2625 inner: i32,
2626 }
2627
2628 let s = Outer {
2629 inner: Inner { inner: 0 },
2630 extra: Any,
2631 };
2632
2633 assert_de_tokens(
2634 &s,
2635 &[
2636 Token::Map { len: None },
2637 Token::Str("inner"),
2638 Token::I32(0),
2639 Token::MapEnd,
2640 ],
2641 );
2642 }
2643
2644 #[test]
test_expecting_message()2645 fn test_expecting_message() {
2646 #[derive(Deserialize, PartialEq, Debug)]
2647 #[serde(expecting = "something strange...")]
2648 struct Unit;
2649
2650 #[derive(Deserialize)]
2651 #[serde(expecting = "something strange...")]
2652 struct Newtype(bool);
2653
2654 #[derive(Deserialize)]
2655 #[serde(expecting = "something strange...")]
2656 struct Tuple(u32, bool);
2657
2658 #[derive(Deserialize)]
2659 #[serde(expecting = "something strange...")]
2660 struct Struct {
2661 question: String,
2662 answer: u32,
2663 }
2664
2665 assert_de_tokens_error::<Unit>(
2666 &[Token::Str("Unit")],
2667 r#"invalid type: string "Unit", expected something strange..."#,
2668 );
2669
2670 assert_de_tokens_error::<Newtype>(
2671 &[Token::Str("Newtype")],
2672 r#"invalid type: string "Newtype", expected something strange..."#,
2673 );
2674
2675 assert_de_tokens_error::<Tuple>(
2676 &[Token::Str("Tuple")],
2677 r#"invalid type: string "Tuple", expected something strange..."#,
2678 );
2679
2680 assert_de_tokens_error::<Struct>(
2681 &[Token::Str("Struct")],
2682 r#"invalid type: string "Struct", expected something strange..."#,
2683 );
2684 }
2685
2686 #[test]
test_expecting_message_externally_tagged_enum()2687 fn test_expecting_message_externally_tagged_enum() {
2688 #[derive(Deserialize)]
2689 #[serde(expecting = "something strange...")]
2690 enum Enum {
2691 ExternallyTagged,
2692 }
2693
2694 assert_de_tokens_error::<Enum>(
2695 &[Token::Str("ExternallyTagged")],
2696 r#"invalid type: string "ExternallyTagged", expected something strange..."#,
2697 );
2698
2699 // Check that #[serde(expecting = "...")] doesn't affect variant identifier error message
2700 assert_de_tokens_error::<Enum>(
2701 &[Token::Enum { name: "Enum" }, Token::Unit],
2702 r#"invalid type: unit value, expected variant identifier"#,
2703 );
2704 }
2705
2706 #[test]
test_expecting_message_internally_tagged_enum()2707 fn test_expecting_message_internally_tagged_enum() {
2708 #[derive(Deserialize)]
2709 #[serde(tag = "tag")]
2710 #[serde(expecting = "something strange...")]
2711 enum Enum {
2712 InternallyTagged,
2713 }
2714
2715 assert_de_tokens_error::<Enum>(
2716 &[Token::Str("InternallyTagged")],
2717 r#"invalid type: string "InternallyTagged", expected something strange..."#,
2718 );
2719
2720 // Check that #[serde(expecting = "...")] doesn't affect variant identifier error message
2721 assert_de_tokens_error::<Enum>(
2722 &[Token::Map { len: None }, Token::Str("tag"), Token::Unit],
2723 r#"invalid type: unit value, expected variant identifier"#,
2724 );
2725 }
2726
2727 #[test]
test_expecting_message_adjacently_tagged_enum()2728 fn test_expecting_message_adjacently_tagged_enum() {
2729 #[derive(Deserialize)]
2730 #[serde(tag = "tag", content = "content")]
2731 #[serde(expecting = "something strange...")]
2732 enum Enum {
2733 AdjacentlyTagged,
2734 }
2735
2736 assert_de_tokens_error::<Enum>(
2737 &[Token::Str("AdjacentlyTagged")],
2738 r#"invalid type: string "AdjacentlyTagged", expected something strange..."#,
2739 );
2740
2741 assert_de_tokens_error::<Enum>(
2742 &[Token::Map { len: None }, Token::Unit],
2743 r#"invalid type: unit value, expected "tag", "content", or other ignored fields"#,
2744 );
2745
2746 // Check that #[serde(expecting = "...")] doesn't affect variant identifier error message
2747 assert_de_tokens_error::<Enum>(
2748 &[Token::Map { len: None }, Token::Str("tag"), Token::Unit],
2749 r#"invalid type: unit value, expected variant identifier"#,
2750 );
2751 }
2752
2753 #[test]
test_expecting_message_untagged_tagged_enum()2754 fn test_expecting_message_untagged_tagged_enum() {
2755 #[derive(Deserialize)]
2756 #[serde(untagged)]
2757 #[serde(expecting = "something strange...")]
2758 enum Enum {
2759 Untagged,
2760 }
2761
2762 assert_de_tokens_error::<Enum>(&[Token::Str("Untagged")], r#"something strange..."#);
2763 }
2764
2765 #[test]
test_expecting_message_identifier_enum()2766 fn test_expecting_message_identifier_enum() {
2767 #[derive(Deserialize)]
2768 #[serde(field_identifier)]
2769 #[serde(expecting = "something strange...")]
2770 enum FieldEnum {
2771 Field,
2772 }
2773
2774 #[derive(Deserialize)]
2775 #[serde(variant_identifier)]
2776 #[serde(expecting = "something strange...")]
2777 enum VariantEnum {
2778 Variant,
2779 }
2780
2781 assert_de_tokens_error::<FieldEnum>(
2782 &[Token::Unit],
2783 r#"invalid type: unit value, expected something strange..."#,
2784 );
2785
2786 assert_de_tokens_error::<FieldEnum>(
2787 &[
2788 Token::Enum { name: "FieldEnum" },
2789 Token::Str("Unknown"),
2790 Token::None,
2791 ],
2792 r#"invalid type: map, expected something strange..."#,
2793 );
2794
2795 assert_de_tokens_error::<VariantEnum>(
2796 &[Token::Unit],
2797 r#"invalid type: unit value, expected something strange..."#,
2798 );
2799
2800 assert_de_tokens_error::<VariantEnum>(
2801 &[
2802 Token::Enum {
2803 name: "VariantEnum",
2804 },
2805 Token::Str("Unknown"),
2806 Token::None,
2807 ],
2808 r#"invalid type: map, expected something strange..."#,
2809 );
2810 }
2811