react-native-tvos 0.87.1-0 → 0.88.0-0rc2

package/ReactAndroid/src/main/java/com/facebook/react/views/view/ReactViewGroup.kt

@@ -166,6 +166,10 @@ public open class ReactViewGroup public constructor(context: Context?) :
 
   public override var hitSlopRect: Rect? = null
   public override var pointerEvents: PointerEvents = PointerEvents.AUTO
+    set(value) {
+      field = value
+      ImportantForInteractionHelper.setImportantForInteraction(this, value, _overflow)
+    }
 
   public var axOrderList: MutableList<String>? = null
 
@@ -203,9 +207,9 @@ public open class ReactViewGroup public constructor(context: Context?) :
     allChildrenCount = 0
     clippingRect = null
     hitSlopRect = null
+    // pointerEvents setter reads _overflow, so _overflow must be assigned first.
     _overflow = Overflow.VISIBLE
     pointerEvents = PointerEvents.AUTO
-    ImportantForInteractionHelper.setImportantForInteraction(this, pointerEvents)
     childrenLayoutChangeListener = null
     onInterceptTouchEventListener = null
     needsOffscreenAlphaCompositing = false
@@ -285,7 +289,7 @@ public open class ReactViewGroup public constructor(context: Context?) :
   }
 
   @Deprecated(
-      "setTranslucentBackgroundDrawable is deprecated since React Native 0.76.0 and will be removed in a future version"
+      "setTranslucentBackgroundDrawable is deprecated since React Native 0.76.0 and will be removed in a future version",
   )
   public fun setTranslucentBackgroundDrawable(background: Drawable?) {
     setFeedbackUnderlay(this, background)
@@ -509,7 +513,7 @@ public open class ReactViewGroup public constructor(context: Context?) :
       }
       if (i - clippedSoFar > childCount) {
         throw IllegalStateException(
-            "Invalid clipping state. i=$i clippedSoFar=$clippedSoFar count=$childCount allChildrenCount=$allChildrenCount recycleCount=$recycleCount  excludedViews=${excludedViewsSet?.size ?: 0}"
+            "Invalid clipping state. i=$i clippedSoFar=$clippedSoFar count=$childCount allChildrenCount=$allChildrenCount recycleCount=$recycleCount  excludedViews=${excludedViewsSet?.size ?: 0}",
         )
       }
     }
@@ -868,12 +872,12 @@ public open class ReactViewGroup public constructor(context: Context?) :
                 logSoftException(
                     ReactSoftExceptionLogger.Categories.CLIPPING_PROHIBITED_VIEW,
                     ReactNoCrashSoftException(
-                        "Child view has been added to Parent view in which it is clipped and not visible. This is not legal for this particular child view. Child: [${child.id}] $child Parent: [$id] ${toString()}"
+                        "Child view has been added to Parent view in which it is clipped and not visible. This is not legal for this particular child view. Child: [${child.id}] $child Parent: [$id] ${toString()}",
                     ),
                 )
               }
             }
-          }
+          },
       )
     }
   }
@@ -925,7 +929,7 @@ public open class ReactViewGroup public constructor(context: Context?) :
       logSoftException(
           ReactSoftExceptionLogger.Categories.RVG_IS_VIEW_CLIPPED,
           ReactNoCrashSoftException(
-              "View missing clipping tag: index=$index parentNull=${parent == null} parentThis=${parent === this} transitioning=$transitioning"
+              "View missing clipping tag: index=$index parentNull=${parent == null} parentThis=${parent === this} transitioning=$transitioning",
           ),
       )
     }
@@ -991,22 +995,17 @@ public open class ReactViewGroup public constructor(context: Context?) :
     }
   }
 
-  private var _overflow: Overflow? = null
+  private var _overflow: Overflow = Overflow.VISIBLE
   override var overflow: String?
     get() =
         when (_overflow) {
           Overflow.HIDDEN -> "hidden"
           Overflow.SCROLL -> "scroll"
           Overflow.VISIBLE -> "visible"
-          else -> null
         }
     set(overflow) {
-      _overflow =
-          if (overflow == null) {
-            Overflow.VISIBLE
-          } else {
-            Overflow.fromString(overflow)
-          }
+      _overflow = Overflow.fromString(overflow)
+      ImportantForInteractionHelper.setImportantForInteraction(this, pointerEvents, _overflow)
       invalidate()
     }
 
@@ -1019,9 +1018,7 @@ public open class ReactViewGroup public constructor(context: Context?) :
    */
   override fun getClipBounds(): Rect? {
     if (
-        ReactNativeFeatureFlags.syncAndroidClipBoundsWithOverflow() &&
-            _overflow != null &&
-            _overflow != Overflow.VISIBLE
+        ReactNativeFeatureFlags.syncAndroidClipBoundsWithOverflow() && _overflow != Overflow.VISIBLE
     ) {
       val rect = Rect()
       getPaddingBoxRect(this, rect)
@@ -1033,9 +1030,7 @@ public open class ReactViewGroup public constructor(context: Context?) :
   /** See [getClipBounds]. */
   override fun getClipBounds(outRect: Rect): Boolean {
     if (
-        ReactNativeFeatureFlags.syncAndroidClipBoundsWithOverflow() &&
-            _overflow != null &&
-            _overflow != Overflow.VISIBLE
+        ReactNativeFeatureFlags.syncAndroidClipBoundsWithOverflow() && _overflow != Overflow.VISIBLE
     ) {
       getPaddingBoxRect(this, outRect)
       return true

package/ReactAndroid/src/main/java/com/facebook/react/views/view/ReactViewManager.kt

@@ -52,19 +52,18 @@ public open class ReactViewManager : ReactClippingViewManager<ReactViewGroup>()
   public companion object {
     public const val REACT_CLASS: String = ViewProps.VIEW_CLASS_NAME
 
-    private val SPACING_TYPES =
-        intArrayOf(
-            Spacing.ALL,
-            Spacing.LEFT,
-            Spacing.RIGHT,
-            Spacing.TOP,
-            Spacing.BOTTOM,
-            Spacing.START,
-            Spacing.END,
-            Spacing.BLOCK,
-            Spacing.BLOCK_END,
-            Spacing.BLOCK_START,
-        )
+    private val SPACING_TYPES = intArrayOf(
+        Spacing.ALL,
+        Spacing.LEFT,
+        Spacing.RIGHT,
+        Spacing.TOP,
+        Spacing.BOTTOM,
+        Spacing.START,
+        Spacing.END,
+        Spacing.BLOCK,
+        Spacing.BLOCK_END,
+        Spacing.BLOCK_START,
+    )
     private const val CMD_HOTSPOT_UPDATE = 1
     private const val CMD_SET_PRESSED = 2
     private const val CMD_SET_DESTINATIONS = 3
@@ -239,6 +238,18 @@ public open class ReactViewManager : ReactClippingViewManager<ReactViewGroup>()
     }
   }
 
+  @Deprecated(
+      "Use setBackgroundSize instead.",
+      ReplaceWith("setBackgroundSize(view, backgroundSize)"),
+  )
+  @ReactProp(name = ViewProps.EXPERIMENTAL_BACKGROUND_SIZE, customType = "BackgroundSize")
+  public open fun setExperimentalBackgroundSize(
+      view: ReactViewGroup,
+      backgroundSize: ReadableArray?,
+  ) {
+    setBackgroundSize(view, backgroundSize)
+  }
+
   @ReactProp(name = ViewProps.BACKGROUND_POSITION, customType = "BackgroundPosition")
   public open fun setBackgroundPosition(view: ReactViewGroup, backgroundPosition: ReadableArray?) {
     if (backgroundPosition != null && backgroundPosition.size() > 0) {
@@ -256,6 +267,18 @@ public open class ReactViewManager : ReactClippingViewManager<ReactViewGroup>()
     }
   }
 
+  @Deprecated(
+      "Use setBackgroundPosition instead.",
+      ReplaceWith("setBackgroundPosition(view, backgroundPosition)"),
+  )
+  @ReactProp(name = ViewProps.EXPERIMENTAL_BACKGROUND_POSITION, customType = "BackgroundPosition")
+  public open fun setExperimentalBackgroundPosition(
+      view: ReactViewGroup,
+      backgroundPosition: ReadableArray?,
+  ) {
+    setBackgroundPosition(view, backgroundPosition)
+  }
+
   @ReactProp(name = ViewProps.BACKGROUND_REPEAT, customType = "BackgroundRepeat")
   public open fun setBackgroundRepeat(view: ReactViewGroup, backgroundRepeat: ReadableArray?) {
     if (backgroundRepeat != null && backgroundRepeat.size() > 0) {
@@ -273,6 +296,18 @@ public open class ReactViewManager : ReactClippingViewManager<ReactViewGroup>()
     }
   }
 
+  @Deprecated(
+      "Use setBackgroundRepeat instead.",
+      ReplaceWith("setBackgroundRepeat(view, backgroundRepeat)"),
+  )
+  @ReactProp(name = ViewProps.EXPERIMENTAL_BACKGROUND_REPEAT, customType = "BackgroundRepeat")
+  public open fun setExperimentalBackgroundRepeat(
+      view: ReactViewGroup,
+      backgroundRepeat: ReadableArray?,
+  ) {
+    setBackgroundRepeat(view, backgroundRepeat)
+  }
+
   @ReactProp(name = "nextFocusDown", defaultInt = View.NO_ID)
   public open fun nextFocusDown(view: ReactViewGroup, viewId: Int) {
     view.nextFocusDownId = viewId
@@ -314,7 +349,7 @@ public open class ReactViewManager : ReactClippingViewManager<ReactViewGroup>()
               ViewProps.BORDER_END_START_RADIUS,
               ViewProps.BORDER_START_END_RADIUS,
               ViewProps.BORDER_START_START_RADIUS,
-          ]
+          ],
   )
   public open fun setBorderRadius(view: ReactViewGroup, index: Int, rawBorderRadius: Dynamic) {
     val borderRadius = LengthPercentage.setFromDynamic(rawBorderRadius)
@@ -372,7 +407,6 @@ public open class ReactViewManager : ReactClippingViewManager<ReactViewGroup>()
   @ReactProp(name = ViewProps.POINTER_EVENTS)
   public open fun setPointerEvents(view: ReactViewGroup, pointerEventsStr: String?) {
     view.pointerEvents = PointerEvents.parsePointerEvents(pointerEventsStr)
-    ImportantForInteractionHelper.setImportantForInteraction(view, view.pointerEvents)
   }
 
   @ReactProp(name = "nativeBackgroundAndroid")
@@ -452,7 +486,7 @@ public open class ReactViewManager : ReactClippingViewManager<ReactViewGroup>()
       view.setOnClickListener {
         val eventDispatcher = UIManagerHelper.getEventDispatcher(view.context as ReactContext)
         eventDispatcher?.dispatchEvent(
-            ViewGroupClickEvent(UIManagerHelper.getSurfaceId(view.context), view.id)
+            ViewGroupClickEvent(UIManagerHelper.getSurfaceId(view.context), view.id),
         )
       }
 
@@ -541,7 +575,7 @@ public open class ReactViewManager : ReactClippingViewManager<ReactViewGroup>()
   private fun handleSetPressed(root: ReactViewGroup, args: ReadableArray?) {
     if (args == null || args.size() != 1) {
       throw JSApplicationIllegalArgumentException(
-          "Illegal number of arguments for 'setPressed' command"
+          "Illegal number of arguments for 'setPressed' command",
       )
     }
     root.isPressed = args.getBoolean(0)
@@ -550,7 +584,7 @@ public open class ReactViewManager : ReactClippingViewManager<ReactViewGroup>()
   private fun handleHotspotUpdate(root: ReactViewGroup, args: ReadableArray?) {
     if (args == null || args.size() != 2) {
       throw JSApplicationIllegalArgumentException(
-          "Illegal number of arguments for 'updateHotspot' command"
+          "Illegal number of arguments for 'updateHotspot' command",
       )
     }
 

package/ReactAndroid/src/main/java/com/facebook/react/views/virtual/view/ReactVirtualViewManager.kt

@@ -99,7 +99,7 @@ public class VirtualViewEventEmitter(
             targetRect,
             thresholdRect,
             synchronous,
-        )
+        ),
     )
   }
 }

package/ReactAndroid/src/main/java/com/facebook/yoga/YogaNodeJNIBase.kt

@@ -38,9 +38,9 @@ public abstract class YogaNodeJNIBase : YogaNode, Cloneable {
   internal constructor() : this(YogaNative.jni_YGNodeNewJNI())
 
   internal constructor(
-      yogaConfig: YogaConfig
+      yogaConfig: YogaConfig,
   ) : this(
-      YogaNative.jni_YGNodeNewWithConfigJNI((yogaConfig as YogaConfigJNIBase).getNativePointer())
+      YogaNative.jni_YGNodeNewWithConfigJNI((yogaConfig as YogaConfigJNIBase).getNativePointer()),
   ) {
     config = yogaConfig
   }
@@ -134,7 +134,7 @@ public abstract class YogaNodeJNIBase : YogaNode, Cloneable {
     val childList =
         children
             ?: throw IllegalStateException(
-                "Trying to remove a child of a YogaNode that does not have children"
+                "Trying to remove a child of a YogaNode that does not have children",
             )
     val child = childList.removeAt(i)
     child.owner = null

package/ReactAndroid/src/main/jni/CMakeLists.txt

@@ -58,6 +58,14 @@ add_react_third_party_ndk_subdir(fast_float)
 add_react_third_party_ndk_subdir(fmt)
 add_react_third_party_ndk_subdir(folly)
 
+# Marks everything added below as React Native's own build, so the
+# react/cxxstableapi guards let internal sources keep including the
+# fine-grained headers they fence off from consumers. Deliberately declared
+# after the third-party subdirectories so it never reaches them, and this
+# project never compiles app or third-party module code (those build against
+# the prefab artifacts through ReactNative-application.cmake).
+add_compile_definitions(RN_BUILDING)
+
 # Common targets
 add_react_common_subdir(yoga)
 add_react_common_subdir(runtimeexecutor)
@@ -118,6 +126,7 @@ add_react_common_subdir(react/renderer/leakchecker)
 add_react_common_subdir(react/renderer/observers/events)
 add_react_common_subdir(react/renderer/observers/intersection)
 add_react_common_subdir(react/renderer/observers/mutation)
+add_react_common_subdir(react/renderer/observers/resize)
 add_react_common_subdir(react/renderer/textlayoutmanager)
 add_react_common_subdir(react/utils)
 add_react_common_subdir(react/bridging)
@@ -130,6 +139,7 @@ add_react_common_subdir(react/nativemodule/microtasks)
 add_react_common_subdir(react/nativemodule/idlecallbacks)
 add_react_common_subdir(react/nativemodule/intersectionobserver)
 add_react_common_subdir(react/nativemodule/mutationobserver)
+add_react_common_subdir(react/nativemodule/resizeobserver)
 add_react_common_subdir(react/nativemodule/viewtransition)
 add_react_common_subdir(react/nativemodule/webperformance)
 add_react_common_subdir(react/networking)
@@ -202,6 +212,7 @@ add_library(reactnative
           $<TARGET_OBJECTS:react_nativemodule_intersectionobserver>
           $<TARGET_OBJECTS:react_nativemodule_microtasks>
           $<TARGET_OBJECTS:react_nativemodule_mutationobserver>
+          $<TARGET_OBJECTS:react_nativemodule_resizeobserver>
           $<TARGET_OBJECTS:react_nativemodule_viewtransition>
           $<TARGET_OBJECTS:react_nativemodule_webperformance>
           $<TARGET_OBJECTS:react_networking>
@@ -226,6 +237,7 @@ add_library(reactnative
           $<TARGET_OBJECTS:react_renderer_observers_events>
           $<TARGET_OBJECTS:react_renderer_observers_intersection>
           $<TARGET_OBJECTS:react_renderer_observers_mutation>
+          $<TARGET_OBJECTS:react_renderer_observers_resize>
           $<TARGET_OBJECTS:react_renderer_runtimescheduler>
           $<TARGET_OBJECTS:react_renderer_scheduler>
           $<TARGET_OBJECTS:react_renderer_telemetry>
@@ -302,6 +314,7 @@ target_include_directories(reactnative
         $<TARGET_PROPERTY:react_nativemodule_intersectionobserver,INTERFACE_INCLUDE_DIRECTORIES>
         $<TARGET_PROPERTY:react_nativemodule_microtasks,INTERFACE_INCLUDE_DIRECTORIES>
         $<TARGET_PROPERTY:react_nativemodule_mutationobserver,INTERFACE_INCLUDE_DIRECTORIES>
+        $<TARGET_PROPERTY:react_nativemodule_resizeobserver,INTERFACE_INCLUDE_DIRECTORIES>
         $<TARGET_PROPERTY:react_nativemodule_viewtransition,INTERFACE_INCLUDE_DIRECTORIES>
         $<TARGET_PROPERTY:react_nativemodule_webperformance,INTERFACE_INCLUDE_DIRECTORIES>
         $<TARGET_PROPERTY:react_networking,INTERFACE_INCLUDE_DIRECTORIES>
@@ -328,6 +341,7 @@ target_include_directories(reactnative
         $<TARGET_PROPERTY:react_renderer_observers_events,INTERFACE_INCLUDE_DIRECTORIES>
         $<TARGET_PROPERTY:react_renderer_observers_intersection,INTERFACE_INCLUDE_DIRECTORIES>
         $<TARGET_PROPERTY:react_renderer_observers_mutation,INTERFACE_INCLUDE_DIRECTORIES>
+        $<TARGET_PROPERTY:react_renderer_observers_resize,INTERFACE_INCLUDE_DIRECTORIES>
         $<TARGET_PROPERTY:react_renderer_runtimescheduler,INTERFACE_INCLUDE_DIRECTORIES>
         $<TARGET_PROPERTY:react_renderer_scheduler,INTERFACE_INCLUDE_DIRECTORIES>
         $<TARGET_PROPERTY:react_renderer_telemetry,INTERFACE_INCLUDE_DIRECTORIES>

package/ReactAndroid/src/main/jni/first-party/yogajni/jni/YGJNIVanilla.cpp

@@ -6,6 +6,7 @@
  */
 
 #include "YGJNIVanilla.h"
+#include <array>
 #include <bit>
 #include <cstring>
 #include <iostream>
@@ -276,7 +277,7 @@ YGTransferLayoutOutputsRecursive(JNIEnv* env, jobject thiz, YGNodeRef root) {
 
   const int arrSize = 6 + (marginFieldSet ? 4 : 0) + (paddingFieldSet ? 4 : 0) +
       (borderFieldSet ? 4 : 0);
-  float arr[18];
+  std::array<float, 18> arr; // NOLINT(cppcoreguidelines-pro-type-member-init)
   arr[LAYOUT_EDGE_SET_FLAG_INDEX] = static_cast<float>(fieldFlags);
   arr[LAYOUT_WIDTH_INDEX] = YGNodeLayoutGetWidth(root);
   arr[LAYOUT_HEIGHT_INDEX] = YGNodeLayoutGetHeight(root);
@@ -293,8 +294,8 @@ YGTransferLayoutOutputsRecursive(JNIEnv* env, jobject thiz, YGNodeRef root) {
         YGNodeLayoutGetMargin(root, YGEdgeBottom);
   }
   if (paddingFieldSet) {
-    int paddingStartIndex =
-        LAYOUT_PADDING_START_INDEX - (marginFieldSet ? 0 : 4);
+    auto paddingStartIndex = static_cast<size_t>(
+        LAYOUT_PADDING_START_INDEX - (marginFieldSet ? 0 : 4));
     arr[paddingStartIndex] = YGNodeLayoutGetPadding(root, YGEdgeLeft);
     arr[paddingStartIndex + 1] = YGNodeLayoutGetPadding(root, YGEdgeTop);
     arr[paddingStartIndex + 2] = YGNodeLayoutGetPadding(root, YGEdgeRight);
@@ -302,8 +303,9 @@ YGTransferLayoutOutputsRecursive(JNIEnv* env, jobject thiz, YGNodeRef root) {
   }
 
   if (borderFieldSet) {
-    int borderStartIndex = LAYOUT_BORDER_START_INDEX -
-        (marginFieldSet ? 0 : 4) - (paddingFieldSet ? 0 : 4);
+    auto borderStartIndex = static_cast<size_t>(
+        LAYOUT_BORDER_START_INDEX - (marginFieldSet ? 0 : 4) -
+        (paddingFieldSet ? 0 : 4));
     arr[borderStartIndex] = YGNodeLayoutGetBorder(root, YGEdgeLeft);
     arr[borderStartIndex + 1] = YGNodeLayoutGetBorder(root, YGEdgeTop);
     arr[borderStartIndex + 2] = YGNodeLayoutGetBorder(root, YGEdgeRight);
@@ -321,7 +323,7 @@ YGTransferLayoutOutputsRecursive(JNIEnv* env, jobject thiz, YGNodeRef root) {
 
     ScopedLocalRef<jfloatArray> arrFinal =
         make_local_ref(env, env->NewFloatArray(arrSize));
-    env->SetFloatArrayRegion(arrFinal.get(), 0, arrSize, arr);
+    env->SetFloatArrayRegion(arrFinal.get(), 0, arrSize, arr.data());
     env->SetObjectField(obj.get(), arrField, arrFinal.get());
   }
 
@@ -839,6 +841,7 @@ static void jni_YGNodeStyleSetGapPercentJNI(
 // Yoga specific properties, not compatible with flexbox specification
 YG_NODE_JNI_STYLE_PROP(jfloat, float, AspectRatio);
 
+// NOLINTNEXTLINE(facebook-hte-CArray, modernize-avoid-c-arrays)
 static JNINativeMethod methods[] = {
     {"jni_YGConfigNewJNI", "()J", (void*)jni_YGConfigNewJNI},
     {"jni_YGConfigFreeJNI", "(J)V", (void*)jni_YGConfigFreeJNI},

package/ReactAndroid/src/main/jni/first-party/yogajni/jni/tests/corefunctionsTest.cpp

@@ -0,0 +1,247 @@
+/*
+ * 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 "corefunctions.h"
+
+#include <gtest/gtest.h>
+#include <jni.h>
+#include "YogaJniException.h"
+
+namespace facebook::yoga::vanillajni {
+namespace {
+
+// A single byte handed out as opaque, never-dereferenced JNI handles (jclass,
+// jobject, jthrowable, jmethodID). The functions under test only compare these
+// against nullptr; they never look inside them.
+char gFakeHandleStorage = 0;
+
+template <typename T>
+T fakeHandle() {
+  return reinterpret_cast<T>(&gFakeHandleStorage);
+}
+
+// Overlay for JNIEnv. The real _JNIEnv is standard-layout with a single leading
+// functions pointer, so a FakeEnv* can be passed anywhere a JNIEnv* is expected
+// and cast back inside the interface callbacks to reach the per-instance,
+// test-controlled behavior below.
+struct FakeEnv {
+  const JNINativeInterface* functions;
+
+  jboolean exceptionCheckResult;
+  jthrowable exceptionOccurredResult;
+  jobject newGlobalRefResult;
+  jclass findClassResult;
+  jmethodID getMethodIdResult;
+  jobject newObjectResult;
+
+  int exceptionCheckCalls;
+  int exceptionClearCalls;
+};
+
+struct FakeVm {
+  const JNIInvokeInterface* functions;
+  JNIEnv* envToReturn;
+  jint getEnvResult;
+};
+
+FakeEnv* asFake(JNIEnv* env) {
+  return reinterpret_cast<FakeEnv*>(env);
+}
+
+jboolean fakeExceptionCheck(JNIEnv* env) {
+  auto* self = asFake(env);
+  ++self->exceptionCheckCalls;
+  return self->exceptionCheckResult;
+}
+
+jthrowable fakeExceptionOccurred(JNIEnv* env) {
+  return asFake(env)->exceptionOccurredResult;
+}
+
+void fakeExceptionClear(JNIEnv* env) {
+  ++asFake(env)->exceptionClearCalls;
+}
+
+jobject fakeNewGlobalRef(JNIEnv* env, jobject /*obj*/) {
+  return asFake(env)->newGlobalRefResult;
+}
+
+void fakeDeleteGlobalRef(JNIEnv* /*env*/, jobject /*obj*/) {}
+
+jclass fakeFindClass(JNIEnv* env, const char* /*name*/) {
+  return asFake(env)->findClassResult;
+}
+
+jmethodID fakeGetMethodID(
+    JNIEnv* env,
+    jclass /*clazz*/,
+    const char* /*name*/,
+    const char* /*sig*/) {
+  return asFake(env)->getMethodIdResult;
+}
+
+jobject fakeNewObjectV(
+    JNIEnv* env,
+    jclass /*clazz*/,
+    jmethodID /*methodId*/,
+    va_list /*args*/) {
+  return asFake(env)->newObjectResult;
+}
+
+const JNINativeInterface& fakeNativeInterface() {
+  static const JNINativeInterface table = [] {
+    JNINativeInterface t{};
+    t.ExceptionCheck = &fakeExceptionCheck;
+    t.ExceptionOccurred = &fakeExceptionOccurred;
+    t.ExceptionClear = &fakeExceptionClear;
+    t.NewGlobalRef = &fakeNewGlobalRef;
+    t.DeleteGlobalRef = &fakeDeleteGlobalRef;
+    t.FindClass = &fakeFindClass;
+    t.GetMethodID = &fakeGetMethodID;
+    t.NewObjectV = &fakeNewObjectV;
+    return t;
+  }();
+  return table;
+}
+
+jint fakeGetEnv(JavaVM* vm, void** out, jint /*version*/) {
+  auto* self = reinterpret_cast<FakeVm*>(vm);
+  *out = self->envToReturn;
+  return self->getEnvResult;
+}
+
+const JNIInvokeInterface& fakeInvokeInterface() {
+  static const JNIInvokeInterface table = [] {
+    JNIInvokeInterface t{};
+    t.GetEnv = &fakeGetEnv;
+    return t;
+  }();
+  return table;
+}
+
+// getCurrentEnv() (invoked while wrapping a Java exception into a
+// YogaJniException) reads a process-global JavaVM that is latched exactly once
+// by the first ensureInitialized() call, so it must stay valid for the entire
+// process. This plumbing env/VM exists solely to satisfy that constraint: it
+// returns constant, non-null JNI handles and is never mutated by any test.
+// All per-test, mutable state lives on each fixture's own FakeEnv, so tests
+// stay fully isolated from one another.
+FakeEnv& plumbingEnv() {
+  static FakeEnv env{
+      .functions = &fakeNativeInterface(),
+      .exceptionCheckResult = JNI_FALSE,
+      .exceptionOccurredResult = fakeHandle<jthrowable>(),
+      .newGlobalRefResult = fakeHandle<jobject>(),
+      .findClassResult = fakeHandle<jclass>(),
+      .getMethodIdResult = fakeHandle<jmethodID>(),
+      .newObjectResult = fakeHandle<jobject>(),
+      .exceptionCheckCalls = 0,
+      .exceptionClearCalls = 0};
+  return env;
+}
+
+JNIEnv* plumbingJniEnv() {
+  return reinterpret_cast<JNIEnv*>(&plumbingEnv());
+}
+
+FakeVm& plumbingVm() {
+  static FakeVm vm{
+      .functions = &fakeInvokeInterface(),
+      .envToReturn = plumbingJniEnv(),
+      .getEnvResult = JNI_OK};
+  return vm;
+}
+
+JavaVM* plumbingJavaVm() {
+  return reinterpret_cast<JavaVM*>(&plumbingVm());
+}
+
+class CoreFunctionsTest : public ::testing::Test {
+ protected:
+  // Latch the process-global JavaVM exactly once for the whole suite so that
+  // getCurrentEnv() (used when wrapping exceptions) has a valid, stable env.
+  static void SetUpTestSuite() {
+    JNIEnv* out = nullptr;
+    ensureInitialized(&out, plumbingJavaVm());
+  }
+
+  void SetUp() override {
+    env_ = FakeEnv{
+        .functions = &fakeNativeInterface(),
+        .exceptionCheckResult = JNI_FALSE,
+        .exceptionOccurredResult = fakeHandle<jthrowable>(),
+        .newGlobalRefResult = fakeHandle<jobject>(),
+        .findClassResult = fakeHandle<jclass>(),
+        .getMethodIdResult = fakeHandle<jmethodID>(),
+        .newObjectResult = fakeHandle<jobject>(),
+        .exceptionCheckCalls = 0,
+        .exceptionClearCalls = 0};
+  }
+
+  JNIEnv* env() {
+    return reinterpret_cast<JNIEnv*>(&env_);
+  }
+
+  // Owned per test instance; each test observes and mutates only its own copy.
+  FakeEnv env_{};
+};
+
+TEST_F(CoreFunctionsTest, ensureInitializedReturnsVersionAndPopulatesEnv) {
+  JNIEnv* out = nullptr;
+
+  jint result = ensureInitialized(&out, plumbingJavaVm());
+
+  EXPECT_EQ(JNI_VERSION_1_6, result);
+  // The out-param must be populated with the JNIEnv that the VM GetEnv hook
+  // wrote, not left untouched.
+  EXPECT_EQ(plumbingJniEnv(), out);
+}
+
+TEST_F(CoreFunctionsTest, assertNoPendingJniExceptionReturnsWhenNoException) {
+  env_.exceptionCheckResult = JNI_FALSE;
+
+  EXPECT_NO_THROW(assertNoPendingJniException(env()));
+  // A clean env must be left alone: no attempt to clear a (non-existent)
+  // pending exception.
+  EXPECT_EQ(0, env_.exceptionClearCalls);
+}
+
+TEST_F(CoreFunctionsTest, assertNoPendingJniExceptionClearsAndWrapsPending) {
+  env_.exceptionCheckResult = JNI_TRUE;
+  env_.exceptionOccurredResult = fakeHandle<jthrowable>();
+
+  EXPECT_THROW(assertNoPendingJniException(env()), YogaJniException);
+  // The pending Java exception must be cleared exactly once before it is
+  // rethrown as a C++ exception, otherwise it would leak into the next JNI
+  // call.
+  EXPECT_EQ(1, env_.exceptionClearCalls);
+}
+
+TEST_F(
+    CoreFunctionsTest,
+    assertNoPendingJniExceptionIfSkipsCheckWhenConditionFalse) {
+  // Arrange a pending exception that would throw if it were inspected.
+  env_.exceptionCheckResult = JNI_TRUE;
+  env_.exceptionOccurredResult = fakeHandle<jthrowable>();
+
+  EXPECT_NO_THROW(assertNoPendingJniExceptionIf(env(), false));
+  // With a false condition the env must not be probed at all.
+  EXPECT_EQ(0, env_.exceptionCheckCalls);
+}
+
+TEST_F(
+    CoreFunctionsTest,
+    assertNoPendingJniExceptionIfThrowsWhenConditionTrueWithoutPending) {
+  // Condition is true but there is no pending JNI exception, so the function
+  // must still surface a failure by synthesizing a YogaJniException.
+  env_.exceptionCheckResult = JNI_FALSE;
+
+  EXPECT_THROW(assertNoPendingJniExceptionIf(env(), true), YogaJniException);
+}
+
+} // namespace
+} // namespace facebook::yoga::vanillajni