diff --git a/ReactCommon/fabric/core/tests/ComponentDescriptorTest.cpp b/ReactCommon/fabric/core/tests/ComponentDescriptorTest.cpp index 2a77081ffa5..ca951a8eac1 100644 --- a/ReactCommon/fabric/core/tests/ComponentDescriptorTest.cpp +++ b/ReactCommon/fabric/core/tests/ComponentDescriptorTest.cpp @@ -17,9 +17,9 @@ TEST(ComponentDescriptorTest, createShadowNode) { std::make_shared( 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); } diff --git a/ReactCommon/fabric/core/tests/PrimitivesTest.cpp b/ReactCommon/fabric/core/tests/PrimitivesTest.cpp index f6fe13ebfae..f156ed77b42 100644 --- a/ReactCommon/fabric/core/tests/PrimitivesTest.cpp +++ b/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()); } diff --git a/ReactCommon/fabric/core/tests/RawPropsTest.cpp b/ReactCommon/fabric/core/tests/RawPropsTest.cpp index 7d22b8132eb..7a5ecb1f94b 100644 --- a/ReactCommon/fabric/core/tests/RawPropsTest.cpp +++ b/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(); @@ -127,12 +127,12 @@ TEST(ShadowNodeTest, handleProps) { auto props = std::make_shared(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(); @@ -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(); @@ -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(); 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(); 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(); 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(); 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(); 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(); @@ -300,8 +300,8 @@ TEST(ShadowNodeTest, handlePropsMultiLookup) { auto props = std::make_shared(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); } diff --git a/ReactCommon/fabric/core/tests/ShadowNodeTest.cpp b/ReactCommon/fabric/core/tests/ShadowNodeTest.cpp index 1e33586b750..fbe4016d150 100644 --- a/ReactCommon/fabric/core/tests/ShadowNodeTest.cpp +++ b/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(*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(*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(*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(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()); }