Add deterministic test for WorkQueue destructor deadlock race

Add a test that deterministically triggers the lost-wakeup race condition
in WorkQueue::~WorkQueue(). Uses a global arcana testing hook to sleep
while holding the queue mutex before wait(), guaranteeing the worker is
between the condition check and wait() when the destructor fires.

The test is expected to FAIL (deadlock timeout) with the current code,
proving the bug exists. The fix will be in a separate PR.

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Author: bghgary

CMakeLists.txt

@@ -14,8 +14,8 @@ FetchContent_Declare(AndroidExtensions
     GIT_TAG 2d5af72259cc73e5f249d3c99bee2010be9cb042
     EXCLUDE_FROM_ALL)
 FetchContent_Declare(arcana.cpp
-    GIT_REPOSITORY https://github.com/microsoft/arcana.cpp.git
-    GIT_TAG 7c6be8aaa29effbc8ee1a2217388fb6e399150d2
+    GIT_REPOSITORY https://github.com/bghgary/arcana.cpp.git
+    GIT_TAG 8328898f159c1778cb16fa41c7ad57994961e5e8
     EXCLUDE_FROM_ALL)
 FetchContent_Declare(asio
     GIT_REPOSITORY https://github.com/chriskohlhoff/asio.git
@@ -113,6 +113,10 @@ endif()
 
 # --------------------------------------------------
 
+if(JSRUNTIMEHOST_TESTS)
+    add_compile_definitions(ARCANA_TESTING_HOOKS)
+endif()
+
 FetchContent_MakeAvailable_With_Message(arcana.cpp)
 set_property(TARGET arcana PROPERTY FOLDER Dependencies)
 

Tests/UnitTests/Android/app/src/main/cpp/CMakeLists.txt

@@ -9,6 +9,7 @@ get_filename_component(UNIT_TESTS_DIR "${CMAKE_CURRENT_LIST_DIR}/../../../../.."
 get_filename_component(TESTS_DIR "${UNIT_TESTS_DIR}/.." ABSOLUTE)
 get_filename_component(REPO_ROOT_DIR "${TESTS_DIR}/.." ABSOLUTE)
 
+set(JSRUNTIMEHOST_TESTS ON CACHE BOOL "" FORCE)
 add_subdirectory(${REPO_ROOT_DIR} "${CMAKE_CURRENT_BINARY_DIR}/JsRuntimeHost")
 
 FetchContent_MakeAvailable_With_Message(googletest)

Tests/UnitTests/Shared/Shared.cpp

@@ -11,8 +11,14 @@
 #include <Babylon/Polyfills/Blob.h>
 #include <Babylon/Polyfills/TextDecoder.h>
 #include <gtest/gtest.h>
+#ifdef ARCANA_TESTING_HOOKS
+#include <arcana/threading/blocking_concurrent_queue.h>
+#endif
+#include <atomic>
+#include <chrono>
 #include <future>
 #include <iostream>
+#include <thread>
 
 namespace
 {
@@ -125,6 +131,83 @@ TEST(Console, Log)
     done.get_future().get();
 }
 
+#ifdef ARCANA_TESTING_HOOKS
+TEST(AppRuntime, DestroyDoesNotDeadlock)
+{
+    // Deterministic test for the race condition in the AppRuntime destructor.
+    //
+    // A global hook sleeps WHILE HOLDING the queue mutex, right before
+    // condition_variable::wait(). We synchronize so the worker is definitely
+    // in the hook before triggering destruction.
+    //
+    // Old (broken) code: cancel() + notify_all() fire without the mutex,
+    //   so the notification is lost while the worker sleeps → deadlock.
+    // Fixed code: Append(cancel) calls push() which NEEDS the mutex,
+    //   so it blocks until the worker enters wait() → notification delivered.
+    for (int i = 0; i < 3; i++)
+    {
+        // Shared state for hook synchronization
+        std::atomic<bool> hookEnabled{false};
+        std::atomic<bool> hookSignaled{false};
+        std::promise<void> workerInHook;
+
+        // Set the callback. It checks hookEnabled so we control
+        // when it actually sleeps.
+        arcana::set_before_wait_callback([&]() {
+            if (hookEnabled.load() && !hookSignaled.exchange(true))
+                workerInHook.set_value();
+            if (hookEnabled.load())
+                std::this_thread::sleep_for(std::chrono::milliseconds(200));
+        });
+
+        auto runtime = std::make_unique<Babylon::AppRuntime>();
+
+        // Dispatch work and wait for completion
+        std::promise<void> ready;
+        runtime->Dispatch([&ready](Napi::Env) {
+            ready.set_value();
+        });
+        ready.get_future().wait();
+
+        // Enable the hook and dispatch a no-op to wake the worker,
+        // ensuring it cycles through the hook on its way back to idle
+        hookEnabled.store(true);
+        runtime->Dispatch([](Napi::Env) {});
+
+        // Wait for the worker to be in the hook (holding mutex, sleeping)
+        auto hookStatus = workerInHook.get_future().wait_for(std::chrono::seconds(5));
+        ASSERT_NE(hookStatus, std::future_status::timeout)
+            << "Worker thread did not enter before-wait hook on iteration " << i;
+
+        // Destroy on a detachable thread so the test doesn't hang if the
+        // destructor deadlocks (std::async's future destructor would block).
+        auto runtimePtr = std::make_shared<std::unique_ptr<Babylon::AppRuntime>>(std::move(runtime));
+        std::promise<void> destroyDone;
+        auto destroyFuture = destroyDone.get_future();
+        std::thread destroyThread([runtimePtr, &destroyDone]() {
+            runtimePtr->reset();
+            destroyDone.set_value();
+        });
+
+        auto status = destroyFuture.wait_for(std::chrono::seconds(5));
+        if (status == std::future_status::timeout)
+        {
+            destroyThread.detach();
+        }
+        else
+        {
+            destroyThread.join();
+        }
+
+        // Reset hook
+        arcana::set_before_wait_callback([]() {});
+
+        ASSERT_NE(status, std::future_status::timeout)
+            << "Deadlock detected on iteration " << i;
+    }
+}
+#endif
+
 int RunTests()
 {
     testing::InitGoogleTest();

Tests/UnitTests/Win32/App.cpp

@@ -1,13 +1,15 @@
 #include "../Shared/Shared.h"
 #include <Windows.h>
 #include "Babylon/DebugTrace.h"
+#include <gtest/gtest.h>
 
-int main()
+int main(int argc, char** argv)
 {
     SetConsoleOutputCP(CP_UTF8);
 
     Babylon::DebugTrace::EnableDebugTrace(true);
     Babylon::DebugTrace::SetTraceOutput([](const char* trace) { OutputDebugStringA(trace); });
 
-    return RunTests();
+    testing::InitGoogleTest(&argc, argv);
+    return RUN_ALL_TESTS();
 }