rhai/tests/call_fn.rs

361 lines
9.4 KiB
Rust
Raw Normal View History

#![cfg(not(feature = "no_function"))]
use rhai::{CallFnOptions, Dynamic, Engine, EvalAltResult, FnPtr, Func, FuncArgs, Scope, AST, INT};
2022-06-11 10:01:15 +02:00
use std::any::TypeId;
2020-03-04 15:00:01 +01:00
#[test]
fn test_call_fn() -> Result<(), Box<EvalAltResult>> {
let engine = Engine::new();
let mut scope = Scope::new();
scope.push("foo", 42 as INT);
2020-03-04 15:00:01 +01:00
let ast = engine.compile(
2021-04-20 06:01:35 +02:00
"
fn hello(x, y) {
x + y
}
fn hello(x) {
2020-07-06 10:20:03 +02:00
x *= foo;
2020-04-05 06:57:20 +02:00
foo = 1;
x
}
fn hello() {
2020-04-05 06:57:20 +02:00
41 + foo
}
fn define_var(scale) {
let bar = 21;
bar * scale
}
",
)?;
2020-03-04 15:00:01 +01:00
2022-08-12 16:48:15 +02:00
let r = engine.call_fn::<INT>(&mut scope, &ast, "hello", (42 as INT, 123 as INT))?;
assert_eq!(r, 165);
2020-03-04 15:00:01 +01:00
2022-08-12 16:48:15 +02:00
let r = engine.call_fn::<INT>(&mut scope, &ast, "hello", (123 as INT,))?;
assert_eq!(r, 5166);
2020-03-04 15:00:01 +01:00
2022-08-12 16:48:15 +02:00
let r = engine.call_fn::<INT>(&mut scope, &ast, "hello", ())?;
2020-04-05 06:57:20 +02:00
assert_eq!(r, 42);
assert_eq!(
scope
.get_value::<INT>("foo")
.expect("variable foo should exist"),
1
);
2022-08-12 16:48:15 +02:00
let r = engine.call_fn::<INT>(&mut scope, &ast, "define_var", (2 as INT,))?;
assert_eq!(r, 42);
assert!(!scope.contains("bar"));
let options = CallFnOptions::new().eval_ast(false).rewind_scope(false);
let r =
engine.call_fn_with_options::<INT>(options, &mut scope, &ast, "define_var", (2 as INT,))?;
assert_eq!(r, 42);
2020-04-05 06:57:20 +02:00
assert_eq!(
scope
.get_value::<INT>("bar")
.expect("variable bar should exist"),
21
2020-04-05 06:57:20 +02:00
);
assert!(!scope.contains("scale"));
2020-03-04 15:00:01 +01:00
Ok(())
}
2021-12-19 16:22:14 +01:00
#[test]
fn test_call_fn_scope() -> Result<(), Box<EvalAltResult>> {
let engine = Engine::new();
let mut scope = Scope::new();
let ast = engine.compile(
"
fn foo(x) {
let hello = 42;
bar + hello + x
}
let bar = 123;
",
)?;
for _ in 0..50 {
assert_eq!(
engine.call_fn_with_options::<INT>(
CallFnOptions::new().rewind_scope(false),
&mut scope,
&ast,
"foo",
[Dynamic::THREE],
)?,
2021-12-19 16:22:14 +01:00
168
);
}
assert_eq!(scope.len(), 100);
Ok(())
}
2021-01-28 08:29:55 +01:00
struct Options {
pub foo: bool,
pub bar: String,
pub baz: INT,
}
impl FuncArgs for Options {
fn parse<C: Extend<Dynamic>>(self, container: &mut C) {
2022-06-11 10:01:15 +02:00
container.extend(Some(self.foo.into()));
container.extend(Some(self.bar.into()));
container.extend(Some(self.baz.into()));
2021-01-28 08:29:55 +01:00
}
}
#[test]
fn test_call_fn_args() -> Result<(), Box<EvalAltResult>> {
let options = Options {
foo: false,
bar: "world".to_string(),
baz: 42,
};
let engine = Engine::new();
let mut scope = Scope::new();
let ast = engine.compile(
2021-06-05 09:26:43 +02:00
"
2021-01-28 08:29:55 +01:00
fn hello(x, y, z) {
2021-04-04 17:22:45 +02:00
if x { `hello ${y}` } else { y + z }
2021-01-28 08:29:55 +01:00
}
2021-06-05 09:26:43 +02:00
",
2021-01-28 08:29:55 +01:00
)?;
2022-08-12 16:48:15 +02:00
let result = engine.call_fn::<String>(&mut scope, &ast, "hello", options)?;
2021-01-28 08:29:55 +01:00
assert_eq!(result, "world42");
Ok(())
}
2020-05-13 07:49:01 +02:00
#[test]
fn test_call_fn_private() -> Result<(), Box<EvalAltResult>> {
let engine = Engine::new();
let mut scope = Scope::new();
let ast = engine.compile("fn add(x, n) { x + n }")?;
2022-08-12 16:48:15 +02:00
let r = engine.call_fn::<INT>(&mut scope, &ast, "add", (40 as INT, 2 as INT))?;
2020-05-13 07:49:01 +02:00
assert_eq!(r, 42);
2020-06-16 16:14:46 +02:00
let ast = engine.compile("private fn add(x, n, ) { x + n }")?;
2020-05-13 07:49:01 +02:00
2022-08-12 16:48:15 +02:00
let r = engine.call_fn::<INT>(&mut scope, &ast, "add", (40 as INT, 2 as INT))?;
2021-03-01 08:39:49 +01:00
assert_eq!(r, 42);
2020-05-13 07:49:01 +02:00
Ok(())
}
2020-07-05 17:08:44 +02:00
#[test]
2020-07-13 13:38:50 +02:00
#[cfg(not(feature = "no_object"))]
fn test_fn_ptr_raw() -> Result<(), Box<EvalAltResult>> {
2020-07-05 17:08:44 +02:00
let mut engine = Engine::new();
engine
.register_fn("mul", |x: &mut INT, y: INT| *x *= y)
.register_raw_fn(
"bar",
&[
TypeId::of::<INT>(),
TypeId::of::<FnPtr>(),
TypeId::of::<INT>(),
],
move |context, args| {
let fp = std::mem::take(args[1]).cast::<FnPtr>();
let value = args[2].clone();
let this_ptr = args.get_mut(0).unwrap();
2021-11-29 05:43:59 +01:00
fp.call_raw(&context, Some(this_ptr), [value])
},
);
2020-07-05 17:08:44 +02:00
assert_eq!(
engine.eval::<INT>(
r#"
fn foo(x) { this += x; }
let x = 41;
2022-08-05 17:30:44 +02:00
x.bar(foo, 1);
x
"#
)?,
42
);
2020-07-05 17:08:44 +02:00
2020-08-22 16:44:24 +02:00
assert_eq!(
engine.eval::<INT>(
r#"
fn foo(x, y) { this += x + y; }
let x = 40;
let v = 1;
x.bar(Fn("foo").curry(v), 1);
x
"#
)?,
42
);
2021-03-01 08:39:49 +01:00
assert_eq!(
engine.eval::<INT>(
r#"
private fn foo(x) { this += x; }
let x = 41;
x.bar(Fn("foo"), 1);
x
"#
2021-03-01 08:39:49 +01:00
)?,
42
);
assert_eq!(
engine.eval::<INT>(
r#"
let x = 21;
x.bar(Fn("mul"), 2);
x
"#
)?,
42
);
2020-07-05 17:08:44 +02:00
Ok(())
}
#[test]
2020-07-29 16:43:57 +02:00
fn test_anonymous_fn() -> Result<(), Box<EvalAltResult>> {
let calc_func = Func::<(INT, INT, INT), INT>::create_from_script(
Engine::new(),
"fn calc(x, y, z,) { (x + y) * z }",
"calc",
)?;
2020-07-29 16:43:57 +02:00
assert_eq!(calc_func(42, 123, 9)?, 1485);
2020-07-29 16:43:57 +02:00
let calc_func = Func::<(INT, String, INT), INT>::create_from_script(
Engine::new(),
"fn calc(x, y, z) { (x + len(y)) * z }",
"calc",
)?;
2020-07-29 16:43:57 +02:00
assert_eq!(calc_func(42, "hello".to_string(), 9)?, 423);
2021-03-01 08:39:49 +01:00
let calc_func = Func::<(INT, String, INT), INT>::create_from_script(
2020-07-29 16:43:57 +02:00
Engine::new(),
2021-03-01 08:39:49 +01:00
"private fn calc(x, y, z) { (x + len(y)) * z }",
2020-07-29 16:43:57 +02:00
"calc",
)?;
2021-03-01 08:39:49 +01:00
assert_eq!(calc_func(42, "hello".to_string(), 9)?, 423);
2021-03-17 15:32:22 +01:00
let calc_func = Func::<(INT, &str, INT), INT>::create_from_script(
Engine::new(),
"fn calc(x, y, z) { (x + len(y)) * z }",
"calc",
)?;
assert_eq!(calc_func(42, "hello", 9)?, 423);
Ok(())
}
2021-10-16 07:59:12 +02:00
#[test]
fn test_call_fn_events() -> Result<(), Box<EvalAltResult>> {
// Event handler
struct Handler {
// Scripting engine
pub engine: Engine,
// Use a custom 'Scope' to keep stored state
pub scope: Scope<'static>,
// Program script
pub ast: AST,
}
const SCRIPT: &str = r#"
fn start(data) { 42 + data }
fn end(data) { 0 }
"#;
impl Handler {
pub fn new() -> Self {
let engine = Engine::new();
// Create a custom 'Scope' to hold state
let mut scope = Scope::new();
// Add initialized state into the custom 'Scope'
scope.push("state", false);
// Compile the handler script.
let ast = engine.compile(SCRIPT).unwrap();
// Evaluate the script to initialize it and other state variables.
// In a real application you'd again be handling errors...
engine.run_ast_with_scope(&mut scope, &ast).unwrap();
// The event handler is essentially these three items:
Handler { engine, scope, ast }
}
// Say there are three events: 'start', 'end', 'update'.
// In a real application you'd be handling errors...
pub fn on_event(&mut self, event_name: &str, event_data: INT) -> Dynamic {
let engine = &self.engine;
let scope = &mut self.scope;
let ast = &self.ast;
match event_name {
// The 'start' event maps to function 'start'.
// In a real application you'd be handling errors...
"start" => engine.call_fn(scope, ast, "start", (event_data,)).unwrap(),
// The 'end' event maps to function 'end'.
// In a real application you'd be handling errors...
"end" => engine.call_fn(scope, ast, "end", (event_data,)).unwrap(),
// The 'update' event maps to function 'update'.
2021-12-17 09:07:13 +01:00
// This event provides a default implementation when the script-defined function is not found.
2021-10-16 07:59:12 +02:00
"update" => engine
.call_fn(scope, ast, "update", (event_data,))
.or_else(|err| match *err {
2022-02-08 02:02:15 +01:00
EvalAltResult::ErrorFunctionNotFound(fn_name, ..)
2021-10-16 07:59:12 +02:00
if fn_name.starts_with("update") =>
{
// Default implementation of 'update' event handler
self.scope.set_value("state", true);
// Turn function-not-found into a success
Ok(Dynamic::UNIT)
}
_ => Err(err),
})
.unwrap(),
// In a real application you'd be handling unknown events...
_ => panic!("unknown event: {}", event_name),
}
}
}
let mut handler = Handler::new();
assert!(!handler.scope.get_value::<bool>("state").unwrap());
2022-12-04 15:47:10 +01:00
let _ = handler.on_event("update", 999);
2021-10-16 07:59:12 +02:00
assert!(handler.scope.get_value::<bool>("state").unwrap());
assert_eq!(handler.on_event("start", 999).as_int().unwrap(), 1041);
Ok(())
}