581 lines
20 KiB
Rust
581 lines
20 KiB
Rust
use rhai_wrapper::wrap_for_rhai;
|
|
use rhai_wrapper::{ToRhaiMap, FromRhaiMap};
|
|
use rhai::{CustomType, TypeBuilder, Engine, INT, FLOAT, Array};
|
|
use rhai_macros_derive::{ToRhaiMap as ToRhaiMapDerive, FromRhaiMap as FromRhaiMapDerive, export_fn};
|
|
|
|
#[export_fn(rhai_name = "add_rhai")]
|
|
fn add(a: INT, b: INT) -> INT { a + b }
|
|
#[export_fn(rhai_name = "mul_rhai")]
|
|
fn mul(a: INT, b: INT) -> INT { a * b }
|
|
#[export_fn(rhai_name = "greet_rhai")]
|
|
fn greet(name: String) -> String { format!("Hello, {name}!") }
|
|
#[export_fn(rhai_name = "get_forty_two_rhai")]
|
|
fn get_forty_two() -> INT { 42 }
|
|
#[export_fn(rhai_name = "shout_rhai")]
|
|
fn shout() -> String { "HEY!".to_string() }
|
|
#[export_fn(rhai_name = "add_float_rhai")]
|
|
fn add_float(a: FLOAT, b: FLOAT) -> FLOAT { a + b }
|
|
#[export_fn(rhai_name = "is_even_rhai")]
|
|
fn is_even(n: INT) -> bool { n % 2 == 0 }
|
|
#[export_fn(rhai_name = "maybe_add_rhai")]
|
|
fn maybe_add(a: INT, b: INT, do_add: bool) -> Option<INT> { if do_add { Some(a + b) } else { None } }
|
|
|
|
// Renamed from sum_vec, takes rhai::Array
|
|
fn sum_arr(arr: Array) -> INT { arr.into_iter().map(|x| x.as_int().unwrap_or(0)).sum() }
|
|
|
|
// New sum_vec, takes Vec<INT>
|
|
fn sum_vec(v: Vec<INT>) -> INT { v.iter().sum() }
|
|
|
|
fn describe(name: String, age: INT, height: FLOAT) -> String {
|
|
format!("{name} is {age} years old and {height:.1}m tall.")
|
|
}
|
|
fn swap(a: INT, b: INT) -> (INT, INT) { (b, a) }
|
|
|
|
fn join_strings(strings: Vec<String>) -> String {
|
|
strings.join(", ")
|
|
}
|
|
|
|
// New function for Vec<FLOAT>
|
|
fn sum_float_vec(floats: Vec<FLOAT>) -> FLOAT {
|
|
floats.iter().sum()
|
|
}
|
|
|
|
#[derive(Debug, Clone, PartialEq, CustomType, ToRhaiMapDerive, FromRhaiMapDerive)]
|
|
pub struct Point {
|
|
pub x: INT,
|
|
pub y: INT,
|
|
}
|
|
|
|
// --- Test Custom Struct: Line (contains Point structs) ---
|
|
#[derive(Debug, Clone, PartialEq, rhai::CustomType, ToRhaiMapDerive, FromRhaiMapDerive)]
|
|
struct Line {
|
|
start: Point,
|
|
end: Point,
|
|
label: String,
|
|
}
|
|
|
|
// --- Test Custom Struct: Polygon (contains Vec<Point> and Point) ---
|
|
#[derive(Debug, Clone, PartialEq, rhai::CustomType, ToRhaiMapDerive, FromRhaiMapDerive)]
|
|
struct Polygon {
|
|
id: String,
|
|
vertices: Vec<Point>,
|
|
center_approx: Point,
|
|
}
|
|
|
|
// New function for Vec<Point>
|
|
fn sum_points(points: Vec<Point>) -> INT {
|
|
points.iter().map(|p| p.x + p.y).sum()
|
|
}
|
|
|
|
// New function: Vec<Point> -> String
|
|
fn points_to_string(points: Vec<Point>) -> String {
|
|
points.iter()
|
|
.map(|p| format!("(x:{},y:{})", p.x, p.y))
|
|
.collect::<Vec<String>>()
|
|
.join("; ")
|
|
}
|
|
|
|
// New function: Vec<Point> -> Vec<INT>
|
|
fn get_all_x_coordinates(points: Vec<Point>) -> Vec<INT> {
|
|
points.iter().map(|p| p.x).collect()
|
|
}
|
|
|
|
// New function: Vec<Point> -> Vec<Point>
|
|
fn make_points_origin_symmetric(points: Vec<Point>) -> Vec<Point> {
|
|
points.into_iter().map(|p| Point { x: -p.x, y: -p.y }).collect()
|
|
}
|
|
|
|
fn get_line_midpoints(lines: Vec<Line>) -> Vec<Point> {
|
|
lines.into_iter().map(|line| {
|
|
Point {
|
|
x: (line.start.x + line.end.x) / 2,
|
|
y: (line.start.y + line.end.y) / 2,
|
|
}
|
|
}).collect()
|
|
}
|
|
|
|
fn create_line(p1: Point, p2: Point, label: String) -> Line {
|
|
Line { start: p1, end: p2, label }
|
|
}
|
|
|
|
fn create_sample_polygon(id: String, center_x: INT, center_y: INT) -> Polygon {
|
|
Polygon {
|
|
id,
|
|
vertices: vec![
|
|
Point { x: center_x - 10, y: center_y - 10 },
|
|
Point { x: center_x + 10, y: center_y - 10 },
|
|
Point { x: center_x + 10, y: center_y + 10 },
|
|
Point { x: center_x - 10, y: center_y + 10 },
|
|
],
|
|
center_approx: Point { x: center_x, y: center_y },
|
|
}
|
|
}
|
|
|
|
fn get_polygon_id_and_num_vertices(poly: Polygon) -> String {
|
|
format!("ID: {}, Vertices: {}", poly.id, poly.vertices.len())
|
|
}
|
|
|
|
#[test]
|
|
fn test_add() {
|
|
let mut engine = Engine::new();
|
|
engine.register_fn("add_rhai", add_rhai_wrapper);
|
|
let result = engine.eval::<INT>("add_rhai(2, 3)").unwrap();
|
|
assert_eq!(result, 5);
|
|
}
|
|
|
|
#[test]
|
|
fn test_mul() {
|
|
let mut engine = Engine::new();
|
|
engine.register_fn("mul_rhai", mul_rhai_wrapper);
|
|
let result = engine.eval::<INT>("mul_rhai(4, 5)").unwrap();
|
|
assert_eq!(result, 20);
|
|
}
|
|
|
|
#[test]
|
|
fn test_greet() {
|
|
let mut engine = Engine::new();
|
|
engine.register_fn("greet_rhai", greet_rhai_wrapper);
|
|
let result = engine.eval::<String>(r#"greet_rhai("Alice")"#).unwrap();
|
|
assert_eq!(result, "Hello, Alice!");
|
|
}
|
|
|
|
#[test]
|
|
fn test_get_forty_two() {
|
|
let mut engine = Engine::new();
|
|
engine.register_fn("get_forty_two_rhai", get_forty_two_rhai_wrapper);
|
|
let result = engine.eval::<INT>("get_forty_two_rhai()").unwrap();
|
|
assert_eq!(result, 42);
|
|
}
|
|
|
|
#[test]
|
|
fn test_shout() {
|
|
let mut engine = Engine::new();
|
|
engine.register_fn("shout_rhai", shout_rhai_wrapper);
|
|
let result = engine.eval::<String>("shout_rhai()").unwrap();
|
|
assert_eq!(result, "HEY!");
|
|
}
|
|
|
|
#[test]
|
|
fn test_add_float() {
|
|
let mut engine = Engine::new();
|
|
engine.register_fn("add_float_rhai", add_float_rhai_wrapper);
|
|
let result = engine.eval::<FLOAT>("add_float_rhai(2.5, 3.5)").unwrap();
|
|
assert_eq!(result, 6.0);
|
|
}
|
|
|
|
#[test]
|
|
fn test_is_even() {
|
|
let mut engine = Engine::new();
|
|
engine.register_fn("is_even_rhai", is_even_rhai_wrapper);
|
|
let result_true = engine.eval::<bool>("is_even_rhai(4)").unwrap();
|
|
assert_eq!(result_true, true);
|
|
let result_false = engine.eval::<bool>("is_even_rhai(3)").unwrap();
|
|
assert_eq!(result_false, false);
|
|
}
|
|
|
|
#[test]
|
|
fn test_maybe_add() {
|
|
let mut engine = Engine::new();
|
|
engine.register_fn("maybe_add_rhai", maybe_add_rhai_wrapper);
|
|
|
|
// Test case where None is returned (expecting an error or specific handling in Rhai)
|
|
// Rhai treats Option::None as an empty Dynamic, which can lead to type mismatch if not handled.
|
|
// For now, let's check if the script produces a specific type or if it can be evaluated to Dynamic.
|
|
// If the function returns None, eval might return an error if trying to cast to INT.
|
|
// Let's eval to Dynamic and check if it's empty (Rhai's representation of None).
|
|
let result_none = engine.eval::<rhai::Dynamic>("maybe_add_rhai(2, 3, false)").unwrap();
|
|
|
|
// Debug prints
|
|
println!("Debug [test_maybe_add]: result_none = {:?}", result_none);
|
|
println!("Debug [test_maybe_add]: result_none.type_name() = {}", result_none.type_name());
|
|
println!("Debug [test_maybe_add]: result_none.is::<()>() = {}", result_none.is::<()>());
|
|
|
|
assert!(result_none.is_unit(), "Expected Rhai None (unit Dynamic)");
|
|
|
|
// Test case where Some is returned
|
|
let result_some = engine.eval::<INT>("maybe_add_rhai(2, 3, true)").unwrap();
|
|
assert_eq!(result_some, 5);
|
|
}
|
|
|
|
#[test]
|
|
// Renamed from test_sum_vec
|
|
fn test_sum_arr() {
|
|
let mut engine = Engine::new();
|
|
engine.register_fn("sum_arr", wrap_for_rhai!(sum_arr));
|
|
let result = engine.eval::<INT>("sum_arr([1, 2, 3, 4])").unwrap();
|
|
assert_eq!(result, 10);
|
|
}
|
|
|
|
#[test]
|
|
// Test for the new sum_vec(v: Vec<INT>)
|
|
fn test_sum_vec() {
|
|
let mut engine = Engine::new();
|
|
engine.register_fn("sum_vec", wrap_for_rhai!(sum_vec, Vec<INT> -> INT));
|
|
let result = engine.eval::<INT>("sum_vec([1, 2, 3, 4])").unwrap();
|
|
assert_eq!(result, 10);
|
|
}
|
|
|
|
#[test]
|
|
fn test_join_strings() {
|
|
let mut engine = Engine::new();
|
|
engine.register_fn("join_strings_rhai", wrap_for_rhai!(join_strings, Vec<String> -> String));
|
|
let result = engine.eval::<String>(r#"join_strings_rhai(["hello", "world", "rhai"]);"#).unwrap();
|
|
assert_eq!(result, "hello, world, rhai");
|
|
}
|
|
|
|
#[test]
|
|
fn test_sum_float_vec() {
|
|
let mut engine = Engine::new();
|
|
engine.register_fn("sum_float_vec_rhai", wrap_for_rhai!(sum_float_vec, Vec<FLOAT> -> FLOAT));
|
|
let result = engine.eval::<FLOAT>(r#"sum_float_vec_rhai([1.1, 2.2, 3.3]);"#).unwrap();
|
|
assert!((result - 6.6).abs() < std::f64::EPSILON);
|
|
}
|
|
|
|
#[test]
|
|
fn test_sum_points() {
|
|
let mut engine = Engine::new();
|
|
|
|
// Register the Point type with Rhai. The name "Point" will be used in Rhai scripts.
|
|
// This is crucial for the generic macro arm to work with Vec<Point>.
|
|
engine.build_type::<Point>();
|
|
|
|
engine.register_fn("sum_points_rhai", wrap_for_rhai!(sum_points, Vec<Point> -> INT));
|
|
let script = r#"
|
|
sum_points_rhai([
|
|
#{ x: 1, y: 2 },
|
|
#{ x: 3, y: 4 },
|
|
#{ x: 5, y: 6 }
|
|
])
|
|
"#;
|
|
let result = engine.eval::<INT>(script).unwrap();
|
|
assert_eq!(result, 1 + 2 + 3 + 4 + 5 + 6); // 21
|
|
}
|
|
|
|
#[test]
|
|
fn test_points_to_string() {
|
|
let mut engine = Engine::new();
|
|
engine.build_type::<Point>(); // Register Point type
|
|
|
|
// Wrap the new function
|
|
engine.register_fn("points_to_string_rhai", wrap_for_rhai!(points_to_string, Vec<Point> -> String));
|
|
|
|
let script = r#"
|
|
points_to_string_rhai([
|
|
#{ x: 1, y: 2 },
|
|
#{ x: 10, y: 20 }
|
|
])
|
|
"#;
|
|
let result: String = engine.eval(script).unwrap();
|
|
assert_eq!(result, "(x:1,y:2); (x:10,y:20)");
|
|
}
|
|
|
|
#[test]
|
|
fn test_get_all_x_coordinates() {
|
|
let mut engine = Engine::new();
|
|
engine.build_type::<Point>(); // Register Point type
|
|
|
|
engine.register_fn("get_all_x_rhai", wrap_for_rhai!(get_all_x_coordinates, Vec<Point> -> Vec<INT>));
|
|
|
|
let script = r#"
|
|
let result = get_all_x_rhai([
|
|
#{ x: 1, y: 2 },
|
|
#{ x: 10, y: 20 },
|
|
#{ x: 50, y: 60 }
|
|
]);
|
|
result // Rhai returns the last expression value
|
|
"#;
|
|
let result_array: rhai::Array = engine.eval(script).unwrap();
|
|
|
|
// Convert rhai::Array to Vec<INT> for comparison
|
|
let result_vec: Vec<INT> = result_array.into_iter().map(|d| d.as_int().unwrap()).collect();
|
|
assert_eq!(result_vec, vec![1, 10, 50]);
|
|
}
|
|
|
|
#[test]
|
|
fn test_make_points_origin_symmetric() {
|
|
let mut engine = Engine::new();
|
|
engine.build_type::<Point>();
|
|
engine.register_fn("make_symmetric_rhai", wrap_for_rhai!(make_points_origin_symmetric, Vec<Point> -> Vec<Point>));
|
|
|
|
let script = r#"
|
|
let points = [ #{x:1, y:2}, #{x:-3, y:4} ];
|
|
make_symmetric_rhai(points)
|
|
"#;
|
|
let result_array: rhai::Array = engine.eval(script).unwrap();
|
|
|
|
assert_eq!(result_array.len(), 2);
|
|
|
|
// Check first point
|
|
let p1_map = result_array[0].clone().try_cast::<rhai::Map>().expect("Failed to cast result[0] to Map");
|
|
assert_eq!(p1_map.get("x").and_then(|d| d.as_int().ok()).expect("p1.x not found or not INT"), -1);
|
|
assert_eq!(p1_map.get("y").and_then(|d| d.as_int().ok()).expect("p1.y not found or not INT"), -2);
|
|
|
|
// Check second point
|
|
let p2_map = result_array[1].clone().try_cast::<rhai::Map>().expect("Failed to cast result[1] to Map");
|
|
assert_eq!(p2_map.get("x").and_then(|d| d.as_int().ok()).expect("p2.x not found or not INT"), 3);
|
|
assert_eq!(p2_map.get("y").and_then(|d| d.as_int().ok()).expect("p2.y not found or not INT"), -4);
|
|
}
|
|
|
|
#[test]
|
|
fn test_describe() {
|
|
let mut engine = Engine::new();
|
|
engine.register_fn("describe", wrap_for_rhai!(describe));
|
|
let result = engine.eval::<String>(r#"describe("Bob", 30, 1.8)"#).unwrap();
|
|
assert_eq!(result, "Bob is 30 years old and 1.8m tall.");
|
|
}
|
|
|
|
#[test]
|
|
fn test_swap() {
|
|
let mut engine = Engine::new();
|
|
engine.register_fn("swap", wrap_for_rhai!(swap));
|
|
let result = engine.eval::<(INT, INT)>("swap(1, 2)").unwrap();
|
|
assert_eq!(result, (2, 1));
|
|
}
|
|
|
|
#[test]
|
|
fn test_get_line_midpoints() {
|
|
let mut engine = Engine::new();
|
|
engine.build_type::<Point>();
|
|
engine.build_type::<Line>();
|
|
engine.register_fn("get_midpoints_rhai", wrap_for_rhai!(get_line_midpoints, Vec<Line> -> Vec<Point>));
|
|
|
|
let script = r#"
|
|
let lines = [
|
|
#{ start: #{x:0, y:0}, end: #{x:2, y:2}, label: "A" },
|
|
#{ start: #{x:10, y:10}, end: #{x:20, y:30}, label: "B" }
|
|
];
|
|
get_midpoints_rhai(lines)
|
|
"#;
|
|
let result_array: rhai::Array = engine.eval(script).unwrap();
|
|
|
|
assert_eq!(result_array.len(), 2);
|
|
|
|
// Check first midpoint (Point)
|
|
let p1_map = result_array[0].clone().try_cast::<rhai::Map>().expect("Result[0] not a Map for Point");
|
|
assert_eq!(p1_map.get("x").and_then(|d| d.as_int().ok()).expect("p1.x not INT"), 1);
|
|
assert_eq!(p1_map.get("y").and_then(|d| d.as_int().ok()).expect("p1.y not INT"), 1);
|
|
|
|
// Check second midpoint (Point)
|
|
let p2_map = result_array[1].clone().try_cast::<rhai::Map>().expect("Result[1] not a Map for Point");
|
|
assert_eq!(p2_map.get("x").and_then(|d| d.as_int().ok()).expect("p2.x not INT"), 15);
|
|
assert_eq!(p2_map.get("y").and_then(|d| d.as_int().ok()).expect("p2.y not INT"), 20);
|
|
}
|
|
|
|
#[test]
|
|
fn test_create_line() {
|
|
let mut engine = Engine::new();
|
|
engine.build_type::<Point>();
|
|
engine.build_type::<Line>();
|
|
engine.register_fn("create_line_rhai", wrap_for_rhai!(create_line, Point, Point, String -> Line));
|
|
|
|
let script = r#"
|
|
let p_start = #{ x: 1, y: 2 };
|
|
let p_end = #{ x: 3, y: 4 };
|
|
create_line_rhai(p_start, p_end, "MyLine")
|
|
"#;
|
|
let result_line_map: rhai::Map = engine.eval(script).unwrap();
|
|
|
|
// Check label
|
|
assert_eq!(result_line_map.get("label").unwrap().clone().into_string().unwrap(), "MyLine");
|
|
|
|
// Check start point
|
|
let start_map = result_line_map.get("start").unwrap().clone().try_cast::<rhai::Map>().unwrap();
|
|
assert_eq!(start_map.get("x").unwrap().as_int().unwrap(), 1);
|
|
assert_eq!(start_map.get("y").unwrap().as_int().unwrap(), 2);
|
|
|
|
// Check end point
|
|
let end_map = result_line_map.get("end").unwrap().clone().try_cast::<rhai::Map>().unwrap();
|
|
assert_eq!(end_map.get("x").unwrap().as_int().unwrap(), 3);
|
|
assert_eq!(end_map.get("y").unwrap().as_int().unwrap(), 4);
|
|
}
|
|
|
|
#[test]
|
|
fn test_create_sample_polygon() {
|
|
let mut engine = Engine::new();
|
|
engine.build_type::<Point>();
|
|
engine.build_type::<Polygon>();
|
|
engine.register_fn("new_polygon_rhai", wrap_for_rhai!(create_sample_polygon, String, INT, INT -> Polygon));
|
|
|
|
let script = r#"
|
|
new_polygon_rhai("poly1", 100, 200)
|
|
"#;
|
|
let result_poly_map: rhai::Map = engine.eval(script).unwrap();
|
|
|
|
assert_eq!(result_poly_map.get("id").unwrap().clone().into_string().unwrap(), "poly1");
|
|
|
|
let center_map = result_poly_map.get("center_approx").unwrap().clone().try_cast::<rhai::Map>().unwrap();
|
|
assert_eq!(center_map.get("x").unwrap().as_int().unwrap(), 100);
|
|
assert_eq!(center_map.get("y").unwrap().as_int().unwrap(), 200);
|
|
|
|
let vertices_array = result_poly_map.get("vertices").unwrap().clone().try_cast::<rhai::Array>().unwrap();
|
|
assert_eq!(vertices_array.len(), 4);
|
|
|
|
// Check one vertex (e.g., the first one: center_x - 10, center_y - 10 -> 90, 190)
|
|
let v1_map = vertices_array[0].clone().try_cast::<rhai::Map>().unwrap();
|
|
assert_eq!(v1_map.get("x").unwrap().as_int().unwrap(), 90);
|
|
assert_eq!(v1_map.get("y").unwrap().as_int().unwrap(), 190);
|
|
}
|
|
|
|
#[test]
|
|
fn test_get_polygon_id_and_num_vertices() {
|
|
let mut engine = Engine::new();
|
|
engine.build_type::<Point>(); // Needed if Polygon::from_rhai_map reconstructs Points, even if not directly used by this func's signature in Rhai
|
|
engine.build_type::<Polygon>();
|
|
engine.register_fn("poly_info_rhai", wrap_for_rhai!(get_polygon_id_and_num_vertices, Polygon -> String));
|
|
|
|
let script = r#"
|
|
let my_poly = #{
|
|
id: "test_poly",
|
|
vertices: [ #{x:0,y:0}, #{x:1,y:0}, #{x:0,y:1} ],
|
|
center_approx: #{x:0,y:0}
|
|
};
|
|
poly_info_rhai(my_poly)
|
|
"#;
|
|
let result_string: String = engine.eval(script).unwrap();
|
|
|
|
assert_eq!(result_string, "ID: test_poly, Vertices: 3");
|
|
}
|
|
|
|
#[test]
|
|
fn test_polygon_derives() {
|
|
let original_polygon = Polygon {
|
|
id: "poly_derive_test".to_string(),
|
|
vertices: vec![
|
|
Point { x: 10, y: 20 },
|
|
Point { x: 30, y: 40 },
|
|
],
|
|
center_approx: Point { x: 20, y: 30 },
|
|
};
|
|
|
|
// Test ToRhaiMap (derived)
|
|
let rhai_map = original_polygon.to_rhai_map();
|
|
|
|
// Verify id
|
|
assert_eq!(
|
|
rhai_map.get("id").unwrap().clone().into_string().unwrap(),
|
|
"poly_derive_test"
|
|
);
|
|
|
|
// Verify center_approx (which uses Point's derived ToRhaiMap)
|
|
let center_map_dyn = rhai_map.get("center_approx").unwrap().clone();
|
|
let center_map = center_map_dyn.try_cast::<rhai::Map>().unwrap();
|
|
assert_eq!(center_map.get("x").unwrap().as_int().unwrap(), 20);
|
|
assert_eq!(center_map.get("y").unwrap().as_int().unwrap(), 30);
|
|
|
|
// Verify vertices (Vec<Point>)
|
|
let vertices_array_dyn = rhai_map.get("vertices").unwrap().clone();
|
|
let vertices_array = vertices_array_dyn.try_cast::<rhai::Array>().unwrap();
|
|
assert_eq!(vertices_array.len(), 2);
|
|
|
|
let v1_map_dyn = vertices_array[0].clone();
|
|
let v1_map = v1_map_dyn.try_cast::<rhai::Map>().unwrap();
|
|
assert_eq!(v1_map.get("x").unwrap().as_int().unwrap(), 10);
|
|
assert_eq!(v1_map.get("y").unwrap().as_int().unwrap(), 20);
|
|
|
|
let v2_map_dyn = vertices_array[1].clone();
|
|
let v2_map = v2_map_dyn.try_cast::<rhai::Map>().unwrap();
|
|
assert_eq!(v2_map.get("x").unwrap().as_int().unwrap(), 30);
|
|
assert_eq!(v2_map.get("y").unwrap().as_int().unwrap(), 40);
|
|
|
|
// Test FromRhaiMap (derived)
|
|
let deserialized_polygon = Polygon::from_rhai_map(rhai_map).unwrap();
|
|
|
|
assert_eq!(original_polygon, deserialized_polygon);
|
|
assert_eq!(deserialized_polygon.id, "poly_derive_test");
|
|
assert_eq!(deserialized_polygon.vertices.len(), 2);
|
|
assert_eq!(deserialized_polygon.vertices[0], Point { x: 10, y: 20 });
|
|
assert_eq!(deserialized_polygon.vertices[1], Point { x: 30, y: 40 });
|
|
assert_eq!(deserialized_polygon.center_approx, Point { x: 20, y: 30 });
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod new_export_fn_tests {
|
|
use rhai::{Engine, INT, CustomType, TypeBuilder};
|
|
use rhai_wrapper::{FromRhaiMap, ToRhaiMap};
|
|
use crate::Point;
|
|
use rhai_macros_derive::{export_fn, FromRhaiMap as FromRhaiMapDerive, ToRhaiMap as ToRhaiMapDerive};
|
|
|
|
// Define the exported functions directly in this module or ensure they are in scope.
|
|
// Assuming 'add_for_attr_test' and 'offset_simple_point' are defined here or imported.
|
|
|
|
// Correctly define the SampleStruct and its FromRhaiMap implementation if not already present
|
|
#[derive(Debug, Clone, PartialEq, FromRhaiMapDerive, ToRhaiMapDerive, CustomType)]
|
|
struct SampleStruct {
|
|
value: INT,
|
|
name: String,
|
|
}
|
|
|
|
#[export_fn]
|
|
fn add_for_attr_test(a: INT, b: INT) -> INT {
|
|
a + b
|
|
}
|
|
|
|
#[export_fn]
|
|
fn offset_simple_point(mut pt: Point, dx: INT) -> Point {
|
|
pt.x += dx;
|
|
pt
|
|
}
|
|
|
|
#[test]
|
|
fn test_export_fn_simple_add() {
|
|
let mut engine = Engine::new();
|
|
engine.register_fn("add_for_attr_test", add_for_attr_test_rhai_wrapper);
|
|
let result = engine.eval::<INT>("add_for_attr_test(5, 10)").unwrap();
|
|
assert_eq!(result, 15);
|
|
}
|
|
|
|
#[test]
|
|
fn test_export_fn_custom_type_arg_return_new() {
|
|
let mut engine = Engine::new();
|
|
engine.build_type::<Point>();
|
|
engine.register_fn("offset_simple_point", offset_simple_point_rhai_wrapper);
|
|
|
|
let script = r#"
|
|
let p = #{ x: 10, y: 20 };
|
|
let p_offset = offset_simple_point(p, 5);
|
|
p_offset.x
|
|
"#;
|
|
let result = engine.eval::<INT>(script).unwrap();
|
|
assert_eq!(result, 15);
|
|
}
|
|
|
|
|
|
#[derive(Debug, Clone, PartialEq, FromRhaiMapDerive, ToRhaiMapDerive, CustomType)]
|
|
struct AnotherSampleStruct {
|
|
id: String,
|
|
value: INT,
|
|
maybe_value: Option<INT>,
|
|
nested_vec: Vec<SampleStruct>,
|
|
optional_nested_vec: Option<Vec<SampleStruct>>
|
|
}
|
|
|
|
#[test]
|
|
fn test_from_rhai_map_derive_full_struct() {
|
|
let mut engine = Engine::new();
|
|
engine.build_type::<SampleStruct>();
|
|
engine.build_type::<AnotherSampleStruct>();
|
|
|
|
let script = r#"
|
|
let data = #{
|
|
id: "test_id",
|
|
value: 123,
|
|
maybe_value: 456,
|
|
nested_vec: [ #{value: 1, name: "n1"}, #{value: 2, name: "n2"} ],
|
|
optional_nested_vec: [ #{value: 3, name: "n3"} ]
|
|
};
|
|
data // Return the map directly for Rust to process
|
|
"#;
|
|
let map = engine.eval::<rhai::Map>(script).unwrap();
|
|
let result_struct = AnotherSampleStruct::from_rhai_map(map).unwrap();
|
|
|
|
assert_eq!(result_struct.id, "test_id");
|
|
assert_eq!(result_struct.value, 123);
|
|
assert_eq!(result_struct.maybe_value, Some(456));
|
|
assert_eq!(result_struct.nested_vec.len(), 2);
|
|
assert_eq!(result_struct.nested_vec[0], SampleStruct { value: 1, name: "n1".to_string() });
|
|
assert_eq!(result_struct.nested_vec[1], SampleStruct { value: 2, name: "n2".to_string() });
|
|
assert_eq!(result_struct.optional_nested_vec.as_ref().unwrap().len(), 1);
|
|
assert_eq!(result_struct.optional_nested_vec.as_ref().unwrap()[0], SampleStruct { value: 3, name: "n3".to_string() });
|
|
}
|
|
}
|