1 #![allow(clippy::derive_partial_eq_without_eq, clippy::unreadable_literal)]
2 #![cfg_attr(feature = "unstable", feature(never_type))]
3
4 use fnv::FnvHasher;
5 use serde_derive::Serialize;
6 use serde_test::{assert_ser_tokens, assert_ser_tokens_error, Configure, Token};
7 use std::cell::RefCell;
8 use std::collections::{BTreeMap, BTreeSet, HashMap, HashSet};
9 use std::ffi::CString;
10 use std::net;
11 use std::num::Wrapping;
12 use std::ops::Bound;
13 use std::path::{Path, PathBuf};
14 use std::rc::{Rc, Weak as RcWeak};
15 #[cfg(unix)]
16 use std::str;
17 use std::sync::atomic::{
18 AtomicBool, AtomicI16, AtomicI32, AtomicI8, AtomicIsize, AtomicU16, AtomicU32, AtomicU8,
19 AtomicUsize,
20 };
21 #[cfg(target_arch = "x86_64")]
22 use std::sync::atomic::{AtomicI64, AtomicU64};
23 use std::sync::{Arc, Mutex, RwLock, Weak as ArcWeak};
24 use std::time::{Duration, UNIX_EPOCH};
25
26 #[macro_use]
27 mod macros;
28
29 //////////////////////////////////////////////////////////////////////////
30
31 #[derive(Serialize)]
32 struct UnitStruct;
33
34 #[derive(Serialize)]
35 struct TupleStruct(i32, i32, i32);
36
37 #[derive(Serialize)]
38 struct Struct {
39 a: i32,
40 b: i32,
41 c: i32,
42 }
43
44 #[derive(PartialEq, Debug)]
45 struct NotSerializable;
46
47 #[derive(Serialize, PartialEq, Debug)]
48 enum Enum {
49 Unit,
50 One(i32),
51 Seq(i32, i32),
52 Map {
53 a: i32,
54 b: i32,
55 },
56 #[serde(skip_serializing)]
57 SkippedUnit,
58 #[serde(skip_serializing)]
59 SkippedOne(i32),
60 #[serde(skip_serializing)]
61 SkippedSeq(i32, i32),
62 #[serde(skip_serializing)]
63 SkippedMap {
64 _a: i32,
65 _b: i32,
66 },
67 OneWithSkipped(#[serde(skip_serializing)] NotSerializable),
68 }
69
70 //////////////////////////////////////////////////////////////////////////
71
72 #[test]
test_unit()73 fn test_unit() {
74 assert_ser_tokens(&(), &[Token::Unit]);
75 }
76
77 #[test]
test_bool()78 fn test_bool() {
79 assert_ser_tokens(&true, &[Token::Bool(true)]);
80 assert_ser_tokens(&false, &[Token::Bool(false)]);
81 }
82
83 #[test]
test_isizes()84 fn test_isizes() {
85 assert_ser_tokens(&0i8, &[Token::I8(0)]);
86 assert_ser_tokens(&0i16, &[Token::I16(0)]);
87 assert_ser_tokens(&0i32, &[Token::I32(0)]);
88 assert_ser_tokens(&0i64, &[Token::I64(0)]);
89 }
90
91 #[test]
test_usizes()92 fn test_usizes() {
93 assert_ser_tokens(&0u8, &[Token::U8(0)]);
94 assert_ser_tokens(&0u16, &[Token::U16(0)]);
95 assert_ser_tokens(&0u32, &[Token::U32(0)]);
96 assert_ser_tokens(&0u64, &[Token::U64(0)]);
97 }
98
99 #[test]
test_floats()100 fn test_floats() {
101 assert_ser_tokens(&0f32, &[Token::F32(0.)]);
102 assert_ser_tokens(&0f64, &[Token::F64(0.)]);
103 }
104
105 #[test]
test_char()106 fn test_char() {
107 assert_ser_tokens(&'a', &[Token::Char('a')]);
108 }
109
110 #[test]
test_str()111 fn test_str() {
112 assert_ser_tokens(&"abc", &[Token::Str("abc")]);
113 assert_ser_tokens(&"abc".to_owned(), &[Token::Str("abc")]);
114 }
115
116 #[test]
test_option()117 fn test_option() {
118 assert_ser_tokens(&None::<i32>, &[Token::None]);
119 assert_ser_tokens(&Some(1), &[Token::Some, Token::I32(1)]);
120 }
121
122 #[test]
test_result()123 fn test_result() {
124 assert_ser_tokens(
125 &Ok::<i32, i32>(0),
126 &[
127 Token::NewtypeVariant {
128 name: "Result",
129 variant: "Ok",
130 },
131 Token::I32(0),
132 ],
133 );
134 assert_ser_tokens(
135 &Err::<i32, i32>(1),
136 &[
137 Token::NewtypeVariant {
138 name: "Result",
139 variant: "Err",
140 },
141 Token::I32(1),
142 ],
143 );
144 }
145
146 #[test]
test_slice()147 fn test_slice() {
148 assert_ser_tokens(&[0][..0], &[Token::Seq { len: Some(0) }, Token::SeqEnd]);
149 assert_ser_tokens(
150 &[1, 2, 3][..],
151 &[
152 Token::Seq { len: Some(3) },
153 Token::I32(1),
154 Token::I32(2),
155 Token::I32(3),
156 Token::SeqEnd,
157 ],
158 );
159 }
160
161 #[test]
test_array()162 fn test_array() {
163 assert_ser_tokens(&[0; 0], &[Token::Tuple { len: 0 }, Token::TupleEnd]);
164 assert_ser_tokens(
165 &[1, 2, 3],
166 &[
167 Token::Tuple { len: 3 },
168 Token::I32(1),
169 Token::I32(2),
170 Token::I32(3),
171 Token::TupleEnd,
172 ],
173 );
174 }
175
176 #[test]
test_vec()177 fn test_vec() {
178 assert_ser_tokens(
179 &Vec::<isize>::new(),
180 &[Token::Seq { len: Some(0) }, Token::SeqEnd],
181 );
182 assert_ser_tokens(
183 &vec![vec![], vec![1], vec![2, 3]],
184 &[
185 Token::Seq { len: Some(3) },
186 Token::Seq { len: Some(0) },
187 Token::SeqEnd,
188 Token::Seq { len: Some(1) },
189 Token::I32(1),
190 Token::SeqEnd,
191 Token::Seq { len: Some(2) },
192 Token::I32(2),
193 Token::I32(3),
194 Token::SeqEnd,
195 Token::SeqEnd,
196 ],
197 );
198 }
199
200 #[test]
test_btreeset()201 fn test_btreeset() {
202 assert_ser_tokens(
203 &BTreeSet::<isize>::new(),
204 &[Token::Seq { len: Some(0) }, Token::SeqEnd],
205 );
206 assert_ser_tokens(
207 &btreeset![1],
208 &[Token::Seq { len: Some(1) }, Token::I32(1), Token::SeqEnd],
209 );
210 }
211
212 #[test]
test_hashset()213 fn test_hashset() {
214 assert_ser_tokens(
215 &HashSet::<isize>::new(),
216 &[Token::Seq { len: Some(0) }, Token::SeqEnd],
217 );
218 assert_ser_tokens(
219 &hashset![1],
220 &[Token::Seq { len: Some(1) }, Token::I32(1), Token::SeqEnd],
221 );
222 assert_ser_tokens(
223 &hashset![FnvHasher @ 1],
224 &[Token::Seq { len: Some(1) }, Token::I32(1), Token::SeqEnd],
225 );
226 }
227
228 #[test]
test_tuple()229 fn test_tuple() {
230 assert_ser_tokens(
231 &(1,),
232 &[Token::Tuple { len: 1 }, Token::I32(1), Token::TupleEnd],
233 );
234 assert_ser_tokens(
235 &(1, 2, 3),
236 &[
237 Token::Tuple { len: 3 },
238 Token::I32(1),
239 Token::I32(2),
240 Token::I32(3),
241 Token::TupleEnd,
242 ],
243 );
244 }
245
246 #[test]
test_btreemap()247 fn test_btreemap() {
248 assert_ser_tokens(
249 &btreemap![1 => 2],
250 &[
251 Token::Map { len: Some(1) },
252 Token::I32(1),
253 Token::I32(2),
254 Token::MapEnd,
255 ],
256 );
257 assert_ser_tokens(
258 &btreemap![1 => 2, 3 => 4],
259 &[
260 Token::Map { len: Some(2) },
261 Token::I32(1),
262 Token::I32(2),
263 Token::I32(3),
264 Token::I32(4),
265 Token::MapEnd,
266 ],
267 );
268 assert_ser_tokens(
269 &btreemap![1 => btreemap![], 2 => btreemap![3 => 4, 5 => 6]],
270 &[
271 Token::Map { len: Some(2) },
272 Token::I32(1),
273 Token::Map { len: Some(0) },
274 Token::MapEnd,
275 Token::I32(2),
276 Token::Map { len: Some(2) },
277 Token::I32(3),
278 Token::I32(4),
279 Token::I32(5),
280 Token::I32(6),
281 Token::MapEnd,
282 Token::MapEnd,
283 ],
284 );
285 }
286
287 #[test]
test_hashmap()288 fn test_hashmap() {
289 assert_ser_tokens(
290 &HashMap::<isize, isize>::new(),
291 &[Token::Map { len: Some(0) }, Token::MapEnd],
292 );
293 assert_ser_tokens(
294 &hashmap![1 => 2],
295 &[
296 Token::Map { len: Some(1) },
297 Token::I32(1),
298 Token::I32(2),
299 Token::MapEnd,
300 ],
301 );
302 assert_ser_tokens(
303 &hashmap![FnvHasher @ 1 => 2],
304 &[
305 Token::Map { len: Some(1) },
306 Token::I32(1),
307 Token::I32(2),
308 Token::MapEnd,
309 ],
310 );
311 }
312
313 #[test]
test_unit_struct()314 fn test_unit_struct() {
315 assert_ser_tokens(&UnitStruct, &[Token::UnitStruct { name: "UnitStruct" }]);
316 }
317
318 #[test]
test_tuple_struct()319 fn test_tuple_struct() {
320 assert_ser_tokens(
321 &TupleStruct(1, 2, 3),
322 &[
323 Token::TupleStruct {
324 name: "TupleStruct",
325 len: 3,
326 },
327 Token::I32(1),
328 Token::I32(2),
329 Token::I32(3),
330 Token::TupleStructEnd,
331 ],
332 );
333 }
334
335 #[test]
test_struct()336 fn test_struct() {
337 assert_ser_tokens(
338 &Struct { a: 1, b: 2, c: 3 },
339 &[
340 Token::Struct {
341 name: "Struct",
342 len: 3,
343 },
344 Token::Str("a"),
345 Token::I32(1),
346 Token::Str("b"),
347 Token::I32(2),
348 Token::Str("c"),
349 Token::I32(3),
350 Token::StructEnd,
351 ],
352 );
353 }
354
355 #[test]
test_enum()356 fn test_enum() {
357 assert_ser_tokens(
358 &Enum::Unit,
359 &[Token::UnitVariant {
360 name: "Enum",
361 variant: "Unit",
362 }],
363 );
364 assert_ser_tokens(
365 &Enum::One(42),
366 &[
367 Token::NewtypeVariant {
368 name: "Enum",
369 variant: "One",
370 },
371 Token::I32(42),
372 ],
373 );
374 assert_ser_tokens(
375 &Enum::Seq(1, 2),
376 &[
377 Token::TupleVariant {
378 name: "Enum",
379 variant: "Seq",
380 len: 2,
381 },
382 Token::I32(1),
383 Token::I32(2),
384 Token::TupleVariantEnd,
385 ],
386 );
387 assert_ser_tokens(
388 &Enum::Map { a: 1, b: 2 },
389 &[
390 Token::StructVariant {
391 name: "Enum",
392 variant: "Map",
393 len: 2,
394 },
395 Token::Str("a"),
396 Token::I32(1),
397 Token::Str("b"),
398 Token::I32(2),
399 Token::StructVariantEnd,
400 ],
401 );
402 assert_ser_tokens(
403 &Enum::OneWithSkipped(NotSerializable),
404 &[Token::UnitVariant {
405 name: "Enum",
406 variant: "OneWithSkipped",
407 }],
408 );
409 }
410
411 #[test]
test_box()412 fn test_box() {
413 assert_ser_tokens(&Box::new(0i32), &[Token::I32(0)]);
414 }
415
416 #[test]
test_boxed_slice()417 fn test_boxed_slice() {
418 assert_ser_tokens(
419 &Box::new([0, 1, 2]),
420 &[
421 Token::Tuple { len: 3 },
422 Token::I32(0),
423 Token::I32(1),
424 Token::I32(2),
425 Token::TupleEnd,
426 ],
427 );
428 }
429
430 #[test]
test_duration()431 fn test_duration() {
432 assert_ser_tokens(
433 &Duration::new(1, 2),
434 &[
435 Token::Struct {
436 name: "Duration",
437 len: 2,
438 },
439 Token::Str("secs"),
440 Token::U64(1),
441 Token::Str("nanos"),
442 Token::U32(2),
443 Token::StructEnd,
444 ],
445 );
446 }
447
448 #[test]
test_system_time()449 fn test_system_time() {
450 let system_time = UNIX_EPOCH + Duration::new(1, 200);
451 assert_ser_tokens(
452 &system_time,
453 &[
454 Token::Struct {
455 name: "SystemTime",
456 len: 2,
457 },
458 Token::Str("secs_since_epoch"),
459 Token::U64(1),
460 Token::Str("nanos_since_epoch"),
461 Token::U32(200),
462 Token::StructEnd,
463 ],
464 );
465 }
466
467 #[test]
test_range()468 fn test_range() {
469 assert_ser_tokens(
470 &(1u32..2u32),
471 &[
472 Token::Struct {
473 name: "Range",
474 len: 2,
475 },
476 Token::Str("start"),
477 Token::U32(1),
478 Token::Str("end"),
479 Token::U32(2),
480 Token::StructEnd,
481 ],
482 );
483 }
484
485 #[test]
test_range_inclusive()486 fn test_range_inclusive() {
487 assert_ser_tokens(
488 &(1u32..=2u32),
489 &[
490 Token::Struct {
491 name: "RangeInclusive",
492 len: 2,
493 },
494 Token::Str("start"),
495 Token::U32(1),
496 Token::Str("end"),
497 Token::U32(2),
498 Token::StructEnd,
499 ],
500 );
501 }
502
503 #[test]
test_range_from()504 fn test_range_from() {
505 assert_ser_tokens(
506 &(1u32..),
507 &[
508 Token::Struct {
509 name: "RangeFrom",
510 len: 1,
511 },
512 Token::Str("start"),
513 Token::U32(1),
514 Token::StructEnd,
515 ],
516 );
517 }
518
519 #[test]
test_range_to()520 fn test_range_to() {
521 assert_ser_tokens(
522 &(..2u32),
523 &[
524 Token::Struct {
525 name: "RangeTo",
526 len: 1,
527 },
528 Token::Str("end"),
529 Token::U32(2),
530 Token::StructEnd,
531 ],
532 );
533 }
534
535 #[test]
test_bound()536 fn test_bound() {
537 assert_ser_tokens(
538 &Bound::Unbounded::<()>,
539 &[
540 Token::Enum { name: "Bound" },
541 Token::Str("Unbounded"),
542 Token::Unit,
543 ],
544 );
545 assert_ser_tokens(
546 &Bound::Included(0u8),
547 &[
548 Token::Enum { name: "Bound" },
549 Token::Str("Included"),
550 Token::U8(0),
551 ],
552 );
553 assert_ser_tokens(
554 &Bound::Excluded(0u8),
555 &[
556 Token::Enum { name: "Bound" },
557 Token::Str("Excluded"),
558 Token::U8(0),
559 ],
560 );
561 }
562
563 #[test]
test_path()564 fn test_path() {
565 assert_ser_tokens(
566 &Path::new("/usr/local/lib"),
567 &[Token::Str("/usr/local/lib")],
568 );
569 }
570
571 #[test]
test_path_buf()572 fn test_path_buf() {
573 assert_ser_tokens(
574 &PathBuf::from("/usr/local/lib"),
575 &[Token::Str("/usr/local/lib")],
576 );
577 }
578
579 #[test]
test_cstring()580 fn test_cstring() {
581 assert_ser_tokens(&CString::new("abc").unwrap(), &[Token::Bytes(b"abc")]);
582 }
583
584 #[test]
test_cstr()585 fn test_cstr() {
586 let cstring = CString::new("abc").unwrap();
587 assert_ser_tokens(cstring.as_c_str(), &[Token::Bytes(b"abc")]);
588 }
589
590 #[test]
test_rc()591 fn test_rc() {
592 assert_ser_tokens(&Rc::new(true), &[Token::Bool(true)]);
593 }
594
595 #[test]
test_rc_weak_some()596 fn test_rc_weak_some() {
597 let rc = Rc::new(true);
598 assert_ser_tokens(&Rc::downgrade(&rc), &[Token::Some, Token::Bool(true)]);
599 }
600
601 #[test]
test_rc_weak_none()602 fn test_rc_weak_none() {
603 assert_ser_tokens(&RcWeak::<bool>::new(), &[Token::None]);
604 }
605
606 #[test]
test_arc()607 fn test_arc() {
608 assert_ser_tokens(&Arc::new(true), &[Token::Bool(true)]);
609 }
610
611 #[test]
test_arc_weak_some()612 fn test_arc_weak_some() {
613 let arc = Arc::new(true);
614 assert_ser_tokens(&Arc::downgrade(&arc), &[Token::Some, Token::Bool(true)]);
615 }
616
617 #[test]
test_arc_weak_none()618 fn test_arc_weak_none() {
619 assert_ser_tokens(&ArcWeak::<bool>::new(), &[Token::None]);
620 }
621
622 #[test]
test_wrapping()623 fn test_wrapping() {
624 assert_ser_tokens(&Wrapping(1usize), &[Token::U64(1)]);
625 }
626
627 #[test]
test_rc_dst()628 fn test_rc_dst() {
629 assert_ser_tokens(&Rc::<str>::from("s"), &[Token::Str("s")]);
630 assert_ser_tokens(
631 &Rc::<[bool]>::from(&[true][..]),
632 &[
633 Token::Seq { len: Some(1) },
634 Token::Bool(true),
635 Token::SeqEnd,
636 ],
637 );
638 }
639
640 #[test]
test_arc_dst()641 fn test_arc_dst() {
642 assert_ser_tokens(&Arc::<str>::from("s"), &[Token::Str("s")]);
643 assert_ser_tokens(
644 &Arc::<[bool]>::from(&[true][..]),
645 &[
646 Token::Seq { len: Some(1) },
647 Token::Bool(true),
648 Token::SeqEnd,
649 ],
650 );
651 }
652
653 #[test]
test_fmt_arguments()654 fn test_fmt_arguments() {
655 assert_ser_tokens(&format_args!("{}{}", 1, 'a'), &[Token::Str("1a")]);
656 }
657
658 #[test]
test_atomic()659 fn test_atomic() {
660 assert_ser_tokens(&AtomicBool::new(false), &[Token::Bool(false)]);
661 assert_ser_tokens(&AtomicBool::new(true), &[Token::Bool(true)]);
662 assert_ser_tokens(&AtomicI8::new(63i8), &[Token::I8(63i8)]);
663 assert_ser_tokens(&AtomicI16::new(-318i16), &[Token::I16(-318i16)]);
664 assert_ser_tokens(&AtomicI32::new(65792i32), &[Token::I32(65792i32)]);
665 assert_ser_tokens(&AtomicIsize::new(-65792isize), &[Token::I64(-65792i64)]);
666 assert_ser_tokens(&AtomicU8::new(192u8), &[Token::U8(192u8)]);
667 assert_ser_tokens(&AtomicU16::new(510u16), &[Token::U16(510u16)]);
668 assert_ser_tokens(&AtomicU32::new(131072u32), &[Token::U32(131072u32)]);
669 assert_ser_tokens(&AtomicUsize::new(655360usize), &[Token::U64(655360u64)]);
670 }
671
672 #[cfg(target_arch = "x86_64")]
673 #[test]
test_atomic64()674 fn test_atomic64() {
675 assert_ser_tokens(
676 &AtomicI64::new(-4295032832i64),
677 &[Token::I64(-4295032832i64)],
678 );
679 assert_ser_tokens(
680 &AtomicU64::new(12884901888u64),
681 &[Token::U64(12884901888u64)],
682 );
683 }
684
685 #[test]
test_net_ipv4addr_readable()686 fn test_net_ipv4addr_readable() {
687 assert_ser_tokens(
688 &"1.2.3.4".parse::<net::Ipv4Addr>().unwrap().readable(),
689 &[Token::Str("1.2.3.4")],
690 );
691 }
692
693 #[test]
test_net_ipv6addr_readable()694 fn test_net_ipv6addr_readable() {
695 assert_ser_tokens(
696 &"::1".parse::<net::Ipv6Addr>().unwrap().readable(),
697 &[Token::Str("::1")],
698 );
699 }
700
701 #[test]
test_net_ipaddr_readable()702 fn test_net_ipaddr_readable() {
703 assert_ser_tokens(
704 &"1.2.3.4".parse::<net::IpAddr>().unwrap().readable(),
705 &[Token::Str("1.2.3.4")],
706 );
707 }
708
709 #[test]
test_net_socketaddr_readable()710 fn test_net_socketaddr_readable() {
711 assert_ser_tokens(
712 &"1.2.3.4:1234"
713 .parse::<net::SocketAddr>()
714 .unwrap()
715 .readable(),
716 &[Token::Str("1.2.3.4:1234")],
717 );
718 assert_ser_tokens(
719 &"1.2.3.4:1234"
720 .parse::<net::SocketAddrV4>()
721 .unwrap()
722 .readable(),
723 &[Token::Str("1.2.3.4:1234")],
724 );
725 assert_ser_tokens(
726 &"[::1]:1234"
727 .parse::<net::SocketAddrV6>()
728 .unwrap()
729 .readable(),
730 &[Token::Str("[::1]:1234")],
731 );
732 }
733
734 #[test]
test_net_ipv4addr_compact()735 fn test_net_ipv4addr_compact() {
736 assert_ser_tokens(
737 &net::Ipv4Addr::from(*b"1234").compact(),
738 &seq![
739 Token::Tuple { len: 4 },
740 b"1234".iter().copied().map(Token::U8),
741 Token::TupleEnd,
742 ],
743 );
744 }
745
746 #[test]
test_net_ipv6addr_compact()747 fn test_net_ipv6addr_compact() {
748 assert_ser_tokens(
749 &net::Ipv6Addr::from(*b"1234567890123456").compact(),
750 &seq![
751 Token::Tuple { len: 16 },
752 b"1234567890123456".iter().copied().map(Token::U8),
753 Token::TupleEnd,
754 ],
755 );
756 }
757
758 #[test]
test_net_ipaddr_compact()759 fn test_net_ipaddr_compact() {
760 assert_ser_tokens(
761 &net::IpAddr::from(*b"1234").compact(),
762 &seq![
763 Token::NewtypeVariant {
764 name: "IpAddr",
765 variant: "V4"
766 },
767 Token::Tuple { len: 4 },
768 b"1234".iter().copied().map(Token::U8),
769 Token::TupleEnd,
770 ],
771 );
772 }
773
774 #[test]
test_net_socketaddr_compact()775 fn test_net_socketaddr_compact() {
776 assert_ser_tokens(
777 &net::SocketAddr::from((*b"1234567890123456", 1234)).compact(),
778 &seq![
779 Token::NewtypeVariant {
780 name: "SocketAddr",
781 variant: "V6"
782 },
783 Token::Tuple { len: 2 },
784 Token::Tuple { len: 16 },
785 b"1234567890123456".iter().copied().map(Token::U8),
786 Token::TupleEnd,
787 Token::U16(1234),
788 Token::TupleEnd,
789 ],
790 );
791 assert_ser_tokens(
792 &net::SocketAddrV4::new(net::Ipv4Addr::from(*b"1234"), 1234).compact(),
793 &seq![
794 Token::Tuple { len: 2 },
795 Token::Tuple { len: 4 },
796 b"1234".iter().copied().map(Token::U8),
797 Token::TupleEnd,
798 Token::U16(1234),
799 Token::TupleEnd,
800 ],
801 );
802 assert_ser_tokens(
803 &net::SocketAddrV6::new(net::Ipv6Addr::from(*b"1234567890123456"), 1234, 0, 0).compact(),
804 &seq![
805 Token::Tuple { len: 2 },
806 Token::Tuple { len: 16 },
807 b"1234567890123456".iter().copied().map(Token::U8),
808 Token::TupleEnd,
809 Token::U16(1234),
810 Token::TupleEnd,
811 ],
812 );
813 }
814
815 #[cfg(feature = "unstable")]
816 #[test]
test_never_result()817 fn test_never_result() {
818 assert_ser_tokens(
819 &Ok::<u8, !>(0),
820 &[
821 Token::NewtypeVariant {
822 name: "Result",
823 variant: "Ok",
824 },
825 Token::U8(0),
826 ],
827 );
828 }
829
830 #[test]
831 #[cfg(unix)]
test_cannot_serialize_paths()832 fn test_cannot_serialize_paths() {
833 use std::ffi::OsStr;
834 use std::os::unix::ffi::OsStrExt;
835
836 assert_ser_tokens_error(
837 &Path::new(OsStr::from_bytes(b"Hello \xF0\x90\x80World")),
838 &[],
839 "path contains invalid UTF-8 characters",
840 );
841 }
842
843 #[test]
test_cannot_serialize_mutably_borrowed_ref_cell()844 fn test_cannot_serialize_mutably_borrowed_ref_cell() {
845 let ref_cell = RefCell::new(42);
846 let _reference = ref_cell.borrow_mut();
847 assert_ser_tokens_error(&ref_cell, &[], "already mutably borrowed");
848 }
849
850 #[test]
test_enum_skipped()851 fn test_enum_skipped() {
852 assert_ser_tokens_error(
853 &Enum::SkippedUnit,
854 &[],
855 "the enum variant Enum::SkippedUnit cannot be serialized",
856 );
857 assert_ser_tokens_error(
858 &Enum::SkippedOne(42),
859 &[],
860 "the enum variant Enum::SkippedOne cannot be serialized",
861 );
862 assert_ser_tokens_error(
863 &Enum::SkippedSeq(1, 2),
864 &[],
865 "the enum variant Enum::SkippedSeq cannot be serialized",
866 );
867 assert_ser_tokens_error(
868 &Enum::SkippedMap { _a: 1, _b: 2 },
869 &[],
870 "the enum variant Enum::SkippedMap cannot be serialized",
871 );
872 }
873
874 #[test]
test_integer128()875 fn test_integer128() {
876 assert_ser_tokens_error(&1i128, &[], "i128 is not supported");
877
878 assert_ser_tokens_error(&1u128, &[], "u128 is not supported");
879 }
880
881 #[test]
test_refcell_dst()882 fn test_refcell_dst() {
883 assert_ser_tokens(
884 &RefCell::new([true]) as &RefCell<[bool]>,
885 &[
886 Token::Seq { len: Some(1) },
887 Token::Bool(true),
888 Token::SeqEnd,
889 ],
890 );
891 }
892
893 #[test]
test_mutex_dst()894 fn test_mutex_dst() {
895 assert_ser_tokens(
896 &Mutex::new([true]) as &Mutex<[bool]>,
897 &[
898 Token::Seq { len: Some(1) },
899 Token::Bool(true),
900 Token::SeqEnd,
901 ],
902 );
903 }
904
905 #[test]
test_rwlock_dst()906 fn test_rwlock_dst() {
907 assert_ser_tokens(
908 &RwLock::new([true]) as &RwLock<[bool]>,
909 &[
910 Token::Seq { len: Some(1) },
911 Token::Bool(true),
912 Token::SeqEnd,
913 ],
914 );
915 }
916