From f79d771f1a9e49cc5e7e7cf2553abb0d37339e36 Mon Sep 17 00:00:00 2001
From: kyren <kerriganw@gmail.com>
Date: Mon, 12 Mar 2018 16:00:11 -0400
Subject: Documentation improvements, split scope into its own module, improved
 tests

Also makes `Lua` and associated types !UnwindSafe and !RefUnwindSafe, which they
should be because they are intensely internally mutable.  Lua IS still panic
safe, but that doesn't mean it should be marked as UnwindSafe (as I understand
it).
---
 src/tests/mod.rs | 50 +++++++++++++++++++++++++++++++++-----------------
 1 file changed, 33 insertions(+), 17 deletions(-)

(limited to 'src/tests/mod.rs')

diff --git a/src/tests/mod.rs b/src/tests/mod.rs
index 7491e8d..f24506f 100644
--- a/src/tests/mod.rs
+++ b/src/tests/mod.rs
@@ -12,8 +12,8 @@ use std::cell::Cell;
 use std::sync::Arc;
 use std::panic::catch_unwind;
 
-use {Error, ExternalError, Function, Lua, Nil, Result, Table, UserData, UserDataMethods, Value,
-     Variadic};
+use {Error, ExternalError, Function, Lua, Nil, Result, String, Table, UserData, UserDataMethods,
+     Value, Variadic};
 
 #[test]
 fn test_load() {
@@ -34,7 +34,7 @@ fn test_debug() {
     }
     let traceback_output = lua.eval::<String>("debug.traceback()", None).unwrap();
     assert_eq!(
-        traceback_output.split("\n").next(),
+        traceback_output.to_str().unwrap().split("\n").next(),
         "stack traceback:".into()
     );
 }
@@ -282,7 +282,7 @@ fn test_error() {
             None,
         )?;
         let rust_panic_function = lua.create_function(|_, ()| -> Result<()> {
-            panic!("expected panic, this panic should be caught in rust")
+            panic!("test_panic")
         }).unwrap();
         globals.set("rust_panic_function", rust_panic_function)?;
 
@@ -292,7 +292,7 @@ fn test_error() {
     }) {
         Ok(Ok(_)) => panic!("no panic was detected, pcall caught it!"),
         Ok(Err(e)) => panic!("error during panic test {:?}", e),
-        Err(_) => {}
+        Err(p) => assert!(*p.downcast::<&str>().unwrap() == "test_panic"),
     };
 
     match catch_unwind(|| -> Result<()> {
@@ -308,7 +308,7 @@ fn test_error() {
             None,
         )?;
         let rust_panic_function = lua.create_function(|_, ()| -> Result<()> {
-            panic!("expected panic, this panic should be caught in rust")
+            panic!("test_panic")
         }).unwrap();
         globals.set("rust_panic_function", rust_panic_function)?;
 
@@ -318,7 +318,7 @@ fn test_error() {
     }) {
         Ok(Ok(_)) => panic!("no panic was detected, xpcall caught it!"),
         Ok(Err(e)) => panic!("error during panic test {:?}", e),
-        Err(_) => {}
+        Err(p) => assert!(*p.downcast::<&str>().unwrap() == "test_panic"),
     };
 }
 
@@ -382,21 +382,22 @@ fn test_pcall_xpcall() {
     let globals = lua.globals();
 
     // make sure that we handle not enough arguments
+
     assert!(lua.exec::<()>("pcall()", None).is_err());
     assert!(lua.exec::<()>("xpcall()", None).is_err());
     assert!(lua.exec::<()>("xpcall(function() end)", None).is_err());
 
     // Make sure that the return values from are correct on success
-    assert_eq!(
-        lua.eval::<(bool, String)>("pcall(function(p) return p end, 'foo')", None)
-            .unwrap(),
-        (true, "foo".to_owned())
-    );
-    assert_eq!(
-        lua.eval::<(bool, String)>("xpcall(function(p) return p end, print, 'foo')", None)
-            .unwrap(),
-        (true, "foo".to_owned())
-    );
+
+    let (r, e) = lua.eval::<(bool, String)>("pcall(function(p) return p end, 'foo')", None)
+        .unwrap();
+    assert!(r);
+    assert_eq!(e, "foo");
+
+    let (r, e) = lua.eval::<(bool, String)>("xpcall(function(p) return p end, print, 'foo')", None)
+        .unwrap();
+    assert!(r);
+    assert_eq!(e, "foo");
 
     // Make sure that the return values are correct on errors, and that error handling works
 
@@ -779,3 +780,18 @@ fn large_args() {
         4950
     );
 }
+
+fn large_args_ref() {
+    let lua = Lua::new();
+    let globals = lua.globals();
+
+    let f = lua.create_function(|_, args: Variadic<String>| {
+        for i in 0..args.len() {
+            assert_eq!(args[i], i.to_string());
+        }
+        Ok(())
+    }).unwrap();
+
+    f.call::<_, ()>((0..100).map(|i| i.to_string()).collect::<Variadic<_>>())
+        .unwrap();
+}
-- 
cgit v1.2.3