CI fixes.

Fix Lua 5.1 tests.
Remove the no-lua-oslib build variant.

Author: jugglerchris

.circleci/config.yml

@@ -37,33 +37,6 @@ jobs:
             - target/debug/build
             - target/debug/deps
           key: cargo-cache-{{ arch }}-{{ checksum "Cargo.lock" }}
-  build-no-oslib:
-    docker:
-      - image: cimg/rust:1.75.0
-    steps:
-      - checkout
-      - run:
-          name: Version information
-          command: rustc --version; cargo --version; rustup --version
-      - run:
-          name: Calculate dependencies
-          command: cargo generate-lockfile
-      - restore_cache:
-          keys:
-            - cargo-cache-no-oslib-{{ arch }}-{{ checksum "Cargo.lock" }}
-      - run:
-          name: Build all targets
-          command: cargo build --features=lua-no-oslib --all --all-targets
-      - run:
-          name: Run all tests
-          command: cargo test --features=lua-no-oslib --all
-      - save_cache:
-          paths:
-            - /usr/local/cargo/registry
-            - target/debug/.fingerprint
-            - target/debug/build
-            - target/debug/deps
-          key: cargo-cache-no-oslib-{{ arch }}-{{ checksum "Cargo.lock" }}
   build-lua53:
     docker:
       - image: cimg/rust:1.75.0
@@ -214,4 +187,3 @@ workflows:
       - "build-lua51"
       - "build-luajit"
       - "build-windows"
-      - "build-no-oslib"

tests/conversion.rs

@@ -2,24 +2,14 @@ use rlua::{Integer, Lua, Result, RluaCompat, String, Table, ToLuaCompat, Value};
 
 fn valid_float(verify: Result<Value>, expected: f64) {
     let verify_unwrap = verify.unwrap();
-    assert_eq!(verify_unwrap.type_name(), "number");
+    assert!(verify_unwrap.type_name() == "number" || verify_unwrap.type_name() == "integer");
     match verify_unwrap {
         Value::Number(value) => assert_eq!(value, expected),
+        Value::Integer(value) => assert_eq!(value as f64, expected),
         _ => panic!("unexpected type"),
     };
 }
 
-#[cfg(rlua_lua51)]
-fn valid_int(verify: Result<Value>, expected: Integer) {
-    let verify_unwrap = verify.unwrap();
-    assert_eq!(verify_unwrap.type_name(), "number");
-    match verify_unwrap {
-        Value::Number(value) => assert_eq!(value as Integer, expected),
-        _ => panic!("unexpected type"),
-    };
-}
-
-#[cfg(not(rlua_lua51))]
 fn valid_int(verify: Result<Value>, expected: Integer) {
     let verify_unwrap = verify.unwrap();
     assert_eq!(verify_unwrap.type_name(), "integer");

tests/tests.rs

@@ -809,16 +809,6 @@ fn test_loadstring_wrappers() {
         .exec()
         .unwrap();
         assert_eq!(globals.get::<_, u32>("x").unwrap(), 1);
-        lua.load(
-            r#"
-                assert(type(binchunk) == "string")
-                chunk = loadstring(binchunk)
-                assert(chunk == nil)
-            "#,
-        )
-        .exec()
-        .unwrap();
-        assert_eq!(globals.get::<_, u32>("x").unwrap(), 1);
         lua.load(
             r#"
                 local s = "x = x + 4"
@@ -1052,15 +1042,24 @@ fn test_pcall_xpcall() {
         assert!(r);
         assert_eq!(e, "foo");
 
+        #[cfg(not(rlua_lua51))]
         let (r, e) = lua
-            .load("xpcall(function(p) return p end, print, 'foo')")
+            .load("xpcall(function(p) return p end, function(e) print(e) return e end, 'foo')")
             .eval::<(bool, String)>()
             .unwrap();
         assert!(r);
         assert_eq!(e, "foo");
 
+        #[cfg(rlua_lua51)]
+        let (r, e) = lua
+            .load("xpcall(function(p) return 'foo' end, function(e) print(e) return e end)")
+            .eval::<(bool, String)>()
+            .unwrap();
+        assert!(r);
+        assert_eq!(e, "foo");
         // Make sure that the return values are correct on errors, and that error handling works
 
+        #[cfg(not(rlua_lua51))]
         lua.load(
             r#"
                 pcall_error = nil
@@ -1073,16 +1072,26 @@ fn test_pcall_xpcall() {
         .exec()
         .unwrap();
 
+        #[cfg(rlua_lua51)]
+        lua.load(
+            r#"
+                pcall_error = nil
+                pcall_status, pcall_error = pcall(error, "testerror")
+
+                xpcall_error = nil
+                xpcall_status, _ = xpcall(function() error("testerror") end, function(err) xpcall_error = err end)
+            "#,
+        )
+        .exec()
+        .unwrap();
         assert_eq!(globals.get::<_, bool>("pcall_status").unwrap(), false);
-        assert_eq!(
-            globals.get::<_, String>("pcall_error").unwrap(),
-            "testerror"
+        assert!(
+            globals.get::<_, String>("pcall_error").unwrap().to_str().unwrap().ends_with("testerror")
         );
 
         assert_eq!(globals.get::<_, bool>("xpcall_statusr").unwrap(), false);
-        assert_eq!(
-            globals.get::<_, String>("xpcall_error").unwrap(),
-            "testerror"
+        assert!(
+            globals.get::<_, String>("xpcall_error").unwrap().to_str().unwrap().ends_with("testerror")
         );
 
         // Make sure that weird xpcall error recursion at least doesn't cause unsafety or panics.