Use quick_exit in test UnhandledExceptionHandlers for consistency (#1640)

Replace `set_exception`-based error handling with `std::quick_exit(1)`
in unit test `UnhandledExceptionHandler`s to match the pattern used by
Playground and PrecompiledShaderTest.

**Why:** When an unhandled JS exception occurs, the JS thread continues
processing the work queue after the handler returns. Using
`set_exception` on a promise signals the waiting thread, but more queued
work can execute before the main thread reacts — causing cascading
errors and confusing logs. `quick_exit` stops everything immediately,
which is the right behavior for tests.

**Changes:**
- Replace `set_exception` with `std::quick_exit(1)` in Tests.JavaScript,
Tests.ShaderCache, and Tests.UniformPadding
- Keep `std::cerr` output before `quick_exit` so CI captures the error
message
- Move `std::promise` declarations closer to first use (no longer
captured by the handler)
- Remove redundant `.flush()` calls after `std::endl` (which already
guarantees a flush per the C++ spec)

---------

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

Author: bghgary

Apps/UnitTests/Source/Tests.JavaScript.cpp

@@ -11,6 +11,8 @@
 #include <Babylon/Plugins/NativeEncoding.h>
 #include <Babylon/ScriptLoader.h>
 
+#include <cstdlib>
+
 extern Babylon::Graphics::Configuration g_deviceConfig;
 
 namespace
@@ -36,19 +38,15 @@ TEST(JavaScript, All)
     // Change this to true to wait for the JavaScript debugger to attach (only applies to V8)
     constexpr const bool waitForDebugger = false;
 
-    std::promise<int32_t> exitCodePromise;
-
     Babylon::Graphics::Device device{g_deviceConfig};
 
     std::optional<Babylon::Polyfills::Canvas> nativeCanvas;
 
     Babylon::AppRuntime::Options options{};
 
-    options.UnhandledExceptionHandler = [&exitCodePromise](const Napi::Error& error) {
+    options.UnhandledExceptionHandler = [](const Napi::Error& error) {
         std::cerr << "[Uncaught Error] " << Napi::GetErrorString(error) << std::endl;
-        std::cerr.flush();
-
-        exitCodePromise.set_exception(std::make_exception_ptr(std::exception{}));
+        std::quick_exit(1);
     };
 
     if (waitForDebugger)
@@ -59,13 +57,14 @@ TEST(JavaScript, All)
 
     Babylon::AppRuntime runtime{options};
 
+    std::promise<int32_t> exitCodePromise;
+
     runtime.Dispatch([&exitCodePromise, &device, &nativeCanvas](Napi::Env env) {
         device.AddToJavaScript(env);
 
         Babylon::Polyfills::XMLHttpRequest::Initialize(env);
         Babylon::Polyfills::Console::Initialize(env, [](const char* message, Babylon::Polyfills::Console::LogLevel logLevel) {
             std::cout << "[" << EnumToString(logLevel) << "] " << message << std::endl;
-            std::cout.flush();
         });
         Babylon::Polyfills::Window::Initialize(env);
         Babylon::Polyfills::Blob::Initialize(env);

Apps/UnitTests/Source/Tests.ShaderCache.cpp

@@ -9,6 +9,7 @@
 #include <Babylon/ScriptLoader.h>
 
 #include <chrono>
+#include <cstdlib>
 #include <optional>
 #include <future>
 #include <iostream>
@@ -28,25 +29,23 @@ TEST(ShaderCache, SaveAndLoad)
     device.StartRenderingCurrentFrame();
     update.Start();
 
-    std::promise<void> scriptIsDone{};
-    std::promise<void> sceneIsReady{};
-
     Babylon::AppRuntime::Options options{};
 
-    options.UnhandledExceptionHandler = [&scriptIsDone](const Napi::Error& error) {
+    options.UnhandledExceptionHandler = [](const Napi::Error& error) {
         std::cerr << "[Uncaught Error] " << Napi::GetErrorString(error) << std::endl;
-        std::cerr.flush();
-
-        scriptIsDone.set_exception(std::make_exception_ptr(std::exception{}));
+        std::quick_exit(1);
     };
 
     Babylon::AppRuntime runtime{options};
+
+    std::promise<void> scriptIsDone{};
+    std::promise<void> sceneIsReady{};
+
     runtime.Dispatch([&device, &sceneIsReady](Napi::Env env) {
         device.AddToJavaScript(env);
 
         Babylon::Polyfills::Console::Initialize(env, [](const char* message, auto) {
             std::cout << message << std::endl;
-            std::cout.flush();
         });
         Babylon::Polyfills::Window::Initialize(env);
         Babylon::Plugins::NativeEngine::Initialize(env);

Apps/UnitTests/Source/Tests.UniformPadding.cpp

@@ -7,6 +7,7 @@
 #include <Babylon/Plugins/NativeEngine.h>
 #include <Babylon/ScriptLoader.h>
 
+#include <cstdlib>
 #include <future>
 #include <iostream>
 
@@ -30,12 +31,10 @@ TEST(UniformPadding, SubVec4UniformsDoNotOverflow)
     device.StartRenderingCurrentFrame();
     update.Start();
 
-    std::promise<void> done{};
-
     Babylon::AppRuntime::Options options{};
-    options.UnhandledExceptionHandler = [&done](const Napi::Error& error) {
+    options.UnhandledExceptionHandler = [](const Napi::Error& error) {
         std::cerr << "[Uncaught Error] " << Napi::GetErrorString(error) << std::endl;
-        done.set_exception(std::make_exception_ptr(std::exception{}));
+        std::quick_exit(1);
     };
 
     Babylon::AppRuntime runtime{options};
@@ -95,6 +94,8 @@ TEST(UniformPadding, SubVec4UniformsDoNotOverflow)
         if (!scene.isReady()) { throw new Error("Scene should be ready with synchronous shader compilation"); }
     )", "uniform_padding_test.js");
 
+    std::promise<void> done{};
+
     loader.Dispatch([&done](Napi::Env) {
         done.set_value();
     });