Use EXPECT instead of ASSERT in tests

Summary:
Changelog: [Internal]

1. Replace ASSERT_* with EXPECT_*. Assert is a fatal assertion. Expect is non-fatal assertion. So if assert fails, tests do not continue and therefore provide less information.

2. Rename tests in `RawPropsTest.cpp` from `ShadowNodeTest` to `RawPropsTest`.

Source: https://github.com/google/googletest/blob/master/googletest/docs/primer.md#basic-assertions

Reviewed By: shergin

Differential Revision: D19464967

fbshipit-source-id: add83751ebdb0a12fbf8f70b851747aa5624366a

ReactCommon/fabric/core/tests/ComponentDescriptorTest.cpp

@@ -17,9 +17,9 @@ TEST(ComponentDescriptorTest, createShadowNode) {
       std::make_shared<TestComponentDescriptor>(
           ComponentDescriptorParameters{eventDispatcher, nullptr, nullptr});
 
-  ASSERT_EQ(descriptor->getComponentHandle(), TestShadowNode::Handle());
-  ASSERT_STREQ(descriptor->getComponentName(), TestShadowNode::Name());
-  ASSERT_STREQ(descriptor->getComponentName(), "Test");
+  EXPECT_EQ(descriptor->getComponentHandle(), TestShadowNode::Handle());
+  EXPECT_STREQ(descriptor->getComponentName(), TestShadowNode::Name());
+  EXPECT_STREQ(descriptor->getComponentName(), "Test");
 
   const auto &raw = RawProps(folly::dynamic::object("nativeID", "abc"));
   SharedProps props = descriptor->cloneProps(nullptr, raw);
@@ -34,12 +34,12 @@ TEST(ComponentDescriptorTest, createShadowNode) {
           /* .eventEmitter = */ descriptor->createEventEmitter(0, 9),
       });
 
-  ASSERT_EQ(node->getComponentHandle(), TestShadowNode::Handle());
-  ASSERT_STREQ(node->getComponentName(), TestShadowNode::Name());
-  ASSERT_STREQ(node->getComponentName(), "Test");
-  ASSERT_EQ(node->getTag(), 9);
-  ASSERT_EQ(node->getSurfaceId(), 1);
-  ASSERT_STREQ(node->getProps()->nativeId.c_str(), "abc");
+  EXPECT_EQ(node->getComponentHandle(), TestShadowNode::Handle());
+  EXPECT_STREQ(node->getComponentName(), TestShadowNode::Name());
+  EXPECT_STREQ(node->getComponentName(), "Test");
+  EXPECT_EQ(node->getTag(), 9);
+  EXPECT_EQ(node->getSurfaceId(), 1);
+  EXPECT_STREQ(node->getProps()->nativeId.c_str(), "abc");
 }
 
 TEST(ComponentDescriptorTest, cloneShadowNode) {
@@ -61,10 +61,10 @@ TEST(ComponentDescriptorTest, cloneShadowNode) {
       });
   SharedShadowNode cloned = descriptor->cloneShadowNode(*node, {});
 
-  ASSERT_STREQ(cloned->getComponentName(), "Test");
-  ASSERT_EQ(cloned->getTag(), 9);
-  ASSERT_EQ(cloned->getSurfaceId(), 1);
-  ASSERT_STREQ(cloned->getProps()->nativeId.c_str(), "abc");
+  EXPECT_STREQ(cloned->getComponentName(), "Test");
+  EXPECT_EQ(cloned->getTag(), 9);
+  EXPECT_EQ(cloned->getSurfaceId(), 1);
+  EXPECT_STREQ(cloned->getProps()->nativeId.c_str(), "abc");
 }
 
 TEST(ComponentDescriptorTest, appendChild) {
@@ -108,7 +108,7 @@ TEST(ComponentDescriptorTest, appendChild) {
   descriptor->appendChild(node1, node3);
 
   auto node1Children = node1->getChildren();
-  ASSERT_EQ(node1Children.size(), 2);
-  ASSERT_EQ(node1Children.at(0), node2);
-  ASSERT_EQ(node1Children.at(1), node3);
+  EXPECT_EQ(node1Children.size(), 2);
+  EXPECT_EQ(node1Children.at(0), node2);
+  EXPECT_EQ(node1Children.at(1), node3);
 }

ReactCommon/fabric/core/tests/PrimitivesTest.cpp

@@ -14,10 +14,10 @@ using namespace facebook::react;
 
 TEST(SealableTest, sealObjectCorrectly) {
   Sealable obj;
-  ASSERT_FALSE(obj.getSealed());
+  EXPECT_FALSE(obj.getSealed());
 
   obj.seal();
-  ASSERT_TRUE(obj.getSealed());
+  EXPECT_TRUE(obj.getSealed());
 }
 
 TEST(SealableTest, handleAssignmentsCorrectly) {
@@ -37,5 +37,5 @@ TEST(SealableTest, handleAssignmentsCorrectly) {
 
   // Fresh creation off other Sealable is still unsealed.
   Sealable other3(obj);
-  ASSERT_FALSE(other3.getSealed());
+  EXPECT_FALSE(other3.getSealed());
 }

ReactCommon/fabric/core/tests/RawPropsTest.cpp

@@ -118,7 +118,7 @@ class PropsMultiLookup : public Props {
   const float derivedFloatValue{40};
 };
 
-TEST(ShadowNodeTest, handleProps) {
+TEST(RawPropsTest, handleProps) {
   const auto &raw = RawProps(folly::dynamic::object("nativeID", "abc"));
   auto parser = RawPropsParser();
   parser.prepare<Props>();
@@ -127,12 +127,12 @@ TEST(ShadowNodeTest, handleProps) {
   auto props = std::make_shared<Props>(Props(), raw);
 
   // Props are not sealed after applying raw props.
-  ASSERT_FALSE(props->getSealed());
+  EXPECT_FALSE(props->getSealed());
 
-  ASSERT_STREQ(props->nativeId.c_str(), "abc");
+  EXPECT_STREQ(props->nativeId.c_str(), "abc");
 }
 
-TEST(ShadowNodeTest, handleRawPropsSingleString) {
+TEST(RawPropsTest, handleRawPropsSingleString) {
   const auto &raw = RawProps(folly::dynamic::object("nativeID", "abc"));
   auto parser = RawPropsParser();
   parser.prepare<Props>();
@@ -140,10 +140,10 @@ TEST(ShadowNodeTest, handleRawPropsSingleString) {
 
   std::string value = (std::string)*raw.at("nativeID", nullptr, nullptr);
 
-  ASSERT_STREQ(value.c_str(), "abc");
+  EXPECT_STREQ(value.c_str(), "abc");
 }
 
-TEST(ShadowNodeTest, handleRawPropsSingleFloat) {
+TEST(RawPropsTest, handleRawPropsSingleFloat) {
   const auto &raw =
       RawProps(folly::dynamic::object("floatValue", (float)42.42));
   auto parser = RawPropsParser();
@@ -152,10 +152,10 @@ TEST(ShadowNodeTest, handleRawPropsSingleFloat) {
 
   float value = (float)*raw.at("floatValue", nullptr, nullptr);
 
-  ASSERT_NEAR(value, 42.42, 0.00001);
+  EXPECT_NEAR(value, 42.42, 0.00001);
 }
 
-TEST(ShadowNodeTest, handleRawPropsSingleDouble) {
+TEST(RawPropsTest, handleRawPropsSingleDouble) {
   const auto &raw =
       RawProps(folly::dynamic::object("doubleValue", (double)42.42));
   auto parser = RawPropsParser();
@@ -164,10 +164,10 @@ TEST(ShadowNodeTest, handleRawPropsSingleDouble) {
 
   double value = (double)*raw.at("doubleValue", nullptr, nullptr);
 
-  ASSERT_NEAR(value, 42.42, 0.00001);
+  EXPECT_NEAR(value, 42.42, 0.00001);
 }
 
-TEST(ShadowNodeTest, handleRawPropsSingleInt) {
+TEST(RawPropsTest, handleRawPropsSingleInt) {
   const auto &raw = RawProps(folly::dynamic::object("intValue", (int)42.42));
   auto parser = RawPropsParser();
   parser.prepare<PropsSingleInt>();
@@ -175,21 +175,21 @@ TEST(ShadowNodeTest, handleRawPropsSingleInt) {
 
   int value = (int)*raw.at("intValue", nullptr, nullptr);
 
-  ASSERT_EQ(value, 42);
+  EXPECT_EQ(value, 42);
 }
 
-TEST(ShadowNodeTest, handleRawPropsSingleIntGetManyTimes) {
+TEST(RawPropsTest, handleRawPropsSingleIntGetManyTimes) {
   const auto &raw = RawProps(folly::dynamic::object("intValue", (int)42.42));
   auto parser = RawPropsParser();
   parser.prepare<PropsSingleInt>();
   raw.parse(parser);
 
-  ASSERT_EQ((int)*raw.at("intValue", nullptr, nullptr), 42);
-  ASSERT_EQ((int)*raw.at("intValue", nullptr, nullptr), 42);
-  ASSERT_EQ((int)*raw.at("intValue", nullptr, nullptr), 42);
+  EXPECT_EQ((int)*raw.at("intValue", nullptr, nullptr), 42);
+  EXPECT_EQ((int)*raw.at("intValue", nullptr, nullptr), 42);
+  EXPECT_EQ((int)*raw.at("intValue", nullptr, nullptr), 42);
 }
 
-TEST(ShadowNodeTest, handleRawPropsPrimitiveTypes) {
+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));
@@ -198,16 +198,16 @@ TEST(ShadowNodeTest, handleRawPropsPrimitiveTypes) {
   parser.prepare<PropsPrimitiveTypes>();
   raw.parse(parser);
 
-  ASSERT_EQ((int)*raw.at("intValue", nullptr, nullptr), 42);
-  ASSERT_NEAR((double)*raw.at("doubleValue", nullptr, nullptr), 17.42, 0.0001);
-  ASSERT_NEAR((float)*raw.at("floatValue", nullptr, nullptr), 66.67, 0.00001);
-  ASSERT_STREQ(
+  EXPECT_EQ((int)*raw.at("intValue", nullptr, nullptr), 42);
+  EXPECT_NEAR((double)*raw.at("doubleValue", nullptr, nullptr), 17.42, 0.0001);
+  EXPECT_NEAR((float)*raw.at("floatValue", nullptr, nullptr), 66.67, 0.00001);
+  EXPECT_STREQ(
       ((std::string)*raw.at("stringValue", nullptr, nullptr)).c_str(),
       "helloworld");
-  ASSERT_EQ((bool)*raw.at("boolValue", nullptr, nullptr), true);
+  EXPECT_EQ((bool)*raw.at("boolValue", nullptr, nullptr), true);
 }
 
-TEST(ShadowNodeTest, handleRawPropsPrimitiveTypesGetTwice) {
+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));
@@ -216,24 +216,24 @@ TEST(ShadowNodeTest, handleRawPropsPrimitiveTypesGetTwice) {
   parser.prepare<PropsPrimitiveTypes>();
   raw.parse(parser);
 
-  ASSERT_EQ((int)*raw.at("intValue", nullptr, nullptr), 42);
-  ASSERT_NEAR((double)*raw.at("doubleValue", nullptr, nullptr), 17.42, 0.0001);
-  ASSERT_NEAR((float)*raw.at("floatValue", nullptr, nullptr), 66.67, 0.00001);
-  ASSERT_STREQ(
+  EXPECT_EQ((int)*raw.at("intValue", nullptr, nullptr), 42);
+  EXPECT_NEAR((double)*raw.at("doubleValue", nullptr, nullptr), 17.42, 0.0001);
+  EXPECT_NEAR((float)*raw.at("floatValue", nullptr, nullptr), 66.67, 0.00001);
+  EXPECT_STREQ(
       ((std::string)*raw.at("stringValue", nullptr, nullptr)).c_str(),
       "helloworld");
-  ASSERT_EQ((bool)*raw.at("boolValue", nullptr, nullptr), true);
+  EXPECT_EQ((bool)*raw.at("boolValue", nullptr, nullptr), true);
 
-  ASSERT_EQ((int)*raw.at("intValue", nullptr, nullptr), 42);
-  ASSERT_NEAR((double)*raw.at("doubleValue", nullptr, nullptr), 17.42, 0.0001);
-  ASSERT_NEAR((float)*raw.at("floatValue", nullptr, nullptr), 66.67, 0.00001);
-  ASSERT_STREQ(
+  EXPECT_EQ((int)*raw.at("intValue", nullptr, nullptr), 42);
+  EXPECT_NEAR((double)*raw.at("doubleValue", nullptr, nullptr), 17.42, 0.0001);
+  EXPECT_NEAR((float)*raw.at("floatValue", nullptr, nullptr), 66.67, 0.00001);
+  EXPECT_STREQ(
       ((std::string)*raw.at("stringValue", nullptr, nullptr)).c_str(),
       "helloworld");
-  ASSERT_EQ((bool)*raw.at("boolValue", nullptr, nullptr), true);
+  EXPECT_EQ((bool)*raw.at("boolValue", nullptr, nullptr), true);
 }
 
-TEST(ShadowNodeTest, handleRawPropsPrimitiveTypesGetOutOfOrder) {
+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));
@@ -242,41 +242,41 @@ TEST(ShadowNodeTest, handleRawPropsPrimitiveTypesGetOutOfOrder) {
   parser.prepare<PropsPrimitiveTypes>();
   raw.parse(parser);
 
-  ASSERT_EQ((int)*raw.at("intValue", nullptr, nullptr), 42);
-  ASSERT_NEAR((double)*raw.at("doubleValue", nullptr, nullptr), 17.42, 0.0001);
-  ASSERT_NEAR((float)*raw.at("floatValue", nullptr, nullptr), 66.67, 0.00001);
-  ASSERT_STREQ(
+  EXPECT_EQ((int)*raw.at("intValue", nullptr, nullptr), 42);
+  EXPECT_NEAR((double)*raw.at("doubleValue", nullptr, nullptr), 17.42, 0.0001);
+  EXPECT_NEAR((float)*raw.at("floatValue", nullptr, nullptr), 66.67, 0.00001);
+  EXPECT_STREQ(
       ((std::string)*raw.at("stringValue", nullptr, nullptr)).c_str(),
       "helloworld");
-  ASSERT_EQ((bool)*raw.at("boolValue", nullptr, nullptr), true);
+  EXPECT_EQ((bool)*raw.at("boolValue", nullptr, nullptr), true);
 
-  ASSERT_NEAR((double)*raw.at("doubleValue", nullptr, nullptr), 17.42, 0.0001);
-  ASSERT_EQ((int)*raw.at("intValue", nullptr, nullptr), 42);
-  ASSERT_NEAR((float)*raw.at("floatValue", nullptr, nullptr), 66.67, 0.00001);
-  ASSERT_STREQ(
+  EXPECT_NEAR((double)*raw.at("doubleValue", nullptr, nullptr), 17.42, 0.0001);
+  EXPECT_EQ((int)*raw.at("intValue", nullptr, nullptr), 42);
+  EXPECT_NEAR((float)*raw.at("floatValue", nullptr, nullptr), 66.67, 0.00001);
+  EXPECT_STREQ(
       ((std::string)*raw.at("stringValue", nullptr, nullptr)).c_str(),
       "helloworld");
-  ASSERT_EQ((bool)*raw.at("boolValue", nullptr, nullptr), true);
+  EXPECT_EQ((bool)*raw.at("boolValue", nullptr, nullptr), true);
 }
 
-TEST(ShadowNodeTest, handleRawPropsPrimitiveTypesIncomplete) {
+TEST(RawPropsTest, handleRawPropsPrimitiveTypesIncomplete) {
   const auto &raw = RawProps(folly::dynamic::object("intValue", (int)42));
 
   auto parser = RawPropsParser();
   parser.prepare<PropsPrimitiveTypes>();
   raw.parse(parser);
 
-  ASSERT_EQ((int)*raw.at("intValue", nullptr, nullptr), 42);
-  ASSERT_EQ(raw.at("doubleValue", nullptr, nullptr), nullptr);
-  ASSERT_EQ(raw.at("floatValue", nullptr, nullptr), nullptr);
-  ASSERT_EQ((int)*raw.at("intValue", nullptr, nullptr), 42);
-  ASSERT_EQ(raw.at("stringValue", nullptr, nullptr), nullptr);
-  ASSERT_EQ(raw.at("boolValue", nullptr, nullptr), nullptr);
-  ASSERT_EQ((int)*raw.at("intValue", nullptr, nullptr), 42);
+  EXPECT_EQ((int)*raw.at("intValue", nullptr, nullptr), 42);
+  EXPECT_EQ(raw.at("doubleValue", nullptr, nullptr), nullptr);
+  EXPECT_EQ(raw.at("floatValue", nullptr, nullptr), nullptr);
+  EXPECT_EQ((int)*raw.at("intValue", nullptr, nullptr), 42);
+  EXPECT_EQ(raw.at("stringValue", nullptr, nullptr), nullptr);
+  EXPECT_EQ(raw.at("boolValue", nullptr, nullptr), nullptr);
+  EXPECT_EQ((int)*raw.at("intValue", nullptr, nullptr), 42);
 }
 
 #ifndef NDEBUG
-TEST(ShadowNodeTest, handleRawPropsPrimitiveTypesIncorrectLookup) {
+TEST(RawPropsTest, handleRawPropsPrimitiveTypesIncorrectLookup) {
   const auto &raw = RawProps(folly::dynamic::object("intValue", (int)42));
 
   auto parser = RawPropsParser();
@@ -286,12 +286,12 @@ TEST(ShadowNodeTest, handleRawPropsPrimitiveTypesIncorrectLookup) {
   // Before D18662135, looking up an invalid key would trigger
   // an infinite loop. This is out of contract, so we should only
   // test this in debug.
-  ASSERT_EQ(raw.at("flurb", nullptr, nullptr), nullptr);
-  ASSERT_EQ((int)*raw.at("intValue", nullptr, nullptr), 42);
+  EXPECT_EQ(raw.at("flurb", nullptr, nullptr), nullptr);
+  EXPECT_EQ((int)*raw.at("intValue", nullptr, nullptr), 42);
 }
 #endif
 
-TEST(ShadowNodeTest, handlePropsMultiLookup) {
+TEST(RawPropsTest, handlePropsMultiLookup) {
   const auto &raw = RawProps(folly::dynamic::object("floatValue", (float)10.0));
   auto parser = RawPropsParser();
   parser.prepare<PropsMultiLookup>();
@@ -300,8 +300,8 @@ TEST(ShadowNodeTest, handlePropsMultiLookup) {
   auto props = std::make_shared<PropsMultiLookup>(PropsMultiLookup(), raw);
 
   // Props are not sealed after applying raw props.
-  ASSERT_FALSE(props->getSealed());
+  EXPECT_FALSE(props->getSealed());
 
-  ASSERT_NEAR(props->floatValue, 10.0, 0.00001);
-  ASSERT_NEAR(props->derivedFloatValue, 20.0, 0.00001);
+  EXPECT_NEAR(props->floatValue, 10.0, 0.00001);
+  EXPECT_NEAR(props->derivedFloatValue, 20.0, 0.00001);
 }

ReactCommon/fabric/core/tests/ShadowNodeTest.cpp

@@ -34,16 +34,16 @@ TEST(ShadowNodeTest, handleShadowNodeCreation) {
       family,
       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);
+  EXPECT_FALSE(node->getSealed());
+  EXPECT_STREQ(node->getComponentName(), "Test");
+  EXPECT_EQ(node->getTag(), 9);
+  EXPECT_EQ(node->getSurfaceId(), 1);
+  EXPECT_EQ(node->getEventEmitter(), nullptr);
+  EXPECT_EQ(node->getChildren().size(), 0);
 
   node->sealRecursive();
-  ASSERT_TRUE(node->getSealed());
-  ASSERT_TRUE(node->getProps()->getSealed());
+  EXPECT_TRUE(node->getSealed());
+  EXPECT_TRUE(node->getProps()->getSealed());
 }
 
 TEST(ShadowNodeTest, handleShadowNodeSimpleCloning) {
@@ -66,10 +66,10 @@ TEST(ShadowNodeTest, handleShadowNodeSimpleCloning) {
       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);
+  EXPECT_STREQ(node->getComponentName(), "Test");
+  EXPECT_EQ(node->getTag(), 9);
+  EXPECT_EQ(node->getSurfaceId(), 1);
+  EXPECT_EQ(node->getEventEmitter(), nullptr);
 }
 
 TEST(ShadowNodeTest, handleShadowNodeMutation) {
@@ -123,29 +123,29 @@ TEST(ShadowNodeTest, handleShadowNodeMutation) {
   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);
+  EXPECT_EQ(node1Children.size(), 2);
+  EXPECT_EQ(node1Children.at(0), node2);
+  EXPECT_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);
+  EXPECT_EQ(node1Children.size(), 2);
+  EXPECT_EQ(node1Children.at(0), node4);
+  EXPECT_EQ(node1Children.at(1), node3);
 
   // Seal the entire tree.
   node1->sealRecursive();
-  ASSERT_TRUE(node1->getSealed());
-  ASSERT_TRUE(node3->getSealed());
-  ASSERT_TRUE(node4->getSealed());
+  EXPECT_TRUE(node1->getSealed());
+  EXPECT_TRUE(node3->getSealed());
+  EXPECT_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);
+  EXPECT_EQ(node5->getLocalData(), nullptr);
 }
 
 TEST(ShadowNodeTest, handleCloneFunction) {
@@ -171,16 +171,16 @@ TEST(ShadowNodeTest, handleCloneFunction) {
   auto firstNodeClone = firstNode->clone({});
 
   // Those two nodes are *not* same.
-  ASSERT_NE(firstNode, firstNodeClone);
+  EXPECT_NE(firstNode, firstNodeClone);
 
   // `secondNodeClone` is an instance of `TestShadowNode`.
-  ASSERT_NE(
+  EXPECT_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());
+  EXPECT_EQ(firstNode->getTag(), firstNodeClone->getTag());
+  EXPECT_EQ(firstNode->getSurfaceId(), firstNodeClone->getSurfaceId());
+  EXPECT_EQ(firstNode->getProps(), firstNodeClone->getProps());
 }
 
 TEST(ShadowNodeTest, handleLocalData) {
@@ -230,14 +230,14 @@ TEST(ShadowNodeTest, handleLocalData) {
   thirdNode->setLocalData(localDataOver9000);
 
   // LocalData object are compared by pointer, not by value.
-  ASSERT_EQ(firstNode->getLocalData(), secondNode->getLocalData());
-  ASSERT_NE(firstNode->getLocalData(), thirdNode->getLocalData());
+  EXPECT_EQ(firstNode->getLocalData(), secondNode->getLocalData());
+  EXPECT_NE(firstNode->getLocalData(), thirdNode->getLocalData());
   secondNode->setLocalData(anotherLocalData42);
-  ASSERT_NE(firstNode->getLocalData(), secondNode->getLocalData());
+  EXPECT_NE(firstNode->getLocalData(), secondNode->getLocalData());
 
   // LocalData cannot be changed for sealed shadow node.
   secondNode->sealRecursive();
-  ASSERT_ANY_THROW(secondNode->setLocalData(localDataOver9000));
+  EXPECT_ANY_THROW(secondNode->setLocalData(localDataOver9000));
 }
 
 TEST(ShadowNodeTest, handleBacktracking) {
@@ -389,11 +389,11 @@ TEST(ShadowNodeTest, handleBacktracking) {
 
   // Negative case:
   auto ancestors1 = nodeZ->getAncestors(*nodeA);
-  ASSERT_EQ(ancestors1.size(), 0);
+  EXPECT_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());
+  EXPECT_EQ(ancestors2.size(), 2);
+  EXPECT_EQ(&ancestors2[0].first.get(), nodeA.get());
+  EXPECT_EQ(&ancestors2[1].first.get(), nodeAB.get());
 }