1 #![allow(
2 clippy::cast_lossless,
3 clippy::decimal_literal_representation,
4 clippy::empty_enum,
5 clippy::manual_assert,
6 clippy::needless_pass_by_value,
7 clippy::unreadable_literal
8 )]
9 #![cfg_attr(feature = "unstable", feature(never_type))]
10
11 use std::collections::{BTreeMap, BTreeSet, HashMap, HashSet};
12 use std::default::Default;
13 use std::ffi::{CStr, CString, OsString};
14 use std::fmt::Debug;
15 use std::net;
16 use std::num::{
17 NonZeroI128, NonZeroI16, NonZeroI32, NonZeroI64, NonZeroI8, NonZeroIsize, NonZeroU128,
18 NonZeroU16, NonZeroU32, NonZeroU64, NonZeroU8, NonZeroUsize, Wrapping,
19 };
20 use std::ops::Bound;
21 use std::path::{Path, PathBuf};
22 use std::rc::{Rc, Weak as RcWeak};
23 use std::sync::atomic::{
24 AtomicBool, AtomicI16, AtomicI32, AtomicI8, AtomicIsize, AtomicU16, AtomicU32, AtomicU8,
25 AtomicUsize, Ordering,
26 };
27 use std::sync::{Arc, Weak as ArcWeak};
28 use std::time::{Duration, UNIX_EPOCH};
29
30 #[cfg(target_arch = "x86_64")]
31 use std::sync::atomic::{AtomicI64, AtomicU64};
32
33 use fnv::FnvHasher;
34 use serde::de::DeserializeOwned;
35 use serde::{Deserialize, Deserializer};
36 use serde_test::{assert_de_tokens, Configure, Token};
37
38 #[macro_use]
39 mod macros;
40
41 //////////////////////////////////////////////////////////////////////////
42
43 #[derive(Copy, Clone, PartialEq, Debug, Deserialize)]
44 struct UnitStruct;
45
46 #[derive(PartialEq, Debug, Deserialize)]
47 struct NewtypeStruct(i32);
48
49 #[derive(PartialEq, Debug, Deserialize)]
50 struct TupleStruct(i32, i32, i32);
51
52 #[derive(PartialEq, Debug, Deserialize)]
53 struct Struct {
54 a: i32,
55 b: i32,
56 #[serde(skip_deserializing)]
57 c: i32,
58 }
59
60 #[derive(PartialEq, Debug, Deserialize)]
61 #[serde(default)]
62 struct StructDefault<T> {
63 a: i32,
64 b: T,
65 }
66
67 impl Default for StructDefault<String> {
default() -> Self68 fn default() -> Self {
69 StructDefault {
70 a: 100,
71 b: "default".to_string(),
72 }
73 }
74 }
75
76 #[derive(PartialEq, Debug, Deserialize)]
77 struct StructSkipAll {
78 #[serde(skip_deserializing)]
79 a: i32,
80 }
81
82 #[derive(PartialEq, Debug, Deserialize)]
83 #[serde(default)]
84 struct StructSkipDefault {
85 #[serde(skip_deserializing)]
86 a: i32,
87 }
88
89 #[derive(PartialEq, Debug, Deserialize)]
90 #[serde(default)]
91 struct StructSkipDefaultGeneric<T> {
92 #[serde(skip_deserializing)]
93 t: T,
94 }
95
96 impl Default for StructSkipDefault {
default() -> Self97 fn default() -> Self {
98 StructSkipDefault { a: 16 }
99 }
100 }
101
102 #[derive(PartialEq, Debug, Deserialize)]
103 #[serde(deny_unknown_fields)]
104 struct StructSkipAllDenyUnknown {
105 #[serde(skip_deserializing)]
106 a: i32,
107 }
108
109 #[derive(Default, PartialEq, Debug)]
110 struct NotDeserializable;
111
112 #[derive(PartialEq, Debug, Deserialize)]
113 enum Enum {
114 #[allow(dead_code)]
115 #[serde(skip_deserializing)]
116 Skipped,
117 Unit,
118 Simple(i32),
119 Seq(i32, i32, i32),
120 Map {
121 a: i32,
122 b: i32,
123 c: i32,
124 },
125 SimpleWithSkipped(#[serde(skip_deserializing)] NotDeserializable),
126 }
127
128 #[derive(PartialEq, Debug, Deserialize)]
129 enum EnumOther {
130 Unit,
131 #[serde(other)]
132 Other,
133 }
134
135 #[derive(PartialEq, Debug)]
136 struct IgnoredAny;
137
138 impl<'de> Deserialize<'de> for IgnoredAny {
deserialize<D>(deserializer: D) -> Result<Self, D::Error> where D: Deserializer<'de>,139 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
140 where
141 D: Deserializer<'de>,
142 {
143 serde::de::IgnoredAny::deserialize(deserializer)?;
144 Ok(IgnoredAny)
145 }
146 }
147
148 //////////////////////////////////////////////////////////////////////////
149
150 #[track_caller]
test<'de, T>(value: T, tokens: &'de [Token]) where T: Deserialize<'de> + PartialEq + Debug,151 fn test<'de, T>(value: T, tokens: &'de [Token])
152 where
153 T: Deserialize<'de> + PartialEq + Debug,
154 {
155 // Test ser/de roundtripping
156 assert_de_tokens(&value, tokens);
157
158 // Test that the tokens are ignorable
159 assert_de_tokens_ignore(tokens);
160 }
161
162 #[derive(Debug)]
163 struct SkipPartialEq<T>(T);
164
165 impl<'de, T> Deserialize<'de> for SkipPartialEq<T>
166 where
167 T: Deserialize<'de>,
168 {
deserialize<D>(deserializer: D) -> Result<Self, D::Error> where D: Deserializer<'de>,169 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
170 where
171 D: Deserializer<'de>,
172 {
173 T::deserialize(deserializer).map(SkipPartialEq)
174 }
175 }
176
177 impl<T> PartialEq for SkipPartialEq<T> {
eq(&self, _other: &Self) -> bool178 fn eq(&self, _other: &Self) -> bool {
179 true
180 }
181 }
182
183 #[track_caller]
assert_de_tokens_ignore(ignorable_tokens: &[Token])184 fn assert_de_tokens_ignore(ignorable_tokens: &[Token]) {
185 #[derive(PartialEq, Debug, Deserialize)]
186 struct IgnoreBase {
187 a: i32,
188 }
189
190 // Embed the tokens to be ignored in the normal token
191 // stream for an IgnoreBase type
192 let concated_tokens: Vec<Token> = vec![
193 Token::Map { len: Some(2) },
194 Token::Str("a"),
195 Token::I32(1),
196 Token::Str("ignored"),
197 ]
198 .into_iter()
199 .chain(ignorable_tokens.iter().copied())
200 .chain(vec![Token::MapEnd].into_iter())
201 .collect();
202
203 let mut de = serde_test::Deserializer::new(&concated_tokens);
204 let base = IgnoreBase::deserialize(&mut de).unwrap();
205 assert_eq!(base, IgnoreBase { a: 1 });
206 }
207
208 //////////////////////////////////////////////////////////////////////////
209
210 #[test]
test_bool()211 fn test_bool() {
212 test(true, &[Token::Bool(true)]);
213 test(false, &[Token::Bool(false)]);
214 }
215
216 #[test]
test_i8()217 fn test_i8() {
218 let test = test::<i8>;
219
220 // from signed
221 test(-128, &[Token::I8(-128)]);
222 test(-128, &[Token::I16(-128)]);
223 test(-128, &[Token::I32(-128)]);
224 test(-128, &[Token::I64(-128)]);
225 test(127, &[Token::I8(127)]);
226 test(127, &[Token::I16(127)]);
227 test(127, &[Token::I32(127)]);
228 test(127, &[Token::I64(127)]);
229
230 // from unsigned
231 test(0, &[Token::U8(0)]);
232 test(0, &[Token::U16(0)]);
233 test(0, &[Token::U32(0)]);
234 test(0, &[Token::U64(0)]);
235 test(127, &[Token::U8(127)]);
236 test(127, &[Token::U16(127)]);
237 test(127, &[Token::U32(127)]);
238 test(127, &[Token::U64(127)]);
239 }
240
241 #[test]
test_i16()242 fn test_i16() {
243 let test = test::<i16>;
244
245 // from signed
246 test(-128, &[Token::I8(-128)]);
247 test(-32768, &[Token::I16(-32768)]);
248 test(-32768, &[Token::I32(-32768)]);
249 test(-32768, &[Token::I64(-32768)]);
250 test(127, &[Token::I8(127)]);
251 test(32767, &[Token::I16(32767)]);
252 test(32767, &[Token::I32(32767)]);
253 test(32767, &[Token::I64(32767)]);
254
255 // from unsigned
256 test(0, &[Token::U8(0)]);
257 test(0, &[Token::U16(0)]);
258 test(0, &[Token::U32(0)]);
259 test(0, &[Token::U64(0)]);
260 test(255, &[Token::U8(255)]);
261 test(32767, &[Token::U16(32767)]);
262 test(32767, &[Token::U32(32767)]);
263 test(32767, &[Token::U64(32767)]);
264 }
265
266 #[test]
test_i32()267 fn test_i32() {
268 let test = test::<i32>;
269
270 // from signed
271 test(-128, &[Token::I8(-128)]);
272 test(-32768, &[Token::I16(-32768)]);
273 test(-2147483648, &[Token::I32(-2147483648)]);
274 test(-2147483648, &[Token::I64(-2147483648)]);
275 test(127, &[Token::I8(127)]);
276 test(32767, &[Token::I16(32767)]);
277 test(2147483647, &[Token::I32(2147483647)]);
278 test(2147483647, &[Token::I64(2147483647)]);
279
280 // from unsigned
281 test(0, &[Token::U8(0)]);
282 test(0, &[Token::U16(0)]);
283 test(0, &[Token::U32(0)]);
284 test(0, &[Token::U64(0)]);
285 test(255, &[Token::U8(255)]);
286 test(65535, &[Token::U16(65535)]);
287 test(2147483647, &[Token::U32(2147483647)]);
288 test(2147483647, &[Token::U64(2147483647)]);
289 }
290
291 #[test]
test_i64()292 fn test_i64() {
293 let test = test::<i64>;
294
295 // from signed
296 test(-128, &[Token::I8(-128)]);
297 test(-32768, &[Token::I16(-32768)]);
298 test(-2147483648, &[Token::I32(-2147483648)]);
299 test(-9223372036854775808, &[Token::I64(-9223372036854775808)]);
300 test(127, &[Token::I8(127)]);
301 test(32767, &[Token::I16(32767)]);
302 test(2147483647, &[Token::I32(2147483647)]);
303 test(9223372036854775807, &[Token::I64(9223372036854775807)]);
304
305 // from unsigned
306 test(0, &[Token::U8(0)]);
307 test(0, &[Token::U16(0)]);
308 test(0, &[Token::U32(0)]);
309 test(0, &[Token::U64(0)]);
310 test(255, &[Token::U8(255)]);
311 test(65535, &[Token::U16(65535)]);
312 test(4294967295, &[Token::U32(4294967295)]);
313 test(9223372036854775807, &[Token::U64(9223372036854775807)]);
314 }
315
316 #[test]
test_i128()317 fn test_i128() {
318 let test = test::<i128>;
319
320 // from signed
321 test(-128, &[Token::I8(-128)]);
322 test(-32768, &[Token::I16(-32768)]);
323 test(-2147483648, &[Token::I32(-2147483648)]);
324 test(-9223372036854775808, &[Token::I64(-9223372036854775808)]);
325 test(127, &[Token::I8(127)]);
326 test(32767, &[Token::I16(32767)]);
327 test(2147483647, &[Token::I32(2147483647)]);
328 test(9223372036854775807, &[Token::I64(9223372036854775807)]);
329
330 // from unsigned
331 test(0, &[Token::U8(0)]);
332 test(0, &[Token::U16(0)]);
333 test(0, &[Token::U32(0)]);
334 test(0, &[Token::U64(0)]);
335 test(255, &[Token::U8(255)]);
336 test(65535, &[Token::U16(65535)]);
337 test(4294967295, &[Token::U32(4294967295)]);
338 test(18446744073709551615, &[Token::U64(18446744073709551615)]);
339 }
340
341 #[test]
test_isize()342 fn test_isize() {
343 let test = test::<isize>;
344
345 // from signed
346 test(-10, &[Token::I8(-10)]);
347 test(-10, &[Token::I16(-10)]);
348 test(-10, &[Token::I32(-10)]);
349 test(-10, &[Token::I64(-10)]);
350 test(10, &[Token::I8(10)]);
351 test(10, &[Token::I16(10)]);
352 test(10, &[Token::I32(10)]);
353 test(10, &[Token::I64(10)]);
354
355 // from unsigned
356 test(0, &[Token::U8(0)]);
357 test(0, &[Token::U16(0)]);
358 test(0, &[Token::U32(0)]);
359 test(0, &[Token::U64(0)]);
360 test(10, &[Token::U8(10)]);
361 test(10, &[Token::U16(10)]);
362 test(10, &[Token::U32(10)]);
363 test(10, &[Token::U64(10)]);
364 }
365
366 #[test]
test_u8()367 fn test_u8() {
368 let test = test::<u8>;
369
370 // from signed
371 test(0, &[Token::I8(0)]);
372 test(0, &[Token::I16(0)]);
373 test(0, &[Token::I32(0)]);
374 test(0, &[Token::I64(0)]);
375 test(127, &[Token::I8(127)]);
376 test(255, &[Token::I16(255)]);
377 test(255, &[Token::I32(255)]);
378 test(255, &[Token::I64(255)]);
379
380 // from unsigned
381 test(0, &[Token::U8(0)]);
382 test(0, &[Token::U16(0)]);
383 test(0, &[Token::U32(0)]);
384 test(0, &[Token::U64(0)]);
385 test(255, &[Token::U8(255)]);
386 test(255, &[Token::U16(255)]);
387 test(255, &[Token::U32(255)]);
388 test(255, &[Token::U64(255)]);
389 }
390
391 #[test]
test_u16()392 fn test_u16() {
393 let test = test::<u16>;
394
395 // from signed
396 test(0, &[Token::I8(0)]);
397 test(0, &[Token::I16(0)]);
398 test(0, &[Token::I32(0)]);
399 test(0, &[Token::I64(0)]);
400 test(127, &[Token::I8(127)]);
401 test(32767, &[Token::I16(32767)]);
402 test(65535, &[Token::I32(65535)]);
403 test(65535, &[Token::I64(65535)]);
404
405 // from unsigned
406 test(0, &[Token::U8(0)]);
407 test(0, &[Token::U16(0)]);
408 test(0, &[Token::U32(0)]);
409 test(0, &[Token::U64(0)]);
410 test(255, &[Token::U8(255)]);
411 test(65535, &[Token::U16(65535)]);
412 test(65535, &[Token::U32(65535)]);
413 test(65535, &[Token::U64(65535)]);
414 }
415
416 #[test]
test_u32()417 fn test_u32() {
418 let test = test::<u32>;
419
420 // from signed
421 test(0, &[Token::I8(0)]);
422 test(0, &[Token::I16(0)]);
423 test(0, &[Token::I32(0)]);
424 test(0, &[Token::I64(0)]);
425 test(127, &[Token::I8(127)]);
426 test(32767, &[Token::I16(32767)]);
427 test(2147483647, &[Token::I32(2147483647)]);
428 test(4294967295, &[Token::I64(4294967295)]);
429
430 // from unsigned
431 test(0, &[Token::U8(0)]);
432 test(0, &[Token::U16(0)]);
433 test(0, &[Token::U32(0)]);
434 test(0, &[Token::U64(0)]);
435 test(255, &[Token::U8(255)]);
436 test(65535, &[Token::U16(65535)]);
437 test(4294967295, &[Token::U32(4294967295)]);
438 test(4294967295, &[Token::U64(4294967295)]);
439 }
440
441 #[test]
test_u64()442 fn test_u64() {
443 let test = test::<u64>;
444
445 // from signed
446 test(0, &[Token::I8(0)]);
447 test(0, &[Token::I16(0)]);
448 test(0, &[Token::I32(0)]);
449 test(0, &[Token::I64(0)]);
450 test(127, &[Token::I8(127)]);
451 test(32767, &[Token::I16(32767)]);
452 test(2147483647, &[Token::I32(2147483647)]);
453 test(9223372036854775807, &[Token::I64(9223372036854775807)]);
454
455 // from unsigned
456 test(0, &[Token::U8(0)]);
457 test(0, &[Token::U16(0)]);
458 test(0, &[Token::U32(0)]);
459 test(0, &[Token::U64(0)]);
460 test(255, &[Token::U8(255)]);
461 test(65535, &[Token::U16(65535)]);
462 test(4294967295, &[Token::U32(4294967295)]);
463 test(18446744073709551615, &[Token::U64(18446744073709551615)]);
464 }
465
466 #[test]
test_u128()467 fn test_u128() {
468 let test = test::<u128>;
469
470 // from signed
471 test(0, &[Token::I8(0)]);
472 test(0, &[Token::I16(0)]);
473 test(0, &[Token::I32(0)]);
474 test(0, &[Token::I64(0)]);
475 test(127, &[Token::I8(127)]);
476 test(32767, &[Token::I16(32767)]);
477 test(2147483647, &[Token::I32(2147483647)]);
478 test(9223372036854775807, &[Token::I64(9223372036854775807)]);
479
480 // from unsigned
481 test(0, &[Token::U8(0)]);
482 test(0, &[Token::U16(0)]);
483 test(0, &[Token::U32(0)]);
484 test(0, &[Token::U64(0)]);
485 test(255, &[Token::U8(255)]);
486 test(65535, &[Token::U16(65535)]);
487 test(4294967295, &[Token::U32(4294967295)]);
488 test(18446744073709551615, &[Token::U64(18446744073709551615)]);
489 }
490
491 #[test]
test_usize()492 fn test_usize() {
493 let test = test::<usize>;
494
495 // from signed
496 test(0, &[Token::I8(0)]);
497 test(0, &[Token::I16(0)]);
498 test(0, &[Token::I32(0)]);
499 test(0, &[Token::I64(0)]);
500 test(10, &[Token::I8(10)]);
501 test(10, &[Token::I16(10)]);
502 test(10, &[Token::I32(10)]);
503 test(10, &[Token::I64(10)]);
504
505 // from unsigned
506 test(0, &[Token::U8(0)]);
507 test(0, &[Token::U16(0)]);
508 test(0, &[Token::U32(0)]);
509 test(0, &[Token::U64(0)]);
510 test(10, &[Token::U8(10)]);
511 test(10, &[Token::U16(10)]);
512 test(10, &[Token::U32(10)]);
513 test(10, &[Token::U64(10)]);
514 }
515
516 #[test]
test_nonzero_i8()517 fn test_nonzero_i8() {
518 let test = |value, tokens| test(NonZeroI8::new(value).unwrap(), tokens);
519
520 // from signed
521 test(-128, &[Token::I8(-128)]);
522 test(-128, &[Token::I16(-128)]);
523 test(-128, &[Token::I32(-128)]);
524 test(-128, &[Token::I64(-128)]);
525 test(127, &[Token::I8(127)]);
526 test(127, &[Token::I16(127)]);
527 test(127, &[Token::I32(127)]);
528 test(127, &[Token::I64(127)]);
529
530 // from unsigned
531 test(1, &[Token::U8(1)]);
532 test(1, &[Token::U16(1)]);
533 test(1, &[Token::U32(1)]);
534 test(1, &[Token::U64(1)]);
535 test(127, &[Token::U8(127)]);
536 test(127, &[Token::U16(127)]);
537 test(127, &[Token::U32(127)]);
538 test(127, &[Token::U64(127)]);
539 }
540
541 #[test]
test_nonzero_i16()542 fn test_nonzero_i16() {
543 let test = |value, tokens| test(NonZeroI16::new(value).unwrap(), tokens);
544
545 // from signed
546 test(-128, &[Token::I8(-128)]);
547 test(-32768, &[Token::I16(-32768)]);
548 test(-32768, &[Token::I32(-32768)]);
549 test(-32768, &[Token::I64(-32768)]);
550 test(127, &[Token::I8(127)]);
551 test(32767, &[Token::I16(32767)]);
552 test(32767, &[Token::I32(32767)]);
553 test(32767, &[Token::I64(32767)]);
554
555 // from unsigned
556 test(1, &[Token::U8(1)]);
557 test(1, &[Token::U16(1)]);
558 test(1, &[Token::U32(1)]);
559 test(1, &[Token::U64(1)]);
560 test(255, &[Token::U8(255)]);
561 test(32767, &[Token::U16(32767)]);
562 test(32767, &[Token::U32(32767)]);
563 test(32767, &[Token::U64(32767)]);
564 }
565
566 #[test]
test_nonzero_i32()567 fn test_nonzero_i32() {
568 let test = |value, tokens| test(NonZeroI32::new(value).unwrap(), tokens);
569
570 // from signed
571 test(-128, &[Token::I8(-128)]);
572 test(-32768, &[Token::I16(-32768)]);
573 test(-2147483648, &[Token::I32(-2147483648)]);
574 test(-2147483648, &[Token::I64(-2147483648)]);
575 test(127, &[Token::I8(127)]);
576 test(32767, &[Token::I16(32767)]);
577 test(2147483647, &[Token::I32(2147483647)]);
578 test(2147483647, &[Token::I64(2147483647)]);
579
580 // from unsigned
581 test(1, &[Token::U8(1)]);
582 test(1, &[Token::U16(1)]);
583 test(1, &[Token::U32(1)]);
584 test(1, &[Token::U64(1)]);
585 test(255, &[Token::U8(255)]);
586 test(65535, &[Token::U16(65535)]);
587 test(2147483647, &[Token::U32(2147483647)]);
588 test(2147483647, &[Token::U64(2147483647)]);
589 }
590
591 #[test]
test_nonzero_i64()592 fn test_nonzero_i64() {
593 let test = |value, tokens| test(NonZeroI64::new(value).unwrap(), tokens);
594
595 // from signed
596 test(-128, &[Token::I8(-128)]);
597 test(-32768, &[Token::I16(-32768)]);
598 test(-2147483648, &[Token::I32(-2147483648)]);
599 test(-9223372036854775808, &[Token::I64(-9223372036854775808)]);
600 test(127, &[Token::I8(127)]);
601 test(32767, &[Token::I16(32767)]);
602 test(2147483647, &[Token::I32(2147483647)]);
603 test(9223372036854775807, &[Token::I64(9223372036854775807)]);
604
605 // from unsigned
606 test(1, &[Token::U8(1)]);
607 test(1, &[Token::U16(1)]);
608 test(1, &[Token::U32(1)]);
609 test(1, &[Token::U64(1)]);
610 test(255, &[Token::U8(255)]);
611 test(65535, &[Token::U16(65535)]);
612 test(4294967295, &[Token::U32(4294967295)]);
613 test(9223372036854775807, &[Token::U64(9223372036854775807)]);
614 }
615
616 #[test]
test_nonzero_i128()617 fn test_nonzero_i128() {
618 let test = |value, tokens| test(NonZeroI128::new(value).unwrap(), tokens);
619
620 // from signed
621 test(-128, &[Token::I8(-128)]);
622 test(-32768, &[Token::I16(-32768)]);
623 test(-2147483648, &[Token::I32(-2147483648)]);
624 test(-9223372036854775808, &[Token::I64(-9223372036854775808)]);
625 test(127, &[Token::I8(127)]);
626 test(32767, &[Token::I16(32767)]);
627 test(2147483647, &[Token::I32(2147483647)]);
628 test(9223372036854775807, &[Token::I64(9223372036854775807)]);
629
630 // from unsigned
631 test(1, &[Token::U8(1)]);
632 test(1, &[Token::U16(1)]);
633 test(1, &[Token::U32(1)]);
634 test(1, &[Token::U64(1)]);
635 test(255, &[Token::U8(255)]);
636 test(65535, &[Token::U16(65535)]);
637 test(4294967295, &[Token::U32(4294967295)]);
638 test(18446744073709551615, &[Token::U64(18446744073709551615)]);
639 }
640
641 #[test]
test_nonzero_isize()642 fn test_nonzero_isize() {
643 let test = |value, tokens| test(NonZeroIsize::new(value).unwrap(), tokens);
644
645 // from signed
646 test(-10, &[Token::I8(-10)]);
647 test(-10, &[Token::I16(-10)]);
648 test(-10, &[Token::I32(-10)]);
649 test(-10, &[Token::I64(-10)]);
650 test(10, &[Token::I8(10)]);
651 test(10, &[Token::I16(10)]);
652 test(10, &[Token::I32(10)]);
653 test(10, &[Token::I64(10)]);
654
655 // from unsigned
656 test(1, &[Token::U8(1)]);
657 test(1, &[Token::U16(1)]);
658 test(1, &[Token::U32(1)]);
659 test(1, &[Token::U64(1)]);
660 test(10, &[Token::U8(10)]);
661 test(10, &[Token::U16(10)]);
662 test(10, &[Token::U32(10)]);
663 test(10, &[Token::U64(10)]);
664 }
665
666 #[test]
test_nonzero_u8()667 fn test_nonzero_u8() {
668 let test = |value, tokens| test(NonZeroU8::new(value).unwrap(), tokens);
669
670 // from signed
671 test(1, &[Token::I8(1)]);
672 test(1, &[Token::I16(1)]);
673 test(1, &[Token::I32(1)]);
674 test(1, &[Token::I64(1)]);
675 test(127, &[Token::I8(127)]);
676 test(255, &[Token::I16(255)]);
677 test(255, &[Token::I32(255)]);
678 test(255, &[Token::I64(255)]);
679
680 // from unsigned
681 test(1, &[Token::U8(1)]);
682 test(1, &[Token::U16(1)]);
683 test(1, &[Token::U32(1)]);
684 test(1, &[Token::U64(1)]);
685 test(255, &[Token::U8(255)]);
686 test(255, &[Token::U16(255)]);
687 test(255, &[Token::U32(255)]);
688 test(255, &[Token::U64(255)]);
689 }
690
691 #[test]
test_nonzero_u16()692 fn test_nonzero_u16() {
693 let test = |value, tokens| test(NonZeroU16::new(value).unwrap(), tokens);
694
695 // from signed
696 test(1, &[Token::I8(1)]);
697 test(1, &[Token::I16(1)]);
698 test(1, &[Token::I32(1)]);
699 test(1, &[Token::I64(1)]);
700 test(127, &[Token::I8(127)]);
701 test(32767, &[Token::I16(32767)]);
702 test(65535, &[Token::I32(65535)]);
703 test(65535, &[Token::I64(65535)]);
704
705 // from unsigned
706 test(1, &[Token::U8(1)]);
707 test(1, &[Token::U16(1)]);
708 test(1, &[Token::U32(1)]);
709 test(1, &[Token::U64(1)]);
710 test(255, &[Token::U8(255)]);
711 test(65535, &[Token::U16(65535)]);
712 test(65535, &[Token::U32(65535)]);
713 test(65535, &[Token::U64(65535)]);
714 }
715
716 #[test]
test_nonzero_u32()717 fn test_nonzero_u32() {
718 let test = |value, tokens| test(NonZeroU32::new(value).unwrap(), tokens);
719
720 // from signed
721 test(1, &[Token::I8(1)]);
722 test(1, &[Token::I16(1)]);
723 test(1, &[Token::I32(1)]);
724 test(1, &[Token::I64(1)]);
725 test(127, &[Token::I8(127)]);
726 test(32767, &[Token::I16(32767)]);
727 test(2147483647, &[Token::I32(2147483647)]);
728 test(4294967295, &[Token::I64(4294967295)]);
729
730 // from unsigned
731 test(1, &[Token::U8(1)]);
732 test(1, &[Token::U16(1)]);
733 test(1, &[Token::U32(1)]);
734 test(1, &[Token::U64(1)]);
735 test(255, &[Token::U8(255)]);
736 test(65535, &[Token::U16(65535)]);
737 test(4294967295, &[Token::U32(4294967295)]);
738 test(4294967295, &[Token::U64(4294967295)]);
739 }
740
741 #[test]
test_nonzero_u64()742 fn test_nonzero_u64() {
743 let test = |value, tokens| test(NonZeroU64::new(value).unwrap(), tokens);
744
745 // from signed
746 test(1, &[Token::I8(1)]);
747 test(1, &[Token::I16(1)]);
748 test(1, &[Token::I32(1)]);
749 test(1, &[Token::I64(1)]);
750 test(127, &[Token::I8(127)]);
751 test(32767, &[Token::I16(32767)]);
752 test(2147483647, &[Token::I32(2147483647)]);
753 test(9223372036854775807, &[Token::I64(9223372036854775807)]);
754
755 // from unsigned
756 test(1, &[Token::U8(1)]);
757 test(1, &[Token::U16(1)]);
758 test(1, &[Token::U32(1)]);
759 test(1, &[Token::U64(1)]);
760 test(255, &[Token::U8(255)]);
761 test(65535, &[Token::U16(65535)]);
762 test(4294967295, &[Token::U32(4294967295)]);
763 test(18446744073709551615, &[Token::U64(18446744073709551615)]);
764 }
765
766 #[test]
test_nonzero_u128()767 fn test_nonzero_u128() {
768 let test = |value, tokens| test(NonZeroU128::new(value).unwrap(), tokens);
769
770 // from signed
771 test(1, &[Token::I8(1)]);
772 test(1, &[Token::I16(1)]);
773 test(1, &[Token::I32(1)]);
774 test(1, &[Token::I64(1)]);
775 test(127, &[Token::I8(127)]);
776 test(32767, &[Token::I16(32767)]);
777 test(2147483647, &[Token::I32(2147483647)]);
778 test(9223372036854775807, &[Token::I64(9223372036854775807)]);
779
780 // from unsigned
781 test(1, &[Token::U8(1)]);
782 test(1, &[Token::U16(1)]);
783 test(1, &[Token::U32(1)]);
784 test(1, &[Token::U64(1)]);
785 test(255, &[Token::U8(255)]);
786 test(65535, &[Token::U16(65535)]);
787 test(4294967295, &[Token::U32(4294967295)]);
788 test(18446744073709551615, &[Token::U64(18446744073709551615)]);
789 }
790
791 #[test]
test_nonzero_usize()792 fn test_nonzero_usize() {
793 let test = |value, tokens| test(NonZeroUsize::new(value).unwrap(), tokens);
794
795 // from signed
796 test(1, &[Token::I8(1)]);
797 test(1, &[Token::I16(1)]);
798 test(1, &[Token::I32(1)]);
799 test(1, &[Token::I64(1)]);
800 test(10, &[Token::I8(10)]);
801 test(10, &[Token::I16(10)]);
802 test(10, &[Token::I32(10)]);
803 test(10, &[Token::I64(10)]);
804
805 // from unsigned
806 test(1, &[Token::U8(1)]);
807 test(1, &[Token::U16(1)]);
808 test(1, &[Token::U32(1)]);
809 test(1, &[Token::U64(1)]);
810 test(10, &[Token::U8(10)]);
811 test(10, &[Token::U16(10)]);
812 test(10, &[Token::U32(10)]);
813 test(10, &[Token::U64(10)]);
814 }
815
816 #[test]
test_f32()817 fn test_f32() {
818 let test = test::<f32>;
819
820 test(1.11, &[Token::F32(1.11)]);
821 test(1.11, &[Token::F64(1.11)]);
822 }
823
824 #[test]
test_f64()825 fn test_f64() {
826 let test = test::<f64>;
827
828 test(1.11f32 as f64, &[Token::F32(1.11)]);
829 test(1.11, &[Token::F64(1.11)]);
830 }
831
832 #[test]
test_char()833 fn test_char() {
834 test('a', &[Token::Char('a')]);
835 test('a', &[Token::Str("a")]);
836 test('a', &[Token::String("a")]);
837 }
838
839 #[test]
test_string()840 fn test_string() {
841 test("abc".to_owned(), &[Token::Str("abc")]);
842 test("abc".to_owned(), &[Token::String("abc")]);
843 test("a".to_owned(), &[Token::Char('a')]);
844 }
845
846 #[test]
test_option()847 fn test_option() {
848 test(None::<i32>, &[Token::Unit]);
849 test(None::<i32>, &[Token::None]);
850 test(Some(1), &[Token::Some, Token::I32(1)]);
851 }
852
853 #[test]
test_result()854 fn test_result() {
855 test(
856 Ok::<i32, i32>(0),
857 &[
858 Token::Enum { name: "Result" },
859 Token::Str("Ok"),
860 Token::I32(0),
861 ],
862 );
863 test(
864 Err::<i32, i32>(1),
865 &[
866 Token::Enum { name: "Result" },
867 Token::Str("Err"),
868 Token::I32(1),
869 ],
870 );
871 }
872
873 #[test]
test_unit()874 fn test_unit() {
875 test((), &[Token::Unit]);
876 }
877
878 #[test]
test_unit_struct()879 fn test_unit_struct() {
880 test(UnitStruct, &[Token::Unit]);
881 test(UnitStruct, &[Token::UnitStruct { name: "UnitStruct" }]);
882 }
883
884 #[test]
test_newtype_struct()885 fn test_newtype_struct() {
886 test(
887 NewtypeStruct(1),
888 &[
889 Token::NewtypeStruct {
890 name: "NewtypeStruct",
891 },
892 Token::I32(1),
893 ],
894 );
895 }
896
897 #[test]
test_tuple_struct()898 fn test_tuple_struct() {
899 test(
900 TupleStruct(1, 2, 3),
901 &[
902 Token::Seq { len: Some(3) },
903 Token::I32(1),
904 Token::I32(2),
905 Token::I32(3),
906 Token::SeqEnd,
907 ],
908 );
909 test(
910 TupleStruct(1, 2, 3),
911 &[
912 Token::Seq { len: None },
913 Token::I32(1),
914 Token::I32(2),
915 Token::I32(3),
916 Token::SeqEnd,
917 ],
918 );
919 test(
920 TupleStruct(1, 2, 3),
921 &[
922 Token::TupleStruct {
923 name: "TupleStruct",
924 len: 3,
925 },
926 Token::I32(1),
927 Token::I32(2),
928 Token::I32(3),
929 Token::TupleStructEnd,
930 ],
931 );
932 test(
933 TupleStruct(1, 2, 3),
934 &[
935 Token::TupleStruct {
936 name: "TupleStruct",
937 len: 3,
938 },
939 Token::I32(1),
940 Token::I32(2),
941 Token::I32(3),
942 Token::TupleStructEnd,
943 ],
944 );
945 }
946
947 #[test]
test_btreeset()948 fn test_btreeset() {
949 test(
950 BTreeSet::<isize>::new(),
951 &[Token::Seq { len: Some(0) }, Token::SeqEnd],
952 );
953 test(
954 btreeset![btreeset![], btreeset![1], btreeset![2, 3]],
955 &[
956 Token::Seq { len: Some(3) },
957 Token::Seq { len: Some(0) },
958 Token::SeqEnd,
959 Token::Seq { len: Some(1) },
960 Token::I32(1),
961 Token::SeqEnd,
962 Token::Seq { len: Some(2) },
963 Token::I32(2),
964 Token::I32(3),
965 Token::SeqEnd,
966 Token::SeqEnd,
967 ],
968 );
969 test(
970 BTreeSet::<isize>::new(),
971 &[
972 Token::TupleStruct {
973 name: "Anything",
974 len: 0,
975 },
976 Token::TupleStructEnd,
977 ],
978 );
979 }
980
981 #[test]
test_hashset()982 fn test_hashset() {
983 test(
984 HashSet::<isize>::new(),
985 &[Token::Seq { len: Some(0) }, Token::SeqEnd],
986 );
987 test(
988 hashset![1, 2, 3],
989 &[
990 Token::Seq { len: Some(3) },
991 Token::I32(1),
992 Token::I32(2),
993 Token::I32(3),
994 Token::SeqEnd,
995 ],
996 );
997 test(
998 HashSet::<isize>::new(),
999 &[
1000 Token::TupleStruct {
1001 name: "Anything",
1002 len: 0,
1003 },
1004 Token::TupleStructEnd,
1005 ],
1006 );
1007 test(
1008 hashset![FnvHasher @ 1, 2, 3],
1009 &[
1010 Token::Seq { len: Some(3) },
1011 Token::I32(1),
1012 Token::I32(2),
1013 Token::I32(3),
1014 Token::SeqEnd,
1015 ],
1016 );
1017 }
1018
1019 #[test]
test_vec()1020 fn test_vec() {
1021 test(
1022 Vec::<isize>::new(),
1023 &[Token::Seq { len: Some(0) }, Token::SeqEnd],
1024 );
1025
1026 test(
1027 vec![vec![], vec![1], vec![2, 3]],
1028 &[
1029 Token::Seq { len: Some(3) },
1030 Token::Seq { len: Some(0) },
1031 Token::SeqEnd,
1032 Token::Seq { len: Some(1) },
1033 Token::I32(1),
1034 Token::SeqEnd,
1035 Token::Seq { len: Some(2) },
1036 Token::I32(2),
1037 Token::I32(3),
1038 Token::SeqEnd,
1039 Token::SeqEnd,
1040 ],
1041 );
1042 test(
1043 Vec::<isize>::new(),
1044 &[
1045 Token::TupleStruct {
1046 name: "Anything",
1047 len: 0,
1048 },
1049 Token::TupleStructEnd,
1050 ],
1051 );
1052 }
1053
1054 #[test]
test_array()1055 fn test_array() {
1056 test([0; 0], &[Token::Seq { len: Some(0) }, Token::SeqEnd]);
1057 test([0; 0], &[Token::Tuple { len: 0 }, Token::TupleEnd]);
1058 test(
1059 ([0; 0], [1], [2, 3]),
1060 &[
1061 Token::Seq { len: Some(3) },
1062 Token::Seq { len: Some(0) },
1063 Token::SeqEnd,
1064 Token::Seq { len: Some(1) },
1065 Token::I32(1),
1066 Token::SeqEnd,
1067 Token::Seq { len: Some(2) },
1068 Token::I32(2),
1069 Token::I32(3),
1070 Token::SeqEnd,
1071 Token::SeqEnd,
1072 ],
1073 );
1074 test(
1075 ([0; 0], [1], [2, 3]),
1076 &[
1077 Token::Tuple { len: 3 },
1078 Token::Tuple { len: 0 },
1079 Token::TupleEnd,
1080 Token::Tuple { len: 1 },
1081 Token::I32(1),
1082 Token::TupleEnd,
1083 Token::Tuple { len: 2 },
1084 Token::I32(2),
1085 Token::I32(3),
1086 Token::TupleEnd,
1087 Token::TupleEnd,
1088 ],
1089 );
1090 test(
1091 [0; 0],
1092 &[
1093 Token::TupleStruct {
1094 name: "Anything",
1095 len: 0,
1096 },
1097 Token::TupleStructEnd,
1098 ],
1099 );
1100 }
1101
1102 #[test]
test_tuple()1103 fn test_tuple() {
1104 test(
1105 (1,),
1106 &[Token::Seq { len: Some(1) }, Token::I32(1), Token::SeqEnd],
1107 );
1108 test(
1109 (1, 2, 3),
1110 &[
1111 Token::Seq { len: Some(3) },
1112 Token::I32(1),
1113 Token::I32(2),
1114 Token::I32(3),
1115 Token::SeqEnd,
1116 ],
1117 );
1118 test(
1119 (1,),
1120 &[Token::Tuple { len: 1 }, Token::I32(1), Token::TupleEnd],
1121 );
1122 test(
1123 (1, 2, 3),
1124 &[
1125 Token::Tuple { len: 3 },
1126 Token::I32(1),
1127 Token::I32(2),
1128 Token::I32(3),
1129 Token::TupleEnd,
1130 ],
1131 );
1132 }
1133
1134 #[test]
test_btreemap()1135 fn test_btreemap() {
1136 test(
1137 BTreeMap::<isize, isize>::new(),
1138 &[Token::Map { len: Some(0) }, Token::MapEnd],
1139 );
1140 test(
1141 btreemap![1 => 2],
1142 &[
1143 Token::Map { len: Some(1) },
1144 Token::I32(1),
1145 Token::I32(2),
1146 Token::MapEnd,
1147 ],
1148 );
1149 test(
1150 btreemap![1 => 2, 3 => 4],
1151 &[
1152 Token::Map { len: Some(2) },
1153 Token::I32(1),
1154 Token::I32(2),
1155 Token::I32(3),
1156 Token::I32(4),
1157 Token::MapEnd,
1158 ],
1159 );
1160 test(
1161 btreemap![1 => btreemap![], 2 => btreemap![3 => 4, 5 => 6]],
1162 &[
1163 Token::Map { len: Some(2) },
1164 Token::I32(1),
1165 Token::Map { len: Some(0) },
1166 Token::MapEnd,
1167 Token::I32(2),
1168 Token::Map { len: Some(2) },
1169 Token::I32(3),
1170 Token::I32(4),
1171 Token::I32(5),
1172 Token::I32(6),
1173 Token::MapEnd,
1174 Token::MapEnd,
1175 ],
1176 );
1177 test(
1178 BTreeMap::<isize, isize>::new(),
1179 &[
1180 Token::Struct {
1181 name: "Anything",
1182 len: 0,
1183 },
1184 Token::StructEnd,
1185 ],
1186 );
1187 }
1188
1189 #[test]
test_hashmap()1190 fn test_hashmap() {
1191 test(
1192 HashMap::<isize, isize>::new(),
1193 &[Token::Map { len: Some(0) }, Token::MapEnd],
1194 );
1195 test(
1196 hashmap![1 => 2],
1197 &[
1198 Token::Map { len: Some(1) },
1199 Token::I32(1),
1200 Token::I32(2),
1201 Token::MapEnd,
1202 ],
1203 );
1204 test(
1205 hashmap![1 => 2, 3 => 4],
1206 &[
1207 Token::Map { len: Some(2) },
1208 Token::I32(1),
1209 Token::I32(2),
1210 Token::I32(3),
1211 Token::I32(4),
1212 Token::MapEnd,
1213 ],
1214 );
1215 test(
1216 hashmap![1 => hashmap![], 2 => hashmap![3 => 4, 5 => 6]],
1217 &[
1218 Token::Map { len: Some(2) },
1219 Token::I32(1),
1220 Token::Map { len: Some(0) },
1221 Token::MapEnd,
1222 Token::I32(2),
1223 Token::Map { len: Some(2) },
1224 Token::I32(3),
1225 Token::I32(4),
1226 Token::I32(5),
1227 Token::I32(6),
1228 Token::MapEnd,
1229 Token::MapEnd,
1230 ],
1231 );
1232 test(
1233 HashMap::<isize, isize>::new(),
1234 &[
1235 Token::Struct {
1236 name: "Anything",
1237 len: 0,
1238 },
1239 Token::StructEnd,
1240 ],
1241 );
1242 test(
1243 hashmap![FnvHasher @ 1 => 2, 3 => 4],
1244 &[
1245 Token::Map { len: Some(2) },
1246 Token::I32(1),
1247 Token::I32(2),
1248 Token::I32(3),
1249 Token::I32(4),
1250 Token::MapEnd,
1251 ],
1252 );
1253 }
1254
1255 #[test]
test_struct()1256 fn test_struct() {
1257 test(
1258 Struct { a: 1, b: 2, c: 0 },
1259 &[
1260 Token::Map { len: Some(3) },
1261 Token::Str("a"),
1262 Token::I32(1),
1263 Token::Str("b"),
1264 Token::I32(2),
1265 Token::MapEnd,
1266 ],
1267 );
1268 test(
1269 Struct { a: 1, b: 2, c: 0 },
1270 &[
1271 Token::Map { len: Some(3) },
1272 Token::U8(0),
1273 Token::I32(1),
1274 Token::U8(1),
1275 Token::I32(2),
1276 Token::MapEnd,
1277 ],
1278 );
1279 test(
1280 Struct { a: 1, b: 2, c: 0 },
1281 &[
1282 Token::Map { len: Some(3) },
1283 Token::U16(0),
1284 Token::I32(1),
1285 Token::U16(1),
1286 Token::I32(2),
1287 Token::MapEnd,
1288 ],
1289 );
1290 test(
1291 Struct { a: 1, b: 2, c: 0 },
1292 &[
1293 Token::Map { len: Some(3) },
1294 Token::U32(0),
1295 Token::I32(1),
1296 Token::U32(1),
1297 Token::I32(2),
1298 Token::MapEnd,
1299 ],
1300 );
1301 test(
1302 Struct { a: 1, b: 2, c: 0 },
1303 &[
1304 Token::Map { len: Some(3) },
1305 Token::U64(0),
1306 Token::I32(1),
1307 Token::U64(1),
1308 Token::I32(2),
1309 Token::MapEnd,
1310 ],
1311 );
1312 // Mixed key types
1313 test(
1314 Struct { a: 1, b: 2, c: 0 },
1315 &[
1316 Token::Map { len: Some(3) },
1317 Token::U8(0),
1318 Token::I32(1),
1319 Token::U64(1),
1320 Token::I32(2),
1321 Token::MapEnd,
1322 ],
1323 );
1324 test(
1325 Struct { a: 1, b: 2, c: 0 },
1326 &[
1327 Token::Map { len: Some(3) },
1328 Token::U8(0),
1329 Token::I32(1),
1330 Token::Str("b"),
1331 Token::I32(2),
1332 Token::MapEnd,
1333 ],
1334 );
1335 test(
1336 Struct { a: 1, b: 2, c: 0 },
1337 &[
1338 Token::Struct {
1339 name: "Struct",
1340 len: 2,
1341 },
1342 Token::Str("a"),
1343 Token::I32(1),
1344 Token::Str("b"),
1345 Token::I32(2),
1346 Token::StructEnd,
1347 ],
1348 );
1349 test(
1350 Struct { a: 1, b: 2, c: 0 },
1351 &[
1352 Token::Seq { len: Some(3) },
1353 Token::I32(1),
1354 Token::I32(2),
1355 Token::SeqEnd,
1356 ],
1357 );
1358 }
1359
1360 #[test]
test_struct_borrowed_keys()1361 fn test_struct_borrowed_keys() {
1362 test(
1363 Struct { a: 1, b: 2, c: 0 },
1364 &[
1365 Token::Map { len: Some(3) },
1366 Token::BorrowedStr("a"),
1367 Token::I32(1),
1368 Token::BorrowedStr("b"),
1369 Token::I32(2),
1370 Token::MapEnd,
1371 ],
1372 );
1373 test(
1374 Struct { a: 1, b: 2, c: 0 },
1375 &[
1376 Token::Struct {
1377 name: "Struct",
1378 len: 2,
1379 },
1380 Token::BorrowedStr("a"),
1381 Token::I32(1),
1382 Token::BorrowedStr("b"),
1383 Token::I32(2),
1384 Token::StructEnd,
1385 ],
1386 );
1387 }
1388
1389 #[test]
test_struct_owned_keys()1390 fn test_struct_owned_keys() {
1391 test(
1392 Struct { a: 1, b: 2, c: 0 },
1393 &[
1394 Token::Map { len: Some(3) },
1395 Token::String("a"),
1396 Token::I32(1),
1397 Token::String("b"),
1398 Token::I32(2),
1399 Token::MapEnd,
1400 ],
1401 );
1402 test(
1403 Struct { a: 1, b: 2, c: 0 },
1404 &[
1405 Token::Struct {
1406 name: "Struct",
1407 len: 2,
1408 },
1409 Token::String("a"),
1410 Token::I32(1),
1411 Token::String("b"),
1412 Token::I32(2),
1413 Token::StructEnd,
1414 ],
1415 );
1416 }
1417
1418 #[test]
test_struct_with_skip()1419 fn test_struct_with_skip() {
1420 test(
1421 Struct { a: 1, b: 2, c: 0 },
1422 &[
1423 Token::Map { len: Some(3) },
1424 Token::Str("a"),
1425 Token::I32(1),
1426 Token::Str("b"),
1427 Token::I32(2),
1428 Token::Str("c"),
1429 Token::I32(3),
1430 Token::Str("d"),
1431 Token::I32(4),
1432 Token::MapEnd,
1433 ],
1434 );
1435 test(
1436 Struct { a: 1, b: 2, c: 0 },
1437 &[
1438 Token::Map { len: Some(3) },
1439 Token::U8(0),
1440 Token::I32(1),
1441 Token::U16(1),
1442 Token::I32(2),
1443 Token::U32(2),
1444 Token::I32(3),
1445 Token::U64(3),
1446 Token::I32(4),
1447 Token::MapEnd,
1448 ],
1449 );
1450 test(
1451 Struct { a: 1, b: 2, c: 0 },
1452 &[
1453 Token::Struct {
1454 name: "Struct",
1455 len: 2,
1456 },
1457 Token::Str("a"),
1458 Token::I32(1),
1459 Token::Str("b"),
1460 Token::I32(2),
1461 Token::Str("c"),
1462 Token::I32(3),
1463 Token::Str("d"),
1464 Token::I32(4),
1465 Token::StructEnd,
1466 ],
1467 );
1468 }
1469
1470 #[test]
test_struct_skip_all()1471 fn test_struct_skip_all() {
1472 test(
1473 StructSkipAll { a: 0 },
1474 &[
1475 Token::Struct {
1476 name: "StructSkipAll",
1477 len: 0,
1478 },
1479 Token::StructEnd,
1480 ],
1481 );
1482 test(
1483 StructSkipAll { a: 0 },
1484 &[
1485 Token::Struct {
1486 name: "StructSkipAll",
1487 len: 0,
1488 },
1489 Token::Str("a"),
1490 Token::I32(1),
1491 Token::Str("b"),
1492 Token::I32(2),
1493 Token::StructEnd,
1494 ],
1495 );
1496 }
1497
1498 #[test]
test_struct_skip_default()1499 fn test_struct_skip_default() {
1500 test(
1501 StructSkipDefault { a: 16 },
1502 &[
1503 Token::Struct {
1504 name: "StructSkipDefault",
1505 len: 0,
1506 },
1507 Token::StructEnd,
1508 ],
1509 );
1510 }
1511
1512 #[test]
test_struct_skip_all_deny_unknown()1513 fn test_struct_skip_all_deny_unknown() {
1514 test(
1515 StructSkipAllDenyUnknown { a: 0 },
1516 &[
1517 Token::Struct {
1518 name: "StructSkipAllDenyUnknown",
1519 len: 0,
1520 },
1521 Token::StructEnd,
1522 ],
1523 );
1524 }
1525
1526 #[test]
test_struct_default()1527 fn test_struct_default() {
1528 test(
1529 StructDefault {
1530 a: 50,
1531 b: "overwritten".to_string(),
1532 },
1533 &[
1534 Token::Struct {
1535 name: "StructDefault",
1536 len: 2,
1537 },
1538 Token::Str("a"),
1539 Token::I32(50),
1540 Token::Str("b"),
1541 Token::String("overwritten"),
1542 Token::StructEnd,
1543 ],
1544 );
1545 test(
1546 StructDefault {
1547 a: 100,
1548 b: "default".to_string(),
1549 },
1550 &[
1551 Token::Struct {
1552 name: "StructDefault",
1553 len: 2,
1554 },
1555 Token::StructEnd,
1556 ],
1557 );
1558 }
1559
1560 #[test]
test_enum_unit()1561 fn test_enum_unit() {
1562 test(
1563 Enum::Unit,
1564 &[Token::UnitVariant {
1565 name: "Enum",
1566 variant: "Unit",
1567 }],
1568 );
1569 }
1570
1571 #[test]
test_enum_simple()1572 fn test_enum_simple() {
1573 test(
1574 Enum::Simple(1),
1575 &[
1576 Token::NewtypeVariant {
1577 name: "Enum",
1578 variant: "Simple",
1579 },
1580 Token::I32(1),
1581 ],
1582 );
1583 }
1584
1585 #[test]
test_enum_simple_with_skipped()1586 fn test_enum_simple_with_skipped() {
1587 test(
1588 Enum::SimpleWithSkipped(NotDeserializable),
1589 &[Token::UnitVariant {
1590 name: "Enum",
1591 variant: "SimpleWithSkipped",
1592 }],
1593 );
1594 }
1595
1596 #[test]
test_enum_seq()1597 fn test_enum_seq() {
1598 test(
1599 Enum::Seq(1, 2, 3),
1600 &[
1601 Token::TupleVariant {
1602 name: "Enum",
1603 variant: "Seq",
1604 len: 3,
1605 },
1606 Token::I32(1),
1607 Token::I32(2),
1608 Token::I32(3),
1609 Token::TupleVariantEnd,
1610 ],
1611 );
1612 }
1613
1614 #[test]
test_enum_map()1615 fn test_enum_map() {
1616 test(
1617 Enum::Map { a: 1, b: 2, c: 3 },
1618 &[
1619 Token::StructVariant {
1620 name: "Enum",
1621 variant: "Map",
1622 len: 3,
1623 },
1624 Token::Str("a"),
1625 Token::I32(1),
1626 Token::Str("b"),
1627 Token::I32(2),
1628 Token::Str("c"),
1629 Token::I32(3),
1630 Token::StructVariantEnd,
1631 ],
1632 );
1633 }
1634
1635 #[test]
test_enum_unit_usize()1636 fn test_enum_unit_usize() {
1637 test(
1638 Enum::Unit,
1639 &[Token::Enum { name: "Enum" }, Token::U32(0), Token::Unit],
1640 );
1641 }
1642
1643 #[test]
test_enum_unit_bytes()1644 fn test_enum_unit_bytes() {
1645 test(
1646 Enum::Unit,
1647 &[
1648 Token::Enum { name: "Enum" },
1649 Token::Bytes(b"Unit"),
1650 Token::Unit,
1651 ],
1652 );
1653 }
1654
1655 #[test]
test_enum_other_unit()1656 fn test_enum_other_unit() {
1657 test(
1658 EnumOther::Unit,
1659 &[
1660 Token::Enum { name: "EnumOther" },
1661 Token::Str("Unit"),
1662 Token::Unit,
1663 ],
1664 );
1665 test(
1666 EnumOther::Unit,
1667 &[Token::Enum { name: "EnumOther" }, Token::U8(0), Token::Unit],
1668 );
1669 test(
1670 EnumOther::Unit,
1671 &[
1672 Token::Enum { name: "EnumOther" },
1673 Token::U16(0),
1674 Token::Unit,
1675 ],
1676 );
1677 test(
1678 EnumOther::Unit,
1679 &[
1680 Token::Enum { name: "EnumOther" },
1681 Token::U32(0),
1682 Token::Unit,
1683 ],
1684 );
1685 test(
1686 EnumOther::Unit,
1687 &[
1688 Token::Enum { name: "EnumOther" },
1689 Token::U64(0),
1690 Token::Unit,
1691 ],
1692 );
1693 }
1694
1695 #[test]
test_enum_other()1696 fn test_enum_other() {
1697 test(
1698 EnumOther::Other,
1699 &[
1700 Token::Enum { name: "EnumOther" },
1701 Token::Str("Foo"),
1702 Token::Unit,
1703 ],
1704 );
1705 test(
1706 EnumOther::Other,
1707 &[
1708 Token::Enum { name: "EnumOther" },
1709 Token::U8(42),
1710 Token::Unit,
1711 ],
1712 );
1713 test(
1714 EnumOther::Other,
1715 &[
1716 Token::Enum { name: "EnumOther" },
1717 Token::U16(42),
1718 Token::Unit,
1719 ],
1720 );
1721 test(
1722 EnumOther::Other,
1723 &[
1724 Token::Enum { name: "EnumOther" },
1725 Token::U32(42),
1726 Token::Unit,
1727 ],
1728 );
1729 test(
1730 EnumOther::Other,
1731 &[
1732 Token::Enum { name: "EnumOther" },
1733 Token::U64(42),
1734 Token::Unit,
1735 ],
1736 );
1737 }
1738
1739 #[test]
test_box()1740 fn test_box() {
1741 test(Box::new(0i32), &[Token::I32(0)]);
1742 }
1743
1744 #[test]
test_boxed_slice()1745 fn test_boxed_slice() {
1746 test(
1747 Box::new([0, 1, 2]),
1748 &[
1749 Token::Seq { len: Some(3) },
1750 Token::I32(0),
1751 Token::I32(1),
1752 Token::I32(2),
1753 Token::SeqEnd,
1754 ],
1755 );
1756 }
1757
1758 #[test]
test_duration()1759 fn test_duration() {
1760 test(
1761 Duration::new(1, 2),
1762 &[
1763 Token::Struct {
1764 name: "Duration",
1765 len: 2,
1766 },
1767 Token::Str("secs"),
1768 Token::U64(1),
1769 Token::Str("nanos"),
1770 Token::U32(2),
1771 Token::StructEnd,
1772 ],
1773 );
1774 test(
1775 Duration::new(1, 2),
1776 &[
1777 Token::Seq { len: Some(2) },
1778 Token::I64(1),
1779 Token::I64(2),
1780 Token::SeqEnd,
1781 ],
1782 );
1783 }
1784
1785 #[test]
test_system_time()1786 fn test_system_time() {
1787 test(
1788 UNIX_EPOCH + Duration::new(1, 2),
1789 &[
1790 Token::Struct {
1791 name: "SystemTime",
1792 len: 2,
1793 },
1794 Token::Str("secs_since_epoch"),
1795 Token::U64(1),
1796 Token::Str("nanos_since_epoch"),
1797 Token::U32(2),
1798 Token::StructEnd,
1799 ],
1800 );
1801 test(
1802 UNIX_EPOCH + Duration::new(1, 2),
1803 &[
1804 Token::Seq { len: Some(2) },
1805 Token::I64(1),
1806 Token::I64(2),
1807 Token::SeqEnd,
1808 ],
1809 );
1810 }
1811
1812 #[test]
test_range()1813 fn test_range() {
1814 test(
1815 1u32..2u32,
1816 &[
1817 Token::Struct {
1818 name: "Range",
1819 len: 2,
1820 },
1821 Token::Str("start"),
1822 Token::U32(1),
1823 Token::Str("end"),
1824 Token::U32(2),
1825 Token::StructEnd,
1826 ],
1827 );
1828 test(
1829 1u32..2u32,
1830 &[
1831 Token::Seq { len: Some(2) },
1832 Token::U64(1),
1833 Token::U64(2),
1834 Token::SeqEnd,
1835 ],
1836 );
1837 }
1838
1839 #[test]
test_range_inclusive()1840 fn test_range_inclusive() {
1841 test(
1842 1u32..=2u32,
1843 &[
1844 Token::Struct {
1845 name: "RangeInclusive",
1846 len: 2,
1847 },
1848 Token::Str("start"),
1849 Token::U32(1),
1850 Token::Str("end"),
1851 Token::U32(2),
1852 Token::StructEnd,
1853 ],
1854 );
1855 test(
1856 1u32..=2u32,
1857 &[
1858 Token::Seq { len: Some(2) },
1859 Token::U64(1),
1860 Token::U64(2),
1861 Token::SeqEnd,
1862 ],
1863 );
1864 }
1865
1866 #[test]
test_bound()1867 fn test_bound() {
1868 test(
1869 Bound::Unbounded::<()>,
1870 &[
1871 Token::Enum { name: "Bound" },
1872 Token::Str("Unbounded"),
1873 Token::Unit,
1874 ],
1875 );
1876 test(
1877 Bound::Included(0),
1878 &[
1879 Token::Enum { name: "Bound" },
1880 Token::Str("Included"),
1881 Token::U8(0),
1882 ],
1883 );
1884 test(
1885 Bound::Excluded(0),
1886 &[
1887 Token::Enum { name: "Bound" },
1888 Token::Str("Excluded"),
1889 Token::U8(0),
1890 ],
1891 );
1892 }
1893
1894 #[test]
test_path()1895 fn test_path() {
1896 test(
1897 Path::new("/usr/local/lib"),
1898 &[Token::BorrowedStr("/usr/local/lib")],
1899 );
1900 test(
1901 Path::new("/usr/local/lib"),
1902 &[Token::BorrowedBytes(b"/usr/local/lib")],
1903 );
1904 }
1905
1906 #[test]
test_path_buf()1907 fn test_path_buf() {
1908 test(
1909 PathBuf::from("/usr/local/lib"),
1910 &[Token::Str("/usr/local/lib")],
1911 );
1912 test(
1913 PathBuf::from("/usr/local/lib"),
1914 &[Token::String("/usr/local/lib")],
1915 );
1916 test(
1917 PathBuf::from("/usr/local/lib"),
1918 &[Token::Bytes(b"/usr/local/lib")],
1919 );
1920 test(
1921 PathBuf::from("/usr/local/lib"),
1922 &[Token::ByteBuf(b"/usr/local/lib")],
1923 );
1924 }
1925
1926 #[test]
test_boxed_path()1927 fn test_boxed_path() {
1928 test(
1929 PathBuf::from("/usr/local/lib").into_boxed_path(),
1930 &[Token::Str("/usr/local/lib")],
1931 );
1932 test(
1933 PathBuf::from("/usr/local/lib").into_boxed_path(),
1934 &[Token::String("/usr/local/lib")],
1935 );
1936 test(
1937 PathBuf::from("/usr/local/lib").into_boxed_path(),
1938 &[Token::Bytes(b"/usr/local/lib")],
1939 );
1940 test(
1941 PathBuf::from("/usr/local/lib").into_boxed_path(),
1942 &[Token::ByteBuf(b"/usr/local/lib")],
1943 );
1944 }
1945
1946 #[test]
test_cstring()1947 fn test_cstring() {
1948 test(CString::new("abc").unwrap(), &[Token::Bytes(b"abc")]);
1949 }
1950
1951 #[test]
test_rc()1952 fn test_rc() {
1953 test(Rc::new(true), &[Token::Bool(true)]);
1954 }
1955
1956 #[test]
test_rc_weak_some()1957 fn test_rc_weak_some() {
1958 test(
1959 SkipPartialEq(RcWeak::<bool>::new()),
1960 &[Token::Some, Token::Bool(true)],
1961 );
1962 }
1963
1964 #[test]
test_rc_weak_none()1965 fn test_rc_weak_none() {
1966 test(SkipPartialEq(RcWeak::<bool>::new()), &[Token::None]);
1967 }
1968
1969 #[test]
test_arc()1970 fn test_arc() {
1971 test(Arc::new(true), &[Token::Bool(true)]);
1972 }
1973
1974 #[test]
test_arc_weak_some()1975 fn test_arc_weak_some() {
1976 test(
1977 SkipPartialEq(ArcWeak::<bool>::new()),
1978 &[Token::Some, Token::Bool(true)],
1979 );
1980 }
1981
1982 #[test]
test_arc_weak_none()1983 fn test_arc_weak_none() {
1984 test(SkipPartialEq(ArcWeak::<bool>::new()), &[Token::None]);
1985 }
1986
1987 #[test]
test_wrapping()1988 fn test_wrapping() {
1989 test(Wrapping(1usize), &[Token::U32(1)]);
1990 test(Wrapping(1usize), &[Token::U64(1)]);
1991 }
1992
1993 #[test]
test_rc_dst()1994 fn test_rc_dst() {
1995 test(Rc::<str>::from("s"), &[Token::Str("s")]);
1996 test(
1997 Rc::<[bool]>::from(&[true][..]),
1998 &[
1999 Token::Seq { len: Some(1) },
2000 Token::Bool(true),
2001 Token::SeqEnd,
2002 ],
2003 );
2004 }
2005
2006 #[test]
test_arc_dst()2007 fn test_arc_dst() {
2008 test(Arc::<str>::from("s"), &[Token::Str("s")]);
2009 test(
2010 Arc::<[bool]>::from(&[true][..]),
2011 &[
2012 Token::Seq { len: Some(1) },
2013 Token::Bool(true),
2014 Token::SeqEnd,
2015 ],
2016 );
2017 }
2018
2019 #[test]
test_ignored_any()2020 fn test_ignored_any() {
2021 test(IgnoredAny, &[Token::Str("s")]);
2022 test(
2023 IgnoredAny,
2024 &[
2025 Token::Seq { len: Some(1) },
2026 Token::Bool(true),
2027 Token::SeqEnd,
2028 ],
2029 );
2030 test(
2031 IgnoredAny,
2032 &[Token::Enum { name: "E" }, Token::Str("Rust"), Token::Unit],
2033 );
2034 }
2035
2036 #[test]
test_net_ipv4addr_readable()2037 fn test_net_ipv4addr_readable() {
2038 test(
2039 "1.2.3.4".parse::<net::Ipv4Addr>().unwrap().readable(),
2040 &[Token::Str("1.2.3.4")],
2041 );
2042 }
2043
2044 #[test]
test_net_ipv6addr_readable()2045 fn test_net_ipv6addr_readable() {
2046 test(
2047 "::1".parse::<net::Ipv6Addr>().unwrap().readable(),
2048 &[Token::Str("::1")],
2049 );
2050 }
2051
2052 #[test]
test_net_ipaddr_readable()2053 fn test_net_ipaddr_readable() {
2054 test(
2055 "1.2.3.4".parse::<net::IpAddr>().unwrap().readable(),
2056 &[Token::Str("1.2.3.4")],
2057 );
2058 }
2059
2060 #[test]
test_net_socketaddr_readable()2061 fn test_net_socketaddr_readable() {
2062 test(
2063 "1.2.3.4:1234"
2064 .parse::<net::SocketAddr>()
2065 .unwrap()
2066 .readable(),
2067 &[Token::Str("1.2.3.4:1234")],
2068 );
2069 test(
2070 "1.2.3.4:1234"
2071 .parse::<net::SocketAddrV4>()
2072 .unwrap()
2073 .readable(),
2074 &[Token::Str("1.2.3.4:1234")],
2075 );
2076 test(
2077 "[::1]:1234"
2078 .parse::<net::SocketAddrV6>()
2079 .unwrap()
2080 .readable(),
2081 &[Token::Str("[::1]:1234")],
2082 );
2083 }
2084
2085 #[test]
test_net_ipv4addr_compact()2086 fn test_net_ipv4addr_compact() {
2087 test(
2088 net::Ipv4Addr::from(*b"1234").compact(),
2089 &seq![
2090 Token::Tuple { len: 4 },
2091 b"1234".iter().copied().map(Token::U8),
2092 Token::TupleEnd
2093 ],
2094 );
2095 }
2096
2097 #[test]
test_net_ipv6addr_compact()2098 fn test_net_ipv6addr_compact() {
2099 test(
2100 net::Ipv6Addr::from(*b"1234567890123456").compact(),
2101 &seq![
2102 Token::Tuple { len: 4 },
2103 b"1234567890123456".iter().copied().map(Token::U8),
2104 Token::TupleEnd
2105 ],
2106 );
2107 }
2108
2109 #[test]
test_net_ipaddr_compact()2110 fn test_net_ipaddr_compact() {
2111 test(
2112 net::IpAddr::from(*b"1234").compact(),
2113 &seq![
2114 Token::NewtypeVariant {
2115 name: "IpAddr",
2116 variant: "V4"
2117 },
2118 Token::Tuple { len: 4 },
2119 b"1234".iter().copied().map(Token::U8),
2120 Token::TupleEnd
2121 ],
2122 );
2123 }
2124
2125 #[test]
test_net_socketaddr_compact()2126 fn test_net_socketaddr_compact() {
2127 test(
2128 net::SocketAddr::from((*b"1234567890123456", 1234)).compact(),
2129 &seq![
2130 Token::NewtypeVariant {
2131 name: "SocketAddr",
2132 variant: "V6"
2133 },
2134 Token::Tuple { len: 2 },
2135 Token::Tuple { len: 16 },
2136 b"1234567890123456".iter().copied().map(Token::U8),
2137 Token::TupleEnd,
2138 Token::U16(1234),
2139 Token::TupleEnd
2140 ],
2141 );
2142 test(
2143 net::SocketAddr::from((*b"1234", 1234)).compact(),
2144 &seq![
2145 Token::NewtypeVariant {
2146 name: "SocketAddr",
2147 variant: "V4"
2148 },
2149 Token::Tuple { len: 2 },
2150 Token::Tuple { len: 4 },
2151 b"1234".iter().copied().map(Token::U8),
2152 Token::TupleEnd,
2153 Token::U16(1234),
2154 Token::TupleEnd
2155 ],
2156 );
2157 test(
2158 net::SocketAddrV4::new(net::Ipv4Addr::from(*b"1234"), 1234).compact(),
2159 &seq![
2160 Token::Tuple { len: 2 },
2161 Token::Tuple { len: 4 },
2162 b"1234".iter().copied().map(Token::U8),
2163 Token::TupleEnd,
2164 Token::U16(1234),
2165 Token::TupleEnd
2166 ],
2167 );
2168 test(
2169 net::SocketAddrV6::new(net::Ipv6Addr::from(*b"1234567890123456"), 1234, 0, 0).compact(),
2170 &seq![
2171 Token::Tuple { len: 2 },
2172 Token::Tuple { len: 16 },
2173 b"1234567890123456".iter().copied().map(Token::U8),
2174 Token::TupleEnd,
2175 Token::U16(1234),
2176 Token::TupleEnd
2177 ],
2178 );
2179 }
2180
2181 #[cfg(feature = "unstable")]
2182 #[test]
test_never_result()2183 fn test_never_result() {
2184 test(
2185 Ok::<u8, !>(0),
2186 &[
2187 Token::NewtypeVariant {
2188 name: "Result",
2189 variant: "Ok",
2190 },
2191 Token::U8(0),
2192 ],
2193 );
2194 }
2195
2196 #[cfg(unix)]
2197 #[test]
test_osstring()2198 fn test_osstring() {
2199 use std::os::unix::ffi::OsStringExt;
2200
2201 let value = OsString::from_vec(vec![1, 2, 3]);
2202 let tokens = [
2203 Token::Enum { name: "OsString" },
2204 Token::Str("Unix"),
2205 Token::Seq { len: Some(2) },
2206 Token::U8(1),
2207 Token::U8(2),
2208 Token::U8(3),
2209 Token::SeqEnd,
2210 ];
2211
2212 assert_de_tokens(&value, &tokens);
2213 assert_de_tokens_ignore(&tokens);
2214 }
2215
2216 #[cfg(windows)]
2217 #[test]
test_osstring()2218 fn test_osstring() {
2219 use std::os::windows::ffi::OsStringExt;
2220
2221 let value = OsString::from_wide(&[1, 2, 3]);
2222 let tokens = [
2223 Token::Enum { name: "OsString" },
2224 Token::Str("Windows"),
2225 Token::Seq { len: Some(2) },
2226 Token::U16(1),
2227 Token::U16(2),
2228 Token::U16(3),
2229 Token::SeqEnd,
2230 ];
2231
2232 assert_de_tokens(&value, &tokens);
2233 assert_de_tokens_ignore(&tokens);
2234 }
2235
2236 #[test]
test_cstr()2237 fn test_cstr() {
2238 assert_de_tokens::<Box<CStr>>(
2239 &CString::new("abc").unwrap().into_boxed_c_str(),
2240 &[Token::Bytes(b"abc")],
2241 );
2242 }
2243
2244 #[test]
test_atomics()2245 fn test_atomics() {
2246 fn test<L, A, T>(load: L, val: T, token: Token)
2247 where
2248 L: Fn(&A, Ordering) -> T,
2249 A: DeserializeOwned,
2250 T: PartialEq + Debug,
2251 {
2252 let tokens = &[token];
2253 let mut de = serde_test::Deserializer::new(tokens);
2254 match A::deserialize(&mut de) {
2255 Ok(v) => {
2256 let loaded = load(&v, Ordering::Relaxed);
2257 assert_eq!(val, loaded);
2258 }
2259 Err(e) => panic!("tokens failed to deserialize: {}", e),
2260 };
2261 if de.remaining() > 0 {
2262 panic!("{} remaining tokens", de.remaining());
2263 }
2264 }
2265
2266 test(AtomicBool::load, true, Token::Bool(true));
2267 test(AtomicI8::load, -127, Token::I8(-127i8));
2268 test(AtomicI16::load, -510, Token::I16(-510i16));
2269 test(AtomicI32::load, -131072, Token::I32(-131072i32));
2270 test(AtomicIsize::load, -131072isize, Token::I32(-131072));
2271 test(AtomicU8::load, 127, Token::U8(127u8));
2272 test(AtomicU16::load, 510u16, Token::U16(510u16));
2273 test(AtomicU32::load, 131072u32, Token::U32(131072u32));
2274 test(AtomicUsize::load, 131072usize, Token::U32(131072));
2275
2276 #[cfg(target_arch = "x86_64")]
2277 {
2278 test(AtomicI64::load, -8589934592, Token::I64(-8589934592));
2279 test(AtomicU64::load, 8589934592u64, Token::U64(8589934592));
2280 }
2281 }
2282