Simply test error matching.

tests/call_fn.rs

@@ -1,7 +1,6 @@
 #![cfg(not(feature = "no_function"))]
 use rhai::{
-    Dynamic, Engine, EvalAltResult, FnPtr, Func, Module, ParseError, ParseErrorType, RegisterFn,
+    Dynamic, Engine, EvalAltResult, FnPtr, Func, Module, ParseErrorType, RegisterFn, Scope, INT,
-    Scope, INT,
 };
 use std::any::TypeId;
 
@@ -10,12 +9,13 @@ fn test_fn() -> Result<(), Box<EvalAltResult>> {
     let engine = Engine::new();
 
     // Expect duplicated parameters error
-    assert!(matches!(
+    assert_eq!(
-        engine
+        *engine
             .compile("fn hello(x, x) { x }")
-            .expect_err("should be error"),
+            .expect_err("should be error")
-        ParseError(x, _) if *x == ParseErrorType::FnDuplicatedParam("hello".to_string(), "x".to_string())
+            .0,
-    ));
+        ParseErrorType::FnDuplicatedParam("hello".to_string(), "x".to_string())
+    );
 
     Ok(())
 }

tests/data_size.rs

@@ -1,5 +1,5 @@
 #![cfg(not(feature = "unchecked"))]
-use rhai::{Engine, EvalAltResult, ParseError, ParseErrorType};
+use rhai::{Engine, EvalAltResult, ParseErrorType};
 
 #[cfg(not(feature = "no_index"))]
 use rhai::Array;
@@ -12,15 +12,21 @@ fn test_max_string_size() -> Result<(), Box<EvalAltResult>> {
     let mut engine = Engine::new();
     engine.set_max_string_size(10);
 
-    assert!(matches!(
+    assert_eq!(
-        engine.compile(r#"let x = "hello, world!";"#).expect_err("should error"),
+        *engine
-        ParseError(x, _) if *x == ParseErrorType::LiteralTooLarge("Length of string literal".to_string(), 10)
+            .compile(r#"let x = "hello, world!";"#)
-    ));
+            .expect_err("should error")
+            .0,
+        ParseErrorType::LiteralTooLarge("Length of string literal".to_string(), 10)
+    );
 
-    assert!(matches!(
+    assert_eq!(
-        engine.compile(r#"let x = "朝に紅顔、暮に白骨";"#).expect_err("should error"),
+        *engine
-        ParseError(x, _) if *x == ParseErrorType::LiteralTooLarge("Length of string literal".to_string(), 10)
+            .compile(r#"let x = "朝に紅顔、暮に白骨";"#)
-    ));
+            .expect_err("should error")
+            .0,
+        ParseErrorType::LiteralTooLarge("Length of string literal".to_string(), 10)
+    );
 
     assert!(matches!(
         *engine
@@ -74,12 +80,13 @@ fn test_max_array_size() -> Result<(), Box<EvalAltResult>> {
     #[cfg(not(feature = "no_object"))]
     engine.set_max_map_size(10);
 
-    assert!(matches!(
+    assert_eq!(
-        engine
+        *engine
             .compile("let x = [1,2,3,4,5,6,7,8,9,10,11,12,13,14,15];")
-            .expect_err("should error"),
+            .expect_err("should error")
-        ParseError(x, _) if *x == ParseErrorType::LiteralTooLarge("Size of array literal".to_string(), 10)
+            .0,
-    ));
+        ParseErrorType::LiteralTooLarge("Size of array literal".to_string(), 10)
+    );
 
     assert!(matches!(
         *engine
@@ -186,12 +193,18 @@ fn test_max_map_size() -> Result<(), Box<EvalAltResult>> {
     #[cfg(not(feature = "no_index"))]
     engine.set_max_array_size(10);
 
-    assert!(matches!(
+    assert_eq!(
-        engine
+        *engine
-            .compile("let x = #{a:1,b:2,c:3,d:4,e:5,f:6,g:7,h:8,i:9,j:10,k:11,l:12,m:13,n:14,o:15};")
+            .compile(
-            .expect_err("should error"),
+                "let x = #{a:1,b:2,c:3,d:4,e:5,f:6,g:7,h:8,i:9,j:10,k:11,l:12,m:13,n:14,o:15};"
-        ParseError(x, _) if *x == ParseErrorType::LiteralTooLarge("Number of properties in object map literal".to_string(), 10)
+            )
-    ));
+            .expect_err("should error")
+            .0,
+        ParseErrorType::LiteralTooLarge(
+            "Number of properties in object map literal".to_string(),
+            10
+        )
+    );
 
     assert!(matches!(
         *engine

tests/functions.rs

@@ -1,5 +1,6 @@
 #![cfg(not(feature = "no_function"))]
-use rhai::{Engine, EvalAltResult, ParseError, ParseErrorType, INT};
+use rhai::{Engine, EvalAltResult, ParseErrorType, INT};
+use std::io::Read;
 
 #[test]
 fn test_functions() -> Result<(), Box<EvalAltResult>> {
@@ -155,7 +156,8 @@ fn test_function_captures() -> Result<(), Box<EvalAltResult>> {
 
     #[cfg(not(feature = "no_object"))]
     assert!(matches!(
-        engine.compile(
+        *engine
+            .compile(
                 r#"
                 fn foo() { this += x; }
 
@@ -164,8 +166,10 @@ fn test_function_captures() -> Result<(), Box<EvalAltResult>> {
 
                 y.foo!();
             "#
-        ).expect_err("should error"),
+            )
-        ParseError(err, _) if matches!(*err, ParseErrorType::MalformedCapture(_))
+            .expect_err("should error")
+            .0,
+        ParseErrorType::MalformedCapture(_)
     ));
 
     Ok(())

tests/looping.rs

@@ -1,4 +1,4 @@
-use rhai::{Engine, EvalAltResult, ParseError, ParseErrorType, INT};
+use rhai::{Engine, EvalAltResult, ParseErrorType, INT};
 
 #[test]
 fn test_loop() -> Result<(), Box<EvalAltResult>> {
@@ -26,15 +26,21 @@ fn test_loop() -> Result<(), Box<EvalAltResult>> {
         21
     );
 
-    assert!(matches!(
+    assert_eq!(
-        engine.compile("let x = 0; break;").expect_err("should error"),
+        *engine
-        ParseError(x, _) if *x == ParseErrorType::LoopBreak
+            .compile("let x = 0; break;")
-    ));
+            .expect_err("should error")
+            .0,
+        ParseErrorType::LoopBreak
+    );
 
-    assert!(matches!(
+    assert_eq!(
-        engine.compile("let x = 0; if x > 0 { continue; }").expect_err("should error"),
+        *engine
-        ParseError(x, _) if *x == ParseErrorType::LoopBreak
+            .compile("let x = 0; if x > 0 { continue; }")
-    ));
+            .expect_err("should error")
+            .0,
+        ParseErrorType::LoopBreak
+    );
 
     Ok(())
 }