From 4c95b7ff4235b86163b1609d2184085989096757 Mon Sep 17 00:00:00 2001
From: Jeff Feasel <jfeasel@csa-iot.org>
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 <gtest/gtest.h>
#include <inttypes.h>
-#include <nlunit-test.h>
#include <crypto/CHIPCryptoPAL.h>
#include <lib/core/CHIPCore.h>
#include <lib/support/CHIPMem.h>
-#include <lib/support/UnitTestRegistration.h>
#include <transport/CryptoContext.h>
@@ -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 <lib/support/DefaultStorageKeyAllocator.h>
#include <lib/support/TestPersistentStorageDelegate.h>
-#include <lib/support/UnitTestRegistration.h>
#include <transport/GroupPeerMessageCounter.h>
#include <transport/PeerMessageCounter.h>
-#include <nlbyteorder.h>
-#include <nlunit-test.h>
+#include <gtest/gtest.h>
#include <errno.h>
@@ -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<chip::FabricIndex>(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 <lib/core/ErrorStr.h>
#include <lib/support/CodeUtils.h>
-#include <lib/support/UnitTestRegistration.h>
#include <transport/SecureSessionTable.h>
-#include <nlunit-test.h>
+#include <gtest/gtest.h>
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<uint16_t>(static_cast<uint16_t>(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 <lib/support/UnitTestRegistration.h>
#include <transport/MessageCounter.h>
#include <transport/PeerMessageCounter.h>
#include <errno.h>
-#include <nlbyteorder.h>
-#include <nlunit-test.h>
+#include <gtest/gtest.h>
#include <vector>
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<uint32_t>(1 << 31) - 5); k <= (static_cast<uint32_t>(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<uint32_t>(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<uint32_t>(1 << 31)); k <= (static_cast<uint32_t>(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<uint32_t>(1 << 31) - 5); k <= (static_cast<uint32_t>(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<uint32_t>(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<uint32_t>(1 << 31)); k <= (static_cast<uint32_t>(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 <errno.h>
-#include <nlunit-test.h>
+#include <gtest/gtest.h>
#include <crypto/DefaultSessionKeystore.h>
#include <lib/core/CHIPCore.h>
#include <lib/support/CodeUtils.h>
-#include <lib/support/UnitTestRegistration.h>
#include <transport/CryptoContext.h>
#include <stdarg.h>
@@ -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 <lib/core/CHIPCore.h>
#include <lib/support/CodeUtils.h>
-#include <lib/support/UnitTestRegistration.h>
#include <transport/SecureSessionTable.h>
#include <transport/SessionHolder.h>
-#include <nlbyteorder.h>
-#include <nlunit-test.h>
+#include <gtest/gtest.h>
#include <errno.h>
#include <vector>
@@ -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<SessionParameters> & sessionParams);
- nlTestSuite * mTestSuite;
Platform::UniquePtr<SecureSessionTable> mSessionTable;
std::vector<Platform::UniquePtr<SessionNotificationListener>> mSessionList;
};
@@ -97,8 +92,8 @@ void TestSecureSessionTable::AllocateSession(const ScopedNodeId & sessionEvictio
std::vector<SessionParameters> & 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<SessionParameters> & sessionParams)
@@ -106,7 +101,7 @@ void TestSecureSessionTable::CreateSessionTable(std::vector<SessionParameters> &
mSessionList.clear();
mSessionTable = Platform::MakeUnique<SecureSessionTable>();
- NL_TEST_ASSERT(mTestSuite, mSessionTable.get() != nullptr);
+ EXPECT_NE(mSessionTable.get(), nullptr);
mSessionTable->Init();
mSessionTable->SetMaxSessionTableSize(static_cast<uint32_t>(sessionParams.size()));
@@ -114,7 +109,7 @@ void TestSecureSessionTable::CreateSessionTable(std::vector<SessionParameters> &
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<uint16_t>(i),
@@ -131,11 +126,8 @@ void TestSecureSessionTable::CreateSessionTable(std::vector<SessionParameters> &
}
}
-void TestSecureSessionTable::ValidateSessionSorting(nlTestSuite * inSuite, void * inContext)
+void TestSecureSessionTable::ValidateSessionSorting()
{
- Platform::UniquePtr<TestSecureSessionTable> & _this = *static_cast<Platform::UniquePtr<TestSecureSessionTable> *>(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<TestSecureSessionTable> 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<chip::Transport::TestSecureSessionTable>();
- 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 <lib/core/CHIPCore.h>
#include <lib/support/CodeUtils.h>
#include <lib/support/TestPersistentStorageDelegate.h>
-#include <lib/support/UnitTestContext.h>
-#include <lib/support/UnitTestRegistration.h>
#include <protocols/Protocols.h>
#include <protocols/echo/Echo.h>
#include <protocols/secure_channel/MessageCounterManager.h>
@@ -41,8 +39,7 @@
#include <transport/TransportMgr.h>
#include <transport/tests/LoopbackTransportManager.h>
-#include <nlbyteorder.h>
-#include <nlunit-test.h>
+#include <gtest/gtest.h>
#include <errno.h>
@@ -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<TestContext *>(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<TestContext *>(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<TestContext *>(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<TestContext *>(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<TestContext *>(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<TestContext *>(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<TestContext *>(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<TestContext *>(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<LocalSessionMessageCounter &>(
@@ -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<TestContext *>(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<TestContext *>(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<TestContext *>(aContext)->Init();
- return (err == CHIP_NO_ERROR) ? SUCCESS : FAILURE;
-}
-
-/**
- * Finalize the test suite.
- */
-int Finalize(void * aContext)
-{
- reinterpret_cast<TestContext *>(aContext)->Shutdown();
- return SUCCESS;
-}
-
} // namespace
-
-/**
- * Main
- */
-int TestSessionManager()
-{
- return chip::ExecuteTestsWithContext<TestContext>(&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 <lib/core/CHIPCore.h>
#include <lib/support/CodeUtils.h>
#include <lib/support/TestPersistentStorageDelegate.h>
-#include <lib/support/UnitTestContext.h>
-#include <lib/support/UnitTestRegistration.h>
#include <protocols/secure_channel/MessageCounterManager.h>
#include <transport/SessionManager.h>
#include <transport/TransportMgr.h>
#include <transport/tests/LoopbackTransportManager.h>
-#include <nlbyteorder.h>
-#include <nlunit-test.h>
+#include <gtest/gtest.h>
#include <errno.h>
@@ -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<TestContext *>(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<const uint8_t *>(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<TestContext *>(aContext)->Init();
- return (err == CHIP_NO_ERROR) ? SUCCESS : FAILURE;
-}
-
-/**
- * Finalize the test suite.
- */
-int Finalize(void * aContext)
-{
- reinterpret_cast<TestContext *>(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<TestContext>(&sSuite);
-}
-
-CHIP_REGISTER_TEST_SUITE(TestSessionManagerDispatchSuite);
From 08fa55e425f05d6a4e9673c721138dcb4197e323 Mon Sep 17 00:00:00 2001
From: Jeff Feasel <jfeasel@csa-iot.org>
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 <jfeasel@csa-iot.org>
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 <jfeasel@csa-iot.org>
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 <jfeasel@csa-iot.org>
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 <jfeasel@csa-iot.org>
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 <jfeasel@csa-iot.org>
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 <jfeasel@csa-iot.org>
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 <gtest/gtest.h>
#include <inttypes.h>
+#include <gtest/gtest.h>
+
#include <crypto/CHIPCryptoPAL.h>
#include <lib/core/CHIPCore.h>
#include <lib/support/CHIPMem.h>
-
#include <transport/CryptoContext.h>
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 <errno.h>
+#include <gtest/gtest.h>
+
#include <lib/support/DefaultStorageKeyAllocator.h>
#include <lib/support/TestPersistentStorageDelegate.h>
#include <transport/GroupPeerMessageCounter.h>
#include <transport/PeerMessageCounter.h>
-#include <gtest/gtest.h>
-
-#include <errno.h>
-
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 <gtest/gtest.h>
+
#include <lib/core/ErrorStr.h>
#include <lib/support/CodeUtils.h>
#include <transport/SecureSessionTable.h>
-#include <gtest/gtest.h>
-
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 <transport/MessageCounter.h>
-#include <transport/PeerMessageCounter.h>
-
#include <errno.h>
-#include <gtest/gtest.h>
#include <vector>
+#include <gtest/gtest.h>
+
+#include <transport/MessageCounter.h>
+#include <transport/PeerMessageCounter.h>
+
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 <errno.h>
+#include <stdarg.h>
+
#include <gtest/gtest.h>
#include <crypto/DefaultSessionKeystore.h>
@@ -29,8 +31,6 @@
#include <lib/support/CodeUtils.h>
#include <transport/CryptoContext.h>
-#include <stdarg.h>
-
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 <errno.h>
+#include <vector>
+
+#include <gtest/gtest.h>
+
#include "system/SystemClock.h"
#include <lib/core/CHIPCore.h>
#include <lib/support/CodeUtils.h>
#include <transport/SecureSessionTable.h>
#include <transport/SessionHolder.h>
-#include <gtest/gtest.h>
-
-#include <errno.h>
-#include <vector>
-
namespace chip {
namespace Transport {