enumset/tests/serde.rs

   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(Serialize, Deserialize, EnumSetType, Debug)]
  20 #[enumset(serialize_as_map)]
  21 #[serde(crate="serde2")]
  22 pub enum MapEnum {
  23     A, B, C, D, E, F, G, H,
  24 }
  25
  26 #[derive(EnumSetType, Debug)]
  27 #[enumset(serialize_repr = "u128")]
  28 pub enum ReprEnum {
  29     A, B, C, D, E, F, G, H,
  30 }
  31
  32 #[derive(EnumSetType, Debug)]
  33 #[enumset(serialize_repr = "u128", serialize_deny_unknown)]
  34 pub enum DenyUnknownEnum {
  35     A, B, C, D, E, F, G, H,
  36 }
  37
  38 macro_rules! serde_test_simple {
  39     ($e:ident, $ser_size:expr) => {
  40         #[test]
  41         fn serialize_deserialize_test_bincode() {
  42             let value = $e::A | $e::C | $e::D | $e::F | $e::E | $e::G;
  43             let serialized = bincode::serialize(&value).unwrap();
  44             let deserialized = bincode::deserialize::<EnumSet<$e>>(&serialized).unwrap();
  45             assert_eq!(value, deserialized);
  46             if $ser_size != !0 {
  47                 assert_eq!(serialized.len(), $ser_size);
  48             }
  49         }
  50
  51         #[test]
  52         fn serialize_deserialize_test_json() {
  53             let value = $e::A | $e::C | $e::D | $e::F | $e::E | $e::G;
  54             let serialized = serde_json::to_string(&value).unwrap();
  55             let deserialized = serde_json::from_str::<EnumSet<$e>>(&serialized).unwrap();
  56             assert_eq!(value, deserialized);
  57         }
  58     }
  59 }
  60 macro_rules! serde_test {
  61     ($e:ident, $ser_size:expr) => {
  62         serde_test_simple!($e, $ser_size);
  63
  64         #[test]
  65         fn deserialize_all_test() {
  66             let serialized = bincode::serialize(&!0u128).unwrap();
  67             let deserialized = bincode::deserialize::<EnumSet<$e>>(&serialized).unwrap();
  68             assert_eq!(EnumSet::<$e>::all(), deserialized);
  69         }
  70     }
  71 }
  72 macro_rules! tests {
  73     ($m:ident, $($tt:tt)*) => { mod $m { use super::*; $($tt)*; } }
  74 }
  75
  76 #[test]
  77 fn test_deny_unknown() {
  78     let serialized = bincode::serialize(&!0u128).unwrap();
  79     let deserialized = bincode::deserialize::<EnumSet<DenyUnknownEnum>>(&serialized);
  80     assert!(deserialized.is_err());
  81 }
  82
  83 #[test]
  84 fn test_json_reprs() {
  85     assert_eq!(ListEnum::A | ListEnum::C | ListEnum::F,
  86                serde_json::from_str::<EnumSet<ListEnum>>(r#"["A","C","F"]"#).unwrap());
  87     assert_eq!(MapEnum::A | MapEnum::C | MapEnum::F,
  88                serde_json::from_str::<EnumSet<MapEnum>>(r#"{"A":true,"C":true,"F":true}"#).unwrap());
  89     assert_eq!(ReprEnum::A | ReprEnum::C | ReprEnum::D,
  90                serde_json::from_str::<EnumSet<ReprEnum>>("13").unwrap());
  91     assert_eq!(r#"["A","C","F"]"#,
  92                serde_json::to_string(&(ListEnum::A | ListEnum::C | ListEnum::F)).unwrap());
  93     assert_eq!(r#"{"A":true,"C":true,"F":true}"#,
  94                serde_json::to_string(&(MapEnum::A | MapEnum::C | MapEnum::F)).unwrap());
  95     assert_eq!("13",
  96                serde_json::to_string(&(ReprEnum::A | ReprEnum::C | ReprEnum::D)).unwrap());
  97 }
  98
  99 tests!(list_enum, serde_test_simple!(ListEnum, !0));
 100 tests!(map_enum, serde_test_simple!(MapEnum, !0));
 101 tests!(repr_enum, serde_test!(ReprEnum, 16));
 102 tests!(deny_unknown_enum, serde_test_simple!(DenyUnknownEnum, 16));