react-native/ReactCommon/fabric/element/tests/ElementTest.cpp at soloader-version · devagul93/react-native · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
/*
 * 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 <memory>

#include <gtest/gtest.h>

#include <react/components/root/RootComponentDescriptor.h>
#include <react/components/view/ViewComponentDescriptor.h>
#include <react/element/ComponentBuilder.h>
#include <react/element/Element.h>
#include <react/element/testUtils.h>
#include <react/uimanager/ComponentDescriptorProviderRegistry.h>

using namespace facebook::react;

TEST(ElementTest, testNormalCases) {
  auto builder = simpleComponentBuilder();

  auto shadowNodeA = std::shared_ptr<RootShadowNode>{};
  auto shadowNodeAA = std::shared_ptr<ViewShadowNode>{};
  auto shadowNodeAB = std::shared_ptr<ViewShadowNode>{};
  auto shadowNodeABA = std::shared_ptr<ViewShadowNode>{};

  auto propsAA = std::make_shared<ViewProps>();
  propsAA->nativeId = "node AA";

  // clang-format off
  auto element =
      Element<RootShadowNode>()
        .reference(shadowNodeA)
        .tag(1)
        .props([]() {
          auto props = std::make_shared<RootProps>();
          props->nativeId = "node A";
          return props;
        })
        .finalize([](RootShadowNode &shadowNode){
          shadowNode.sealRecursive();
        })
        .children({
          Element<ViewShadowNode>()
            .reference(shadowNodeAA)
            .tag(2)
            .props(propsAA),
          Element<ViewShadowNode>()
            .reference(shadowNodeAB)
            .tag(3)
            .props([]() {
               auto props = std::make_shared<ViewProps>();
               props->nativeId = "node AB";
               return props;
            })
            .children({
              Element<ViewShadowNode>()
                .reference(shadowNodeABA)
                .tag(4)
                .props([]() {
                  auto props = std::make_shared<ViewProps>();
                  props->nativeId = "node ABA";
                  return props;
                })
            })
        });
  // clang-format on

  auto shadowNode = builder.build(element);

  EXPECT_EQ(shadowNode, shadowNodeA);

  // Tags
  EXPECT_EQ(shadowNodeA->getTag(), 1);
  EXPECT_EQ(shadowNodeAA->getTag(), 2);
  EXPECT_EQ(shadowNodeAB->getTag(), 3);
  EXPECT_EQ(shadowNodeABA->getTag(), 4);

  // Children
  EXPECT_EQ(shadowNodeA->getChildren().size(), 2);
  EXPECT_EQ(shadowNodeAA->getChildren().size(), 0);
  EXPECT_EQ(shadowNodeAB->getChildren().size(), 1);
  EXPECT_EQ(shadowNodeABA->getChildren().size(), 0);
  EXPECT_EQ(
      shadowNodeA->getChildren(),
      (ShadowNode::ListOfShared{shadowNodeAA, shadowNodeAB}));
  EXPECT_EQ(
      shadowNodeAB->getChildren(), (ShadowNode::ListOfShared{shadowNodeABA}));

  // Props
  EXPECT_EQ(shadowNodeA->getProps()->nativeId, "node A");
  EXPECT_EQ(shadowNodeABA->getProps()->nativeId, "node ABA");
  EXPECT_EQ(shadowNodeAA->getProps(), propsAA);

  // Finalize
  EXPECT_TRUE(shadowNodeA->getSealed());
  EXPECT_TRUE(shadowNodeAA->getSealed());
  EXPECT_TRUE(shadowNodeAB->getSealed());
  EXPECT_TRUE(shadowNodeABA->getSealed());
}