first commit

node_modules/react-native/ReactCommon/react/renderer/graphics/tests/ColorTest.cpp

@@ -0,0 +1,38 @@
+/*
+ * 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/renderer/graphics/Color.h>
+
+#include <gtest/gtest.h>
+
+TEST(ColorTest, testColorConversion) {
+  using namespace facebook::react;
+  {
+    auto color = colorFromRGBA(255, 0, 15, 17);
+
+    EXPECT_EQ(alphaFromColor(color), 17);
+    EXPECT_EQ(redFromColor(color), 255);
+    EXPECT_EQ(greenFromColor(color), 0);
+    EXPECT_EQ(blueFromColor(color), 15);
+  }
+
+  {
+    auto color = colorFromComponents(
+        {.red = 0.1f, .green = 0.2f, .blue = 0, .alpha = 0.3f});
+
+    EXPECT_EQ(alphaFromColor(color), std::round(255 * 0.3f));
+    EXPECT_EQ(redFromColor(color), std::round(255 * 0.1f));
+    EXPECT_EQ(greenFromColor(color), 255 * 0.2f);
+    EXPECT_EQ(blueFromColor(color), 0.f);
+
+    auto colorComponents = colorComponentsFromColor(color);
+    EXPECT_EQ(std::round(colorComponents.alpha * 10) / 10.f, 0.3f);
+    EXPECT_EQ(std::round(colorComponents.red * 10) / 10.f, 0.1f);
+    EXPECT_EQ(std::round(colorComponents.green * 10) / 10.f, 0.2f);
+    EXPECT_EQ(std::round(colorComponents.blue * 10) / 10.f, 0);
+  }
+}

node_modules/react-native/ReactCommon/react/renderer/graphics/tests/GraphicsTest.cpp

@@ -0,0 +1,14 @@
+/*
+ * 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 <memory>
+
+#include <gtest/gtest.h>
+
+TEST(GraphicsTest, testSomething) {
+  // TODO
+}

node_modules/react-native/ReactCommon/react/renderer/graphics/tests/PointTest.cpp

@@ -0,0 +1,87 @@
+/*
+ * 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/renderer/graphics/Point.h>
+
+#include <gtest/gtest.h>
+
+using namespace facebook::react;
+
+TEST(PointTest, testConstructor) {
+  auto point = facebook::react::Point{1, 2};
+
+  EXPECT_EQ(point.x, 1);
+  EXPECT_EQ(point.y, 2);
+}
+
+TEST(PointTest, testPlusEqualOperator) {
+  auto point = facebook::react::Point{1, 2};
+  point += facebook::react::Point{3, 4};
+
+  EXPECT_EQ(point.x, 4);
+  EXPECT_EQ(point.y, 6);
+}
+
+TEST(PointTest, testMinusEqualOperator) {
+  auto point = facebook::react::Point{1, 2};
+  point -= facebook::react::Point{3, 4};
+
+  EXPECT_EQ(point.x, -2);
+  EXPECT_EQ(point.y, -2);
+}
+
+TEST(PointTest, testMultiplyEqualOperator) {
+  auto point = facebook::react::Point{1, 2};
+  point *= facebook::react::Point{3, 4};
+
+  EXPECT_EQ(point.x, 3);
+  EXPECT_EQ(point.y, 8);
+}
+
+TEST(PointTest, testPlusOperator) {
+  auto newPoint = facebook::react::Point{1, 2} + facebook::react::Point{3, 4};
+
+  EXPECT_EQ(newPoint.x, 4);
+  EXPECT_EQ(newPoint.y, 6);
+}
+
+TEST(PointTest, testMinusOperator) {
+  auto newPoint = facebook::react::Point{1, 2} - facebook::react::Point{3, 4};
+
+  EXPECT_EQ(newPoint.x, -2);
+  EXPECT_EQ(newPoint.y, -2);
+}
+
+TEST(PointTest, testEqualOperator) {
+  auto pointA = facebook::react::Point{1, 2};
+  auto pointB = facebook::react::Point{1, 2};
+  auto pointC = facebook::react::Point{1, 3};
+  auto pointD = facebook::react::Point{2, 2};
+
+  EXPECT_TRUE(pointA == pointB);
+  EXPECT_FALSE(pointA == pointC);
+  EXPECT_FALSE(pointA == pointD);
+}
+
+TEST(PointTest, testUnequalOperator) {
+  auto pointA = facebook::react::Point{1, 2};
+  auto pointB = facebook::react::Point{1, 2};
+  auto pointC = facebook::react::Point{1, 3};
+  auto pointD = facebook::react::Point{2, 2};
+
+  EXPECT_FALSE(pointA != pointB);
+  EXPECT_TRUE(pointA != pointC);
+  EXPECT_TRUE(pointA != pointD);
+}
+
+TEST(PointTest, testMinusUnaryOperator) {
+  auto point = facebook::react::Point{1, 2};
+  auto negativePoint = -point;
+
+  EXPECT_EQ(negativePoint.x, -1);
+  EXPECT_EQ(negativePoint.y, -2);
+}

node_modules/react-native/ReactCommon/react/renderer/graphics/tests/TransformTest.cpp

@@ -0,0 +1,136 @@
+/*
+ * 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/renderer/graphics/Transform.h>
+
+#include <gtest/gtest.h>
+#include <cmath>
+
+using namespace facebook::react;
+
+TEST(TransformTest, transformingSize) {
+  auto size = facebook::react::Size{100, 200};
+  auto scaledSize = size * Transform::Scale(0.5, 0.5, 1);
+
+  EXPECT_EQ(scaledSize.width, 50);
+  EXPECT_EQ(scaledSize.height, 100);
+}
+
+TEST(TransformTest, transformingPoint) {
+  auto point = facebook::react::Point{100, 200};
+  auto translatedPoint = point * Transform::Translate(-50, -100, 0);
+
+  EXPECT_EQ(translatedPoint.x, 50);
+  EXPECT_EQ(translatedPoint.y, 100);
+}
+
+TEST(TransformTest, fromTransformOperationPercentage) {
+  auto point = facebook::react::Point{0, 0};
+  facebook::react::Size size = {120, 200};
+
+  auto operation = TransformOperation{
+      TransformOperationType::Translate,
+      ValueUnit{50.0f, UnitType::Percent},
+      ValueUnit{20.0f, UnitType::Percent},
+      {}};
+  auto translatedPoint =
+      point * Transform::FromTransformOperation(operation, size);
+  EXPECT_EQ(translatedPoint.x, 60);
+  EXPECT_EQ(translatedPoint.y, 40);
+
+  operation = TransformOperation{
+      TransformOperationType::Translate,
+      ValueUnit{40.0f, UnitType::Percent},
+      ValueUnit{20.0f, UnitType::Point},
+      {}};
+  translatedPoint = point * Transform::FromTransformOperation(operation, size);
+  EXPECT_EQ(translatedPoint.x, 48);
+  EXPECT_EQ(translatedPoint.y, 20);
+}
+
+TEST(TransformTest, scalingRect) {
+  auto point = facebook::react::Point{100, 200};
+  auto size = facebook::react::Size{300, 400};
+  auto rect = facebook::react::Rect{point, size};
+
+  auto transformedRect = rect * Transform::Scale(0.5, 0.5, 1);
+
+  EXPECT_EQ(transformedRect.origin.x, 175);
+  EXPECT_EQ(transformedRect.origin.y, 300);
+  EXPECT_EQ(transformedRect.size.width, 150);
+  EXPECT_EQ(transformedRect.size.height, 200);
+}
+
+TEST(TransformTest, scalingRectWithDifferentCenter) {
+  auto point = facebook::react::Point{100, 200};
+  auto size = facebook::react::Size{300, 400};
+  auto rect = facebook::react::Rect{point, size};
+
+  auto center = facebook::react::Point{0, 0};
+
+  auto transformedRect =
+      Transform::Scale(0.5, 0.5, 1).applyWithCenter(rect, center);
+
+  EXPECT_EQ(transformedRect.origin.x, 50);
+  EXPECT_EQ(transformedRect.origin.y, 100);
+  EXPECT_EQ(transformedRect.size.width, 150);
+  EXPECT_EQ(transformedRect.size.height, 200);
+}
+
+TEST(TransformTest, invertingSize) {
+  auto size = facebook::react::Size{300, 400};
+  auto transformedSize = size * Transform::VerticalInversion();
+  EXPECT_EQ(transformedSize.width, 300);
+  EXPECT_EQ(transformedSize.height, 400);
+}
+
+TEST(TransformTest, rotatingRect) {
+  auto point = facebook::react::Point{10, 10};
+  auto size = facebook::react::Size{10, 10};
+  auto rect = facebook::react::Rect{point, size};
+
+  auto transformedRect = rect * Transform::RotateZ(M_PI_4);
+
+  ASSERT_NEAR(transformedRect.origin.x, 7.9289, 0.0001);
+  ASSERT_NEAR(transformedRect.origin.y, 7.9289, 0.0001);
+  ASSERT_NEAR(transformedRect.size.width, 14.1421, 0.0001);
+  ASSERT_NEAR(transformedRect.size.height, 14.1421, 0.0001);
+}
+
+TEST(TransformTest, rotate3dOverload) {
+  auto point = facebook::react::Point{10, 10};
+  auto size = facebook::react::Size{10, 10};
+  auto rect = facebook::react::Rect{point, size};
+
+  auto transform = Transform::Rotate(0, 0, M_PI_4);
+  EXPECT_EQ(transform.operations.size(), 1);
+  EXPECT_EQ(transform.operations[0].type, TransformOperationType::Rotate);
+  EXPECT_EQ(transform.operations[0].x.resolve(0), 0);
+  EXPECT_EQ(transform.operations[0].y.resolve(0), 0);
+  ASSERT_NEAR(transform.operations[0].z.resolve(0), M_PI_4, 0.0001);
+
+  auto transformedRect = rect * Transform::Rotate(0, 0, M_PI_4);
+
+  ASSERT_NEAR(transformedRect.origin.x, 7.9289, 0.0001);
+  ASSERT_NEAR(transformedRect.origin.y, 7.9289, 0.0001);
+  ASSERT_NEAR(transformedRect.size.width, 14.1421, 0.0001);
+  ASSERT_NEAR(transformedRect.size.height, 14.1421, 0.0001);
+}
+
+TEST(TransformTest, scalingAndTranslatingRect) {
+  auto point = facebook::react::Point{100, 200};
+  auto size = facebook::react::Size{300, 400};
+  auto rect = facebook::react::Rect{point, size};
+
+  auto transformedRect =
+      rect * Transform::Scale(0.5, 0.5, 1) * Transform::Translate(1, 1, 0);
+
+  EXPECT_EQ(transformedRect.origin.x, 176);
+  EXPECT_EQ(transformedRect.origin.y, 301);
+  EXPECT_EQ(transformedRect.size.width, 150);
+  EXPECT_EQ(transformedRect.size.height, 200);
+}