From 4c95b7ff4235b86163b1609d2184085989096757 Mon Sep 17 00:00:00 2001
From: Jeff Feasel <jfeasel@csa-iot.org>
Date: Tue, 30 Apr 2024 20:07:32 -0400
Subject: [PATCH 1/8] Refactored TestSecureSessionTable.cpp to use
 TestSecureSessionTable as the pw test context.

---
 src/transport/tests/BUILD.gn                  |   6 +-
 src/transport/tests/TestCryptoContext.cpp     |  54 +-
 .../tests/TestGroupMessageCounter.cpp         | 211 ++++----
 src/transport/tests/TestPeerConnections.cpp   |  88 ++--
 .../tests/TestPeerMessageCounter.cpp          | 170 +++----
 src/transport/tests/TestSecureSession.cpp     | 152 ++----
 .../tests/TestSecureSessionTable.cpp          | 146 ++----
 src/transport/tests/TestSessionManager.cpp    | 476 +++++++-----------
 .../tests/TestSessionManagerDispatch.cpp      | 137 ++---
 9 files changed, 522 insertions(+), 918 deletions(-)

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

From 08fa55e425f05d6a4e9673c721138dcb4197e323 Mon Sep 17 00:00:00 2001
From: Jeff Feasel <jfeasel@csa-iot.org>
Date: Tue, 30 Apr 2024 20:22:15 -0400
Subject: [PATCH 2/8] Updated test_components[_nl].txt to move
 TransportLayerTests

---
 src/test_driver/openiotsdk/unit-tests/test_components.txt    | 1 +
 src/test_driver/openiotsdk/unit-tests/test_components_nl.txt | 1 -
 2 files changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/test_driver/openiotsdk/unit-tests/test_components.txt b/src/test_driver/openiotsdk/unit-tests/test_components.txt
index 5887de730725df..e832a83f4bea85 100644
--- a/src/test_driver/openiotsdk/unit-tests/test_components.txt
+++ b/src/test_driver/openiotsdk/unit-tests/test_components.txt
@@ -18,3 +18,4 @@ SupportTests
 UserDirectedCommissioningTests
 SecureChannelTests
 ICDServerTests
+TransportLayerTests
diff --git a/src/test_driver/openiotsdk/unit-tests/test_components_nl.txt b/src/test_driver/openiotsdk/unit-tests/test_components_nl.txt
index e3d66b49d3f644..6af4ed11c4f625 100644
--- a/src/test_driver/openiotsdk/unit-tests/test_components_nl.txt
+++ b/src/test_driver/openiotsdk/unit-tests/test_components_nl.txt
@@ -5,4 +5,3 @@ InetLayerTests
 MessagingLayerTests
 SecureChannelTestsNL
 SupportTestsNL
-TransportLayerTests

From db33f68ddac7813d7186541a0f07b76ccaf316bf Mon Sep 17 00:00:00 2001
From: Jeff Feasel <jfeasel@csa-iot.org>
Date: Sat, 4 May 2024 07:25:45 -0400
Subject: [PATCH 3/8] Fixed formatting

---
 .../tests/TestSessionManagerDispatch.cpp      | 40 +++++++++----------
 1 file changed, 20 insertions(+), 20 deletions(-)

diff --git a/src/transport/tests/TestSessionManagerDispatch.cpp b/src/transport/tests/TestSessionManagerDispatch.cpp
index b83421eb1a47c1..47b2a9daed5c52 100644
--- a/src/transport/tests/TestSessionManagerDispatch.cpp
+++ b/src/transport/tests/TestSessionManagerDispatch.cpp
@@ -103,8 +103,8 @@ struct MessageTestEntry theMessageTestVector[] = {
         .plain     = "\x00\xb8\x0b\x00\x39\x30\x00\x00\x05\x64\xee\x0e\x20\x7d",
         .encrypted = "\x00\xb8\x0b\x00\x39\x30\x00\x00\x5a\x98\x9a\xe4\x2e\x8d"
                      "\x84\x7f\x53\x5c\x30\x07\xe6\x15\x0c\xd6\x58\x67\xf2\xb8\x17\xdb", // Includes MIC
-        .privacy = "\x00\xb8\x0b\x00\x39\x30\x00\x00\x5a\x98\x9a\xe4\x2e\x8d"
-                   "\x84\x7f\x53\x5c\x30\x07\xe6\x15\x0c\xd6\x58\x67\xf2\xb8\x17\xdb", // Includes MIC
+        .privacy   = "\x00\xb8\x0b\x00\x39\x30\x00\x00\x5a\x98\x9a\xe4\x2e\x8d"
+                     "\x84\x7f\x53\x5c\x30\x07\xe6\x15\x0c\xd6\x58\x67\xf2\xb8\x17\xdb", // Includes MIC
 
         .payloadLength   = 0,
         .plainLength     = 14,
@@ -129,8 +129,8 @@ struct MessageTestEntry theMessageTestVector[] = {
         .plain     = "\x00\xb8\x0b\x00\x39\x30\x00\x00\x05\x64\xee\x0e\x20\x7d\x11\x22\x33\x44\x55",
         .encrypted = "\x00\xb8\x0b\x00\x39\x30\x00\x00\x5a\x98\x9a\xe4\x2e\x8d\x0f\x7f\x88\x5d\xfb"
                      "\x2f\xaa\x89\x49\xcf\x73\x0a\x57\x28\xe0\x35\x46\x10\xa0\xc4\xa7", // Includes MIC
-        .privacy = "\x00\xb8\x0b\x00\x39\x30\x00\x00\x5a\x98\x9a\xe4\x2e\x8d\x0f\x7f\x88\x5d\xfb"
-                   "\x2f\xaa\x89\x49\xcf\x73\x0a\x57\x28\xe0\x35\x46\x10\xa0\xc4\xa7", // Includes MIC
+        .privacy   = "\x00\xb8\x0b\x00\x39\x30\x00\x00\x5a\x98\x9a\xe4\x2e\x8d\x0f\x7f\x88\x5d\xfb"
+                     "\x2f\xaa\x89\x49\xcf\x73\x0a\x57\x28\xe0\x35\x46\x10\xa0\xc4\xa7", // Includes MIC
 
         .payloadLength   = 5,
         .plainLength     = 19,
@@ -158,8 +158,8 @@ struct MessageTestEntry theMessageTestVector[] = {
         .plain     = "\x00\xb8\x0b\x00\x39\x30\x00\x00\x05\x64\xee\x0e\x20\x7d",
         .encrypted = "\x00\xb8\x0b\x00\x39\x30\x00\x00\x5a\x98\x9a\xe4\x2e\x8d"
                      "\x84\x7f\x53\x5c\x30\x07\xe6\x15\x0c\xd6\x58\x67\xf2\xb8\x17\xdd", // Includes wrong MIC
-        .privacy = "\x00\xb8\x0b\x00\x39\x30\x00\x00\x5a\x98\x9a\xe4\x2e\x8d"
-                   "\x84\x7f\x53\x5c\x30\x07\xe6\x15\x0c\xd6\x58\x67\xf2\xb8\x17\xdd", // Includes wrong MIC
+        .privacy   = "\x00\xb8\x0b\x00\x39\x30\x00\x00\x5a\x98\x9a\xe4\x2e\x8d"
+                     "\x84\x7f\x53\x5c\x30\x07\xe6\x15\x0c\xd6\x58\x67\xf2\xb8\x17\xdd", // Includes wrong MIC
 
         .payloadLength   = 0,
         .plainLength     = 14,
@@ -184,8 +184,8 @@ struct MessageTestEntry theMessageTestVector[] = {
         .plain     = "\x00\xb8\x0b\x00\x39\x30\x00\x00\x05\x64\xee\x0e\x20\x7d\x11\x22\x33\x44\x55",
         .encrypted = "\x00\xb8\x0b\x00\x39\x30\x00\x00\x5a\x98\x9a\xe4\x2e\x8d\x0f\x7f\x88\x5d\xfb"
                      "\x2f\xaa\x89\x49\xcf\x73\x0a\x57\x28\xe0\x35\x46\x10\xa0\xc4\xaa", // Includes wrong MIC
-        .privacy = "\x00\xb8\x0b\x00\x39\x30\x00\x00\x5a\x98\x9a\xe4\x2e\x8d\x0f\x7f\x88\x5d\xfb"
-                   "\x2f\xaa\x89\x49\xcf\x73\x0a\x57\x28\xe0\x35\x46\x10\xa0\xc4\xaa", // Includes wrong MIC
+        .privacy   = "\x00\xb8\x0b\x00\x39\x30\x00\x00\x5a\x98\x9a\xe4\x2e\x8d\x0f\x7f\x88\x5d\xfb"
+                     "\x2f\xaa\x89\x49\xcf\x73\x0a\x57\x28\xe0\x35\x46\x10\xa0\xc4\xaa", // Includes wrong MIC
 
         .payloadLength   = 5,
         .plainLength     = 19,
@@ -210,8 +210,8 @@ struct MessageTestEntry theMessageTestVector[] = {
         .plain     = "\x00\xb8\x0b\x80\x39\x30\x00\x00\x05\x64\xee\x0e\x20\x7d\x11\x22\x33\x44\x55",
         .encrypted = "\x00\xb8\x0b\x80\x39\x30\x00\x00\xaa\x26\xa0\xf9\x01\xef\xce\x9f\x9a\x67\xc8"
                      "\x13\x79\x17\xd1\x5b\x81\xd1\x5d\x31\x33\x08\x31\x97\x58\xea\x3f", // Includes MIC
-        .privacy = "\x00\xb8\x0b\x80\x87\xbe\xef\x06\xaa\x26\xa0\xf9\x01\xef\xce\x9f\x9a\x67\xc8"
-                   "\x13\x79\x17\xd1\x5b\x81\xd1\x5d\x31\x33\x08\x31\x97\x58\xea\x3f", // Includes MIC
+        .privacy   = "\x00\xb8\x0b\x80\x87\xbe\xef\x06\xaa\x26\xa0\xf9\x01\xef\xce\x9f\x9a\x67\xc8"
+                     "\x13\x79\x17\xd1\x5b\x81\xd1\x5d\x31\x33\x08\x31\x97\x58\xea\x3f", // Includes MIC
 
         .payloadLength   = 5,
         .plainLength     = 19,
@@ -243,8 +243,8 @@ struct MessageTestEntry theMessageTestVector[] = {
         .plain     = "\06\x7d\xdb\x01\x78\x56\x34\x12\x01\x00\x00\x00\x00\x00\x00\x00\x02\x00\x01\x64\xee\x0e\x20\x7d",
         .encrypted = "\x06\x7d\xdb\x01\x78\x56\x34\x12\x01\x00\x00\x00\x00\x00\x00\x00\x02\x00\x65\xc7\x67\xbc\x6c\xda"
                      "\x01\x06\xc9\x80\x13\x23\x90\x0e\x9b\x3c\xe6\xd4\xbb\x03\x27\xd6", // Includes MIC
-        .privacy = "\x06\x7d\xdb\x01\x78\x56\x34\x12\x01\x00\x00\x00\x00\x00\x00\x00\x02\x00\x65\xc7\x67\xbc\x6c\xda"
-                   "\x01\x06\xc9\x80\x13\x23\x90\x0e\x9b\x3c\xe6\xd4\xbb\x03\x27\xd6", // Includes MIC
+        .privacy   = "\x06\x7d\xdb\x01\x78\x56\x34\x12\x01\x00\x00\x00\x00\x00\x00\x00\x02\x00\x65\xc7\x67\xbc\x6c\xda"
+                     "\x01\x06\xc9\x80\x13\x23\x90\x0e\x9b\x3c\xe6\xd4\xbb\x03\x27\xd6", // Includes MIC
 
         .payloadLength   = 0,
         .plainLength     = 24,
@@ -275,8 +275,8 @@ struct MessageTestEntry theMessageTestVector[] = {
         .plain     = "\06\x7d\xdb\x01\x78\x56\x34\x12\x01\x00\x00\x00\x00\x00\x00\x00\x02\x00\x01\x64\xee\x0e\x20\x7d",
         .encrypted = "\x06\x7d\xdb\x01\x78\x56\x34\x12\x01\x00\x00\x00\x00\x00\x00\x00\x02\x00\x65\xc7\x67\xbc\x6c\xda"
                      "\x01\x06\xc9\x80\x13\x23\x90\x0e\x9b\x3c\xe6\xd4\xbb\x03\x27\xd6", // Includes MIC
-        .privacy = "\x06\x7d\xdb\x01\x78\x56\x34\x12\x01\x00\x00\x00\x00\x00\x00\x00\x02\x00\x65\xc7\x67\xbc\x6c\xda"
-                   "\x01\x06\xc9\x80\x13\x23\x90\x0e\x9b\x3c\xe6\xd4\xbb\x03\x27\xd6", // Includes MIC
+        .privacy   = "\x06\x7d\xdb\x01\x78\x56\x34\x12\x01\x00\x00\x00\x00\x00\x00\x00\x02\x00\x65\xc7\x67\xbc\x6c\xda"
+                     "\x01\x06\xc9\x80\x13\x23\x90\x0e\x9b\x3c\xe6\xd4\xbb\x03\x27\xd6", // Includes MIC
 
         .payloadLength   = 0,
         .plainLength     = 24,
@@ -307,8 +307,8 @@ struct MessageTestEntry theMessageTestVector[] = {
         .plain     = "\x06\x7d\xdb\x81\x79\x56\x34\x12\x01\x00\x00\x00\x00\x00\x00\x00\x02\x00\x01\x64\xee\x0e\x20\x7d",
         .encrypted = "\x06\x7d\xdb\x81\x79\x56\x34\x12\x01\x00\x00\x00\x00\x00\x00\x00\x02\x00\x2b\x2f\x91\x5a\x66\xc9"
                      "\x59\x62\x90\xeb\xe4\x40\x82\x17\xb3\xc0\xc9\x21\xa2\xfc\xa4\xe1",
-        .privacy = "\x06\x7d\xdb\x81\xd9\x26\xaf\xce\x24\xc8\xa0\x98\x1b\xdd\x44\xf4\xe7\x30\x2b\x2f\x91\x5a\x66\xc9"
-                   "\x59\x62\x90\xeb\xe4\x40\x82\x17\xb3\xc0\xc9\x21\xa2\xfc\xa4\xe1",
+        .privacy   = "\x06\x7d\xdb\x81\xd9\x26\xaf\xce\x24\xc8\xa0\x98\x1b\xdd\x44\xf4\xe7\x30\x2b\x2f\x91\x5a\x66\xc9"
+                     "\x59\x62\x90\xeb\xe4\x40\x82\x17\xb3\xc0\xc9\x21\xa2\xfc\xa4\xe1",
 
         .payloadLength   = 0,
         .plainLength     = 24,
@@ -342,8 +342,8 @@ struct MessageTestEntry theMessageTestVector[] = {
         .plain     = "\x06\x7d\xdb\x81\x79\x56\x34\x12\x01\x00\x00\x00\x00\x00\x00\x00\x02\x00\x01\x64\xee\x0e\x20\x7d",
         .encrypted = "\x06\x7d\xdb\x81\x79\x56\x34\x12\x01\x00\x00\x00\x00\x00\x00\x00\x02\x00\x2b\x2f\x91\x5a\x66\xc9"
                      "\x59\x62\x90\xeb\xe4\x40\x82\x17\xb3\xc0\xc9\x21\xa2\xfc\xa4\xee",
-        .privacy = "\x06\x7d\xdb\x81\xd9\x26\xaf\xce\x24\xc8\xa0\x98\x1b\xdd\x44\xf4\xe7\x30\x2b\x2f\x91\x5a\x66\xc9"
-                   "\x59\x62\x90\xeb\xe4\x40\x82\x17\xb3\xc0\xc9\x21\xa2\xfc\xa4\xee",
+        .privacy   = "\x06\x7d\xdb\x81\xd9\x26\xaf\xce\x24\xc8\xa0\x98\x1b\xdd\x44\xf4\xe7\x30\x2b\x2f\x91\x5a\x66\xc9"
+                     "\x59\x62\x90\xeb\xe4\x40\x82\x17\xb3\xc0\xc9\x21\xa2\xfc\xa4\xee",
 
         .payloadLength   = 0,
         .plainLength     = 24,
@@ -378,8 +378,8 @@ struct MessageTestEntry theMessageTestVector[] = {
         .plain     = "\06\x7d\xdb\x81\x91\x56\x34\x12\x01\x00\x00\x00\x00\x00\x00\x00\x02\x00\x01\x64\xee\x0e\x20\x7d",
         .encrypted = "\x06\x7d\xdb\x81\x91\x56\x34\x12\x01\x00\x00\x00\x00\x00\x00\x00\x02\x00\x91\xe0\x22\x85\xe0\x59\x07\xe0"
                      "\xd8\x68\x0c\x79\xac\x6d\x64\x46\x90\x65\xb2\x6f\x90\x26", // Includes MIC
-        .privacy = "\x06\x7d\xdb\x81\x91\x56\x34\x12\x01\x00\x00\x00\x00\x00\x00\x00\x02\x00\x91\xe0\x22\x85\xe0\x59\x07\xe0"
-                   "\xd8\x68\x0c\x79\xac\x6d\x64\x46\x90\x65\xb2\x6f\x90\x26", // Includes MIC
+        .privacy   = "\x06\x7d\xdb\x81\x91\x56\x34\x12\x01\x00\x00\x00\x00\x00\x00\x00\x02\x00\x91\xe0\x22\x85\xe0\x59\x07\xe0"
+                     "\xd8\x68\x0c\x79\xac\x6d\x64\x46\x90\x65\xb2\x6f\x90\x26", // Includes MIC
 
         .payloadLength   = 0,
         .plainLength     = 24,

From 8c55586fdafc15655815935d55478cca0b4ea8ce Mon Sep 17 00:00:00 2001
From: Jeff Feasel <jfeasel@csa-iot.org>
Date: Sat, 4 May 2024 07:37:09 -0400
Subject: [PATCH 4/8] Fixing merge conflict in test components nl

---
 src/test_driver/openiotsdk/unit-tests/test_components_nl.txt | 1 +
 1 file changed, 1 insertion(+)

diff --git a/src/test_driver/openiotsdk/unit-tests/test_components_nl.txt b/src/test_driver/openiotsdk/unit-tests/test_components_nl.txt
index 66789f206baf4b..e56e366e6090ee 100644
--- a/src/test_driver/openiotsdk/unit-tests/test_components_nl.txt
+++ b/src/test_driver/openiotsdk/unit-tests/test_components_nl.txt
@@ -3,3 +3,4 @@ DataModelTests
 InetLayerTests
 MessagingLayerTests
 SecureChannelTestsNL
+SupportTestsNL

From c03613811d7d66ae872cc22770d5b34847de09a4 Mon Sep 17 00:00:00 2001
From: Jeff Feasel <jfeasel@csa-iot.org>
Date: Sat, 4 May 2024 07:38:01 -0400
Subject: [PATCH 5/8] Fixing merge conflict

---
 src/test_driver/openiotsdk/unit-tests/test_components_nl.txt | 1 -
 1 file changed, 1 deletion(-)

diff --git a/src/test_driver/openiotsdk/unit-tests/test_components_nl.txt b/src/test_driver/openiotsdk/unit-tests/test_components_nl.txt
index e56e366e6090ee..66789f206baf4b 100644
--- a/src/test_driver/openiotsdk/unit-tests/test_components_nl.txt
+++ b/src/test_driver/openiotsdk/unit-tests/test_components_nl.txt
@@ -3,4 +3,3 @@ DataModelTests
 InetLayerTests
 MessagingLayerTests
 SecureChannelTestsNL
-SupportTestsNL

From 537c360d57d16ed743ca3f3079139b1b1b1a64bd Mon Sep 17 00:00:00 2001
From: Jeff Feasel <jfeasel@csa-iot.org>
Date: Mon, 6 May 2024 11:13:32 -0400
Subject: [PATCH 6/8] Updated TestSessionManagerDispatch to use staticly
 allocated context instead of dynamically.  Changed all tests to use
 XTestSuite instead of per-test SetUp/TearDown.

---
 src/transport/tests/TestCryptoContext.cpp     |  6 +-
 src/transport/tests/TestPeerConnections.cpp   |  6 +-
 src/transport/tests/TestSessionManager.cpp    | 60 ++++++++++---------
 .../tests/TestSessionManagerDispatch.cpp      | 17 +++---
 4 files changed, 47 insertions(+), 42 deletions(-)

diff --git a/src/transport/tests/TestCryptoContext.cpp b/src/transport/tests/TestCryptoContext.cpp
index 7a688dbf7f8536..281ad1e92de675 100644
--- a/src/transport/tests/TestCryptoContext.cpp
+++ b/src/transport/tests/TestCryptoContext.cpp
@@ -49,9 +49,9 @@ struct PrivacyNonceTestEntry thePrivacyNonceTestVector[] = {
 
 class TestGroupCryptoContext : public ::testing::Test
 {
-protected:
-    void SetUp() { ASSERT_EQ(chip::Platform::MemoryInit(), CHIP_NO_ERROR); }
-    void TearDown() { chip::Platform::MemoryShutdown(); }
+public:
+    static void SetUpTestSuite() { ASSERT_EQ(chip::Platform::MemoryInit(), CHIP_NO_ERROR); }
+    static void TearDownTestSuite() { chip::Platform::MemoryShutdown(); }
 };
 
 TEST_F(TestGroupCryptoContext, TestBuildPrivacyNonce)
diff --git a/src/transport/tests/TestPeerConnections.cpp b/src/transport/tests/TestPeerConnections.cpp
index 4f7acb147080eb..f15aeb2cc63c4b 100644
--- a/src/transport/tests/TestPeerConnections.cpp
+++ b/src/transport/tests/TestPeerConnections.cpp
@@ -57,9 +57,9 @@ const CATValues kPeer2CATs = { { 0xABCD0012, kUndefinedCAT, kUndefinedCAT } };
 
 class TestPeerConnections : public ::testing::Test
 {
-protected:
-    void SetUp() { ASSERT_EQ(chip::Platform::MemoryInit(), CHIP_NO_ERROR); }
-    void TearDown() { chip::Platform::MemoryShutdown(); }
+public:
+    static void SetUpTestSuite() { ASSERT_EQ(chip::Platform::MemoryInit(), CHIP_NO_ERROR); }
+    static void TearDownTestSuite() { chip::Platform::MemoryShutdown(); }
 };
 
 TEST_F(TestPeerConnections, TestBasicFunctionality)
diff --git a/src/transport/tests/TestSessionManager.cpp b/src/transport/tests/TestSessionManager.cpp
index b1b6c4620cd86a..b67379fbd3fa20 100644
--- a/src/transport/tests/TestSessionManager.cpp
+++ b/src/transport/tests/TestSessionManager.cpp
@@ -117,12 +117,16 @@ class TestSessMgrCallback : public SessionMessageDelegate
     bool LargeMessageSent       = false;
 };
 
-class TestSessionManager : public ::testing::Test, public TestContext
+class TestSessionManager : public ::testing::Test
 {
+public:
+    static void SetUpTestSuite() { ASSERT_EQ(mContext.Init(), CHIP_NO_ERROR); }
+    static void TearDownTestSuite() { mContext.Shutdown(); }
+
 protected:
-    void SetUp() { ASSERT_EQ(Init(), CHIP_NO_ERROR); }
-    void TearDown() { Shutdown(); }
+    static TestContext mContext;
 };
+TestContext TestSessionManager::mContext;
 
 TEST_F(TestSessionManager, CheckSimpleInitTest)
 {
@@ -134,7 +138,7 @@ TEST_F(TestSessionManager, CheckSimpleInitTest)
 
     EXPECT_EQ(CHIP_NO_ERROR, fabricTableHolder.Init());
     EXPECT_EQ(CHIP_NO_ERROR,
-              sessionManager.Init(&GetSystemLayer(), &GetTransportMgr(), &gMessageCounterManager, &deviceStorage,
+              sessionManager.Init(&mContext.GetSystemLayer(), &mContext.GetTransportMgr(), &gMessageCounterManager, &deviceStorage,
                                   &fabricTableHolder.GetFabricTable(), sessionKeystore));
 }
 
@@ -163,7 +167,7 @@ TEST_F(TestSessionManager, CheckMessageTest)
 
     EXPECT_EQ(CHIP_NO_ERROR, fabricTableHolder.Init());
     EXPECT_EQ(CHIP_NO_ERROR,
-              sessionManager.Init(&GetSystemLayer(), &GetTransportMgr(), &gMessageCounterManager, &deviceStorage,
+              sessionManager.Init(&mContext.GetSystemLayer(), &mContext.GetTransportMgr(), &gMessageCounterManager, &deviceStorage,
                                   &fabricTableHolder.GetFabricTable(), sessionKeystore));
 
     sessionManager.SetMessageDelegate(&callback);
@@ -209,7 +213,7 @@ TEST_F(TestSessionManager, CheckMessageTest)
     err = sessionManager.SendPreparedMessage(aliceToBobSession.Get().Value(), preparedMessage);
     EXPECT_EQ(err, CHIP_NO_ERROR);
 
-    DrainAndServiceIO();
+    mContext.DrainAndServiceIO();
     EXPECT_EQ(callback.ReceiveHandlerCallCount, 1);
 
     // Let's send the max sized message and make sure it is received
@@ -224,7 +228,7 @@ TEST_F(TestSessionManager, CheckMessageTest)
     err = sessionManager.SendPreparedMessage(aliceToBobSession.Get().Value(), preparedMessage);
     EXPECT_EQ(err, CHIP_NO_ERROR);
 
-    DrainAndServiceIO();
+    mContext.DrainAndServiceIO();
     EXPECT_EQ(callback.ReceiveHandlerCallCount, 2);
 
     uint16_t large_payload_len = sizeof(LARGE_PAYLOAD);
@@ -267,7 +271,7 @@ TEST_F(TestSessionManager, SendEncryptedPacketTest)
 
     EXPECT_EQ(CHIP_NO_ERROR, fabricTableHolder.Init());
     EXPECT_EQ(CHIP_NO_ERROR,
-              sessionManager.Init(&GetSystemLayer(), &GetTransportMgr(), &gMessageCounterManager, &deviceStorage,
+              sessionManager.Init(&mContext.GetSystemLayer(), &mContext.GetTransportMgr(), &gMessageCounterManager, &deviceStorage,
                                   &fabricTableHolder.GetFabricTable(), sessionKeystore));
 
     sessionManager.SetMessageDelegate(&callback);
@@ -315,7 +319,7 @@ TEST_F(TestSessionManager, SendEncryptedPacketTest)
     err = sessionManager.SendPreparedMessage(aliceToBobSession.Get().Value(), preparedMessage);
     EXPECT_EQ(err, CHIP_NO_ERROR);
 
-    DrainAndServiceIO();
+    mContext.DrainAndServiceIO();
     EXPECT_EQ(callback.ReceiveHandlerCallCount, 1);
 
     // Reset receive side message counter, or duplicated message will be denied.
@@ -325,7 +329,7 @@ TEST_F(TestSessionManager, SendEncryptedPacketTest)
     err = sessionManager.SendPreparedMessage(aliceToBobSession.Get().Value(), preparedMessage);
     EXPECT_EQ(err, CHIP_NO_ERROR);
 
-    DrainAndServiceIO();
+    mContext.DrainAndServiceIO();
     EXPECT_EQ(callback.ReceiveHandlerCallCount, 2);
 
     sessionManager.Shutdown();
@@ -356,7 +360,7 @@ TEST_F(TestSessionManager, SendBadEncryptedPacketTest)
 
     EXPECT_EQ(CHIP_NO_ERROR, fabricTableHolder.Init());
     EXPECT_EQ(CHIP_NO_ERROR,
-              sessionManager.Init(&GetSystemLayer(), &GetTransportMgr(), &gMessageCounterManager, &deviceStorage,
+              sessionManager.Init(&mContext.GetSystemLayer(), &mContext.GetTransportMgr(), &gMessageCounterManager, &deviceStorage,
                                   &fabricTableHolder.GetFabricTable(), sessionKeystore));
 
     sessionManager.SetMessageDelegate(&callback);
@@ -404,7 +408,7 @@ TEST_F(TestSessionManager, SendBadEncryptedPacketTest)
     err = sessionManager.SendPreparedMessage(aliceToBobSession.Get().Value(), preparedMessage);
     EXPECT_EQ(err, CHIP_NO_ERROR);
 
-    DrainAndServiceIO();
+    mContext.DrainAndServiceIO();
     EXPECT_EQ(callback.ReceiveHandlerCallCount, 1);
 
     /* -------------------------------------------------------------------------------------------*/
@@ -425,7 +429,7 @@ TEST_F(TestSessionManager, SendBadEncryptedPacketTest)
     err = sessionManager.SendPreparedMessage(aliceToBobSession.Get().Value(), badMessageCounterMsg);
     EXPECT_EQ(err, CHIP_NO_ERROR);
 
-    DrainAndServiceIO();
+    mContext.DrainAndServiceIO();
     EXPECT_EQ(callback.ReceiveHandlerCallCount, 1);
 
     /* -------------------------------------------------------------------------------------------*/
@@ -442,7 +446,7 @@ TEST_F(TestSessionManager, SendBadEncryptedPacketTest)
     err = sessionManager.SendPreparedMessage(aliceToBobSession.Get().Value(), badKeyIdMsg);
     EXPECT_EQ(err, CHIP_NO_ERROR);
 
-    DrainAndServiceIO();
+    mContext.DrainAndServiceIO();
     EXPECT_EQ(callback.ReceiveHandlerCallCount, 1);
 
     /* -------------------------------------------------------------------------------------------*/
@@ -452,7 +456,7 @@ TEST_F(TestSessionManager, SendBadEncryptedPacketTest)
     err = sessionManager.SendPreparedMessage(aliceToBobSession.Get().Value(), preparedMessage);
     EXPECT_EQ(err, CHIP_NO_ERROR);
 
-    DrainAndServiceIO();
+    mContext.DrainAndServiceIO();
     EXPECT_EQ(callback.ReceiveHandlerCallCount, 2);
 
     sessionManager.Shutdown();
@@ -483,7 +487,7 @@ TEST_F(TestSessionManager, SendPacketWithOldCounterTest)
 
     EXPECT_EQ(CHIP_NO_ERROR, fabricTableHolder.Init());
     EXPECT_EQ(CHIP_NO_ERROR,
-              sessionManager.Init(&GetSystemLayer(), &GetTransportMgr(), &gMessageCounterManager, &deviceStorage,
+              sessionManager.Init(&mContext.GetSystemLayer(), &mContext.GetTransportMgr(), &gMessageCounterManager, &deviceStorage,
                                   &fabricTableHolder.GetFabricTable(), sessionKeystore));
 
     sessionManager.SetMessageDelegate(&callback);
@@ -530,7 +534,7 @@ TEST_F(TestSessionManager, SendPacketWithOldCounterTest)
     err = sessionManager.SendPreparedMessage(aliceToBobSession.Get().Value(), preparedMessage);
     EXPECT_EQ(err, CHIP_NO_ERROR);
 
-    DrainAndServiceIO();
+    mContext.DrainAndServiceIO();
     EXPECT_EQ(callback.ReceiveHandlerCallCount, 1);
 
     // Now advance our message counter by 5.
@@ -547,7 +551,7 @@ TEST_F(TestSessionManager, SendPacketWithOldCounterTest)
     err = sessionManager.SendPreparedMessage(aliceToBobSession.Get().Value(), newMessage);
     EXPECT_EQ(err, CHIP_NO_ERROR);
 
-    DrainAndServiceIO();
+    mContext.DrainAndServiceIO();
     EXPECT_EQ(callback.ReceiveHandlerCallCount, 2);
 
     // Now resend our original message.  It should be rejected as a duplicate.
@@ -555,7 +559,7 @@ TEST_F(TestSessionManager, SendPacketWithOldCounterTest)
     err = sessionManager.SendPreparedMessage(aliceToBobSession.Get().Value(), preparedMessage);
     EXPECT_EQ(err, CHIP_NO_ERROR);
 
-    DrainAndServiceIO();
+    mContext.DrainAndServiceIO();
     EXPECT_EQ(callback.ReceiveHandlerCallCount, 2);
 
     sessionManager.Shutdown();
@@ -586,7 +590,7 @@ TEST_F(TestSessionManager, SendPacketWithTooOldCounterTest)
 
     EXPECT_EQ(CHIP_NO_ERROR, fabricTableHolder.Init());
     EXPECT_EQ(CHIP_NO_ERROR,
-              sessionManager.Init(&GetSystemLayer(), &GetTransportMgr(), &gMessageCounterManager, &deviceStorage,
+              sessionManager.Init(&mContext.GetSystemLayer(), &mContext.GetTransportMgr(), &gMessageCounterManager, &deviceStorage,
                                   &fabricTableHolder.GetFabricTable(), sessionKeystore));
     sessionManager.SetMessageDelegate(&callback);
 
@@ -632,7 +636,7 @@ TEST_F(TestSessionManager, SendPacketWithTooOldCounterTest)
     err = sessionManager.SendPreparedMessage(aliceToBobSession.Get().Value(), preparedMessage);
     EXPECT_EQ(err, CHIP_NO_ERROR);
 
-    DrainAndServiceIO();
+    mContext.DrainAndServiceIO();
     EXPECT_EQ(callback.ReceiveHandlerCallCount, 1);
 
     // Now advance our message counter by at least
@@ -651,7 +655,7 @@ TEST_F(TestSessionManager, SendPacketWithTooOldCounterTest)
     err = sessionManager.SendPreparedMessage(aliceToBobSession.Get().Value(), newMessage);
     EXPECT_EQ(err, CHIP_NO_ERROR);
 
-    DrainAndServiceIO();
+    mContext.DrainAndServiceIO();
     EXPECT_EQ(callback.ReceiveHandlerCallCount, 2);
 
     // Now resend our original message.  It should be rejected as a duplicate.
@@ -659,7 +663,7 @@ TEST_F(TestSessionManager, SendPacketWithTooOldCounterTest)
     err = sessionManager.SendPreparedMessage(aliceToBobSession.Get().Value(), preparedMessage);
     EXPECT_EQ(err, CHIP_NO_ERROR);
 
-    DrainAndServiceIO();
+    mContext.DrainAndServiceIO();
     EXPECT_EQ(callback.ReceiveHandlerCallCount, 2);
 
     sessionManager.Shutdown();
@@ -691,7 +695,7 @@ TEST_F(TestSessionManager, SessionAllocationTest)
     SessionManager sessionManager;
 
     EXPECT_EQ(CHIP_NO_ERROR,
-              sessionManager.Init(&GetSystemLayer(), &GetTransportMgr(), &messageCounterManager, &deviceStorage1,
+              sessionManager.Init(&mContext.GetSystemLayer(), &mContext.GetTransportMgr(), &messageCounterManager, &deviceStorage1,
                                   &fabricTableHolder.GetFabricTable(), sessionKeystore));
 
     // Allocate a session.
@@ -729,7 +733,7 @@ TEST_F(TestSessionManager, SessionAllocationTest)
     sessionManager.~SessionManager();
     new (&sessionManager) SessionManager();
     EXPECT_EQ(CHIP_NO_ERROR,
-              sessionManager.Init(&GetSystemLayer(), &GetTransportMgr(), &messageCounterManager, &deviceStorage2,
+              sessionManager.Init(&mContext.GetSystemLayer(), &mContext.GetTransportMgr(), &messageCounterManager, &deviceStorage2,
                                   &fabricTableHolder.GetFabricTable(), sessionKeystore));
 
     // Allocate a single session so we know what random id we are starting at.
@@ -827,7 +831,7 @@ TEST_F(TestSessionManager, SessionCounterExhaustedTest)
 
     EXPECT_EQ(CHIP_NO_ERROR, fabricTableHolder.Init());
     EXPECT_EQ(CHIP_NO_ERROR,
-              sessionManager.Init(&GetSystemLayer(), &GetTransportMgr(), &gMessageCounterManager, &deviceStorage,
+              sessionManager.Init(&mContext.GetSystemLayer(), &mContext.GetTransportMgr(), &gMessageCounterManager, &deviceStorage,
                                   &fabricTableHolder.GetFabricTable(), sessionKeystore));
 
     Transport::PeerAddress peer(Transport::PeerAddress::UDP(addr, CHIP_PORT));
@@ -903,7 +907,7 @@ TEST_F(TestSessionManager, SessionShiftingTest)
 
     EXPECT_EQ(CHIP_NO_ERROR, fabricTableHolder.Init());
     EXPECT_EQ(CHIP_NO_ERROR,
-              sessionManager.Init(&GetSystemLayer(), &GetTransportMgr(), &messageCounterManager, &deviceStorage,
+              sessionManager.Init(&mContext.GetSystemLayer(), &mContext.GetTransportMgr(), &messageCounterManager, &deviceStorage,
                                   &fabricTableHolder.GetFabricTable(), sessionKeystore));
 
     Transport::PeerAddress peer(Transport::PeerAddress::UDP(addr, CHIP_PORT));
@@ -980,7 +984,7 @@ TEST_F(TestSessionManager, TestFindSecureSessionForNode)
 
     EXPECT_EQ(CHIP_NO_ERROR, fabricTableHolder.Init());
     EXPECT_EQ(CHIP_NO_ERROR,
-              sessionManager.Init(&GetSystemLayer(), &GetTransportMgr(), &messageCounterManager, &deviceStorage,
+              sessionManager.Init(&mContext.GetSystemLayer(), &mContext.GetTransportMgr(), &messageCounterManager, &deviceStorage,
                                   &fabricTableHolder.GetFabricTable(), sessionKeystore));
 
     Transport::PeerAddress peer(Transport::PeerAddress::UDP(addr, CHIP_PORT));
diff --git a/src/transport/tests/TestSessionManagerDispatch.cpp b/src/transport/tests/TestSessionManagerDispatch.cpp
index 47b2a9daed5c52..cb7310ae8f9567 100644
--- a/src/transport/tests/TestSessionManagerDispatch.cpp
+++ b/src/transport/tests/TestSessionManagerDispatch.cpp
@@ -501,7 +501,7 @@ PeerAddress AddressFromString(const char * str)
     return PeerAddress::UDP(addr);
 }
 
-void TestSessionManagerInit(TestContext * ctx, SessionManager & sessionManager)
+void TestSessionManagerInit(TestContext & ctx, SessionManager & sessionManager)
 {
     static FabricTableHolder fabricTableHolder;
     static secure_channel::MessageCounterManager gMessageCounterManager;
@@ -510,7 +510,7 @@ void TestSessionManagerInit(TestContext * ctx, SessionManager & sessionManager)
 
     EXPECT_EQ(CHIP_NO_ERROR, fabricTableHolder.Init());
     EXPECT_EQ(CHIP_NO_ERROR,
-              sessionManager.Init(&ctx->GetSystemLayer(), &ctx->GetTransportMgr(), &gMessageCounterManager, &deviceStorage,
+              sessionManager.Init(&ctx.GetSystemLayer(), &ctx.GetTransportMgr(), &gMessageCounterManager, &deviceStorage,
                                   &fabricTableHolder.GetFabricTable(), sessionKeystore));
 }
 
@@ -549,13 +549,14 @@ CHIP_ERROR InjectGroupSessionWithTestKey(SessionHolder & sessionHolder, MessageT
 
 class TestSessionManagerDispatch : public ::testing::Test
 {
+public:
+    static void SetUpTestSuite() { ASSERT_EQ(mContext.Init(), CHIP_NO_ERROR); }
+    static void TearDownTestSuite() { mContext.Shutdown(); }
+
 protected:
-    TestSessionManagerDispatch() { inContext = new TestContext(); }
-    ~TestSessionManagerDispatch() { delete inContext; }
-    void SetUp() { ASSERT_EQ(inContext->Init(), CHIP_NO_ERROR); }
-    void TearDown() { inContext->Shutdown(); }
-    TestContext * inContext;
+    static TestContext mContext;
 };
+TestContext TestSessionManagerDispatch::mContext;
 
 TEST_F(TestSessionManagerDispatch, TestSessionManagerDispatch)
 {
@@ -564,7 +565,7 @@ TEST_F(TestSessionManagerDispatch, TestSessionManagerDispatch)
     SessionManager sessionManager;
     TestSessionManagerCallback callback;
 
-    TestSessionManagerInit(inContext, sessionManager);
+    TestSessionManagerInit(mContext, sessionManager);
     sessionManager.SetMessageDelegate(&callback);
 
     IPAddress addr;

From 38806bd04779a6d54581b7748a2abd3670f03625 Mon Sep 17 00:00:00 2001
From: Jeff Feasel <jfeasel@csa-iot.org>
Date: Mon, 6 May 2024 13:41:21 -0400
Subject: [PATCH 7/8] Made context a non-pointer which is created/destroyed
 implicitly when each test case is run.

---
 src/transport/tests/TestSessionManager.cpp         | 10 ++++------
 src/transport/tests/TestSessionManagerDispatch.cpp | 10 ++++------
 2 files changed, 8 insertions(+), 12 deletions(-)

diff --git a/src/transport/tests/TestSessionManager.cpp b/src/transport/tests/TestSessionManager.cpp
index b67379fbd3fa20..c5384a7be40328 100644
--- a/src/transport/tests/TestSessionManager.cpp
+++ b/src/transport/tests/TestSessionManager.cpp
@@ -119,14 +119,12 @@ class TestSessMgrCallback : public SessionMessageDelegate
 
 class TestSessionManager : public ::testing::Test
 {
-public:
-    static void SetUpTestSuite() { ASSERT_EQ(mContext.Init(), CHIP_NO_ERROR); }
-    static void TearDownTestSuite() { mContext.Shutdown(); }
-
 protected:
-    static TestContext mContext;
+    void SetUp() { ASSERT_EQ(mContext.Init(), CHIP_NO_ERROR); }
+    void TearDown() { mContext.Shutdown(); }
+
+    TestContext mContext;
 };
-TestContext TestSessionManager::mContext;
 
 TEST_F(TestSessionManager, CheckSimpleInitTest)
 {
diff --git a/src/transport/tests/TestSessionManagerDispatch.cpp b/src/transport/tests/TestSessionManagerDispatch.cpp
index cb7310ae8f9567..f90cb0fa2b21ac 100644
--- a/src/transport/tests/TestSessionManagerDispatch.cpp
+++ b/src/transport/tests/TestSessionManagerDispatch.cpp
@@ -549,14 +549,12 @@ CHIP_ERROR InjectGroupSessionWithTestKey(SessionHolder & sessionHolder, MessageT
 
 class TestSessionManagerDispatch : public ::testing::Test
 {
-public:
-    static void SetUpTestSuite() { ASSERT_EQ(mContext.Init(), CHIP_NO_ERROR); }
-    static void TearDownTestSuite() { mContext.Shutdown(); }
-
 protected:
-    static TestContext mContext;
+    void SetUp() { ASSERT_EQ(mContext.Init(), CHIP_NO_ERROR); }
+    void TearDown() { mContext.Shutdown(); }
+
+    TestContext mContext;
 };
-TestContext TestSessionManagerDispatch::mContext;
 
 TEST_F(TestSessionManagerDispatch, TestSessionManagerDispatch)
 {

From 570ed238f809f4002e8a3c570e1836b4d28891da Mon Sep 17 00:00:00 2001
From: Jeff Feasel <jfeasel@csa-iot.org>
Date: Mon, 6 May 2024 13:46:00 -0400
Subject: [PATCH 8/8] Reordered includes to be consistent with the standard.

---
 src/transport/tests/TestCryptoContext.cpp       |  4 ++--
 src/transport/tests/TestGroupMessageCounter.cpp |  7 +++----
 src/transport/tests/TestPeerConnections.cpp     |  5 +++--
 src/transport/tests/TestPeerMessageCounter.cpp  |  9 +++++----
 src/transport/tests/TestSecureSession.cpp       |  4 ++--
 src/transport/tests/TestSecureSessionTable.cpp  | 10 +++++-----
 6 files changed, 20 insertions(+), 19 deletions(-)

diff --git a/src/transport/tests/TestCryptoContext.cpp b/src/transport/tests/TestCryptoContext.cpp
index 281ad1e92de675..45c3f3e5eb441e 100644
--- a/src/transport/tests/TestCryptoContext.cpp
+++ b/src/transport/tests/TestCryptoContext.cpp
@@ -16,13 +16,13 @@
  *    limitations under the License.
  */
 
-#include <gtest/gtest.h>
 #include <inttypes.h>
 
+#include <gtest/gtest.h>
+
 #include <crypto/CHIPCryptoPAL.h>
 #include <lib/core/CHIPCore.h>
 #include <lib/support/CHIPMem.h>
-
 #include <transport/CryptoContext.h>
 
 using namespace chip;
diff --git a/src/transport/tests/TestGroupMessageCounter.cpp b/src/transport/tests/TestGroupMessageCounter.cpp
index 9ae99dadd1e871..72fe57754e8976 100644
--- a/src/transport/tests/TestGroupMessageCounter.cpp
+++ b/src/transport/tests/TestGroupMessageCounter.cpp
@@ -21,15 +21,14 @@
  *      This file implements unit tests for the SessionManager implementation.
  */
 
+#include <errno.h>
+#include <gtest/gtest.h>
+
 #include <lib/support/DefaultStorageKeyAllocator.h>
 #include <lib/support/TestPersistentStorageDelegate.h>
 #include <transport/GroupPeerMessageCounter.h>
 #include <transport/PeerMessageCounter.h>
 
-#include <gtest/gtest.h>
-
-#include <errno.h>
-
 namespace {
 
 using namespace chip;
diff --git a/src/transport/tests/TestPeerConnections.cpp b/src/transport/tests/TestPeerConnections.cpp
index f15aeb2cc63c4b..9beb263f1d15c8 100644
--- a/src/transport/tests/TestPeerConnections.cpp
+++ b/src/transport/tests/TestPeerConnections.cpp
@@ -22,12 +22,13 @@
  *      the SecureSessionTable class within the transport layer
  *
  */
+
+#include <gtest/gtest.h>
+
 #include <lib/core/ErrorStr.h>
 #include <lib/support/CodeUtils.h>
 #include <transport/SecureSessionTable.h>
 
-#include <gtest/gtest.h>
-
 namespace {
 
 using namespace chip;
diff --git a/src/transport/tests/TestPeerMessageCounter.cpp b/src/transport/tests/TestPeerMessageCounter.cpp
index be1a749982ba69..75f296b1bcba21 100644
--- a/src/transport/tests/TestPeerMessageCounter.cpp
+++ b/src/transport/tests/TestPeerMessageCounter.cpp
@@ -21,13 +21,14 @@
  *      This file implements unit tests for the SessionManager implementation.
  */
 
-#include <transport/MessageCounter.h>
-#include <transport/PeerMessageCounter.h>
-
 #include <errno.h>
-#include <gtest/gtest.h>
 #include <vector>
 
+#include <gtest/gtest.h>
+
+#include <transport/MessageCounter.h>
+#include <transport/PeerMessageCounter.h>
+
 namespace {
 
 using namespace chip;
diff --git a/src/transport/tests/TestSecureSession.cpp b/src/transport/tests/TestSecureSession.cpp
index de90fe98537505..672ba04e8fd38c 100644
--- a/src/transport/tests/TestSecureSession.cpp
+++ b/src/transport/tests/TestSecureSession.cpp
@@ -22,6 +22,8 @@
  */
 
 #include <errno.h>
+#include <stdarg.h>
+
 #include <gtest/gtest.h>
 
 #include <crypto/DefaultSessionKeystore.h>
@@ -29,8 +31,6 @@
 #include <lib/support/CodeUtils.h>
 #include <transport/CryptoContext.h>
 
-#include <stdarg.h>
-
 using namespace chip;
 using namespace Crypto;
 
diff --git a/src/transport/tests/TestSecureSessionTable.cpp b/src/transport/tests/TestSecureSessionTable.cpp
index 92376d3471e5a7..323558a0cecd24 100644
--- a/src/transport/tests/TestSecureSessionTable.cpp
+++ b/src/transport/tests/TestSecureSessionTable.cpp
@@ -21,17 +21,17 @@
  *      This file implements unit tests for the SessionManager implementation.
  */
 
+#include <errno.h>
+#include <vector>
+
+#include <gtest/gtest.h>
+
 #include "system/SystemClock.h"
 #include <lib/core/CHIPCore.h>
 #include <lib/support/CodeUtils.h>
 #include <transport/SecureSessionTable.h>
 #include <transport/SessionHolder.h>
 
-#include <gtest/gtest.h>
-
-#include <errno.h>
-#include <vector>
-
 namespace chip {
 namespace Transport {