rhai/tests/call_fn.rs

212 lines
5.2 KiB
Rust
Raw Normal View History

#![cfg(not(feature = "no_function"))]
2020-07-05 17:08:44 +02:00
use rhai::{
Dynamic, Engine, EvalAltResult, FnPtr, Func, Module, ParseError, ParseErrorType, RegisterFn,
Scope, INT,
2020-07-05 17:08:44 +02:00
};
use std::any::TypeId;
#[test]
fn test_fn() -> Result<(), Box<EvalAltResult>> {
2020-03-27 16:47:23 +01:00
let engine = Engine::new();
// Expect duplicated parameters error
assert!(matches!(
engine
.compile("fn hello(x, x) { x }")
.expect_err("should be error"),
ParseError(x, _) if *x == ParseErrorType::FnDuplicatedParam("hello".to_string(), "x".to_string())
));
Ok(())
}
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(
r"
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
}
",
)?;
2020-03-04 15:00:01 +01:00
2020-05-13 07:49:01 +02:00
let r: INT = engine.call_fn(&mut scope, &ast, "hello", (42 as INT, 123 as INT))?;
assert_eq!(r, 165);
2020-03-04 15:00:01 +01:00
2020-05-13 07:49:01 +02:00
let r: INT = engine.call_fn(&mut scope, &ast, "hello", (123 as INT,))?;
assert_eq!(r, 5166);
2020-03-04 15:00:01 +01:00
2020-05-13 07:49:01 +02:00
let r: INT = engine.call_fn(&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
);
2020-03-04 15:00:01 +01:00
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 }")?;
let r: INT = engine.call_fn(&mut scope, &ast, "add", (40 as INT, 2 as INT))?;
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
assert!(matches!(
*engine.call_fn::<_, INT>(&mut scope, &ast, "add", (40 as INT, 2 as INT))
.expect_err("should error"),
EvalAltResult::ErrorFunctionNotFound(fn_name, _) if fn_name == "add"
));
Ok(())
}
#[test]
fn test_anonymous_fn() -> Result<(), Box<EvalAltResult>> {
2020-04-09 04:38:33 +02:00
let calc_func = Func::<(INT, INT, INT), INT>::create_from_script(
Engine::new(),
2020-06-16 16:14:46 +02:00
"fn calc(x, y, z,) { (x + y) * z }",
"calc",
)?;
assert_eq!(calc_func(42, 123, 9)?, 1485);
let calc_func = Func::<(INT, String, INT), INT>::create_from_script(
Engine::new(),
"fn calc(x, y, z) { (x + len(y)) * z }",
"calc",
)?;
assert_eq!(calc_func(42, "hello".to_string(), 9)?, 423);
2020-05-13 07:49:01 +02:00
let calc_func = Func::<(INT, INT, INT), INT>::create_from_script(
Engine::new(),
"private fn calc(x, y, z) { (x + y) * z }",
"calc",
)?;
assert!(matches!(
*calc_func(42, 123, 9).expect_err("should error"),
EvalAltResult::ErrorFunctionNotFound(fn_name, _) if fn_name == "calc"
));
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 |engine: &Engine, lib: &Module, args: &mut [&mut Dynamic]| {
let fp = std::mem::take(args[1]).cast::<FnPtr>();
let value = args[2].clone();
let this_ptr = args.get_mut(0).unwrap();
fp.call_dynamic(engine, lib, 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;
2020-07-07 16:59:23 +02:00
x.bar(Fn("foo"), 1);
x
"#
)?,
42
);
2020-07-05 17:08:44 +02:00
assert!(matches!(
*engine.eval::<INT>(
r#"
private fn foo(x) { this += x; }
let x = 41;
x.bar(Fn("foo"), 1);
x
"#
).expect_err("should error"),
EvalAltResult::ErrorFunctionNotFound(x, _) if x.starts_with("foo (")
));
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-23 09:49:09 +02:00
fn test_fn_ptr_curry_call() -> Result<(), Box<EvalAltResult>> {
let mut module = Module::new();
module.set_raw_fn(
"call_with_arg",
&[TypeId::of::<FnPtr>(), TypeId::of::<INT>()],
2020-07-26 09:53:22 +02:00
|engine: &Engine, lib: &Module, args: &mut [&mut Dynamic]| {
2020-07-23 09:49:09 +02:00
let fn_ptr = std::mem::take(args[0]).cast::<FnPtr>();
2020-07-26 09:53:22 +02:00
fn_ptr.call_dynamic(engine, lib, None, [std::mem::take(args[1])])
},
);
let mut engine = Engine::new();
2020-07-23 09:49:09 +02:00
engine.load_package(module.into());
2020-07-23 09:49:09 +02:00
#[cfg(not(feature = "no_object"))]
assert_eq!(
engine.eval::<INT>(
r#"
let addition = |x, y| { x + y };
2020-07-23 09:49:09 +02:00
let curried = addition.curry(2);
2020-07-23 09:49:09 +02:00
call_with_arg(curried, 40)
"#
)?,
2020-07-23 09:49:09 +02:00
42
);
Ok(())
}