From 4c95b7ff4235b86163b1609d2184085989096757 Mon Sep 17 00:00:00 2001 From: Jeff Feasel Date: Tue, 30 Apr 2024 20:07:32 -0400 Subject: [PATCH 1/8] Refactored TestSecureSessionTable.cpp to use TestSecureSessionTable as the pw test context. --- src/transport/tests/BUILD.gn | 6 +- src/transport/tests/TestCryptoContext.cpp | 54 +- .../tests/TestGroupMessageCounter.cpp | 211 ++++---- src/transport/tests/TestPeerConnections.cpp | 88 ++-- .../tests/TestPeerMessageCounter.cpp | 170 +++---- src/transport/tests/TestSecureSession.cpp | 152 ++---- .../tests/TestSecureSessionTable.cpp | 146 ++---- src/transport/tests/TestSessionManager.cpp | 476 +++++++----------- .../tests/TestSessionManagerDispatch.cpp | 137 ++--- 9 files changed, 522 insertions(+), 918 deletions(-) diff --git a/src/transport/tests/BUILD.gn b/src/transport/tests/BUILD.gn index 8e3f9365d023c8..7c38cea5e7e8eb 100644 --- a/src/transport/tests/BUILD.gn +++ b/src/transport/tests/BUILD.gn @@ -14,7 +14,7 @@ import("//build_overrides/build.gni") import("//build_overrides/chip.gni") -import("//build_overrides/nlunit_test.gni") +import("//build_overrides/pigweed.gni") import("${chip_root}/build/chip/chip_test_suite.gni") @@ -31,7 +31,7 @@ source_set("helpers") { ] } -chip_test_suite_using_nltest("tests") { +chip_test_suite("tests") { output_name = "libTransportLayerTests" test_sources = [ @@ -59,10 +59,8 @@ chip_test_suite_using_nltest("tests") { "${chip_root}/src/lib/core", "${chip_root}/src/lib/support", "${chip_root}/src/lib/support:testing", - "${chip_root}/src/lib/support:testing_nlunit", "${chip_root}/src/protocols", "${chip_root}/src/transport", "${chip_root}/src/transport/tests:helpers", - "${nlunit_test_root}:nlunit-test", ] } diff --git a/src/transport/tests/TestCryptoContext.cpp b/src/transport/tests/TestCryptoContext.cpp index 9bcf0d25c7cbbb..7a688dbf7f8536 100644 --- a/src/transport/tests/TestCryptoContext.cpp +++ b/src/transport/tests/TestCryptoContext.cpp @@ -16,13 +16,12 @@ * limitations under the License. */ +#include #include -#include #include #include #include -#include #include @@ -48,7 +47,14 @@ struct PrivacyNonceTestEntry thePrivacyNonceTestVector[] = { }, }; -void TestBuildPrivacyNonce(nlTestSuite * apSuite, void * apContext) +class TestGroupCryptoContext : public ::testing::Test +{ +protected: + void SetUp() { ASSERT_EQ(chip::Platform::MemoryInit(), CHIP_NO_ERROR); } + void TearDown() { chip::Platform::MemoryShutdown(); } +}; + +TEST_F(TestGroupCryptoContext, TestBuildPrivacyNonce) { for (const auto & testVector : thePrivacyNonceTestVector) { @@ -60,47 +66,9 @@ void TestBuildPrivacyNonce(nlTestSuite * apSuite, void * apContext) mic.SetTag(nullptr, testVector.mic, MIC_LENGTH); - NL_TEST_ASSERT(apSuite, CHIP_NO_ERROR == chip::CryptoContext::BuildPrivacyNonce(privacyNonce, sessionId, mic)); - NL_TEST_ASSERT(apSuite, 0 == memcmp(privacyNonceView.data(), expectedPrivacyNonce.data(), NONCE_LENGTH)); + EXPECT_EQ(CHIP_NO_ERROR, chip::CryptoContext::BuildPrivacyNonce(privacyNonce, sessionId, mic)); + EXPECT_EQ(0, memcmp(privacyNonceView.data(), expectedPrivacyNonce.data(), NONCE_LENGTH)); } } -/** - * Test Suite. It lists all the test functions. - */ -const nlTest sTests[] = { NL_TEST_DEF("TestBuildPrivacyNonce", TestBuildPrivacyNonce), NL_TEST_SENTINEL() }; - -/** - * Set up the test suite. - */ -int Test_Setup(void * inContext) -{ - CHIP_ERROR error = chip::Platform::MemoryInit(); - VerifyOrReturnError(error == CHIP_NO_ERROR, FAILURE); - return SUCCESS; -} - -/** - * Tear down the test suite. - */ -int Test_Teardown(void * inContext) -{ - chip::Platform::MemoryShutdown(); - return SUCCESS; -} - } // namespace - -/** - * Main - */ -int TestGroupCryptoContext() -{ - nlTestSuite theSuite = { "TestGroupCryptoContext", &sTests[0], Test_Setup, Test_Teardown }; - - // Run test suite againt one context. - nlTestRunner(&theSuite, nullptr); - return nlTestRunnerStats(&theSuite); -} - -CHIP_REGISTER_TEST_SUITE(TestGroupCryptoContext) diff --git a/src/transport/tests/TestGroupMessageCounter.cpp b/src/transport/tests/TestGroupMessageCounter.cpp index 8e3101e482bd70..9ae99dadd1e871 100644 --- a/src/transport/tests/TestGroupMessageCounter.cpp +++ b/src/transport/tests/TestGroupMessageCounter.cpp @@ -23,12 +23,10 @@ #include #include -#include #include #include -#include -#include +#include #include @@ -101,11 +99,11 @@ class TestGroupPeerTable : public chip::Transport::GroupPeerTable } }; -void AddPeerTest(nlTestSuite * inSuite, void * inContext) +TEST(TestGroupMessageCounter, AddPeerTest) { NodeId peerNodeId = 1234; FabricIndex fabricIndex = 1; - uint32_t i = 0; + int i = 0; CHIP_ERROR err = CHIP_NO_ERROR; chip::Transport::PeerMessageCounter * counter = nullptr; chip::Transport::GroupPeerTable mGroupPeerMsgCounter; @@ -117,7 +115,7 @@ void AddPeerTest(nlTestSuite * inSuite, void * inContext) } while (err != CHIP_ERROR_TOO_MANY_PEER_NODES); - NL_TEST_ASSERT(inSuite, i == CHIP_CONFIG_MAX_GROUP_DATA_PEERS + 1); + EXPECT_EQ(i, CHIP_CONFIG_MAX_GROUP_DATA_PEERS + 1); i = 1; do @@ -125,10 +123,10 @@ void AddPeerTest(nlTestSuite * inSuite, void * inContext) err = mGroupPeerMsgCounter.FindOrAddPeer(++fabricIndex, peerNodeId, false, counter); i++; } while (err != CHIP_ERROR_TOO_MANY_PEER_NODES); - NL_TEST_ASSERT(inSuite, i == CHIP_CONFIG_MAX_FABRICS + 1); + EXPECT_EQ(i, CHIP_CONFIG_MAX_FABRICS + 1); } -void RemovePeerTest(nlTestSuite * inSuite, void * inContext) +TEST(TestGroupMessageCounter, RemovePeerTest) { NodeId peerNodeId = 1234; FabricIndex fabricIndex = 1; @@ -147,7 +145,7 @@ void RemovePeerTest(nlTestSuite * inSuite, void * inContext) } // Verify that table is indeed full (for control Peer) err = mGroupPeerMsgCounter.FindOrAddPeer(99, 99, true, counter); - NL_TEST_ASSERT(inSuite, err == CHIP_ERROR_TOO_MANY_PEER_NODES); + EXPECT_EQ(err, CHIP_ERROR_TOO_MANY_PEER_NODES); // Clear all Peer fabricIndex = 1; @@ -157,39 +155,39 @@ void RemovePeerTest(nlTestSuite * inSuite, void * inContext) for (uint32_t peerId = 0; peerId < CHIP_CONFIG_MAX_GROUP_CONTROL_PEERS; peerId++) { err = mGroupPeerMsgCounter.RemovePeer(fabricIndex, peerNodeId++, true); - NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR); + EXPECT_EQ(err, CHIP_NO_ERROR); } fabricIndex++; } // Try re-adding the previous peer without any error err = mGroupPeerMsgCounter.FindOrAddPeer(99, 99, true, counter); - NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR); + EXPECT_EQ(err, CHIP_NO_ERROR); err = mGroupPeerMsgCounter.FindOrAddPeer(104, 99, true, counter); - NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR); + EXPECT_EQ(err, CHIP_NO_ERROR); err = mGroupPeerMsgCounter.FindOrAddPeer(105, 99, true, counter); - NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR); + EXPECT_EQ(err, CHIP_NO_ERROR); err = mGroupPeerMsgCounter.FindOrAddPeer(106, 99, true, counter); - NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR); + EXPECT_EQ(err, CHIP_NO_ERROR); // Fabric removal test err = mGroupPeerMsgCounter.FabricRemoved(123); - NL_TEST_ASSERT(inSuite, err == CHIP_ERROR_NOT_FOUND); + EXPECT_EQ(err, CHIP_ERROR_NOT_FOUND); err = mGroupPeerMsgCounter.FabricRemoved(99); - NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR); + EXPECT_EQ(err, CHIP_NO_ERROR); err = mGroupPeerMsgCounter.FabricRemoved(99); - NL_TEST_ASSERT(inSuite, err == CHIP_ERROR_NOT_FOUND); + EXPECT_EQ(err, CHIP_ERROR_NOT_FOUND); // Verify that the Fabric List was compacted. - NL_TEST_ASSERT(inSuite, 106 == mGroupPeerMsgCounter.GetFabricIndexAt(0)); + EXPECT_EQ(106, mGroupPeerMsgCounter.GetFabricIndexAt(0)); } -void PeerRetrievalTest(nlTestSuite * inSuite, void * inContext) +TEST(TestGroupMessageCounter, PeerRetrievalTest) { NodeId peerNodeId = 1234; FabricIndex fabricIndex = 1; @@ -199,120 +197,120 @@ void PeerRetrievalTest(nlTestSuite * inSuite, void * inContext) chip::Transport::GroupPeerTable mGroupPeerMsgCounter; err = mGroupPeerMsgCounter.FindOrAddPeer(fabricIndex, peerNodeId, true, counter); - NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR); - NL_TEST_ASSERT(inSuite, counter != nullptr); + EXPECT_EQ(err, CHIP_NO_ERROR); + EXPECT_NE(counter, nullptr); err = mGroupPeerMsgCounter.FindOrAddPeer(99, 99, true, counter2); - NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR); - NL_TEST_ASSERT(inSuite, counter2 != nullptr); - NL_TEST_ASSERT(inSuite, counter2 != counter); + EXPECT_EQ(err, CHIP_NO_ERROR); + EXPECT_NE(counter2, nullptr); + EXPECT_NE(counter2, counter); err = mGroupPeerMsgCounter.FindOrAddPeer(fabricIndex, peerNodeId, true, counter2); - NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR); - NL_TEST_ASSERT(inSuite, counter2 == counter); + EXPECT_EQ(err, CHIP_NO_ERROR); + EXPECT_EQ(counter2, counter); } -void CounterCommitRolloverTest(nlTestSuite * inSuite, void * inContext) +TEST(TestGroupMessageCounter, CounterCommitRolloverTest) { CHIP_ERROR err = CHIP_NO_ERROR; chip::Transport::PeerMessageCounter * counter = nullptr; chip::Transport::GroupPeerTable mGroupPeerMsgCounter; err = mGroupPeerMsgCounter.FindOrAddPeer(99, 99, true, counter); - NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR); - NL_TEST_ASSERT(inSuite, counter != nullptr); + EXPECT_EQ(err, CHIP_NO_ERROR); + EXPECT_NE(counter, nullptr); err = counter->VerifyOrTrustFirstGroup(UINT32_MAX); - NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR); + EXPECT_EQ(err, CHIP_NO_ERROR); counter->CommitGroup(UINT32_MAX); err = counter->VerifyOrTrustFirstGroup(0); - NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR); + EXPECT_EQ(err, CHIP_NO_ERROR); counter->CommitGroup(0); err = counter->VerifyOrTrustFirstGroup(1); - NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR); + EXPECT_EQ(err, CHIP_NO_ERROR); counter->CommitGroup(1); } -void CounterTrustFirstTest(nlTestSuite * inSuite, void * inContext) +TEST(TestGroupMessageCounter, CounterTrustFirstTest) { CHIP_ERROR err = CHIP_NO_ERROR; chip::Transport::PeerMessageCounter * counter = nullptr; chip::Transport::GroupPeerTable mGroupPeerMsgCounter; err = mGroupPeerMsgCounter.FindOrAddPeer(99, 99, true, counter); - NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR); - NL_TEST_ASSERT(inSuite, counter != nullptr); + EXPECT_EQ(err, CHIP_NO_ERROR); + EXPECT_NE(counter, nullptr); err = counter->VerifyOrTrustFirstGroup(5656); - NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR); + EXPECT_EQ(err, CHIP_NO_ERROR); counter->CommitGroup(5656); err = counter->VerifyOrTrustFirstGroup(5756); - NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR); + EXPECT_EQ(err, CHIP_NO_ERROR); counter->CommitGroup(5756); err = counter->VerifyOrTrustFirstGroup(4756); - NL_TEST_ASSERT(inSuite, err != CHIP_NO_ERROR); + EXPECT_NE(err, CHIP_NO_ERROR); // test sequential reception err = counter->VerifyOrTrustFirstGroup(5757); - NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR); + EXPECT_EQ(err, CHIP_NO_ERROR); counter->CommitGroup(5757); err = counter->VerifyOrTrustFirstGroup(5758); - NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR); + EXPECT_EQ(err, CHIP_NO_ERROR); counter->CommitGroup(5758); err = counter->VerifyOrTrustFirstGroup(5756); - NL_TEST_ASSERT(inSuite, err != CHIP_NO_ERROR); + EXPECT_NE(err, CHIP_NO_ERROR); // Test Roll over err = mGroupPeerMsgCounter.FindOrAddPeer(1, 99, true, counter); - NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR); - NL_TEST_ASSERT(inSuite, counter != nullptr); + EXPECT_EQ(err, CHIP_NO_ERROR); + EXPECT_NE(counter, nullptr); err = counter->VerifyOrTrustFirstGroup(UINT32_MAX - 6); - NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR); + EXPECT_EQ(err, CHIP_NO_ERROR); counter->CommitGroup(UINT32_MAX - 6); err = counter->VerifyOrTrustFirstGroup(UINT32_MAX - 1); - NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR); + EXPECT_EQ(err, CHIP_NO_ERROR); counter->CommitGroup(UINT32_MAX - 1); err = counter->VerifyOrTrustFirstGroup(UINT32_MAX); - NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR); + EXPECT_EQ(err, CHIP_NO_ERROR); err = counter->VerifyOrTrustFirstGroup(0); - NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR); + EXPECT_EQ(err, CHIP_NO_ERROR); err = counter->VerifyOrTrustFirstGroup(1); - NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR); + EXPECT_EQ(err, CHIP_NO_ERROR); err = counter->VerifyOrTrustFirstGroup(2); - NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR); + EXPECT_EQ(err, CHIP_NO_ERROR); err = counter->VerifyOrTrustFirstGroup(3); - NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR); + EXPECT_EQ(err, CHIP_NO_ERROR); err = counter->VerifyOrTrustFirstGroup(4); - NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR); + EXPECT_EQ(err, CHIP_NO_ERROR); err = counter->VerifyOrTrustFirstGroup(5); - NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR); + EXPECT_EQ(err, CHIP_NO_ERROR); err = counter->VerifyOrTrustFirstGroup(6); - NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR); + EXPECT_EQ(err, CHIP_NO_ERROR); err = counter->VerifyOrTrustFirstGroup(7); - NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR); + EXPECT_EQ(err, CHIP_NO_ERROR); } -void ReorderPeerRemovalTest(nlTestSuite * inSuite, void * inContext) +TEST(TestGroupMessageCounter, ReorderPeerRemovalTest) { CHIP_ERROR err = CHIP_NO_ERROR; chip::Transport::PeerMessageCounter * counter = nullptr; @@ -322,7 +320,7 @@ void ReorderPeerRemovalTest(nlTestSuite * inSuite, void * inContext) err = mGroupPeerMsgCounter.FindOrAddPeer(1, 2, true, counter); err = mGroupPeerMsgCounter.RemovePeer(1, 1, true); - NL_TEST_ASSERT(inSuite, mGroupPeerMsgCounter.GetNodeIdAt(0, 0, true) == 2); + EXPECT_EQ(mGroupPeerMsgCounter.GetNodeIdAt(0, 0, true), 2u); // with other list err = mGroupPeerMsgCounter.FindOrAddPeer(2, 1, false, counter); @@ -336,19 +334,19 @@ void ReorderPeerRemovalTest(nlTestSuite * inSuite, void * inContext) err = mGroupPeerMsgCounter.FindOrAddPeer(2, 9, false, counter); err = mGroupPeerMsgCounter.RemovePeer(2, 7, false); - NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR); - NL_TEST_ASSERT(inSuite, mGroupPeerMsgCounter.GetNodeIdAt(1, 6, false) == 9); + EXPECT_EQ(err, CHIP_NO_ERROR); + EXPECT_EQ(mGroupPeerMsgCounter.GetNodeIdAt(1, 6, false), 9u); err = mGroupPeerMsgCounter.RemovePeer(2, 4, false); - NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR); - NL_TEST_ASSERT(inSuite, mGroupPeerMsgCounter.GetNodeIdAt(1, 3, false) == 8); + EXPECT_EQ(err, CHIP_NO_ERROR); + EXPECT_EQ(mGroupPeerMsgCounter.GetNodeIdAt(1, 3, false), 8u); err = mGroupPeerMsgCounter.RemovePeer(2, 1, false); - NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR); - NL_TEST_ASSERT(inSuite, mGroupPeerMsgCounter.GetNodeIdAt(1, 0, false) == 9); + EXPECT_EQ(err, CHIP_NO_ERROR); + EXPECT_EQ(mGroupPeerMsgCounter.GetNodeIdAt(1, 0, false), 9u); } -void ReorderFabricRemovalTest(nlTestSuite * inSuite, void * inContext) +TEST(TestGroupMessageCounter, ReorderFabricRemovalTest) { CHIP_ERROR err = CHIP_NO_ERROR; chip::Transport::PeerMessageCounter * counter = nullptr; @@ -357,49 +355,49 @@ void ReorderFabricRemovalTest(nlTestSuite * inSuite, void * inContext) for (uint8_t i = 0; i < CHIP_CONFIG_MAX_FABRICS; i++) { err = mGroupPeerMsgCounter.FindOrAddPeer(static_cast(i + 1), 1, false, counter); - NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR); + EXPECT_EQ(err, CHIP_NO_ERROR); } // Try removing last Fabric first err = counter->VerifyOrTrustFirstGroup(1234); - NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR); + EXPECT_EQ(err, CHIP_NO_ERROR); counter->CommitGroup(1234); err = mGroupPeerMsgCounter.FabricRemoved(CHIP_CONFIG_MAX_FABRICS); - NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR); - NL_TEST_ASSERT(inSuite, mGroupPeerMsgCounter.GetFabricIndexAt(CHIP_CONFIG_MAX_FABRICS - 1) == kUndefinedFabricIndex); + EXPECT_EQ(err, CHIP_NO_ERROR); + EXPECT_EQ(mGroupPeerMsgCounter.GetFabricIndexAt(CHIP_CONFIG_MAX_FABRICS - 1), kUndefinedFabricIndex); err = mGroupPeerMsgCounter.FindOrAddPeer(CHIP_CONFIG_MAX_FABRICS, 1, false, counter); - NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR); + EXPECT_EQ(err, CHIP_NO_ERROR); // Verify that the counter was indeed cleared err = counter->VerifyOrTrustFirstGroup(1234); - NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR); + EXPECT_EQ(err, CHIP_NO_ERROR); // Set a counter that will be moved around err = counter->VerifyOrTrustFirstGroup(5656); - NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR); + EXPECT_EQ(err, CHIP_NO_ERROR); counter->CommitGroup(5656); err = counter->VerifyOrTrustFirstGroup(4756); - NL_TEST_ASSERT(inSuite, err != CHIP_NO_ERROR); + EXPECT_NE(err, CHIP_NO_ERROR); // Per Spec CHIP_CONFIG_MAX_FABRICS can only be as low as 4 err = mGroupPeerMsgCounter.RemovePeer(3, 1, false); - NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR); - NL_TEST_ASSERT(inSuite, mGroupPeerMsgCounter.GetFabricIndexAt(2) == CHIP_CONFIG_MAX_FABRICS); + EXPECT_EQ(err, CHIP_NO_ERROR); + EXPECT_EQ(mGroupPeerMsgCounter.GetFabricIndexAt(2), CHIP_CONFIG_MAX_FABRICS); err = mGroupPeerMsgCounter.RemovePeer(2, 1, false); - NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR); - NL_TEST_ASSERT(inSuite, mGroupPeerMsgCounter.GetFabricIndexAt(1) == CHIP_CONFIG_MAX_FABRICS - 1); + EXPECT_EQ(err, CHIP_NO_ERROR); + EXPECT_EQ(mGroupPeerMsgCounter.GetFabricIndexAt(1), CHIP_CONFIG_MAX_FABRICS - 1); // Validate that counter value were moved around correctly err = mGroupPeerMsgCounter.FindOrAddPeer(CHIP_CONFIG_MAX_FABRICS, 1, false, counter); - NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR); + EXPECT_EQ(err, CHIP_NO_ERROR); err = counter->VerifyOrTrustFirstGroup(4756); - NL_TEST_ASSERT(inSuite, err != CHIP_NO_ERROR); + EXPECT_NE(err, CHIP_NO_ERROR); } -void GroupMessageCounterTest(nlTestSuite * inSuite, void * inContext) +TEST(TestGroupMessageCounter, GroupMessageCounterTest) { chip::TestPersistentStorageDelegate delegate; @@ -407,7 +405,7 @@ void GroupMessageCounterTest(nlTestSuite * inSuite, void * inContext) uint32_t controlCounter = 0, dataCounter = 0; CHIP_ERROR err = groupCientCounter.Init(&delegate); - NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR); + EXPECT_EQ(err, CHIP_NO_ERROR); // Start Test with Control counter // Counter should be random @@ -415,78 +413,45 @@ void GroupMessageCounterTest(nlTestSuite * inSuite, void * inContext) dataCounter = groupCientCounter.GetCounter(false); groupCientCounter.IncrementCounter(true); - NL_TEST_ASSERT(inSuite, (groupCientCounter.GetCounter(true) - controlCounter) == 1); + EXPECT_EQ((groupCientCounter.GetCounter(true) - controlCounter), 1u); groupCientCounter.SetCounter(true, UINT32_MAX - GROUP_MSG_COUNTER_MIN_INCREMENT); - NL_TEST_ASSERT(inSuite, groupCientCounter.GetCounter(true) == UINT32_MAX - GROUP_MSG_COUNTER_MIN_INCREMENT); + EXPECT_EQ(groupCientCounter.GetCounter(true), UINT32_MAX - GROUP_MSG_COUNTER_MIN_INCREMENT); // Test Persistence TestGroupOutgoingCounters groupCientCounter2(&delegate); - NL_TEST_ASSERT(inSuite, groupCientCounter2.GetCounter(true) == UINT32_MAX); - NL_TEST_ASSERT(inSuite, (groupCientCounter2.GetCounter(false) - dataCounter) == GROUP_MSG_COUNTER_MIN_INCREMENT); + EXPECT_EQ(groupCientCounter2.GetCounter(true), UINT32_MAX); + EXPECT_EQ((groupCientCounter2.GetCounter(false) - dataCounter), (uint32_t) GROUP_MSG_COUNTER_MIN_INCREMENT); // Test Roll over groupCientCounter2.IncrementCounter(true); - NL_TEST_ASSERT(inSuite, groupCientCounter2.GetCounter(true) == 0); + EXPECT_EQ(groupCientCounter2.GetCounter(true), 0u); TestGroupOutgoingCounters groupCientCounter3(&delegate); - NL_TEST_ASSERT(inSuite, groupCientCounter3.GetCounter(true) == (UINT32_MAX + GROUP_MSG_COUNTER_MIN_INCREMENT)); + EXPECT_EQ(groupCientCounter3.GetCounter(true), (UINT32_MAX + GROUP_MSG_COUNTER_MIN_INCREMENT)); // Redo the test with the second counter // Start Test with Control counter dataCounter = groupCientCounter.GetCounter(false); groupCientCounter.IncrementCounter(false); - NL_TEST_ASSERT(inSuite, (groupCientCounter.GetCounter(false) - dataCounter) == 1); + EXPECT_EQ((groupCientCounter.GetCounter(false) - dataCounter), 1u); groupCientCounter.SetCounter(false, UINT32_MAX - GROUP_MSG_COUNTER_MIN_INCREMENT); - NL_TEST_ASSERT(inSuite, groupCientCounter.GetCounter(false) == UINT32_MAX - GROUP_MSG_COUNTER_MIN_INCREMENT); + EXPECT_EQ(groupCientCounter.GetCounter(false), UINT32_MAX - GROUP_MSG_COUNTER_MIN_INCREMENT); // Test Persistence TestGroupOutgoingCounters groupCientCounter4(&delegate); - NL_TEST_ASSERT(inSuite, groupCientCounter4.GetCounter(false) == UINT32_MAX); + EXPECT_EQ(groupCientCounter4.GetCounter(false), UINT32_MAX); // Test Roll over groupCientCounter4.IncrementCounter(false); - NL_TEST_ASSERT(inSuite, groupCientCounter4.GetCounter(false) == 0); + EXPECT_EQ(groupCientCounter4.GetCounter(false), 0u); TestGroupOutgoingCounters groupCientCounter5(&delegate); - NL_TEST_ASSERT(inSuite, groupCientCounter5.GetCounter(false) == (UINT32_MAX + GROUP_MSG_COUNTER_MIN_INCREMENT)); + EXPECT_EQ(groupCientCounter5.GetCounter(false), (UINT32_MAX + GROUP_MSG_COUNTER_MIN_INCREMENT)); } } // namespace - -/** - * Test Suite that lists all the test functions. - */ -// clang-format off -const nlTest sTests[] = -{ - NL_TEST_DEF("Add Peer", AddPeerTest), - NL_TEST_DEF("Remove Peer", RemovePeerTest), - NL_TEST_DEF("Peer retrieval", PeerRetrievalTest), - NL_TEST_DEF("Counter Rollover", CounterCommitRolloverTest), - NL_TEST_DEF("Counter Trust first", CounterTrustFirstTest), - NL_TEST_DEF("Reorder Peer removal", ReorderPeerRemovalTest), - NL_TEST_DEF("Reorder Fabric Removal", ReorderFabricRemovalTest), - NL_TEST_DEF("Group Message Counter", GroupMessageCounterTest), - NL_TEST_SENTINEL() -}; -// clang-format on - -/** - * Main - */ -int TestGroupMessageCounter() -{ - // Run test suit against one context - - nlTestSuite theSuite = { "Transport-TestGroupMessageCounter", &sTests[0], nullptr, nullptr }; - nlTestRunner(&theSuite, nullptr); - - return (nlTestRunnerStats(&theSuite)); -} - -CHIP_REGISTER_TEST_SUITE(TestGroupMessageCounter); diff --git a/src/transport/tests/TestPeerConnections.cpp b/src/transport/tests/TestPeerConnections.cpp index f4ea8c40244919..4f7acb147080eb 100644 --- a/src/transport/tests/TestPeerConnections.cpp +++ b/src/transport/tests/TestPeerConnections.cpp @@ -24,10 +24,9 @@ */ #include #include -#include #include -#include +#include namespace { @@ -56,7 +55,14 @@ const FabricIndex kFabricIndex = 8; const CATValues kPeer1CATs = { { 0xABCD0001, 0xABCE0100, 0xABCD0020 } }; const CATValues kPeer2CATs = { { 0xABCD0012, kUndefinedCAT, kUndefinedCAT } }; -void TestBasicFunctionality(nlTestSuite * inSuite, void * inContext) +class TestPeerConnections : public ::testing::Test +{ +protected: + void SetUp() { ASSERT_EQ(chip::Platform::MemoryInit(), CHIP_NO_ERROR); } + void TearDown() { chip::Platform::MemoryShutdown(); } +}; + +TEST_F(TestPeerConnections, TestBasicFunctionality) { SecureSessionTable connections; System::Clock::Internal::MockClock clock; @@ -69,27 +75,27 @@ void TestBasicFunctionality(nlTestSuite * inSuite, void * inContext) // First node, peer session id 1, local session id 2 auto optionalSession = connections.CreateNewSecureSessionForTest(SecureSession::Type::kCASE, 2, kLocalNodeId, kCasePeer1NodeId, kPeer1CATs, 1, kFabricIndex, GetDefaultMRPConfig()); - NL_TEST_ASSERT(inSuite, optionalSession.HasValue()); - NL_TEST_ASSERT(inSuite, optionalSession.Value()->AsSecureSession()->GetSecureSessionType() == SecureSession::Type::kCASE); - NL_TEST_ASSERT(inSuite, optionalSession.Value()->AsSecureSession()->GetPeerNodeId() == kCasePeer1NodeId); - NL_TEST_ASSERT(inSuite, optionalSession.Value()->AsSecureSession()->GetLocalNodeId() == kLocalNodeId); - NL_TEST_ASSERT(inSuite, optionalSession.Value()->GetPeer() == ScopedNodeId(kCasePeer1NodeId, kFabricIndex)); - NL_TEST_ASSERT(inSuite, optionalSession.Value()->GetLocalScopedNodeId() == ScopedNodeId(kLocalNodeId, kFabricIndex)); + EXPECT_TRUE(optionalSession.HasValue()); + EXPECT_EQ(optionalSession.Value()->AsSecureSession()->GetSecureSessionType(), SecureSession::Type::kCASE); + EXPECT_EQ(optionalSession.Value()->AsSecureSession()->GetPeerNodeId(), kCasePeer1NodeId); + EXPECT_EQ(optionalSession.Value()->AsSecureSession()->GetLocalNodeId(), kLocalNodeId); + EXPECT_EQ(optionalSession.Value()->GetPeer(), ScopedNodeId(kCasePeer1NodeId, kFabricIndex)); + EXPECT_EQ(optionalSession.Value()->GetLocalScopedNodeId(), ScopedNodeId(kLocalNodeId, kFabricIndex)); peerCATs = optionalSession.Value()->AsSecureSession()->GetPeerCATs(); - NL_TEST_ASSERT(inSuite, memcmp(&peerCATs, &kPeer1CATs, sizeof(CATValues)) == 0); + EXPECT_EQ(memcmp(&peerCATs, &kPeer1CATs, sizeof(CATValues)), 0); // Second node, peer session id 3, local session id 4 optionalSession = connections.CreateNewSecureSessionForTest(SecureSession::Type::kCASE, 4, kLocalNodeId, kCasePeer2NodeId, kPeer2CATs, 3, kFabricIndex, GetDefaultMRPConfig()); - NL_TEST_ASSERT(inSuite, optionalSession.HasValue()); - NL_TEST_ASSERT(inSuite, optionalSession.Value()->AsSecureSession()->GetSecureSessionType() == SecureSession::Type::kCASE); - NL_TEST_ASSERT(inSuite, optionalSession.Value()->AsSecureSession()->GetPeerNodeId() == kCasePeer2NodeId); - NL_TEST_ASSERT(inSuite, optionalSession.Value()->AsSecureSession()->GetLocalNodeId() == kLocalNodeId); - NL_TEST_ASSERT(inSuite, optionalSession.Value()->GetPeer() == ScopedNodeId(kCasePeer2NodeId, kFabricIndex)); - NL_TEST_ASSERT(inSuite, optionalSession.Value()->GetLocalScopedNodeId() == ScopedNodeId(kLocalNodeId, kFabricIndex)); - NL_TEST_ASSERT(inSuite, optionalSession.Value()->AsSecureSession()->GetLastActivityTime() == 100_ms64); + EXPECT_TRUE(optionalSession.HasValue()); + EXPECT_EQ(optionalSession.Value()->AsSecureSession()->GetSecureSessionType(), SecureSession::Type::kCASE); + EXPECT_EQ(optionalSession.Value()->AsSecureSession()->GetPeerNodeId(), kCasePeer2NodeId); + EXPECT_EQ(optionalSession.Value()->AsSecureSession()->GetLocalNodeId(), kLocalNodeId); + EXPECT_EQ(optionalSession.Value()->GetPeer(), ScopedNodeId(kCasePeer2NodeId, kFabricIndex)); + EXPECT_EQ(optionalSession.Value()->GetLocalScopedNodeId(), ScopedNodeId(kLocalNodeId, kFabricIndex)); + EXPECT_EQ(optionalSession.Value()->AsSecureSession()->GetLastActivityTime(), 100_ms64); peerCATs = optionalSession.Value()->AsSecureSession()->GetPeerCATs(); - NL_TEST_ASSERT(inSuite, memcmp(&peerCATs, &kPeer2CATs, sizeof(CATValues)) == 0); + EXPECT_EQ(memcmp(&peerCATs, &kPeer2CATs, sizeof(CATValues)), 0); // // Fill up the session table. @@ -99,14 +105,14 @@ void TestBasicFunctionality(nlTestSuite * inSuite, void * inContext) sessions[i] = connections.CreateNewSecureSessionForTest( SecureSession::Type::kCASE, static_cast(static_cast(i) + 6u), kLocalNodeId, kCasePeer2NodeId, kPeer2CATs, 3, kFabricIndex, GetDefaultMRPConfig()); - NL_TEST_ASSERT(inSuite, sessions[i].HasValue()); + EXPECT_TRUE(sessions[i].HasValue()); } // #endif System::Clock::Internal::SetSystemClockForTesting(realClock); } -void TestFindByKeyId(nlTestSuite * inSuite, void * inContext) +TEST_F(TestPeerConnections, TestFindByKeyId) { SecureSessionTable connections; System::Clock::Internal::MockClock clock; @@ -116,18 +122,18 @@ void TestFindByKeyId(nlTestSuite * inSuite, void * inContext) // First node, peer session id 1, local session id 2 auto optionalSession = connections.CreateNewSecureSessionForTest(SecureSession::Type::kCASE, 2, kLocalNodeId, kCasePeer1NodeId, kPeer1CATs, 1, kFabricIndex, GetDefaultMRPConfig()); - NL_TEST_ASSERT(inSuite, optionalSession.HasValue()); + EXPECT_TRUE(optionalSession.HasValue()); - NL_TEST_ASSERT(inSuite, !connections.FindSecureSessionByLocalKey(1).HasValue()); - NL_TEST_ASSERT(inSuite, connections.FindSecureSessionByLocalKey(2).HasValue()); + EXPECT_FALSE(connections.FindSecureSessionByLocalKey(1).HasValue()); + EXPECT_TRUE(connections.FindSecureSessionByLocalKey(2).HasValue()); // Second node, peer session id 3, local session id 4 optionalSession = connections.CreateNewSecureSessionForTest(SecureSession::Type::kCASE, 4, kLocalNodeId, kCasePeer2NodeId, kPeer2CATs, 3, kFabricIndex, GetDefaultMRPConfig()); - NL_TEST_ASSERT(inSuite, optionalSession.HasValue()); + EXPECT_TRUE(optionalSession.HasValue()); - NL_TEST_ASSERT(inSuite, !connections.FindSecureSessionByLocalKey(3).HasValue()); - NL_TEST_ASSERT(inSuite, connections.FindSecureSessionByLocalKey(4).HasValue()); + EXPECT_FALSE(connections.FindSecureSessionByLocalKey(3).HasValue()); + EXPECT_TRUE(connections.FindSecureSessionByLocalKey(4).HasValue()); System::Clock::Internal::SetSystemClockForTesting(realClock); } @@ -139,34 +145,4 @@ struct ExpiredCallInfo PeerAddress lastCallPeerAddress = PeerAddress::Uninitialized(); }; -int Initialize(void * apSuite) -{ - VerifyOrReturnError(chip::Platform::MemoryInit() == CHIP_NO_ERROR, FAILURE); - return SUCCESS; -} - -int Finalize(void * aContext) -{ - chip::Platform::MemoryShutdown(); - return SUCCESS; -} - } // namespace - -// clang-format off -static const nlTest sTests[] = -{ - NL_TEST_DEF("BasicFunctionality", TestBasicFunctionality), - NL_TEST_DEF("FindByKeyId", TestFindByKeyId), - NL_TEST_SENTINEL() -}; -// clang-format on - -int TestPeerConnectionsFn() -{ - nlTestSuite theSuite = { "Transport-SecureSessionTable", &sTests[0], Initialize, Finalize }; - nlTestRunner(&theSuite, nullptr); - return nlTestRunnerStats(&theSuite); -} - -CHIP_REGISTER_TEST_SUITE(TestPeerConnectionsFn) diff --git a/src/transport/tests/TestPeerMessageCounter.cpp b/src/transport/tests/TestPeerMessageCounter.cpp index 2c10ce4c8e6a0a..be1a749982ba69 100644 --- a/src/transport/tests/TestPeerMessageCounter.cpp +++ b/src/transport/tests/TestPeerMessageCounter.cpp @@ -21,13 +21,11 @@ * This file implements unit tests for the SessionManager implementation. */ -#include #include #include #include -#include -#include +#include #include namespace { @@ -36,23 +34,23 @@ using namespace chip; static uint32_t counterValuesArray[] = { 0, 10, 0x7FFFFFFF, 0x80000000, 0x80000001, 0x80000002, 0xFFFFFFF0, 0xFFFFFFFF }; -void GroupRollOverTest(nlTestSuite * inSuite, void * inContext) +TEST(TestPeerMessageCounter, GroupRollOverTest) { for (auto n : counterValuesArray) { for (uint32_t k = 1; k <= 2 * CHIP_CONFIG_MESSAGE_COUNTER_WINDOW_SIZE; k++) { chip::Transport::PeerMessageCounter counter; - NL_TEST_ASSERT(inSuite, counter.VerifyOrTrustFirstGroup(n) == CHIP_NO_ERROR); + EXPECT_EQ(counter.VerifyOrTrustFirstGroup(n), CHIP_NO_ERROR); counter.CommitGroup(n); // 1. A counter value of N + k comes in, we detect it as valid and commit it. - NL_TEST_ASSERT(inSuite, counter.VerifyOrTrustFirstGroup(n + k) == CHIP_NO_ERROR); + EXPECT_EQ(counter.VerifyOrTrustFirstGroup(n + k), CHIP_NO_ERROR); counter.CommitGroup(n + k); // 2. A counter value of N comes in, we detect it as duplicate. - NL_TEST_ASSERT(inSuite, counter.VerifyOrTrustFirstGroup(n) == CHIP_ERROR_DUPLICATE_MESSAGE_RECEIVED); + EXPECT_EQ(counter.VerifyOrTrustFirstGroup(n), CHIP_ERROR_DUPLICATE_MESSAGE_RECEIVED); // 3. A counter value between N - CHIP_CONFIG_MESSAGE_COUNTER_WINDOW_SIZE and // N + k - CHIP_CONFIG_MESSAGE_COUNTER_WINDOW_SIZE (but not including @@ -60,47 +58,45 @@ void GroupRollOverTest(nlTestSuite * inSuite, void * inContext) for (uint32_t i = n - CHIP_CONFIG_MESSAGE_COUNTER_WINDOW_SIZE; i != (n + k - CHIP_CONFIG_MESSAGE_COUNTER_WINDOW_SIZE); i++) { - NL_TEST_ASSERT(inSuite, counter.VerifyOrTrustFirstGroup(i) != CHIP_NO_ERROR); + EXPECT_NE(counter.VerifyOrTrustFirstGroup(i), CHIP_NO_ERROR); } // 4. A counter value of N + k - CHIP_CONFIG_MESSAGE_COUNTER_WINDOW_SIZE comes in, is treated as valid. if (k != CHIP_CONFIG_MESSAGE_COUNTER_WINDOW_SIZE) { - NL_TEST_ASSERT(inSuite, - counter.VerifyOrTrustFirstGroup(n + k - CHIP_CONFIG_MESSAGE_COUNTER_WINDOW_SIZE) == CHIP_NO_ERROR); + EXPECT_EQ(counter.VerifyOrTrustFirstGroup(n + k - CHIP_CONFIG_MESSAGE_COUNTER_WINDOW_SIZE), CHIP_NO_ERROR); } else { - NL_TEST_ASSERT(inSuite, - counter.VerifyOrTrustFirstGroup(n + k - CHIP_CONFIG_MESSAGE_COUNTER_WINDOW_SIZE) != CHIP_NO_ERROR); + EXPECT_NE(counter.VerifyOrTrustFirstGroup(n + k - CHIP_CONFIG_MESSAGE_COUNTER_WINDOW_SIZE), CHIP_NO_ERROR); } } } } -void GroupBackTrackTest(nlTestSuite * inSuite, void * inContext) +TEST(TestPeerMessageCounter, GroupBackTrackTest) { for (auto n : counterValuesArray) { chip::Transport::PeerMessageCounter counter; - NL_TEST_ASSERT(inSuite, counter.VerifyOrTrustFirstGroup(n) == CHIP_NO_ERROR); + EXPECT_EQ(counter.VerifyOrTrustFirstGroup(n), CHIP_NO_ERROR); counter.CommitGroup(n); // 1. Some set of values N - k come in, for 0 < k < CHIP_CONFIG_MESSAGE_COUNTER_WINDOW_SIZE. // All of those should be considered valid and committed. for (uint32_t k = 1; k * k < CHIP_CONFIG_MESSAGE_COUNTER_WINDOW_SIZE; k++) { - NL_TEST_ASSERT(inSuite, counter.VerifyOrTrustFirstGroup(n - (k * k)) == CHIP_NO_ERROR); + EXPECT_EQ(counter.VerifyOrTrustFirstGroup(n - (k * k)), CHIP_NO_ERROR); counter.CommitGroup(n - (k * k)); } // 2. Counter value N + 3 comes in - NL_TEST_ASSERT(inSuite, counter.VerifyOrTrustFirstGroup(n + 3) == CHIP_NO_ERROR); + EXPECT_EQ(counter.VerifyOrTrustFirstGroup(n + 3), CHIP_NO_ERROR); counter.CommitGroup(n + 3); // 3. The same set of values N - k come in as in step (1) and are all considered duplicates/out of window. for (uint32_t k = 1; k * k < CHIP_CONFIG_MESSAGE_COUNTER_WINDOW_SIZE; k++) { - NL_TEST_ASSERT(inSuite, counter.VerifyOrTrustFirstGroup(n - (k * k)) != CHIP_NO_ERROR); + EXPECT_NE(counter.VerifyOrTrustFirstGroup(n - (k * k)), CHIP_NO_ERROR); } // 4. The values that were not in the set in step (a) (but are at least N + 3 - CHIP_CONFIG_MESSAGE_COUNTER_WINDOW_SIZE) @@ -111,29 +107,29 @@ void GroupBackTrackTest(nlTestSuite * inSuite, void * inContext) { continue; } - NL_TEST_ASSERT(inSuite, counter.VerifyOrTrustFirstGroup(k) == CHIP_NO_ERROR); + EXPECT_EQ(counter.VerifyOrTrustFirstGroup(k), CHIP_NO_ERROR); counter.CommitGroup(k); } } } -void GroupBigLeapTest(nlTestSuite * inSuite, void * inContext) +TEST(TestPeerMessageCounter, GroupBigLeapTest) { for (auto n : counterValuesArray) { for (uint32_t k = (static_cast(1 << 31) - 5); k <= (static_cast(1 << 31) - 1); k++) { chip::Transport::PeerMessageCounter counter; - NL_TEST_ASSERT(inSuite, counter.VerifyOrTrustFirstGroup(n) == CHIP_NO_ERROR); + EXPECT_EQ(counter.VerifyOrTrustFirstGroup(n), CHIP_NO_ERROR); counter.CommitGroup(n); // 1. A counter value of N + k comes in, we detect it as valid and commit it. - NL_TEST_ASSERT(inSuite, counter.VerifyOrTrustFirstGroup(n + k) == CHIP_NO_ERROR); + EXPECT_EQ(counter.VerifyOrTrustFirstGroup(n + k), CHIP_NO_ERROR); counter.CommitGroup(n + k); // 2. A counter value of N comes in, we detect it as duplicate. - NL_TEST_ASSERT(inSuite, counter.VerifyOrTrustFirstGroup(n) != CHIP_NO_ERROR); + EXPECT_NE(counter.VerifyOrTrustFirstGroup(n), CHIP_NO_ERROR); // 3. A counter value between N and N + k - CHIP_CONFIG_MESSAGE_COUNTER_WINDOW_SIZE // (but not including N + k - CHIP_CONFIG_MESSAGE_COUNTER_WINDOW_SIZE) comes in, we treat it as duplicate. @@ -149,38 +145,37 @@ void GroupBigLeapTest(nlTestSuite * inSuite, void * inContext) testValues.push_back(static_cast(n + k - CHIP_CONFIG_MESSAGE_COUNTER_WINDOW_SIZE - 1)); // Will be inside the valid window of counter + (2^31 -1) - NL_TEST_ASSERT(inSuite, counter.VerifyOrTrustFirstGroup(n - CHIP_CONFIG_MESSAGE_COUNTER_WINDOW_SIZE) == CHIP_NO_ERROR); + EXPECT_EQ(counter.VerifyOrTrustFirstGroup(n - CHIP_CONFIG_MESSAGE_COUNTER_WINDOW_SIZE), CHIP_NO_ERROR); for (auto it : testValues) { - NL_TEST_ASSERT(inSuite, counter.VerifyOrTrustFirstGroup(it) != CHIP_NO_ERROR); + EXPECT_NE(counter.VerifyOrTrustFirstGroup(it), CHIP_NO_ERROR); } // 4. A counter value of N + k - CHIP_CONFIG_MESSAGE_COUNTER_WINDOW_SIZE comes in, is treated as valid. - NL_TEST_ASSERT(inSuite, - counter.VerifyOrTrustFirstGroup(n + k - CHIP_CONFIG_MESSAGE_COUNTER_WINDOW_SIZE) == CHIP_NO_ERROR); + EXPECT_EQ(counter.VerifyOrTrustFirstGroup(n + k - CHIP_CONFIG_MESSAGE_COUNTER_WINDOW_SIZE), CHIP_NO_ERROR); } } } -void GroupOutOfWindow(nlTestSuite * inSuite, void * inContext) +TEST(TestPeerMessageCounter, GroupOutOfWindow) { for (auto n : counterValuesArray) { for (uint32_t k = (static_cast(1 << 31)); k <= (static_cast(1 << 31) + 2); k++) { chip::Transport::PeerMessageCounter counter; - NL_TEST_ASSERT(inSuite, counter.VerifyOrTrustFirstGroup(n) == CHIP_NO_ERROR); + EXPECT_EQ(counter.VerifyOrTrustFirstGroup(n), CHIP_NO_ERROR); counter.CommitGroup(n); // 1. A counter value of N + k comes in, we detect it as duplicate. - NL_TEST_ASSERT(inSuite, counter.VerifyOrTrustFirstGroup(n + k) == CHIP_ERROR_DUPLICATE_MESSAGE_RECEIVED); + EXPECT_EQ(counter.VerifyOrTrustFirstGroup(n + k), CHIP_ERROR_DUPLICATE_MESSAGE_RECEIVED); } } } -void UnicastSmallStepTest(nlTestSuite * inSuite, void * inContext) +TEST(TestPeerMessageCounter, UnicastSmallStepTest) { for (auto n : counterValuesArray) { @@ -201,22 +196,22 @@ void UnicastSmallStepTest(nlTestSuite * inSuite, void * inContext) } // A counter value of N comes in, we detect it as duplicate. - NL_TEST_ASSERT(inSuite, counter.VerifyEncryptedUnicast(n) == CHIP_ERROR_DUPLICATE_MESSAGE_RECEIVED); + EXPECT_EQ(counter.VerifyEncryptedUnicast(n), CHIP_ERROR_DUPLICATE_MESSAGE_RECEIVED); // A counter value of N + k comes in, we detect it as valid only if it would not // overflow, and commit it. if (k > UINT32_MAX - n) { - NL_TEST_ASSERT(inSuite, counter.VerifyEncryptedUnicast(n + k) == CHIP_ERROR_DUPLICATE_MESSAGE_RECEIVED); + EXPECT_EQ(counter.VerifyEncryptedUnicast(n + k), CHIP_ERROR_DUPLICATE_MESSAGE_RECEIVED); // The other tests make no sense if we did not commit N+k as the new max counter. continue; } - NL_TEST_ASSERT(inSuite, counter.VerifyEncryptedUnicast(n + k) == CHIP_NO_ERROR); + EXPECT_EQ(counter.VerifyEncryptedUnicast(n + k), CHIP_NO_ERROR); counter.CommitEncryptedUnicast(n + k); // A counter value of N comes in, we detect it as duplicate. - NL_TEST_ASSERT(inSuite, counter.VerifyEncryptedUnicast(n) == CHIP_ERROR_DUPLICATE_MESSAGE_RECEIVED); + EXPECT_EQ(counter.VerifyEncryptedUnicast(n), CHIP_ERROR_DUPLICATE_MESSAGE_RECEIVED); // A counter value between N - CHIP_CONFIG_MESSAGE_COUNTER_WINDOW_SIZE and // N + k - CHIP_CONFIG_MESSAGE_COUNTER_WINDOW_SIZE (but not including @@ -229,7 +224,7 @@ void UnicastSmallStepTest(nlTestSuite * inSuite, void * inContext) (n + k >= CHIP_CONFIG_MESSAGE_COUNTER_WINDOW_SIZE) ? (n + k - CHIP_CONFIG_MESSAGE_COUNTER_WINDOW_SIZE) : 0; for (uint32_t i = outOfWindowStart; i < outOfWindowEnd; i++) { - NL_TEST_ASSERT(inSuite, counter.VerifyEncryptedUnicast(i) != CHIP_NO_ERROR); + EXPECT_NE(counter.VerifyEncryptedUnicast(i), CHIP_NO_ERROR); } // A counter value of N + k - CHIP_CONFIG_MESSAGE_COUNTER_WINDOW_SIZE (if that does not @@ -239,20 +234,18 @@ void UnicastSmallStepTest(nlTestSuite * inSuite, void * inContext) { if ((k != CHIP_CONFIG_MESSAGE_COUNTER_WINDOW_SIZE) && (n + k != CHIP_CONFIG_MESSAGE_COUNTER_WINDOW_SIZE)) { - NL_TEST_ASSERT( - inSuite, counter.VerifyEncryptedUnicast(n + k - CHIP_CONFIG_MESSAGE_COUNTER_WINDOW_SIZE) == CHIP_NO_ERROR); + EXPECT_EQ(counter.VerifyEncryptedUnicast(n + k - CHIP_CONFIG_MESSAGE_COUNTER_WINDOW_SIZE), CHIP_NO_ERROR); } else { - NL_TEST_ASSERT( - inSuite, counter.VerifyEncryptedUnicast(n + k - CHIP_CONFIG_MESSAGE_COUNTER_WINDOW_SIZE) != CHIP_NO_ERROR); + EXPECT_NE(counter.VerifyEncryptedUnicast(n + k - CHIP_CONFIG_MESSAGE_COUNTER_WINDOW_SIZE), CHIP_NO_ERROR); } } } } } -void UnicastLargeStepTest(nlTestSuite * inSuite, void * inContext) +TEST(TestPeerMessageCounter, UnicastLargeStepTest) { for (auto n : counterValuesArray) { @@ -276,16 +269,16 @@ void UnicastLargeStepTest(nlTestSuite * inSuite, void * inContext) // if it would not overflow, and commit it. if (k > UINT32_MAX - n) { - NL_TEST_ASSERT(inSuite, counter.VerifyEncryptedUnicast(n + k) == CHIP_ERROR_DUPLICATE_MESSAGE_RECEIVED); + EXPECT_EQ(counter.VerifyEncryptedUnicast(n + k), CHIP_ERROR_DUPLICATE_MESSAGE_RECEIVED); // The other tests make no sense if we did not commit N+k as the new max counter. continue; } - NL_TEST_ASSERT(inSuite, counter.VerifyEncryptedUnicast(n + k) == CHIP_NO_ERROR); + EXPECT_EQ(counter.VerifyEncryptedUnicast(n + k), CHIP_NO_ERROR); counter.CommitEncryptedUnicast(n + k); // 2. A counter value of N comes in, we detect it as duplicate. - NL_TEST_ASSERT(inSuite, counter.VerifyEncryptedUnicast(n) != CHIP_NO_ERROR); + EXPECT_NE(counter.VerifyEncryptedUnicast(n), CHIP_NO_ERROR); // 3. A counter value between N and N + k - CHIP_CONFIG_MESSAGE_COUNTER_WINDOW_SIZE // (but not including N + k - CHIP_CONFIG_MESSAGE_COUNTER_WINDOW_SIZE) comes in, we treat it as duplicate. @@ -303,81 +296,77 @@ void UnicastLargeStepTest(nlTestSuite * inSuite, void * inContext) // n - CHIP_CONFIG_MESSAGE_COUNTER_WINDOW_SIZE will be smaller than the current allowed counter values. if (n >= CHIP_CONFIG_MESSAGE_COUNTER_WINDOW_SIZE) { - NL_TEST_ASSERT(inSuite, - counter.VerifyEncryptedUnicast(n - CHIP_CONFIG_MESSAGE_COUNTER_WINDOW_SIZE) != CHIP_NO_ERROR); + EXPECT_NE(counter.VerifyEncryptedUnicast(n - CHIP_CONFIG_MESSAGE_COUNTER_WINDOW_SIZE), CHIP_NO_ERROR); } for (auto it : testValues) { - NL_TEST_ASSERT(inSuite, counter.VerifyEncryptedUnicast(it) != CHIP_NO_ERROR); + EXPECT_NE(counter.VerifyEncryptedUnicast(it), CHIP_NO_ERROR); } // 4. A counter value of N + k - CHIP_CONFIG_MESSAGE_COUNTER_WINDOW_SIZE comes in, is treated as valid. - NL_TEST_ASSERT(inSuite, - counter.VerifyEncryptedUnicast(n + k - CHIP_CONFIG_MESSAGE_COUNTER_WINDOW_SIZE) == CHIP_NO_ERROR); + EXPECT_EQ(counter.VerifyEncryptedUnicast(n + k - CHIP_CONFIG_MESSAGE_COUNTER_WINDOW_SIZE), CHIP_NO_ERROR); } } } -void UnencryptedRollOverTest(nlTestSuite * inSuite, void * inContext) +TEST(TestPeerMessageCounter, UnencryptedRollOverTest) { for (auto n : counterValuesArray) { for (uint32_t k = 1; k <= 2 * CHIP_CONFIG_MESSAGE_COUNTER_WINDOW_SIZE; k++) { chip::Transport::PeerMessageCounter counter; - NL_TEST_ASSERT(inSuite, counter.VerifyUnencrypted(n) == CHIP_NO_ERROR); + EXPECT_EQ(counter.VerifyUnencrypted(n), CHIP_NO_ERROR); counter.CommitUnencrypted(n); // 1. A counter value of N + k comes in, we detect it as valid and commit it. - NL_TEST_ASSERT(inSuite, counter.VerifyUnencrypted(n + k) == CHIP_NO_ERROR); + EXPECT_EQ(counter.VerifyUnencrypted(n + k), CHIP_NO_ERROR); counter.CommitUnencrypted(n + k); // 2. A counter value of N comes in, we detect it as duplicate if // it's in the window. if (k <= CHIP_CONFIG_MESSAGE_COUNTER_WINDOW_SIZE) { - NL_TEST_ASSERT(inSuite, counter.VerifyUnencrypted(n) == CHIP_ERROR_DUPLICATE_MESSAGE_RECEIVED); + EXPECT_EQ(counter.VerifyUnencrypted(n), CHIP_ERROR_DUPLICATE_MESSAGE_RECEIVED); } else { - NL_TEST_ASSERT(inSuite, counter.VerifyUnencrypted(n) == CHIP_NO_ERROR); + EXPECT_EQ(counter.VerifyUnencrypted(n), CHIP_NO_ERROR); // Don't commit here so we change our max counter value. } // 4. A counter value of N + k - CHIP_CONFIG_MESSAGE_COUNTER_WINDOW_SIZE comes in, is treated as valid. if (k != CHIP_CONFIG_MESSAGE_COUNTER_WINDOW_SIZE) { - NL_TEST_ASSERT(inSuite, - counter.VerifyUnencrypted(n + k - CHIP_CONFIG_MESSAGE_COUNTER_WINDOW_SIZE) == CHIP_NO_ERROR); + EXPECT_EQ(counter.VerifyUnencrypted(n + k - CHIP_CONFIG_MESSAGE_COUNTER_WINDOW_SIZE), CHIP_NO_ERROR); } else { - NL_TEST_ASSERT(inSuite, - counter.VerifyUnencrypted(n + k - CHIP_CONFIG_MESSAGE_COUNTER_WINDOW_SIZE) != CHIP_NO_ERROR); + EXPECT_NE(counter.VerifyUnencrypted(n + k - CHIP_CONFIG_MESSAGE_COUNTER_WINDOW_SIZE), CHIP_NO_ERROR); } } } } -void UnencryptedBackTrackTest(nlTestSuite * inSuite, void * inContext) +TEST(TestPeerMessageCounter, UnencryptedBackTrackTest) { for (auto n : counterValuesArray) { chip::Transport::PeerMessageCounter counter; - NL_TEST_ASSERT(inSuite, counter.VerifyUnencrypted(n) == CHIP_NO_ERROR); + EXPECT_EQ(counter.VerifyUnencrypted(n), CHIP_NO_ERROR); counter.CommitUnencrypted(n); // 1. Some set of values N - k come in, for 0 < k < CHIP_CONFIG_MESSAGE_COUNTER_WINDOW_SIZE. // All of those should be considered valid and committed. for (uint32_t k = 1; k * k < CHIP_CONFIG_MESSAGE_COUNTER_WINDOW_SIZE; k++) { - NL_TEST_ASSERT(inSuite, counter.VerifyUnencrypted(n - (k * k)) == CHIP_NO_ERROR); + EXPECT_EQ(counter.VerifyUnencrypted(n - (k * k)), CHIP_NO_ERROR); counter.CommitUnencrypted(n - (k * k)); } // 2. Counter value N + 3 comes in - NL_TEST_ASSERT(inSuite, counter.VerifyUnencrypted(n + 3) == CHIP_NO_ERROR); + EXPECT_EQ(counter.VerifyUnencrypted(n + 3), CHIP_NO_ERROR); counter.CommitUnencrypted(n + 3); // 3. The same set of values N - k come in as in step (1) and are all considered duplicates. @@ -385,7 +374,7 @@ void UnencryptedBackTrackTest(nlTestSuite * inSuite, void * inContext) // are out of window, and 25 is the biggest k*k value we are dealing with. for (uint32_t k = 1; k * k < CHIP_CONFIG_MESSAGE_COUNTER_WINDOW_SIZE; k++) { - NL_TEST_ASSERT(inSuite, counter.VerifyUnencrypted(n - (k * k)) != CHIP_NO_ERROR); + EXPECT_NE(counter.VerifyUnencrypted(n - (k * k)), CHIP_NO_ERROR); } // 4. The values that were not in the set in step (a) (but are at least N + 3 - CHIP_CONFIG_MESSAGE_COUNTER_WINDOW_SIZE) @@ -396,30 +385,30 @@ void UnencryptedBackTrackTest(nlTestSuite * inSuite, void * inContext) { continue; } - NL_TEST_ASSERT(inSuite, counter.VerifyUnencrypted(k) == CHIP_NO_ERROR); + EXPECT_EQ(counter.VerifyUnencrypted(k), CHIP_NO_ERROR); counter.CommitUnencrypted(k); } } } -void UnencryptedBigLeapTest(nlTestSuite * inSuite, void * inContext) +TEST(TestPeerMessageCounter, UnencryptedBigLeapTest) { for (auto n : counterValuesArray) { for (uint32_t k = (static_cast(1 << 31) - 5); k <= (static_cast(1 << 31) - 1); k++) { chip::Transport::PeerMessageCounter counter; - NL_TEST_ASSERT(inSuite, counter.VerifyUnencrypted(n) == CHIP_NO_ERROR); + EXPECT_EQ(counter.VerifyUnencrypted(n), CHIP_NO_ERROR); counter.CommitUnencrypted(n); // 1. A counter value of N + k comes in, we detect it as valid and commit it. - NL_TEST_ASSERT(inSuite, counter.VerifyUnencrypted(n + k) == CHIP_NO_ERROR); + EXPECT_EQ(counter.VerifyUnencrypted(n + k), CHIP_NO_ERROR); counter.CommitUnencrypted(n + k); // 2. A counter value of N comes in, we detect it as valid, since // it's out of window. - NL_TEST_ASSERT(inSuite, counter.VerifyUnencrypted(n) == CHIP_NO_ERROR); + EXPECT_EQ(counter.VerifyUnencrypted(n), CHIP_NO_ERROR); // Don't commit, though. // 3. A counter value between N and N + k - CHIP_CONFIG_MESSAGE_COUNTER_WINDOW_SIZE @@ -437,70 +426,35 @@ void UnencryptedBigLeapTest(nlTestSuite * inSuite, void * inContext) testValues.push_back(static_cast(n + k - CHIP_CONFIG_MESSAGE_COUNTER_WINDOW_SIZE - 1)); // Will be inside the valid window of counter + (2^31 -1) - NL_TEST_ASSERT(inSuite, counter.VerifyUnencrypted(n - CHIP_CONFIG_MESSAGE_COUNTER_WINDOW_SIZE) == CHIP_NO_ERROR); + EXPECT_EQ(counter.VerifyUnencrypted(n - CHIP_CONFIG_MESSAGE_COUNTER_WINDOW_SIZE), CHIP_NO_ERROR); for (auto it : testValues) { - NL_TEST_ASSERT(inSuite, counter.VerifyUnencrypted(it) == CHIP_NO_ERROR); + EXPECT_EQ(counter.VerifyUnencrypted(it), CHIP_NO_ERROR); } // 4. A counter value of N + k - CHIP_CONFIG_MESSAGE_COUNTER_WINDOW_SIZE comes in, is treated as valid. - NL_TEST_ASSERT(inSuite, counter.VerifyUnencrypted(n + k - CHIP_CONFIG_MESSAGE_COUNTER_WINDOW_SIZE) == CHIP_NO_ERROR); + EXPECT_EQ(counter.VerifyUnencrypted(n + k - CHIP_CONFIG_MESSAGE_COUNTER_WINDOW_SIZE), CHIP_NO_ERROR); } } } -void UnencryptedOutOfWindow(nlTestSuite * inSuite, void * inContext) +TEST(TestPeerMessageCounter, UnencryptedOutOfWindow) { for (auto n : counterValuesArray) { for (uint32_t k = (static_cast(1 << 31)); k <= (static_cast(1 << 31) + 2); k++) { chip::Transport::PeerMessageCounter counter; - NL_TEST_ASSERT(inSuite, counter.VerifyUnencrypted(n) == CHIP_NO_ERROR); + EXPECT_EQ(counter.VerifyUnencrypted(n), CHIP_NO_ERROR); counter.CommitUnencrypted(n); // 1. A counter value of N + k comes in, we treat it as valid, since // it's out of window. - NL_TEST_ASSERT(inSuite, counter.VerifyUnencrypted(n + k) == CHIP_NO_ERROR); + EXPECT_EQ(counter.VerifyUnencrypted(n + k), CHIP_NO_ERROR); } } } } // namespace - -/** - * Test Suite that lists all the test functions. - */ -// clang-format off -const nlTest sTests[] = -{ - NL_TEST_DEF("Group Roll over Test", GroupRollOverTest), - NL_TEST_DEF("Group Backtrack Test", GroupBackTrackTest), - NL_TEST_DEF("Group All value test", GroupBigLeapTest), - NL_TEST_DEF("Group Out of Window Test", GroupOutOfWindow), - NL_TEST_DEF("Unicast small step Test", UnicastSmallStepTest), - NL_TEST_DEF("Unicast large step Test", UnicastLargeStepTest), - NL_TEST_DEF("Unencrypted Roll over Test", UnencryptedRollOverTest), - NL_TEST_DEF("Unencrypted Backtrack Test", UnencryptedBackTrackTest), - NL_TEST_DEF("Unencrypted All value test", UnencryptedBigLeapTest), - NL_TEST_DEF("Unencrypted Out of Window Test", UnencryptedOutOfWindow), - NL_TEST_SENTINEL() -}; -// clang-format on - -/** - * Main - */ -int TestPeerMessageCounter() -{ - // Run test suit against one context - - nlTestSuite theSuite = { "Transport-TestPeerMessageCounter", &sTests[0], nullptr, nullptr }; - nlTestRunner(&theSuite, nullptr); - - return (nlTestRunnerStats(&theSuite)); -} - -CHIP_REGISTER_TEST_SUITE(TestPeerMessageCounter); diff --git a/src/transport/tests/TestSecureSession.cpp b/src/transport/tests/TestSecureSession.cpp index 023876c4f7f3c1..de90fe98537505 100644 --- a/src/transport/tests/TestSecureSession.cpp +++ b/src/transport/tests/TestSecureSession.cpp @@ -22,12 +22,11 @@ */ #include -#include +#include #include #include #include -#include #include #include @@ -35,40 +34,39 @@ using namespace chip; using namespace Crypto; -void SecureChannelInitTest(nlTestSuite * inSuite, void * inContext) +TEST(TestSecureSession, SecureChannelInitTest) { Crypto::DefaultSessionKeystore sessionKeystore; CryptoContext channel; P256Keypair keypair; - NL_TEST_ASSERT(inSuite, keypair.Initialize(ECPKeyTarget::ECDH) == CHIP_NO_ERROR); + EXPECT_EQ(keypair.Initialize(ECPKeyTarget::ECDH), CHIP_NO_ERROR); P256Keypair keypair2; - NL_TEST_ASSERT(inSuite, keypair2.Initialize(ECPKeyTarget::ECDH) == CHIP_NO_ERROR); + EXPECT_EQ(keypair2.Initialize(ECPKeyTarget::ECDH), CHIP_NO_ERROR); // Test the channel is successfully created with valid parameters - NL_TEST_ASSERT(inSuite, - channel.InitFromKeyPair(sessionKeystore, keypair, keypair2.Pubkey(), ByteSpan(), - CryptoContext::SessionInfoType::kSessionEstablishment, - CryptoContext::SessionRole::kInitiator) == CHIP_NO_ERROR); + EXPECT_EQ(channel.InitFromKeyPair(sessionKeystore, keypair, keypair2.Pubkey(), ByteSpan(), + CryptoContext::SessionInfoType::kSessionEstablishment, + CryptoContext::SessionRole::kInitiator), + CHIP_NO_ERROR); // Test the channel cannot be reinitialized - NL_TEST_ASSERT(inSuite, - channel.InitFromKeyPair(sessionKeystore, keypair, keypair2.Pubkey(), ByteSpan(), - CryptoContext::SessionInfoType::kSessionEstablishment, - CryptoContext::SessionRole::kInitiator) == CHIP_ERROR_INCORRECT_STATE); + EXPECT_EQ(channel.InitFromKeyPair(sessionKeystore, keypair, keypair2.Pubkey(), ByteSpan(), + CryptoContext::SessionInfoType::kSessionEstablishment, + CryptoContext::SessionRole::kInitiator), + CHIP_ERROR_INCORRECT_STATE); // Test the channel can be initialized with valid salt const char * salt = "Test Salt"; CryptoContext channel2; - NL_TEST_ASSERT(inSuite, - channel2.InitFromKeyPair(sessionKeystore, keypair, keypair2.Pubkey(), - ByteSpan((const uint8_t *) salt, strlen(salt)), - CryptoContext::SessionInfoType::kSessionEstablishment, - CryptoContext::SessionRole::kInitiator) == CHIP_NO_ERROR); + EXPECT_EQ(channel2.InitFromKeyPair(sessionKeystore, keypair, keypair2.Pubkey(), ByteSpan((const uint8_t *) salt, strlen(salt)), + CryptoContext::SessionInfoType::kSessionEstablishment, + CryptoContext::SessionRole::kInitiator), + CHIP_NO_ERROR); } -void SecureChannelEncryptTest(nlTestSuite * inSuite, void * inContext) +TEST(TestSecureSession, SecureChannelEncryptTest) { Crypto::DefaultSessionKeystore sessionKeystore; CryptoContext channel; @@ -78,41 +76,38 @@ void SecureChannelEncryptTest(nlTestSuite * inSuite, void * inContext) MessageAuthenticationCode mac; packetHeader.SetSessionId(1); - NL_TEST_ASSERT(inSuite, packetHeader.IsEncrypted() == true); - NL_TEST_ASSERT(inSuite, packetHeader.MICTagLength() == 16); + EXPECT_TRUE(packetHeader.IsEncrypted()); + EXPECT_EQ(packetHeader.MICTagLength(), 16); CryptoContext::NonceStorage nonce; CryptoContext::BuildNonce(nonce, packetHeader.GetSecurityFlags(), packetHeader.GetMessageCounter(), 0); P256Keypair keypair; - NL_TEST_ASSERT(inSuite, keypair.Initialize(ECPKeyTarget::ECDH) == CHIP_NO_ERROR); + EXPECT_EQ(keypair.Initialize(ECPKeyTarget::ECDH), CHIP_NO_ERROR); P256Keypair keypair2; - NL_TEST_ASSERT(inSuite, keypair2.Initialize(ECPKeyTarget::ECDH) == CHIP_NO_ERROR); + EXPECT_EQ(keypair2.Initialize(ECPKeyTarget::ECDH), CHIP_NO_ERROR); // Test uninitialized channel - NL_TEST_ASSERT(inSuite, - channel.Encrypt(plain_text, sizeof(plain_text), output, nonce, packetHeader, mac) == - CHIP_ERROR_INVALID_USE_OF_SESSION_KEY); + EXPECT_EQ(channel.Encrypt(plain_text, sizeof(plain_text), output, nonce, packetHeader, mac), + CHIP_ERROR_INVALID_USE_OF_SESSION_KEY); const char * salt = "Test Salt"; - NL_TEST_ASSERT(inSuite, - channel.InitFromKeyPair(sessionKeystore, keypair, keypair2.Pubkey(), - ByteSpan((const uint8_t *) salt, strlen(salt)), - CryptoContext::SessionInfoType::kSessionEstablishment, - CryptoContext::SessionRole::kInitiator) == CHIP_NO_ERROR); + EXPECT_EQ(channel.InitFromKeyPair(sessionKeystore, keypair, keypair2.Pubkey(), ByteSpan((const uint8_t *) salt, strlen(salt)), + CryptoContext::SessionInfoType::kSessionEstablishment, + CryptoContext::SessionRole::kInitiator), + CHIP_NO_ERROR); // Test initialized channel, but invalid arguments - NL_TEST_ASSERT(inSuite, channel.Encrypt(nullptr, 0, nullptr, nonce, packetHeader, mac) == CHIP_ERROR_INVALID_ARGUMENT); - NL_TEST_ASSERT(inSuite, channel.Encrypt(plain_text, 0, nullptr, nonce, packetHeader, mac) == CHIP_ERROR_INVALID_ARGUMENT); - NL_TEST_ASSERT( - inSuite, channel.Encrypt(plain_text, sizeof(plain_text), nullptr, nonce, packetHeader, mac) == CHIP_ERROR_INVALID_ARGUMENT); + EXPECT_EQ(channel.Encrypt(nullptr, 0, nullptr, nonce, packetHeader, mac), CHIP_ERROR_INVALID_ARGUMENT); + EXPECT_EQ(channel.Encrypt(plain_text, 0, nullptr, nonce, packetHeader, mac), CHIP_ERROR_INVALID_ARGUMENT); + EXPECT_EQ(channel.Encrypt(plain_text, sizeof(plain_text), nullptr, nonce, packetHeader, mac), CHIP_ERROR_INVALID_ARGUMENT); // Valid arguments - NL_TEST_ASSERT(inSuite, channel.Encrypt(plain_text, sizeof(plain_text), output, nonce, packetHeader, mac) == CHIP_NO_ERROR); + EXPECT_EQ(channel.Encrypt(plain_text, sizeof(plain_text), output, nonce, packetHeader, mac), CHIP_NO_ERROR); } -void SecureChannelDecryptTest(nlTestSuite * inSuite, void * inContext) +TEST(TestSecureSession, SecureChannelDecryptTest) { Crypto::DefaultSessionKeystore sessionKeystore; CryptoContext channel; @@ -122,8 +117,8 @@ void SecureChannelDecryptTest(nlTestSuite * inSuite, void * inContext) MessageAuthenticationCode mac; packetHeader.SetSessionId(1); - NL_TEST_ASSERT(inSuite, packetHeader.IsEncrypted() == true); - NL_TEST_ASSERT(inSuite, packetHeader.MICTagLength() == 16); + EXPECT_TRUE(packetHeader.IsEncrypted()); + EXPECT_EQ(packetHeader.MICTagLength(), 16); CryptoContext::NonceStorage nonce; CryptoContext::BuildNonce(nonce, packetHeader.GetSecurityFlags(), packetHeader.GetMessageCounter(), 0); @@ -131,77 +126,34 @@ void SecureChannelDecryptTest(nlTestSuite * inSuite, void * inContext) const char * salt = "Test Salt"; P256Keypair keypair; - NL_TEST_ASSERT(inSuite, keypair.Initialize(ECPKeyTarget::ECDH) == CHIP_NO_ERROR); + EXPECT_EQ(keypair.Initialize(ECPKeyTarget::ECDH), CHIP_NO_ERROR); P256Keypair keypair2; - NL_TEST_ASSERT(inSuite, keypair2.Initialize(ECPKeyTarget::ECDH) == CHIP_NO_ERROR); + EXPECT_EQ(keypair2.Initialize(ECPKeyTarget::ECDH), CHIP_NO_ERROR); - NL_TEST_ASSERT(inSuite, - channel.InitFromKeyPair(sessionKeystore, keypair, keypair2.Pubkey(), - ByteSpan((const uint8_t *) salt, strlen(salt)), - CryptoContext::SessionInfoType::kSessionEstablishment, - CryptoContext::SessionRole::kInitiator) == CHIP_NO_ERROR); - NL_TEST_ASSERT(inSuite, channel.Encrypt(plain_text, sizeof(plain_text), encrypted, nonce, packetHeader, mac) == CHIP_NO_ERROR); + EXPECT_EQ(channel.InitFromKeyPair(sessionKeystore, keypair, keypair2.Pubkey(), ByteSpan((const uint8_t *) salt, strlen(salt)), + CryptoContext::SessionInfoType::kSessionEstablishment, + CryptoContext::SessionRole::kInitiator), + CHIP_NO_ERROR); + EXPECT_EQ(channel.Encrypt(plain_text, sizeof(plain_text), encrypted, nonce, packetHeader, mac), CHIP_NO_ERROR); CryptoContext channel2; uint8_t output[128]; // Uninitialized channel - NL_TEST_ASSERT(inSuite, - channel2.Decrypt(encrypted, sizeof(plain_text), output, nonce, packetHeader, mac) == - CHIP_ERROR_INVALID_USE_OF_SESSION_KEY); - NL_TEST_ASSERT(inSuite, - channel2.InitFromKeyPair(sessionKeystore, keypair2, keypair.Pubkey(), - ByteSpan((const uint8_t *) salt, strlen(salt)), - CryptoContext::SessionInfoType::kSessionEstablishment, - CryptoContext::SessionRole::kResponder) == CHIP_NO_ERROR); + EXPECT_EQ(channel2.Decrypt(encrypted, sizeof(plain_text), output, nonce, packetHeader, mac), + CHIP_ERROR_INVALID_USE_OF_SESSION_KEY); + EXPECT_EQ(channel2.InitFromKeyPair(sessionKeystore, keypair2, keypair.Pubkey(), ByteSpan((const uint8_t *) salt, strlen(salt)), + CryptoContext::SessionInfoType::kSessionEstablishment, + CryptoContext::SessionRole::kResponder), + CHIP_NO_ERROR); // Channel initialized, but invalid arguments to decrypt - NL_TEST_ASSERT(inSuite, channel2.Decrypt(nullptr, 0, nullptr, nonce, packetHeader, mac) == CHIP_ERROR_INVALID_ARGUMENT); - NL_TEST_ASSERT(inSuite, channel2.Decrypt(encrypted, 0, nullptr, nonce, packetHeader, mac) == CHIP_ERROR_INVALID_ARGUMENT); - NL_TEST_ASSERT( - inSuite, channel2.Decrypt(encrypted, sizeof(encrypted), nullptr, nonce, packetHeader, mac) == CHIP_ERROR_INVALID_ARGUMENT); + EXPECT_EQ(channel2.Decrypt(nullptr, 0, nullptr, nonce, packetHeader, mac), CHIP_ERROR_INVALID_ARGUMENT); + EXPECT_EQ(channel2.Decrypt(encrypted, 0, nullptr, nonce, packetHeader, mac), CHIP_ERROR_INVALID_ARGUMENT); + EXPECT_EQ(channel2.Decrypt(encrypted, sizeof(encrypted), nullptr, nonce, packetHeader, mac), CHIP_ERROR_INVALID_ARGUMENT); // Valid arguments - NL_TEST_ASSERT(inSuite, channel2.Decrypt(encrypted, sizeof(plain_text), output, nonce, packetHeader, mac) == CHIP_NO_ERROR); + EXPECT_EQ(channel2.Decrypt(encrypted, sizeof(plain_text), output, nonce, packetHeader, mac), CHIP_NO_ERROR); - NL_TEST_ASSERT(inSuite, memcmp(plain_text, output, sizeof(plain_text)) == 0); + EXPECT_EQ(memcmp(plain_text, output, sizeof(plain_text)), 0); } - -// Test Suite - -/** - * Test Suite that lists all the test functions. - */ -// clang-format off -static const nlTest sTests[] = -{ - NL_TEST_DEF("Init", SecureChannelInitTest), - NL_TEST_DEF("Encrypt", SecureChannelEncryptTest), - NL_TEST_DEF("Decrypt", SecureChannelDecryptTest), - - NL_TEST_SENTINEL() -}; -// clang-format on - -// clang-format off -static nlTestSuite sSuite = -{ - "Test-CHIP-CryptoContext", - &sTests[0], - nullptr, - nullptr -}; -// clang-format on - -/** - * Main - */ -int TestSecureSession() -{ - // Run test suit against one context - nlTestRunner(&sSuite, nullptr); - - return (nlTestRunnerStats(&sSuite)); -} - -CHIP_REGISTER_TEST_SUITE(TestSecureSession) diff --git a/src/transport/tests/TestSecureSessionTable.cpp b/src/transport/tests/TestSecureSessionTable.cpp index 7dbbeba654117f..92376d3471e5a7 100644 --- a/src/transport/tests/TestSecureSessionTable.cpp +++ b/src/transport/tests/TestSecureSessionTable.cpp @@ -24,12 +24,10 @@ #include "system/SystemClock.h" #include #include -#include #include #include -#include -#include +#include #include #include @@ -37,15 +35,13 @@ namespace chip { namespace Transport { -class TestSecureSessionTable +class TestSecureSessionTable : public ::testing::Test { public: - // - // This test specifically validates eviction of sessions in the session table - // with various scenarios based on the existing set of sessions in the table - // and a provided session eviction hint - // - static void ValidateSessionSorting(nlTestSuite * inSuite, void * inContext); + static void SetUpTestSuite() { ASSERT_EQ(chip::Platform::MemoryInit(), CHIP_NO_ERROR); } + static void TearDownTestSuite() { chip::Platform::MemoryShutdown(); } + + void ValidateSessionSorting(); private: struct SessionParameters @@ -88,7 +84,6 @@ class TestSecureSessionTable // void CreateSessionTable(std::vector & sessionParams); - nlTestSuite * mTestSuite; Platform::UniquePtr mSessionTable; std::vector> mSessionList; }; @@ -97,8 +92,8 @@ void TestSecureSessionTable::AllocateSession(const ScopedNodeId & sessionEvictio std::vector & sessionParameters, uint16_t evictedSessionIndex) { auto session = mSessionTable->CreateNewSecureSession(SecureSession::Type::kCASE, sessionEvictionHint); - NL_TEST_ASSERT(mTestSuite, session.HasValue()); - NL_TEST_ASSERT(mTestSuite, mSessionList[evictedSessionIndex].get()->mSessionReleased == true); + EXPECT_TRUE(session.HasValue()); + EXPECT_TRUE(mSessionList[evictedSessionIndex].get()->mSessionReleased); } void TestSecureSessionTable::CreateSessionTable(std::vector & sessionParams) @@ -106,7 +101,7 @@ void TestSecureSessionTable::CreateSessionTable(std::vector & mSessionList.clear(); mSessionTable = Platform::MakeUnique(); - NL_TEST_ASSERT(mTestSuite, mSessionTable.get() != nullptr); + EXPECT_NE(mSessionTable.get(), nullptr); mSessionTable->Init(); mSessionTable->SetMaxSessionTableSize(static_cast(sessionParams.size())); @@ -114,7 +109,7 @@ void TestSecureSessionTable::CreateSessionTable(std::vector & for (unsigned int i = 0; i < sessionParams.size(); i++) { auto session = mSessionTable->CreateNewSecureSession(SecureSession::Type::kCASE, ScopedNodeId()); - NL_TEST_ASSERT(mTestSuite, session.HasValue()); + EXPECT_TRUE(session.HasValue()); session.Value()->AsSecureSession()->Activate( ScopedNodeId(1, sessionParams[i].mPeer.GetFabricIndex()), sessionParams[i].mPeer, CATValues(), static_cast(i), @@ -131,11 +126,8 @@ void TestSecureSessionTable::CreateSessionTable(std::vector & } } -void TestSecureSessionTable::ValidateSessionSorting(nlTestSuite * inSuite, void * inContext) +void TestSecureSessionTable::ValidateSessionSorting() { - Platform::UniquePtr & _this = *static_cast *>(inContext); - _this->mTestSuite = inSuite; - // // This validates basic eviction. The table is full of sessions from Fabric1 from the same // Node (2). Eviction should select the oldest session in the table (with timestamp 1) and evict that @@ -152,8 +144,8 @@ void TestSecureSessionTable::ValidateSessionSorting(nlTestSuite * inSuite, void { { 2, kFabric1 }, System::Clock::Timestamp(2), SecureSession::State::kActive }, }; - _this->CreateSessionTable(sessionParamList); - _this->AllocateSession(ScopedNodeId(2, kFabric1), sessionParamList, 4); + CreateSessionTable(sessionParamList); + AllocateSession(ScopedNodeId(2, kFabric1), sessionParamList, 4); } // @@ -174,8 +166,8 @@ void TestSecureSessionTable::ValidateSessionSorting(nlTestSuite * inSuite, void { { 2, kFabric1 }, System::Clock::Timestamp(2), SecureSession::State::kActive }, }; - _this->CreateSessionTable(sessionParamList); - _this->AllocateSession(ScopedNodeId(2, kFabric2), sessionParamList, 4); + CreateSessionTable(sessionParamList); + AllocateSession(ScopedNodeId(2, kFabric2), sessionParamList, 4); } // @@ -200,8 +192,8 @@ void TestSecureSessionTable::ValidateSessionSorting(nlTestSuite * inSuite, void { { 4, kFabric2 }, System::Clock::Timestamp(2), SecureSession::State::kActive }, }; - _this->CreateSessionTable(sessionParamList); - _this->AllocateSession(ScopedNodeId(2, kFabric1), sessionParamList, 1); + CreateSessionTable(sessionParamList); + AllocateSession(ScopedNodeId(2, kFabric1), sessionParamList, 1); } // @@ -226,8 +218,8 @@ void TestSecureSessionTable::ValidateSessionSorting(nlTestSuite * inSuite, void { { 4, kFabric2 }, System::Clock::Timestamp(2), SecureSession::State::kActive }, }; - _this->CreateSessionTable(sessionParamList); - _this->AllocateSession(ScopedNodeId(2, kFabric1), sessionParamList, 3); + CreateSessionTable(sessionParamList); + AllocateSession(ScopedNodeId(2, kFabric1), sessionParamList, 3); } // @@ -252,8 +244,8 @@ void TestSecureSessionTable::ValidateSessionSorting(nlTestSuite * inSuite, void { { 4, kFabric2 }, System::Clock::Timestamp(2), SecureSession::State::kActive }, }; - _this->CreateSessionTable(sessionParamList); - _this->AllocateSession(ScopedNodeId(2, kFabric1), sessionParamList, 4); + CreateSessionTable(sessionParamList); + AllocateSession(ScopedNodeId(2, kFabric1), sessionParamList, 4); } // @@ -275,8 +267,8 @@ void TestSecureSessionTable::ValidateSessionSorting(nlTestSuite * inSuite, void { { 4, kFabric2 }, System::Clock::Timestamp(2), SecureSession::State::kActive }, }; - _this->CreateSessionTable(sessionParamList); - _this->AllocateSession(ScopedNodeId(3, kFabric1), sessionParamList, 2); + CreateSessionTable(sessionParamList); + AllocateSession(ScopedNodeId(3, kFabric1), sessionParamList, 2); } // @@ -303,8 +295,8 @@ void TestSecureSessionTable::ValidateSessionSorting(nlTestSuite * inSuite, void { { 4, kFabric2 }, System::Clock::Timestamp(2), SecureSession::State::kDefunct }, }; - _this->CreateSessionTable(sessionParamList); - _this->AllocateSession(ScopedNodeId(3, kFabric1), sessionParamList, 3); + CreateSessionTable(sessionParamList); + AllocateSession(ScopedNodeId(3, kFabric1), sessionParamList, 3); } // @@ -337,8 +329,8 @@ void TestSecureSessionTable::ValidateSessionSorting(nlTestSuite * inSuite, void { { 4, kFabric2 }, System::Clock::Timestamp(3), SecureSession::State::kActive }, }; - _this->CreateSessionTable(sessionParamList); - _this->AllocateSession(ScopedNodeId(3, kFabric1), sessionParamList, 3); + CreateSessionTable(sessionParamList); + AllocateSession(ScopedNodeId(3, kFabric1), sessionParamList, 3); } // @@ -363,8 +355,8 @@ void TestSecureSessionTable::ValidateSessionSorting(nlTestSuite * inSuite, void { { 4, kFabric2 }, System::Clock::Timestamp(2), SecureSession::State::kActive }, }; - _this->CreateSessionTable(sessionParamList); - _this->AllocateSession(ScopedNodeId(3, kFabric1), sessionParamList, 2); + CreateSessionTable(sessionParamList); + AllocateSession(ScopedNodeId(3, kFabric1), sessionParamList, 2); } // @@ -390,8 +382,8 @@ void TestSecureSessionTable::ValidateSessionSorting(nlTestSuite * inSuite, void { { 4, kFabric2 }, System::Clock::Timestamp(2), SecureSession::State::kActive }, }; - _this->CreateSessionTable(sessionParamList); - _this->AllocateSession(ScopedNodeId(3, kFabric1), sessionParamList, 0); + CreateSessionTable(sessionParamList); + AllocateSession(ScopedNodeId(3, kFabric1), sessionParamList, 0); } // @@ -412,8 +404,8 @@ void TestSecureSessionTable::ValidateSessionSorting(nlTestSuite * inSuite, void { { 4, kFabric2 }, System::Clock::Timestamp(2), SecureSession::State::kActive }, }; - _this->CreateSessionTable(sessionParamList); - _this->AllocateSession(ScopedNodeId(4, kFabric1), sessionParamList, 2); + CreateSessionTable(sessionParamList); + AllocateSession(ScopedNodeId(4, kFabric1), sessionParamList, 2); } // @@ -432,8 +424,8 @@ void TestSecureSessionTable::ValidateSessionSorting(nlTestSuite * inSuite, void { { 4, kFabric2 }, System::Clock::Timestamp(2), SecureSession::State::kActive }, }; - _this->CreateSessionTable(sessionParamList); - _this->AllocateSession(ScopedNodeId(4, kFabric3), sessionParamList, 4); + CreateSessionTable(sessionParamList); + AllocateSession(ScopedNodeId(4, kFabric3), sessionParamList, 4); } // @@ -454,67 +446,19 @@ void TestSecureSessionTable::ValidateSessionSorting(nlTestSuite * inSuite, void { { 4, kFabric2 }, System::Clock::Timestamp(2), SecureSession::State::kActive }, }; - _this->CreateSessionTable(sessionParamList); - _this->AllocateSession(ScopedNodeId(4, kFabric3), sessionParamList, 5); + CreateSessionTable(sessionParamList); + AllocateSession(ScopedNodeId(4, kFabric3), sessionParamList, 5); } } -Platform::UniquePtr gTestSecureSessionTable; - -} // namespace Transport -} // namespace chip - -// Test Suite - -namespace { - -/** - * Test Suite that lists all the test functions. - */ -// clang-format off -const nlTest sTests[] = -{ - NL_TEST_DEF("Validate Session Sorting (Over Minima)", chip::Transport::TestSecureSessionTable::ValidateSessionSorting), - NL_TEST_SENTINEL() -}; -// clang-format on - -int Initialize(void * apSuite) -{ - VerifyOrReturnError(chip::Platform::MemoryInit() == CHIP_NO_ERROR, FAILURE); - chip::Transport::gTestSecureSessionTable = chip::Platform::MakeUnique(); - return SUCCESS; -} - -int Finalize(void * aContext) +TEST_F(TestSecureSessionTable, ValidateSessionSorting) { - chip::Transport::gTestSecureSessionTable.reset(); - chip::Platform::MemoryShutdown(); - return SUCCESS; + // This calls TestSecureSessionTable::ValidateSessionSorting instead of just doing the + // tests directly in here, since the tests reference `SecureSession::State`, which is + // private. Defining the function inside TestSecureSessionTable allows State to be + // accessible since SecureSession contains `friend class TestSecureSessionTable`. + ValidateSessionSorting(); } -// clang-format off -nlTestSuite sSuite = -{ - "TestSecureSessionTable", - &sTests[0], - Initialize, - Finalize -}; -// clang-format on - -} // namespace - -/** - * Main - */ -int SecureSessionTableTest() -{ - // Run test suit against one context - nlTestRunner(&sSuite, &chip::Transport::gTestSecureSessionTable); - - int r = (nlTestRunnerStats(&sSuite)); - return r; -} - -CHIP_REGISTER_TEST_SUITE(SecureSessionTableTest); +} // namespace Transport +} // namespace chip diff --git a/src/transport/tests/TestSessionManager.cpp b/src/transport/tests/TestSessionManager.cpp index 12dc46ae360cc6..b1b6c4620cd86a 100644 --- a/src/transport/tests/TestSessionManager.cpp +++ b/src/transport/tests/TestSessionManager.cpp @@ -31,8 +31,6 @@ #include #include #include -#include -#include #include #include #include @@ -41,8 +39,7 @@ #include #include -#include -#include +#include #include @@ -106,51 +103,50 @@ class TestSessMgrCallback : public SessionMessageDelegate if (LargeMessageSent) { - int compare = memcmp(msgBuf->Start(), LARGE_PAYLOAD, data_len); - NL_TEST_ASSERT(mSuite, compare == 0); + EXPECT_EQ(0, memcmp(msgBuf->Start(), LARGE_PAYLOAD, data_len)); } else { - int compare = memcmp(msgBuf->Start(), PAYLOAD, data_len); - NL_TEST_ASSERT(mSuite, compare == 0); + EXPECT_EQ(0, memcmp(msgBuf->Start(), PAYLOAD, data_len)); } ReceiveHandlerCallCount++; } - nlTestSuite * mSuite = nullptr; int ReceiveHandlerCallCount = 0; bool LargeMessageSent = false; }; -void CheckSimpleInitTest(nlTestSuite * inSuite, void * inContext) +class TestSessionManager : public ::testing::Test, public TestContext { - TestContext & ctx = *reinterpret_cast(inContext); +protected: + void SetUp() { ASSERT_EQ(Init(), CHIP_NO_ERROR); } + void TearDown() { Shutdown(); } +}; +TEST_F(TestSessionManager, CheckSimpleInitTest) +{ FabricTableHolder fabricTableHolder; SessionManager sessionManager; secure_channel::MessageCounterManager gMessageCounterManager; chip::TestPersistentStorageDelegate deviceStorage; chip::Crypto::DefaultSessionKeystore sessionKeystore; - NL_TEST_ASSERT(inSuite, CHIP_NO_ERROR == fabricTableHolder.Init()); - NL_TEST_ASSERT(inSuite, - CHIP_NO_ERROR == - sessionManager.Init(&ctx.GetSystemLayer(), &ctx.GetTransportMgr(), &gMessageCounterManager, &deviceStorage, - &fabricTableHolder.GetFabricTable(), sessionKeystore)); + EXPECT_EQ(CHIP_NO_ERROR, fabricTableHolder.Init()); + EXPECT_EQ(CHIP_NO_ERROR, + sessionManager.Init(&GetSystemLayer(), &GetTransportMgr(), &gMessageCounterManager, &deviceStorage, + &fabricTableHolder.GetFabricTable(), sessionKeystore)); } -void CheckMessageTest(nlTestSuite * inSuite, void * inContext) +TEST_F(TestSessionManager, CheckMessageTest) { - TestContext & ctx = *reinterpret_cast(inContext); - uint16_t payload_len = sizeof(PAYLOAD); TestSessMgrCallback callback; callback.LargeMessageSent = false; chip::System::PacketBufferHandle buffer = chip::MessagePacketBuffer::NewWithData(PAYLOAD, payload_len); - NL_TEST_ASSERT(inSuite, !buffer.IsNull()); + EXPECT_FALSE(buffer.IsNull()); IPAddress addr; IPAddress::FromString("::1", addr); @@ -165,13 +161,10 @@ void CheckMessageTest(nlTestSuite * inSuite, void * inContext) FabricIndex aliceFabricIndex = kUndefinedFabricIndex; FabricIndex bobFabricIndex = kUndefinedFabricIndex; - NL_TEST_ASSERT(inSuite, CHIP_NO_ERROR == fabricTableHolder.Init()); - NL_TEST_ASSERT(inSuite, - CHIP_NO_ERROR == - sessionManager.Init(&ctx.GetSystemLayer(), &ctx.GetTransportMgr(), &gMessageCounterManager, &deviceStorage, - &fabricTableHolder.GetFabricTable(), sessionKeystore)); - - callback.mSuite = inSuite; + EXPECT_EQ(CHIP_NO_ERROR, fabricTableHolder.Init()); + EXPECT_EQ(CHIP_NO_ERROR, + sessionManager.Init(&GetSystemLayer(), &GetTransportMgr(), &gMessageCounterManager, &deviceStorage, + &fabricTableHolder.GetFabricTable(), sessionKeystore)); sessionManager.SetMessageDelegate(&callback); @@ -180,23 +173,23 @@ void CheckMessageTest(nlTestSuite * inSuite, void * inContext) err = fabricTable.AddNewFabricForTestIgnoringCollisions(GetRootACertAsset().mCert, GetIAA1CertAsset().mCert, GetNodeA1CertAsset().mCert, GetNodeA1CertAsset().mKey, &aliceFabricIndex); - NL_TEST_ASSERT(inSuite, CHIP_NO_ERROR == err); + EXPECT_EQ(CHIP_NO_ERROR, err); err = fabricTable.AddNewFabricForTestIgnoringCollisions(GetRootACertAsset().mCert, GetIAA1CertAsset().mCert, GetNodeA2CertAsset().mCert, GetNodeA2CertAsset().mKey, &bobFabricIndex); - NL_TEST_ASSERT(inSuite, CHIP_NO_ERROR == err); + EXPECT_EQ(CHIP_NO_ERROR, err); SessionHolder aliceToBobSession; err = sessionManager.InjectPaseSessionWithTestKey(aliceToBobSession, 2, fabricTable.FindFabricWithIndex(bobFabricIndex)->GetNodeId(), 1, aliceFabricIndex, peer, CryptoContext::SessionRole::kInitiator); - NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR); + EXPECT_EQ(err, CHIP_NO_ERROR); SessionHolder bobToAliceSession; err = sessionManager.InjectPaseSessionWithTestKey(bobToAliceSession, 1, fabricTable.FindFabricWithIndex(aliceFabricIndex)->GetNodeId(), 2, bobFabricIndex, peer, CryptoContext::SessionRole::kResponder); - NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR); + EXPECT_EQ(err, CHIP_NO_ERROR); // Should be able to send a message to itself by just calling send. callback.ReceiveHandlerCallCount = 0; @@ -211,55 +204,53 @@ void CheckMessageTest(nlTestSuite * inSuite, void * inContext) EncryptedPacketBufferHandle preparedMessage; err = sessionManager.PrepareMessage(aliceToBobSession.Get().Value(), payloadHeader, std::move(buffer), preparedMessage); - NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR); + EXPECT_EQ(err, CHIP_NO_ERROR); err = sessionManager.SendPreparedMessage(aliceToBobSession.Get().Value(), preparedMessage); - NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR); + EXPECT_EQ(err, CHIP_NO_ERROR); - ctx.DrainAndServiceIO(); - NL_TEST_ASSERT(inSuite, callback.ReceiveHandlerCallCount == 1); + DrainAndServiceIO(); + EXPECT_EQ(callback.ReceiveHandlerCallCount, 1); // Let's send the max sized message and make sure it is received chip::System::PacketBufferHandle large_buffer = chip::MessagePacketBuffer::NewWithData(LARGE_PAYLOAD, kMaxAppMessageLen); - NL_TEST_ASSERT(inSuite, !large_buffer.IsNull()); + EXPECT_FALSE(large_buffer.IsNull()); callback.LargeMessageSent = true; err = sessionManager.PrepareMessage(aliceToBobSession.Get().Value(), payloadHeader, std::move(large_buffer), preparedMessage); - NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR); + EXPECT_EQ(err, CHIP_NO_ERROR); err = sessionManager.SendPreparedMessage(aliceToBobSession.Get().Value(), preparedMessage); - NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR); + EXPECT_EQ(err, CHIP_NO_ERROR); - ctx.DrainAndServiceIO(); - NL_TEST_ASSERT(inSuite, callback.ReceiveHandlerCallCount == 2); + DrainAndServiceIO(); + EXPECT_EQ(callback.ReceiveHandlerCallCount, 2); uint16_t large_payload_len = sizeof(LARGE_PAYLOAD); // Let's send bigger message than supported and make sure it fails to send chip::System::PacketBufferHandle extra_large_buffer = chip::MessagePacketBuffer::NewWithData(LARGE_PAYLOAD, large_payload_len); - NL_TEST_ASSERT(inSuite, !extra_large_buffer.IsNull()); + EXPECT_FALSE(extra_large_buffer.IsNull()); callback.LargeMessageSent = true; err = sessionManager.PrepareMessage(aliceToBobSession.Get().Value(), payloadHeader, std::move(extra_large_buffer), preparedMessage); - NL_TEST_ASSERT(inSuite, err == CHIP_ERROR_MESSAGE_TOO_LONG); + EXPECT_EQ(err, CHIP_ERROR_MESSAGE_TOO_LONG); sessionManager.Shutdown(); } -void SendEncryptedPacketTest(nlTestSuite * inSuite, void * inContext) +TEST_F(TestSessionManager, SendEncryptedPacketTest) { - TestContext & ctx = *reinterpret_cast(inContext); - uint16_t payload_len = sizeof(PAYLOAD); TestSessMgrCallback callback; callback.LargeMessageSent = false; chip::System::PacketBufferHandle buffer = chip::MessagePacketBuffer::NewWithData(PAYLOAD, payload_len); - NL_TEST_ASSERT(inSuite, !buffer.IsNull()); + EXPECT_FALSE(buffer.IsNull()); IPAddress addr; IPAddress::FromString("::1", addr); @@ -274,13 +265,10 @@ void SendEncryptedPacketTest(nlTestSuite * inSuite, void * inContext) FabricIndex aliceFabricIndex = kUndefinedFabricIndex; FabricIndex bobFabricIndex = kUndefinedFabricIndex; - NL_TEST_ASSERT(inSuite, CHIP_NO_ERROR == fabricTableHolder.Init()); - NL_TEST_ASSERT(inSuite, - CHIP_NO_ERROR == - sessionManager.Init(&ctx.GetSystemLayer(), &ctx.GetTransportMgr(), &gMessageCounterManager, &deviceStorage, - &fabricTableHolder.GetFabricTable(), sessionKeystore)); - - callback.mSuite = inSuite; + EXPECT_EQ(CHIP_NO_ERROR, fabricTableHolder.Init()); + EXPECT_EQ(CHIP_NO_ERROR, + sessionManager.Init(&GetSystemLayer(), &GetTransportMgr(), &gMessageCounterManager, &deviceStorage, + &fabricTableHolder.GetFabricTable(), sessionKeystore)); sessionManager.SetMessageDelegate(&callback); @@ -289,23 +277,23 @@ void SendEncryptedPacketTest(nlTestSuite * inSuite, void * inContext) err = fabricTable.AddNewFabricForTestIgnoringCollisions(GetRootACertAsset().mCert, GetIAA1CertAsset().mCert, GetNodeA1CertAsset().mCert, GetNodeA1CertAsset().mKey, &aliceFabricIndex); - NL_TEST_ASSERT(inSuite, CHIP_NO_ERROR == err); + EXPECT_EQ(CHIP_NO_ERROR, err); err = fabricTable.AddNewFabricForTestIgnoringCollisions(GetRootACertAsset().mCert, GetIAA1CertAsset().mCert, GetNodeA2CertAsset().mCert, GetNodeA2CertAsset().mKey, &bobFabricIndex); - NL_TEST_ASSERT(inSuite, CHIP_NO_ERROR == err); + EXPECT_EQ(CHIP_NO_ERROR, err); SessionHolder aliceToBobSession; err = sessionManager.InjectPaseSessionWithTestKey(aliceToBobSession, 2, fabricTable.FindFabricWithIndex(bobFabricIndex)->GetNodeId(), 1, aliceFabricIndex, peer, CryptoContext::SessionRole::kInitiator); - NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR); + EXPECT_EQ(err, CHIP_NO_ERROR); SessionHolder bobToAliceSession; err = sessionManager.InjectPaseSessionWithTestKey(bobToAliceSession, 1, fabricTable.FindFabricWithIndex(aliceFabricIndex)->GetNodeId(), 2, bobFabricIndex, peer, CryptoContext::SessionRole::kResponder); - NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR); + EXPECT_EQ(err, CHIP_NO_ERROR); // Should be able to send a message to itself by just calling send. callback.ReceiveHandlerCallCount = 0; @@ -322,38 +310,36 @@ void SendEncryptedPacketTest(nlTestSuite * inSuite, void * inContext) payloadHeader.SetInitiator(true); err = sessionManager.PrepareMessage(aliceToBobSession.Get().Value(), payloadHeader, std::move(buffer), preparedMessage); - NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR); + EXPECT_EQ(err, CHIP_NO_ERROR); err = sessionManager.SendPreparedMessage(aliceToBobSession.Get().Value(), preparedMessage); - NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR); + EXPECT_EQ(err, CHIP_NO_ERROR); - ctx.DrainAndServiceIO(); - NL_TEST_ASSERT(inSuite, callback.ReceiveHandlerCallCount == 1); + DrainAndServiceIO(); + EXPECT_EQ(callback.ReceiveHandlerCallCount, 1); // Reset receive side message counter, or duplicated message will be denied. Transport::SecureSession * session = bobToAliceSession.Get().Value()->AsSecureSession(); session->GetSessionMessageCounter().GetPeerMessageCounter().SetCounter(1); err = sessionManager.SendPreparedMessage(aliceToBobSession.Get().Value(), preparedMessage); - NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR); + EXPECT_EQ(err, CHIP_NO_ERROR); - ctx.DrainAndServiceIO(); - NL_TEST_ASSERT(inSuite, callback.ReceiveHandlerCallCount == 2); + DrainAndServiceIO(); + EXPECT_EQ(callback.ReceiveHandlerCallCount, 2); sessionManager.Shutdown(); } -void SendBadEncryptedPacketTest(nlTestSuite * inSuite, void * inContext) +TEST_F(TestSessionManager, SendBadEncryptedPacketTest) { - TestContext & ctx = *reinterpret_cast(inContext); - uint16_t payload_len = sizeof(PAYLOAD); TestSessMgrCallback callback; callback.LargeMessageSent = false; chip::System::PacketBufferHandle buffer = chip::MessagePacketBuffer::NewWithData(PAYLOAD, payload_len); - NL_TEST_ASSERT(inSuite, !buffer.IsNull()); + EXPECT_FALSE(buffer.IsNull()); IPAddress addr; IPAddress::FromString("::1", addr); @@ -368,13 +354,10 @@ void SendBadEncryptedPacketTest(nlTestSuite * inSuite, void * inContext) FabricIndex aliceFabricIndex = kUndefinedFabricIndex; FabricIndex bobFabricIndex = kUndefinedFabricIndex; - NL_TEST_ASSERT(inSuite, CHIP_NO_ERROR == fabricTableHolder.Init()); - NL_TEST_ASSERT(inSuite, - CHIP_NO_ERROR == - sessionManager.Init(&ctx.GetSystemLayer(), &ctx.GetTransportMgr(), &gMessageCounterManager, &deviceStorage, - &fabricTableHolder.GetFabricTable(), sessionKeystore)); - - callback.mSuite = inSuite; + EXPECT_EQ(CHIP_NO_ERROR, fabricTableHolder.Init()); + EXPECT_EQ(CHIP_NO_ERROR, + sessionManager.Init(&GetSystemLayer(), &GetTransportMgr(), &gMessageCounterManager, &deviceStorage, + &fabricTableHolder.GetFabricTable(), sessionKeystore)); sessionManager.SetMessageDelegate(&callback); @@ -383,23 +366,23 @@ void SendBadEncryptedPacketTest(nlTestSuite * inSuite, void * inContext) err = fabricTable.AddNewFabricForTestIgnoringCollisions(GetRootACertAsset().mCert, GetIAA1CertAsset().mCert, GetNodeA1CertAsset().mCert, GetNodeA1CertAsset().mKey, &aliceFabricIndex); - NL_TEST_ASSERT(inSuite, CHIP_NO_ERROR == err); + EXPECT_EQ(CHIP_NO_ERROR, err); err = fabricTable.AddNewFabricForTestIgnoringCollisions(GetRootACertAsset().mCert, GetIAA1CertAsset().mCert, GetNodeA2CertAsset().mCert, GetNodeA2CertAsset().mKey, &bobFabricIndex); - NL_TEST_ASSERT(inSuite, CHIP_NO_ERROR == err); + EXPECT_EQ(CHIP_NO_ERROR, err); SessionHolder aliceToBobSession; err = sessionManager.InjectPaseSessionWithTestKey(aliceToBobSession, 2, fabricTable.FindFabricWithIndex(bobFabricIndex)->GetNodeId(), 1, aliceFabricIndex, peer, CryptoContext::SessionRole::kInitiator); - NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR); + EXPECT_EQ(err, CHIP_NO_ERROR); SessionHolder bobToAliceSession; err = sessionManager.InjectPaseSessionWithTestKey(bobToAliceSession, 1, fabricTable.FindFabricWithIndex(aliceFabricIndex)->GetNodeId(), 2, bobFabricIndex, peer, CryptoContext::SessionRole::kResponder); - NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR); + EXPECT_EQ(err, CHIP_NO_ERROR); // Should be able to send a message to itself by just calling send. callback.ReceiveHandlerCallCount = 0; @@ -416,13 +399,13 @@ void SendBadEncryptedPacketTest(nlTestSuite * inSuite, void * inContext) payloadHeader.SetInitiator(true); err = sessionManager.PrepareMessage(aliceToBobSession.Get().Value(), payloadHeader, std::move(buffer), preparedMessage); - NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR); + EXPECT_EQ(err, CHIP_NO_ERROR); err = sessionManager.SendPreparedMessage(aliceToBobSession.Get().Value(), preparedMessage); - NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR); + EXPECT_EQ(err, CHIP_NO_ERROR); - ctx.DrainAndServiceIO(); - NL_TEST_ASSERT(inSuite, callback.ReceiveHandlerCallCount == 1); + DrainAndServiceIO(); + EXPECT_EQ(callback.ReceiveHandlerCallCount, 1); /* -------------------------------------------------------------------------------------------*/ // Reset receive side message counter, or duplicated message will be denied. @@ -433,59 +416,57 @@ void SendBadEncryptedPacketTest(nlTestSuite * inSuite, void * inContext) // Change Message ID EncryptedPacketBufferHandle badMessageCounterMsg = preparedMessage.CloneData(); - NL_TEST_ASSERT(inSuite, badMessageCounterMsg.ExtractPacketHeader(packetHeader) == CHIP_NO_ERROR); + EXPECT_EQ(badMessageCounterMsg.ExtractPacketHeader(packetHeader), CHIP_NO_ERROR); uint32_t messageCounter = packetHeader.GetMessageCounter(); packetHeader.SetMessageCounter(messageCounter + 1); - NL_TEST_ASSERT(inSuite, badMessageCounterMsg.InsertPacketHeader(packetHeader) == CHIP_NO_ERROR); + EXPECT_EQ(badMessageCounterMsg.InsertPacketHeader(packetHeader), CHIP_NO_ERROR); err = sessionManager.SendPreparedMessage(aliceToBobSession.Get().Value(), badMessageCounterMsg); - NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR); + EXPECT_EQ(err, CHIP_NO_ERROR); - ctx.DrainAndServiceIO(); - NL_TEST_ASSERT(inSuite, callback.ReceiveHandlerCallCount == 1); + DrainAndServiceIO(); + EXPECT_EQ(callback.ReceiveHandlerCallCount, 1); /* -------------------------------------------------------------------------------------------*/ session->GetSessionMessageCounter().GetPeerMessageCounter().SetCounter(1); // Change Key ID EncryptedPacketBufferHandle badKeyIdMsg = preparedMessage.CloneData(); - NL_TEST_ASSERT(inSuite, badKeyIdMsg.ExtractPacketHeader(packetHeader) == CHIP_NO_ERROR); + EXPECT_EQ(badKeyIdMsg.ExtractPacketHeader(packetHeader), CHIP_NO_ERROR); // the secure channel is setup to use key ID 1, and 2. So let's use 3 here. packetHeader.SetSessionId(3); - NL_TEST_ASSERT(inSuite, badKeyIdMsg.InsertPacketHeader(packetHeader) == CHIP_NO_ERROR); + EXPECT_EQ(badKeyIdMsg.InsertPacketHeader(packetHeader), CHIP_NO_ERROR); err = sessionManager.SendPreparedMessage(aliceToBobSession.Get().Value(), badKeyIdMsg); - NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR); + EXPECT_EQ(err, CHIP_NO_ERROR); - ctx.DrainAndServiceIO(); - NL_TEST_ASSERT(inSuite, callback.ReceiveHandlerCallCount == 1); + DrainAndServiceIO(); + EXPECT_EQ(callback.ReceiveHandlerCallCount, 1); /* -------------------------------------------------------------------------------------------*/ session->GetSessionMessageCounter().GetPeerMessageCounter().SetCounter(1); // Send the correct encrypted msg err = sessionManager.SendPreparedMessage(aliceToBobSession.Get().Value(), preparedMessage); - NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR); + EXPECT_EQ(err, CHIP_NO_ERROR); - ctx.DrainAndServiceIO(); - NL_TEST_ASSERT(inSuite, callback.ReceiveHandlerCallCount == 2); + DrainAndServiceIO(); + EXPECT_EQ(callback.ReceiveHandlerCallCount, 2); sessionManager.Shutdown(); } -void SendPacketWithOldCounterTest(nlTestSuite * inSuite, void * inContext) +TEST_F(TestSessionManager, SendPacketWithOldCounterTest) { - TestContext & ctx = *reinterpret_cast(inContext); - uint16_t payload_len = sizeof(PAYLOAD); TestSessMgrCallback callback; callback.LargeMessageSent = false; chip::System::PacketBufferHandle buffer = chip::MessagePacketBuffer::NewWithData(PAYLOAD, payload_len); - NL_TEST_ASSERT(inSuite, !buffer.IsNull()); + EXPECT_FALSE(buffer.IsNull()); IPAddress addr; IPAddress::FromString("::1", addr); @@ -500,13 +481,10 @@ void SendPacketWithOldCounterTest(nlTestSuite * inSuite, void * inContext) FabricIndex aliceFabricIndex = kUndefinedFabricIndex; FabricIndex bobFabricIndex = kUndefinedFabricIndex; - NL_TEST_ASSERT(inSuite, CHIP_NO_ERROR == fabricTableHolder.Init()); - NL_TEST_ASSERT(inSuite, - CHIP_NO_ERROR == - sessionManager.Init(&ctx.GetSystemLayer(), &ctx.GetTransportMgr(), &gMessageCounterManager, &deviceStorage, - &fabricTableHolder.GetFabricTable(), sessionKeystore)); - - callback.mSuite = inSuite; + EXPECT_EQ(CHIP_NO_ERROR, fabricTableHolder.Init()); + EXPECT_EQ(CHIP_NO_ERROR, + sessionManager.Init(&GetSystemLayer(), &GetTransportMgr(), &gMessageCounterManager, &deviceStorage, + &fabricTableHolder.GetFabricTable(), sessionKeystore)); sessionManager.SetMessageDelegate(&callback); @@ -515,23 +493,23 @@ void SendPacketWithOldCounterTest(nlTestSuite * inSuite, void * inContext) err = fabricTable.AddNewFabricForTestIgnoringCollisions(GetRootACertAsset().mCert, GetIAA1CertAsset().mCert, GetNodeA1CertAsset().mCert, GetNodeA1CertAsset().mKey, &aliceFabricIndex); - NL_TEST_ASSERT(inSuite, CHIP_NO_ERROR == err); + EXPECT_EQ(CHIP_NO_ERROR, err); err = fabricTable.AddNewFabricForTestIgnoringCollisions(GetRootACertAsset().mCert, GetIAA1CertAsset().mCert, GetNodeA2CertAsset().mCert, GetNodeA2CertAsset().mKey, &bobFabricIndex); - NL_TEST_ASSERT(inSuite, CHIP_NO_ERROR == err); + EXPECT_EQ(CHIP_NO_ERROR, err); SessionHolder aliceToBobSession; err = sessionManager.InjectPaseSessionWithTestKey(aliceToBobSession, 2, fabricTable.FindFabricWithIndex(bobFabricIndex)->GetNodeId(), 1, aliceFabricIndex, peer, CryptoContext::SessionRole::kInitiator); - NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR); + EXPECT_EQ(err, CHIP_NO_ERROR); SessionHolder bobToAliceSession; err = sessionManager.InjectPaseSessionWithTestKey(bobToAliceSession, 1, fabricTable.FindFabricWithIndex(aliceFabricIndex)->GetNodeId(), 2, bobFabricIndex, peer, CryptoContext::SessionRole::kResponder); - NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR); + EXPECT_EQ(err, CHIP_NO_ERROR); callback.ReceiveHandlerCallCount = 0; @@ -547,53 +525,51 @@ void SendPacketWithOldCounterTest(nlTestSuite * inSuite, void * inContext) payloadHeader.SetInitiator(true); err = sessionManager.PrepareMessage(aliceToBobSession.Get().Value(), payloadHeader, std::move(buffer), preparedMessage); - NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR); + EXPECT_EQ(err, CHIP_NO_ERROR); err = sessionManager.SendPreparedMessage(aliceToBobSession.Get().Value(), preparedMessage); - NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR); + EXPECT_EQ(err, CHIP_NO_ERROR); - ctx.DrainAndServiceIO(); - NL_TEST_ASSERT(inSuite, callback.ReceiveHandlerCallCount == 1); + DrainAndServiceIO(); + EXPECT_EQ(callback.ReceiveHandlerCallCount, 1); // Now advance our message counter by 5. EncryptedPacketBufferHandle newMessage; for (size_t i = 0; i < 5; ++i) { buffer = chip::MessagePacketBuffer::NewWithData(PAYLOAD, payload_len); - NL_TEST_ASSERT(inSuite, !buffer.IsNull()); + EXPECT_FALSE(buffer.IsNull()); err = sessionManager.PrepareMessage(aliceToBobSession.Get().Value(), payloadHeader, std::move(buffer), newMessage); - NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR); + EXPECT_EQ(err, CHIP_NO_ERROR); } err = sessionManager.SendPreparedMessage(aliceToBobSession.Get().Value(), newMessage); - NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR); + EXPECT_EQ(err, CHIP_NO_ERROR); - ctx.DrainAndServiceIO(); - NL_TEST_ASSERT(inSuite, callback.ReceiveHandlerCallCount == 2); + DrainAndServiceIO(); + EXPECT_EQ(callback.ReceiveHandlerCallCount, 2); // Now resend our original message. It should be rejected as a duplicate. err = sessionManager.SendPreparedMessage(aliceToBobSession.Get().Value(), preparedMessage); - NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR); + EXPECT_EQ(err, CHIP_NO_ERROR); - ctx.DrainAndServiceIO(); - NL_TEST_ASSERT(inSuite, callback.ReceiveHandlerCallCount == 2); + DrainAndServiceIO(); + EXPECT_EQ(callback.ReceiveHandlerCallCount, 2); sessionManager.Shutdown(); } -void SendPacketWithTooOldCounterTest(nlTestSuite * inSuite, void * inContext) +TEST_F(TestSessionManager, SendPacketWithTooOldCounterTest) { - TestContext & ctx = *reinterpret_cast(inContext); - uint16_t payload_len = sizeof(PAYLOAD); TestSessMgrCallback callback; callback.LargeMessageSent = false; chip::System::PacketBufferHandle buffer = chip::MessagePacketBuffer::NewWithData(PAYLOAD, payload_len); - NL_TEST_ASSERT(inSuite, !buffer.IsNull()); + EXPECT_FALSE(buffer.IsNull()); IPAddress addr; IPAddress::FromString("::1", addr); @@ -608,13 +584,10 @@ void SendPacketWithTooOldCounterTest(nlTestSuite * inSuite, void * inContext) FabricIndex aliceFabricIndex = kUndefinedFabricIndex; FabricIndex bobFabricIndex = kUndefinedFabricIndex; - NL_TEST_ASSERT(inSuite, CHIP_NO_ERROR == fabricTableHolder.Init()); - NL_TEST_ASSERT(inSuite, - CHIP_NO_ERROR == - sessionManager.Init(&ctx.GetSystemLayer(), &ctx.GetTransportMgr(), &gMessageCounterManager, &deviceStorage, - &fabricTableHolder.GetFabricTable(), sessionKeystore)); - callback.mSuite = inSuite; - + EXPECT_EQ(CHIP_NO_ERROR, fabricTableHolder.Init()); + EXPECT_EQ(CHIP_NO_ERROR, + sessionManager.Init(&GetSystemLayer(), &GetTransportMgr(), &gMessageCounterManager, &deviceStorage, + &fabricTableHolder.GetFabricTable(), sessionKeystore)); sessionManager.SetMessageDelegate(&callback); Transport::PeerAddress peer(Transport::PeerAddress::UDP(addr, CHIP_PORT)); @@ -622,23 +595,23 @@ void SendPacketWithTooOldCounterTest(nlTestSuite * inSuite, void * inContext) err = fabricTable.AddNewFabricForTestIgnoringCollisions(GetRootACertAsset().mCert, GetIAA1CertAsset().mCert, GetNodeA1CertAsset().mCert, GetNodeA1CertAsset().mKey, &aliceFabricIndex); - NL_TEST_ASSERT(inSuite, CHIP_NO_ERROR == err); + EXPECT_EQ(CHIP_NO_ERROR, err); err = fabricTable.AddNewFabricForTestIgnoringCollisions(GetRootACertAsset().mCert, GetIAA1CertAsset().mCert, GetNodeA2CertAsset().mCert, GetNodeA2CertAsset().mKey, &bobFabricIndex); - NL_TEST_ASSERT(inSuite, CHIP_NO_ERROR == err); + EXPECT_EQ(CHIP_NO_ERROR, err); SessionHolder aliceToBobSession; err = sessionManager.InjectPaseSessionWithTestKey(aliceToBobSession, 2, fabricTable.FindFabricWithIndex(bobFabricIndex)->GetNodeId(), 1, aliceFabricIndex, peer, CryptoContext::SessionRole::kInitiator); - NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR); + EXPECT_EQ(err, CHIP_NO_ERROR); SessionHolder bobToAliceSession; err = sessionManager.InjectPaseSessionWithTestKey(bobToAliceSession, 1, fabricTable.FindFabricWithIndex(aliceFabricIndex)->GetNodeId(), 2, bobFabricIndex, peer, CryptoContext::SessionRole::kResponder); - NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR); + EXPECT_EQ(err, CHIP_NO_ERROR); callback.ReceiveHandlerCallCount = 0; @@ -654,13 +627,13 @@ void SendPacketWithTooOldCounterTest(nlTestSuite * inSuite, void * inContext) payloadHeader.SetInitiator(true); err = sessionManager.PrepareMessage(aliceToBobSession.Get().Value(), payloadHeader, std::move(buffer), preparedMessage); - NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR); + EXPECT_EQ(err, CHIP_NO_ERROR); err = sessionManager.SendPreparedMessage(aliceToBobSession.Get().Value(), preparedMessage); - NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR); + EXPECT_EQ(err, CHIP_NO_ERROR); - ctx.DrainAndServiceIO(); - NL_TEST_ASSERT(inSuite, callback.ReceiveHandlerCallCount == 1); + DrainAndServiceIO(); + EXPECT_EQ(callback.ReceiveHandlerCallCount, 1); // Now advance our message counter by at least // CHIP_CONFIG_MESSAGE_COUNTER_WINDOW_SIZE + 2, so preparedMessage will be @@ -669,30 +642,30 @@ void SendPacketWithTooOldCounterTest(nlTestSuite * inSuite, void * inContext) for (size_t i = 0; i < CHIP_CONFIG_MESSAGE_COUNTER_WINDOW_SIZE + 2; ++i) { buffer = chip::MessagePacketBuffer::NewWithData(PAYLOAD, payload_len); - NL_TEST_ASSERT(inSuite, !buffer.IsNull()); + EXPECT_FALSE(buffer.IsNull()); err = sessionManager.PrepareMessage(aliceToBobSession.Get().Value(), payloadHeader, std::move(buffer), newMessage); - NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR); + EXPECT_EQ(err, CHIP_NO_ERROR); } err = sessionManager.SendPreparedMessage(aliceToBobSession.Get().Value(), newMessage); - NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR); + EXPECT_EQ(err, CHIP_NO_ERROR); - ctx.DrainAndServiceIO(); - NL_TEST_ASSERT(inSuite, callback.ReceiveHandlerCallCount == 2); + DrainAndServiceIO(); + EXPECT_EQ(callback.ReceiveHandlerCallCount, 2); // Now resend our original message. It should be rejected as a duplicate. err = sessionManager.SendPreparedMessage(aliceToBobSession.Get().Value(), preparedMessage); - NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR); + EXPECT_EQ(err, CHIP_NO_ERROR); - ctx.DrainAndServiceIO(); - NL_TEST_ASSERT(inSuite, callback.ReceiveHandlerCallCount == 2); + DrainAndServiceIO(); + EXPECT_EQ(callback.ReceiveHandlerCallCount, 2); sessionManager.Shutdown(); } -static void RandomSessionIdAllocatorOffset(nlTestSuite * inSuite, SessionManager & sessionManager, int max) +static void RandomSessionIdAllocatorOffset(SessionManager & sessionManager, int max) { // Allocate + free a pseudo-random number of sessions to create a // pseudo-random offset in mNextSessionId. @@ -702,27 +675,24 @@ static void RandomSessionIdAllocatorOffset(nlTestSuite * inSuite, SessionManager auto handle = sessionManager.AllocateSession( Transport::SecureSession::Type::kPASE, ScopedNodeId(NodeIdFromPAKEKeyId(kDefaultCommissioningPasscodeId), kUndefinedFabricIndex)); - NL_TEST_ASSERT(inSuite, handle.HasValue()); + EXPECT_TRUE(handle.HasValue()); handle.Value()->AsSecureSession()->MarkForEviction(); } } -void SessionAllocationTest(nlTestSuite * inSuite, void * inContext) +TEST_F(TestSessionManager, SessionAllocationTest) { - TestContext & ctx = *reinterpret_cast(inContext); - FabricTableHolder fabricTableHolder; - NL_TEST_ASSERT(inSuite, CHIP_NO_ERROR == fabricTableHolder.Init()); + EXPECT_EQ(CHIP_NO_ERROR, fabricTableHolder.Init()); secure_channel::MessageCounterManager messageCounterManager; TestPersistentStorageDelegate deviceStorage1, deviceStorage2; chip::Crypto::DefaultSessionKeystore sessionKeystore; SessionManager sessionManager; - NL_TEST_ASSERT(inSuite, - CHIP_NO_ERROR == - sessionManager.Init(&ctx.GetSystemLayer(), &ctx.GetTransportMgr(), &messageCounterManager, &deviceStorage1, - &fabricTableHolder.GetFabricTable(), sessionKeystore)); + EXPECT_EQ(CHIP_NO_ERROR, + sessionManager.Init(&GetSystemLayer(), &GetTransportMgr(), &messageCounterManager, &deviceStorage1, + &fabricTableHolder.GetFabricTable(), sessionKeystore)); // Allocate a session. uint16_t sessionId1; @@ -730,7 +700,7 @@ void SessionAllocationTest(nlTestSuite * inSuite, void * inContext) auto handle = sessionManager.AllocateSession( Transport::SecureSession::Type::kPASE, ScopedNodeId(NodeIdFromPAKEKeyId(kDefaultCommissioningPasscodeId), kUndefinedFabricIndex)); - NL_TEST_ASSERT(inSuite, handle.HasValue()); + EXPECT_TRUE(handle.HasValue()); SessionHolder session; session.GrabPairingSession(handle.Value()); sessionId1 = session->AsSecureSession()->GetLocalSessionId(); @@ -749,8 +719,8 @@ void SessionAllocationTest(nlTestSuite * inSuite, void * inContext) break; } auto sessionId = handle.Value()->AsSecureSession()->GetLocalSessionId(); - NL_TEST_ASSERT(inSuite, sessionId - prevSessionId == 1 || (sessionId == 1 && prevSessionId == 65535)); - NL_TEST_ASSERT(inSuite, sessionId != 0); + EXPECT_TRUE(sessionId - prevSessionId == 1 || (sessionId == 1 && prevSessionId == 65535)); + EXPECT_NE(sessionId, 0); prevSessionId = sessionId; } @@ -758,17 +728,16 @@ void SessionAllocationTest(nlTestSuite * inSuite, void * inContext) sessionManager.Shutdown(); sessionManager.~SessionManager(); new (&sessionManager) SessionManager(); - NL_TEST_ASSERT(inSuite, - CHIP_NO_ERROR == - sessionManager.Init(&ctx.GetSystemLayer(), &ctx.GetTransportMgr(), &messageCounterManager, &deviceStorage2, - &fabricTableHolder.GetFabricTable(), sessionKeystore)); + EXPECT_EQ(CHIP_NO_ERROR, + sessionManager.Init(&GetSystemLayer(), &GetTransportMgr(), &messageCounterManager, &deviceStorage2, + &fabricTableHolder.GetFabricTable(), sessionKeystore)); // Allocate a single session so we know what random id we are starting at. { auto handle = sessionManager.AllocateSession( Transport::SecureSession::Type::kPASE, ScopedNodeId(NodeIdFromPAKEKeyId(kDefaultCommissioningPasscodeId), kUndefinedFabricIndex)); - NL_TEST_ASSERT(inSuite, handle.HasValue()); + EXPECT_TRUE(handle.HasValue()); prevSessionId = handle.Value()->AsSecureSession()->GetLocalSessionId(); handle.Value()->AsSecureSession()->MarkForEviction(); } @@ -781,10 +750,10 @@ void SessionAllocationTest(nlTestSuite * inSuite, void * inContext) auto handle = sessionManager.AllocateSession( Transport::SecureSession::Type::kPASE, ScopedNodeId(NodeIdFromPAKEKeyId(kDefaultCommissioningPasscodeId), kUndefinedFabricIndex)); - NL_TEST_ASSERT(inSuite, handle.HasValue()); + EXPECT_TRUE(handle.HasValue()); auto sessionId = handle.Value()->AsSecureSession()->GetLocalSessionId(); - NL_TEST_ASSERT(inSuite, sessionId - prevSessionId == 1 || (sessionId == 1 && prevSessionId == 65535)); - NL_TEST_ASSERT(inSuite, sessionId != 0); + EXPECT_TRUE(sessionId - prevSessionId == 1 || (sessionId == 1 && prevSessionId == 65535)); + EXPECT_NE(sessionId, 0); prevSessionId = sessionId; handle.Value()->AsSecureSession()->MarkForEviction(); } @@ -804,15 +773,15 @@ void SessionAllocationTest(nlTestSuite * inSuite, void * inContext) handles[h] = sessionManager.AllocateSession( Transport::SecureSession::Type::kPASE, ScopedNodeId(NodeIdFromPAKEKeyId(kDefaultCommissioningPasscodeId), kUndefinedFabricIndex)); - NL_TEST_ASSERT(inSuite, handles[h].HasValue()); + EXPECT_TRUE(handles[h].HasValue()); sessionIds[h] = handles[h].Value()->AsSecureSession()->GetLocalSessionId(); - RandomSessionIdAllocatorOffset(inSuite, sessionManager, maxOffset); + RandomSessionIdAllocatorOffset(sessionManager, maxOffset); } // Verify that none collide each other. for (size_t h = 0; h < numHandles; ++h) { - NL_TEST_ASSERT(inSuite, sessionIds[h] != sessionIds[(h + 1) % numHandles]); + EXPECT_NE(sessionIds[h], sessionIds[(h + 1) % numHandles]); } // Allocate through the entire session ID space and verify that none of @@ -822,11 +791,11 @@ void SessionAllocationTest(nlTestSuite * inSuite, void * inContext) auto handle = sessionManager.AllocateSession( Transport::SecureSession::Type::kPASE, ScopedNodeId(NodeIdFromPAKEKeyId(kDefaultCommissioningPasscodeId), kUndefinedFabricIndex)); - NL_TEST_ASSERT(inSuite, handle.HasValue()); + EXPECT_TRUE(handle.HasValue()); auto potentialCollision = handle.Value()->AsSecureSession()->GetLocalSessionId(); for (uint16_t sessionId : sessionIds) { - NL_TEST_ASSERT(inSuite, potentialCollision != sessionId); + EXPECT_NE(potentialCollision, sessionId); } handle.Value()->AsSecureSession()->MarkForEviction(); } @@ -841,10 +810,8 @@ void SessionAllocationTest(nlTestSuite * inSuite, void * inContext) sessionManager.Shutdown(); } -void SessionCounterExhaustedTest(nlTestSuite * inSuite, void * inContext) +TEST_F(TestSessionManager, SessionCounterExhaustedTest) { - TestContext & ctx = *reinterpret_cast(inContext); - IPAddress addr; IPAddress::FromString("::1", addr); CHIP_ERROR err = CHIP_NO_ERROR; @@ -858,34 +825,33 @@ void SessionCounterExhaustedTest(nlTestSuite * inSuite, void * inContext) FabricIndex aliceFabricIndex = kUndefinedFabricIndex; FabricIndex bobFabricIndex = kUndefinedFabricIndex; - NL_TEST_ASSERT(inSuite, CHIP_NO_ERROR == fabricTableHolder.Init()); - NL_TEST_ASSERT(inSuite, - CHIP_NO_ERROR == - sessionManager.Init(&ctx.GetSystemLayer(), &ctx.GetTransportMgr(), &gMessageCounterManager, &deviceStorage, - &fabricTableHolder.GetFabricTable(), sessionKeystore)); + EXPECT_EQ(CHIP_NO_ERROR, fabricTableHolder.Init()); + EXPECT_EQ(CHIP_NO_ERROR, + sessionManager.Init(&GetSystemLayer(), &GetTransportMgr(), &gMessageCounterManager, &deviceStorage, + &fabricTableHolder.GetFabricTable(), sessionKeystore)); Transport::PeerAddress peer(Transport::PeerAddress::UDP(addr, CHIP_PORT)); err = fabricTable.AddNewFabricForTestIgnoringCollisions(GetRootACertAsset().mCert, GetIAA1CertAsset().mCert, GetNodeA1CertAsset().mCert, GetNodeA1CertAsset().mKey, &aliceFabricIndex); - NL_TEST_ASSERT(inSuite, CHIP_NO_ERROR == err); + EXPECT_EQ(CHIP_NO_ERROR, err); err = fabricTable.AddNewFabricForTestIgnoringCollisions(GetRootACertAsset().mCert, GetIAA1CertAsset().mCert, GetNodeA2CertAsset().mCert, GetNodeA2CertAsset().mKey, &bobFabricIndex); - NL_TEST_ASSERT(inSuite, CHIP_NO_ERROR == err); + EXPECT_EQ(CHIP_NO_ERROR, err); SessionHolder aliceToBobSession; err = sessionManager.InjectPaseSessionWithTestKey(aliceToBobSession, 2, fabricTable.FindFabricWithIndex(bobFabricIndex)->GetNodeId(), 1, aliceFabricIndex, peer, CryptoContext::SessionRole::kInitiator); - NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR); + EXPECT_EQ(err, CHIP_NO_ERROR); SessionHolder bobToAliceSession; err = sessionManager.InjectPaseSessionWithTestKey(bobToAliceSession, 1, fabricTable.FindFabricWithIndex(aliceFabricIndex)->GetNodeId(), 2, bobFabricIndex, peer, CryptoContext::SessionRole::kResponder); - NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR); + EXPECT_EQ(err, CHIP_NO_ERROR); // ==== Set counter value to max ==== LocalSessionMessageCounter & counter = static_cast( @@ -894,7 +860,7 @@ void SessionCounterExhaustedTest(nlTestSuite * inSuite, void * inContext) // ==== Build a valid message with max counter value ==== chip::System::PacketBufferHandle buffer = chip::MessagePacketBuffer::NewWithData(PAYLOAD, sizeof(PAYLOAD)); - NL_TEST_ASSERT(inSuite, !buffer.IsNull()); + EXPECT_FALSE(buffer.IsNull()); PayloadHeader payloadHeader; @@ -906,23 +872,21 @@ void SessionCounterExhaustedTest(nlTestSuite * inSuite, void * inContext) EncryptedPacketBufferHandle preparedMessage; err = sessionManager.PrepareMessage(aliceToBobSession.Get().Value(), payloadHeader, std::move(buffer), preparedMessage); - NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR); + EXPECT_EQ(err, CHIP_NO_ERROR); // ==== Build another message which will fail becuase message counter is exhausted ==== chip::System::PacketBufferHandle buffer2 = chip::MessagePacketBuffer::NewWithData(PAYLOAD, sizeof(PAYLOAD)); - NL_TEST_ASSERT(inSuite, !buffer2.IsNull()); + EXPECT_FALSE(buffer2.IsNull()); EncryptedPacketBufferHandle preparedMessage2; err = sessionManager.PrepareMessage(aliceToBobSession.Get().Value(), payloadHeader, std::move(buffer2), preparedMessage2); - NL_TEST_ASSERT(inSuite, err == CHIP_ERROR_MESSAGE_COUNTER_EXHAUSTED); + EXPECT_EQ(err, CHIP_ERROR_MESSAGE_COUNTER_EXHAUSTED); sessionManager.Shutdown(); } -static void SessionShiftingTest(nlTestSuite * inSuite, void * inContext) +TEST_F(TestSessionManager, SessionShiftingTest) { - TestContext & ctx = *reinterpret_cast(inContext); - IPAddress addr; IPAddress::FromString("::1", addr); @@ -937,18 +901,17 @@ static void SessionShiftingTest(nlTestSuite * inSuite, void * inContext) chip::Crypto::DefaultSessionKeystore sessionKeystore; SessionManager sessionManager; - NL_TEST_ASSERT(inSuite, CHIP_NO_ERROR == fabricTableHolder.Init()); - NL_TEST_ASSERT(inSuite, - CHIP_NO_ERROR == - sessionManager.Init(&ctx.GetSystemLayer(), &ctx.GetTransportMgr(), &messageCounterManager, &deviceStorage, - &fabricTableHolder.GetFabricTable(), sessionKeystore)); + EXPECT_EQ(CHIP_NO_ERROR, fabricTableHolder.Init()); + EXPECT_EQ(CHIP_NO_ERROR, + sessionManager.Init(&GetSystemLayer(), &GetTransportMgr(), &messageCounterManager, &deviceStorage, + &fabricTableHolder.GetFabricTable(), sessionKeystore)); Transport::PeerAddress peer(Transport::PeerAddress::UDP(addr, CHIP_PORT)); SessionHolder aliceToBobSession; CHIP_ERROR err = sessionManager.InjectCaseSessionWithTestKey(aliceToBobSession, 2, 1, aliceNodeId, bobNodeId, aliceFabricIndex, peer, CryptoContext::SessionRole::kInitiator); - NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR); + EXPECT_EQ(err, CHIP_NO_ERROR); class StickySessionDelegate : public SessionDelegate { @@ -958,17 +921,17 @@ static void SessionShiftingTest(nlTestSuite * inSuite, void * inContext) } delegate; SessionHolderWithDelegate stickyAliceToBobSession(aliceToBobSession.Get().Value(), delegate); - NL_TEST_ASSERT(inSuite, aliceToBobSession.Contains(stickyAliceToBobSession.Get().Value())); + EXPECT_TRUE(aliceToBobSession.Contains(stickyAliceToBobSession.Get().Value())); SessionHolder bobToAliceSession; err = sessionManager.InjectCaseSessionWithTestKey(bobToAliceSession, 1, 2, bobNodeId, aliceNodeId, bobFabricIndex, peer, CryptoContext::SessionRole::kResponder); - NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR); + EXPECT_EQ(err, CHIP_NO_ERROR); SessionHolder newAliceToBobSession; err = sessionManager.InjectCaseSessionWithTestKey(newAliceToBobSession, 3, 4, aliceNodeId, bobNodeId, aliceFabricIndex, peer, CryptoContext::SessionRole::kInitiator); - NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR); + EXPECT_EQ(err, CHIP_NO_ERROR); // Here we got 3 sessions, and 4 holders: // 1. alice -> bob: aliceToBobSession, stickyAliceToBobSession @@ -979,8 +942,8 @@ static void SessionShiftingTest(nlTestSuite * inSuite, void * inContext) SecureSession * session2 = bobToAliceSession->AsSecureSession(); SecureSession * session3 = newAliceToBobSession->AsSecureSession(); - NL_TEST_ASSERT(inSuite, session1 != session3); - NL_TEST_ASSERT(inSuite, stickyAliceToBobSession->AsSecureSession() == session1); + EXPECT_NE(session1, session3); + EXPECT_EQ(stickyAliceToBobSession->AsSecureSession(), session1); // Now shift the 1st session to the 3rd one, after shifting, holders should be: // 1. alice -> bob: stickyAliceToBobSession @@ -988,22 +951,20 @@ static void SessionShiftingTest(nlTestSuite * inSuite, void * inContext) // 3. alice -> bob: aliceToBobSession, newAliceToBobSession sessionManager.GetSecureSessions().NewerSessionAvailable(newAliceToBobSession.Get().Value()->AsSecureSession()); - NL_TEST_ASSERT(inSuite, aliceToBobSession); - NL_TEST_ASSERT(inSuite, stickyAliceToBobSession); - NL_TEST_ASSERT(inSuite, newAliceToBobSession); + EXPECT_TRUE(aliceToBobSession); + EXPECT_TRUE(stickyAliceToBobSession); + EXPECT_TRUE(newAliceToBobSession); - NL_TEST_ASSERT(inSuite, stickyAliceToBobSession->AsSecureSession() == session1); - NL_TEST_ASSERT(inSuite, bobToAliceSession->AsSecureSession() == session2); - NL_TEST_ASSERT(inSuite, aliceToBobSession->AsSecureSession() == session3); - NL_TEST_ASSERT(inSuite, newAliceToBobSession->AsSecureSession() == session3); + EXPECT_EQ(stickyAliceToBobSession->AsSecureSession(), session1); + EXPECT_EQ(bobToAliceSession->AsSecureSession(), session2); + EXPECT_EQ(aliceToBobSession->AsSecureSession(), session3); + EXPECT_EQ(newAliceToBobSession->AsSecureSession(), session3); sessionManager.Shutdown(); } -static void TestFindSecureSessionForNode(nlTestSuite * inSuite, void * inContext) +TEST_F(TestSessionManager, TestFindSecureSessionForNode) { - TestContext & ctx = *reinterpret_cast(inContext); - IPAddress addr; IPAddress::FromString("::1", addr); @@ -1017,24 +978,23 @@ static void TestFindSecureSessionForNode(nlTestSuite * inSuite, void * inContext chip::Crypto::DefaultSessionKeystore sessionKeystore; SessionManager sessionManager; - NL_TEST_ASSERT(inSuite, CHIP_NO_ERROR == fabricTableHolder.Init()); - NL_TEST_ASSERT(inSuite, - CHIP_NO_ERROR == - sessionManager.Init(&ctx.GetSystemLayer(), &ctx.GetTransportMgr(), &messageCounterManager, &deviceStorage, - &fabricTableHolder.GetFabricTable(), sessionKeystore)); + EXPECT_EQ(CHIP_NO_ERROR, fabricTableHolder.Init()); + EXPECT_EQ(CHIP_NO_ERROR, + sessionManager.Init(&GetSystemLayer(), &GetTransportMgr(), &messageCounterManager, &deviceStorage, + &fabricTableHolder.GetFabricTable(), sessionKeystore)); Transport::PeerAddress peer(Transport::PeerAddress::UDP(addr, CHIP_PORT)); SessionHolder aliceToBobSession; CHIP_ERROR err = sessionManager.InjectCaseSessionWithTestKey(aliceToBobSession, 2, 1, aliceNodeId, bobNodeId, aliceFabricIndex, peer, CryptoContext::SessionRole::kInitiator); - NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR); + EXPECT_EQ(err, CHIP_NO_ERROR); aliceToBobSession->AsSecureSession()->MarkActive(); SessionHolder newAliceToBobSession; err = sessionManager.InjectCaseSessionWithTestKey(newAliceToBobSession, 3, 4, aliceNodeId, bobNodeId, aliceFabricIndex, peer, CryptoContext::SessionRole::kInitiator); - NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR); + EXPECT_EQ(err, CHIP_NO_ERROR); while (System::SystemClock().GetMonotonicTimestamp() <= aliceToBobSession->AsSecureSession()->GetLastActivityTime()) { @@ -1045,75 +1005,11 @@ static void TestFindSecureSessionForNode(nlTestSuite * inSuite, void * inContext auto foundSession = sessionManager.FindSecureSessionForNode(ScopedNodeId(bobNodeId, aliceFabricIndex), MakeOptional(SecureSession::Type::kCASE)); - NL_TEST_ASSERT(inSuite, foundSession.HasValue()); - NL_TEST_ASSERT(inSuite, newAliceToBobSession.Contains(foundSession.Value())); - NL_TEST_ASSERT(inSuite, !aliceToBobSession.Contains(foundSession.Value())); + EXPECT_TRUE(foundSession.HasValue()); + EXPECT_TRUE(newAliceToBobSession.Contains(foundSession.Value())); + EXPECT_FALSE(aliceToBobSession.Contains(foundSession.Value())); sessionManager.Shutdown(); } -// Test Suite - -/** - * Test Suite that lists all the test functions. - */ -// clang-format off -const nlTest sTests[] = -{ - NL_TEST_DEF("Simple Init Test", CheckSimpleInitTest), - NL_TEST_DEF("Message Self Test", CheckMessageTest), - NL_TEST_DEF("Send Encrypted Packet Test", SendEncryptedPacketTest), - NL_TEST_DEF("Send Bad Encrypted Packet Test", SendBadEncryptedPacketTest), - NL_TEST_DEF("Old counter Test", SendPacketWithOldCounterTest), - NL_TEST_DEF("Too-old counter Test", SendPacketWithTooOldCounterTest), - NL_TEST_DEF("Session Allocation Test", SessionAllocationTest), - NL_TEST_DEF("Session Counter Exhausted Test", SessionCounterExhaustedTest), - NL_TEST_DEF("SessionShiftingTest", SessionShiftingTest), - NL_TEST_DEF("TestFindSecureSessionForNode", TestFindSecureSessionForNode), - - NL_TEST_SENTINEL() -}; -// clang-format on - -int Initialize(void * aContext); -int Finalize(void * aContext); - -// clang-format off -nlTestSuite sSuite = -{ - "Test-CHIP-SessionManager", - &sTests[0], - Initialize, - Finalize -}; -// clang-format on - -/** - * Initialize the test suite. - */ -int Initialize(void * aContext) -{ - CHIP_ERROR err = reinterpret_cast(aContext)->Init(); - return (err == CHIP_NO_ERROR) ? SUCCESS : FAILURE; -} - -/** - * Finalize the test suite. - */ -int Finalize(void * aContext) -{ - reinterpret_cast(aContext)->Shutdown(); - return SUCCESS; -} - } // namespace - -/** - * Main - */ -int TestSessionManager() -{ - return chip::ExecuteTestsWithContext(&sSuite); -} - -CHIP_REGISTER_TEST_SUITE(TestSessionManager); diff --git a/src/transport/tests/TestSessionManagerDispatch.cpp b/src/transport/tests/TestSessionManagerDispatch.cpp index 9d351ab3cacdb2..b83421eb1a47c1 100644 --- a/src/transport/tests/TestSessionManagerDispatch.cpp +++ b/src/transport/tests/TestSessionManagerDispatch.cpp @@ -31,15 +31,12 @@ #include #include #include -#include -#include #include #include #include #include -#include -#include +#include #include @@ -106,8 +103,8 @@ struct MessageTestEntry theMessageTestVector[] = { .plain = "\x00\xb8\x0b\x00\x39\x30\x00\x00\x05\x64\xee\x0e\x20\x7d", .encrypted = "\x00\xb8\x0b\x00\x39\x30\x00\x00\x5a\x98\x9a\xe4\x2e\x8d" "\x84\x7f\x53\x5c\x30\x07\xe6\x15\x0c\xd6\x58\x67\xf2\xb8\x17\xdb", // Includes MIC - .privacy = "\x00\xb8\x0b\x00\x39\x30\x00\x00\x5a\x98\x9a\xe4\x2e\x8d" - "\x84\x7f\x53\x5c\x30\x07\xe6\x15\x0c\xd6\x58\x67\xf2\xb8\x17\xdb", // Includes MIC + .privacy = "\x00\xb8\x0b\x00\x39\x30\x00\x00\x5a\x98\x9a\xe4\x2e\x8d" + "\x84\x7f\x53\x5c\x30\x07\xe6\x15\x0c\xd6\x58\x67\xf2\xb8\x17\xdb", // Includes MIC .payloadLength = 0, .plainLength = 14, @@ -132,8 +129,8 @@ struct MessageTestEntry theMessageTestVector[] = { .plain = "\x00\xb8\x0b\x00\x39\x30\x00\x00\x05\x64\xee\x0e\x20\x7d\x11\x22\x33\x44\x55", .encrypted = "\x00\xb8\x0b\x00\x39\x30\x00\x00\x5a\x98\x9a\xe4\x2e\x8d\x0f\x7f\x88\x5d\xfb" "\x2f\xaa\x89\x49\xcf\x73\x0a\x57\x28\xe0\x35\x46\x10\xa0\xc4\xa7", // Includes MIC - .privacy = "\x00\xb8\x0b\x00\x39\x30\x00\x00\x5a\x98\x9a\xe4\x2e\x8d\x0f\x7f\x88\x5d\xfb" - "\x2f\xaa\x89\x49\xcf\x73\x0a\x57\x28\xe0\x35\x46\x10\xa0\xc4\xa7", // Includes MIC + .privacy = "\x00\xb8\x0b\x00\x39\x30\x00\x00\x5a\x98\x9a\xe4\x2e\x8d\x0f\x7f\x88\x5d\xfb" + "\x2f\xaa\x89\x49\xcf\x73\x0a\x57\x28\xe0\x35\x46\x10\xa0\xc4\xa7", // Includes MIC .payloadLength = 5, .plainLength = 19, @@ -161,8 +158,8 @@ struct MessageTestEntry theMessageTestVector[] = { .plain = "\x00\xb8\x0b\x00\x39\x30\x00\x00\x05\x64\xee\x0e\x20\x7d", .encrypted = "\x00\xb8\x0b\x00\x39\x30\x00\x00\x5a\x98\x9a\xe4\x2e\x8d" "\x84\x7f\x53\x5c\x30\x07\xe6\x15\x0c\xd6\x58\x67\xf2\xb8\x17\xdd", // Includes wrong MIC - .privacy = "\x00\xb8\x0b\x00\x39\x30\x00\x00\x5a\x98\x9a\xe4\x2e\x8d" - "\x84\x7f\x53\x5c\x30\x07\xe6\x15\x0c\xd6\x58\x67\xf2\xb8\x17\xdd", // Includes wrong MIC + .privacy = "\x00\xb8\x0b\x00\x39\x30\x00\x00\x5a\x98\x9a\xe4\x2e\x8d" + "\x84\x7f\x53\x5c\x30\x07\xe6\x15\x0c\xd6\x58\x67\xf2\xb8\x17\xdd", // Includes wrong MIC .payloadLength = 0, .plainLength = 14, @@ -187,8 +184,8 @@ struct MessageTestEntry theMessageTestVector[] = { .plain = "\x00\xb8\x0b\x00\x39\x30\x00\x00\x05\x64\xee\x0e\x20\x7d\x11\x22\x33\x44\x55", .encrypted = "\x00\xb8\x0b\x00\x39\x30\x00\x00\x5a\x98\x9a\xe4\x2e\x8d\x0f\x7f\x88\x5d\xfb" "\x2f\xaa\x89\x49\xcf\x73\x0a\x57\x28\xe0\x35\x46\x10\xa0\xc4\xaa", // Includes wrong MIC - .privacy = "\x00\xb8\x0b\x00\x39\x30\x00\x00\x5a\x98\x9a\xe4\x2e\x8d\x0f\x7f\x88\x5d\xfb" - "\x2f\xaa\x89\x49\xcf\x73\x0a\x57\x28\xe0\x35\x46\x10\xa0\xc4\xaa", // Includes wrong MIC + .privacy = "\x00\xb8\x0b\x00\x39\x30\x00\x00\x5a\x98\x9a\xe4\x2e\x8d\x0f\x7f\x88\x5d\xfb" + "\x2f\xaa\x89\x49\xcf\x73\x0a\x57\x28\xe0\x35\x46\x10\xa0\xc4\xaa", // Includes wrong MIC .payloadLength = 5, .plainLength = 19, @@ -213,8 +210,8 @@ struct MessageTestEntry theMessageTestVector[] = { .plain = "\x00\xb8\x0b\x80\x39\x30\x00\x00\x05\x64\xee\x0e\x20\x7d\x11\x22\x33\x44\x55", .encrypted = "\x00\xb8\x0b\x80\x39\x30\x00\x00\xaa\x26\xa0\xf9\x01\xef\xce\x9f\x9a\x67\xc8" "\x13\x79\x17\xd1\x5b\x81\xd1\x5d\x31\x33\x08\x31\x97\x58\xea\x3f", // Includes MIC - .privacy = "\x00\xb8\x0b\x80\x87\xbe\xef\x06\xaa\x26\xa0\xf9\x01\xef\xce\x9f\x9a\x67\xc8" - "\x13\x79\x17\xd1\x5b\x81\xd1\x5d\x31\x33\x08\x31\x97\x58\xea\x3f", // Includes MIC + .privacy = "\x00\xb8\x0b\x80\x87\xbe\xef\x06\xaa\x26\xa0\xf9\x01\xef\xce\x9f\x9a\x67\xc8" + "\x13\x79\x17\xd1\x5b\x81\xd1\x5d\x31\x33\x08\x31\x97\x58\xea\x3f", // Includes MIC .payloadLength = 5, .plainLength = 19, @@ -246,8 +243,8 @@ struct MessageTestEntry theMessageTestVector[] = { .plain = "\06\x7d\xdb\x01\x78\x56\x34\x12\x01\x00\x00\x00\x00\x00\x00\x00\x02\x00\x01\x64\xee\x0e\x20\x7d", .encrypted = "\x06\x7d\xdb\x01\x78\x56\x34\x12\x01\x00\x00\x00\x00\x00\x00\x00\x02\x00\x65\xc7\x67\xbc\x6c\xda" "\x01\x06\xc9\x80\x13\x23\x90\x0e\x9b\x3c\xe6\xd4\xbb\x03\x27\xd6", // Includes MIC - .privacy = "\x06\x7d\xdb\x01\x78\x56\x34\x12\x01\x00\x00\x00\x00\x00\x00\x00\x02\x00\x65\xc7\x67\xbc\x6c\xda" - "\x01\x06\xc9\x80\x13\x23\x90\x0e\x9b\x3c\xe6\xd4\xbb\x03\x27\xd6", // Includes MIC + .privacy = "\x06\x7d\xdb\x01\x78\x56\x34\x12\x01\x00\x00\x00\x00\x00\x00\x00\x02\x00\x65\xc7\x67\xbc\x6c\xda" + "\x01\x06\xc9\x80\x13\x23\x90\x0e\x9b\x3c\xe6\xd4\xbb\x03\x27\xd6", // Includes MIC .payloadLength = 0, .plainLength = 24, @@ -278,8 +275,8 @@ struct MessageTestEntry theMessageTestVector[] = { .plain = "\06\x7d\xdb\x01\x78\x56\x34\x12\x01\x00\x00\x00\x00\x00\x00\x00\x02\x00\x01\x64\xee\x0e\x20\x7d", .encrypted = "\x06\x7d\xdb\x01\x78\x56\x34\x12\x01\x00\x00\x00\x00\x00\x00\x00\x02\x00\x65\xc7\x67\xbc\x6c\xda" "\x01\x06\xc9\x80\x13\x23\x90\x0e\x9b\x3c\xe6\xd4\xbb\x03\x27\xd6", // Includes MIC - .privacy = "\x06\x7d\xdb\x01\x78\x56\x34\x12\x01\x00\x00\x00\x00\x00\x00\x00\x02\x00\x65\xc7\x67\xbc\x6c\xda" - "\x01\x06\xc9\x80\x13\x23\x90\x0e\x9b\x3c\xe6\xd4\xbb\x03\x27\xd6", // Includes MIC + .privacy = "\x06\x7d\xdb\x01\x78\x56\x34\x12\x01\x00\x00\x00\x00\x00\x00\x00\x02\x00\x65\xc7\x67\xbc\x6c\xda" + "\x01\x06\xc9\x80\x13\x23\x90\x0e\x9b\x3c\xe6\xd4\xbb\x03\x27\xd6", // Includes MIC .payloadLength = 0, .plainLength = 24, @@ -310,8 +307,8 @@ struct MessageTestEntry theMessageTestVector[] = { .plain = "\x06\x7d\xdb\x81\x79\x56\x34\x12\x01\x00\x00\x00\x00\x00\x00\x00\x02\x00\x01\x64\xee\x0e\x20\x7d", .encrypted = "\x06\x7d\xdb\x81\x79\x56\x34\x12\x01\x00\x00\x00\x00\x00\x00\x00\x02\x00\x2b\x2f\x91\x5a\x66\xc9" "\x59\x62\x90\xeb\xe4\x40\x82\x17\xb3\xc0\xc9\x21\xa2\xfc\xa4\xe1", - .privacy = "\x06\x7d\xdb\x81\xd9\x26\xaf\xce\x24\xc8\xa0\x98\x1b\xdd\x44\xf4\xe7\x30\x2b\x2f\x91\x5a\x66\xc9" - "\x59\x62\x90\xeb\xe4\x40\x82\x17\xb3\xc0\xc9\x21\xa2\xfc\xa4\xe1", + .privacy = "\x06\x7d\xdb\x81\xd9\x26\xaf\xce\x24\xc8\xa0\x98\x1b\xdd\x44\xf4\xe7\x30\x2b\x2f\x91\x5a\x66\xc9" + "\x59\x62\x90\xeb\xe4\x40\x82\x17\xb3\xc0\xc9\x21\xa2\xfc\xa4\xe1", .payloadLength = 0, .plainLength = 24, @@ -345,8 +342,8 @@ struct MessageTestEntry theMessageTestVector[] = { .plain = "\x06\x7d\xdb\x81\x79\x56\x34\x12\x01\x00\x00\x00\x00\x00\x00\x00\x02\x00\x01\x64\xee\x0e\x20\x7d", .encrypted = "\x06\x7d\xdb\x81\x79\x56\x34\x12\x01\x00\x00\x00\x00\x00\x00\x00\x02\x00\x2b\x2f\x91\x5a\x66\xc9" "\x59\x62\x90\xeb\xe4\x40\x82\x17\xb3\xc0\xc9\x21\xa2\xfc\xa4\xee", - .privacy = "\x06\x7d\xdb\x81\xd9\x26\xaf\xce\x24\xc8\xa0\x98\x1b\xdd\x44\xf4\xe7\x30\x2b\x2f\x91\x5a\x66\xc9" - "\x59\x62\x90\xeb\xe4\x40\x82\x17\xb3\xc0\xc9\x21\xa2\xfc\xa4\xee", + .privacy = "\x06\x7d\xdb\x81\xd9\x26\xaf\xce\x24\xc8\xa0\x98\x1b\xdd\x44\xf4\xe7\x30\x2b\x2f\x91\x5a\x66\xc9" + "\x59\x62\x90\xeb\xe4\x40\x82\x17\xb3\xc0\xc9\x21\xa2\xfc\xa4\xee", .payloadLength = 0, .plainLength = 24, @@ -381,8 +378,8 @@ struct MessageTestEntry theMessageTestVector[] = { .plain = "\06\x7d\xdb\x81\x91\x56\x34\x12\x01\x00\x00\x00\x00\x00\x00\x00\x02\x00\x01\x64\xee\x0e\x20\x7d", .encrypted = "\x06\x7d\xdb\x81\x91\x56\x34\x12\x01\x00\x00\x00\x00\x00\x00\x00\x02\x00\x91\xe0\x22\x85\xe0\x59\x07\xe0" "\xd8\x68\x0c\x79\xac\x6d\x64\x46\x90\x65\xb2\x6f\x90\x26", // Includes MIC - .privacy = "\x06\x7d\xdb\x81\x91\x56\x34\x12\x01\x00\x00\x00\x00\x00\x00\x00\x02\x00\x91\xe0\x22\x85\xe0\x59\x07\xe0" - "\xd8\x68\x0c\x79\xac\x6d\x64\x46\x90\x65\xb2\x6f\x90\x26", // Includes MIC + .privacy = "\x06\x7d\xdb\x81\x91\x56\x34\x12\x01\x00\x00\x00\x00\x00\x00\x00\x02\x00\x91\xe0\x22\x85\xe0\x59\x07\xe0" + "\xd8\x68\x0c\x79\xac\x6d\x64\x46\x90\x65\xb2\x6f\x90\x26", // Includes MIC .payloadLength = 0, .plainLength = 24, @@ -472,13 +469,13 @@ class TestSessionManagerCallback : public SessionMessageDelegate MessageTestEntry & testEntry = theMessageTestVector[mTestVectorIndex]; ChipLogProgress(Test, "OnMessageReceived: sessionId=0x%04x", testEntry.sessionId); - NL_TEST_ASSERT(mSuite, header.GetSessionId() == testEntry.sessionId); + EXPECT_EQ(header.GetSessionId(), testEntry.sessionId); size_t dataLength = msgBuf->DataLength(); size_t expectLength = testEntry.payloadLength; - NL_TEST_ASSERT(mSuite, dataLength == expectLength); - NL_TEST_ASSERT(mSuite, memcmp(msgBuf->Start(), testEntry.payload, dataLength) == 0); + EXPECT_EQ(dataLength, expectLength); + EXPECT_EQ(memcmp(msgBuf->Start(), testEntry.payload, dataLength), 0); ChipLogProgress(Test, "::: TestSessionManagerDispatch[%d] PASS", mTestVectorIndex); } @@ -491,7 +488,6 @@ class TestSessionManagerCallback : public SessionMessageDelegate unsigned NumMessagesReceived() { return mReceivedCount; } - nlTestSuite * mSuite = nullptr; unsigned mTestVectorIndex = 0; unsigned mReceivedCount = 0; }; @@ -505,18 +501,17 @@ PeerAddress AddressFromString(const char * str) return PeerAddress::UDP(addr); } -void TestSessionManagerInit(nlTestSuite * inSuite, TestContext & ctx, SessionManager & sessionManager) +void TestSessionManagerInit(TestContext * ctx, SessionManager & sessionManager) { static FabricTableHolder fabricTableHolder; static secure_channel::MessageCounterManager gMessageCounterManager; static chip::TestPersistentStorageDelegate deviceStorage; static chip::Crypto::DefaultSessionKeystore sessionKeystore; - NL_TEST_ASSERT(inSuite, CHIP_NO_ERROR == fabricTableHolder.Init()); - NL_TEST_ASSERT(inSuite, - CHIP_NO_ERROR == - sessionManager.Init(&ctx.GetSystemLayer(), &ctx.GetTransportMgr(), &gMessageCounterManager, &deviceStorage, - &fabricTableHolder.GetFabricTable(), sessionKeystore)); + EXPECT_EQ(CHIP_NO_ERROR, fabricTableHolder.Init()); + EXPECT_EQ(CHIP_NO_ERROR, + sessionManager.Init(&ctx->GetSystemLayer(), &ctx->GetTransportMgr(), &gMessageCounterManager, &deviceStorage, + &fabricTableHolder.GetFabricTable(), sessionKeystore)); } // constexpr chip::FabricId kFabricId1 = 0x2906C908D115D362; @@ -552,15 +547,24 @@ CHIP_ERROR InjectGroupSessionWithTestKey(SessionHolder & sessionHolder, MessageT return CHIP_NO_ERROR; } -void TestSessionManagerDispatch(nlTestSuite * inSuite, void * inContext) +class TestSessionManagerDispatch : public ::testing::Test +{ +protected: + TestSessionManagerDispatch() { inContext = new TestContext(); } + ~TestSessionManagerDispatch() { delete inContext; } + void SetUp() { ASSERT_EQ(inContext->Init(), CHIP_NO_ERROR); } + void TearDown() { inContext->Shutdown(); } + TestContext * inContext; +}; + +TEST_F(TestSessionManagerDispatch, TestSessionManagerDispatch) { CHIP_ERROR err = CHIP_NO_ERROR; - TestContext & ctx = *reinterpret_cast(inContext); SessionManager sessionManager; TestSessionManagerCallback callback; - TestSessionManagerInit(inSuite, ctx, sessionManager); + TestSessionManagerInit(inContext, sessionManager); sessionManager.SetMessageDelegate(&callback); IPAddress addr; @@ -570,7 +574,6 @@ void TestSessionManagerDispatch(nlTestSuite * inSuite, void * inContext) SessionHolder aliceToBobSession; SessionHolder testGroupSession; - callback.mSuite = inSuite; for (unsigned i = 0; i < theMessageTestVectorLength; i++) { MessageTestEntry & testEntry = theMessageTestVector[i]; @@ -585,10 +588,10 @@ void TestSessionManagerDispatch(nlTestSuite * inSuite, void * inContext) err = sessionManager.InjectPaseSessionWithTestKey(aliceToBobSession, testEntry.sessionId, testEntry.peerNodeId, testEntry.sessionId, kFabricIndex, peer, CryptoContext::SessionRole::kResponder); - NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR); + EXPECT_EQ(err, CHIP_NO_ERROR); err = InjectGroupSessionWithTestKey(testGroupSession, testEntry); - NL_TEST_ASSERT(inSuite, CHIP_NO_ERROR == err); + EXPECT_EQ(CHIP_NO_ERROR, err); const char * plain = testEntry.plain; const ByteSpan expectedPlain(reinterpret_cast(plain), testEntry.plainLength); @@ -598,7 +601,7 @@ void TestSessionManagerDispatch(nlTestSuite * inSuite, void * inContext) const PeerAddress peerAddress = AddressFromString(testEntry.peerAddr); sessionManager.OnMessageReceived(peerAddress, std::move(msg)); - NL_TEST_ASSERT(inSuite, callback.NumMessagesReceived() == testEntry.expectedMessageCount); + EXPECT_EQ(callback.NumMessagesReceived(), testEntry.expectedMessageCount); if ((testEntry.expectedMessageCount == 0) && (callback.NumMessagesReceived() == 0)) { @@ -609,56 +612,4 @@ void TestSessionManagerDispatch(nlTestSuite * inSuite, void * inContext) sessionManager.Shutdown(); } -// ============================================================================ -// Test Suite Instrumenation -// ============================================================================ - -/** - * Initialize the test suite. - */ -int Initialize(void * aContext) -{ - CHIP_ERROR err = reinterpret_cast(aContext)->Init(); - return (err == CHIP_NO_ERROR) ? SUCCESS : FAILURE; -} - -/** - * Finalize the test suite. - */ -int Finalize(void * aContext) -{ - reinterpret_cast(aContext)->Shutdown(); - return SUCCESS; -} - -/** - * Test Suite that lists all the test functions. - */ -// clang-format off -const nlTest sTests[] = -{ - NL_TEST_DEF("Test Session Manager Dispatch", TestSessionManagerDispatch), - - NL_TEST_SENTINEL() -}; - -nlTestSuite sSuite = -{ - "TestSessionManagerDispatch", - &sTests[0], - Initialize, - Finalize -}; -// clang-format on - } // namespace - -/** - * Main - */ -int TestSessionManagerDispatchSuite() -{ - return chip::ExecuteTestsWithContext(&sSuite); -} - -CHIP_REGISTER_TEST_SUITE(TestSessionManagerDispatchSuite); From 08fa55e425f05d6a4e9673c721138dcb4197e323 Mon Sep 17 00:00:00 2001 From: Jeff Feasel Date: Tue, 30 Apr 2024 20:22:15 -0400 Subject: [PATCH 2/8] Updated test_components[_nl].txt to move TransportLayerTests --- src/test_driver/openiotsdk/unit-tests/test_components.txt | 1 + src/test_driver/openiotsdk/unit-tests/test_components_nl.txt | 1 - 2 files changed, 1 insertion(+), 1 deletion(-) diff --git a/src/test_driver/openiotsdk/unit-tests/test_components.txt b/src/test_driver/openiotsdk/unit-tests/test_components.txt index 5887de730725df..e832a83f4bea85 100644 --- a/src/test_driver/openiotsdk/unit-tests/test_components.txt +++ b/src/test_driver/openiotsdk/unit-tests/test_components.txt @@ -18,3 +18,4 @@ SupportTests UserDirectedCommissioningTests SecureChannelTests ICDServerTests +TransportLayerTests diff --git a/src/test_driver/openiotsdk/unit-tests/test_components_nl.txt b/src/test_driver/openiotsdk/unit-tests/test_components_nl.txt index e3d66b49d3f644..6af4ed11c4f625 100644 --- a/src/test_driver/openiotsdk/unit-tests/test_components_nl.txt +++ b/src/test_driver/openiotsdk/unit-tests/test_components_nl.txt @@ -5,4 +5,3 @@ InetLayerTests MessagingLayerTests SecureChannelTestsNL SupportTestsNL -TransportLayerTests From db33f68ddac7813d7186541a0f07b76ccaf316bf Mon Sep 17 00:00:00 2001 From: Jeff Feasel Date: Sat, 4 May 2024 07:25:45 -0400 Subject: [PATCH 3/8] Fixed formatting --- .../tests/TestSessionManagerDispatch.cpp | 40 +++++++++---------- 1 file changed, 20 insertions(+), 20 deletions(-) diff --git a/src/transport/tests/TestSessionManagerDispatch.cpp b/src/transport/tests/TestSessionManagerDispatch.cpp index b83421eb1a47c1..47b2a9daed5c52 100644 --- a/src/transport/tests/TestSessionManagerDispatch.cpp +++ b/src/transport/tests/TestSessionManagerDispatch.cpp @@ -103,8 +103,8 @@ struct MessageTestEntry theMessageTestVector[] = { .plain = "\x00\xb8\x0b\x00\x39\x30\x00\x00\x05\x64\xee\x0e\x20\x7d", .encrypted = "\x00\xb8\x0b\x00\x39\x30\x00\x00\x5a\x98\x9a\xe4\x2e\x8d" "\x84\x7f\x53\x5c\x30\x07\xe6\x15\x0c\xd6\x58\x67\xf2\xb8\x17\xdb", // Includes MIC - .privacy = "\x00\xb8\x0b\x00\x39\x30\x00\x00\x5a\x98\x9a\xe4\x2e\x8d" - "\x84\x7f\x53\x5c\x30\x07\xe6\x15\x0c\xd6\x58\x67\xf2\xb8\x17\xdb", // Includes MIC + .privacy = "\x00\xb8\x0b\x00\x39\x30\x00\x00\x5a\x98\x9a\xe4\x2e\x8d" + "\x84\x7f\x53\x5c\x30\x07\xe6\x15\x0c\xd6\x58\x67\xf2\xb8\x17\xdb", // Includes MIC .payloadLength = 0, .plainLength = 14, @@ -129,8 +129,8 @@ struct MessageTestEntry theMessageTestVector[] = { .plain = "\x00\xb8\x0b\x00\x39\x30\x00\x00\x05\x64\xee\x0e\x20\x7d\x11\x22\x33\x44\x55", .encrypted = "\x00\xb8\x0b\x00\x39\x30\x00\x00\x5a\x98\x9a\xe4\x2e\x8d\x0f\x7f\x88\x5d\xfb" "\x2f\xaa\x89\x49\xcf\x73\x0a\x57\x28\xe0\x35\x46\x10\xa0\xc4\xa7", // Includes MIC - .privacy = "\x00\xb8\x0b\x00\x39\x30\x00\x00\x5a\x98\x9a\xe4\x2e\x8d\x0f\x7f\x88\x5d\xfb" - "\x2f\xaa\x89\x49\xcf\x73\x0a\x57\x28\xe0\x35\x46\x10\xa0\xc4\xa7", // Includes MIC + .privacy = "\x00\xb8\x0b\x00\x39\x30\x00\x00\x5a\x98\x9a\xe4\x2e\x8d\x0f\x7f\x88\x5d\xfb" + "\x2f\xaa\x89\x49\xcf\x73\x0a\x57\x28\xe0\x35\x46\x10\xa0\xc4\xa7", // Includes MIC .payloadLength = 5, .plainLength = 19, @@ -158,8 +158,8 @@ struct MessageTestEntry theMessageTestVector[] = { .plain = "\x00\xb8\x0b\x00\x39\x30\x00\x00\x05\x64\xee\x0e\x20\x7d", .encrypted = "\x00\xb8\x0b\x00\x39\x30\x00\x00\x5a\x98\x9a\xe4\x2e\x8d" "\x84\x7f\x53\x5c\x30\x07\xe6\x15\x0c\xd6\x58\x67\xf2\xb8\x17\xdd", // Includes wrong MIC - .privacy = "\x00\xb8\x0b\x00\x39\x30\x00\x00\x5a\x98\x9a\xe4\x2e\x8d" - "\x84\x7f\x53\x5c\x30\x07\xe6\x15\x0c\xd6\x58\x67\xf2\xb8\x17\xdd", // Includes wrong MIC + .privacy = "\x00\xb8\x0b\x00\x39\x30\x00\x00\x5a\x98\x9a\xe4\x2e\x8d" + "\x84\x7f\x53\x5c\x30\x07\xe6\x15\x0c\xd6\x58\x67\xf2\xb8\x17\xdd", // Includes wrong MIC .payloadLength = 0, .plainLength = 14, @@ -184,8 +184,8 @@ struct MessageTestEntry theMessageTestVector[] = { .plain = "\x00\xb8\x0b\x00\x39\x30\x00\x00\x05\x64\xee\x0e\x20\x7d\x11\x22\x33\x44\x55", .encrypted = "\x00\xb8\x0b\x00\x39\x30\x00\x00\x5a\x98\x9a\xe4\x2e\x8d\x0f\x7f\x88\x5d\xfb" "\x2f\xaa\x89\x49\xcf\x73\x0a\x57\x28\xe0\x35\x46\x10\xa0\xc4\xaa", // Includes wrong MIC - .privacy = "\x00\xb8\x0b\x00\x39\x30\x00\x00\x5a\x98\x9a\xe4\x2e\x8d\x0f\x7f\x88\x5d\xfb" - "\x2f\xaa\x89\x49\xcf\x73\x0a\x57\x28\xe0\x35\x46\x10\xa0\xc4\xaa", // Includes wrong MIC + .privacy = "\x00\xb8\x0b\x00\x39\x30\x00\x00\x5a\x98\x9a\xe4\x2e\x8d\x0f\x7f\x88\x5d\xfb" + "\x2f\xaa\x89\x49\xcf\x73\x0a\x57\x28\xe0\x35\x46\x10\xa0\xc4\xaa", // Includes wrong MIC .payloadLength = 5, .plainLength = 19, @@ -210,8 +210,8 @@ struct MessageTestEntry theMessageTestVector[] = { .plain = "\x00\xb8\x0b\x80\x39\x30\x00\x00\x05\x64\xee\x0e\x20\x7d\x11\x22\x33\x44\x55", .encrypted = "\x00\xb8\x0b\x80\x39\x30\x00\x00\xaa\x26\xa0\xf9\x01\xef\xce\x9f\x9a\x67\xc8" "\x13\x79\x17\xd1\x5b\x81\xd1\x5d\x31\x33\x08\x31\x97\x58\xea\x3f", // Includes MIC - .privacy = "\x00\xb8\x0b\x80\x87\xbe\xef\x06\xaa\x26\xa0\xf9\x01\xef\xce\x9f\x9a\x67\xc8" - "\x13\x79\x17\xd1\x5b\x81\xd1\x5d\x31\x33\x08\x31\x97\x58\xea\x3f", // Includes MIC + .privacy = "\x00\xb8\x0b\x80\x87\xbe\xef\x06\xaa\x26\xa0\xf9\x01\xef\xce\x9f\x9a\x67\xc8" + "\x13\x79\x17\xd1\x5b\x81\xd1\x5d\x31\x33\x08\x31\x97\x58\xea\x3f", // Includes MIC .payloadLength = 5, .plainLength = 19, @@ -243,8 +243,8 @@ struct MessageTestEntry theMessageTestVector[] = { .plain = "\06\x7d\xdb\x01\x78\x56\x34\x12\x01\x00\x00\x00\x00\x00\x00\x00\x02\x00\x01\x64\xee\x0e\x20\x7d", .encrypted = "\x06\x7d\xdb\x01\x78\x56\x34\x12\x01\x00\x00\x00\x00\x00\x00\x00\x02\x00\x65\xc7\x67\xbc\x6c\xda" "\x01\x06\xc9\x80\x13\x23\x90\x0e\x9b\x3c\xe6\xd4\xbb\x03\x27\xd6", // Includes MIC - .privacy = "\x06\x7d\xdb\x01\x78\x56\x34\x12\x01\x00\x00\x00\x00\x00\x00\x00\x02\x00\x65\xc7\x67\xbc\x6c\xda" - "\x01\x06\xc9\x80\x13\x23\x90\x0e\x9b\x3c\xe6\xd4\xbb\x03\x27\xd6", // Includes MIC + .privacy = "\x06\x7d\xdb\x01\x78\x56\x34\x12\x01\x00\x00\x00\x00\x00\x00\x00\x02\x00\x65\xc7\x67\xbc\x6c\xda" + "\x01\x06\xc9\x80\x13\x23\x90\x0e\x9b\x3c\xe6\xd4\xbb\x03\x27\xd6", // Includes MIC .payloadLength = 0, .plainLength = 24, @@ -275,8 +275,8 @@ struct MessageTestEntry theMessageTestVector[] = { .plain = "\06\x7d\xdb\x01\x78\x56\x34\x12\x01\x00\x00\x00\x00\x00\x00\x00\x02\x00\x01\x64\xee\x0e\x20\x7d", .encrypted = "\x06\x7d\xdb\x01\x78\x56\x34\x12\x01\x00\x00\x00\x00\x00\x00\x00\x02\x00\x65\xc7\x67\xbc\x6c\xda" "\x01\x06\xc9\x80\x13\x23\x90\x0e\x9b\x3c\xe6\xd4\xbb\x03\x27\xd6", // Includes MIC - .privacy = "\x06\x7d\xdb\x01\x78\x56\x34\x12\x01\x00\x00\x00\x00\x00\x00\x00\x02\x00\x65\xc7\x67\xbc\x6c\xda" - "\x01\x06\xc9\x80\x13\x23\x90\x0e\x9b\x3c\xe6\xd4\xbb\x03\x27\xd6", // Includes MIC + .privacy = "\x06\x7d\xdb\x01\x78\x56\x34\x12\x01\x00\x00\x00\x00\x00\x00\x00\x02\x00\x65\xc7\x67\xbc\x6c\xda" + "\x01\x06\xc9\x80\x13\x23\x90\x0e\x9b\x3c\xe6\xd4\xbb\x03\x27\xd6", // Includes MIC .payloadLength = 0, .plainLength = 24, @@ -307,8 +307,8 @@ struct MessageTestEntry theMessageTestVector[] = { .plain = "\x06\x7d\xdb\x81\x79\x56\x34\x12\x01\x00\x00\x00\x00\x00\x00\x00\x02\x00\x01\x64\xee\x0e\x20\x7d", .encrypted = "\x06\x7d\xdb\x81\x79\x56\x34\x12\x01\x00\x00\x00\x00\x00\x00\x00\x02\x00\x2b\x2f\x91\x5a\x66\xc9" "\x59\x62\x90\xeb\xe4\x40\x82\x17\xb3\xc0\xc9\x21\xa2\xfc\xa4\xe1", - .privacy = "\x06\x7d\xdb\x81\xd9\x26\xaf\xce\x24\xc8\xa0\x98\x1b\xdd\x44\xf4\xe7\x30\x2b\x2f\x91\x5a\x66\xc9" - "\x59\x62\x90\xeb\xe4\x40\x82\x17\xb3\xc0\xc9\x21\xa2\xfc\xa4\xe1", + .privacy = "\x06\x7d\xdb\x81\xd9\x26\xaf\xce\x24\xc8\xa0\x98\x1b\xdd\x44\xf4\xe7\x30\x2b\x2f\x91\x5a\x66\xc9" + "\x59\x62\x90\xeb\xe4\x40\x82\x17\xb3\xc0\xc9\x21\xa2\xfc\xa4\xe1", .payloadLength = 0, .plainLength = 24, @@ -342,8 +342,8 @@ struct MessageTestEntry theMessageTestVector[] = { .plain = "\x06\x7d\xdb\x81\x79\x56\x34\x12\x01\x00\x00\x00\x00\x00\x00\x00\x02\x00\x01\x64\xee\x0e\x20\x7d", .encrypted = "\x06\x7d\xdb\x81\x79\x56\x34\x12\x01\x00\x00\x00\x00\x00\x00\x00\x02\x00\x2b\x2f\x91\x5a\x66\xc9" "\x59\x62\x90\xeb\xe4\x40\x82\x17\xb3\xc0\xc9\x21\xa2\xfc\xa4\xee", - .privacy = "\x06\x7d\xdb\x81\xd9\x26\xaf\xce\x24\xc8\xa0\x98\x1b\xdd\x44\xf4\xe7\x30\x2b\x2f\x91\x5a\x66\xc9" - "\x59\x62\x90\xeb\xe4\x40\x82\x17\xb3\xc0\xc9\x21\xa2\xfc\xa4\xee", + .privacy = "\x06\x7d\xdb\x81\xd9\x26\xaf\xce\x24\xc8\xa0\x98\x1b\xdd\x44\xf4\xe7\x30\x2b\x2f\x91\x5a\x66\xc9" + "\x59\x62\x90\xeb\xe4\x40\x82\x17\xb3\xc0\xc9\x21\xa2\xfc\xa4\xee", .payloadLength = 0, .plainLength = 24, @@ -378,8 +378,8 @@ struct MessageTestEntry theMessageTestVector[] = { .plain = "\06\x7d\xdb\x81\x91\x56\x34\x12\x01\x00\x00\x00\x00\x00\x00\x00\x02\x00\x01\x64\xee\x0e\x20\x7d", .encrypted = "\x06\x7d\xdb\x81\x91\x56\x34\x12\x01\x00\x00\x00\x00\x00\x00\x00\x02\x00\x91\xe0\x22\x85\xe0\x59\x07\xe0" "\xd8\x68\x0c\x79\xac\x6d\x64\x46\x90\x65\xb2\x6f\x90\x26", // Includes MIC - .privacy = "\x06\x7d\xdb\x81\x91\x56\x34\x12\x01\x00\x00\x00\x00\x00\x00\x00\x02\x00\x91\xe0\x22\x85\xe0\x59\x07\xe0" - "\xd8\x68\x0c\x79\xac\x6d\x64\x46\x90\x65\xb2\x6f\x90\x26", // Includes MIC + .privacy = "\x06\x7d\xdb\x81\x91\x56\x34\x12\x01\x00\x00\x00\x00\x00\x00\x00\x02\x00\x91\xe0\x22\x85\xe0\x59\x07\xe0" + "\xd8\x68\x0c\x79\xac\x6d\x64\x46\x90\x65\xb2\x6f\x90\x26", // Includes MIC .payloadLength = 0, .plainLength = 24, From 8c55586fdafc15655815935d55478cca0b4ea8ce Mon Sep 17 00:00:00 2001 From: Jeff Feasel Date: Sat, 4 May 2024 07:37:09 -0400 Subject: [PATCH 4/8] Fixing merge conflict in test components nl --- src/test_driver/openiotsdk/unit-tests/test_components_nl.txt | 1 + 1 file changed, 1 insertion(+) diff --git a/src/test_driver/openiotsdk/unit-tests/test_components_nl.txt b/src/test_driver/openiotsdk/unit-tests/test_components_nl.txt index 66789f206baf4b..e56e366e6090ee 100644 --- a/src/test_driver/openiotsdk/unit-tests/test_components_nl.txt +++ b/src/test_driver/openiotsdk/unit-tests/test_components_nl.txt @@ -3,3 +3,4 @@ DataModelTests InetLayerTests MessagingLayerTests SecureChannelTestsNL +SupportTestsNL From c03613811d7d66ae872cc22770d5b34847de09a4 Mon Sep 17 00:00:00 2001 From: Jeff Feasel Date: Sat, 4 May 2024 07:38:01 -0400 Subject: [PATCH 5/8] Fixing merge conflict --- src/test_driver/openiotsdk/unit-tests/test_components_nl.txt | 1 - 1 file changed, 1 deletion(-) diff --git a/src/test_driver/openiotsdk/unit-tests/test_components_nl.txt b/src/test_driver/openiotsdk/unit-tests/test_components_nl.txt index e56e366e6090ee..66789f206baf4b 100644 --- a/src/test_driver/openiotsdk/unit-tests/test_components_nl.txt +++ b/src/test_driver/openiotsdk/unit-tests/test_components_nl.txt @@ -3,4 +3,3 @@ DataModelTests InetLayerTests MessagingLayerTests SecureChannelTestsNL -SupportTestsNL From 537c360d57d16ed743ca3f3079139b1b1b1a64bd Mon Sep 17 00:00:00 2001 From: Jeff Feasel Date: Mon, 6 May 2024 11:13:32 -0400 Subject: [PATCH 6/8] Updated TestSessionManagerDispatch to use staticly allocated context instead of dynamically. Changed all tests to use XTestSuite instead of per-test SetUp/TearDown. --- src/transport/tests/TestCryptoContext.cpp | 6 +- src/transport/tests/TestPeerConnections.cpp | 6 +- src/transport/tests/TestSessionManager.cpp | 60 ++++++++++--------- .../tests/TestSessionManagerDispatch.cpp | 17 +++--- 4 files changed, 47 insertions(+), 42 deletions(-) diff --git a/src/transport/tests/TestCryptoContext.cpp b/src/transport/tests/TestCryptoContext.cpp index 7a688dbf7f8536..281ad1e92de675 100644 --- a/src/transport/tests/TestCryptoContext.cpp +++ b/src/transport/tests/TestCryptoContext.cpp @@ -49,9 +49,9 @@ struct PrivacyNonceTestEntry thePrivacyNonceTestVector[] = { class TestGroupCryptoContext : public ::testing::Test { -protected: - void SetUp() { ASSERT_EQ(chip::Platform::MemoryInit(), CHIP_NO_ERROR); } - void TearDown() { chip::Platform::MemoryShutdown(); } +public: + static void SetUpTestSuite() { ASSERT_EQ(chip::Platform::MemoryInit(), CHIP_NO_ERROR); } + static void TearDownTestSuite() { chip::Platform::MemoryShutdown(); } }; TEST_F(TestGroupCryptoContext, TestBuildPrivacyNonce) diff --git a/src/transport/tests/TestPeerConnections.cpp b/src/transport/tests/TestPeerConnections.cpp index 4f7acb147080eb..f15aeb2cc63c4b 100644 --- a/src/transport/tests/TestPeerConnections.cpp +++ b/src/transport/tests/TestPeerConnections.cpp @@ -57,9 +57,9 @@ const CATValues kPeer2CATs = { { 0xABCD0012, kUndefinedCAT, kUndefinedCAT } }; class TestPeerConnections : public ::testing::Test { -protected: - void SetUp() { ASSERT_EQ(chip::Platform::MemoryInit(), CHIP_NO_ERROR); } - void TearDown() { chip::Platform::MemoryShutdown(); } +public: + static void SetUpTestSuite() { ASSERT_EQ(chip::Platform::MemoryInit(), CHIP_NO_ERROR); } + static void TearDownTestSuite() { chip::Platform::MemoryShutdown(); } }; TEST_F(TestPeerConnections, TestBasicFunctionality) diff --git a/src/transport/tests/TestSessionManager.cpp b/src/transport/tests/TestSessionManager.cpp index b1b6c4620cd86a..b67379fbd3fa20 100644 --- a/src/transport/tests/TestSessionManager.cpp +++ b/src/transport/tests/TestSessionManager.cpp @@ -117,12 +117,16 @@ class TestSessMgrCallback : public SessionMessageDelegate bool LargeMessageSent = false; }; -class TestSessionManager : public ::testing::Test, public TestContext +class TestSessionManager : public ::testing::Test { +public: + static void SetUpTestSuite() { ASSERT_EQ(mContext.Init(), CHIP_NO_ERROR); } + static void TearDownTestSuite() { mContext.Shutdown(); } + protected: - void SetUp() { ASSERT_EQ(Init(), CHIP_NO_ERROR); } - void TearDown() { Shutdown(); } + static TestContext mContext; }; +TestContext TestSessionManager::mContext; TEST_F(TestSessionManager, CheckSimpleInitTest) { @@ -134,7 +138,7 @@ TEST_F(TestSessionManager, CheckSimpleInitTest) EXPECT_EQ(CHIP_NO_ERROR, fabricTableHolder.Init()); EXPECT_EQ(CHIP_NO_ERROR, - sessionManager.Init(&GetSystemLayer(), &GetTransportMgr(), &gMessageCounterManager, &deviceStorage, + sessionManager.Init(&mContext.GetSystemLayer(), &mContext.GetTransportMgr(), &gMessageCounterManager, &deviceStorage, &fabricTableHolder.GetFabricTable(), sessionKeystore)); } @@ -163,7 +167,7 @@ TEST_F(TestSessionManager, CheckMessageTest) EXPECT_EQ(CHIP_NO_ERROR, fabricTableHolder.Init()); EXPECT_EQ(CHIP_NO_ERROR, - sessionManager.Init(&GetSystemLayer(), &GetTransportMgr(), &gMessageCounterManager, &deviceStorage, + sessionManager.Init(&mContext.GetSystemLayer(), &mContext.GetTransportMgr(), &gMessageCounterManager, &deviceStorage, &fabricTableHolder.GetFabricTable(), sessionKeystore)); sessionManager.SetMessageDelegate(&callback); @@ -209,7 +213,7 @@ TEST_F(TestSessionManager, CheckMessageTest) err = sessionManager.SendPreparedMessage(aliceToBobSession.Get().Value(), preparedMessage); EXPECT_EQ(err, CHIP_NO_ERROR); - DrainAndServiceIO(); + mContext.DrainAndServiceIO(); EXPECT_EQ(callback.ReceiveHandlerCallCount, 1); // Let's send the max sized message and make sure it is received @@ -224,7 +228,7 @@ TEST_F(TestSessionManager, CheckMessageTest) err = sessionManager.SendPreparedMessage(aliceToBobSession.Get().Value(), preparedMessage); EXPECT_EQ(err, CHIP_NO_ERROR); - DrainAndServiceIO(); + mContext.DrainAndServiceIO(); EXPECT_EQ(callback.ReceiveHandlerCallCount, 2); uint16_t large_payload_len = sizeof(LARGE_PAYLOAD); @@ -267,7 +271,7 @@ TEST_F(TestSessionManager, SendEncryptedPacketTest) EXPECT_EQ(CHIP_NO_ERROR, fabricTableHolder.Init()); EXPECT_EQ(CHIP_NO_ERROR, - sessionManager.Init(&GetSystemLayer(), &GetTransportMgr(), &gMessageCounterManager, &deviceStorage, + sessionManager.Init(&mContext.GetSystemLayer(), &mContext.GetTransportMgr(), &gMessageCounterManager, &deviceStorage, &fabricTableHolder.GetFabricTable(), sessionKeystore)); sessionManager.SetMessageDelegate(&callback); @@ -315,7 +319,7 @@ TEST_F(TestSessionManager, SendEncryptedPacketTest) err = sessionManager.SendPreparedMessage(aliceToBobSession.Get().Value(), preparedMessage); EXPECT_EQ(err, CHIP_NO_ERROR); - DrainAndServiceIO(); + mContext.DrainAndServiceIO(); EXPECT_EQ(callback.ReceiveHandlerCallCount, 1); // Reset receive side message counter, or duplicated message will be denied. @@ -325,7 +329,7 @@ TEST_F(TestSessionManager, SendEncryptedPacketTest) err = sessionManager.SendPreparedMessage(aliceToBobSession.Get().Value(), preparedMessage); EXPECT_EQ(err, CHIP_NO_ERROR); - DrainAndServiceIO(); + mContext.DrainAndServiceIO(); EXPECT_EQ(callback.ReceiveHandlerCallCount, 2); sessionManager.Shutdown(); @@ -356,7 +360,7 @@ TEST_F(TestSessionManager, SendBadEncryptedPacketTest) EXPECT_EQ(CHIP_NO_ERROR, fabricTableHolder.Init()); EXPECT_EQ(CHIP_NO_ERROR, - sessionManager.Init(&GetSystemLayer(), &GetTransportMgr(), &gMessageCounterManager, &deviceStorage, + sessionManager.Init(&mContext.GetSystemLayer(), &mContext.GetTransportMgr(), &gMessageCounterManager, &deviceStorage, &fabricTableHolder.GetFabricTable(), sessionKeystore)); sessionManager.SetMessageDelegate(&callback); @@ -404,7 +408,7 @@ TEST_F(TestSessionManager, SendBadEncryptedPacketTest) err = sessionManager.SendPreparedMessage(aliceToBobSession.Get().Value(), preparedMessage); EXPECT_EQ(err, CHIP_NO_ERROR); - DrainAndServiceIO(); + mContext.DrainAndServiceIO(); EXPECT_EQ(callback.ReceiveHandlerCallCount, 1); /* -------------------------------------------------------------------------------------------*/ @@ -425,7 +429,7 @@ TEST_F(TestSessionManager, SendBadEncryptedPacketTest) err = sessionManager.SendPreparedMessage(aliceToBobSession.Get().Value(), badMessageCounterMsg); EXPECT_EQ(err, CHIP_NO_ERROR); - DrainAndServiceIO(); + mContext.DrainAndServiceIO(); EXPECT_EQ(callback.ReceiveHandlerCallCount, 1); /* -------------------------------------------------------------------------------------------*/ @@ -442,7 +446,7 @@ TEST_F(TestSessionManager, SendBadEncryptedPacketTest) err = sessionManager.SendPreparedMessage(aliceToBobSession.Get().Value(), badKeyIdMsg); EXPECT_EQ(err, CHIP_NO_ERROR); - DrainAndServiceIO(); + mContext.DrainAndServiceIO(); EXPECT_EQ(callback.ReceiveHandlerCallCount, 1); /* -------------------------------------------------------------------------------------------*/ @@ -452,7 +456,7 @@ TEST_F(TestSessionManager, SendBadEncryptedPacketTest) err = sessionManager.SendPreparedMessage(aliceToBobSession.Get().Value(), preparedMessage); EXPECT_EQ(err, CHIP_NO_ERROR); - DrainAndServiceIO(); + mContext.DrainAndServiceIO(); EXPECT_EQ(callback.ReceiveHandlerCallCount, 2); sessionManager.Shutdown(); @@ -483,7 +487,7 @@ TEST_F(TestSessionManager, SendPacketWithOldCounterTest) EXPECT_EQ(CHIP_NO_ERROR, fabricTableHolder.Init()); EXPECT_EQ(CHIP_NO_ERROR, - sessionManager.Init(&GetSystemLayer(), &GetTransportMgr(), &gMessageCounterManager, &deviceStorage, + sessionManager.Init(&mContext.GetSystemLayer(), &mContext.GetTransportMgr(), &gMessageCounterManager, &deviceStorage, &fabricTableHolder.GetFabricTable(), sessionKeystore)); sessionManager.SetMessageDelegate(&callback); @@ -530,7 +534,7 @@ TEST_F(TestSessionManager, SendPacketWithOldCounterTest) err = sessionManager.SendPreparedMessage(aliceToBobSession.Get().Value(), preparedMessage); EXPECT_EQ(err, CHIP_NO_ERROR); - DrainAndServiceIO(); + mContext.DrainAndServiceIO(); EXPECT_EQ(callback.ReceiveHandlerCallCount, 1); // Now advance our message counter by 5. @@ -547,7 +551,7 @@ TEST_F(TestSessionManager, SendPacketWithOldCounterTest) err = sessionManager.SendPreparedMessage(aliceToBobSession.Get().Value(), newMessage); EXPECT_EQ(err, CHIP_NO_ERROR); - DrainAndServiceIO(); + mContext.DrainAndServiceIO(); EXPECT_EQ(callback.ReceiveHandlerCallCount, 2); // Now resend our original message. It should be rejected as a duplicate. @@ -555,7 +559,7 @@ TEST_F(TestSessionManager, SendPacketWithOldCounterTest) err = sessionManager.SendPreparedMessage(aliceToBobSession.Get().Value(), preparedMessage); EXPECT_EQ(err, CHIP_NO_ERROR); - DrainAndServiceIO(); + mContext.DrainAndServiceIO(); EXPECT_EQ(callback.ReceiveHandlerCallCount, 2); sessionManager.Shutdown(); @@ -586,7 +590,7 @@ TEST_F(TestSessionManager, SendPacketWithTooOldCounterTest) EXPECT_EQ(CHIP_NO_ERROR, fabricTableHolder.Init()); EXPECT_EQ(CHIP_NO_ERROR, - sessionManager.Init(&GetSystemLayer(), &GetTransportMgr(), &gMessageCounterManager, &deviceStorage, + sessionManager.Init(&mContext.GetSystemLayer(), &mContext.GetTransportMgr(), &gMessageCounterManager, &deviceStorage, &fabricTableHolder.GetFabricTable(), sessionKeystore)); sessionManager.SetMessageDelegate(&callback); @@ -632,7 +636,7 @@ TEST_F(TestSessionManager, SendPacketWithTooOldCounterTest) err = sessionManager.SendPreparedMessage(aliceToBobSession.Get().Value(), preparedMessage); EXPECT_EQ(err, CHIP_NO_ERROR); - DrainAndServiceIO(); + mContext.DrainAndServiceIO(); EXPECT_EQ(callback.ReceiveHandlerCallCount, 1); // Now advance our message counter by at least @@ -651,7 +655,7 @@ TEST_F(TestSessionManager, SendPacketWithTooOldCounterTest) err = sessionManager.SendPreparedMessage(aliceToBobSession.Get().Value(), newMessage); EXPECT_EQ(err, CHIP_NO_ERROR); - DrainAndServiceIO(); + mContext.DrainAndServiceIO(); EXPECT_EQ(callback.ReceiveHandlerCallCount, 2); // Now resend our original message. It should be rejected as a duplicate. @@ -659,7 +663,7 @@ TEST_F(TestSessionManager, SendPacketWithTooOldCounterTest) err = sessionManager.SendPreparedMessage(aliceToBobSession.Get().Value(), preparedMessage); EXPECT_EQ(err, CHIP_NO_ERROR); - DrainAndServiceIO(); + mContext.DrainAndServiceIO(); EXPECT_EQ(callback.ReceiveHandlerCallCount, 2); sessionManager.Shutdown(); @@ -691,7 +695,7 @@ TEST_F(TestSessionManager, SessionAllocationTest) SessionManager sessionManager; EXPECT_EQ(CHIP_NO_ERROR, - sessionManager.Init(&GetSystemLayer(), &GetTransportMgr(), &messageCounterManager, &deviceStorage1, + sessionManager.Init(&mContext.GetSystemLayer(), &mContext.GetTransportMgr(), &messageCounterManager, &deviceStorage1, &fabricTableHolder.GetFabricTable(), sessionKeystore)); // Allocate a session. @@ -729,7 +733,7 @@ TEST_F(TestSessionManager, SessionAllocationTest) sessionManager.~SessionManager(); new (&sessionManager) SessionManager(); EXPECT_EQ(CHIP_NO_ERROR, - sessionManager.Init(&GetSystemLayer(), &GetTransportMgr(), &messageCounterManager, &deviceStorage2, + sessionManager.Init(&mContext.GetSystemLayer(), &mContext.GetTransportMgr(), &messageCounterManager, &deviceStorage2, &fabricTableHolder.GetFabricTable(), sessionKeystore)); // Allocate a single session so we know what random id we are starting at. @@ -827,7 +831,7 @@ TEST_F(TestSessionManager, SessionCounterExhaustedTest) EXPECT_EQ(CHIP_NO_ERROR, fabricTableHolder.Init()); EXPECT_EQ(CHIP_NO_ERROR, - sessionManager.Init(&GetSystemLayer(), &GetTransportMgr(), &gMessageCounterManager, &deviceStorage, + sessionManager.Init(&mContext.GetSystemLayer(), &mContext.GetTransportMgr(), &gMessageCounterManager, &deviceStorage, &fabricTableHolder.GetFabricTable(), sessionKeystore)); Transport::PeerAddress peer(Transport::PeerAddress::UDP(addr, CHIP_PORT)); @@ -903,7 +907,7 @@ TEST_F(TestSessionManager, SessionShiftingTest) EXPECT_EQ(CHIP_NO_ERROR, fabricTableHolder.Init()); EXPECT_EQ(CHIP_NO_ERROR, - sessionManager.Init(&GetSystemLayer(), &GetTransportMgr(), &messageCounterManager, &deviceStorage, + sessionManager.Init(&mContext.GetSystemLayer(), &mContext.GetTransportMgr(), &messageCounterManager, &deviceStorage, &fabricTableHolder.GetFabricTable(), sessionKeystore)); Transport::PeerAddress peer(Transport::PeerAddress::UDP(addr, CHIP_PORT)); @@ -980,7 +984,7 @@ TEST_F(TestSessionManager, TestFindSecureSessionForNode) EXPECT_EQ(CHIP_NO_ERROR, fabricTableHolder.Init()); EXPECT_EQ(CHIP_NO_ERROR, - sessionManager.Init(&GetSystemLayer(), &GetTransportMgr(), &messageCounterManager, &deviceStorage, + sessionManager.Init(&mContext.GetSystemLayer(), &mContext.GetTransportMgr(), &messageCounterManager, &deviceStorage, &fabricTableHolder.GetFabricTable(), sessionKeystore)); Transport::PeerAddress peer(Transport::PeerAddress::UDP(addr, CHIP_PORT)); diff --git a/src/transport/tests/TestSessionManagerDispatch.cpp b/src/transport/tests/TestSessionManagerDispatch.cpp index 47b2a9daed5c52..cb7310ae8f9567 100644 --- a/src/transport/tests/TestSessionManagerDispatch.cpp +++ b/src/transport/tests/TestSessionManagerDispatch.cpp @@ -501,7 +501,7 @@ PeerAddress AddressFromString(const char * str) return PeerAddress::UDP(addr); } -void TestSessionManagerInit(TestContext * ctx, SessionManager & sessionManager) +void TestSessionManagerInit(TestContext & ctx, SessionManager & sessionManager) { static FabricTableHolder fabricTableHolder; static secure_channel::MessageCounterManager gMessageCounterManager; @@ -510,7 +510,7 @@ void TestSessionManagerInit(TestContext * ctx, SessionManager & sessionManager) EXPECT_EQ(CHIP_NO_ERROR, fabricTableHolder.Init()); EXPECT_EQ(CHIP_NO_ERROR, - sessionManager.Init(&ctx->GetSystemLayer(), &ctx->GetTransportMgr(), &gMessageCounterManager, &deviceStorage, + sessionManager.Init(&ctx.GetSystemLayer(), &ctx.GetTransportMgr(), &gMessageCounterManager, &deviceStorage, &fabricTableHolder.GetFabricTable(), sessionKeystore)); } @@ -549,13 +549,14 @@ CHIP_ERROR InjectGroupSessionWithTestKey(SessionHolder & sessionHolder, MessageT class TestSessionManagerDispatch : public ::testing::Test { +public: + static void SetUpTestSuite() { ASSERT_EQ(mContext.Init(), CHIP_NO_ERROR); } + static void TearDownTestSuite() { mContext.Shutdown(); } + protected: - TestSessionManagerDispatch() { inContext = new TestContext(); } - ~TestSessionManagerDispatch() { delete inContext; } - void SetUp() { ASSERT_EQ(inContext->Init(), CHIP_NO_ERROR); } - void TearDown() { inContext->Shutdown(); } - TestContext * inContext; + static TestContext mContext; }; +TestContext TestSessionManagerDispatch::mContext; TEST_F(TestSessionManagerDispatch, TestSessionManagerDispatch) { @@ -564,7 +565,7 @@ TEST_F(TestSessionManagerDispatch, TestSessionManagerDispatch) SessionManager sessionManager; TestSessionManagerCallback callback; - TestSessionManagerInit(inContext, sessionManager); + TestSessionManagerInit(mContext, sessionManager); sessionManager.SetMessageDelegate(&callback); IPAddress addr; From 38806bd04779a6d54581b7748a2abd3670f03625 Mon Sep 17 00:00:00 2001 From: Jeff Feasel Date: Mon, 6 May 2024 13:41:21 -0400 Subject: [PATCH 7/8] Made context a non-pointer which is created/destroyed implicitly when each test case is run. --- src/transport/tests/TestSessionManager.cpp | 10 ++++------ src/transport/tests/TestSessionManagerDispatch.cpp | 10 ++++------ 2 files changed, 8 insertions(+), 12 deletions(-) diff --git a/src/transport/tests/TestSessionManager.cpp b/src/transport/tests/TestSessionManager.cpp index b67379fbd3fa20..c5384a7be40328 100644 --- a/src/transport/tests/TestSessionManager.cpp +++ b/src/transport/tests/TestSessionManager.cpp @@ -119,14 +119,12 @@ class TestSessMgrCallback : public SessionMessageDelegate class TestSessionManager : public ::testing::Test { -public: - static void SetUpTestSuite() { ASSERT_EQ(mContext.Init(), CHIP_NO_ERROR); } - static void TearDownTestSuite() { mContext.Shutdown(); } - protected: - static TestContext mContext; + void SetUp() { ASSERT_EQ(mContext.Init(), CHIP_NO_ERROR); } + void TearDown() { mContext.Shutdown(); } + + TestContext mContext; }; -TestContext TestSessionManager::mContext; TEST_F(TestSessionManager, CheckSimpleInitTest) { diff --git a/src/transport/tests/TestSessionManagerDispatch.cpp b/src/transport/tests/TestSessionManagerDispatch.cpp index cb7310ae8f9567..f90cb0fa2b21ac 100644 --- a/src/transport/tests/TestSessionManagerDispatch.cpp +++ b/src/transport/tests/TestSessionManagerDispatch.cpp @@ -549,14 +549,12 @@ CHIP_ERROR InjectGroupSessionWithTestKey(SessionHolder & sessionHolder, MessageT class TestSessionManagerDispatch : public ::testing::Test { -public: - static void SetUpTestSuite() { ASSERT_EQ(mContext.Init(), CHIP_NO_ERROR); } - static void TearDownTestSuite() { mContext.Shutdown(); } - protected: - static TestContext mContext; + void SetUp() { ASSERT_EQ(mContext.Init(), CHIP_NO_ERROR); } + void TearDown() { mContext.Shutdown(); } + + TestContext mContext; }; -TestContext TestSessionManagerDispatch::mContext; TEST_F(TestSessionManagerDispatch, TestSessionManagerDispatch) { From 570ed238f809f4002e8a3c570e1836b4d28891da Mon Sep 17 00:00:00 2001 From: Jeff Feasel Date: Mon, 6 May 2024 13:46:00 -0400 Subject: [PATCH 8/8] Reordered includes to be consistent with the standard. --- src/transport/tests/TestCryptoContext.cpp | 4 ++-- src/transport/tests/TestGroupMessageCounter.cpp | 7 +++---- src/transport/tests/TestPeerConnections.cpp | 5 +++-- src/transport/tests/TestPeerMessageCounter.cpp | 9 +++++---- src/transport/tests/TestSecureSession.cpp | 4 ++-- src/transport/tests/TestSecureSessionTable.cpp | 10 +++++----- 6 files changed, 20 insertions(+), 19 deletions(-) diff --git a/src/transport/tests/TestCryptoContext.cpp b/src/transport/tests/TestCryptoContext.cpp index 281ad1e92de675..45c3f3e5eb441e 100644 --- a/src/transport/tests/TestCryptoContext.cpp +++ b/src/transport/tests/TestCryptoContext.cpp @@ -16,13 +16,13 @@ * limitations under the License. */ -#include #include +#include + #include #include #include - #include using namespace chip; diff --git a/src/transport/tests/TestGroupMessageCounter.cpp b/src/transport/tests/TestGroupMessageCounter.cpp index 9ae99dadd1e871..72fe57754e8976 100644 --- a/src/transport/tests/TestGroupMessageCounter.cpp +++ b/src/transport/tests/TestGroupMessageCounter.cpp @@ -21,15 +21,14 @@ * This file implements unit tests for the SessionManager implementation. */ +#include +#include + #include #include #include #include -#include - -#include - namespace { using namespace chip; diff --git a/src/transport/tests/TestPeerConnections.cpp b/src/transport/tests/TestPeerConnections.cpp index f15aeb2cc63c4b..9beb263f1d15c8 100644 --- a/src/transport/tests/TestPeerConnections.cpp +++ b/src/transport/tests/TestPeerConnections.cpp @@ -22,12 +22,13 @@ * the SecureSessionTable class within the transport layer * */ + +#include + #include #include #include -#include - namespace { using namespace chip; diff --git a/src/transport/tests/TestPeerMessageCounter.cpp b/src/transport/tests/TestPeerMessageCounter.cpp index be1a749982ba69..75f296b1bcba21 100644 --- a/src/transport/tests/TestPeerMessageCounter.cpp +++ b/src/transport/tests/TestPeerMessageCounter.cpp @@ -21,13 +21,14 @@ * This file implements unit tests for the SessionManager implementation. */ -#include -#include - #include -#include #include +#include + +#include +#include + namespace { using namespace chip; diff --git a/src/transport/tests/TestSecureSession.cpp b/src/transport/tests/TestSecureSession.cpp index de90fe98537505..672ba04e8fd38c 100644 --- a/src/transport/tests/TestSecureSession.cpp +++ b/src/transport/tests/TestSecureSession.cpp @@ -22,6 +22,8 @@ */ #include +#include + #include #include @@ -29,8 +31,6 @@ #include #include -#include - using namespace chip; using namespace Crypto; diff --git a/src/transport/tests/TestSecureSessionTable.cpp b/src/transport/tests/TestSecureSessionTable.cpp index 92376d3471e5a7..323558a0cecd24 100644 --- a/src/transport/tests/TestSecureSessionTable.cpp +++ b/src/transport/tests/TestSecureSessionTable.cpp @@ -21,17 +21,17 @@ * This file implements unit tests for the SessionManager implementation. */ +#include +#include + +#include + #include "system/SystemClock.h" #include #include #include #include -#include - -#include -#include - namespace chip { namespace Transport {