109 lines
2.6 KiB
Rust
109 lines
2.6 KiB
Rust
#![cfg(feature = "serde")]
|
|
|
|
use rhai::{de::from_dynamic, Dynamic, Engine, EvalAltResult, INT};
|
|
use serde::Deserialize;
|
|
|
|
#[cfg(not(feature = "no_index"))]
|
|
use rhai::Array;
|
|
#[cfg(not(feature = "no_object"))]
|
|
use rhai::Map;
|
|
|
|
#[test]
|
|
fn test_serde_de_primary_types() {
|
|
assert_eq!(42_u16, from_dynamic(&Dynamic::from(42_u16)).unwrap());
|
|
assert_eq!(42 as INT, from_dynamic(&(42 as INT).into()).unwrap());
|
|
assert_eq!(true, from_dynamic(&true.into()).unwrap());
|
|
assert_eq!((), from_dynamic(&().into()).unwrap());
|
|
|
|
#[cfg(not(feature = "no_float"))]
|
|
{
|
|
assert_eq!(123.456_f64, from_dynamic(&123.456_f64.into()).unwrap());
|
|
assert_eq!(
|
|
123.456_f32,
|
|
from_dynamic(&Dynamic::from(123.456_f32)).unwrap()
|
|
);
|
|
}
|
|
|
|
assert_eq!(
|
|
"hello",
|
|
from_dynamic::<String>(&"hello".to_string().into()).unwrap()
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
#[cfg(not(feature = "no_index"))]
|
|
fn test_serde_de_array() {
|
|
let arr: Vec<INT> = vec![123, 456, 42, 999];
|
|
assert_eq!(arr, from_dynamic::<Vec<INT>>(&arr.clone().into()).unwrap());
|
|
}
|
|
|
|
#[test]
|
|
fn test_serde_de_struct() {
|
|
#[derive(Debug, Deserialize, PartialEq)]
|
|
struct Hello {
|
|
a: INT,
|
|
b: bool,
|
|
}
|
|
|
|
#[derive(Debug, Deserialize, PartialEq)]
|
|
struct Test {
|
|
int: u32,
|
|
seq: Vec<String>,
|
|
obj: Hello,
|
|
}
|
|
|
|
let mut map = Map::new();
|
|
map.insert("int".into(), Dynamic::from(42_u32));
|
|
|
|
let mut map2 = Map::new();
|
|
map2.insert("a".into(), (123 as INT).into());
|
|
map2.insert("b".into(), true.into());
|
|
|
|
map.insert("obj".into(), map2.into());
|
|
|
|
let arr: Array = vec!["hello".into(), "kitty".into(), "world".into()];
|
|
map.insert("seq".into(), arr.into());
|
|
|
|
let expected = Test {
|
|
int: 42,
|
|
seq: vec!["hello".into(), "kitty".into(), "world".into()],
|
|
obj: Hello { a: 123, b: true },
|
|
};
|
|
assert_eq!(expected, from_dynamic(&map.into()).unwrap());
|
|
}
|
|
|
|
#[test]
|
|
fn test_serde_de_script() -> Result<(), Box<EvalAltResult>> {
|
|
#[derive(Debug, Deserialize)]
|
|
struct Point {
|
|
x: f64,
|
|
y: f64,
|
|
}
|
|
|
|
#[derive(Debug, Deserialize)]
|
|
struct MyStruct {
|
|
a: i64,
|
|
b: Vec<String>,
|
|
c: bool,
|
|
d: Point,
|
|
}
|
|
|
|
let engine = Engine::new();
|
|
|
|
let result: Dynamic = engine.eval(
|
|
r#"
|
|
#{
|
|
a: 42,
|
|
b: [ "hello", "world" ],
|
|
c: true,
|
|
d: #{ x: 123.456, y: 999.0 }
|
|
}
|
|
"#,
|
|
)?;
|
|
|
|
// Convert the 'Dynamic' object map into 'MyStruct'
|
|
let x: MyStruct = from_dynamic(&result)?;
|
|
|
|
Ok(())
|
|
}
|