From e75d91e9bf6514f4c47229944fc9d0eae2db372b Mon Sep 17 00:00:00 2001 From: Stephen Chung Date: Sun, 16 Aug 2020 23:41:59 +0800 Subject: [PATCH] Bring more functions into modules in plugins via rhai_fn(name) attribute. --- codegen/src/lib.rs | 2 +- src/packages/array_basic.rs | 44 ++++------ src/packages/eval.rs | 8 +- src/packages/fn_basic.rs | 10 +-- src/packages/map_basic.rs | 50 +++++------ src/packages/string_more.rs | 153 ++++++++++++++------------------- src/packages/time_basic.rs | 166 +++++++++++++++++------------------- tests/plugins.rs | 12 ++- tests/time.rs | 9 ++ 9 files changed, 210 insertions(+), 244 deletions(-) diff --git a/codegen/src/lib.rs b/codegen/src/lib.rs index 6f25be9a..9675ac66 100644 --- a/codegen/src/lib.rs +++ b/codegen/src/lib.rs @@ -93,7 +93,7 @@ //! ``` //! -use quote::{quote, ToTokens}; +use quote::quote; use syn::parse_macro_input; mod function; diff --git a/src/packages/array_basic.rs b/src/packages/array_basic.rs index fc44c4c5..fee7ae4d 100644 --- a/src/packages/array_basic.rs +++ b/src/packages/array_basic.rs @@ -11,9 +11,6 @@ use crate::plugin::*; #[cfg(not(feature = "unchecked"))] use crate::{result::EvalAltResult, token::Position}; -#[cfg(not(feature = "no_object"))] -use crate::engine::make_getter; - use crate::stdlib::{any::TypeId, boxed::Box}; #[cfg(not(feature = "unchecked"))] @@ -61,8 +58,9 @@ macro_rules! reg_pad { def_package!(crate:BasicArrayPackage:"Basic array utilities.", lib, { lib.combine(exported_module!(array_functions)); - set_exported_fn!(lib, "+", append); - set_exported_fn!(lib, "+", concat); + + #[cfg(not(feature = "no_object"))] + lib.combine(exported_module!(object_functions)); reg_functions!(lib += basic; INT, bool, char, ImmutableString, FnPtr, Array, Unit); reg_pad!(lib, INT, bool, char, ImmutableString, FnPtr, Array, Unit); @@ -86,9 +84,6 @@ def_package!(crate:BasicArrayPackage:"Basic array utilities.", lib, { reg_pad!(lib, f32, f64); } - #[cfg(not(feature = "no_object"))] - set_exported_fn!(lib, make_getter("len"), array_funcs::len); - // Register array iterator lib.set_iter( TypeId::of::(), @@ -96,24 +91,23 @@ def_package!(crate:BasicArrayPackage:"Basic array utilities.", lib, { ); }); -#[export_fn] -fn append(x: &mut Array, y: Array) { - x.extend(y); -} -#[export_fn] -fn concat(mut x: Array, y: Array) -> Array { - x.extend(y); - x -} - #[export_module] mod array_functions { pub fn len(list: &mut Array) -> INT { - array_funcs::len(list) + list.len() as INT } pub fn append(x: &mut Array, y: Array) { x.extend(y); } + #[rhai_fn(name = "+=")] + pub fn append_operator(x: &mut Array, y: Array) { + append(x, y) + } + #[rhai_fn(name = "+")] + pub fn concat(mut x: Array, y: Array) -> Array { + x.extend(y); + x + } pub fn pop(list: &mut Array) -> Dynamic { list.pop().unwrap_or_else(|| ().into()) } @@ -143,14 +137,12 @@ mod array_functions { } } -mod array_funcs { - use crate::engine::Array; - use crate::parser::INT; - use crate::plugin::*; - - #[export_fn] +#[cfg(not(feature = "no_object"))] +#[export_module] +mod object_functions { + #[rhai_fn(name = "get$len")] pub fn len(list: &mut Array) -> INT { - list.len() as INT + array_functions::len(list) } } diff --git a/src/packages/eval.rs b/src/packages/eval.rs index 6b2b9aa9..0e2187da 100644 --- a/src/packages/eval.rs +++ b/src/packages/eval.rs @@ -4,11 +4,11 @@ use crate::parser::ImmutableString; use crate::plugin::*; use crate::result::EvalAltResult; +def_package!(crate:EvalPackage:"Disable 'eval'.", lib, { + set_exported_fn!(lib, "eval", eval_override); +}); + #[export_fn(return_raw)] fn eval_override(_script: ImmutableString) -> Result> { Err("eval is evil!".into()) } - -def_package!(crate:EvalPackage:"Disable 'eval'.", lib, { - set_exported_fn!(lib, "eval", eval_override); -}); diff --git a/src/packages/fn_basic.rs b/src/packages/fn_basic.rs index e34cb918..7523b7f6 100644 --- a/src/packages/fn_basic.rs +++ b/src/packages/fn_basic.rs @@ -5,14 +5,14 @@ use crate::plugin::*; #[cfg(not(feature = "no_object"))] use crate::engine::make_getter; -#[export_fn] -fn get_fn_name(f: &mut FnPtr) -> ImmutableString { - f.get_fn_name().clone() -} - def_package!(crate:BasicFnPackage:"Basic Fn functions.", lib, { set_exported_fn!(lib, "name", get_fn_name); #[cfg(not(feature = "no_object"))] set_exported_fn!(lib, make_getter("name"), get_fn_name); }); + +#[export_fn] +fn get_fn_name(f: &mut FnPtr) -> ImmutableString { + f.get_fn_name().clone() +} diff --git a/src/packages/map_basic.rs b/src/packages/map_basic.rs index bb2f4f09..9c9f080d 100644 --- a/src/packages/map_basic.rs +++ b/src/packages/map_basic.rs @@ -2,7 +2,7 @@ use crate::any::Dynamic; use crate::def_package; -use crate::engine::{make_getter, Map}; +use crate::engine::Map; use crate::parser::{ImmutableString, INT}; use crate::plugin::*; @@ -10,9 +10,6 @@ use crate::stdlib::vec::Vec; def_package!(crate:BasicMapPackage:"Basic object map utilities.", lib, { lib.combine(exported_module!(map_functions)); - set_exported_fn!(lib, make_getter("len"), map_funcs::len); - set_exported_fn!(lib, "+=", map_funcs::mixin); - set_exported_fn!(lib, "+", map_funcs::merge); // Register map access functions #[cfg(not(feature = "no_index"))] @@ -25,7 +22,11 @@ mod map_functions { map.contains_key(&prop) } pub fn len(map: &mut Map) -> INT { - map_funcs::len(map) + map.len() as INT + } + #[rhai_fn(name = "get$len")] + pub fn len_prop(map: &mut Map) -> INT { + len(map) } pub fn clear(map: &mut Map) { map.clear(); @@ -34,7 +35,20 @@ mod map_functions { x.remove(&name).unwrap_or_else(|| ().into()) } pub fn mixin(map1: &mut Map, map2: Map) { - map_funcs::mixin(map1, map2); + map2.into_iter().for_each(|(key, value)| { + map1.insert(key, value); + }); + } + #[rhai_fn(name = "+=")] + pub fn mixin_operator(map1: &mut Map, map2: Map) { + mixin(map1, map2) + } + #[rhai_fn(name = "+")] + pub fn merge(mut map1: Map, map2: Map) -> Map { + map2.into_iter().for_each(|(key, value)| { + map1.insert(key, value); + }); + map1 } pub fn fill_with(map1: &mut Map, map2: Map) { map2.into_iter().for_each(|(key, value)| { @@ -45,30 +59,6 @@ mod map_functions { } } -mod map_funcs { - use crate::engine::Map; - use crate::parser::INT; - use crate::plugin::*; - - #[export_fn] - pub fn len(map: &mut Map) -> INT { - map.len() as INT - } - #[export_fn] - pub fn mixin(map1: &mut Map, map2: Map) { - map2.into_iter().for_each(|(key, value)| { - map1.insert(key, value); - }); - } - #[export_fn] - pub fn merge(mut map1: Map, map2: Map) -> Map { - map2.into_iter().for_each(|(key, value)| { - map1.insert(key, value); - }); - map1 - } -} - #[cfg(not(feature = "no_index"))] #[export_module] mod index_functions { diff --git a/src/packages/string_more.rs b/src/packages/string_more.rs index ded48378..c9efcffe 100644 --- a/src/packages/string_more.rs +++ b/src/packages/string_more.rs @@ -11,9 +11,6 @@ use crate::utils::StaticVec; #[cfg(not(feature = "unchecked"))] use crate::{result::EvalAltResult, token::Position}; -#[cfg(not(feature = "no_object"))] -use crate::engine::make_getter; - use crate::stdlib::{ any::TypeId, boxed::Box, fmt::Display, format, mem, string::String, string::ToString, vec::Vec, }; @@ -61,29 +58,12 @@ def_package!(crate:MoreStringPackage:"Additional string utilities, including str reg_functions!(lib += float; f32, f64); #[cfg(not(feature = "no_index"))] - { - set_exported_fn!(lib, "+", string_funcs_array::append_array); - set_exported_fn!(lib, "+", string_funcs_array::prepend_array); - } + lib.combine(exported_module!(index_functions)); + + #[cfg(not(feature = "no_object"))] + lib.combine(exported_module!(object_functions)); lib.combine(exported_module!(string_functions)); - set_exported_fn!(lib, "contains", string_funcs::contains_char); - set_exported_fn!(lib, "contains", string_funcs::contains_string); - set_exported_fn!(lib, "index_of", string_funcs::index_of_char); - set_exported_fn!(lib, "index_of", string_funcs::index_of_char_starting_from); - set_exported_fn!(lib, "index_of", string_funcs::index_of_string); - set_exported_fn!(lib, "index_of", string_funcs::index_of_string_starting_from); - set_exported_fn!(lib, "append", string_funcs::append_char); - set_exported_fn!(lib, "+=", string_funcs::append_char); - set_exported_fn!(lib, "append", string_funcs::append_string); - set_exported_fn!(lib, "sub_string", string_funcs::sub_string); - set_exported_fn!(lib, "sub_string", string_funcs::sub_string_starting_from); - set_exported_fn!(lib, "crop", string_funcs::crop_string); - set_exported_fn!(lib, "crop", string_funcs::crop_string_starting_from); - set_exported_fn!(lib, "replace", string_funcs::replace_string); - set_exported_fn!(lib, "replace", string_funcs::replace_char); - set_exported_fn!(lib, "replace", string_funcs::replace_string_with_char); - set_exported_fn!(lib, "replace", string_funcs::replace_char_with_string); lib.set_raw_fn( "pad", @@ -131,9 +111,6 @@ def_package!(crate:MoreStringPackage:"Additional string utilities, including str }, ); - #[cfg(not(feature = "no_object"))] - set_exported_fn!(lib, make_getter("len"), string_funcs::len); - // Register string iterator lib.set_iter( TypeId::of::(), @@ -166,9 +143,27 @@ gen_concat_functions!(float => f32, f64); #[export_module] mod string_functions { - pub fn len(s: &mut ImmutableString) -> INT { - string_funcs::len(s) + #[rhai_fn(name = "+")] + pub fn append_unit(s: ImmutableString, _x: ()) -> ImmutableString { + s } + #[rhai_fn(name = "+")] + pub fn prepend_unit(_x: (), s: ImmutableString) -> ImmutableString { + s + } + #[rhai_fn(name = "+")] + pub fn append_char(s: &mut ImmutableString, ch: char) { + *s += ch; + } + #[rhai_fn(name = "+")] + pub fn append_string(s: &mut ImmutableString, add: ImmutableString) { + *s += &add; + } + + pub fn len(s: &mut ImmutableString) -> INT { + s.chars().count() as INT + } + pub fn clear(s: &mut ImmutableString) { s.make_mut().clear(); } @@ -189,52 +184,17 @@ mod string_functions { *s = trimmed.to_string().into(); } } -} -#[cfg(not(feature = "no_index"))] -mod string_funcs_array { - use crate::engine::Array; - use crate::plugin::*; - use crate::stdlib::string::String; - use crate::utils::ImmutableString; - - #[export_fn] - pub fn append_array(x: &mut ImmutableString, y: Array) -> String { - format!("{}{:?}", x, y) - } - #[export_fn] - pub fn prepend_array(x: &mut Array, y: ImmutableString) -> String { - format!("{:?}{}", x, y) - } -} - -mod string_funcs { - use crate::parser::INT; - use crate::plugin::*; - use crate::stdlib::string::{String, ToString}; - use crate::utils::{ImmutableString, StaticVec}; - - #[export_fn] - pub fn append_unit(s: ImmutableString, _x: ()) -> ImmutableString { - s - } - #[export_fn] - pub fn prepend_unit(_x: (), s: ImmutableString) -> ImmutableString { - s - } - #[export_fn] - pub fn len(s: &mut ImmutableString) -> INT { - s.chars().count() as INT - } - #[export_fn] + #[rhai_fn(name = "contains")] pub fn contains_char(s: &mut ImmutableString, ch: char) -> bool { s.contains(ch) } - #[export_fn] + #[rhai_fn(name = "contains")] pub fn contains_string(s: &mut ImmutableString, find: ImmutableString) -> bool { s.contains(find.as_str()) } - #[export_fn] + + #[rhai_fn(name = "index_of")] pub fn index_of_char_starting_from(s: &mut ImmutableString, ch: char, start: INT) -> INT { let start = if start < 0 { 0 @@ -249,13 +209,13 @@ mod string_funcs { .map(|index| s[0..start + index].chars().count() as INT) .unwrap_or(-1 as INT) } - #[export_fn] + #[rhai_fn(name = "index_of")] pub fn index_of_char(s: &mut ImmutableString, ch: char) -> INT { s.find(ch) .map(|index| s[0..index].chars().count() as INT) .unwrap_or(-1 as INT) } - #[export_fn] + #[rhai_fn(name = "index_of")] pub fn index_of_string_starting_from( s: &mut ImmutableString, find: ImmutableString, @@ -274,21 +234,14 @@ mod string_funcs { .map(|index| s[0..start + index].chars().count() as INT) .unwrap_or(-1 as INT) } - #[export_fn] + #[rhai_fn(name = "index_of")] pub fn index_of_string(s: &mut ImmutableString, find: ImmutableString) -> INT { s.find(find.as_str()) .map(|index| s[0..index].chars().count() as INT) .unwrap_or(-1 as INT) } - #[export_fn] - pub fn append_char(s: &mut ImmutableString, ch: char) { - *s += ch; - } - #[export_fn] - pub fn append_string(s: &mut ImmutableString, add: ImmutableString) { - *s += &add; - } - #[export_fn] + + #[rhai_fn(name = "sub_string")] pub fn sub_string(s: ImmutableString, start: INT, len: INT) -> ImmutableString { let offset = if s.is_empty() || len <= 0 { return "".to_string().into(); @@ -316,12 +269,13 @@ mod string_funcs { .collect::() .into() } - #[export_fn] + #[rhai_fn(name = "sub_string")] pub fn sub_string_starting_from(s: ImmutableString, start: INT) -> ImmutableString { let len = s.len() as INT; sub_string(s, start, len) } - #[export_fn] + + #[rhai_fn(name = "crop")] fn crop_string(s: &mut ImmutableString, start: INT, len: INT) { let offset = if s.is_empty() || len <= 0 { s.make_mut().clear(); @@ -347,24 +301,49 @@ mod string_funcs { copy.clear(); copy.extend(chars.iter().skip(offset).take(len)); } - #[export_fn] + #[rhai_fn(name = "crop")] pub fn crop_string_starting_from(s: &mut ImmutableString, start: INT) { crop_string(s, start, s.len() as INT); } - #[export_fn] + + #[rhai_fn(name = "replace")] pub fn replace_string(s: &mut ImmutableString, find: ImmutableString, sub: ImmutableString) { *s = s.replace(find.as_str(), sub.as_str()).into(); } - #[export_fn] + #[rhai_fn(name = "replace")] pub fn replace_string_with_char(s: &mut ImmutableString, find: ImmutableString, sub: char) { *s = s.replace(find.as_str(), &sub.to_string()).into(); } - #[export_fn] + #[rhai_fn(name = "replace")] pub fn replace_char_with_string(s: &mut ImmutableString, find: char, sub: ImmutableString) { *s = s.replace(&find.to_string(), sub.as_str()).into(); } - #[export_fn] + #[rhai_fn(name = "replace")] pub fn replace_char(s: &mut ImmutableString, find: char, sub: char) { *s = s.replace(&find.to_string(), &sub.to_string()).into(); } } + +#[cfg(not(feature = "no_index"))] +#[export_module] +mod index_functions { + use crate::engine::Array; + + #[rhai_fn(name = "+")] + pub fn append(x: &mut ImmutableString, y: Array) -> String { + format!("{}{:?}", x, y) + } + #[rhai_fn(name = "+")] + pub fn prepend(x: &mut Array, y: ImmutableString) -> String { + format!("{:?}{}", x, y) + } +} + +#[cfg(not(feature = "no_object"))] +#[export_module] +mod object_functions { + #[rhai_fn(name = "get$len")] + pub fn len(s: &mut ImmutableString) -> INT { + string_functions::len(s) + } +} diff --git a/src/packages/time_basic.rs b/src/packages/time_basic.rs index 55315cee..a55471ee 100644 --- a/src/packages/time_basic.rs +++ b/src/packages/time_basic.rs @@ -18,9 +18,6 @@ use crate::parser::INT; #[cfg(not(feature = "unchecked"))] use crate::token::Position; -#[cfg(not(feature = "no_object"))] -use crate::engine::make_getter; - #[cfg(not(target_arch = "wasm32"))] use crate::stdlib::time::Instant; @@ -29,111 +26,104 @@ use instant::Instant; def_package!(crate:BasicTimePackage:"Basic timing utilities.", lib, { // Register date/time functions - set_exported_fn!(lib, "timestamp", create_timestamp); - set_exported_fn!(lib, "elapsed", elapsed); + lib.combine(exported_module!(time_functions)); #[cfg(not(feature = "no_object"))] - set_exported_fn!(lib, make_getter("elapsed"), elapsed); - - set_exported_fn!(lib, "-", time_diff); - - //lib.combine(exported_module!(time_compare)); - - lib.set_fn_2("<", |x:Instant, y:Instant| Ok(x < y)); - lib.set_fn_2("<=", |x:Instant, y:Instant| Ok(x <= y)); - lib.set_fn_2(">", |x:Instant, y:Instant| Ok(x > y)); - lib.set_fn_2(">=", |x:Instant, y:Instant| Ok(x >= y)); - lib.set_fn_2("==", |x:Instant, y:Instant| Ok(x == y)); - lib.set_fn_2("!=", |x:Instant, y:Instant| Ok(x != y)); + lib.set_getter_fn("elapsed", time_functions::elapsed); }); -#[export_fn] -fn create_timestamp() -> Instant { - Instant::now() -} - -#[cfg(not(feature = "no_float"))] -#[export_fn] -fn elapsed(timestamp: &mut Instant) -> FLOAT { - timestamp.elapsed().as_secs_f64() as FLOAT -} - -#[cfg(feature = "no_float")] -#[export_fn(return_raw)] -fn elapsed(timestamp: &mut Instant) -> Result> { - let seconds = timestamp.elapsed().as_secs(); - - #[cfg(not(feature = "unchecked"))] - if seconds > (MAX_INT as u64) { - return EvalAltResult::ErrorArithmetic( - format!("Integer overflow for timestamp.elapsed: {}", seconds), - Position::none(), - ) - .into(); - } - - Ok((seconds as INT).into()) -} - -#[cfg(not(feature = "no_float"))] -#[export_fn] -fn time_diff(ts1: Instant, ts2: Instant) -> FLOAT { - if ts2 > ts1 { - -(ts2 - ts1).as_secs_f64() as FLOAT - } else { - (ts1 - ts2).as_secs_f64() as FLOAT - } -} - -#[cfg(feature = "no_float")] -#[export_fn(return_raw)] -fn time_diff(ts1: Instant, ts2: Instant) -> Result> { - if ts2 > ts1 { - let seconds = (ts2 - ts1).as_secs(); - - #[cfg(not(feature = "unchecked"))] - if seconds > (MAX_INT as u64) { - return EvalAltResult::ErrorArithmetic( - format!("Integer overflow for timestamp duration: -{}", seconds), - Position::none(), - ) - .into(); - } - - Ok(Dynamic::from(-(seconds as INT))) - } else { - let seconds = (ts1 - ts2).as_secs(); - - #[cfg(not(feature = "unchecked"))] - if seconds > (MAX_INT as u64) { - return EvalAltResult::ErrorArithmetic( - format!("Integer overflow for timestamp duration: {}", seconds), - Position::none(), - ) - .into(); - } - - Ok((seconds as INT).into()) - } -} - #[export_module] -mod time_compare { +mod time_functions { + pub fn timestamp() -> Instant { + Instant::now() + } + #[rhai_fn(return_raw)] + pub fn elapsed(timestamp: &mut Instant) -> Result> { + #[cfg(not(feature = "no_float"))] + { + Ok((timestamp.elapsed().as_secs_f64() as FLOAT).into()) + } + + #[cfg(feature = "no_float")] + { + let seconds = timestamp.elapsed().as_secs(); + + #[cfg(not(feature = "unchecked"))] + if seconds > (MAX_INT as u64) { + return EvalAltResult::ErrorArithmetic( + format!("Integer overflow for timestamp.elapsed: {}", seconds), + Position::none(), + ) + .into(); + } + + Ok((seconds as INT).into()) + } + } + + #[rhai_fn(return_raw, name = "-")] + fn time_diff(ts1: Instant, ts2: Instant) -> Result> { + #[cfg(not(feature = "no_float"))] + { + Ok(if ts2 > ts1 { + -(ts2 - ts1).as_secs_f64() as FLOAT + } else { + (ts1 - ts2).as_secs_f64() as FLOAT + } + .into()) + } + + #[cfg(feature = "no_float")] + if ts2 > ts1 { + let seconds = (ts2 - ts1).as_secs(); + + #[cfg(not(feature = "unchecked"))] + if seconds > (MAX_INT as u64) { + return EvalAltResult::ErrorArithmetic( + format!("Integer overflow for timestamp duration: -{}", seconds), + Position::none(), + ) + .into(); + } + + Ok(Dynamic::from(-(seconds as INT))) + } else { + let seconds = (ts1 - ts2).as_secs(); + + #[cfg(not(feature = "unchecked"))] + if seconds > (MAX_INT as u64) { + return EvalAltResult::ErrorArithmetic( + format!("Integer overflow for timestamp duration: {}", seconds), + Position::none(), + ) + .into(); + } + + Ok((seconds as INT).into()) + } + } + + #[rhai_fn(name = "==")] pub fn eq(x: Instant, y: Instant) -> bool { x == y } + #[rhai_fn(name = "!=")] pub fn ne(x: Instant, y: Instant) -> bool { x != y } + #[rhai_fn(name = "<")] pub fn lt(x: Instant, y: Instant) -> bool { x < y } + #[rhai_fn(name = "<=")] pub fn lte(x: Instant, y: Instant) -> bool { x <= y } + #[rhai_fn(name = ">")] pub fn gt(x: Instant, y: Instant) -> bool { x > y } + #[rhai_fn(name = ">=")] pub fn gte(x: Instant, y: Instant) -> bool { x >= y } diff --git a/tests/plugins.rs b/tests/plugins.rs index b6399ced..3379b411 100644 --- a/tests/plugins.rs +++ b/tests/plugins.rs @@ -7,9 +7,14 @@ use rhai::{Engine, EvalAltResult, INT}; mod special_array_package { use rhai::{Array, INT}; + #[rhai_fn(name = "test")] pub fn len(array: &mut Array, mul: INT) -> INT { (array.len() as INT) * mul } + #[rhai_fn(name = "+")] + pub fn funky_add(x: INT, y: INT) -> INT { + x / 2 + y * 2 + } } macro_rules! gen_unary_functions { @@ -18,7 +23,7 @@ macro_rules! gen_unary_functions { pub mod $arg_type { use super::super::*; - #[export_fn] + #[export_fn(name="test")] pub fn single(x: $arg_type) -> $return_type { super::super::$op_fn(x) } @@ -48,9 +53,10 @@ fn test_plugins_package() -> Result<(), Box> { reg_functions!(engine += greet::single(INT, bool, char)); - assert_eq!(engine.eval::("let a = [1, 2, 3]; len(a, 2)")?, 6); + assert_eq!(engine.eval::("let a = [1, 2, 3]; test(a, 2)")?, 6); + assert_eq!(engine.eval::("2 + 2")?, 5); assert_eq!( - engine.eval::("let a = [1, 2, 3]; greet(len(a, 2))")?, + engine.eval::("let a = [1, 2, 3]; greet(test(a, 2))")?, "6 kitties" ); diff --git a/tests/time.rs b/tests/time.rs index b3f6668f..ad7fc4c9 100644 --- a/tests/time.rs +++ b/tests/time.rs @@ -39,5 +39,14 @@ fn test_timestamp() -> Result<(), Box> { )? < 10 ); + assert!(engine.eval::( + r" + let time1 = timestamp(); + for x in range(0, 10000) {} + let time2 = timestamp(); + time1 <= time2 + " + )?); + Ok(()) }