Files
react-native/ReactCommon/fabric/core/tests/ShadowNodeTest.cpp
T
Valentin Shergin 059142935a Fabric: Introducing ShadowNodeTraits
Summary:
Quite often in the Fabric codebase, we need to iterate on a list of shadow nodes and perform some work depending on the exact type (or kind) of shadow node we have. Today, we exclusively use RTTI to test for exact type. The problem here is that RTTI is not only expensive in terms of code size (we are moving towards removing RTTI), it's expensive in terms of CPU cycles. (Don't mistake RTTI/dynamic_cast overhead with dynamic dispatch overhead!)

`dynamic_cast` has it's own advantages, of cource: it's simple and straight-forward and does not require additional configuration. On the other side, it requires knowledge about exact class relationship configuration and knowing the exact name of the class.

ShadowNodeTraits is the generalized solution for storing predefined traits right inside ShadowNode object and check/set/unset them efficiently and in a particular-class-independent manner.

This diff only implements it in general and switching storing an internal flag of ShadowNode inside the trait collection to save some space (and for illustration purposes as well).

In the coming diff, we will see how this approach allows tackling the real, non-trivial problem.

In addition to the concept, this diff implements some convenience infra, such as `ConcreteShadowNode::BaseTraits()` static method that allows designating intrinsic-to-a-class traits declaratively.

Changelog: [Internal] Fabric-specific internal change.

Reviewed By: sammy-SC

Differential Revision: D18525348

fbshipit-source-id: 083bb85e0a9dc9d6c69bf395bd338d3c18def688
2019-11-15 19:51:21 -08:00

350 lines
13 KiB
C++

/*
* 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/core/ConcreteShadowNode.h>
#include <react/core/ShadowNode.h>
#include "TestComponent.h"
using namespace facebook::react;
TEST(ShadowNodeTest, handleProps) {
const auto &raw = RawProps(folly::dynamic::object("nativeID", "abc"));
auto parser = RawPropsParser();
parser.prepare<Props>();
raw.parse(parser);
auto props = std::make_shared<Props>(Props(), raw);
// Props are not sealed after applying raw props.
ASSERT_FALSE(props->getSealed());
ASSERT_STREQ(props->nativeId.c_str(), "abc");
}
TEST(ShadowNodeTest, handleShadowNodeCreation) {
auto eventDispatcher = std::shared_ptr<EventDispatcher const>();
auto componentDescriptor = TestComponentDescriptor(eventDispatcher);
auto node = std::make_shared<TestShadowNode>(
ShadowNodeFragment{
/* .tag = */ 9,
/* .surfaceId = */ 1,
/* .props = */ std::make_shared<const TestProps>(),
/* .eventEmitter = */ ShadowNodeFragment::eventEmitterPlaceholder(),
/* .children = */ ShadowNode::emptySharedShadowNodeSharedList(),
},
componentDescriptor,
ShadowNodeTraits{});
ASSERT_FALSE(node->getSealed());
ASSERT_STREQ(node->getComponentName(), "Test");
ASSERT_EQ(node->getTag(), 9);
ASSERT_EQ(node->getSurfaceId(), 1);
ASSERT_EQ(node->getEventEmitter(), nullptr);
ASSERT_EQ(node->getChildren().size(), 0);
node->sealRecursive();
ASSERT_TRUE(node->getSealed());
ASSERT_TRUE(node->getProps()->getSealed());
}
TEST(ShadowNodeTest, handleShadowNodeSimpleCloning) {
auto eventDispatcher = std::shared_ptr<EventDispatcher const>();
auto componentDescriptor = TestComponentDescriptor(eventDispatcher);
auto node = std::make_shared<TestShadowNode>(
ShadowNodeFragment{
/* .tag = */ 9,
/* .surfaceId = */ 1,
/* .props = */ std::make_shared<const TestProps>(),
/* .eventEmitter = */ ShadowNodeFragment::eventEmitterPlaceholder(),
/* .children = */ ShadowNode::emptySharedShadowNodeSharedList(),
},
componentDescriptor,
ShadowNodeTraits{});
auto node2 = std::make_shared<TestShadowNode>(*node, ShadowNodeFragment{});
ASSERT_STREQ(node->getComponentName(), "Test");
ASSERT_EQ(node->getTag(), 9);
ASSERT_EQ(node->getSurfaceId(), 1);
ASSERT_EQ(node->getEventEmitter(), nullptr);
}
TEST(ShadowNodeTest, handleShadowNodeMutation) {
auto eventDispatcher = std::shared_ptr<EventDispatcher const>();
auto componentDescriptor = TestComponentDescriptor(eventDispatcher);
auto props = std::make_shared<const TestProps>();
auto node1 = std::make_shared<TestShadowNode>(
ShadowNodeFragment{
/* .tag = */ 1,
/* .surfaceId = */ 1,
/* .props = */ std::make_shared<const TestProps>(),
/* .eventEmitter = */ ShadowNodeFragment::eventEmitterPlaceholder(),
/* .children = */ ShadowNode::emptySharedShadowNodeSharedList(),
},
componentDescriptor,
ShadowNodeTraits{});
auto node2 = std::make_shared<TestShadowNode>(
ShadowNodeFragment{
/* .tag = */ 2,
/* .surfaceId = */ 1,
/* .props = */ std::make_shared<const TestProps>(),
/* .eventEmitter = */ ShadowNodeFragment::eventEmitterPlaceholder(),
/* .children = */ ShadowNode::emptySharedShadowNodeSharedList(),
},
componentDescriptor,
ShadowNodeTraits{});
auto node3 = std::make_shared<TestShadowNode>(
ShadowNodeFragment{
/* .tag = */ 3,
/* .surfaceId = */ 1,
/* .props = */ std::make_shared<const TestProps>(),
/* .eventEmitter = */ ShadowNodeFragment::eventEmitterPlaceholder(),
/* .children = */ ShadowNode::emptySharedShadowNodeSharedList(),
},
componentDescriptor,
ShadowNodeTraits{});
node1->appendChild(node2);
node1->appendChild(node3);
auto node1Children = node1->getChildren();
ASSERT_EQ(node1Children.size(), 2);
ASSERT_EQ(node1Children.at(0), node2);
ASSERT_EQ(node1Children.at(1), node3);
auto node4 = std::make_shared<TestShadowNode>(*node2, ShadowNodeFragment{});
node1->replaceChild(*node2, node4);
node1Children = node1->getChildren();
ASSERT_EQ(node1Children.size(), 2);
ASSERT_EQ(node1Children.at(0), node4);
ASSERT_EQ(node1Children.at(1), node3);
// Seal the entire tree.
node1->sealRecursive();
ASSERT_TRUE(node1->getSealed());
ASSERT_TRUE(node3->getSealed());
ASSERT_TRUE(node4->getSealed());
// No more mutation after sealing.
EXPECT_THROW(node4->setLocalData(nullptr), std::runtime_error);
auto node5 = std::make_shared<TestShadowNode>(*node4, ShadowNodeFragment{});
node5->setLocalData(nullptr);
ASSERT_EQ(node5->getLocalData(), nullptr);
}
TEST(ShadowNodeTest, handleCloneFunction) {
auto eventDispatcher = std::shared_ptr<EventDispatcher const>();
auto componentDescriptor = TestComponentDescriptor(eventDispatcher);
auto firstNode = std::make_shared<TestShadowNode>(
ShadowNodeFragment{
/* .tag = */ 9,
/* .surfaceId = */ 1,
/* .props = */ std::make_shared<const TestProps>(),
/* .eventEmitter = */ ShadowNodeFragment::eventEmitterPlaceholder(),
/* .children = */ ShadowNode::emptySharedShadowNodeSharedList(),
},
componentDescriptor,
ShadowNodeTraits{});
auto firstNodeClone = firstNode->clone({});
// Those two nodes are *not* same.
ASSERT_NE(firstNode, firstNodeClone);
// `secondNodeClone` is an instance of `TestShadowNode`.
ASSERT_NE(
std::dynamic_pointer_cast<const TestShadowNode>(firstNodeClone), nullptr);
// Both nodes have same content.
ASSERT_EQ(firstNode->getTag(), firstNodeClone->getTag());
ASSERT_EQ(firstNode->getSurfaceId(), firstNodeClone->getSurfaceId());
ASSERT_EQ(firstNode->getProps(), firstNodeClone->getProps());
}
TEST(ShadowNodeTest, handleLocalData) {
auto eventDispatcher = std::shared_ptr<EventDispatcher const>();
auto componentDescriptor = TestComponentDescriptor(eventDispatcher);
auto localData42 = std::make_shared<TestLocalData>();
localData42->setNumber(42);
auto anotherLocalData42 = std::make_shared<TestLocalData>();
anotherLocalData42->setNumber(42);
auto localDataOver9000 = std::make_shared<TestLocalData>();
localDataOver9000->setNumber(9001);
auto props = std::make_shared<const TestProps>();
auto firstNode = std::make_shared<TestShadowNode>(
ShadowNodeFragment{
/* .tag = */ 9,
/* .surfaceId = */ 1,
/* .props = */ props,
/* .eventEmitter = */ ShadowNodeFragment::eventEmitterPlaceholder(),
/* .children = */ ShadowNode::emptySharedShadowNodeSharedList(),
},
componentDescriptor,
ShadowNodeTraits{});
auto secondNode = std::make_shared<TestShadowNode>(
ShadowNodeFragment{
/* .tag = */ 9,
/* .surfaceId = */ 1,
/* .props = */ props,
/* .eventEmitter = */ ShadowNodeFragment::eventEmitterPlaceholder(),
/* .children = */ ShadowNode::emptySharedShadowNodeSharedList(),
},
componentDescriptor,
ShadowNodeTraits{});
auto thirdNode = std::make_shared<TestShadowNode>(
ShadowNodeFragment{
/* .tag = */ 9,
/* .surfaceId = */ 1,
/* .props = */ props,
/* .eventEmitter = */ ShadowNodeFragment::eventEmitterPlaceholder(),
/* .children = */ ShadowNode::emptySharedShadowNodeSharedList(),
},
componentDescriptor,
ShadowNodeTraits{});
firstNode->setLocalData(localData42);
secondNode->setLocalData(localData42);
thirdNode->setLocalData(localDataOver9000);
// LocalData object are compared by pointer, not by value.
ASSERT_EQ(firstNode->getLocalData(), secondNode->getLocalData());
ASSERT_NE(firstNode->getLocalData(), thirdNode->getLocalData());
secondNode->setLocalData(anotherLocalData42);
ASSERT_NE(firstNode->getLocalData(), secondNode->getLocalData());
// LocalData cannot be changed for sealed shadow node.
secondNode->sealRecursive();
ASSERT_ANY_THROW(secondNode->setLocalData(localDataOver9000));
}
TEST(ShadowNodeTest, handleBacktracking) {
/*
* The structure:
* <A>
* <AA/>
* <AB>
* <ABA/>
* <ABB/>
* <ABC/>
* </AB>
* <AC/>
* </A>
*/
auto eventDispatcher = std::shared_ptr<EventDispatcher const>();
auto componentDescriptor = TestComponentDescriptor(eventDispatcher);
auto props = std::make_shared<const TestProps>();
auto nodeAA = std::make_shared<TestShadowNode>(
ShadowNodeFragment{
/* .tag = */ ShadowNodeFragment::tagPlaceholder(),
/* .surfaceId = */ ShadowNodeFragment::surfaceIdPlaceholder(),
/* .props = */ props,
/* .eventEmitter = */ ShadowNodeFragment::eventEmitterPlaceholder(),
/* .children = */ ShadowNode::emptySharedShadowNodeSharedList(),
},
componentDescriptor,
ShadowNodeTraits{});
auto nodeABA = std::make_shared<TestShadowNode>(
ShadowNodeFragment{
/* .tag = */ ShadowNodeFragment::tagPlaceholder(),
/* .surfaceId = */ ShadowNodeFragment::surfaceIdPlaceholder(),
/* .props = */ props,
/* .eventEmitter = */ ShadowNodeFragment::eventEmitterPlaceholder(),
/* .children = */ ShadowNode::emptySharedShadowNodeSharedList(),
},
componentDescriptor,
ShadowNodeTraits{});
auto nodeABB = std::make_shared<TestShadowNode>(
ShadowNodeFragment{
/* .tag = */ ShadowNodeFragment::tagPlaceholder(),
/* .surfaceId = */ ShadowNodeFragment::surfaceIdPlaceholder(),
/* .props = */ props,
/* .eventEmitter = */ ShadowNodeFragment::eventEmitterPlaceholder(),
/* .children = */ ShadowNode::emptySharedShadowNodeSharedList(),
},
componentDescriptor,
ShadowNodeTraits{});
auto nodeABC = std::make_shared<TestShadowNode>(
ShadowNodeFragment{
/* .tag = */ ShadowNodeFragment::tagPlaceholder(),
/* .surfaceId = */ ShadowNodeFragment::surfaceIdPlaceholder(),
/* .props = */ props,
/* .eventEmitter = */ ShadowNodeFragment::eventEmitterPlaceholder(),
/* .children = */ ShadowNode::emptySharedShadowNodeSharedList(),
},
componentDescriptor,
ShadowNodeTraits{});
auto nodeABChildren = std::make_shared<SharedShadowNodeList>(
SharedShadowNodeList{nodeABA, nodeABB, nodeABC});
auto nodeAB = std::make_shared<TestShadowNode>(
ShadowNodeFragment{
/* .tag = */ ShadowNodeFragment::tagPlaceholder(),
/* .surfaceId = */ ShadowNodeFragment::surfaceIdPlaceholder(),
/* .props = */ props,
/* .eventEmitter = */ ShadowNodeFragment::eventEmitterPlaceholder(),
/* .children = */ nodeABChildren,
},
componentDescriptor,
ShadowNodeTraits{});
auto nodeAC = std::make_shared<TestShadowNode>(
ShadowNodeFragment{
/* .tag = */ ShadowNodeFragment::tagPlaceholder(),
/* .surfaceId = */ ShadowNodeFragment::surfaceIdPlaceholder(),
/* .props = */ props,
/* .eventEmitter = */ ShadowNodeFragment::eventEmitterPlaceholder(),
/* .children = */ ShadowNode::emptySharedShadowNodeSharedList(),
},
componentDescriptor,
ShadowNodeTraits{});
auto nodeAChildren = std::make_shared<SharedShadowNodeList>(
SharedShadowNodeList{nodeAA, nodeAB, nodeAC});
auto nodeA = std::make_shared<TestShadowNode>(
ShadowNodeFragment{
/* .tag = */ ShadowNodeFragment::tagPlaceholder(),
/* .surfaceId = */ ShadowNodeFragment::surfaceIdPlaceholder(),
/* .props = */ props,
/* .eventEmitter = */ ShadowNodeFragment::eventEmitterPlaceholder(),
/* .children = */ nodeAChildren,
},
componentDescriptor,
ShadowNodeTraits{});
auto nodeZ = std::make_shared<TestShadowNode>(
ShadowNodeFragment{
/* .tag = */ ShadowNodeFragment::tagPlaceholder(),
/* .surfaceId = */ ShadowNodeFragment::surfaceIdPlaceholder(),
/* .props = */ props,
/* .eventEmitter = */ ShadowNodeFragment::eventEmitterPlaceholder(),
/* .children = */ ShadowNode::emptySharedShadowNodeSharedList(),
},
componentDescriptor,
ShadowNodeTraits{});
std::vector<std::reference_wrapper<const ShadowNode>> ancestors = {};
// Negative case:
auto ancestors1 = nodeZ->getAncestors(*nodeA);
ASSERT_EQ(ancestors1.size(), 0);
// Positive case:
auto ancestors2 = nodeABC->getAncestors(*nodeA);
ASSERT_EQ(ancestors2.size(), 2);
ASSERT_EQ(&ancestors2[0].first.get(), nodeA.get());
ASSERT_EQ(&ancestors2[1].first.get(), nodeAB.get());
}