Modernize StateReconciliationTest

Differential Revision: D48969984

fbshipit-source-id: cb8fe8262a23b655cf783a2aed77699a266dcc04

Author: javache

packages/react-native/ReactCommon/react/renderer/mounting/tests/StateReconciliationTest.cpp

@@ -22,6 +22,8 @@
 
 using namespace facebook::react;
 
+namespace {
+
 class DummyShadowTreeDelegate : public ShadowTreeDelegate {
  public:
   RootShadowNode::Unshared shadowTreeWillCommit(
@@ -36,7 +38,7 @@ class DummyShadowTreeDelegate : public ShadowTreeDelegate {
       bool mountSynchronously) const override{};
 };
 
-inline const ShadowNode* findDescendantNode(
+const ShadowNode* findDescendantNode(
     const ShadowNode& shadowNode,
     const ShadowNodeFamily& family) {
   const ShadowNode* result = nullptr;
@@ -47,82 +49,87 @@ inline const ShadowNode* findDescendantNode(
   return result;
 }
 
-inline const ShadowNode* findDescendantNode(
+const ShadowNode* findDescendantNode(
     const ShadowTree& shadowTree,
     const ShadowNodeFamily& family) {
   return findDescendantNode(
       *shadowTree.getCurrentRevision().rootShadowNode, family);
 }
 
-TEST(StateReconciliationTest, testStateReconciliation) {
-  auto builder = simpleComponentBuilder();
-
-  auto shadowNodeA = std::shared_ptr<RootShadowNode>{};
-  auto shadowNodeAA = std::shared_ptr<ViewShadowNode>{};
-  auto shadowNodeAB = std::shared_ptr<ScrollViewShadowNode>{};
-  auto shadowNodeABA = std::shared_ptr<ViewShadowNode>{};
-  auto shadowNodeABB = std::shared_ptr<ViewShadowNode>{};
-  auto shadowNodeABC = std::shared_ptr<ViewShadowNode>{};
-
-  // clang-format off
-  auto element =
-      Element<RootShadowNode>()
-        .reference(shadowNodeA)
-        .finalize([](RootShadowNode &shadowNode){
-          shadowNode.sealRecursive();
-        })
-        .children({
-          Element<ViewShadowNode>()
-            .reference(shadowNodeAA),
-          Element<ScrollViewShadowNode>()
-            .reference(shadowNodeAB)
-            .children({
-              Element<ViewShadowNode>()
+} // namespace
+
+class StateReconciliationTest : public ::testing::Test {
+ public:
+  StateReconciliationTest()
+      : shadowTree_(
+            SurfaceId{11},
+            LayoutConstraints{},
+            LayoutContext{},
+            shadowTreeDelegate_,
+            contextContainer_) {
+    // clang-format off
+    auto element =
+        Element<RootShadowNode>()
+          .reference(shadowNodeA_)
+          .finalize([](RootShadowNode &shadowNode){
+            shadowNode.sealRecursive();
+          })
+          .children({
+            Element<ViewShadowNode>()
+              .reference(shadowNodeAA_),
+            Element<ScrollViewShadowNode>()
+              .reference(shadowNodeAB_)
               .children({
                 Element<ViewShadowNode>()
-                  .reference(shadowNodeABA),
-                Element<ViewShadowNode>()
-                  .reference(shadowNodeABB),
-                Element<ViewShadowNode>()
-                  .reference(shadowNodeABC)
+                .children({
+                  Element<ViewShadowNode>()
+                    .reference(shadowNodeABA_),
+                  Element<ViewShadowNode>()
+                    .reference(shadowNodeABB_),
+                  Element<ViewShadowNode>()
+                    .reference(shadowNodeABC_)
+                })
               })
-            })
-        });
-  // clang-format on
-
-  ContextContainer contextContainer{};
-
-  auto shadowNode = builder.build(element);
-
-  auto rootShadowNodeState1 = shadowNode->ShadowNode::clone({});
+          });
+    // clang-format on
+    componentBuilder_.build(element);
+  }
+
+  ComponentBuilder componentBuilder_ = simpleComponentBuilder();
+  ContextContainer contextContainer_;
+  DummyShadowTreeDelegate shadowTreeDelegate_;
+  ShadowTree shadowTree_;
+
+  std::shared_ptr<RootShadowNode> shadowNodeA_;
+  std::shared_ptr<ViewShadowNode> shadowNodeAA_;
+  std::shared_ptr<ScrollViewShadowNode> shadowNodeAB_;
+  std::shared_ptr<ViewShadowNode> shadowNodeABA_;
+  std::shared_ptr<ViewShadowNode> shadowNodeABB_;
+  std::shared_ptr<ViewShadowNode> shadowNodeABC_;
+};
 
-  auto& scrollViewComponentDescriptor = shadowNodeAB->getComponentDescriptor();
-  auto& family = shadowNodeAB->getFamily();
-  auto state1 = shadowNodeAB->getState();
-  auto shadowTreeDelegate = DummyShadowTreeDelegate{};
-  ShadowTree shadowTree{
-      SurfaceId{11},
-      LayoutConstraints{},
-      LayoutContext{},
-      shadowTreeDelegate,
-      contextContainer};
+TEST_F(StateReconciliationTest, testStateReconciliation) {
+  // Cloning to get an unsealed shadowNode
+  auto rootShadowNodeState1 = shadowNodeA_->ShadowNode::clone({});
+  auto state1 = shadowNodeAB_->getState();
+  auto& family = shadowNodeAB_->getFamily();
 
-  shadowTree.commit(
+  shadowTree_.commit(
       [&](const RootShadowNode& /*oldRootShadowNode*/) {
         return std::static_pointer_cast<RootShadowNode>(rootShadowNodeState1);
       },
-      {true});
+      {/* .enableStateReconciliation = */ true});
 
   EXPECT_EQ(state1->getMostRecentState(), state1);
-
   EXPECT_EQ(
       findDescendantNode(*rootShadowNodeState1, family)->getState(), state1);
 
+  auto& scrollViewComponentDescriptor = shadowNodeAB_->getComponentDescriptor();
   auto state2 = scrollViewComponentDescriptor.createState(
       family, std::make_shared<const ScrollViewState>());
 
   auto rootShadowNodeState2 =
-      shadowNode->cloneTree(family, [&](const ShadowNode& oldShadowNode) {
+      shadowNodeA_->cloneTree(family, [&](const ShadowNode& oldShadowNode) {
         return oldShadowNode.clone(
             {ShadowNodeFragment::propsPlaceholder(),
              ShadowNodeFragment::childrenPlaceholder(),
@@ -132,11 +139,11 @@ TEST(StateReconciliationTest, testStateReconciliation) {
   EXPECT_EQ(
       findDescendantNode(*rootShadowNodeState2, family)->getState(), state2);
 
-  shadowTree.commit(
+  shadowTree_.commit(
       [&](const RootShadowNode& /*oldRootShadowNode*/) {
         return std::static_pointer_cast<RootShadowNode>(rootShadowNodeState2);
       },
-      {true});
+      {/* .enableStateReconciliation = */ true});
 
   EXPECT_EQ(state1->getMostRecentState(), state2);
   EXPECT_EQ(state2->getMostRecentState(), state2);
@@ -155,13 +162,13 @@ TEST(StateReconciliationTest, testStateReconciliation) {
   EXPECT_EQ(
       findDescendantNode(*rootShadowNodeState3, family)->getState(), state3);
 
-  shadowTree.commit(
+  shadowTree_.commit(
       [&](const RootShadowNode& /*oldRootShadowNode*/) {
         return std::static_pointer_cast<RootShadowNode>(rootShadowNodeState3);
       },
-      {true});
+      {/* .enableStateReconciliation = */ true});
 
-  EXPECT_EQ(findDescendantNode(shadowTree, family)->getState(), state3);
+  EXPECT_EQ(findDescendantNode(shadowTree_, family)->getState(), state3);
 
   EXPECT_EQ(state1->getMostRecentState(), state3);
   EXPECT_EQ(state2->getMostRecentState(), state3);
@@ -170,11 +177,11 @@ TEST(StateReconciliationTest, testStateReconciliation) {
   // This is the core part of the whole test.
   // Here we commit the old tree but we expect that the state associated with
   // the node will stay the same (newer that the old tree has).
-  shadowTree.commit(
+  shadowTree_.commit(
       [&](const RootShadowNode& /*oldRootShadowNode*/) {
         return std::static_pointer_cast<RootShadowNode>(rootShadowNodeState2);
       },
       {true});
 
-  EXPECT_EQ(findDescendantNode(shadowTree, family)->getState(), state3);
+  EXPECT_EQ(findDescendantNode(shadowTree_, family)->getState(), state3);
 }