Updated unit tests in src/transport/tests/ to use PW instead of NL. (#33249)
* Refactored TestSecureSessionTable.cpp to use TestSecureSessionTable as the pw test context.
* Updated test_components[_nl].txt to move TransportLayerTests
* Fixed formatting
* Fixing merge conflict in test components nl
* Fixing merge conflict
* Updated TestSessionManagerDispatch to use staticly allocated context instead of dynamically. Changed all tests to use XTestSuite instead of per-test SetUp/TearDown.
* Made context a non-pointer which is created/destroyed implicitly when each test case is run.
* Reordered includes to be consistent with the standard.
---------
Co-authored-by: Andrei Litvin <andy314@gmail.com>
diff --git a/src/test_driver/openiotsdk/unit-tests/test_components.txt b/src/test_driver/openiotsdk/unit-tests/test_components.txt
index db6d92b..a509669 100644
--- a/src/test_driver/openiotsdk/unit-tests/test_components.txt
+++ b/src/test_driver/openiotsdk/unit-tests/test_components.txt
@@ -17,5 +17,4 @@
SupportTests
UserDirectedCommissioningTests
SecureChannelTests
-ICDServerTests
-InetLayerTests
+ICDServerTests
\ No newline at end of file
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 e00ff91..941d486 100644
--- a/src/test_driver/openiotsdk/unit-tests/test_components_nl.txt
+++ b/src/test_driver/openiotsdk/unit-tests/test_components_nl.txt
@@ -2,4 +2,3 @@
DataModelTests
MessagingLayerTests
SecureChannelTestsNL
-TransportLayerTests
diff --git a/src/transport/tests/BUILD.gn b/src/transport/tests/BUILD.gn
index 8e3f936..7c38cea 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 @@
]
}
-chip_test_suite_using_nltest("tests") {
+chip_test_suite("tests") {
output_name = "libTransportLayerTests"
test_sources = [
@@ -59,10 +59,8 @@
"${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 9bcf0d2..45c3f3e 100644
--- a/src/transport/tests/TestCryptoContext.cpp
+++ b/src/transport/tests/TestCryptoContext.cpp
@@ -17,13 +17,12 @@
*/
#include <inttypes.h>
-#include <nlunit-test.h>
+
+#include <gtest/gtest.h>
#include <crypto/CHIPCryptoPAL.h>
#include <lib/core/CHIPCore.h>
#include <lib/support/CHIPMem.h>
-#include <lib/support/UnitTestRegistration.h>
-
#include <transport/CryptoContext.h>
using namespace chip;
@@ -48,7 +47,14 @@
},
};
-void TestBuildPrivacyNonce(nlTestSuite * apSuite, void * apContext)
+class TestGroupCryptoContext : public ::testing::Test
+{
+public:
+ static void SetUpTestSuite() { ASSERT_EQ(chip::Platform::MemoryInit(), CHIP_NO_ERROR); }
+ static void TearDownTestSuite() { chip::Platform::MemoryShutdown(); }
+};
+
+TEST_F(TestGroupCryptoContext, TestBuildPrivacyNonce)
{
for (const auto & testVector : thePrivacyNonceTestVector)
{
@@ -60,47 +66,9 @@
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 8e3101e..72fe577 100644
--- a/src/transport/tests/TestGroupMessageCounter.cpp
+++ b/src/transport/tests/TestGroupMessageCounter.cpp
@@ -21,17 +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 <lib/support/UnitTestRegistration.h>
#include <transport/GroupPeerMessageCounter.h>
#include <transport/PeerMessageCounter.h>
-#include <nlbyteorder.h>
-#include <nlunit-test.h>
-
-#include <errno.h>
-
namespace {
using namespace chip;
@@ -101,11 +98,11 @@
}
};
-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 +114,7 @@
} 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 +122,10 @@
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 +144,7 @@
}
// 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 +154,39 @@
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 +196,120 @@
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 +319,7 @@
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 +333,19 @@
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 +354,49 @@
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 +404,7 @@
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 +412,45 @@
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 f4ea8c4..9beb263 100644
--- a/src/transport/tests/TestPeerConnections.cpp
+++ b/src/transport/tests/TestPeerConnections.cpp
@@ -22,13 +22,13 @@
* the SecureSessionTable class within the transport layer
*
*/
+
+#include <gtest/gtest.h>
+
#include <lib/core/ErrorStr.h>
#include <lib/support/CodeUtils.h>
-#include <lib/support/UnitTestRegistration.h>
#include <transport/SecureSessionTable.h>
-#include <nlunit-test.h>
-
namespace {
using namespace chip;
@@ -56,7 +56,14 @@
const CATValues kPeer1CATs = { { 0xABCD0001, 0xABCE0100, 0xABCD0020 } };
const CATValues kPeer2CATs = { { 0xABCD0012, kUndefinedCAT, kUndefinedCAT } };
-void TestBasicFunctionality(nlTestSuite * inSuite, void * inContext)
+class TestPeerConnections : public ::testing::Test
+{
+public:
+ static void SetUpTestSuite() { ASSERT_EQ(chip::Platform::MemoryInit(), CHIP_NO_ERROR); }
+ static void TearDownTestSuite() { chip::Platform::MemoryShutdown(); }
+};
+
+TEST_F(TestPeerConnections, TestBasicFunctionality)
{
SecureSessionTable connections;
System::Clock::Internal::MockClock clock;
@@ -69,27 +76,27 @@
// 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 +106,14 @@
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 +123,18 @@
// 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 +146,4 @@
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 2c10ce4..75f296b 100644
--- a/src/transport/tests/TestPeerMessageCounter.cpp
+++ b/src/transport/tests/TestPeerMessageCounter.cpp
@@ -21,38 +21,37 @@
* This file implements unit tests for the SessionManager implementation.
*/
-#include <lib/support/UnitTestRegistration.h>
+#include <errno.h>
+#include <vector>
+
+#include <gtest/gtest.h>
+
#include <transport/MessageCounter.h>
#include <transport/PeerMessageCounter.h>
-#include <errno.h>
-#include <nlbyteorder.h>
-#include <nlunit-test.h>
-#include <vector>
-
namespace {
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 +59,45 @@
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 +108,29 @@
{
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 +146,37 @@
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 +197,22 @@
}
// 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 +225,7 @@
(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 +235,18 @@
{
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 +270,16 @@
// 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 +297,77 @@
// 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 +375,7 @@
// 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 +386,30 @@
{
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 +427,35 @@
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 023876c..672ba04 100644
--- a/src/transport/tests/TestSecureSession.cpp
+++ b/src/transport/tests/TestSecureSession.cpp
@@ -22,53 +22,51 @@
*/
#include <errno.h>
-#include <nlunit-test.h>
+#include <stdarg.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>
-
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 @@
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 @@
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 @@
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 7dbbeba..323558a 100644
--- a/src/transport/tests/TestSecureSessionTable.cpp
+++ b/src/transport/tests/TestSecureSessionTable.cpp
@@ -21,31 +21,27 @@
* 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 <lib/support/UnitTestRegistration.h>
#include <transport/SecureSessionTable.h>
#include <transport/SessionHolder.h>
-#include <nlbyteorder.h>
-#include <nlunit-test.h>
-
-#include <errno.h>
-#include <vector>
-
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 @@
//
void CreateSessionTable(std::vector<SessionParameters> & sessionParams);
- nlTestSuite * mTestSuite;
Platform::UniquePtr<SecureSessionTable> mSessionTable;
std::vector<Platform::UniquePtr<SessionNotificationListener>> mSessionList;
};
@@ -97,8 +92,8 @@
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 @@
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 @@
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::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 @@
{ { 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 @@
{ { 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 @@
{ { 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 @@
{ { 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 @@
{ { 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 @@
{ { 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 @@
{ { 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 @@
{ { 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 @@
{ { 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 @@
{ { 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 @@
{ { 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 @@
{ { 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 @@
{ { 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;
+TEST_F(TestSecureSessionTable, ValidateSessionSorting)
+{
+ // 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();
+}
} // 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)
-{
- chip::Transport::gTestSecureSessionTable.reset();
- chip::Platform::MemoryShutdown();
- return SUCCESS;
-}
-
-// 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);
diff --git a/src/transport/tests/TestSessionManager.cpp b/src/transport/tests/TestSessionManager.cpp
index 12dc46a..c5384a7 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,52 @@
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
{
- TestContext & ctx = *reinterpret_cast<TestContext *>(inContext);
+protected:
+ void SetUp() { ASSERT_EQ(mContext.Init(), CHIP_NO_ERROR); }
+ void TearDown() { mContext.Shutdown(); }
+ TestContext mContext;
+};
+
+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(&mContext.GetSystemLayer(), &mContext.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 +163,10 @@
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(&mContext.GetSystemLayer(), &mContext.GetTransportMgr(), &gMessageCounterManager, &deviceStorage,
+ &fabricTableHolder.GetFabricTable(), sessionKeystore));
sessionManager.SetMessageDelegate(&callback);
@@ -180,23 +175,23 @@
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 +206,53 @@
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);
+ mContext.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);
+ mContext.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 +267,10 @@
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(&mContext.GetSystemLayer(), &mContext.GetTransportMgr(), &gMessageCounterManager, &deviceStorage,
+ &fabricTableHolder.GetFabricTable(), sessionKeystore));
sessionManager.SetMessageDelegate(&callback);
@@ -289,23 +279,23 @@
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 +312,36 @@
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);
+ mContext.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);
+ mContext.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 +356,10 @@
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(&mContext.GetSystemLayer(), &mContext.GetTransportMgr(), &gMessageCounterManager, &deviceStorage,
+ &fabricTableHolder.GetFabricTable(), sessionKeystore));
sessionManager.SetMessageDelegate(&callback);
@@ -383,23 +368,23 @@
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 +401,13 @@
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);
+ mContext.DrainAndServiceIO();
+ EXPECT_EQ(callback.ReceiveHandlerCallCount, 1);
/* -------------------------------------------------------------------------------------------*/
// Reset receive side message counter, or duplicated message will be denied.
@@ -433,59 +418,57 @@
// 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);
+ mContext.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);
+ mContext.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);
+ mContext.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 +483,10 @@
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(&mContext.GetSystemLayer(), &mContext.GetTransportMgr(), &gMessageCounterManager, &deviceStorage,
+ &fabricTableHolder.GetFabricTable(), sessionKeystore));
sessionManager.SetMessageDelegate(&callback);
@@ -515,23 +495,23 @@
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 +527,51 @@
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);
+ mContext.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);
+ mContext.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);
+ mContext.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 +586,10 @@
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(&mContext.GetSystemLayer(), &mContext.GetTransportMgr(), &gMessageCounterManager, &deviceStorage,
+ &fabricTableHolder.GetFabricTable(), sessionKeystore));
sessionManager.SetMessageDelegate(&callback);
Transport::PeerAddress peer(Transport::PeerAddress::UDP(addr, CHIP_PORT));
@@ -622,23 +597,23 @@
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 +629,13 @@
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);
+ mContext.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 +644,30 @@
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);
+ mContext.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);
+ mContext.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 +677,24 @@
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(&mContext.GetSystemLayer(), &mContext.GetTransportMgr(), &messageCounterManager, &deviceStorage1,
+ &fabricTableHolder.GetFabricTable(), sessionKeystore));
// Allocate a session.
uint16_t sessionId1;
@@ -730,7 +702,7 @@
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 +721,8 @@
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 +730,16 @@
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(&mContext.GetSystemLayer(), &mContext.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 +752,10 @@
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 +775,15 @@
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 +793,11 @@
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 +812,8 @@
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 +827,33 @@
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(&mContext.GetSystemLayer(), &mContext.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 +862,7 @@
// ==== 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 +874,21 @@
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 +903,17 @@
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(&mContext.GetSystemLayer(), &mContext.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 +923,17 @@
} 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 +944,8 @@
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 +953,20 @@
// 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 +980,23 @@
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(&mContext.GetSystemLayer(), &mContext.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 +1007,11 @@
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 9d351ab..f90cb0f 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>
@@ -472,13 +469,13 @@
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 @@
unsigned NumMessagesReceived() { return mReceivedCount; }
- nlTestSuite * mSuite = nullptr;
unsigned mTestVectorIndex = 0;
unsigned mReceivedCount = 0;
};
@@ -505,18 +501,17 @@
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,23 @@
return CHIP_NO_ERROR;
}
-void TestSessionManagerDispatch(nlTestSuite * inSuite, void * inContext)
+class TestSessionManagerDispatch : public ::testing::Test
+{
+protected:
+ void SetUp() { ASSERT_EQ(mContext.Init(), CHIP_NO_ERROR); }
+ void TearDown() { mContext.Shutdown(); }
+
+ TestContext mContext;
+};
+
+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(mContext, sessionManager);
sessionManager.SetMessageDelegate(&callback);
IPAddress addr;
@@ -570,7 +573,6 @@
SessionHolder aliceToBobSession;
SessionHolder testGroupSession;
- callback.mSuite = inSuite;
for (unsigned i = 0; i < theMessageTestVectorLength; i++)
{
MessageTestEntry & testEntry = theMessageTestVector[i];
@@ -585,10 +587,10 @@
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 +600,7 @@
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 +611,4 @@
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);
