diff --git a/packages/react-native/ReactCommon/react/runtime/tests/cxx/ReactInstanceTest.cpp b/packages/react-native/ReactCommon/react/runtime/tests/cxx/ReactInstanceTest.cpp index 8d39ace3f5f..0c6aeb3f3a5 100644 --- a/packages/react-native/ReactCommon/react/runtime/tests/cxx/ReactInstanceTest.cpp +++ b/packages/react-native/ReactCommon/react/runtime/tests/cxx/ReactInstanceTest.cpp @@ -26,9 +26,9 @@ namespace facebook::react { class MockTimerRegistry : public PlatformTimerRegistry { public: - MOCK_METHOD2(createTimer, void(uint32_t, double)); - MOCK_METHOD2(createRecurringTimer, void(uint32_t, double)); - MOCK_METHOD1(deleteTimer, void(uint32_t)); + MOCK_METHOD(void, createTimer, (uint32_t, double), (override)); + MOCK_METHOD(void, createRecurringTimer, (uint32_t, double), (override)); + MOCK_METHOD(void, deleteTimer, (uint32_t), (override)); }; class MockMessageQueueThread : public MessageQueueThread { diff --git a/packages/react-native/ReactCommon/react/runtime/tests/cxx/RuntimeExecutorShutdownTest.cpp b/packages/react-native/ReactCommon/react/runtime/tests/cxx/RuntimeExecutorShutdownTest.cpp new file mode 100644 index 00000000000..f68527cc20f --- /dev/null +++ b/packages/react-native/ReactCommon/react/runtime/tests/cxx/RuntimeExecutorShutdownTest.cpp @@ -0,0 +1,149 @@ +/* + * Copyright (c) Meta Platforms, Inc. and affiliates. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + */ + +#include +#include +#include + +#include +#include + +#include +#include +#include +#include +#include + +namespace facebook::react { + +namespace { + +class MockTimerRegistry : public PlatformTimerRegistry { + public: + MOCK_METHOD(void, createTimer, (uint32_t, double), (override)); + MOCK_METHOD(void, createRecurringTimer, (uint32_t, double), (override)); + MOCK_METHOD(void, deleteTimer, (uint32_t), (override)); +}; + +class MockMessageQueueThread : public MessageQueueThread { + public: + void runOnQueue(std::function&& func) override { + callbackQueue_.push(std::move(func)); + } + + void runOnQueueSync(std::function&& /*unused*/) override {} + void quitSynchronous() override {} + + void tick() { + while (!callbackQueue_.empty()) { + auto callback = std::move(callbackQueue_.front()); + callbackQueue_.pop(); + callback(); + } + } + + size_t size() const { + return callbackQueue_.size(); + } + + private: + std::queue> callbackQueue_; +}; + +} // namespace + +class RuntimeExecutorShutdownTest : public ::testing::Test { + protected: + void SetUp() override { + auto runtime = + std::make_unique(hermes::makeHermesRuntime()); + messageQueueThread_ = std::make_shared(); + auto mockRegistry = std::make_unique(); + auto timerManager = std::make_shared(std::move(mockRegistry)); + auto onJsError = + [](jsi::Runtime& /*runtime*/, + const JsErrorHandler::ProcessedError& /*error*/) noexcept {}; + + instance_ = std::make_unique( + std::move(runtime), + messageQueueThread_, + timerManager, + std::move(onJsError)); + } + + std::shared_ptr messageQueueThread_; + std::unique_ptr instance_; +}; + +// Calling a held RuntimeExecutor after ReactInstance has been destroyed +// must silently drop the callback. Use a shared_ptr captured into the +// callback to also prove the callback itself is destroyed (not retained +// somewhere indefinitely). +TEST_F( + RuntimeExecutorShutdownTest, + heldExecutorCallAfterShutdownDropsCallback) { + RuntimeExecutor executor = instance_->getBufferedRuntimeExecutor(); + + instance_.reset(); + + auto tracker = std::make_shared(0); + std::weak_ptr weakTracker = tracker; + executor([tracker = std::move(tracker)](jsi::Runtime& /*runtime*/) { + FAIL() << "Callback should never run after shutdown"; + }); + + EXPECT_EQ(messageQueueThread_->size(), 0u); + EXPECT_TRUE(weakTracker.expired()) + << "Rejected callback (and its captures) should be destroyed"; + messageQueueThread_->tick(); +} + +// Repeated post-shutdown invocations must remain memory-safe. This guards +// against future refactors that swap the weak_ptr capture for a raw pointer +// or shared_ptr. +TEST_F(RuntimeExecutorShutdownTest, heldExecutorCallAfterShutdownDoesNotCrash) { + RuntimeExecutor executor = instance_->getBufferedRuntimeExecutor(); + + instance_.reset(); + + for (int i = 0; i < 100; ++i) { + executor([](jsi::Runtime& /*runtime*/) { + FAIL() << "Callback should never run after shutdown"; + }); + } + messageQueueThread_->tick(); +} + +// Work scheduled through the buffered executor sits in the internal buffer +// until flush() (which only happens via loadScript). If the ReactInstance +// is destroyed before flush, the buffered work must be dropped — never +// surfaced on the JS queue and never retained past instance destruction. +// A shared_ptr captured into the callback, watched via weak_ptr from +// outside, proves the buffered queue actually releases its contents. +TEST_F( + RuntimeExecutorShutdownTest, + pendingCallbackShutdownBeforeTickDropsCallback) { + RuntimeExecutor executor = instance_->getBufferedRuntimeExecutor(); + + auto tracker = std::make_shared(0); + std::weak_ptr weakTracker = tracker; + executor([tracker = std::move(tracker)](jsi::Runtime& /*runtime*/) { + FAIL() << "Buffered callback should never run after shutdown"; + }); + + EXPECT_EQ(messageQueueThread_->size(), 0u); + EXPECT_FALSE(weakTracker.expired()) + << "Callback should still be alive in BufferedRuntimeExecutor's queue"; + + instance_.reset(); + + EXPECT_TRUE(weakTracker.expired()) + << "Buffered callback should be destroyed when ReactInstance is"; + messageQueueThread_->tick(); +} + +} // namespace facebook::react