1 files changed, 79 insertions, 48 deletions

diff --git a/unit_tests/shared.cpp b/unit_tests/shared.cpp
index d139579..9f3b08e 100644
--- a/unit_tests/shared.cpp
+++ b/unit_tests/shared.cpp
@@ -18,42 +18,26 @@ namespace
         {
             STACK_CHECK_START_REL(L_, 0);
             lua_getglobal(L_, "package");                                                          // L_: package
-            std::ignore = luaG_getfield(L_, kIdxTop, "preload");                                   // L_: package package.preload
+            std::ignore = luaW_getfield(L_, kIdxTop, "preload");                                   // L_: package package.preload
             lua_pushcfunction(L_, openf_);                                                         // L_: package package.preload openf_
-            luaG_setfield(L_, StackIndex{ -2 }, name_);                                            // L_: package package.preload
+            luaW_setfield(L_, StackIndex{ -2 }, name_);                                            // L_: package package.preload
             lua_pop(L_, 2);
             STACK_CHECK(L_, 0);
         }
 
-
         static std::map<lua_State*, std::atomic_flag> sFinalizerHits;
         static std::mutex sCallCountsLock;
 
         // a finalizer that we can detect even after closing the state
-        lua_CFunction sThrowingFinalizer = +[](lua_State* L_) {
+        lua_CFunction sFreezingFinalizer = +[](lua_State* const L_) {
             std::lock_guard _guard{ sCallCountsLock };
             sFinalizerHits[L_].test_and_set();
-            luaG_pushstring(L_, "throw");
+            luaW_pushstring(L_, "freeze"); // just freeze the thread in place so that it can be debugged
             return 1;
         };
 
-        // a finalizer that we can detect even after closing the state
-        lua_CFunction sYieldingFinalizer = +[](lua_State* L_) {
-            std::lock_guard _guard{ sCallCountsLock };
-            sFinalizerHits[L_].test_and_set();
-            return 0;
-        };
-
-        // a function that runs forever
-        lua_CFunction sForever = +[](lua_State* L_) {
-            while (true) {
-                std::this_thread::yield();
-            }
-            return 0;
-        };
-
         // a function that returns immediately (so that LuaJIT issues a function call for it)
-        lua_CFunction sGiveMeBack = +[](lua_State* L_) {
+        lua_CFunction sGiveMeBack = +[](lua_State* const L_) {
             return lua_gettop(L_);
         };
 
@@ -63,25 +47,53 @@ namespace
         };
 
         lua_CFunction sNewUserData = +[](lua_State* const L_) {
-            std::ignore = luaG_newuserdatauv<int>(L_, UserValueCount{ 0 });
+            std::ignore = luaW_newuserdatauv<int>(L_, UserValueCount{ 0 });
             return 1;
         };
 
-        // a function that enables any lane to require "fixture"
+        // a function that enables any lane to require "fixture" and "deep_userdata_example"
         lua_CFunction sOnStateCreate = +[](lua_State* const L_) {
             PreloadModule(L_, "fixture", luaopen_fixture);
             PreloadModule(L_, "deep_userdata_example", luaopen_deep_userdata_example);
             return 0;
         };
 
+        // a function that blocks for the specified duration (in seconds) by putting the current thread to sleep
+        lua_CFunction sBlockFor = +[](lua_State* const L_) {
+            std::chrono::time_point<std::chrono::steady_clock> _until{ std::chrono::time_point<std::chrono::steady_clock>::max() };
+            lua_settop(L_, 1);
+            if (luaW_type(L_, kIdxTop) == LuaType::NUMBER) { // we don't want to use lua_isnumber() because of autocoercion
+                lua_Duration const _duration{ lua_tonumber(L_, kIdxTop) };
+                if (_duration.count() >= 0.0) {
+                    _until = std::chrono::steady_clock::now() + std::chrono::duration_cast<std::chrono::steady_clock::duration>(_duration);
+                } else {
+                    raise_luaL_argerror(L_, kIdxTop, "duration cannot be < 0");
+                }
+
+            } else if (!lua_isnoneornil(L_, 2)) {
+                raise_luaL_argerror(L_, StackIndex{ 2 }, "incorrect duration type");
+            }
+            std::this_thread::sleep_until(_until);
+            return 0;
+        };
+
+        // a finalizer that we can detect even after closing the state
+        lua_CFunction sThrowingFinalizer = +[](lua_State* const L_) {
+            std::lock_guard _guard{ sCallCountsLock };
+            sFinalizerHits[L_].test_and_set();
+            bool const _allLanesTerminated = lua_toboolean(L_, kIdxTop);
+            luaW_pushstring(L_, "Finalizer%s", _allLanesTerminated ? "" : ": Uncooperative lanes detected");
+            return 1;
+        };
+
         static luaL_Reg const sFixture[] = {
-            { "forever", sForever },
-            { "give_me_back()", sGiveMeBack },
+            { "freezing_finalizer", sFreezingFinalizer },
+            { "give_me_back", sGiveMeBack },
             { "newlightuserdata", sNewLightUserData },
             { "newuserdata", sNewUserData },
             { "on_state_create", sOnStateCreate },
+            { "block_for", sBlockFor },
             { "throwing_finalizer", sThrowingFinalizer },
-            { "yielding_finalizer", sYieldingFinalizer },
             { nullptr, nullptr }
         };
     } // namespace local
@@ -91,7 +103,7 @@ namespace
     int luaopen_fixture(lua_State* L_)
     {
         STACK_CHECK_START_REL(L_, 0);
-        luaG_newlib<std::size(local::sFixture)>(L_, local::sFixture);                              // M
+        luaW_newlib<std::size(local::sFixture)>(L_, local::sFixture);                              // M
         STACK_CHECK(L_, 1);
         return 1;
     }
@@ -234,7 +246,7 @@ LuaError LuaState::doString(std::string_view const& str_) const
         return _loadErr;
     }
     LuaError const _callErr{ lua_pcall(L, 0, 1, 0) };                                              // L: "<msg>"?
-    [[maybe_unused]] std::string_view const _out{ luaG_tostring(L, kIdxTop) };
+    [[maybe_unused]] std::string_view const _out{ luaW_tostring(L, kIdxTop) };
     STACK_CHECK(L, 1);
     return _callErr;
 }
@@ -245,8 +257,8 @@ std::string_view LuaState::doStringAndRet(std::string_view const& str_) const
 {
     lua_settop(L, 0);
     if (str_.empty()) {
-        luaG_pushstring(L, "");
-        return luaG_tostring(L, kIdxTop);
+        luaW_pushstring(L, "");
+        return luaW_tostring(L, kIdxTop);
     }
     STACK_CHECK_START_REL(L, 0);
     LuaError const _loadErr{ luaL_loadstring(L, str_.data()) };                                    // L: chunk()
@@ -256,7 +268,7 @@ std::string_view LuaState::doStringAndRet(std::string_view const& str_) const
     }
     [[maybe_unused]] LuaError const _callErr{ lua_pcall(L, 0, 1, 0) };                             // L: "<msg>"?|retstring
     STACK_CHECK(L, 1);
-    return luaG_tostring(L, kIdxTop);
+    return luaW_tostring(L, kIdxTop);
 }
 
 // #################################################################################################
@@ -324,7 +336,7 @@ void LuaState::requireFailure(std::string_view const& script_)
 {
     auto const _result{ doString(script_) };
     if (_result == LuaError::OK) {
-        WARN(luaG_tostring(L, kIdxTop));
+        WARN(luaW_tostring(L, kIdxTop));
     }
     REQUIRE(_result != LuaError::OK);
     lua_settop(L, 0);
@@ -360,7 +372,7 @@ void LuaState::requireSuccess(std::string_view const& script_)
 {
     auto const _result{ doString(script_) };
     if (_result != LuaError::OK) {
-        WARN(luaG_tostring(L, kIdxTop));
+        WARN(luaW_tostring(L, kIdxTop));
     }
     REQUIRE(_result == LuaError::OK);
     lua_settop(L, 0);
@@ -372,7 +384,7 @@ void LuaState::requireSuccess(std::filesystem::path const& root_, std::string_vi
 {
     auto const _result{ doFile(root_, path_) };
     if (_result != LuaError::OK) {
-        WARN(luaG_tostring(L, kIdxTop));
+        WARN(luaW_tostring(L, kIdxTop));
     }
     REQUIRE(_result == LuaError::OK);
     lua_settop(L, 0);
@@ -395,20 +407,20 @@ TEST_CASE("LuaState.doString")
 {
     LuaState _L{ LuaState::WithBaseLibs{ true }, LuaState::WithFixture{ false } };
     // if the script fails to load, we should find the error message at the top of the stack
-    REQUIRE([&L = _L]() { std::ignore = L.doString("function end"); return lua_gettop(L) == 1 && luaG_type(L, StackIndex{1}) == LuaType::STRING; }());
+    REQUIRE([&L = _L]() { std::ignore = L.doString("function end"); return lua_gettop(L) == 1 && luaW_type(L, StackIndex{1}) == LuaType::STRING; }());
 
     // if the script runs, the stack should contain its return value
-    REQUIRE([&L = _L]() { std::ignore = L.doString("return true"); return lua_gettop(L) == 1 && luaG_type(L, StackIndex{1}) == LuaType::BOOLEAN; }());
-    REQUIRE([&L = _L]() { std::ignore = L.doString("return 'hello'"); return lua_gettop(L) == 1 && luaG_tostring(L, StackIndex{1}) == "hello"; }());
+    REQUIRE([&L = _L]() { std::ignore = L.doString("return true"); return lua_gettop(L) == 1 && luaW_type(L, StackIndex{1}) == LuaType::BOOLEAN; }());
+    REQUIRE([&L = _L]() { std::ignore = L.doString("return 'hello'"); return lua_gettop(L) == 1 && luaW_tostring(L, StackIndex{1}) == "hello"; }());
     // or nil if it didn't return anything
-    REQUIRE([&L = _L]() { std::ignore = L.doString("return"); return lua_gettop(L) == 1 && luaG_type(L, StackIndex{1}) == LuaType::NIL; }());
+    REQUIRE([&L = _L]() { std::ignore = L.doString("return"); return lua_gettop(L) == 1 && luaW_type(L, StackIndex{1}) == LuaType::NIL; }());
 
     // on failure, doStringAndRet returns "", and the error message is on the stack
-    REQUIRE([&L = _L]() { return L.doStringAndRet("function end") == "" && lua_gettop(L) == 1 && luaG_type(L, StackIndex{ 1 }) == LuaType::STRING && luaG_tostring(L, StackIndex{ 1 }) != ""; }());
+    REQUIRE([&L = _L]() { return L.doStringAndRet("function end") == "" && lua_gettop(L) == 1 && luaW_type(L, StackIndex{ 1 }) == LuaType::STRING && luaW_tostring(L, StackIndex{ 1 }) != ""; }());
     // on success doStringAndRet returns the string returned by the script, that is also at the top of the stack
-    REQUIRE([&L = _L]() { return L.doStringAndRet("return 'hello'") == "hello" && lua_gettop(L) == 1 && luaG_type(L, StackIndex{ 1 }) == LuaType::STRING && luaG_tostring(L, StackIndex{ 1 }) == "hello"; }());
+    REQUIRE([&L = _L]() { return L.doStringAndRet("return 'hello'") == "hello" && lua_gettop(L) == 1 && luaW_type(L, StackIndex{ 1 }) == LuaType::STRING && luaW_tostring(L, StackIndex{ 1 }) == "hello"; }());
     // if the returned value is not (convertible to) a string, we should get an empty string out of doStringAndRet
-    REQUIRE([&L = _L]() { return L.doStringAndRet("return function() end") == "" && lua_gettop(L) == 1 && luaG_type(L, StackIndex{ 1 }) == LuaType::FUNCTION && luaG_tostring(L, StackIndex{ 1 }) == ""; }());
+    REQUIRE([&L = _L]() { return L.doStringAndRet("return function() end") == "" && lua_gettop(L) == 1 && luaW_type(L, StackIndex{ 1 }) == LuaType::FUNCTION && luaW_tostring(L, StackIndex{ 1 }) == ""; }());
 }
 
 // #################################################################################################
@@ -424,9 +436,9 @@ FileRunner::FileRunner(std::string_view const& where_)
     // because the VS Test Explorer doesn't appreciate the text output of some scripts, so absorb them
     if constexpr (1) {
         auto const _nullprint = +[](lua_State* const L_) { return 0; };
-        luaG_pushglobaltable(L);
+        luaW_pushglobaltable(L);
         lua_pushcfunction(L, _nullprint);
-        luaG_setfield(L, StackIndex{ -2 }, std::string_view{ "print" });
+        luaW_setfield(L, StackIndex{ -2 }, std::string_view{ "print" });
         lua_pop(L, 1);
         stackCheck(0);
     }
@@ -448,16 +460,35 @@ FileRunner::FileRunner(std::string_view const& where_)
 
 void FileRunner::performTest(FileRunnerParam const& testParam_)
 {
+    static constexpr auto _atPanic = [](lua_State* const L_) {
+        throw std::logic_error("panic!");
+        return 0;
+    };
+
+#if LUA_VERSION_NUM >= 504 // // warnings are a Lua 5.4 feature
+    std::string _warnMessage;
+    static constexpr auto _onWarn = [](void* const opaque_, char const* const msg_, int const tocont_) {
+        std::string& _warnMessage = *static_cast<std::string*>(opaque_);
+        _warnMessage += msg_;
+    };
+#endif // LUA_VERSION_NUM
+
     INFO(testParam_.script);
     switch (testParam_.test) {
     case TestType::AssertNoLuaError:
+        lua_atpanic(L, _atPanic);
         requireSuccess(root, testParam_.script);
         break;
-    case TestType::AssertNoThrow:
-        REQUIRE_NOTHROW((std::ignore = doFile(root, testParam_.script), close()));
-        break;
-    case TestType::AssertThrows:
-        REQUIRE_THROWS_AS((std::ignore = doFile(root, testParam_.script), close()), std::logic_error);
+
+#if LUA_VERSION_NUM >= 504 // // warnings are a Lua 5.4 feature
+    case TestType::AssertWarns:
+        lua_atpanic(L, _atPanic);
+        lua_setwarnf(L, _onWarn, &_warnMessage);
+        std::ignore = doFile(root, testParam_.script);
+        close();
+        WARN(_warnMessage);
+        REQUIRE(_warnMessage != std::string_view{});
         break;
+#endif // LUA_VERSION_NUM
     }
 }