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