kjuulh/rhai
1
0
Fork 0
Code Issues 1 Pull Requests 1 Packages Projects Releases Wiki Activity

Fix serde test.

Browse Source
This commit is contained in:
Stephen Chung 2020-10-10 14:15:23 +08:00
parent dd9f58f323
commit c463e42987
1 changed files with 134 additions and 181 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

315
tests/serde.rs
View File

@ -1,6 +1,9 @@
#![cfg(feature = "serde")] #![cfg(feature = "serde")]
use rhai::{de::from_dynamic, ser::to_dynamic, Dynamic, Engine, EvalAltResult, INT}; use rhai::{
serde::{from_dynamic, to_dynamic},
Dynamic, Engine, EvalAltResult, INT,
};
use serde::{Deserialize, Serialize}; use serde::{Deserialize, Serialize};
#[cfg(not(feature = "no_index"))] #[cfg(not(feature = "no_index"))]
@ -139,12 +142,10 @@ fn test_serde_ser_externally_tagged_enum() -> Result<(), Box<EvalAltResult>> {
assert!(content.is_empty()); assert!(content.is_empty());
} }
{ let mut map = to_dynamic(MyEnum::VariantNewtype(123))?.cast::<Map>();
let mut map = to_dynamic(MyEnum::VariantNewtype(123))?.cast::<Map>(); let content = map.remove("VariantNewtype").unwrap();
let content = map.remove("VariantNewtype").unwrap(); assert!(map.is_empty());
assert!(map.is_empty()); assert_eq!(Ok(123), content.as_int());
assert_eq!(Ok(123), content.as_int());
}
#[cfg(not(feature = "no_index"))] #[cfg(not(feature = "no_index"))]
{ {
@ -156,20 +157,16 @@ fn test_serde_ser_externally_tagged_enum() -> Result<(), Box<EvalAltResult>> {
assert_eq!(Ok(456), content[1].as_int()); assert_eq!(Ok(456), content[1].as_int());
} }
{ let mut map = to_dynamic(MyEnum::VariantEmptyStruct {})?.cast::<Map>();
let mut map = to_dynamic(MyEnum::VariantEmptyStruct {})?.cast::<Map>(); let map_inner = map.remove("VariantEmptyStruct").unwrap().cast::<Map>();
let map_inner = map.remove("VariantEmptyStruct").unwrap().cast::<Map>(); assert!(map.is_empty());
assert!(map.is_empty()); assert!(map_inner.is_empty());
assert!(map_inner.is_empty());
}
{ let mut map = to_dynamic(MyEnum::VariantStruct { a: 123 })?.cast::<Map>();
let mut map = to_dynamic(MyEnum::VariantStruct { a: 123 })?.cast::<Map>(); let mut map_inner = map.remove("VariantStruct").unwrap().cast::<Map>();
let mut map_inner = map.remove("VariantStruct").unwrap().cast::<Map>(); assert!(map.is_empty());
assert!(map.is_empty()); assert_eq!(Ok(123), map_inner.remove("a").unwrap().as_int());
assert_eq!(Ok(123), map_inner.remove("a").unwrap().as_int()); assert!(map_inner.is_empty());
assert!(map_inner.is_empty());
}
Ok(()) Ok(())
} }
@ -217,11 +214,9 @@ fn test_serde_ser_adjacently_tagged_enum() -> Result<(), Box<EvalAltResult>> {
}, },
} }
{ let mut map = to_dynamic(MyEnum::VariantUnit)?.cast::<Map>();
let mut map = to_dynamic(MyEnum::VariantUnit)?.cast::<Map>(); assert_eq!(Ok("VariantUnit"), map.remove("tag").unwrap().as_str());
assert_eq!(Ok("VariantUnit"), map.remove("tag").unwrap().as_str()); assert!(map.is_empty());
assert!(map.is_empty());
}
#[cfg(not(feature = "no_index"))] #[cfg(not(feature = "no_index"))]
{ {
@ -232,13 +227,11 @@ fn test_serde_ser_adjacently_tagged_enum() -> Result<(), Box<EvalAltResult>> {
assert!(content.is_empty()); assert!(content.is_empty());
} }
{ let mut map = to_dynamic(MyEnum::VariantNewtype(123))?.cast::<Map>();
let mut map = to_dynamic(MyEnum::VariantNewtype(123))?.cast::<Map>(); assert_eq!(Ok("VariantNewtype"), map.remove("tag").unwrap().as_str());
assert_eq!(Ok("VariantNewtype"), map.remove("tag").unwrap().as_str()); let content = map.remove("content").unwrap();
let content = map.remove("content").unwrap(); assert!(map.is_empty());
assert!(map.is_empty()); assert_eq!(Ok(123), content.as_int());
assert_eq!(Ok(123), content.as_int());
}
#[cfg(not(feature = "no_index"))] #[cfg(not(feature = "no_index"))]
{ {
@ -251,25 +244,21 @@ fn test_serde_ser_adjacently_tagged_enum() -> Result<(), Box<EvalAltResult>> {
assert_eq!(Ok(456), content[1].as_int()); assert_eq!(Ok(456), content[1].as_int());
} }
{ let mut map = to_dynamic(MyEnum::VariantEmptyStruct {})?.cast::<Map>();
let mut map = to_dynamic(MyEnum::VariantEmptyStruct {})?.cast::<Map>(); assert_eq!(
assert_eq!( Ok("VariantEmptyStruct"),
Ok("VariantEmptyStruct"), map.remove("tag").unwrap().as_str()
map.remove("tag").unwrap().as_str() );
); let map_inner = map.remove("content").unwrap().cast::<Map>();
let map_inner = map.remove("content").unwrap().cast::<Map>(); assert!(map.is_empty());
assert!(map.is_empty()); assert!(map_inner.is_empty());
assert!(map_inner.is_empty());
}
{ let mut map = to_dynamic(MyEnum::VariantStruct { a: 123 })?.cast::<Map>();
let mut map = to_dynamic(MyEnum::VariantStruct { a: 123 })?.cast::<Map>(); assert_eq!(Ok("VariantStruct"), map.remove("tag").unwrap().as_str());
assert_eq!(Ok("VariantStruct"), map.remove("tag").unwrap().as_str()); let mut map_inner = map.remove("content").unwrap().cast::<Map>();
let mut map_inner = map.remove("content").unwrap().cast::<Map>(); assert!(map.is_empty());
assert!(map.is_empty()); assert_eq!(Ok(123), map_inner.remove("a").unwrap().as_int());
assert_eq!(Ok(123), map_inner.remove("a").unwrap().as_int()); assert!(map_inner.is_empty());
assert!(map_inner.is_empty());
}
Ok(()) Ok(())
} }
@ -285,22 +274,16 @@ fn test_serde_ser_untagged_enum() -> Result<(), Box<EvalAltResult>> {
VariantStruct2 { b: i32 }, VariantStruct2 { b: i32 },
} }
{ let map = to_dynamic(MyEnum::VariantEmptyStruct {})?.cast::<Map>();
let map = to_dynamic(MyEnum::VariantEmptyStruct {})?.cast::<Map>(); assert!(map.is_empty());
assert!(map.is_empty());
}
{ let mut map = to_dynamic(MyEnum::VariantStruct1 { a: 123 })?.cast::<Map>();
let mut map = to_dynamic(MyEnum::VariantStruct1 { a: 123 })?.cast::<Map>(); assert_eq!(Ok(123), map.remove("a").unwrap().as_int());
assert_eq!(Ok(123), map.remove("a").unwrap().as_int()); assert!(map.is_empty());
assert!(map.is_empty());
}
{ let mut map = to_dynamic(MyEnum::VariantStruct2 { b: 123 })?.cast::<Map>();
let mut map = to_dynamic(MyEnum::VariantStruct2 { b: 123 })?.cast::<Map>(); assert_eq!(Ok(123), map.remove("b").unwrap().as_int());
assert_eq!(Ok(123), map.remove("b").unwrap().as_int()); assert!(map.is_empty());
assert!(map.is_empty());
}
Ok(()) Ok(())
} }
@ -433,15 +416,11 @@ fn test_serde_de_unit_enum() -> Result<(), Box<EvalAltResult>> {
VariantBar, VariantBar,
} }
{ let d = Dynamic::from("VariantFoo".to_string());
let d = Dynamic::from("VariantFoo".to_string()); assert_eq!(MyEnum::VariantFoo, from_dynamic(&d)?);
assert_eq!(MyEnum::VariantFoo, from_dynamic(&d)?);
}
{ let d = Dynamic::from("VariantBar".to_string());
let d = Dynamic::from("VariantBar".to_string()); assert_eq!(MyEnum::VariantBar, from_dynamic(&d)?);
assert_eq!(MyEnum::VariantBar, from_dynamic(&d)?);
}
Ok(()) Ok(())
} }
@ -464,10 +443,8 @@ fn test_serde_de_externally_tagged_enum() -> Result<(), Box<EvalAltResult>> {
}, },
} }
{ let d = Dynamic::from("VariantUnit".to_string());
let d = Dynamic::from("VariantUnit".to_string()); assert_eq!(MyEnum::VariantUnit, from_dynamic(&d).unwrap());
assert_eq!(MyEnum::VariantUnit, from_dynamic(&d).unwrap());
}
#[cfg(not(feature = "no_index"))] #[cfg(not(feature = "no_index"))]
{ {
@ -480,14 +457,12 @@ fn test_serde_de_externally_tagged_enum() -> Result<(), Box<EvalAltResult>> {
); );
} }
{ let mut map_outer = Map::new();
let mut map_outer = Map::new(); map_outer.insert("VariantNewtype".into(), (123 as INT).into());
map_outer.insert("VariantNewtype".into(), (123 as INT).into()); assert_eq!(
assert_eq!( MyEnum::VariantNewtype(123),
MyEnum::VariantNewtype(123), from_dynamic(&map_outer.into()).unwrap()
from_dynamic(&map_outer.into()).unwrap() );
);
}
#[cfg(not(feature = "no_index"))] #[cfg(not(feature = "no_index"))]
{ {
@ -500,26 +475,22 @@ fn test_serde_de_externally_tagged_enum() -> Result<(), Box<EvalAltResult>> {
); );
} }
{ let map_inner = Map::new();
let map_inner = Map::new(); let mut map_outer = Map::new();
let mut map_outer = Map::new(); map_outer.insert("VariantEmptyStruct".into(), map_inner.into());
map_outer.insert("VariantEmptyStruct".into(), map_inner.into()); assert_eq!(
assert_eq!( MyEnum::VariantEmptyStruct {},
MyEnum::VariantEmptyStruct {}, from_dynamic(&map_outer.into()).unwrap()
from_dynamic(&map_outer.into()).unwrap() );
);
}
{ let mut map_inner = Map::new();
let mut map_inner = Map::new(); map_inner.insert("a".into(), (123 as INT).into());
map_inner.insert("a".into(), (123 as INT).into()); let mut map_outer = Map::new();
let mut map_outer = Map::new(); map_outer.insert("VariantStruct".into(), map_inner.into());
map_outer.insert("VariantStruct".into(), map_inner.into()); assert_eq!(
assert_eq!( MyEnum::VariantStruct { a: 123 },
MyEnum::VariantStruct { a: 123 }, from_dynamic(&map_outer.into()).unwrap()
from_dynamic(&map_outer.into()).unwrap() );
);
}
Ok(()) Ok(())
} }
@ -534,24 +505,20 @@ fn test_serde_de_internally_tagged_enum() -> Result<(), Box<EvalAltResult>> {
VariantStruct { a: i32 }, VariantStruct { a: i32 },
} }
{ let mut map = Map::new();
let mut map = Map::new(); map.insert("tag".into(), "VariantStruct".into());
map.insert("tag".into(), "VariantStruct".into()); map.insert("a".into(), (123 as INT).into());
map.insert("a".into(), (123 as INT).into()); assert_eq!(
assert_eq!( MyEnum::VariantStruct { a: 123 },
MyEnum::VariantStruct { a: 123 }, from_dynamic(&map.into()).unwrap()
from_dynamic(&map.into()).unwrap() );
);
}
{ let mut map = Map::new();
let mut map = Map::new(); map.insert("tag".into(), "VariantEmptyStruct".into());
map.insert("tag".into(), "VariantEmptyStruct".into()); assert_eq!(
assert_eq!( MyEnum::VariantEmptyStruct {},
MyEnum::VariantEmptyStruct {}, from_dynamic(&map.into()).unwrap()
from_dynamic(&map.into()).unwrap() );
);
}
Ok(()) Ok(())
} }
@ -574,14 +541,12 @@ fn test_serde_de_adjacently_tagged_enum() -> Result<(), Box<EvalAltResult>> {
}, },
} }
{ let mut map_outer = Map::new();
let mut map_outer = Map::new(); map_outer.insert("tag".into(), "VariantUnit".into());
map_outer.insert("tag".into(), "VariantUnit".into()); assert_eq!(
assert_eq!( MyEnum::VariantUnit,
MyEnum::VariantUnit, from_dynamic(&map_outer.into()).unwrap()
from_dynamic(&map_outer.into()).unwrap() );
);
}
#[cfg(not(feature = "no_index"))] #[cfg(not(feature = "no_index"))]
{ {
@ -595,15 +560,13 @@ fn test_serde_de_adjacently_tagged_enum() -> Result<(), Box<EvalAltResult>> {
); );
} }
{ let mut map_outer = Map::new();
let mut map_outer = Map::new(); map_outer.insert("tag".into(), "VariantNewtype".into());
map_outer.insert("tag".into(), "VariantNewtype".into()); map_outer.insert("content".into(), (123 as INT).into());
map_outer.insert("content".into(), (123 as INT).into()); assert_eq!(
assert_eq!( MyEnum::VariantNewtype(123),
MyEnum::VariantNewtype(123), from_dynamic(&map_outer.into()).unwrap()
from_dynamic(&map_outer.into()).unwrap() );
);
}
#[cfg(not(feature = "no_index"))] #[cfg(not(feature = "no_index"))]
{ {
@ -617,28 +580,24 @@ fn test_serde_de_adjacently_tagged_enum() -> Result<(), Box<EvalAltResult>> {
); );
} }
{ let map_inner = Map::new();
let map_inner = Map::new(); let mut map_outer = Map::new();
let mut map_outer = Map::new(); map_outer.insert("tag".into(), "VariantEmptyStruct".into());
map_outer.insert("tag".into(), "VariantEmptyStruct".into()); map_outer.insert("content".into(), map_inner.into());
map_outer.insert("content".into(), map_inner.into()); assert_eq!(
assert_eq!( MyEnum::VariantEmptyStruct {},
MyEnum::VariantEmptyStruct {}, from_dynamic(&map_outer.into()).unwrap()
from_dynamic(&map_outer.into()).unwrap() );
);
}
{ let mut map_inner = Map::new();
let mut map_inner = Map::new(); map_inner.insert("a".into(), (123 as INT).into());
map_inner.insert("a".into(), (123 as INT).into()); let mut map_outer = Map::new();
let mut map_outer = Map::new(); map_outer.insert("tag".into(), "VariantStruct".into());
map_outer.insert("tag".into(), "VariantStruct".into()); map_outer.insert("content".into(), map_inner.into());
map_outer.insert("content".into(), map_inner.into()); assert_eq!(
assert_eq!( MyEnum::VariantStruct { a: 123 },
MyEnum::VariantStruct { a: 123 }, from_dynamic(&map_outer.into()).unwrap()
from_dynamic(&map_outer.into()).unwrap() );
);
}
Ok(()) Ok(())
} }
@ -654,31 +613,25 @@ fn test_serde_de_untagged_enum() -> Result<(), Box<EvalAltResult>> {
VariantStruct2 { b: i32 }, VariantStruct2 { b: i32 },
} }
{ let map = Map::new();
let map = Map::new(); assert_eq!(
assert_eq!( MyEnum::VariantEmptyStruct {},
MyEnum::VariantEmptyStruct {}, from_dynamic(&map.into()).unwrap()
from_dynamic(&map.into()).unwrap() );
);
}
{ let mut map = Map::new();
let mut map = Map::new(); map.insert("a".into(), (123 as INT).into());
map.insert("a".into(), (123 as INT).into()); assert_eq!(
assert_eq!( MyEnum::VariantStruct1 { a: 123 },
MyEnum::VariantStruct1 { a: 123 }, from_dynamic(&map.into()).unwrap()
from_dynamic(&map.into()).unwrap() );
);
}
{ let mut map = Map::new();
let mut map = Map::new(); map.insert("b".into(), (123 as INT).into());
map.insert("b".into(), (123 as INT).into()); assert_eq!(
assert_eq!( MyEnum::VariantStruct2 { b: 123 },
MyEnum::VariantStruct2 { b: 123 }, from_dynamic(&map.into()).unwrap()
from_dynamic(&map.into()).unwrap() );
);
}
Ok(()) Ok(())
} }