xplat/js/react-native-github/packages/react-native/ReactAndroid/src/main/jni/react/fabric/FabricMountingManager.cpp (#57433)

Summary: Pull Request resolved: https://github.com/react/react-native/pull/57433

Differential Revision: D108739423

fbshipit-source-id: 306d2041d8ff0e17c0f2e387d3ce8ff3f65a71c0
This commit is contained in:
generatedunixname1563563004708334 authored and meta-codesync[bot] committed 2026-07-06 03:28:05 -07:00
1 parent e04ff69ab3
commit 22ff92575a
1 file changed
+159
@@ -0,0 +1,159 @@
/*
* 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 <react/fabric/FabricMountingManager.h>
#include <fbjni/fbjni.h>
#include <gtest/gtest.h>
#include <memory>
namespace facebook::react {
/**
* Pure-C++ unit tests for the surface-registry behavior of
* `FabricMountingManager`. The class as a whole is heavily JNI-coupled; full
* end-to-end coverage lives in the Robolectric-driven instrumentation tests
* under
* `ReactAndroid/src/test/java/com/facebook/react/fabric/FabricMountingManagerInstrumentationTest`.
*
* These tests focus on the small, JNI-free slice of the public API:
* - `onSurfaceStart` — populates the allocated-view registry for a new
* surface.
* - `onSurfaceStop` — removes the registry entry for a surface.
* - `isViewAllocated` — returns whether a `(surfaceId, tag)` pair is
* registered.
*
* These three methods only touch in-memory state guarded by
* `allocatedViewsMutex_`; they never call into Java. That is what makes them
* unit-testable here.
*
* NOTE: `~FabricMountingManager()` calls `jni::ThreadScope::WithClassLoader`,
* which throws `std::runtime_error` when no JavaVM has been attached (see
* `xplat/spectrum/androidLibs/fbjni/cxx/fbjni/detail/Environment.h`). Because
* no JVM is available in this host-side test, the manager instance is
* intentionally never destroyed: each test allocates a single
* `FabricMountingManager` on the heap and wraps it in a `std::shared_ptr`
* with a no-op deleter. The resulting per-test leak is bounded (one ~100-byte
* instance) and does not cross test boundaries.
*/
class FabricMountingManagerTest : public ::testing::Test {
protected:
// Returns a `FabricMountingManager` whose destructor is suppressed.
// See the class-level note above for why this is necessary.
static std::shared_ptr<FabricMountingManager> makeManager() {
// `jni::global_ref<>` default-constructs to an empty (null) reference,
// so no JNI calls are performed during construction. The empty
// reference is safe to copy into the manager because the
// surface-registry methods under test never dereference
// `javaUIManager_`.
auto* emptyRef = new jni::global_ref<JFabricUIManager::javaobject>();
auto* raw = new FabricMountingManager(*emptyRef);
// `emptyRef` is intentionally leaked: resetting it would also engage
// `WithClassLoader`, which requires an attached JavaVM.
return {raw, [](FabricMountingManager* /*unused*/) noexcept {
// No-op deleter: see class-level note.
}};
}
};
/*
* Verifies that `onSurfaceStart` seeds the allocated-view registry for the
* new surface with the surface tag itself. Downstream, `executeMount` relies
* on this seeding to detect "executing commit after surface ... was stopped"
* and to short-circuit a redundant Create mount item for the root view.
*
* Bug this catches: if a refactor stops registering the root surface tag
* (e.g. switches to `unordered_set<Tag>{}` instead of
* `unordered_set<Tag>({surfaceId})`), the root view would be re-created on
* every commit. Without this assertion, that regression would only surface
* via end-to-end Java tests.
*/
TEST_F(
FabricMountingManagerTest,
onSurfaceStartRegistersSurfaceTagAsAllocated) {
auto manager = makeManager();
constexpr SurfaceId kSurfaceId = 42;
manager->onSurfaceStart(kSurfaceId);
EXPECT_TRUE(manager->isViewAllocated(kSurfaceId, /*tag=*/kSurfaceId));
}
/*
* Verifies that `isViewAllocated` returns false for a surface that has not
* been started. The contract is "false when the surface is unknown", not
* "throw" or "abort"; `executeMount` and `preallocateShadowView` both rely
* on this to gracefully no-op when a surface has been stopped concurrently.
*/
TEST_F(
FabricMountingManagerTest,
isViewAllocatedReturnsFalseForSurfaceThatWasNeverStarted) {
auto manager = makeManager();
// Tag is arbitrary; the registry has no entry for surface 9999 so any
// tag must report unallocated.
EXPECT_FALSE(manager->isViewAllocated(/*surfaceId=*/9999, /*tag=*/12345));
}
/*
* Verifies that `onSurfaceStop` removes the surface's entire registry entry
* — not just clears its contents. After `onSurfaceStop`, `isViewAllocated`
* must return false for *any* tag on that surface, including the surface
* tag itself (which `onSurfaceStart` had inserted).
*
* Bug this catches: if `onSurfaceStop` only `.clear()`-ed the inner set
* instead of erasing the outer map entry, `executeMount`'s "surface was
* stopped" log would never fire, masking commit-after-stop bugs.
*/
TEST_F(
FabricMountingManagerTest,
onSurfaceStopRemovesEntireRegistryForSurface) {
auto manager = makeManager();
constexpr SurfaceId kSurfaceId = 7;
manager->onSurfaceStart(kSurfaceId);
ASSERT_TRUE(manager->isViewAllocated(kSurfaceId, kSurfaceId));
manager->onSurfaceStop(kSurfaceId);
EXPECT_FALSE(manager->isViewAllocated(kSurfaceId, kSurfaceId));
}
/*
* Verifies that registries for distinct surfaces are isolated: starting and
* stopping one surface must not leak state into another. This is the
* concurrency-safety invariant that lets multiple React surfaces coexist in
* the same process.
*
* Bug this catches: if a future change accidentally shared the
* `unordered_set<Tag>` across surfaces (e.g. via a misplaced static), tags
* from one surface would falsely appear as allocated on another, and
* stopping any surface would purge unrelated surfaces' registries.
*/
TEST_F(
FabricMountingManagerTest,
onSurfaceStartCreatesIsolatedRegistriesPerSurface) {
auto manager = makeManager();
constexpr SurfaceId kSurfaceA = 1;
constexpr SurfaceId kSurfaceB = 2;
manager->onSurfaceStart(kSurfaceA);
manager->onSurfaceStart(kSurfaceB);
// Each surface knows about its own tag but not the other surface's tag.
EXPECT_TRUE(manager->isViewAllocated(kSurfaceA, /*tag=*/kSurfaceA));
EXPECT_FALSE(manager->isViewAllocated(kSurfaceA, /*tag=*/kSurfaceB));
EXPECT_TRUE(manager->isViewAllocated(kSurfaceB, /*tag=*/kSurfaceB));
EXPECT_FALSE(manager->isViewAllocated(kSurfaceB, /*tag=*/kSurfaceA));
// Stopping surface A must not affect surface B.
manager->onSurfaceStop(kSurfaceA);
EXPECT_FALSE(manager->isViewAllocated(kSurfaceA, kSurfaceA));
EXPECT_TRUE(manager->isViewAllocated(kSurfaceB, kSurfaceB));
}
} // namespace facebook::react