rhai/tests/functions.rs

262 lines
5.8 KiB
Rust
Raw Normal View History

2020-05-12 04:20:29 +02:00
#![cfg(not(feature = "no_function"))]
2021-03-15 14:30:45 +01:00
use rhai::{Engine, EvalAltResult, FnNamespace, Module, NativeCallContext, ParseErrorType, INT};
2020-05-12 04:20:29 +02:00
#[test]
fn test_functions() -> Result<(), Box<EvalAltResult>> {
let engine = Engine::new();
2020-05-13 07:49:01 +02:00
assert_eq!(engine.eval::<INT>("fn add(x, n) { x + n } add(40, 2)")?, 42);
2020-05-12 04:20:29 +02:00
2020-06-16 16:14:46 +02:00
assert_eq!(
engine.eval::<INT>("fn add(x, n,) { x + n } add(40, 2,)")?,
42
);
assert_eq!(
engine.eval::<INT>("fn add(x, n) { x + n } let a = 40; add(a, 2); a")?,
40
);
2020-05-12 04:20:29 +02:00
#[cfg(not(feature = "no_object"))]
assert_eq!(
2020-06-26 04:39:18 +02:00
engine.eval::<INT>("fn add(n) { this + n } let x = 40; x.add(2)")?,
2020-05-12 04:20:29 +02:00
42
);
#[cfg(not(feature = "no_object"))]
assert_eq!(
2020-06-26 04:39:18 +02:00
engine.eval::<INT>("fn add(n) { this += n; } let x = 40; x.add(2); x")?,
42
);
2020-05-13 07:49:01 +02:00
assert_eq!(engine.eval::<INT>("fn mul2(x) { x * 2 } mul2(21)")?, 42);
2020-05-12 04:20:29 +02:00
2020-06-26 04:39:18 +02:00
assert_eq!(
engine.eval::<INT>("fn mul2(x) { x *= 2 } let a = 21; mul2(a); a")?,
21
);
2020-05-12 04:20:29 +02:00
#[cfg(not(feature = "no_object"))]
assert_eq!(
2020-06-26 04:39:18 +02:00
engine.eval::<INT>("fn mul2() { this * 2 } let x = 21; x.mul2()")?,
2020-05-12 04:20:29 +02:00
42
);
#[cfg(not(feature = "no_object"))]
assert_eq!(
2020-06-26 04:39:18 +02:00
engine.eval::<INT>("fn mul2() { this *= 2; } let x = 21; x.mul2(); x")?,
42
);
2020-05-12 04:20:29 +02:00
Ok(())
}
2020-06-25 12:07:57 +02:00
2021-03-15 16:03:26 +01:00
#[cfg(not(feature = "no_module"))]
2021-03-17 08:26:37 +01:00
#[cfg(not(feature = "unchecked"))]
2021-03-15 14:30:45 +01:00
#[test]
fn test_functions_context() -> Result<(), Box<EvalAltResult>> {
let mut engine = Engine::new();
engine.set_max_modules(40);
engine.register_fn("test", |context: NativeCallContext, x: INT| {
context.engine().max_modules() as INT + x
});
assert_eq!(engine.eval::<INT>("test(2)")?, 42);
Ok(())
}
2021-01-28 08:29:55 +01:00
#[test]
fn test_functions_params() -> Result<(), Box<EvalAltResult>> {
let engine = Engine::new();
// Expect duplicated parameters error
assert_eq!(
*engine
.compile("fn hello(x, x) { x }")
.expect_err("should be error")
.0,
ParseErrorType::FnDuplicatedParam("hello".to_string(), "x".to_string())
);
Ok(())
}
2020-12-07 14:54:52 +01:00
#[test]
fn test_functions_namespaces() -> Result<(), Box<EvalAltResult>> {
let mut engine = Engine::new();
#[cfg(not(feature = "no_module"))]
{
let mut m = Module::new();
2021-03-15 05:39:06 +01:00
let hash = m.set_native_fn("test", || Ok(999 as INT));
2020-12-07 14:54:52 +01:00
m.update_fn_namespace(hash, FnNamespace::Global);
engine.register_static_module("hello", m.into());
2020-12-07 14:54:52 +01:00
assert_eq!(engine.eval::<INT>("test()")?, 999);
2021-03-15 14:30:45 +01:00
#[cfg(not(feature = "no_function"))]
2020-12-07 14:54:52 +01:00
assert_eq!(engine.eval::<INT>("fn test() { 123 } test()")?, 123);
}
engine.register_fn("test", || 42 as INT);
assert_eq!(engine.eval::<INT>("test()")?, 42);
2021-03-15 14:30:45 +01:00
#[cfg(not(feature = "no_function"))]
2020-12-07 14:54:52 +01:00
assert_eq!(engine.eval::<INT>("fn test() { 123 } test()")?, 123);
Ok(())
}
2020-06-25 12:07:57 +02:00
#[test]
fn test_function_pointers() -> Result<(), Box<EvalAltResult>> {
let engine = Engine::new();
assert_eq!(engine.eval::<String>(r#"type_of(Fn("abc"))"#)?, "Fn");
2020-07-16 06:09:31 +02:00
assert_eq!(
engine.eval::<INT>(
r#"
fn foo(x) { 40 + x }
let f = Fn("foo");
call(f, 2)
"#
)?,
42
);
#[cfg(not(feature = "no_object"))]
2020-06-25 12:07:57 +02:00
assert_eq!(
engine.eval::<INT>(
r#"
fn foo(x) { 40 + x }
let fn_name = "f";
fn_name += "oo";
let f = Fn(fn_name);
f.call(2)
"#
)?,
42
);
2020-07-16 06:09:31 +02:00
#[cfg(not(feature = "no_object"))]
2020-06-25 12:07:57 +02:00
assert!(matches!(
*engine.eval::<INT>(r#"let f = Fn("abc"); f.call(0)"#).expect_err("should error"),
EvalAltResult::ErrorFunctionNotFound(f, _) if f.starts_with("abc (")
));
2020-07-16 06:09:31 +02:00
#[cfg(not(feature = "no_object"))]
2020-06-25 12:07:57 +02:00
assert_eq!(
engine.eval::<INT>(
r#"
fn foo(x) { 40 + x }
let x = #{ action: Fn("foo") };
x.action.call(2)
"#
)?,
42
);
2020-07-24 17:16:54 +02:00
#[cfg(not(feature = "no_object"))]
assert_eq!(
engine.eval::<INT>(
r#"
fn foo(x) { this.data += x; }
let x = #{ data: 40, action: Fn("foo") };
x.action(2);
x.data
"#
)?,
42
);
2020-06-25 12:07:57 +02:00
Ok(())
}
2020-07-30 12:18:28 +02:00
#[test]
2020-08-03 06:10:20 +02:00
#[cfg(not(feature = "no_closure"))]
2020-07-30 12:18:28 +02:00
fn test_function_captures() -> Result<(), Box<EvalAltResult>> {
let engine = Engine::new();
assert_eq!(
engine.eval::<INT>(
r#"
fn foo(y) { x += y; x }
let x = 41;
let y = 999;
foo!(1) + x
"#
)?,
83
);
assert!(engine
.eval::<INT>(
r#"
fn foo(y) { x += y; x }
let x = 41;
let y = 999;
foo(1) + x
"#
)
.is_err());
#[cfg(not(feature = "no_object"))]
assert!(matches!(
2020-08-08 10:03:14 +02:00
*engine
.compile(
r#"
2020-10-22 06:26:44 +02:00
fn foo() { this += x; }
2020-07-30 12:18:28 +02:00
2020-10-22 06:26:44 +02:00
let x = 41;
let y = 999;
2020-07-30 12:18:28 +02:00
2020-10-22 06:26:44 +02:00
y.foo!();
"#
2020-08-08 10:03:14 +02:00
)
.expect_err("should error")
.0,
ParseErrorType::MalformedCapture(_)
2020-07-30 12:18:28 +02:00
));
Ok(())
}
2020-10-03 15:59:19 +02:00
#[test]
fn test_function_is_def() -> Result<(), Box<EvalAltResult>> {
let engine = Engine::new();
assert!(engine.eval::<bool>(
r#"
fn foo(x) { x + 1 }
is_def_fn("foo", 1)
"#
)?);
assert!(!engine.eval::<bool>(
r#"
fn foo(x) { x + 1 }
is_def_fn("bar", 1)
"#
)?);
assert!(!engine.eval::<bool>(
r#"
fn foo(x) { x + 1 }
is_def_fn("foo", 0)
"#
)?);
Ok(())
}