kjuulh/rhai
1
0
Fork 0
Code Issues 1 Pull Requests 1 Packages Projects Releases Wiki Activity

Make sure all tests run with all features.

Browse Source
This commit is contained in:
Stephen Chung 2020-03-10 19:48:47 +08:00
parent cc772c6e2a
commit e22aaca5c1
14 changed files with 71 additions and 38 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
.gitignore vendored
View File

@ -1,3 +1,4 @@
target/
Cargo.lock
.vscode/
.vscode/
.cargo/

20
README.md
View File

@ -43,8 +43,8 @@ Optional features
| `debug_msgs` | Print debug messages to stdout (using `println!`) related to function registrations and function calls. |
| `no_stdlib` | Exclude the standard library of utility functions in the build, and only include the minimum necessary functionalities. |
| `unchecked` | Exclude arithmetic checking in the standard library. Beware that a bad script may panic the entire system! |
| `no_index` | Disable arrays and indexing features |
| `no_float` | Disable floating-point numbers and math |
| `no_index` | Disable arrays and indexing features if you don't need them. |
| `no_float` | Disable floating-point numbers and math if you don't need them. |
Related
-------
@ -190,14 +190,14 @@ Values and types
The following primitive types are supported natively:
| Category | Types |
| ------------------------------ | -------------------------------------- |
| Integer | `i32`, `u32`, `i64` _(default)_, `u64` |
| Floating-point | `f32`, `f64` _(default)_ |
| Character | `char` |
| Boolean | `bool` |
| Array | `rhai::Array` |
| Dynamic (i.e. can be anything) | `rhai::Dynamic` |
| Category | Types |
| --------------------------------------------------------------- | -------------------------------------- |
| Integer | `i32`, `u32`, `i64` _(default)_, `u64` |
| Floating-point (disabled with [`no_float`](#optional-features)) | `f32`, `f64` _(default)_ |
| Character | `char` |
| Boolean | `bool` |
| Array (disabled with [`no_index`](#optional-features)) | `rhai::Array` |
| Dynamic (i.e. can be anything) | `rhai::Dynamic` |
Value conversions
-----------------

3
src/api.rs
View File

@ -274,6 +274,8 @@ impl<'e> Engine<'e> {
///
/// ```rust
/// # fn main() -> Result<(), rhai::EvalAltResult> {
/// # #[cfg(not(feature = "no_stdlib"))]
/// # {
/// use rhai::Engine;
///
/// let mut engine = Engine::new();
@ -283,6 +285,7 @@ impl<'e> Engine<'e> {
/// let result: i64 = engine.call_fn("add", &ast, (String::from("abc"), 123_i64))?;
///
/// assert_eq!(result, 126);
/// # }
/// # Ok(())
/// # }
/// ```

4
src/builtin.rs
View File

@ -479,7 +479,7 @@ impl Engine<'_> {
reg_func1!(self, "debug", print_debug, String, i8, u8, i16, u16);
reg_func1!(self, "debug", print_debug, String, i32, i64, u32, u64);
reg_func1!(self, "debug", print_debug, String, bool, char);
reg_func1!(self, "debug", print_debug, String, bool, char, String, ());
#[cfg(not(feature = "no_float"))]
{
@ -490,7 +490,7 @@ impl Engine<'_> {
#[cfg(not(feature = "no_index"))]
{
reg_func1!(self, "print", print_debug, String, Array);
reg_func1!(self, "debug", print_debug, String, String, Array, ());
reg_func1!(self, "debug", print_debug, String, Array);
// Register array iterator
self.register_iterator::<Array, _>(|a| {

2
src/optimize.rs
View File

@ -61,7 +61,7 @@ fn optimize_stmt(stmt: Stmt, changed: &mut bool) -> Stmt {
// Remove all raw expression statements that evaluate to constants
// except for the very last statement
result.retain(|stmt| match stmt {
Stmt::Expr(expr) if expr.is_constant() => false,
Stmt::Expr(expr) if expr.is_constant() || expr.is_identifier() => false,
_ => true,
});

1
tests/arrays.rs
View File

@ -1,3 +1,4 @@
#![cfg(not(feature = "no_index"))]
use rhai::{Engine, EvalAltResult, RegisterFn};
#[test]

14
tests/chars.rs
View File

@ -6,11 +6,15 @@ fn test_chars() -> Result<(), EvalAltResult> {
assert_eq!(engine.eval::<char>("'y'")?, 'y');
assert_eq!(engine.eval::<char>("'\\u2764'")?, '❤');
assert_eq!(engine.eval::<char>(r#"let x="hello"; x[2]"#)?, 'l');
assert_eq!(
engine.eval::<String>(r#"let x="hello"; x[2]='$'; x"#)?,
"he$lo".to_string()
);
#[cfg(not(feature = "no_index"))]
{
assert_eq!(engine.eval::<char>(r#"let x="hello"; x[2]"#)?, 'l');
assert_eq!(
engine.eval::<String>(r#"let x="hello"; x[2]='$'; x"#)?,
"he$lo".to_string()
);
}
assert!(engine.eval::<char>("'\\uhello'").is_err());
assert!(engine.eval::<char>("''").is_err());

1
tests/engine.rs
View File

@ -1,3 +1,4 @@
#![cfg(not(feature = "no_stdlib"))]
use rhai::{Engine, EvalAltResult};
#[test]

1
tests/float.rs
View File

@ -1,3 +1,4 @@
#![cfg(not(feature = "no_float"))]
use rhai::{Engine, EvalAltResult, RegisterFn};
#[test]

1
tests/for.rs
View File

@ -1,3 +1,4 @@
#![cfg(not(feature = "no_index"))]
use rhai::{Engine, EvalAltResult};
#[test]

9
tests/mismatched_op.rs
View File

@ -1,6 +1,7 @@
use rhai::{Engine, EvalAltResult, RegisterFn};
#[test]
#[cfg(not(feature = "no_stdlib"))]
fn test_mismatched_op() {
let mut engine = Engine::new();
@ -26,17 +27,13 @@ fn test_mismatched_op_custom_type() {
}
let mut engine = Engine::new();
engine.register_type::<TestStruct>();
engine.register_type_with_name::<TestStruct>("TestStruct");
engine.register_fn("new_ts", TestStruct::new);
let r = engine.eval::<i64>("60 + new_ts()");
match r {
Err(EvalAltResult::ErrorFunctionNotFound(err, _))
if err == "+ (i64, mismatched_op::test_mismatched_op_custom_type::TestStruct)" =>
{
()
}
Err(EvalAltResult::ErrorFunctionNotFound(err, _)) if err == "+ (i64, TestStruct)" => (),
_ => panic!(),
}
}

34
tests/power_of.rs
View File

@ -6,11 +6,15 @@ fn test_power_of() -> Result<(), EvalAltResult> {
assert_eq!(engine.eval::<i64>("2 ~ 3")?, 8);
assert_eq!(engine.eval::<i64>("(-2 ~ 3)")?, -8);
assert_eq!(engine.eval::<f64>("2.2 ~ 3.3")?, 13.489468760533386_f64);
assert_eq!(engine.eval::<f64>("2.0~-2.0")?, 0.25_f64);
assert_eq!(engine.eval::<f64>("(-2.0~-2.0)")?, 0.25_f64);
assert_eq!(engine.eval::<f64>("(-2.0~-2)")?, 0.25_f64);
assert_eq!(engine.eval::<i64>("4~3")?, 64);
#[cfg(not(feature = "no_float"))]
{
assert_eq!(engine.eval::<f64>("2.2 ~ 3.3")?, 13.489468760533386_f64);
assert_eq!(engine.eval::<f64>("2.0~-2.0")?, 0.25_f64);
assert_eq!(engine.eval::<f64>("(-2.0~-2.0)")?, 0.25_f64);
assert_eq!(engine.eval::<f64>("(-2.0~-2)")?, 0.25_f64);
assert_eq!(engine.eval::<i64>("4~3")?, 64);
}
Ok(())
}
@ -21,14 +25,18 @@ fn test_power_of_equals() -> Result<(), EvalAltResult> {
assert_eq!(engine.eval::<i64>("let x = 2; x ~= 3; x")?, 8);
assert_eq!(engine.eval::<i64>("let x = -2; x ~= 3; x")?, -8);
assert_eq!(
engine.eval::<f64>("let x = 2.2; x ~= 3.3; x")?,
13.489468760533386_f64
);
assert_eq!(engine.eval::<f64>("let x = 2.0; x ~= -2.0; x")?, 0.25_f64);
assert_eq!(engine.eval::<f64>("let x = -2.0; x ~= -2.0; x")?, 0.25_f64);
assert_eq!(engine.eval::<f64>("let x = -2.0; x ~= -2; x")?, 0.25_f64);
assert_eq!(engine.eval::<i64>("let x =4; x ~= 3; x")?, 64);
#[cfg(not(feature = "no_float"))]
{
assert_eq!(
engine.eval::<f64>("let x = 2.2; x ~= 3.3; x")?,
13.489468760533386_f64
);
assert_eq!(engine.eval::<f64>("let x = 2.0; x ~= -2.0; x")?, 0.25_f64);
assert_eq!(engine.eval::<f64>("let x = -2.0; x ~= -2.0; x")?, 0.25_f64);
assert_eq!(engine.eval::<f64>("let x = -2.0; x ~= -2; x")?, 0.25_f64);
assert_eq!(engine.eval::<i64>("let x =4; x ~= 3; x")?, 64);
}
Ok(())
}

10
tests/string.rs
View File

@ -12,10 +12,20 @@ fn test_string() -> Result<(), EvalAltResult> {
engine.eval::<String>(r#""Test string: \x58""#)?,
"Test string: X".to_string()
);
assert_eq!(
engine.eval::<String>(r#""foo" + "bar""#)?,
"foobar".to_string()
);
#[cfg(not(feature = "no_stdlib"))]
assert_eq!(
engine.eval::<String>(r#""foo" + 123"#)?,
"foo123".to_string()
);
#[cfg(not(feature = "no_float"))]
#[cfg(not(feature = "no_stdlib"))]
assert_eq!(
engine.eval::<String>(r#""foo" + 123.4556"#)?,
"foo123.4556".to_string()

6
tests/types.rs
View File

@ -5,11 +5,17 @@ fn test_type_of() -> Result<(), EvalAltResult> {
let mut engine = Engine::new();
assert_eq!(engine.eval::<String>("type_of(60 + 5)")?, "i64");
#[cfg(not(feature = "no_float"))]
assert_eq!(engine.eval::<String>("type_of(1.0 + 2.0)")?, "f64");
#[cfg(not(feature = "no_index"))]
#[cfg(not(feature = "no_float"))]
assert_eq!(
engine.eval::<String>(r#"type_of([1.0, 2, "hello"])"#)?,
"array"
);
assert_eq!(engine.eval::<String>(r#"type_of("hello")"#)?, "string");
assert_eq!(engine.eval::<String>("let x = 123; x.type_of()")?, "i64");