react-native 0.0.0-201c10733 → 0.0.0-268efb102

package/ReactCommon/react/renderer/core/propsConversions.h

@@ -10,6 +10,7 @@
 #include <better/optional.h>
 #include <folly/Likely.h>
 #include <folly/dynamic.h>
+#include <react/renderer/core/PropsParserContext.h>
 #include <react/renderer/core/RawProps.h>
 #include <react/renderer/graphics/Color.h>
 #include <react/renderer/graphics/Geometry.h>
@@ -19,20 +20,26 @@ namespace facebook {
 namespace react {
 
 template <typename T>
-void fromRawValue(RawValue const &rawValue, T &result) {
+void fromRawValue(
+    const PropsParserContext &context,
+    RawValue const &rawValue,
+    T &result) {
   result = (T)rawValue;
 }
 
 template <typename T>
-void fromRawValue(RawValue const &rawValue, std::vector<T> &result) {
+void fromRawValue(
+    const PropsParserContext &context,
+    RawValue const &rawValue,
+    std::vector<T> &result) {
   if (rawValue.hasType<std::vector<RawValue>>()) {
     auto items = (std::vector<RawValue>)rawValue;
     auto length = items.size();
     result.clear();
     result.reserve(length);
-    for (int i = 0; i < length; i++) {
+    for (size_t i = 0; i < length; i++) {
       T itemResult;
-      fromRawValue(items.at(i), itemResult);
+      fromRawValue(context, items.at(i), itemResult);
       result.push_back(itemResult);
     }
     return;
@@ -42,12 +49,13 @@ void fromRawValue(RawValue const &rawValue, std::vector<T> &result) {
   result.clear();
   result.reserve(1);
   T itemResult;
-  fromRawValue(rawValue, itemResult);
+  fromRawValue(context, rawValue, itemResult);
   result.push_back(itemResult);
 }
 
 template <typename T>
 void fromRawValue(
+    const PropsParserContext &context,
     RawValue const &rawValue,
     std::vector<std::vector<T>> &result) {
   if (rawValue.hasType<std::vector<std::vector<RawValue>>>()) {
@@ -57,7 +65,7 @@ void fromRawValue(
     result.reserve(length);
     for (int i = 0; i < length; i++) {
       T itemResult;
-      fromRawValue(items.at(i), itemResult);
+      fromRawValue(context, items.at(i), itemResult);
       result.push_back(itemResult);
     }
     return;
@@ -67,12 +75,13 @@ void fromRawValue(
   result.clear();
   result.reserve(1);
   T itemResult;
-  fromRawValue(rawValue, itemResult);
+  fromRawValue(context, rawValue, itemResult);
   result.push_back(itemResult);
 }
 
 template <typename T, typename U = T>
 T convertRawProp(
+    const PropsParserContext &context,
     RawProps const &rawProps,
     char const *name,
     T const &sourceValue,
@@ -92,12 +101,13 @@ T convertRawProp(
   }
 
   T result;
-  fromRawValue(*rawValue, result);
+  fromRawValue(context, *rawValue, result);
   return result;
 }
 
 template <typename T>
 static better::optional<T> convertRawProp(
+    const PropsParserContext &context,
     RawProps const &rawProps,
     char const *name,
     better::optional<T> const &sourceValue,
@@ -117,7 +127,7 @@ static better::optional<T> convertRawProp(
   }
 
   T result;
-  fromRawValue(*rawValue, result);
+  fromRawValue(context, *rawValue, result);
   return better::optional<T>{result};
 }
 

package/ReactCommon/react/renderer/core/tests/ComponentDescriptorTest.cpp

@@ -7,6 +7,8 @@
 
 #include <gtest/gtest.h>
 
+#include <react/renderer/core/PropsParserContext.h>
+
 #include "TestComponent.h"
 
 using namespace facebook::react;
@@ -21,8 +23,11 @@ TEST(ComponentDescriptorTest, createShadowNode) {
   EXPECT_STREQ(descriptor->getComponentName(), TestShadowNode::Name());
   EXPECT_STREQ(descriptor->getComponentName(), "Test");
 
+  ContextContainer contextContainer{};
+  PropsParserContext parserContext{-1, contextContainer};
+
   const auto &raw = RawProps(folly::dynamic::object("nativeID", "abc"));
-  SharedProps props = descriptor->cloneProps(nullptr, raw);
+  SharedProps props = descriptor->cloneProps(parserContext, nullptr, raw);
 
   auto family = descriptor->createFamily(
       ShadowNodeFamilyFragment{
@@ -52,8 +57,11 @@ TEST(ComponentDescriptorTest, cloneShadowNode) {
       std::make_shared<TestComponentDescriptor>(
           ComponentDescriptorParameters{eventDispatcher, nullptr, nullptr});
 
+  ContextContainer contextContainer{};
+  PropsParserContext parserContext{-1, contextContainer};
+
   const auto &raw = RawProps(folly::dynamic::object("nativeID", "abc"));
-  SharedProps props = descriptor->cloneProps(nullptr, raw);
+  SharedProps props = descriptor->cloneProps(parserContext, nullptr, raw);
   auto family = descriptor->createFamily(
       ShadowNodeFamilyFragment{
           /* .tag = */ 9,
@@ -73,7 +81,8 @@ TEST(ComponentDescriptorTest, cloneShadowNode) {
   EXPECT_EQ(cloned->getSurfaceId(), 1);
   EXPECT_STREQ(cloned->getProps()->nativeId.c_str(), "abc");
 
-  auto clonedButSameProps = descriptor->cloneProps(props, RawProps());
+  auto clonedButSameProps =
+      descriptor->cloneProps(parserContext, props, RawProps());
   EXPECT_NE(clonedButSameProps, props);
 }
 
@@ -83,8 +92,11 @@ TEST(ComponentDescriptorTest, appendChild) {
       std::make_shared<TestComponentDescriptor>(
           ComponentDescriptorParameters{eventDispatcher, nullptr, nullptr});
 
+  ContextContainer contextContainer{};
+  PropsParserContext parserContext{-1, contextContainer};
+
   const auto &raw = RawProps(folly::dynamic::object("nativeID", "abc"));
-  SharedProps props = descriptor->cloneProps(nullptr, raw);
+  SharedProps props = descriptor->cloneProps(parserContext, nullptr, raw);
   auto family1 = descriptor->createFamily(
       ShadowNodeFamilyFragment{
           /* .tag = */ 1,

package/ReactCommon/react/renderer/core/tests/ConcreteShadowNodeTest.cpp

@@ -26,7 +26,7 @@ TEST(ConcreteShadowNodeTest, testSetStateData) {
 
   auto shadowNode = builder.build(element);
 
-  shadowNode->setStateData({{10, 11}, {{21, 22}, {301, 302}}});
+  shadowNode->setStateData({{10, 11}, {{21, 22}, {301, 302}}, 0});
 
   EXPECT_NE(
       shadowNode->getState(), shadowNode->getFamily().getMostRecentState());

package/ReactCommon/react/renderer/core/tests/DynamicPropsUtilitiesTest.cpp

@@ -0,0 +1,66 @@
+/*
+ * Copyright (c) Facebook, Inc. and its 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 <react/renderer/core/DynamicPropsUtilities.h>
+
+using namespace folly;
+using namespace facebook::react;
+
+/*
+  Tests that verify expected behaviour from `folly::dynamic::merge_patch`.
+  `merge_patch` is used for props forwarding on Android to enable Background
+  Executor and will be removed once JNI layer is reimplmeneted.
+ */
+TEST(DynamicPropsUtilitiesTest, handleNestedObjects) {
+  dynamic map1 = dynamic::object;
+  map1["style"] = dynamic::object("backgroundColor", "red");
+
+  dynamic map2 = dynamic::object;
+  map2["style"] = dynamic::object("backgroundColor", "blue")("color", "black");
+  map2["height"] = 100;
+
+  auto result = mergeDynamicProps(map1, map2);
+
+  EXPECT_TRUE(result["style"].isObject());
+  EXPECT_TRUE(result["style"]["backgroundColor"].isString());
+  EXPECT_TRUE(result["style"]["color"].isString());
+  EXPECT_TRUE(result["height"].isInt());
+
+  EXPECT_EQ(result["style"]["backgroundColor"].asString(), "blue");
+  EXPECT_EQ(result["style"]["color"], "black");
+  EXPECT_EQ(result["height"], 100);
+}
+
+TEST(DynamicPropsUtilitiesTest, handleEmptyObject) {
+  dynamic map1 = dynamic::object;
+
+  dynamic map2 = dynamic::object;
+  map2["height"] = 100;
+
+  auto result = mergeDynamicProps(map1, map2);
+
+  EXPECT_TRUE(result["height"].isInt());
+  EXPECT_EQ(result["height"], 100);
+
+  result = mergeDynamicProps(map1, map2);
+
+  EXPECT_TRUE(result["height"].isInt());
+  EXPECT_EQ(result["height"], 100);
+}
+
+TEST(DynamicPropsUtilitiesTest, handleNull) {
+  dynamic map1 = dynamic::object;
+  map1["height"] = 100;
+
+  dynamic map2 = dynamic::object;
+  map2["height"] = nullptr;
+
+  auto result = mergeDynamicProps(map1, map2);
+
+  EXPECT_TRUE(result["height"].isNull());
+}

package/ReactCommon/react/renderer/core/tests/EventQueueProcessorTest.cpp

@@ -0,0 +1,134 @@
+/*
+ * Copyright (c) Facebook, Inc. and its 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 <hermes/API/hermes/hermes.h>
+#include <jsi/jsi.h>
+#include <react/renderer/core/EventPipe.h>
+#include <react/renderer/core/EventQueueProcessor.h>
+#include <react/renderer/core/StatePipe.h>
+
+#include <memory>
+
+namespace facebook::react {
+
+class EventQueueProcessorTest : public testing::Test {
+ protected:
+  void SetUp() override {
+    runtime_ = facebook::hermes::makeHermesRuntime();
+
+    auto eventPipe = [this](
+                         jsi::Runtime &runtime,
+                         const EventTarget *eventTarget,
+                         const std::string &type,
+                         ReactEventPriority priority,
+                         const ValueFactory &payloadFactory) {
+      eventTypes_.push_back(type);
+      eventPriorities_.push_back(priority);
+    };
+
+    auto dummyStatePipe = [](StateUpdate const &stateUpdate) {};
+
+    eventProcessor_ =
+        std::make_unique<EventQueueProcessor>(eventPipe, dummyStatePipe);
+  }
+
+  std::unique_ptr<facebook::hermes::HermesRuntime> runtime_;
+  std::unique_ptr<EventQueueProcessor> eventProcessor_;
+  std::vector<std::string> eventTypes_;
+  std::vector<ReactEventPriority> eventPriorities_;
+  ValueFactory dummyValueFactory_;
+};
+
+TEST_F(EventQueueProcessorTest, singleUnspecifiedEvent) {
+  eventProcessor_->flushEvents(
+      *runtime_,
+      {RawEvent(
+          "my type",
+          dummyValueFactory_,
+          nullptr,
+          RawEvent::Category::Unspecified)});
+
+  EXPECT_EQ(eventPriorities_.size(), 1);
+  EXPECT_EQ(eventTypes_[0], "my type");
+  EXPECT_EQ(eventPriorities_[0], ReactEventPriority::Discrete);
+}
+
+TEST_F(EventQueueProcessorTest, continiousEvent) {
+  eventProcessor_->flushEvents(
+      *runtime_,
+      {RawEvent(
+           "touchStart",
+           dummyValueFactory_,
+           nullptr,
+           RawEvent::Category::ContinuousStart),
+       RawEvent(
+           "touchMove",
+           dummyValueFactory_,
+           nullptr,
+           RawEvent::Category::Unspecified),
+       RawEvent(
+           "touchEnd",
+           dummyValueFactory_,
+           nullptr,
+           RawEvent::Category::ContinuousEnd),
+       RawEvent(
+           "custom event",
+           dummyValueFactory_,
+           nullptr,
+           RawEvent::Category::Unspecified)});
+
+  EXPECT_EQ(eventPriorities_.size(), 4);
+
+  EXPECT_EQ(eventTypes_[0], "touchStart");
+  EXPECT_EQ(eventPriorities_[0], ReactEventPriority::Discrete);
+
+  EXPECT_EQ(eventTypes_[1], "touchMove");
+  EXPECT_EQ(eventPriorities_[1], ReactEventPriority::Default);
+
+  EXPECT_EQ(eventTypes_[2], "touchEnd");
+  EXPECT_EQ(eventPriorities_[2], ReactEventPriority::Discrete);
+
+  EXPECT_EQ(eventTypes_[3], "custom event");
+  EXPECT_EQ(eventPriorities_[3], ReactEventPriority::Discrete);
+}
+
+TEST_F(EventQueueProcessorTest, alwaysContinuousEvent) {
+  eventProcessor_->flushEvents(
+      *runtime_,
+      {
+          RawEvent(
+              "onScroll",
+              dummyValueFactory_,
+              nullptr,
+              RawEvent::Category::Continuous),
+      });
+
+  EXPECT_EQ(eventPriorities_.size(), 1);
+
+  EXPECT_EQ(eventTypes_[0], "onScroll");
+  EXPECT_EQ(eventPriorities_[0], ReactEventPriority::Default);
+}
+
+TEST_F(EventQueueProcessorTest, alwaysDiscreteEvent) {
+  eventProcessor_->flushEvents(
+      *runtime_,
+      {
+          RawEvent(
+              "onChange",
+              dummyValueFactory_,
+              nullptr,
+              RawEvent::Category::Discrete),
+      });
+
+  EXPECT_EQ(eventPriorities_.size(), 1);
+
+  EXPECT_EQ(eventTypes_[0], "onChange");
+  EXPECT_EQ(eventPriorities_[0], ReactEventPriority::Discrete);
+}
+
+} // namespace facebook::react

package/ReactCommon/react/renderer/core/tests/RawPropsTest.cpp

@@ -8,7 +8,9 @@
 #include <memory>
 
 #include <gtest/gtest.h>
+#include <react/debug/flags.h>
 #include <react/renderer/core/ConcreteShadowNode.h>
+#include <react/renderer/core/PropsParserContext.h>
 #include <react/renderer/core/ShadowNode.h>
 #include <react/renderer/core/propsConversions.h>
 
@@ -20,9 +22,11 @@ class PropsSingleFloat : public Props {
  public:
   PropsSingleFloat() = default;
   PropsSingleFloat(
+      const PropsParserContext &context,
       const PropsSingleFloat &sourceProps,
       const RawProps &rawProps)
       : floatValue(convertRawProp(
+            context,
             rawProps,
             "floatValue",
             sourceProps.floatValue,
@@ -36,9 +40,11 @@ class PropsSingleDouble : public Props {
  public:
   PropsSingleDouble() = default;
   PropsSingleDouble(
+      const PropsParserContext &context,
       const PropsSingleDouble &sourceProps,
       const RawProps &rawProps)
       : doubleValue(convertRawProp(
+            context,
             rawProps,
             "doubleValue",
             sourceProps.doubleValue,
@@ -51,9 +57,16 @@ class PropsSingleDouble : public Props {
 class PropsSingleInt : public Props {
  public:
   PropsSingleInt() = default;
-  PropsSingleInt(const PropsSingleInt &sourceProps, const RawProps &rawProps)
-      : intValue(
-            convertRawProp(rawProps, "intValue", sourceProps.intValue, 17)) {}
+  PropsSingleInt(
+      const PropsParserContext &context,
+      const PropsSingleInt &sourceProps,
+      const RawProps &rawProps)
+      : intValue(convertRawProp(
+            context,
+            rawProps,
+            "intValue",
+            sourceProps.intValue,
+            17)) {}
 
  private:
   const int intValue{17};
@@ -63,26 +76,35 @@ class PropsPrimitiveTypes : public Props {
  public:
   PropsPrimitiveTypes() = default;
   PropsPrimitiveTypes(
+      const PropsParserContext &context,
       const PropsPrimitiveTypes &sourceProps,
       const RawProps &rawProps)
-      : intValue(
-            convertRawProp(rawProps, "intValue", sourceProps.intValue, 17)),
+      : intValue(convertRawProp(
+            context,
+            rawProps,
+            "intValue",
+            sourceProps.intValue,
+            17)),
         doubleValue(convertRawProp(
+            context,
             rawProps,
             "doubleValue",
             sourceProps.doubleValue,
             17.56)),
         floatValue(convertRawProp(
+            context,
             rawProps,
             "floatValue",
             sourceProps.floatValue,
             56.75)),
         stringValue(convertRawProp(
+            context,
             rawProps,
             "stringValue",
             sourceProps.stringValue,
             "")),
         boolValue(convertRawProp(
+            context,
             rawProps,
             "boolValue",
             sourceProps.boolValue,
@@ -100,9 +122,11 @@ class PropsMultiLookup : public Props {
  public:
   PropsMultiLookup() = default;
   PropsMultiLookup(
+      const PropsParserContext &context,
       const PropsMultiLookup &sourceProps,
       const RawProps &rawProps)
       : floatValue(convertRawProp(
+            context,
             rawProps,
             "floatValue",
             sourceProps.floatValue,
@@ -111,7 +135,12 @@ class PropsMultiLookup : public Props {
         // pattern that does occur a lot: nested structs that access props we
         // have already accessed populating Props
         derivedFloatValue(
-            convertRawProp(rawProps, "floatValue", sourceProps.floatValue, 40) *
+            convertRawProp(
+                context,
+                rawProps,
+                "floatValue",
+                sourceProps.floatValue,
+                40) *
             2) {}
 
   const float floatValue{17.5};
@@ -119,12 +148,15 @@ class PropsMultiLookup : public Props {
 };
 
 TEST(RawPropsTest, handleProps) {
+  ContextContainer contextContainer{};
+  PropsParserContext parserContext{-1, contextContainer};
+
   const auto &raw = RawProps(folly::dynamic::object("nativeID", "abc"));
   auto parser = RawPropsParser();
   parser.prepare<Props>();
-  raw.parse(parser);
+  raw.parse(parser, parserContext);
 
-  auto props = std::make_shared<Props>(Props(), raw);
+  auto props = std::make_shared<Props>(parserContext, Props(), raw);
 
   // Props are not sealed after applying raw props.
   EXPECT_FALSE(props->getSealed());
@@ -133,10 +165,13 @@ TEST(RawPropsTest, handleProps) {
 }
 
 TEST(RawPropsTest, handleRawPropsSingleString) {
+  ContextContainer contextContainer{};
+  PropsParserContext parserContext{-1, contextContainer};
+
   const auto &raw = RawProps(folly::dynamic::object("nativeID", "abc"));
   auto parser = RawPropsParser();
   parser.prepare<Props>();
-  raw.parse(parser);
+  raw.parse(parser, parserContext);
 
   std::string value = (std::string)*raw.at("nativeID", nullptr, nullptr);
 
@@ -144,11 +179,14 @@ TEST(RawPropsTest, handleRawPropsSingleString) {
 }
 
 TEST(RawPropsTest, handleRawPropsSingleFloat) {
+  ContextContainer contextContainer{};
+  PropsParserContext parserContext{-1, contextContainer};
+
   const auto &raw =
       RawProps(folly::dynamic::object("floatValue", (float)42.42));
   auto parser = RawPropsParser();
   parser.prepare<PropsSingleFloat>();
-  raw.parse(parser);
+  raw.parse(parser, parserContext);
 
   float value = (float)*raw.at("floatValue", nullptr, nullptr);
 
@@ -156,11 +194,14 @@ TEST(RawPropsTest, handleRawPropsSingleFloat) {
 }
 
 TEST(RawPropsTest, handleRawPropsSingleDouble) {
+  ContextContainer contextContainer{};
+  PropsParserContext parserContext{-1, contextContainer};
+
   const auto &raw =
       RawProps(folly::dynamic::object("doubleValue", (double)42.42));
   auto parser = RawPropsParser();
   parser.prepare<PropsSingleDouble>();
-  raw.parse(parser);
+  raw.parse(parser, parserContext);
 
   double value = (double)*raw.at("doubleValue", nullptr, nullptr);
 
@@ -168,10 +209,13 @@ TEST(RawPropsTest, handleRawPropsSingleDouble) {
 }
 
 TEST(RawPropsTest, handleRawPropsSingleInt) {
+  ContextContainer contextContainer{};
+  PropsParserContext parserContext{-1, contextContainer};
+
   const auto &raw = RawProps(folly::dynamic::object("intValue", (int)42.42));
   auto parser = RawPropsParser();
   parser.prepare<PropsSingleInt>();
-  raw.parse(parser);
+  raw.parse(parser, parserContext);
 
   int value = (int)*raw.at("intValue", nullptr, nullptr);
 
@@ -179,10 +223,13 @@ TEST(RawPropsTest, handleRawPropsSingleInt) {
 }
 
 TEST(RawPropsTest, handleRawPropsSingleIntGetManyTimes) {
+  ContextContainer contextContainer{};
+  PropsParserContext parserContext{-1, contextContainer};
+
   const auto &raw = RawProps(folly::dynamic::object("intValue", (int)42.42));
   auto parser = RawPropsParser();
   parser.prepare<PropsSingleInt>();
-  raw.parse(parser);
+  raw.parse(parser, parserContext);
 
   EXPECT_EQ((int)*raw.at("intValue", nullptr, nullptr), 42);
   EXPECT_EQ((int)*raw.at("intValue", nullptr, nullptr), 42);
@@ -190,13 +237,17 @@ TEST(RawPropsTest, handleRawPropsSingleIntGetManyTimes) {
 }
 
 TEST(RawPropsTest, handleRawPropsPrimitiveTypes) {
-  const auto &raw = RawProps(folly::dynamic::object("intValue", (int)42)(
-      "doubleValue", (double)17.42)("floatValue", (float)66.67)(
-      "stringValue", "helloworld")("boolValue", true));
+  ContextContainer contextContainer{};
+  PropsParserContext parserContext{-1, contextContainer};
+
+  const auto &raw = RawProps(
+      folly::dynamic::object("intValue", (int)42)("doubleValue", (double)17.42)(
+          "floatValue",
+          (float)66.67)("stringValue", "helloworld")("boolValue", true));
 
   auto parser = RawPropsParser();
   parser.prepare<PropsPrimitiveTypes>();
-  raw.parse(parser);
+  raw.parse(parser, parserContext);
 
   EXPECT_EQ((int)*raw.at("intValue", nullptr, nullptr), 42);
   EXPECT_NEAR((double)*raw.at("doubleValue", nullptr, nullptr), 17.42, 0.0001);
@@ -208,13 +259,17 @@ TEST(RawPropsTest, handleRawPropsPrimitiveTypes) {
 }
 
 TEST(RawPropsTest, handleRawPropsPrimitiveTypesGetTwice) {
-  const auto &raw = RawProps(folly::dynamic::object("intValue", (int)42)(
-      "doubleValue", (double)17.42)("floatValue", (float)66.67)(
-      "stringValue", "helloworld")("boolValue", true));
+  ContextContainer contextContainer{};
+  PropsParserContext parserContext{-1, contextContainer};
+
+  const auto &raw = RawProps(
+      folly::dynamic::object("intValue", (int)42)("doubleValue", (double)17.42)(
+          "floatValue",
+          (float)66.67)("stringValue", "helloworld")("boolValue", true));
 
   auto parser = RawPropsParser();
   parser.prepare<PropsPrimitiveTypes>();
-  raw.parse(parser);
+  raw.parse(parser, parserContext);
 
   EXPECT_EQ((int)*raw.at("intValue", nullptr, nullptr), 42);
   EXPECT_NEAR((double)*raw.at("doubleValue", nullptr, nullptr), 17.42, 0.0001);
@@ -234,13 +289,17 @@ TEST(RawPropsTest, handleRawPropsPrimitiveTypesGetTwice) {
 }
 
 TEST(RawPropsTest, handleRawPropsPrimitiveTypesGetOutOfOrder) {
-  const auto &raw = RawProps(folly::dynamic::object("intValue", (int)42)(
-      "doubleValue", (double)17.42)("floatValue", (float)66.67)(
-      "stringValue", "helloworld")("boolValue", true));
+  ContextContainer contextContainer{};
+  PropsParserContext parserContext{-1, contextContainer};
+
+  const auto &raw = RawProps(
+      folly::dynamic::object("intValue", (int)42)("doubleValue", (double)17.42)(
+          "floatValue",
+          (float)66.67)("stringValue", "helloworld")("boolValue", true));
 
   auto parser = RawPropsParser();
   parser.prepare<PropsPrimitiveTypes>();
-  raw.parse(parser);
+  raw.parse(parser, parserContext);
 
   EXPECT_EQ((int)*raw.at("intValue", nullptr, nullptr), 42);
   EXPECT_NEAR((double)*raw.at("doubleValue", nullptr, nullptr), 17.42, 0.0001);
@@ -260,11 +319,14 @@ TEST(RawPropsTest, handleRawPropsPrimitiveTypesGetOutOfOrder) {
 }
 
 TEST(RawPropsTest, handleRawPropsPrimitiveTypesIncomplete) {
+  ContextContainer contextContainer{};
+  PropsParserContext parserContext{-1, contextContainer};
+
   const auto &raw = RawProps(folly::dynamic::object("intValue", (int)42));
 
   auto parser = RawPropsParser();
   parser.prepare<PropsPrimitiveTypes>();
-  raw.parse(parser);
+  raw.parse(parser, parserContext);
 
   EXPECT_EQ((int)*raw.at("intValue", nullptr, nullptr), 42);
   EXPECT_EQ(raw.at("doubleValue", nullptr, nullptr), nullptr);
@@ -275,13 +337,16 @@ TEST(RawPropsTest, handleRawPropsPrimitiveTypesIncomplete) {
   EXPECT_EQ((int)*raw.at("intValue", nullptr, nullptr), 42);
 }
 
-#ifndef NDEBUG
+#ifdef REACT_NATIVE_DEBUG
 TEST(RawPropsTest, handleRawPropsPrimitiveTypesIncorrectLookup) {
+  ContextContainer contextContainer{};
+  PropsParserContext parserContext{-1, contextContainer};
+
   const auto &raw = RawProps(folly::dynamic::object("intValue", (int)42));
 
   auto parser = RawPropsParser();
   parser.prepare<PropsPrimitiveTypes>();
-  raw.parse(parser);
+  raw.parse(parser, parserContext);
 
   // Before D18662135, looking up an invalid key would trigger
   // an infinite loop. This is out of contract, so we should only
@@ -292,12 +357,16 @@ TEST(RawPropsTest, handleRawPropsPrimitiveTypesIncorrectLookup) {
 #endif
 
 TEST(RawPropsTest, handlePropsMultiLookup) {
+  ContextContainer contextContainer{};
+  PropsParserContext parserContext{-1, contextContainer};
+
   const auto &raw = RawProps(folly::dynamic::object("floatValue", (float)10.0));
   auto parser = RawPropsParser();
   parser.prepare<PropsMultiLookup>();
-  raw.parse(parser);
+  raw.parse(parser, parserContext);
 
-  auto props = std::make_shared<PropsMultiLookup>(PropsMultiLookup(), raw);
+  auto props = std::make_shared<PropsMultiLookup>(
+      parserContext, PropsMultiLookup(), raw);
 
   // Props are not sealed after applying raw props.
   EXPECT_FALSE(props->getSealed());