1 #![cfg(feature = "serde")]
2 #![allow(dead_code)]
3
4 use enumset::*;
5 use serde_derive::*;
6
7 // Test resistance against shadowed types.
8 type Some = ();
9 type None = ();
10 type Result = ();
11
12 #[derive(Serialize, Deserialize, EnumSetType, Debug)]
13 #[enumset(serialize_as_list)]
14 #[serde(crate="serde2")]
15 pub enum ListEnum {
16 A, B, C, D, E, F, G, H,
17 }
18
19 #[derive(EnumSetType, Debug)]
20 #[enumset(serialize_repr = "u128")]
21 pub enum ReprEnum {
22 A, B, C, D, E, F, G, H,
23 }
24
25 #[derive(EnumSetType, Debug)]
26 #[enumset(serialize_repr = "u128", serialize_deny_unknown)]
27 pub enum DenyUnknownEnum {
28 A, B, C, D, E, F, G, H,
29 }
30
31 macro_rules! serde_test_simple {
32 ($e:ident, $ser_size:expr) => {
33 #[test]
34 fn serialize_deserialize_test_bincode() {
35 let value = $e::A | $e::C | $e::D | $e::F | $e::E | $e::G;
36 let serialized = bincode::serialize(&value).unwrap();
37 let deserialized = bincode::deserialize::<EnumSet<$e>>(&serialized).unwrap();
38 assert_eq!(value, deserialized);
39 if $ser_size != !0 {
40 assert_eq!(serialized.len(), $ser_size);
41 }
42 }
43
44 #[test]
45 fn serialize_deserialize_test_json() {
46 let value = $e::A | $e::C | $e::D | $e::F | $e::E | $e::G;
47 let serialized = serde_json::to_string(&value).unwrap();
48 let deserialized = serde_json::from_str::<EnumSet<$e>>(&serialized).unwrap();
49 assert_eq!(value, deserialized);
50 }
51 }
52 }
53 macro_rules! serde_test {
54 ($e:ident, $ser_size:expr) => {
55 serde_test_simple!($e, $ser_size);
56
57 #[test]
58 fn deserialize_all_test() {
59 let serialized = bincode::serialize(&!0u128).unwrap();
60 let deserialized = bincode::deserialize::<EnumSet<$e>>(&serialized).unwrap();
61 assert_eq!(EnumSet::<$e>::all(), deserialized);
62 }
63 }
64 }
65 macro_rules! tests {
66 ($m:ident, $($tt:tt)*) => { mod $m { use super::*; $($tt)*; } }
67 }
68
69 #[test]
test_deny_unknown()70 fn test_deny_unknown() {
71 let serialized = bincode::serialize(&!0u128).unwrap();
72 let deserialized = bincode::deserialize::<EnumSet<DenyUnknownEnum>>(&serialized);
73 assert!(deserialized.is_err());
74 }
75
76 #[test]
test_json_reprs()77 fn test_json_reprs() {
78 assert_eq!(ListEnum::A | ListEnum::C | ListEnum::F,
79 serde_json::from_str::<EnumSet<ListEnum>>(r#"["A","C","F"]"#).unwrap());
80 assert_eq!(ReprEnum::A | ReprEnum::C | ReprEnum::D,
81 serde_json::from_str::<EnumSet<ReprEnum>>("13").unwrap());
82 assert_eq!(r#"["A","C","F"]"#,
83 serde_json::to_string(&(ListEnum::A | ListEnum::C | ListEnum::F)).unwrap());
84 assert_eq!("13",
85 serde_json::to_string(&(ReprEnum::A | ReprEnum::C | ReprEnum::D)).unwrap());
86 }
87
88 tests!(list_enum, serde_test_simple!(ListEnum, !0));
89 tests!(repr_enum, serde_test!(ReprEnum, 16));
90 tests!(deny_unknown_enum, serde_test_simple!(DenyUnknownEnum, 16));
91