Add unit tests for enableMainQueueCoordinatorOnIOS (#56934)

Summary:
Pull Request resolved: #56934

The `enableMainQueueCoordinatorOnIOS` flag swaps two non-trivial threading primitives — `RCTUnsafeExecuteOnMainQueueSync` uses either `dispatch_sync(main, ...)` or `unsafeExecuteOnMainThreadSync`, and `executeSynchronouslyOnSameThread_CAN_DEADLOCK` switches between `saferExecuteSynchronouslyOnSameThread_CAN_DEADLOCK` and the legacy variant. There was zero in-tree test coverage for either branch.

Adds three characterization tests:

- `testRCTUnsafeExecuteOnMainQueueSync_flagOff_runsBlockOnMainFromBG` and `..._flagOn_...` pin the basic contract for both branches: from a background thread, the block runs on the main queue and the call returns synchronously.
- `testExecuteSynchronouslyOnSameThread_flagOn_pumpsUITasksWhileWaitingForJS` is the coordinator's signature property: while the main thread is blocked in the safer impl's wait loop, a UI task posted from a background thread is pumped before the runtime work resumes. The test wires a deliberately slow `RuntimeExecutor` (300ms sleep before invoking its callback) so a BG thread can post a `RCTUnsafeExecuteOnMainQueueSync` work item during the window, then asserts the ordering via a monotonic sequence counter.
- `basicUIThreadExecution` (in `RuntimeSchedulerTest.cpp`) mirrors the existing `basicSameThreadExecution` for the production call pattern: the caller is the GTest test body (main NSThread on Apple), so `executeNowOnTheSameThread` routes through the coordinator path. An off-main `driver` thread ticks the stub queue so main can wake up.

Changelog: [Internal]

___

Differential Revision: D105972787

fbshipit-source-id: 98325021d0d770b4fe3a9da707c724ef8febbd62

Author: javache

packages/react-native/ReactCommon/react/renderer/runtimescheduler/tests/RuntimeSchedulerTest.cpp

@@ -951,6 +951,40 @@ TEST_P(RuntimeSchedulerTest, basicSameThreadExecution) {
   EXPECT_TRUE(didRunSynchronousTask);
 }
 
+// Mirror of `basicSameThreadExecution` for the production call pattern: the
+// caller is the UI thread (XCTest test methods run on the main NSThread on
+// Apple), so `executeNowOnTheSameThread` routes through the coordinator path
+// in `executeSynchronouslyOnSameThread_CAN_DEADLOCK`. The off-main `driver`
+// thread drives the stub queue ("JS thread") so the main thread can wake up.
+TEST_P(RuntimeSchedulerTest, basicUIThreadExecution) {
+  class CoordinatorFeatureFlags : public RuntimeSchedulerTestFeatureFlags {
+   public:
+    using RuntimeSchedulerTestFeatureFlags::RuntimeSchedulerTestFeatureFlags;
+    bool enableMainQueueCoordinatorOnIOS() override {
+      return true;
+    }
+  };
+  ReactNativeFeatureFlags::dangerouslyReset();
+  ReactNativeFeatureFlags::override(
+      std::make_unique<CoordinatorFeatureFlags>(GetParam()));
+
+  bool didRunSynchronousTask = false;
+
+  std::thread driver([this]() {
+    stubQueue_->waitForTask();
+    stubQueue_->tick();
+  });
+
+  runtimeScheduler_->executeNowOnTheSameThread(
+      [&didRunSynchronousTask](jsi::Runtime& /*rt*/) {
+        didRunSynchronousTask = true;
+      });
+
+  driver.join();
+
+  EXPECT_TRUE(didRunSynchronousTask);
+}
+
 TEST_P(RuntimeSchedulerTest, sameThreadTaskCreatesImmediatePriorityTask) {
   bool didRunSynchronousTask = false;
   bool didRunSubsequentTask = false;

packages/react-native/ReactCommon/react/runtime/iostests/MainQueueCoordinatorTests.mm

@@ -0,0 +1,147 @@
+/*
+ * 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.
+ */
+
+#import <XCTest/XCTest.h>
+
+#import <React/RCTUtils.h>
+#import <ReactCommon/RuntimeExecutor.h>
+#import <ReactCommon/RuntimeExecutorSyncUIThreadUtils.h>
+#import <hermes/hermes.h>
+#import <react/featureflags/ReactNativeFeatureFlags.h>
+#import <react/featureflags/ReactNativeFeatureFlagsDefaults.h>
+#import <atomic>
+#import <chrono>
+#import <thread>
+
+using namespace facebook::react;
+
+namespace {
+class MainQueueCoordinatorOverride : public ReactNativeFeatureFlagsDefaults {
+ public:
+  explicit MainQueueCoordinatorOverride(bool enabled) : enabled_(enabled) {}
+  bool enableMainQueueCoordinatorOnIOS() override
+  {
+    return enabled_;
+  }
+
+ private:
+  bool enabled_;
+};
+} // namespace
+
+@interface MainQueueCoordinatorTests : XCTestCase
+@end
+
+@implementation MainQueueCoordinatorTests
+
+- (void)setUp
+{
+  [super setUp];
+  ReactNativeFeatureFlags::dangerouslyReset();
+}
+
+- (void)tearDown
+{
+  ReactNativeFeatureFlags::dangerouslyReset();
+  [super tearDown];
+}
+
+#pragma mark - RCTUnsafeExecuteOnMainQueueSync
+
+- (void)_assertRCTUnsafeExecuteOnMainQueueSyncRunsBlockOnMainFromBackgroundThread
+{
+  XCTestExpectation *done = [self expectationWithDescription:@"BG-thread call completed"];
+  __block BOOL ranOnMain = NO;
+  __block BOOL returnedToBG = NO;
+
+  dispatch_async(dispatch_get_global_queue(QOS_CLASS_USER_INITIATED, 0), ^{
+    RCTUnsafeExecuteOnMainQueueSync(^{
+      ranOnMain = RCTIsMainQueue();
+    });
+    returnedToBG = YES;
+    [done fulfill];
+  });
+
+  [self waitForExpectations:@[ done ] timeout:5.0];
+  XCTAssertTrue(ranOnMain, @"Block must execute on main queue");
+  XCTAssertTrue(returnedToBG, @"BG thread must resume after sync call returns");
+}
+
+- (void)testRCTUnsafeExecuteOnMainQueueSync_flagOff_runsBlockOnMainFromBG
+{
+  // Default off — exercises the dispatch_sync(main) branch.
+  [self _assertRCTUnsafeExecuteOnMainQueueSyncRunsBlockOnMainFromBackgroundThread];
+}
+
+- (void)testRCTUnsafeExecuteOnMainQueueSync_flagOn_runsBlockOnMainFromBG
+{
+  ReactNativeFeatureFlags::override(std::make_unique<MainQueueCoordinatorOverride>(true));
+  // Coordinator branch — `unsafeExecuteOnMainThreadSync` posts a UI task and waits.
+  [self _assertRCTUnsafeExecuteOnMainQueueSyncRunsBlockOnMainFromBackgroundThread];
+}
+
+#pragma mark - executeSynchronouslyOnSameThread_CAN_DEADLOCK
+
+- (void)testExecuteSynchronouslyOnSameThread_flagOn_pumpsUITasksWhileWaitingForJS
+{
+  ReactNativeFeatureFlags::override(std::make_unique<MainQueueCoordinatorOverride>(true));
+
+  // A real runtime — needed only for the reference type. We never call into it.
+  auto runtime = facebook::hermes::makeHermesRuntime();
+
+  // A "JS thread" that the executor posts to. Sleeps before invoking the callback
+  // so that the main thread is forced to wait, giving us a window to post a UI task.
+  constexpr auto kJSDelay = std::chrono::milliseconds(300);
+
+  RuntimeExecutor slowJSExecutor = [&runtime, kJSDelay](std::function<void(facebook::jsi::Runtime &)> &&callback) {
+    std::thread([cb = std::move(callback), &runtime, kJSDelay]() mutable {
+      std::this_thread::sleep_for(kJSDelay);
+      cb(*runtime);
+    }).detach();
+  };
+
+  // Both threads only ever write on main, so plain ints are race-free. Held in
+  // a struct so we can capture a pointer from an ObjC block and a reference
+  // from a C++ lambda without `__block` (which doesn't compose with lambdas).
+  struct State {
+    int sequence = 0;
+    int uiTaskOrder = 0;
+    int runtimeWorkOrder = 0;
+    BOOL uiTaskRanOnMain = NO;
+    BOOL runtimeWorkRanOnMain = NO;
+  };
+  State state;
+  State *statePtr = &state;
+
+  // Background thread posts a UI task ~100ms after the main thread enters the
+  // wait loop — well before the JS thread wakes up at +300ms.
+  XCTestExpectation *bgDone = [self expectationWithDescription:@"BG-thread sync call completed"];
+  dispatch_async(dispatch_get_global_queue(QOS_CLASS_USER_INITIATED, 0), ^{
+    std::this_thread::sleep_for(std::chrono::milliseconds(100));
+    RCTUnsafeExecuteOnMainQueueSync(^{
+      statePtr->uiTaskOrder = ++statePtr->sequence;
+      statePtr->uiTaskRanOnMain = RCTIsMainQueue();
+    });
+    [bgDone fulfill];
+  });
+
+  // This call blocks main inside the coordinator's wait loop. While it waits,
+  // it should pump the UI task posted by the BG thread above.
+  executeSynchronouslyOnSameThread_CAN_DEADLOCK(slowJSExecutor, [&state](facebook::jsi::Runtime & /*_*/) {
+    state.runtimeWorkOrder = ++state.sequence;
+    state.runtimeWorkRanOnMain = RCTIsMainQueue();
+  });
+
+  [self waitForExpectations:@[ bgDone ] timeout:5.0];
+
+  XCTAssertTrue(state.uiTaskRanOnMain, @"UI task posted from BG should run on main");
+  XCTAssertTrue(state.runtimeWorkRanOnMain, @"runtimeWork should run on main");
+  XCTAssertEqual(state.uiTaskOrder, 1, @"UI task should be pumped before runtimeWork");
+  XCTAssertEqual(state.runtimeWorkOrder, 2, @"runtimeWork should run after the pumped UI task");
+}
+
+@end