react-nitro-yoga 0.0.0-stage → 0.0.1-alpha.7

package/yoga/tests/CMakeLists.txt

@@ -0,0 +1,35 @@
+# 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.
+
+
+cmake_minimum_required(VERSION 3.13...3.26)
+project(tests)
+set(CMAKE_VERBOSE_MAKEFILE on)
+
+include(FetchContent)
+include(GoogleTest)
+
+set(YOGA_ROOT ${CMAKE_CURRENT_SOURCE_DIR}/..)
+include(${YOGA_ROOT}/cmake/project-defaults.cmake)
+
+# Fetch GTest
+FetchContent_Declare(
+  googletest
+  URL https://github.com/google/googletest/archive/refs/tags/release-1.12.1.zip
+)
+FetchContent_MakeAvailable(googletest)
+
+add_subdirectory(${YOGA_ROOT}/yoga ${CMAKE_CURRENT_BINARY_DIR}/yoga)
+
+file(GLOB SOURCES CONFIGURE_DEPENDS
+    ${CMAKE_CURRENT_SOURCE_DIR}/*.cpp
+    ${CMAKE_CURRENT_SOURCE_DIR}/**/*.cpp)
+
+enable_testing()
+
+add_executable(yogatests ${SOURCES})
+target_link_libraries(yogatests yogacore GTest::gtest_main)
+
+gtest_discover_tests(yogatests)

package/yoga/tests/CacheTest.cpp

@@ -0,0 +1,229 @@
+/*
+ * 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 <gtest/gtest.h>
+
+#include <yoga/Yoga.h>
+#include <yoga/algorithm/Cache.h>
+#include <yoga/algorithm/SizingMode.h>
+#include <yoga/config/Config.h>
+
+namespace facebook::yoga {
+
+class CacheTest : public ::testing::Test {
+ protected:
+  void SetUp() override {
+    config_ = static_cast<yoga::Config*>(YGConfigNew());
+  }
+
+  void TearDown() override {
+    YGConfigFree(config_);
+  }
+
+  yoga::Config* config_ = nullptr;
+};
+
+TEST_F(CacheTest, negativeCachedMeasurementDisablesCache) {
+  // Cached values with defined-but-negative extents are treated as invalid;
+  // both axes must independently invalidate the cache.
+  const bool negativeWidth = canUseCachedMeasurement(
+      SizingMode::StretchFit,
+      100.0f,
+      SizingMode::StretchFit,
+      50.0f,
+      SizingMode::StretchFit,
+      100.0f,
+      SizingMode::StretchFit,
+      50.0f,
+      /*lastComputedWidth=*/-1.0f,
+      /*lastComputedHeight=*/50.0f,
+      0.0f,
+      0.0f,
+      config_);
+  EXPECT_FALSE(negativeWidth);
+
+  const bool negativeHeight = canUseCachedMeasurement(
+      SizingMode::StretchFit,
+      100.0f,
+      SizingMode::StretchFit,
+      50.0f,
+      SizingMode::StretchFit,
+      100.0f,
+      SizingMode::StretchFit,
+      50.0f,
+      /*lastComputedWidth=*/100.0f,
+      /*lastComputedHeight=*/-0.5f,
+      0.0f,
+      0.0f,
+      config_);
+  EXPECT_FALSE(negativeHeight);
+}
+
+TEST_F(CacheTest, identicalSpecsAllowCacheReuse) {
+  // Primary cache-hit path: identical mode + available size on both axes
+  // means the previously computed measurement can be reused verbatim.
+  const bool canUse = canUseCachedMeasurement(
+      SizingMode::StretchFit,
+      100.0f,
+      SizingMode::FitContent,
+      50.0f,
+      SizingMode::StretchFit,
+      100.0f,
+      SizingMode::FitContent,
+      50.0f,
+      /*lastComputedWidth=*/95.0f,
+      /*lastComputedHeight=*/45.0f,
+      0.0f,
+      0.0f,
+      config_);
+
+  EXPECT_TRUE(canUse);
+}
+
+TEST_F(CacheTest, incompatibleSpecsDisableCache) {
+  // Previous run used MaxContent with a computed size of 95; the new run
+  // stretches to 200. StretchFit only reuses a cached size when the new
+  // inner extent equals the last computed size, which does not hold here,
+  // so no compatibility branch applies.
+  const bool canUse = canUseCachedMeasurement(
+      SizingMode::StretchFit,
+      200.0f,
+      SizingMode::StretchFit,
+      200.0f,
+      SizingMode::MaxContent,
+      YGUndefined,
+      SizingMode::MaxContent,
+      YGUndefined,
+      /*lastComputedWidth=*/95.0f,
+      /*lastComputedHeight=*/95.0f,
+      0.0f,
+      0.0f,
+      config_);
+
+  EXPECT_FALSE(canUse);
+}
+
+TEST_F(
+    CacheTest,
+    stretchFitMatchingComputedSizeReusesCacheAccountingForMargin) {
+  // Under StretchFit, the requested content size is (availableWidth -
+  // marginRow) = 90, which matches the last computed width of 90. This
+  // hits the sizeIsExactAndMatchesOldMeasuredSize branch and also verifies
+  // that marginRow is subtracted before the comparison (a bare 100 would
+  // not match 90).
+  const bool canUse = canUseCachedMeasurement(
+      SizingMode::StretchFit,
+      /*availableWidth=*/100.0f,
+      SizingMode::StretchFit,
+      /*availableHeight=*/60.0f,
+      SizingMode::FitContent,
+      /*lastAvailableWidth=*/90.0f,
+      SizingMode::StretchFit,
+      /*lastAvailableHeight=*/60.0f,
+      /*lastComputedWidth=*/90.0f,
+      /*lastComputedHeight=*/60.0f,
+      /*marginRow=*/10.0f,
+      /*marginColumn=*/0.0f,
+      config_);
+
+  EXPECT_TRUE(canUse);
+}
+
+TEST_F(CacheTest, maxContentResultStillFitsFitContentRequest) {
+  // Cached MaxContent width of 80 fits inside a FitContent request with 120
+  // available space, so the previous result remains valid (the max-content
+  // size cannot overflow the looser constraint).
+  const bool canUse = canUseCachedMeasurement(
+      SizingMode::FitContent,
+      /*availableWidth=*/120.0f,
+      SizingMode::StretchFit,
+      /*availableHeight=*/50.0f,
+      SizingMode::MaxContent,
+      /*lastAvailableWidth=*/YGUndefined,
+      SizingMode::StretchFit,
+      /*lastAvailableHeight=*/50.0f,
+      /*lastComputedWidth=*/80.0f,
+      /*lastComputedHeight=*/50.0f,
+      0.0f,
+      0.0f,
+      config_);
+
+  EXPECT_TRUE(canUse);
+}
+
+TEST_F(CacheTest, tighterFitContentReusesCacheWhenPreviousResultStillFits) {
+  // Both runs use FitContent. The new available width (100) is stricter than
+  // the previous one (150), but the previously computed width (80) still
+  // fits inside the new constraint, so the cached measurement is reusable.
+  const bool canUse = canUseCachedMeasurement(
+      SizingMode::FitContent,
+      /*availableWidth=*/100.0f,
+      SizingMode::StretchFit,
+      /*availableHeight=*/50.0f,
+      SizingMode::FitContent,
+      /*lastAvailableWidth=*/150.0f,
+      SizingMode::StretchFit,
+      /*lastAvailableHeight=*/50.0f,
+      /*lastComputedWidth=*/80.0f,
+      /*lastComputedHeight=*/50.0f,
+      0.0f,
+      0.0f,
+      config_);
+
+  EXPECT_TRUE(canUse);
+}
+
+TEST_F(
+    CacheTest,
+    tighterFitContentInvalidatesCacheWhenPreviousResultOverflows) {
+  // Same shape as the previous test but the cached width (120) is larger
+  // than the tightened constraint (100). Reusing the measurement would
+  // silently overflow the container, so the cache must be discarded.
+  const bool canUse = canUseCachedMeasurement(
+      SizingMode::FitContent,
+      /*availableWidth=*/100.0f,
+      SizingMode::StretchFit,
+      /*availableHeight=*/50.0f,
+      SizingMode::FitContent,
+      /*lastAvailableWidth=*/150.0f,
+      SizingMode::StretchFit,
+      /*lastAvailableHeight=*/50.0f,
+      /*lastComputedWidth=*/120.0f,
+      /*lastComputedHeight=*/50.0f,
+      0.0f,
+      0.0f,
+      config_);
+
+  EXPECT_FALSE(canUse);
+}
+
+TEST_F(CacheTest, pixelGridRoundingMakesSubPixelSpecsEquivalent) {
+  // At a point scale factor of 2, both 10.25 and 10.5 snap to 10.5 on the
+  // physical pixel grid. Specs that differ by less than one device pixel
+  // must be treated as identical so we can reuse the cache; without grid
+  // rounding, inexactEquals(10.25, 10.5) is false and the cache would miss.
+  config_->setPointScaleFactor(2.0f);
+
+  const bool canUse = canUseCachedMeasurement(
+      SizingMode::StretchFit,
+      /*availableWidth=*/10.25f,
+      SizingMode::StretchFit,
+      /*availableHeight=*/20.0f,
+      SizingMode::StretchFit,
+      /*lastAvailableWidth=*/10.5f,
+      SizingMode::StretchFit,
+      /*lastAvailableHeight=*/20.0f,
+      /*lastComputedWidth=*/10.5f,
+      /*lastComputedHeight=*/20.0f,
+      0.0f,
+      0.0f,
+      config_);
+
+  EXPECT_TRUE(canUse);
+}
+
+} // namespace facebook::yoga

package/yoga/tests/EventPublisherTest.cpp

@@ -0,0 +1,162 @@
+/*
+ * 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 <gtest/gtest.h>
+#include <yoga/Yoga.h>
+#include <yoga/event/event.h>
+
+#include <array>
+#include <string_view>
+#include <unordered_set>
+
+namespace facebook::yoga::test {
+
+// Every enum value declared in LayoutPassReason (excluding the COUNT sentinel).
+// Kept in sync with yoga/event/event.h; a missing entry causes the "all known
+// reasons" test to catch the omission on the next run.
+constexpr std::array<LayoutPassReason, 9> kAllKnownReasons = {
+    LayoutPassReason::kInitial,
+    LayoutPassReason::kAbsLayout,
+    LayoutPassReason::kStretch,
+    LayoutPassReason::kMultilineStretch,
+    LayoutPassReason::kFlexLayout,
+    LayoutPassReason::kMeasureChild,
+    LayoutPassReason::kAbsMeasureChild,
+    LayoutPassReason::kFlexMeasure,
+    LayoutPassReason::kGridLayout,
+};
+
+TEST(
+    LayoutPassReasonToStringTest,
+    everyKnownReasonMapsToDistinctNonUnknownLabel) {
+  std::unordered_set<std::string_view> labels;
+  for (auto reason : kAllKnownReasons) {
+    const char* label = LayoutPassReasonToString(reason);
+    ASSERT_NE(label, nullptr)
+        << "LayoutPassReasonToString returned nullptr for enum value "
+        << static_cast<int>(reason);
+    EXPECT_STRNE(label, "")
+        << "Empty label for enum value " << static_cast<int>(reason);
+    EXPECT_STRNE(label, "unknown")
+        << "Enum value " << static_cast<int>(reason)
+        << " unexpectedly fell through to the default case";
+    labels.emplace(label);
+  }
+  EXPECT_EQ(labels.size(), kAllKnownReasons.size())
+      << "At least two LayoutPassReason values share the same label";
+}
+
+TEST(LayoutPassReasonToStringTest, fallsBackToUnknownForUnrecognizedValues) {
+  // Out-of-range integer cast: exercises the switch's default branch, which
+  // guards against silent regressions when new enum values are added without
+  // updating the switch.
+  EXPECT_STREQ(
+      LayoutPassReasonToString(static_cast<LayoutPassReason>(9999)), "unknown");
+
+  // COUNT is the sentinel used to size arrays and is not a real reason, so
+  // it must also fall through to the default case.
+  EXPECT_STREQ(LayoutPassReasonToString(LayoutPassReason::COUNT), "unknown");
+}
+
+class EventPublisherTest : public ::testing::Test {
+ protected:
+  // Event maintains a process-global subscriber list; clear it around each
+  // test to keep the tests independent regardless of ordering.
+  void SetUp() override {
+    Event::reset();
+  }
+  void TearDown() override {
+    Event::reset();
+  }
+};
+
+TEST_F(
+    EventPublisherTest,
+    resetDetachesPreviouslyRegisteredSubscribersFromFutureEvents) {
+  int callCount = 0;
+  Event::subscribe(
+      [&](YGNodeConstRef, Event::Type, Event::Data) { ++callCount; });
+
+  // Sanity-check that the subscriber is actually wired up before reset.
+  Event::publish<Event::LayoutPassStart>(nullptr);
+  ASSERT_EQ(callCount, 1);
+
+  Event::reset();
+  Event::publish<Event::LayoutPassStart>(nullptr);
+  Event::publish<Event::LayoutPassEnd>(
+      nullptr, Event::TypedData<Event::LayoutPassEnd>{nullptr});
+
+  EXPECT_EQ(callCount, 1)
+      << "Subscriber should not have been invoked after Event::reset()";
+}
+
+TEST_F(EventPublisherTest, publishForwardsToEverySubscriberWithNodeAndType) {
+  YGNodeRef sentinelNode = YGNodeNew();
+
+  int subscriberACallCount = 0;
+  int subscriberBCallCount = 0;
+  YGNodeConstRef subscriberAReceivedNode = nullptr;
+  Event::Type subscriberAReceivedType = Event::NodeAllocation;
+
+  Event::subscribe([&](YGNodeConstRef node, Event::Type type, Event::Data) {
+    ++subscriberACallCount;
+    subscriberAReceivedNode = node;
+    subscriberAReceivedType = type;
+  });
+  Event::subscribe([&](YGNodeConstRef, Event::Type, Event::Data) {
+    ++subscriberBCallCount;
+  });
+
+  Event::publish<Event::LayoutPassStart>(sentinelNode);
+
+  EXPECT_EQ(subscriberACallCount, 1);
+  EXPECT_EQ(subscriberBCallCount, 1);
+  EXPECT_EQ(subscriberAReceivedNode, sentinelNode);
+  EXPECT_EQ(subscriberAReceivedType, Event::LayoutPassStart);
+
+  YGNodeFree(sentinelNode);
+}
+
+TEST_F(EventPublisherTest, publishForwardsTypedEventDataPayloadUnmodified) {
+  int measureCallbackEndCount = 0;
+  YGMeasureMode capturedWidthMode = YGMeasureModeUndefined;
+  float capturedMeasuredWidth = 0.0f;
+  float capturedMeasuredHeight = 0.0f;
+  LayoutPassReason capturedReason = LayoutPassReason::kInitial;
+
+  Event::subscribe([&](YGNodeConstRef, Event::Type type, Event::Data data) {
+    if (type != Event::MeasureCallbackEnd) {
+      return;
+    }
+    const auto& payload = data.get<Event::MeasureCallbackEnd>();
+    capturedWidthMode = payload.widthMeasureMode;
+    capturedMeasuredWidth = payload.measuredWidth;
+    capturedMeasuredHeight = payload.measuredHeight;
+    capturedReason = payload.reason;
+    ++measureCallbackEndCount;
+  });
+
+  Event::publish<Event::MeasureCallbackEnd>(
+      nullptr,
+      Event::TypedData<Event::MeasureCallbackEnd>{
+          .width = 100.0f,
+          .widthMeasureMode = YGMeasureModeAtMost,
+          .height = 200.0f,
+          .heightMeasureMode = YGMeasureModeExactly,
+          .measuredWidth = 42.5f,
+          .measuredHeight = 84.25f,
+          .reason = LayoutPassReason::kFlexMeasure,
+      });
+
+  ASSERT_EQ(measureCallbackEndCount, 1);
+  EXPECT_EQ(capturedWidthMode, YGMeasureModeAtMost);
+  EXPECT_FLOAT_EQ(capturedMeasuredWidth, 42.5f);
+  EXPECT_FLOAT_EQ(capturedMeasuredHeight, 84.25f);
+  EXPECT_EQ(capturedReason, LayoutPassReason::kFlexMeasure);
+}
+
+} // namespace facebook::yoga::test