diff --git a/src/test_driver/openiotsdk/unit-tests/test_components.txt b/src/test_driver/openiotsdk/unit-tests/test_components.txt
index db6d92b..a509669 100644
--- a/src/test_driver/openiotsdk/unit-tests/test_components.txt
+++ b/src/test_driver/openiotsdk/unit-tests/test_components.txt
@@ -17,5 +17,4 @@
 SupportTests
 UserDirectedCommissioningTests
 SecureChannelTests
-ICDServerTests
-InetLayerTests
+ICDServerTests
\ No newline at end of file
diff --git a/src/test_driver/openiotsdk/unit-tests/test_components_nl.txt b/src/test_driver/openiotsdk/unit-tests/test_components_nl.txt
index e00ff91..941d486 100644
--- a/src/test_driver/openiotsdk/unit-tests/test_components_nl.txt
+++ b/src/test_driver/openiotsdk/unit-tests/test_components_nl.txt
@@ -2,4 +2,3 @@
 DataModelTests
 MessagingLayerTests
 SecureChannelTestsNL
-TransportLayerTests
diff --git a/src/transport/tests/BUILD.gn b/src/transport/tests/BUILD.gn
index 8e3f936..7c38cea 100644
--- a/src/transport/tests/BUILD.gn
+++ b/src/transport/tests/BUILD.gn
@@ -14,7 +14,7 @@
 
 import("//build_overrides/build.gni")
 import("//build_overrides/chip.gni")
-import("//build_overrides/nlunit_test.gni")
+import("//build_overrides/pigweed.gni")
 
 import("${chip_root}/build/chip/chip_test_suite.gni")
 
@@ -31,7 +31,7 @@
   ]
 }
 
-chip_test_suite_using_nltest("tests") {
+chip_test_suite("tests") {
   output_name = "libTransportLayerTests"
 
   test_sources = [
@@ -59,10 +59,8 @@
     "${chip_root}/src/lib/core",
     "${chip_root}/src/lib/support",
     "${chip_root}/src/lib/support:testing",
-    "${chip_root}/src/lib/support:testing_nlunit",
     "${chip_root}/src/protocols",
     "${chip_root}/src/transport",
     "${chip_root}/src/transport/tests:helpers",
-    "${nlunit_test_root}:nlunit-test",
   ]
 }
diff --git a/src/transport/tests/TestCryptoContext.cpp b/src/transport/tests/TestCryptoContext.cpp
index 9bcf0d2..45c3f3e 100644
--- a/src/transport/tests/TestCryptoContext.cpp
+++ b/src/transport/tests/TestCryptoContext.cpp
@@ -17,13 +17,12 @@
  */
 
 #include <inttypes.h>
-#include <nlunit-test.h>
+
+#include <gtest/gtest.h>
 
 #include <crypto/CHIPCryptoPAL.h>
 #include <lib/core/CHIPCore.h>
 #include <lib/support/CHIPMem.h>
-#include <lib/support/UnitTestRegistration.h>
-
 #include <transport/CryptoContext.h>
 
 using namespace chip;
@@ -48,7 +47,14 @@
     },
 };
 
-void TestBuildPrivacyNonce(nlTestSuite * apSuite, void * apContext)
+class TestGroupCryptoContext : public ::testing::Test
+{
+public:
+    static void SetUpTestSuite() { ASSERT_EQ(chip::Platform::MemoryInit(), CHIP_NO_ERROR); }
+    static void TearDownTestSuite() { chip::Platform::MemoryShutdown(); }
+};
+
+TEST_F(TestGroupCryptoContext, TestBuildPrivacyNonce)
 {
     for (const auto & testVector : thePrivacyNonceTestVector)
     {
@@ -60,47 +66,9 @@
 
         mic.SetTag(nullptr, testVector.mic, MIC_LENGTH);
 
-        NL_TEST_ASSERT(apSuite, CHIP_NO_ERROR == chip::CryptoContext::BuildPrivacyNonce(privacyNonce, sessionId, mic));
-        NL_TEST_ASSERT(apSuite, 0 == memcmp(privacyNonceView.data(), expectedPrivacyNonce.data(), NONCE_LENGTH));
+        EXPECT_EQ(CHIP_NO_ERROR, chip::CryptoContext::BuildPrivacyNonce(privacyNonce, sessionId, mic));
+        EXPECT_EQ(0, memcmp(privacyNonceView.data(), expectedPrivacyNonce.data(), NONCE_LENGTH));
     }
 }
 
-/**
- *   Test Suite. It lists all the test functions.
- */
-const nlTest sTests[] = { NL_TEST_DEF("TestBuildPrivacyNonce", TestBuildPrivacyNonce), NL_TEST_SENTINEL() };
-
-/**
- *  Set up the test suite.
- */
-int Test_Setup(void * inContext)
-{
-    CHIP_ERROR error = chip::Platform::MemoryInit();
-    VerifyOrReturnError(error == CHIP_NO_ERROR, FAILURE);
-    return SUCCESS;
-}
-
-/**
- *  Tear down the test suite.
- */
-int Test_Teardown(void * inContext)
-{
-    chip::Platform::MemoryShutdown();
-    return SUCCESS;
-}
-
 } // namespace
-
-/**
- *  Main
- */
-int TestGroupCryptoContext()
-{
-    nlTestSuite theSuite = { "TestGroupCryptoContext", &sTests[0], Test_Setup, Test_Teardown };
-
-    // Run test suite againt one context.
-    nlTestRunner(&theSuite, nullptr);
-    return nlTestRunnerStats(&theSuite);
-}
-
-CHIP_REGISTER_TEST_SUITE(TestGroupCryptoContext)
diff --git a/src/transport/tests/TestGroupMessageCounter.cpp b/src/transport/tests/TestGroupMessageCounter.cpp
index 8e3101e..72fe577 100644
--- a/src/transport/tests/TestGroupMessageCounter.cpp
+++ b/src/transport/tests/TestGroupMessageCounter.cpp
@@ -21,17 +21,14 @@
  *      This file implements unit tests for the SessionManager implementation.
  */
 
+#include <errno.h>
+#include <gtest/gtest.h>
+
 #include <lib/support/DefaultStorageKeyAllocator.h>
 #include <lib/support/TestPersistentStorageDelegate.h>
-#include <lib/support/UnitTestRegistration.h>
 #include <transport/GroupPeerMessageCounter.h>
 #include <transport/PeerMessageCounter.h>
 
-#include <nlbyteorder.h>
-#include <nlunit-test.h>
-
-#include <errno.h>
-
 namespace {
 
 using namespace chip;
@@ -101,11 +98,11 @@
     }
 };
 
-void AddPeerTest(nlTestSuite * inSuite, void * inContext)
+TEST(TestGroupMessageCounter, AddPeerTest)
 {
     NodeId peerNodeId                             = 1234;
     FabricIndex fabricIndex                       = 1;
-    uint32_t i                                    = 0;
+    int i                                         = 0;
     CHIP_ERROR err                                = CHIP_NO_ERROR;
     chip::Transport::PeerMessageCounter * counter = nullptr;
     chip::Transport::GroupPeerTable mGroupPeerMsgCounter;
@@ -117,7 +114,7 @@
 
     } while (err != CHIP_ERROR_TOO_MANY_PEER_NODES);
 
-    NL_TEST_ASSERT(inSuite, i == CHIP_CONFIG_MAX_GROUP_DATA_PEERS + 1);
+    EXPECT_EQ(i, CHIP_CONFIG_MAX_GROUP_DATA_PEERS + 1);
 
     i = 1;
     do
@@ -125,10 +122,10 @@
         err = mGroupPeerMsgCounter.FindOrAddPeer(++fabricIndex, peerNodeId, false, counter);
         i++;
     } while (err != CHIP_ERROR_TOO_MANY_PEER_NODES);
-    NL_TEST_ASSERT(inSuite, i == CHIP_CONFIG_MAX_FABRICS + 1);
+    EXPECT_EQ(i, CHIP_CONFIG_MAX_FABRICS + 1);
 }
 
-void RemovePeerTest(nlTestSuite * inSuite, void * inContext)
+TEST(TestGroupMessageCounter, RemovePeerTest)
 {
     NodeId peerNodeId                             = 1234;
     FabricIndex fabricIndex                       = 1;
@@ -147,7 +144,7 @@
     }
     // Verify that table is indeed full (for control Peer)
     err = mGroupPeerMsgCounter.FindOrAddPeer(99, 99, true, counter);
-    NL_TEST_ASSERT(inSuite, err == CHIP_ERROR_TOO_MANY_PEER_NODES);
+    EXPECT_EQ(err, CHIP_ERROR_TOO_MANY_PEER_NODES);
 
     // Clear all Peer
     fabricIndex = 1;
@@ -157,39 +154,39 @@
         for (uint32_t peerId = 0; peerId < CHIP_CONFIG_MAX_GROUP_CONTROL_PEERS; peerId++)
         {
             err = mGroupPeerMsgCounter.RemovePeer(fabricIndex, peerNodeId++, true);
-            NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
+            EXPECT_EQ(err, CHIP_NO_ERROR);
         }
         fabricIndex++;
     }
 
     // Try re-adding the previous peer without any error
     err = mGroupPeerMsgCounter.FindOrAddPeer(99, 99, true, counter);
-    NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
+    EXPECT_EQ(err, CHIP_NO_ERROR);
 
     err = mGroupPeerMsgCounter.FindOrAddPeer(104, 99, true, counter);
-    NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
+    EXPECT_EQ(err, CHIP_NO_ERROR);
 
     err = mGroupPeerMsgCounter.FindOrAddPeer(105, 99, true, counter);
-    NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
+    EXPECT_EQ(err, CHIP_NO_ERROR);
 
     err = mGroupPeerMsgCounter.FindOrAddPeer(106, 99, true, counter);
-    NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
+    EXPECT_EQ(err, CHIP_NO_ERROR);
 
     // Fabric removal test
     err = mGroupPeerMsgCounter.FabricRemoved(123);
-    NL_TEST_ASSERT(inSuite, err == CHIP_ERROR_NOT_FOUND);
+    EXPECT_EQ(err, CHIP_ERROR_NOT_FOUND);
 
     err = mGroupPeerMsgCounter.FabricRemoved(99);
-    NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
+    EXPECT_EQ(err, CHIP_NO_ERROR);
 
     err = mGroupPeerMsgCounter.FabricRemoved(99);
-    NL_TEST_ASSERT(inSuite, err == CHIP_ERROR_NOT_FOUND);
+    EXPECT_EQ(err, CHIP_ERROR_NOT_FOUND);
 
     // Verify that the Fabric List was compacted.
-    NL_TEST_ASSERT(inSuite, 106 == mGroupPeerMsgCounter.GetFabricIndexAt(0));
+    EXPECT_EQ(106, mGroupPeerMsgCounter.GetFabricIndexAt(0));
 }
 
-void PeerRetrievalTest(nlTestSuite * inSuite, void * inContext)
+TEST(TestGroupMessageCounter, PeerRetrievalTest)
 {
     NodeId peerNodeId                              = 1234;
     FabricIndex fabricIndex                        = 1;
@@ -199,120 +196,120 @@
     chip::Transport::GroupPeerTable mGroupPeerMsgCounter;
 
     err = mGroupPeerMsgCounter.FindOrAddPeer(fabricIndex, peerNodeId, true, counter);
-    NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
-    NL_TEST_ASSERT(inSuite, counter != nullptr);
+    EXPECT_EQ(err, CHIP_NO_ERROR);
+    EXPECT_NE(counter, nullptr);
 
     err = mGroupPeerMsgCounter.FindOrAddPeer(99, 99, true, counter2);
-    NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
-    NL_TEST_ASSERT(inSuite, counter2 != nullptr);
-    NL_TEST_ASSERT(inSuite, counter2 != counter);
+    EXPECT_EQ(err, CHIP_NO_ERROR);
+    EXPECT_NE(counter2, nullptr);
+    EXPECT_NE(counter2, counter);
 
     err = mGroupPeerMsgCounter.FindOrAddPeer(fabricIndex, peerNodeId, true, counter2);
-    NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
-    NL_TEST_ASSERT(inSuite, counter2 == counter);
+    EXPECT_EQ(err, CHIP_NO_ERROR);
+    EXPECT_EQ(counter2, counter);
 }
 
-void CounterCommitRolloverTest(nlTestSuite * inSuite, void * inContext)
+TEST(TestGroupMessageCounter, CounterCommitRolloverTest)
 {
     CHIP_ERROR err                                = CHIP_NO_ERROR;
     chip::Transport::PeerMessageCounter * counter = nullptr;
     chip::Transport::GroupPeerTable mGroupPeerMsgCounter;
 
     err = mGroupPeerMsgCounter.FindOrAddPeer(99, 99, true, counter);
-    NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
-    NL_TEST_ASSERT(inSuite, counter != nullptr);
+    EXPECT_EQ(err, CHIP_NO_ERROR);
+    EXPECT_NE(counter, nullptr);
 
     err = counter->VerifyOrTrustFirstGroup(UINT32_MAX);
-    NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
+    EXPECT_EQ(err, CHIP_NO_ERROR);
 
     counter->CommitGroup(UINT32_MAX);
 
     err = counter->VerifyOrTrustFirstGroup(0);
-    NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
+    EXPECT_EQ(err, CHIP_NO_ERROR);
 
     counter->CommitGroup(0);
 
     err = counter->VerifyOrTrustFirstGroup(1);
-    NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
+    EXPECT_EQ(err, CHIP_NO_ERROR);
 
     counter->CommitGroup(1);
 }
 
-void CounterTrustFirstTest(nlTestSuite * inSuite, void * inContext)
+TEST(TestGroupMessageCounter, CounterTrustFirstTest)
 {
     CHIP_ERROR err                                = CHIP_NO_ERROR;
     chip::Transport::PeerMessageCounter * counter = nullptr;
     chip::Transport::GroupPeerTable mGroupPeerMsgCounter;
 
     err = mGroupPeerMsgCounter.FindOrAddPeer(99, 99, true, counter);
-    NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
-    NL_TEST_ASSERT(inSuite, counter != nullptr);
+    EXPECT_EQ(err, CHIP_NO_ERROR);
+    EXPECT_NE(counter, nullptr);
 
     err = counter->VerifyOrTrustFirstGroup(5656);
-    NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
+    EXPECT_EQ(err, CHIP_NO_ERROR);
 
     counter->CommitGroup(5656);
 
     err = counter->VerifyOrTrustFirstGroup(5756);
-    NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
+    EXPECT_EQ(err, CHIP_NO_ERROR);
     counter->CommitGroup(5756);
     err = counter->VerifyOrTrustFirstGroup(4756);
-    NL_TEST_ASSERT(inSuite, err != CHIP_NO_ERROR);
+    EXPECT_NE(err, CHIP_NO_ERROR);
 
     // test sequential reception
     err = counter->VerifyOrTrustFirstGroup(5757);
-    NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
+    EXPECT_EQ(err, CHIP_NO_ERROR);
     counter->CommitGroup(5757);
 
     err = counter->VerifyOrTrustFirstGroup(5758);
-    NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
+    EXPECT_EQ(err, CHIP_NO_ERROR);
     counter->CommitGroup(5758);
 
     err = counter->VerifyOrTrustFirstGroup(5756);
-    NL_TEST_ASSERT(inSuite, err != CHIP_NO_ERROR);
+    EXPECT_NE(err, CHIP_NO_ERROR);
 
     // Test Roll over
     err = mGroupPeerMsgCounter.FindOrAddPeer(1, 99, true, counter);
-    NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
-    NL_TEST_ASSERT(inSuite, counter != nullptr);
+    EXPECT_EQ(err, CHIP_NO_ERROR);
+    EXPECT_NE(counter, nullptr);
 
     err = counter->VerifyOrTrustFirstGroup(UINT32_MAX - 6);
-    NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
+    EXPECT_EQ(err, CHIP_NO_ERROR);
     counter->CommitGroup(UINT32_MAX - 6);
 
     err = counter->VerifyOrTrustFirstGroup(UINT32_MAX - 1);
-    NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
+    EXPECT_EQ(err, CHIP_NO_ERROR);
     counter->CommitGroup(UINT32_MAX - 1);
 
     err = counter->VerifyOrTrustFirstGroup(UINT32_MAX);
-    NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
+    EXPECT_EQ(err, CHIP_NO_ERROR);
 
     err = counter->VerifyOrTrustFirstGroup(0);
-    NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
+    EXPECT_EQ(err, CHIP_NO_ERROR);
 
     err = counter->VerifyOrTrustFirstGroup(1);
-    NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
+    EXPECT_EQ(err, CHIP_NO_ERROR);
 
     err = counter->VerifyOrTrustFirstGroup(2);
-    NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
+    EXPECT_EQ(err, CHIP_NO_ERROR);
 
     err = counter->VerifyOrTrustFirstGroup(3);
-    NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
+    EXPECT_EQ(err, CHIP_NO_ERROR);
 
     err = counter->VerifyOrTrustFirstGroup(4);
-    NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
+    EXPECT_EQ(err, CHIP_NO_ERROR);
 
     err = counter->VerifyOrTrustFirstGroup(5);
-    NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
+    EXPECT_EQ(err, CHIP_NO_ERROR);
 
     err = counter->VerifyOrTrustFirstGroup(6);
-    NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
+    EXPECT_EQ(err, CHIP_NO_ERROR);
 
     err = counter->VerifyOrTrustFirstGroup(7);
-    NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
+    EXPECT_EQ(err, CHIP_NO_ERROR);
 }
 
-void ReorderPeerRemovalTest(nlTestSuite * inSuite, void * inContext)
+TEST(TestGroupMessageCounter, ReorderPeerRemovalTest)
 {
     CHIP_ERROR err                                = CHIP_NO_ERROR;
     chip::Transport::PeerMessageCounter * counter = nullptr;
@@ -322,7 +319,7 @@
     err = mGroupPeerMsgCounter.FindOrAddPeer(1, 2, true, counter);
     err = mGroupPeerMsgCounter.RemovePeer(1, 1, true);
 
-    NL_TEST_ASSERT(inSuite, mGroupPeerMsgCounter.GetNodeIdAt(0, 0, true) == 2);
+    EXPECT_EQ(mGroupPeerMsgCounter.GetNodeIdAt(0, 0, true), 2u);
 
     // with other list
     err = mGroupPeerMsgCounter.FindOrAddPeer(2, 1, false, counter);
@@ -336,19 +333,19 @@
     err = mGroupPeerMsgCounter.FindOrAddPeer(2, 9, false, counter);
 
     err = mGroupPeerMsgCounter.RemovePeer(2, 7, false);
-    NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
-    NL_TEST_ASSERT(inSuite, mGroupPeerMsgCounter.GetNodeIdAt(1, 6, false) == 9);
+    EXPECT_EQ(err, CHIP_NO_ERROR);
+    EXPECT_EQ(mGroupPeerMsgCounter.GetNodeIdAt(1, 6, false), 9u);
 
     err = mGroupPeerMsgCounter.RemovePeer(2, 4, false);
-    NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
-    NL_TEST_ASSERT(inSuite, mGroupPeerMsgCounter.GetNodeIdAt(1, 3, false) == 8);
+    EXPECT_EQ(err, CHIP_NO_ERROR);
+    EXPECT_EQ(mGroupPeerMsgCounter.GetNodeIdAt(1, 3, false), 8u);
 
     err = mGroupPeerMsgCounter.RemovePeer(2, 1, false);
-    NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
-    NL_TEST_ASSERT(inSuite, mGroupPeerMsgCounter.GetNodeIdAt(1, 0, false) == 9);
+    EXPECT_EQ(err, CHIP_NO_ERROR);
+    EXPECT_EQ(mGroupPeerMsgCounter.GetNodeIdAt(1, 0, false), 9u);
 }
 
-void ReorderFabricRemovalTest(nlTestSuite * inSuite, void * inContext)
+TEST(TestGroupMessageCounter, ReorderFabricRemovalTest)
 {
     CHIP_ERROR err                                = CHIP_NO_ERROR;
     chip::Transport::PeerMessageCounter * counter = nullptr;
@@ -357,49 +354,49 @@
     for (uint8_t i = 0; i < CHIP_CONFIG_MAX_FABRICS; i++)
     {
         err = mGroupPeerMsgCounter.FindOrAddPeer(static_cast<chip::FabricIndex>(i + 1), 1, false, counter);
-        NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
+        EXPECT_EQ(err, CHIP_NO_ERROR);
     }
 
     // Try removing last Fabric first
     err = counter->VerifyOrTrustFirstGroup(1234);
-    NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
+    EXPECT_EQ(err, CHIP_NO_ERROR);
     counter->CommitGroup(1234);
 
     err = mGroupPeerMsgCounter.FabricRemoved(CHIP_CONFIG_MAX_FABRICS);
-    NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
-    NL_TEST_ASSERT(inSuite, mGroupPeerMsgCounter.GetFabricIndexAt(CHIP_CONFIG_MAX_FABRICS - 1) == kUndefinedFabricIndex);
+    EXPECT_EQ(err, CHIP_NO_ERROR);
+    EXPECT_EQ(mGroupPeerMsgCounter.GetFabricIndexAt(CHIP_CONFIG_MAX_FABRICS - 1), kUndefinedFabricIndex);
 
     err = mGroupPeerMsgCounter.FindOrAddPeer(CHIP_CONFIG_MAX_FABRICS, 1, false, counter);
-    NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
+    EXPECT_EQ(err, CHIP_NO_ERROR);
 
     // Verify that the counter was indeed cleared
     err = counter->VerifyOrTrustFirstGroup(1234);
-    NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
+    EXPECT_EQ(err, CHIP_NO_ERROR);
 
     // Set a counter that will be moved around
     err = counter->VerifyOrTrustFirstGroup(5656);
-    NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
+    EXPECT_EQ(err, CHIP_NO_ERROR);
     counter->CommitGroup(5656);
 
     err = counter->VerifyOrTrustFirstGroup(4756);
-    NL_TEST_ASSERT(inSuite, err != CHIP_NO_ERROR);
+    EXPECT_NE(err, CHIP_NO_ERROR);
 
     // Per Spec CHIP_CONFIG_MAX_FABRICS can only be as low as 4
     err = mGroupPeerMsgCounter.RemovePeer(3, 1, false);
-    NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
-    NL_TEST_ASSERT(inSuite, mGroupPeerMsgCounter.GetFabricIndexAt(2) == CHIP_CONFIG_MAX_FABRICS);
+    EXPECT_EQ(err, CHIP_NO_ERROR);
+    EXPECT_EQ(mGroupPeerMsgCounter.GetFabricIndexAt(2), CHIP_CONFIG_MAX_FABRICS);
     err = mGroupPeerMsgCounter.RemovePeer(2, 1, false);
-    NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
-    NL_TEST_ASSERT(inSuite, mGroupPeerMsgCounter.GetFabricIndexAt(1) == CHIP_CONFIG_MAX_FABRICS - 1);
+    EXPECT_EQ(err, CHIP_NO_ERROR);
+    EXPECT_EQ(mGroupPeerMsgCounter.GetFabricIndexAt(1), CHIP_CONFIG_MAX_FABRICS - 1);
 
     // Validate that counter value were moved around correctly
     err = mGroupPeerMsgCounter.FindOrAddPeer(CHIP_CONFIG_MAX_FABRICS, 1, false, counter);
-    NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
+    EXPECT_EQ(err, CHIP_NO_ERROR);
     err = counter->VerifyOrTrustFirstGroup(4756);
-    NL_TEST_ASSERT(inSuite, err != CHIP_NO_ERROR);
+    EXPECT_NE(err, CHIP_NO_ERROR);
 }
 
-void GroupMessageCounterTest(nlTestSuite * inSuite, void * inContext)
+TEST(TestGroupMessageCounter, GroupMessageCounterTest)
 {
 
     chip::TestPersistentStorageDelegate delegate;
@@ -407,7 +404,7 @@
     uint32_t controlCounter = 0, dataCounter = 0;
     CHIP_ERROR err = groupCientCounter.Init(&delegate);
 
-    NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
+    EXPECT_EQ(err, CHIP_NO_ERROR);
 
     // Start Test with Control counter
     // Counter should be random
@@ -415,78 +412,45 @@
     dataCounter    = groupCientCounter.GetCounter(false);
     groupCientCounter.IncrementCounter(true);
 
-    NL_TEST_ASSERT(inSuite, (groupCientCounter.GetCounter(true) - controlCounter) == 1);
+    EXPECT_EQ((groupCientCounter.GetCounter(true) - controlCounter), 1u);
 
     groupCientCounter.SetCounter(true, UINT32_MAX - GROUP_MSG_COUNTER_MIN_INCREMENT);
-    NL_TEST_ASSERT(inSuite, groupCientCounter.GetCounter(true) == UINT32_MAX - GROUP_MSG_COUNTER_MIN_INCREMENT);
+    EXPECT_EQ(groupCientCounter.GetCounter(true), UINT32_MAX - GROUP_MSG_COUNTER_MIN_INCREMENT);
 
     // Test Persistence
     TestGroupOutgoingCounters groupCientCounter2(&delegate);
 
-    NL_TEST_ASSERT(inSuite, groupCientCounter2.GetCounter(true) == UINT32_MAX);
-    NL_TEST_ASSERT(inSuite, (groupCientCounter2.GetCounter(false) - dataCounter) == GROUP_MSG_COUNTER_MIN_INCREMENT);
+    EXPECT_EQ(groupCientCounter2.GetCounter(true), UINT32_MAX);
+    EXPECT_EQ((groupCientCounter2.GetCounter(false) - dataCounter), (uint32_t) GROUP_MSG_COUNTER_MIN_INCREMENT);
 
     // Test Roll over
     groupCientCounter2.IncrementCounter(true);
-    NL_TEST_ASSERT(inSuite, groupCientCounter2.GetCounter(true) == 0);
+    EXPECT_EQ(groupCientCounter2.GetCounter(true), 0u);
 
     TestGroupOutgoingCounters groupCientCounter3(&delegate);
-    NL_TEST_ASSERT(inSuite, groupCientCounter3.GetCounter(true) == (UINT32_MAX + GROUP_MSG_COUNTER_MIN_INCREMENT));
+    EXPECT_EQ(groupCientCounter3.GetCounter(true), (UINT32_MAX + GROUP_MSG_COUNTER_MIN_INCREMENT));
 
     // Redo the test with the second counter
 
     // Start Test with Control counter
     dataCounter = groupCientCounter.GetCounter(false);
     groupCientCounter.IncrementCounter(false);
-    NL_TEST_ASSERT(inSuite, (groupCientCounter.GetCounter(false) - dataCounter) == 1);
+    EXPECT_EQ((groupCientCounter.GetCounter(false) - dataCounter), 1u);
 
     groupCientCounter.SetCounter(false, UINT32_MAX - GROUP_MSG_COUNTER_MIN_INCREMENT);
-    NL_TEST_ASSERT(inSuite, groupCientCounter.GetCounter(false) == UINT32_MAX - GROUP_MSG_COUNTER_MIN_INCREMENT);
+    EXPECT_EQ(groupCientCounter.GetCounter(false), UINT32_MAX - GROUP_MSG_COUNTER_MIN_INCREMENT);
 
     // Test Persistence
     TestGroupOutgoingCounters groupCientCounter4(&delegate);
 
-    NL_TEST_ASSERT(inSuite, groupCientCounter4.GetCounter(false) == UINT32_MAX);
+    EXPECT_EQ(groupCientCounter4.GetCounter(false), UINT32_MAX);
 
     // Test Roll over
     groupCientCounter4.IncrementCounter(false);
-    NL_TEST_ASSERT(inSuite, groupCientCounter4.GetCounter(false) == 0);
+    EXPECT_EQ(groupCientCounter4.GetCounter(false), 0u);
 
     TestGroupOutgoingCounters groupCientCounter5(&delegate);
-    NL_TEST_ASSERT(inSuite, groupCientCounter5.GetCounter(false) == (UINT32_MAX + GROUP_MSG_COUNTER_MIN_INCREMENT));
+    EXPECT_EQ(groupCientCounter5.GetCounter(false), (UINT32_MAX + GROUP_MSG_COUNTER_MIN_INCREMENT));
 }
 
 } // namespace
-
-/**
- *  Test Suite that lists all the test functions.
- */
-// clang-format off
-const nlTest sTests[] =
-{
-    NL_TEST_DEF("Add Peer",               AddPeerTest),
-    NL_TEST_DEF("Remove Peer",            RemovePeerTest),
-    NL_TEST_DEF("Peer retrieval",         PeerRetrievalTest),
-    NL_TEST_DEF("Counter Rollover",       CounterCommitRolloverTest),
-    NL_TEST_DEF("Counter Trust first",    CounterTrustFirstTest),
-    NL_TEST_DEF("Reorder Peer removal",   ReorderPeerRemovalTest),
-    NL_TEST_DEF("Reorder Fabric Removal", ReorderFabricRemovalTest),
-    NL_TEST_DEF("Group Message Counter",  GroupMessageCounterTest),
-    NL_TEST_SENTINEL()
-};
-// clang-format on
-
-/**
- *  Main
- */
-int TestGroupMessageCounter()
-{
-    // Run test suit against one context
-
-    nlTestSuite theSuite = { "Transport-TestGroupMessageCounter", &sTests[0], nullptr, nullptr };
-    nlTestRunner(&theSuite, nullptr);
-
-    return (nlTestRunnerStats(&theSuite));
-}
-
-CHIP_REGISTER_TEST_SUITE(TestGroupMessageCounter);
diff --git a/src/transport/tests/TestPeerConnections.cpp b/src/transport/tests/TestPeerConnections.cpp
index f4ea8c4..9beb263 100644
--- a/src/transport/tests/TestPeerConnections.cpp
+++ b/src/transport/tests/TestPeerConnections.cpp
@@ -22,13 +22,13 @@
  *      the SecureSessionTable class within the transport layer
  *
  */
+
+#include <gtest/gtest.h>
+
 #include <lib/core/ErrorStr.h>
 #include <lib/support/CodeUtils.h>
-#include <lib/support/UnitTestRegistration.h>
 #include <transport/SecureSessionTable.h>
 
-#include <nlunit-test.h>
-
 namespace {
 
 using namespace chip;
@@ -56,7 +56,14 @@
 const CATValues kPeer1CATs = { { 0xABCD0001, 0xABCE0100, 0xABCD0020 } };
 const CATValues kPeer2CATs = { { 0xABCD0012, kUndefinedCAT, kUndefinedCAT } };
 
-void TestBasicFunctionality(nlTestSuite * inSuite, void * inContext)
+class TestPeerConnections : public ::testing::Test
+{
+public:
+    static void SetUpTestSuite() { ASSERT_EQ(chip::Platform::MemoryInit(), CHIP_NO_ERROR); }
+    static void TearDownTestSuite() { chip::Platform::MemoryShutdown(); }
+};
+
+TEST_F(TestPeerConnections, TestBasicFunctionality)
 {
     SecureSessionTable connections;
     System::Clock::Internal::MockClock clock;
@@ -69,27 +76,27 @@
     // First node, peer session id 1, local session id 2
     auto optionalSession = connections.CreateNewSecureSessionForTest(SecureSession::Type::kCASE, 2, kLocalNodeId, kCasePeer1NodeId,
                                                                      kPeer1CATs, 1, kFabricIndex, GetDefaultMRPConfig());
-    NL_TEST_ASSERT(inSuite, optionalSession.HasValue());
-    NL_TEST_ASSERT(inSuite, optionalSession.Value()->AsSecureSession()->GetSecureSessionType() == SecureSession::Type::kCASE);
-    NL_TEST_ASSERT(inSuite, optionalSession.Value()->AsSecureSession()->GetPeerNodeId() == kCasePeer1NodeId);
-    NL_TEST_ASSERT(inSuite, optionalSession.Value()->AsSecureSession()->GetLocalNodeId() == kLocalNodeId);
-    NL_TEST_ASSERT(inSuite, optionalSession.Value()->GetPeer() == ScopedNodeId(kCasePeer1NodeId, kFabricIndex));
-    NL_TEST_ASSERT(inSuite, optionalSession.Value()->GetLocalScopedNodeId() == ScopedNodeId(kLocalNodeId, kFabricIndex));
+    EXPECT_TRUE(optionalSession.HasValue());
+    EXPECT_EQ(optionalSession.Value()->AsSecureSession()->GetSecureSessionType(), SecureSession::Type::kCASE);
+    EXPECT_EQ(optionalSession.Value()->AsSecureSession()->GetPeerNodeId(), kCasePeer1NodeId);
+    EXPECT_EQ(optionalSession.Value()->AsSecureSession()->GetLocalNodeId(), kLocalNodeId);
+    EXPECT_EQ(optionalSession.Value()->GetPeer(), ScopedNodeId(kCasePeer1NodeId, kFabricIndex));
+    EXPECT_EQ(optionalSession.Value()->GetLocalScopedNodeId(), ScopedNodeId(kLocalNodeId, kFabricIndex));
     peerCATs = optionalSession.Value()->AsSecureSession()->GetPeerCATs();
-    NL_TEST_ASSERT(inSuite, memcmp(&peerCATs, &kPeer1CATs, sizeof(CATValues)) == 0);
+    EXPECT_EQ(memcmp(&peerCATs, &kPeer1CATs, sizeof(CATValues)), 0);
 
     // Second node, peer session id 3, local session id 4
     optionalSession = connections.CreateNewSecureSessionForTest(SecureSession::Type::kCASE, 4, kLocalNodeId, kCasePeer2NodeId,
                                                                 kPeer2CATs, 3, kFabricIndex, GetDefaultMRPConfig());
-    NL_TEST_ASSERT(inSuite, optionalSession.HasValue());
-    NL_TEST_ASSERT(inSuite, optionalSession.Value()->AsSecureSession()->GetSecureSessionType() == SecureSession::Type::kCASE);
-    NL_TEST_ASSERT(inSuite, optionalSession.Value()->AsSecureSession()->GetPeerNodeId() == kCasePeer2NodeId);
-    NL_TEST_ASSERT(inSuite, optionalSession.Value()->AsSecureSession()->GetLocalNodeId() == kLocalNodeId);
-    NL_TEST_ASSERT(inSuite, optionalSession.Value()->GetPeer() == ScopedNodeId(kCasePeer2NodeId, kFabricIndex));
-    NL_TEST_ASSERT(inSuite, optionalSession.Value()->GetLocalScopedNodeId() == ScopedNodeId(kLocalNodeId, kFabricIndex));
-    NL_TEST_ASSERT(inSuite, optionalSession.Value()->AsSecureSession()->GetLastActivityTime() == 100_ms64);
+    EXPECT_TRUE(optionalSession.HasValue());
+    EXPECT_EQ(optionalSession.Value()->AsSecureSession()->GetSecureSessionType(), SecureSession::Type::kCASE);
+    EXPECT_EQ(optionalSession.Value()->AsSecureSession()->GetPeerNodeId(), kCasePeer2NodeId);
+    EXPECT_EQ(optionalSession.Value()->AsSecureSession()->GetLocalNodeId(), kLocalNodeId);
+    EXPECT_EQ(optionalSession.Value()->GetPeer(), ScopedNodeId(kCasePeer2NodeId, kFabricIndex));
+    EXPECT_EQ(optionalSession.Value()->GetLocalScopedNodeId(), ScopedNodeId(kLocalNodeId, kFabricIndex));
+    EXPECT_EQ(optionalSession.Value()->AsSecureSession()->GetLastActivityTime(), 100_ms64);
     peerCATs = optionalSession.Value()->AsSecureSession()->GetPeerCATs();
-    NL_TEST_ASSERT(inSuite, memcmp(&peerCATs, &kPeer2CATs, sizeof(CATValues)) == 0);
+    EXPECT_EQ(memcmp(&peerCATs, &kPeer2CATs, sizeof(CATValues)), 0);
 
     //
     // Fill up the session table.
@@ -99,14 +106,14 @@
         sessions[i] = connections.CreateNewSecureSessionForTest(
             SecureSession::Type::kCASE, static_cast<uint16_t>(static_cast<uint16_t>(i) + 6u), kLocalNodeId, kCasePeer2NodeId,
             kPeer2CATs, 3, kFabricIndex, GetDefaultMRPConfig());
-        NL_TEST_ASSERT(inSuite, sessions[i].HasValue());
+        EXPECT_TRUE(sessions[i].HasValue());
     }
 
     // #endif
     System::Clock::Internal::SetSystemClockForTesting(realClock);
 }
 
-void TestFindByKeyId(nlTestSuite * inSuite, void * inContext)
+TEST_F(TestPeerConnections, TestFindByKeyId)
 {
     SecureSessionTable connections;
     System::Clock::Internal::MockClock clock;
@@ -116,18 +123,18 @@
     // First node, peer session id 1, local session id 2
     auto optionalSession = connections.CreateNewSecureSessionForTest(SecureSession::Type::kCASE, 2, kLocalNodeId, kCasePeer1NodeId,
                                                                      kPeer1CATs, 1, kFabricIndex, GetDefaultMRPConfig());
-    NL_TEST_ASSERT(inSuite, optionalSession.HasValue());
+    EXPECT_TRUE(optionalSession.HasValue());
 
-    NL_TEST_ASSERT(inSuite, !connections.FindSecureSessionByLocalKey(1).HasValue());
-    NL_TEST_ASSERT(inSuite, connections.FindSecureSessionByLocalKey(2).HasValue());
+    EXPECT_FALSE(connections.FindSecureSessionByLocalKey(1).HasValue());
+    EXPECT_TRUE(connections.FindSecureSessionByLocalKey(2).HasValue());
 
     // Second node, peer session id 3, local session id 4
     optionalSession = connections.CreateNewSecureSessionForTest(SecureSession::Type::kCASE, 4, kLocalNodeId, kCasePeer2NodeId,
                                                                 kPeer2CATs, 3, kFabricIndex, GetDefaultMRPConfig());
-    NL_TEST_ASSERT(inSuite, optionalSession.HasValue());
+    EXPECT_TRUE(optionalSession.HasValue());
 
-    NL_TEST_ASSERT(inSuite, !connections.FindSecureSessionByLocalKey(3).HasValue());
-    NL_TEST_ASSERT(inSuite, connections.FindSecureSessionByLocalKey(4).HasValue());
+    EXPECT_FALSE(connections.FindSecureSessionByLocalKey(3).HasValue());
+    EXPECT_TRUE(connections.FindSecureSessionByLocalKey(4).HasValue());
 
     System::Clock::Internal::SetSystemClockForTesting(realClock);
 }
@@ -139,34 +146,4 @@
     PeerAddress lastCallPeerAddress = PeerAddress::Uninitialized();
 };
 
-int Initialize(void * apSuite)
-{
-    VerifyOrReturnError(chip::Platform::MemoryInit() == CHIP_NO_ERROR, FAILURE);
-    return SUCCESS;
-}
-
-int Finalize(void * aContext)
-{
-    chip::Platform::MemoryShutdown();
-    return SUCCESS;
-}
-
 } // namespace
-
-// clang-format off
-static const nlTest sTests[] =
-{
-    NL_TEST_DEF("BasicFunctionality", TestBasicFunctionality),
-    NL_TEST_DEF("FindByKeyId", TestFindByKeyId),
-    NL_TEST_SENTINEL()
-};
-// clang-format on
-
-int TestPeerConnectionsFn()
-{
-    nlTestSuite theSuite = { "Transport-SecureSessionTable", &sTests[0], Initialize, Finalize };
-    nlTestRunner(&theSuite, nullptr);
-    return nlTestRunnerStats(&theSuite);
-}
-
-CHIP_REGISTER_TEST_SUITE(TestPeerConnectionsFn)
diff --git a/src/transport/tests/TestPeerMessageCounter.cpp b/src/transport/tests/TestPeerMessageCounter.cpp
index 2c10ce4..75f296b 100644
--- a/src/transport/tests/TestPeerMessageCounter.cpp
+++ b/src/transport/tests/TestPeerMessageCounter.cpp
@@ -21,38 +21,37 @@
  *      This file implements unit tests for the SessionManager implementation.
  */
 
-#include <lib/support/UnitTestRegistration.h>
+#include <errno.h>
+#include <vector>
+
+#include <gtest/gtest.h>
+
 #include <transport/MessageCounter.h>
 #include <transport/PeerMessageCounter.h>
 
-#include <errno.h>
-#include <nlbyteorder.h>
-#include <nlunit-test.h>
-#include <vector>
-
 namespace {
 
 using namespace chip;
 
 static uint32_t counterValuesArray[] = { 0, 10, 0x7FFFFFFF, 0x80000000, 0x80000001, 0x80000002, 0xFFFFFFF0, 0xFFFFFFFF };
 
-void GroupRollOverTest(nlTestSuite * inSuite, void * inContext)
+TEST(TestPeerMessageCounter, GroupRollOverTest)
 {
     for (auto n : counterValuesArray)
     {
         for (uint32_t k = 1; k <= 2 * CHIP_CONFIG_MESSAGE_COUNTER_WINDOW_SIZE; k++)
         {
             chip::Transport::PeerMessageCounter counter;
-            NL_TEST_ASSERT(inSuite, counter.VerifyOrTrustFirstGroup(n) == CHIP_NO_ERROR);
+            EXPECT_EQ(counter.VerifyOrTrustFirstGroup(n), CHIP_NO_ERROR);
 
             counter.CommitGroup(n);
 
             // 1. A counter value of N + k comes in, we detect it as valid and commit it.
-            NL_TEST_ASSERT(inSuite, counter.VerifyOrTrustFirstGroup(n + k) == CHIP_NO_ERROR);
+            EXPECT_EQ(counter.VerifyOrTrustFirstGroup(n + k), CHIP_NO_ERROR);
             counter.CommitGroup(n + k);
 
             // 2. A counter value of N comes in, we detect it as duplicate.
-            NL_TEST_ASSERT(inSuite, counter.VerifyOrTrustFirstGroup(n) == CHIP_ERROR_DUPLICATE_MESSAGE_RECEIVED);
+            EXPECT_EQ(counter.VerifyOrTrustFirstGroup(n), CHIP_ERROR_DUPLICATE_MESSAGE_RECEIVED);
 
             // 3. A counter value between N - CHIP_CONFIG_MESSAGE_COUNTER_WINDOW_SIZE and
             //    N + k - CHIP_CONFIG_MESSAGE_COUNTER_WINDOW_SIZE (but not including
@@ -60,47 +59,45 @@
             for (uint32_t i = n - CHIP_CONFIG_MESSAGE_COUNTER_WINDOW_SIZE; i != (n + k - CHIP_CONFIG_MESSAGE_COUNTER_WINDOW_SIZE);
                  i++)
             {
-                NL_TEST_ASSERT(inSuite, counter.VerifyOrTrustFirstGroup(i) != CHIP_NO_ERROR);
+                EXPECT_NE(counter.VerifyOrTrustFirstGroup(i), CHIP_NO_ERROR);
             }
 
             // 4. A counter value of N + k - CHIP_CONFIG_MESSAGE_COUNTER_WINDOW_SIZE comes in, is treated as valid.
             if (k != CHIP_CONFIG_MESSAGE_COUNTER_WINDOW_SIZE)
             {
-                NL_TEST_ASSERT(inSuite,
-                               counter.VerifyOrTrustFirstGroup(n + k - CHIP_CONFIG_MESSAGE_COUNTER_WINDOW_SIZE) == CHIP_NO_ERROR);
+                EXPECT_EQ(counter.VerifyOrTrustFirstGroup(n + k - CHIP_CONFIG_MESSAGE_COUNTER_WINDOW_SIZE), CHIP_NO_ERROR);
             }
             else
             {
-                NL_TEST_ASSERT(inSuite,
-                               counter.VerifyOrTrustFirstGroup(n + k - CHIP_CONFIG_MESSAGE_COUNTER_WINDOW_SIZE) != CHIP_NO_ERROR);
+                EXPECT_NE(counter.VerifyOrTrustFirstGroup(n + k - CHIP_CONFIG_MESSAGE_COUNTER_WINDOW_SIZE), CHIP_NO_ERROR);
             }
         }
     }
 }
 
-void GroupBackTrackTest(nlTestSuite * inSuite, void * inContext)
+TEST(TestPeerMessageCounter, GroupBackTrackTest)
 {
     for (auto n : counterValuesArray)
     {
         chip::Transport::PeerMessageCounter counter;
-        NL_TEST_ASSERT(inSuite, counter.VerifyOrTrustFirstGroup(n) == CHIP_NO_ERROR);
+        EXPECT_EQ(counter.VerifyOrTrustFirstGroup(n), CHIP_NO_ERROR);
 
         counter.CommitGroup(n);
         // 1.   Some set of values N - k come in, for 0 < k < CHIP_CONFIG_MESSAGE_COUNTER_WINDOW_SIZE.
         //      All of those should be considered valid and committed.
         for (uint32_t k = 1; k * k < CHIP_CONFIG_MESSAGE_COUNTER_WINDOW_SIZE; k++)
         {
-            NL_TEST_ASSERT(inSuite, counter.VerifyOrTrustFirstGroup(n - (k * k)) == CHIP_NO_ERROR);
+            EXPECT_EQ(counter.VerifyOrTrustFirstGroup(n - (k * k)), CHIP_NO_ERROR);
             counter.CommitGroup(n - (k * k));
         }
         // 2. Counter value N + 3 comes in
-        NL_TEST_ASSERT(inSuite, counter.VerifyOrTrustFirstGroup(n + 3) == CHIP_NO_ERROR);
+        EXPECT_EQ(counter.VerifyOrTrustFirstGroup(n + 3), CHIP_NO_ERROR);
         counter.CommitGroup(n + 3);
 
         // 3. The same set of values N - k come in as in step (1) and are all considered duplicates/out of window.
         for (uint32_t k = 1; k * k < CHIP_CONFIG_MESSAGE_COUNTER_WINDOW_SIZE; k++)
         {
-            NL_TEST_ASSERT(inSuite, counter.VerifyOrTrustFirstGroup(n - (k * k)) != CHIP_NO_ERROR);
+            EXPECT_NE(counter.VerifyOrTrustFirstGroup(n - (k * k)), CHIP_NO_ERROR);
         }
 
         // 4. The values that were not in the set in step (a) (but are at least N + 3 - CHIP_CONFIG_MESSAGE_COUNTER_WINDOW_SIZE)
@@ -111,29 +108,29 @@
             {
                 continue;
             }
-            NL_TEST_ASSERT(inSuite, counter.VerifyOrTrustFirstGroup(k) == CHIP_NO_ERROR);
+            EXPECT_EQ(counter.VerifyOrTrustFirstGroup(k), CHIP_NO_ERROR);
             counter.CommitGroup(k);
         }
     }
 }
 
-void GroupBigLeapTest(nlTestSuite * inSuite, void * inContext)
+TEST(TestPeerMessageCounter, GroupBigLeapTest)
 {
     for (auto n : counterValuesArray)
     {
         for (uint32_t k = (static_cast<uint32_t>(1 << 31) - 5); k <= (static_cast<uint32_t>(1 << 31) - 1); k++)
         {
             chip::Transport::PeerMessageCounter counter;
-            NL_TEST_ASSERT(inSuite, counter.VerifyOrTrustFirstGroup(n) == CHIP_NO_ERROR);
+            EXPECT_EQ(counter.VerifyOrTrustFirstGroup(n), CHIP_NO_ERROR);
 
             counter.CommitGroup(n);
 
             // 1. A counter value of N + k comes in, we detect it as valid and commit it.
-            NL_TEST_ASSERT(inSuite, counter.VerifyOrTrustFirstGroup(n + k) == CHIP_NO_ERROR);
+            EXPECT_EQ(counter.VerifyOrTrustFirstGroup(n + k), CHIP_NO_ERROR);
             counter.CommitGroup(n + k);
 
             // 2. A counter value of N comes in, we detect it as duplicate.
-            NL_TEST_ASSERT(inSuite, counter.VerifyOrTrustFirstGroup(n) != CHIP_NO_ERROR);
+            EXPECT_NE(counter.VerifyOrTrustFirstGroup(n), CHIP_NO_ERROR);
 
             // 3. A counter value between N and N + k - CHIP_CONFIG_MESSAGE_COUNTER_WINDOW_SIZE
             //    (but not including N + k - CHIP_CONFIG_MESSAGE_COUNTER_WINDOW_SIZE) comes in, we treat it as duplicate.
@@ -149,38 +146,37 @@
             testValues.push_back(static_cast<uint32_t>(n + k - CHIP_CONFIG_MESSAGE_COUNTER_WINDOW_SIZE - 1));
 
             // Will be inside the valid window of counter + (2^31 -1)
-            NL_TEST_ASSERT(inSuite, counter.VerifyOrTrustFirstGroup(n - CHIP_CONFIG_MESSAGE_COUNTER_WINDOW_SIZE) == CHIP_NO_ERROR);
+            EXPECT_EQ(counter.VerifyOrTrustFirstGroup(n - CHIP_CONFIG_MESSAGE_COUNTER_WINDOW_SIZE), CHIP_NO_ERROR);
 
             for (auto it : testValues)
             {
-                NL_TEST_ASSERT(inSuite, counter.VerifyOrTrustFirstGroup(it) != CHIP_NO_ERROR);
+                EXPECT_NE(counter.VerifyOrTrustFirstGroup(it), CHIP_NO_ERROR);
             }
 
             // 4. A counter value of N + k - CHIP_CONFIG_MESSAGE_COUNTER_WINDOW_SIZE comes in, is treated as valid.
-            NL_TEST_ASSERT(inSuite,
-                           counter.VerifyOrTrustFirstGroup(n + k - CHIP_CONFIG_MESSAGE_COUNTER_WINDOW_SIZE) == CHIP_NO_ERROR);
+            EXPECT_EQ(counter.VerifyOrTrustFirstGroup(n + k - CHIP_CONFIG_MESSAGE_COUNTER_WINDOW_SIZE), CHIP_NO_ERROR);
         }
     }
 }
 
-void GroupOutOfWindow(nlTestSuite * inSuite, void * inContext)
+TEST(TestPeerMessageCounter, GroupOutOfWindow)
 {
     for (auto n : counterValuesArray)
     {
         for (uint32_t k = (static_cast<uint32_t>(1 << 31)); k <= (static_cast<uint32_t>(1 << 31) + 2); k++)
         {
             chip::Transport::PeerMessageCounter counter;
-            NL_TEST_ASSERT(inSuite, counter.VerifyOrTrustFirstGroup(n) == CHIP_NO_ERROR);
+            EXPECT_EQ(counter.VerifyOrTrustFirstGroup(n), CHIP_NO_ERROR);
 
             counter.CommitGroup(n);
 
             // 1. A counter value of N + k comes in, we detect it as duplicate.
-            NL_TEST_ASSERT(inSuite, counter.VerifyOrTrustFirstGroup(n + k) == CHIP_ERROR_DUPLICATE_MESSAGE_RECEIVED);
+            EXPECT_EQ(counter.VerifyOrTrustFirstGroup(n + k), CHIP_ERROR_DUPLICATE_MESSAGE_RECEIVED);
         }
     }
 }
 
-void UnicastSmallStepTest(nlTestSuite * inSuite, void * inContext)
+TEST(TestPeerMessageCounter, UnicastSmallStepTest)
 {
     for (auto n : counterValuesArray)
     {
@@ -201,22 +197,22 @@
             }
 
             // A counter value of N comes in, we detect it as duplicate.
-            NL_TEST_ASSERT(inSuite, counter.VerifyEncryptedUnicast(n) == CHIP_ERROR_DUPLICATE_MESSAGE_RECEIVED);
+            EXPECT_EQ(counter.VerifyEncryptedUnicast(n), CHIP_ERROR_DUPLICATE_MESSAGE_RECEIVED);
 
             // A counter value of N + k comes in, we detect it as valid only if it would not
             // overflow, and commit it.
             if (k > UINT32_MAX - n)
             {
-                NL_TEST_ASSERT(inSuite, counter.VerifyEncryptedUnicast(n + k) == CHIP_ERROR_DUPLICATE_MESSAGE_RECEIVED);
+                EXPECT_EQ(counter.VerifyEncryptedUnicast(n + k), CHIP_ERROR_DUPLICATE_MESSAGE_RECEIVED);
                 // The other tests make no sense if we did not commit N+k as the new max counter.
                 continue;
             }
 
-            NL_TEST_ASSERT(inSuite, counter.VerifyEncryptedUnicast(n + k) == CHIP_NO_ERROR);
+            EXPECT_EQ(counter.VerifyEncryptedUnicast(n + k), CHIP_NO_ERROR);
             counter.CommitEncryptedUnicast(n + k);
 
             // A counter value of N comes in, we detect it as duplicate.
-            NL_TEST_ASSERT(inSuite, counter.VerifyEncryptedUnicast(n) == CHIP_ERROR_DUPLICATE_MESSAGE_RECEIVED);
+            EXPECT_EQ(counter.VerifyEncryptedUnicast(n), CHIP_ERROR_DUPLICATE_MESSAGE_RECEIVED);
 
             // A counter value between N - CHIP_CONFIG_MESSAGE_COUNTER_WINDOW_SIZE and
             // N + k - CHIP_CONFIG_MESSAGE_COUNTER_WINDOW_SIZE (but not including
@@ -229,7 +225,7 @@
                 (n + k >= CHIP_CONFIG_MESSAGE_COUNTER_WINDOW_SIZE) ? (n + k - CHIP_CONFIG_MESSAGE_COUNTER_WINDOW_SIZE) : 0;
             for (uint32_t i = outOfWindowStart; i < outOfWindowEnd; i++)
             {
-                NL_TEST_ASSERT(inSuite, counter.VerifyEncryptedUnicast(i) != CHIP_NO_ERROR);
+                EXPECT_NE(counter.VerifyEncryptedUnicast(i), CHIP_NO_ERROR);
             }
 
             // A counter value of N + k - CHIP_CONFIG_MESSAGE_COUNTER_WINDOW_SIZE (if that does not
@@ -239,20 +235,18 @@
             {
                 if ((k != CHIP_CONFIG_MESSAGE_COUNTER_WINDOW_SIZE) && (n + k != CHIP_CONFIG_MESSAGE_COUNTER_WINDOW_SIZE))
                 {
-                    NL_TEST_ASSERT(
-                        inSuite, counter.VerifyEncryptedUnicast(n + k - CHIP_CONFIG_MESSAGE_COUNTER_WINDOW_SIZE) == CHIP_NO_ERROR);
+                    EXPECT_EQ(counter.VerifyEncryptedUnicast(n + k - CHIP_CONFIG_MESSAGE_COUNTER_WINDOW_SIZE), CHIP_NO_ERROR);
                 }
                 else
                 {
-                    NL_TEST_ASSERT(
-                        inSuite, counter.VerifyEncryptedUnicast(n + k - CHIP_CONFIG_MESSAGE_COUNTER_WINDOW_SIZE) != CHIP_NO_ERROR);
+                    EXPECT_NE(counter.VerifyEncryptedUnicast(n + k - CHIP_CONFIG_MESSAGE_COUNTER_WINDOW_SIZE), CHIP_NO_ERROR);
                 }
             }
         }
     }
 }
 
-void UnicastLargeStepTest(nlTestSuite * inSuite, void * inContext)
+TEST(TestPeerMessageCounter, UnicastLargeStepTest)
 {
     for (auto n : counterValuesArray)
     {
@@ -276,16 +270,16 @@
             // if it would not overflow, and commit it.
             if (k > UINT32_MAX - n)
             {
-                NL_TEST_ASSERT(inSuite, counter.VerifyEncryptedUnicast(n + k) == CHIP_ERROR_DUPLICATE_MESSAGE_RECEIVED);
+                EXPECT_EQ(counter.VerifyEncryptedUnicast(n + k), CHIP_ERROR_DUPLICATE_MESSAGE_RECEIVED);
                 // The other tests make no sense if we did not commit N+k as the new max counter.
                 continue;
             }
 
-            NL_TEST_ASSERT(inSuite, counter.VerifyEncryptedUnicast(n + k) == CHIP_NO_ERROR);
+            EXPECT_EQ(counter.VerifyEncryptedUnicast(n + k), CHIP_NO_ERROR);
             counter.CommitEncryptedUnicast(n + k);
 
             // 2. A counter value of N comes in, we detect it as duplicate.
-            NL_TEST_ASSERT(inSuite, counter.VerifyEncryptedUnicast(n) != CHIP_NO_ERROR);
+            EXPECT_NE(counter.VerifyEncryptedUnicast(n), CHIP_NO_ERROR);
 
             // 3. A counter value between N and N + k - CHIP_CONFIG_MESSAGE_COUNTER_WINDOW_SIZE
             //    (but not including N + k - CHIP_CONFIG_MESSAGE_COUNTER_WINDOW_SIZE) comes in, we treat it as duplicate.
@@ -303,81 +297,77 @@
             // n - CHIP_CONFIG_MESSAGE_COUNTER_WINDOW_SIZE will be smaller than the current allowed counter values.
             if (n >= CHIP_CONFIG_MESSAGE_COUNTER_WINDOW_SIZE)
             {
-                NL_TEST_ASSERT(inSuite,
-                               counter.VerifyEncryptedUnicast(n - CHIP_CONFIG_MESSAGE_COUNTER_WINDOW_SIZE) != CHIP_NO_ERROR);
+                EXPECT_NE(counter.VerifyEncryptedUnicast(n - CHIP_CONFIG_MESSAGE_COUNTER_WINDOW_SIZE), CHIP_NO_ERROR);
             }
 
             for (auto it : testValues)
             {
-                NL_TEST_ASSERT(inSuite, counter.VerifyEncryptedUnicast(it) != CHIP_NO_ERROR);
+                EXPECT_NE(counter.VerifyEncryptedUnicast(it), CHIP_NO_ERROR);
             }
 
             // 4. A counter value of N + k - CHIP_CONFIG_MESSAGE_COUNTER_WINDOW_SIZE comes in, is treated as valid.
-            NL_TEST_ASSERT(inSuite,
-                           counter.VerifyEncryptedUnicast(n + k - CHIP_CONFIG_MESSAGE_COUNTER_WINDOW_SIZE) == CHIP_NO_ERROR);
+            EXPECT_EQ(counter.VerifyEncryptedUnicast(n + k - CHIP_CONFIG_MESSAGE_COUNTER_WINDOW_SIZE), CHIP_NO_ERROR);
         }
     }
 }
 
-void UnencryptedRollOverTest(nlTestSuite * inSuite, void * inContext)
+TEST(TestPeerMessageCounter, UnencryptedRollOverTest)
 {
     for (auto n : counterValuesArray)
     {
         for (uint32_t k = 1; k <= 2 * CHIP_CONFIG_MESSAGE_COUNTER_WINDOW_SIZE; k++)
         {
             chip::Transport::PeerMessageCounter counter;
-            NL_TEST_ASSERT(inSuite, counter.VerifyUnencrypted(n) == CHIP_NO_ERROR);
+            EXPECT_EQ(counter.VerifyUnencrypted(n), CHIP_NO_ERROR);
 
             counter.CommitUnencrypted(n);
 
             // 1. A counter value of N + k comes in, we detect it as valid and commit it.
-            NL_TEST_ASSERT(inSuite, counter.VerifyUnencrypted(n + k) == CHIP_NO_ERROR);
+            EXPECT_EQ(counter.VerifyUnencrypted(n + k), CHIP_NO_ERROR);
             counter.CommitUnencrypted(n + k);
 
             // 2. A counter value of N comes in, we detect it as duplicate if
             // it's in the window.
             if (k <= CHIP_CONFIG_MESSAGE_COUNTER_WINDOW_SIZE)
             {
-                NL_TEST_ASSERT(inSuite, counter.VerifyUnencrypted(n) == CHIP_ERROR_DUPLICATE_MESSAGE_RECEIVED);
+                EXPECT_EQ(counter.VerifyUnencrypted(n), CHIP_ERROR_DUPLICATE_MESSAGE_RECEIVED);
             }
             else
             {
-                NL_TEST_ASSERT(inSuite, counter.VerifyUnencrypted(n) == CHIP_NO_ERROR);
+                EXPECT_EQ(counter.VerifyUnencrypted(n), CHIP_NO_ERROR);
                 // Don't commit here so we change our max counter value.
             }
 
             // 4. A counter value of N + k - CHIP_CONFIG_MESSAGE_COUNTER_WINDOW_SIZE comes in, is treated as valid.
             if (k != CHIP_CONFIG_MESSAGE_COUNTER_WINDOW_SIZE)
             {
-                NL_TEST_ASSERT(inSuite,
-                               counter.VerifyUnencrypted(n + k - CHIP_CONFIG_MESSAGE_COUNTER_WINDOW_SIZE) == CHIP_NO_ERROR);
+                EXPECT_EQ(counter.VerifyUnencrypted(n + k - CHIP_CONFIG_MESSAGE_COUNTER_WINDOW_SIZE), CHIP_NO_ERROR);
             }
             else
             {
-                NL_TEST_ASSERT(inSuite,
-                               counter.VerifyUnencrypted(n + k - CHIP_CONFIG_MESSAGE_COUNTER_WINDOW_SIZE) != CHIP_NO_ERROR);
+                EXPECT_NE(counter.VerifyUnencrypted(n + k - CHIP_CONFIG_MESSAGE_COUNTER_WINDOW_SIZE), CHIP_NO_ERROR);
             }
         }
     }
 }
 
-void UnencryptedBackTrackTest(nlTestSuite * inSuite, void * inContext)
+TEST(TestPeerMessageCounter, UnencryptedBackTrackTest)
 {
     for (auto n : counterValuesArray)
     {
         chip::Transport::PeerMessageCounter counter;
-        NL_TEST_ASSERT(inSuite, counter.VerifyUnencrypted(n) == CHIP_NO_ERROR);
+        EXPECT_EQ(counter.VerifyUnencrypted(n), CHIP_NO_ERROR);
 
         counter.CommitUnencrypted(n);
         // 1.   Some set of values N - k come in, for 0 < k < CHIP_CONFIG_MESSAGE_COUNTER_WINDOW_SIZE.
         //      All of those should be considered valid and committed.
         for (uint32_t k = 1; k * k < CHIP_CONFIG_MESSAGE_COUNTER_WINDOW_SIZE; k++)
         {
-            NL_TEST_ASSERT(inSuite, counter.VerifyUnencrypted(n - (k * k)) == CHIP_NO_ERROR);
+            EXPECT_EQ(counter.VerifyUnencrypted(n - (k * k)), CHIP_NO_ERROR);
             counter.CommitUnencrypted(n - (k * k));
         }
         // 2. Counter value N + 3 comes in
-        NL_TEST_ASSERT(inSuite, counter.VerifyUnencrypted(n + 3) == CHIP_NO_ERROR);
+        EXPECT_EQ(counter.VerifyUnencrypted(n + 3), CHIP_NO_ERROR);
         counter.CommitUnencrypted(n + 3);
 
         // 3. The same set of values N - k come in as in step (1) and are all considered duplicates.
@@ -385,7 +375,7 @@
         //    are out of window, and 25 is the biggest k*k value we are dealing with.
         for (uint32_t k = 1; k * k < CHIP_CONFIG_MESSAGE_COUNTER_WINDOW_SIZE; k++)
         {
-            NL_TEST_ASSERT(inSuite, counter.VerifyUnencrypted(n - (k * k)) != CHIP_NO_ERROR);
+            EXPECT_NE(counter.VerifyUnencrypted(n - (k * k)), CHIP_NO_ERROR);
         }
 
         // 4. The values that were not in the set in step (a) (but are at least N + 3 - CHIP_CONFIG_MESSAGE_COUNTER_WINDOW_SIZE)
@@ -396,30 +386,30 @@
             {
                 continue;
             }
-            NL_TEST_ASSERT(inSuite, counter.VerifyUnencrypted(k) == CHIP_NO_ERROR);
+            EXPECT_EQ(counter.VerifyUnencrypted(k), CHIP_NO_ERROR);
             counter.CommitUnencrypted(k);
         }
     }
 }
 
-void UnencryptedBigLeapTest(nlTestSuite * inSuite, void * inContext)
+TEST(TestPeerMessageCounter, UnencryptedBigLeapTest)
 {
     for (auto n : counterValuesArray)
     {
         for (uint32_t k = (static_cast<uint32_t>(1 << 31) - 5); k <= (static_cast<uint32_t>(1 << 31) - 1); k++)
         {
             chip::Transport::PeerMessageCounter counter;
-            NL_TEST_ASSERT(inSuite, counter.VerifyUnencrypted(n) == CHIP_NO_ERROR);
+            EXPECT_EQ(counter.VerifyUnencrypted(n), CHIP_NO_ERROR);
 
             counter.CommitUnencrypted(n);
 
             // 1. A counter value of N + k comes in, we detect it as valid and commit it.
-            NL_TEST_ASSERT(inSuite, counter.VerifyUnencrypted(n + k) == CHIP_NO_ERROR);
+            EXPECT_EQ(counter.VerifyUnencrypted(n + k), CHIP_NO_ERROR);
             counter.CommitUnencrypted(n + k);
 
             // 2. A counter value of N comes in, we detect it as valid, since
             // it's out of window.
-            NL_TEST_ASSERT(inSuite, counter.VerifyUnencrypted(n) == CHIP_NO_ERROR);
+            EXPECT_EQ(counter.VerifyUnencrypted(n), CHIP_NO_ERROR);
             // Don't commit, though.
 
             // 3. A counter value between N and N + k - CHIP_CONFIG_MESSAGE_COUNTER_WINDOW_SIZE
@@ -437,70 +427,35 @@
             testValues.push_back(static_cast<uint32_t>(n + k - CHIP_CONFIG_MESSAGE_COUNTER_WINDOW_SIZE - 1));
 
             // Will be inside the valid window of counter + (2^31 -1)
-            NL_TEST_ASSERT(inSuite, counter.VerifyUnencrypted(n - CHIP_CONFIG_MESSAGE_COUNTER_WINDOW_SIZE) == CHIP_NO_ERROR);
+            EXPECT_EQ(counter.VerifyUnencrypted(n - CHIP_CONFIG_MESSAGE_COUNTER_WINDOW_SIZE), CHIP_NO_ERROR);
 
             for (auto it : testValues)
             {
-                NL_TEST_ASSERT(inSuite, counter.VerifyUnencrypted(it) == CHIP_NO_ERROR);
+                EXPECT_EQ(counter.VerifyUnencrypted(it), CHIP_NO_ERROR);
             }
 
             // 4. A counter value of N + k - CHIP_CONFIG_MESSAGE_COUNTER_WINDOW_SIZE comes in, is treated as valid.
-            NL_TEST_ASSERT(inSuite, counter.VerifyUnencrypted(n + k - CHIP_CONFIG_MESSAGE_COUNTER_WINDOW_SIZE) == CHIP_NO_ERROR);
+            EXPECT_EQ(counter.VerifyUnencrypted(n + k - CHIP_CONFIG_MESSAGE_COUNTER_WINDOW_SIZE), CHIP_NO_ERROR);
         }
     }
 }
 
-void UnencryptedOutOfWindow(nlTestSuite * inSuite, void * inContext)
+TEST(TestPeerMessageCounter, UnencryptedOutOfWindow)
 {
     for (auto n : counterValuesArray)
     {
         for (uint32_t k = (static_cast<uint32_t>(1 << 31)); k <= (static_cast<uint32_t>(1 << 31) + 2); k++)
         {
             chip::Transport::PeerMessageCounter counter;
-            NL_TEST_ASSERT(inSuite, counter.VerifyUnencrypted(n) == CHIP_NO_ERROR);
+            EXPECT_EQ(counter.VerifyUnencrypted(n), CHIP_NO_ERROR);
 
             counter.CommitUnencrypted(n);
 
             // 1. A counter value of N + k comes in, we treat it as valid, since
             // it's out of window.
-            NL_TEST_ASSERT(inSuite, counter.VerifyUnencrypted(n + k) == CHIP_NO_ERROR);
+            EXPECT_EQ(counter.VerifyUnencrypted(n + k), CHIP_NO_ERROR);
         }
     }
 }
 
 } // namespace
-
-/**
- *  Test Suite that lists all the test functions.
- */
-// clang-format off
-const nlTest sTests[] =
-{
-    NL_TEST_DEF("Group Roll over Test",           GroupRollOverTest),
-    NL_TEST_DEF("Group Backtrack Test",           GroupBackTrackTest),
-    NL_TEST_DEF("Group All value test",           GroupBigLeapTest),
-    NL_TEST_DEF("Group Out of Window Test",       GroupOutOfWindow),
-    NL_TEST_DEF("Unicast small step Test",        UnicastSmallStepTest),
-    NL_TEST_DEF("Unicast large step Test",        UnicastLargeStepTest),
-    NL_TEST_DEF("Unencrypted Roll over Test",     UnencryptedRollOverTest),
-    NL_TEST_DEF("Unencrypted Backtrack Test",     UnencryptedBackTrackTest),
-    NL_TEST_DEF("Unencrypted All value test",     UnencryptedBigLeapTest),
-    NL_TEST_DEF("Unencrypted Out of Window Test", UnencryptedOutOfWindow),
-    NL_TEST_SENTINEL()
-};
-// clang-format on
-
-/**
- *  Main
- */
-int TestPeerMessageCounter()
-{
-    // Run test suit against one context
-
-    nlTestSuite theSuite = { "Transport-TestPeerMessageCounter", &sTests[0], nullptr, nullptr };
-    nlTestRunner(&theSuite, nullptr);
-
-    return (nlTestRunnerStats(&theSuite));
-}
-
-CHIP_REGISTER_TEST_SUITE(TestPeerMessageCounter);
diff --git a/src/transport/tests/TestSecureSession.cpp b/src/transport/tests/TestSecureSession.cpp
index 023876c..672ba04 100644
--- a/src/transport/tests/TestSecureSession.cpp
+++ b/src/transport/tests/TestSecureSession.cpp
@@ -22,53 +22,51 @@
  */
 
 #include <errno.h>
-#include <nlunit-test.h>
+#include <stdarg.h>
+
+#include <gtest/gtest.h>
 
 #include <crypto/DefaultSessionKeystore.h>
 #include <lib/core/CHIPCore.h>
 #include <lib/support/CodeUtils.h>
-#include <lib/support/UnitTestRegistration.h>
 #include <transport/CryptoContext.h>
 
-#include <stdarg.h>
-
 using namespace chip;
 using namespace Crypto;
 
-void SecureChannelInitTest(nlTestSuite * inSuite, void * inContext)
+TEST(TestSecureSession, SecureChannelInitTest)
 {
     Crypto::DefaultSessionKeystore sessionKeystore;
     CryptoContext channel;
 
     P256Keypair keypair;
-    NL_TEST_ASSERT(inSuite, keypair.Initialize(ECPKeyTarget::ECDH) == CHIP_NO_ERROR);
+    EXPECT_EQ(keypair.Initialize(ECPKeyTarget::ECDH), CHIP_NO_ERROR);
 
     P256Keypair keypair2;
-    NL_TEST_ASSERT(inSuite, keypair2.Initialize(ECPKeyTarget::ECDH) == CHIP_NO_ERROR);
+    EXPECT_EQ(keypair2.Initialize(ECPKeyTarget::ECDH), CHIP_NO_ERROR);
 
     // Test the channel is successfully created with valid parameters
-    NL_TEST_ASSERT(inSuite,
-                   channel.InitFromKeyPair(sessionKeystore, keypair, keypair2.Pubkey(), ByteSpan(),
-                                           CryptoContext::SessionInfoType::kSessionEstablishment,
-                                           CryptoContext::SessionRole::kInitiator) == CHIP_NO_ERROR);
+    EXPECT_EQ(channel.InitFromKeyPair(sessionKeystore, keypair, keypair2.Pubkey(), ByteSpan(),
+                                      CryptoContext::SessionInfoType::kSessionEstablishment,
+                                      CryptoContext::SessionRole::kInitiator),
+              CHIP_NO_ERROR);
 
     // Test the channel cannot be reinitialized
-    NL_TEST_ASSERT(inSuite,
-                   channel.InitFromKeyPair(sessionKeystore, keypair, keypair2.Pubkey(), ByteSpan(),
-                                           CryptoContext::SessionInfoType::kSessionEstablishment,
-                                           CryptoContext::SessionRole::kInitiator) == CHIP_ERROR_INCORRECT_STATE);
+    EXPECT_EQ(channel.InitFromKeyPair(sessionKeystore, keypair, keypair2.Pubkey(), ByteSpan(),
+                                      CryptoContext::SessionInfoType::kSessionEstablishment,
+                                      CryptoContext::SessionRole::kInitiator),
+              CHIP_ERROR_INCORRECT_STATE);
 
     // Test the channel can be initialized with valid salt
     const char * salt = "Test Salt";
     CryptoContext channel2;
-    NL_TEST_ASSERT(inSuite,
-                   channel2.InitFromKeyPair(sessionKeystore, keypair, keypair2.Pubkey(),
-                                            ByteSpan((const uint8_t *) salt, strlen(salt)),
-                                            CryptoContext::SessionInfoType::kSessionEstablishment,
-                                            CryptoContext::SessionRole::kInitiator) == CHIP_NO_ERROR);
+    EXPECT_EQ(channel2.InitFromKeyPair(sessionKeystore, keypair, keypair2.Pubkey(), ByteSpan((const uint8_t *) salt, strlen(salt)),
+                                       CryptoContext::SessionInfoType::kSessionEstablishment,
+                                       CryptoContext::SessionRole::kInitiator),
+              CHIP_NO_ERROR);
 }
 
-void SecureChannelEncryptTest(nlTestSuite * inSuite, void * inContext)
+TEST(TestSecureSession, SecureChannelEncryptTest)
 {
     Crypto::DefaultSessionKeystore sessionKeystore;
     CryptoContext channel;
@@ -78,41 +76,38 @@
     MessageAuthenticationCode mac;
 
     packetHeader.SetSessionId(1);
-    NL_TEST_ASSERT(inSuite, packetHeader.IsEncrypted() == true);
-    NL_TEST_ASSERT(inSuite, packetHeader.MICTagLength() == 16);
+    EXPECT_TRUE(packetHeader.IsEncrypted());
+    EXPECT_EQ(packetHeader.MICTagLength(), 16);
 
     CryptoContext::NonceStorage nonce;
     CryptoContext::BuildNonce(nonce, packetHeader.GetSecurityFlags(), packetHeader.GetMessageCounter(), 0);
 
     P256Keypair keypair;
-    NL_TEST_ASSERT(inSuite, keypair.Initialize(ECPKeyTarget::ECDH) == CHIP_NO_ERROR);
+    EXPECT_EQ(keypair.Initialize(ECPKeyTarget::ECDH), CHIP_NO_ERROR);
 
     P256Keypair keypair2;
-    NL_TEST_ASSERT(inSuite, keypair2.Initialize(ECPKeyTarget::ECDH) == CHIP_NO_ERROR);
+    EXPECT_EQ(keypair2.Initialize(ECPKeyTarget::ECDH), CHIP_NO_ERROR);
 
     // Test uninitialized channel
-    NL_TEST_ASSERT(inSuite,
-                   channel.Encrypt(plain_text, sizeof(plain_text), output, nonce, packetHeader, mac) ==
-                       CHIP_ERROR_INVALID_USE_OF_SESSION_KEY);
+    EXPECT_EQ(channel.Encrypt(plain_text, sizeof(plain_text), output, nonce, packetHeader, mac),
+              CHIP_ERROR_INVALID_USE_OF_SESSION_KEY);
 
     const char * salt = "Test Salt";
-    NL_TEST_ASSERT(inSuite,
-                   channel.InitFromKeyPair(sessionKeystore, keypair, keypair2.Pubkey(),
-                                           ByteSpan((const uint8_t *) salt, strlen(salt)),
-                                           CryptoContext::SessionInfoType::kSessionEstablishment,
-                                           CryptoContext::SessionRole::kInitiator) == CHIP_NO_ERROR);
+    EXPECT_EQ(channel.InitFromKeyPair(sessionKeystore, keypair, keypair2.Pubkey(), ByteSpan((const uint8_t *) salt, strlen(salt)),
+                                      CryptoContext::SessionInfoType::kSessionEstablishment,
+                                      CryptoContext::SessionRole::kInitiator),
+              CHIP_NO_ERROR);
 
     // Test initialized channel, but invalid arguments
-    NL_TEST_ASSERT(inSuite, channel.Encrypt(nullptr, 0, nullptr, nonce, packetHeader, mac) == CHIP_ERROR_INVALID_ARGUMENT);
-    NL_TEST_ASSERT(inSuite, channel.Encrypt(plain_text, 0, nullptr, nonce, packetHeader, mac) == CHIP_ERROR_INVALID_ARGUMENT);
-    NL_TEST_ASSERT(
-        inSuite, channel.Encrypt(plain_text, sizeof(plain_text), nullptr, nonce, packetHeader, mac) == CHIP_ERROR_INVALID_ARGUMENT);
+    EXPECT_EQ(channel.Encrypt(nullptr, 0, nullptr, nonce, packetHeader, mac), CHIP_ERROR_INVALID_ARGUMENT);
+    EXPECT_EQ(channel.Encrypt(plain_text, 0, nullptr, nonce, packetHeader, mac), CHIP_ERROR_INVALID_ARGUMENT);
+    EXPECT_EQ(channel.Encrypt(plain_text, sizeof(plain_text), nullptr, nonce, packetHeader, mac), CHIP_ERROR_INVALID_ARGUMENT);
 
     // Valid arguments
-    NL_TEST_ASSERT(inSuite, channel.Encrypt(plain_text, sizeof(plain_text), output, nonce, packetHeader, mac) == CHIP_NO_ERROR);
+    EXPECT_EQ(channel.Encrypt(plain_text, sizeof(plain_text), output, nonce, packetHeader, mac), CHIP_NO_ERROR);
 }
 
-void SecureChannelDecryptTest(nlTestSuite * inSuite, void * inContext)
+TEST(TestSecureSession, SecureChannelDecryptTest)
 {
     Crypto::DefaultSessionKeystore sessionKeystore;
     CryptoContext channel;
@@ -122,8 +117,8 @@
     MessageAuthenticationCode mac;
 
     packetHeader.SetSessionId(1);
-    NL_TEST_ASSERT(inSuite, packetHeader.IsEncrypted() == true);
-    NL_TEST_ASSERT(inSuite, packetHeader.MICTagLength() == 16);
+    EXPECT_TRUE(packetHeader.IsEncrypted());
+    EXPECT_EQ(packetHeader.MICTagLength(), 16);
 
     CryptoContext::NonceStorage nonce;
     CryptoContext::BuildNonce(nonce, packetHeader.GetSecurityFlags(), packetHeader.GetMessageCounter(), 0);
@@ -131,77 +126,34 @@
     const char * salt = "Test Salt";
 
     P256Keypair keypair;
-    NL_TEST_ASSERT(inSuite, keypair.Initialize(ECPKeyTarget::ECDH) == CHIP_NO_ERROR);
+    EXPECT_EQ(keypair.Initialize(ECPKeyTarget::ECDH), CHIP_NO_ERROR);
 
     P256Keypair keypair2;
-    NL_TEST_ASSERT(inSuite, keypair2.Initialize(ECPKeyTarget::ECDH) == CHIP_NO_ERROR);
+    EXPECT_EQ(keypair2.Initialize(ECPKeyTarget::ECDH), CHIP_NO_ERROR);
 
-    NL_TEST_ASSERT(inSuite,
-                   channel.InitFromKeyPair(sessionKeystore, keypair, keypair2.Pubkey(),
-                                           ByteSpan((const uint8_t *) salt, strlen(salt)),
-                                           CryptoContext::SessionInfoType::kSessionEstablishment,
-                                           CryptoContext::SessionRole::kInitiator) == CHIP_NO_ERROR);
-    NL_TEST_ASSERT(inSuite, channel.Encrypt(plain_text, sizeof(plain_text), encrypted, nonce, packetHeader, mac) == CHIP_NO_ERROR);
+    EXPECT_EQ(channel.InitFromKeyPair(sessionKeystore, keypair, keypair2.Pubkey(), ByteSpan((const uint8_t *) salt, strlen(salt)),
+                                      CryptoContext::SessionInfoType::kSessionEstablishment,
+                                      CryptoContext::SessionRole::kInitiator),
+              CHIP_NO_ERROR);
+    EXPECT_EQ(channel.Encrypt(plain_text, sizeof(plain_text), encrypted, nonce, packetHeader, mac), CHIP_NO_ERROR);
 
     CryptoContext channel2;
     uint8_t output[128];
     // Uninitialized channel
-    NL_TEST_ASSERT(inSuite,
-                   channel2.Decrypt(encrypted, sizeof(plain_text), output, nonce, packetHeader, mac) ==
-                       CHIP_ERROR_INVALID_USE_OF_SESSION_KEY);
-    NL_TEST_ASSERT(inSuite,
-                   channel2.InitFromKeyPair(sessionKeystore, keypair2, keypair.Pubkey(),
-                                            ByteSpan((const uint8_t *) salt, strlen(salt)),
-                                            CryptoContext::SessionInfoType::kSessionEstablishment,
-                                            CryptoContext::SessionRole::kResponder) == CHIP_NO_ERROR);
+    EXPECT_EQ(channel2.Decrypt(encrypted, sizeof(plain_text), output, nonce, packetHeader, mac),
+              CHIP_ERROR_INVALID_USE_OF_SESSION_KEY);
+    EXPECT_EQ(channel2.InitFromKeyPair(sessionKeystore, keypair2, keypair.Pubkey(), ByteSpan((const uint8_t *) salt, strlen(salt)),
+                                       CryptoContext::SessionInfoType::kSessionEstablishment,
+                                       CryptoContext::SessionRole::kResponder),
+              CHIP_NO_ERROR);
 
     // Channel initialized, but invalid arguments to decrypt
-    NL_TEST_ASSERT(inSuite, channel2.Decrypt(nullptr, 0, nullptr, nonce, packetHeader, mac) == CHIP_ERROR_INVALID_ARGUMENT);
-    NL_TEST_ASSERT(inSuite, channel2.Decrypt(encrypted, 0, nullptr, nonce, packetHeader, mac) == CHIP_ERROR_INVALID_ARGUMENT);
-    NL_TEST_ASSERT(
-        inSuite, channel2.Decrypt(encrypted, sizeof(encrypted), nullptr, nonce, packetHeader, mac) == CHIP_ERROR_INVALID_ARGUMENT);
+    EXPECT_EQ(channel2.Decrypt(nullptr, 0, nullptr, nonce, packetHeader, mac), CHIP_ERROR_INVALID_ARGUMENT);
+    EXPECT_EQ(channel2.Decrypt(encrypted, 0, nullptr, nonce, packetHeader, mac), CHIP_ERROR_INVALID_ARGUMENT);
+    EXPECT_EQ(channel2.Decrypt(encrypted, sizeof(encrypted), nullptr, nonce, packetHeader, mac), CHIP_ERROR_INVALID_ARGUMENT);
 
     // Valid arguments
-    NL_TEST_ASSERT(inSuite, channel2.Decrypt(encrypted, sizeof(plain_text), output, nonce, packetHeader, mac) == CHIP_NO_ERROR);
+    EXPECT_EQ(channel2.Decrypt(encrypted, sizeof(plain_text), output, nonce, packetHeader, mac), CHIP_NO_ERROR);
 
-    NL_TEST_ASSERT(inSuite, memcmp(plain_text, output, sizeof(plain_text)) == 0);
+    EXPECT_EQ(memcmp(plain_text, output, sizeof(plain_text)), 0);
 }
-
-// Test Suite
-
-/**
- *  Test Suite that lists all the test functions.
- */
-// clang-format off
-static const nlTest sTests[] =
-{
-    NL_TEST_DEF("Init",    SecureChannelInitTest),
-    NL_TEST_DEF("Encrypt", SecureChannelEncryptTest),
-    NL_TEST_DEF("Decrypt", SecureChannelDecryptTest),
-
-    NL_TEST_SENTINEL()
-};
-// clang-format on
-
-// clang-format off
-static nlTestSuite sSuite =
-{
-    "Test-CHIP-CryptoContext",
-    &sTests[0],
-    nullptr,
-    nullptr
-};
-// clang-format on
-
-/**
- *  Main
- */
-int TestSecureSession()
-{
-    // Run test suit against one context
-    nlTestRunner(&sSuite, nullptr);
-
-    return (nlTestRunnerStats(&sSuite));
-}
-
-CHIP_REGISTER_TEST_SUITE(TestSecureSession)
diff --git a/src/transport/tests/TestSecureSessionTable.cpp b/src/transport/tests/TestSecureSessionTable.cpp
index 7dbbeba..323558a 100644
--- a/src/transport/tests/TestSecureSessionTable.cpp
+++ b/src/transport/tests/TestSecureSessionTable.cpp
@@ -21,31 +21,27 @@
  *      This file implements unit tests for the SessionManager implementation.
  */
 
+#include <errno.h>
+#include <vector>
+
+#include <gtest/gtest.h>
+
 #include "system/SystemClock.h"
 #include <lib/core/CHIPCore.h>
 #include <lib/support/CodeUtils.h>
-#include <lib/support/UnitTestRegistration.h>
 #include <transport/SecureSessionTable.h>
 #include <transport/SessionHolder.h>
 
-#include <nlbyteorder.h>
-#include <nlunit-test.h>
-
-#include <errno.h>
-#include <vector>
-
 namespace chip {
 namespace Transport {
 
-class TestSecureSessionTable
+class TestSecureSessionTable : public ::testing::Test
 {
 public:
-    //
-    // This test specifically validates eviction of sessions in the session table
-    // with various scenarios based on the existing set of sessions in the table
-    // and a provided session eviction hint
-    //
-    static void ValidateSessionSorting(nlTestSuite * inSuite, void * inContext);
+    static void SetUpTestSuite() { ASSERT_EQ(chip::Platform::MemoryInit(), CHIP_NO_ERROR); }
+    static void TearDownTestSuite() { chip::Platform::MemoryShutdown(); }
+
+    void ValidateSessionSorting();
 
 private:
     struct SessionParameters
@@ -88,7 +84,6 @@
     //
     void CreateSessionTable(std::vector<SessionParameters> & sessionParams);
 
-    nlTestSuite * mTestSuite;
     Platform::UniquePtr<SecureSessionTable> mSessionTable;
     std::vector<Platform::UniquePtr<SessionNotificationListener>> mSessionList;
 };
@@ -97,8 +92,8 @@
                                              std::vector<SessionParameters> & sessionParameters, uint16_t evictedSessionIndex)
 {
     auto session = mSessionTable->CreateNewSecureSession(SecureSession::Type::kCASE, sessionEvictionHint);
-    NL_TEST_ASSERT(mTestSuite, session.HasValue());
-    NL_TEST_ASSERT(mTestSuite, mSessionList[evictedSessionIndex].get()->mSessionReleased == true);
+    EXPECT_TRUE(session.HasValue());
+    EXPECT_TRUE(mSessionList[evictedSessionIndex].get()->mSessionReleased);
 }
 
 void TestSecureSessionTable::CreateSessionTable(std::vector<SessionParameters> & sessionParams)
@@ -106,7 +101,7 @@
     mSessionList.clear();
 
     mSessionTable = Platform::MakeUnique<SecureSessionTable>();
-    NL_TEST_ASSERT(mTestSuite, mSessionTable.get() != nullptr);
+    EXPECT_NE(mSessionTable.get(), nullptr);
 
     mSessionTable->Init();
     mSessionTable->SetMaxSessionTableSize(static_cast<uint32_t>(sessionParams.size()));
@@ -114,7 +109,7 @@
     for (unsigned int i = 0; i < sessionParams.size(); i++)
     {
         auto session = mSessionTable->CreateNewSecureSession(SecureSession::Type::kCASE, ScopedNodeId());
-        NL_TEST_ASSERT(mTestSuite, session.HasValue());
+        EXPECT_TRUE(session.HasValue());
 
         session.Value()->AsSecureSession()->Activate(
             ScopedNodeId(1, sessionParams[i].mPeer.GetFabricIndex()), sessionParams[i].mPeer, CATValues(), static_cast<uint16_t>(i),
@@ -131,11 +126,8 @@
     }
 }
 
-void TestSecureSessionTable::ValidateSessionSorting(nlTestSuite * inSuite, void * inContext)
+void TestSecureSessionTable::ValidateSessionSorting()
 {
-    Platform::UniquePtr<TestSecureSessionTable> & _this = *static_cast<Platform::UniquePtr<TestSecureSessionTable> *>(inContext);
-    _this->mTestSuite                                   = inSuite;
-
     //
     // This validates basic eviction. The table is full of sessions from Fabric1 from the same
     // Node (2). Eviction should select the oldest session in the table (with timestamp 1) and evict that
@@ -152,8 +144,8 @@
             { { 2, kFabric1 }, System::Clock::Timestamp(2), SecureSession::State::kActive },
         };
 
-        _this->CreateSessionTable(sessionParamList);
-        _this->AllocateSession(ScopedNodeId(2, kFabric1), sessionParamList, 4);
+        CreateSessionTable(sessionParamList);
+        AllocateSession(ScopedNodeId(2, kFabric1), sessionParamList, 4);
     }
 
     //
@@ -174,8 +166,8 @@
             { { 2, kFabric1 }, System::Clock::Timestamp(2), SecureSession::State::kActive },
         };
 
-        _this->CreateSessionTable(sessionParamList);
-        _this->AllocateSession(ScopedNodeId(2, kFabric2), sessionParamList, 4);
+        CreateSessionTable(sessionParamList);
+        AllocateSession(ScopedNodeId(2, kFabric2), sessionParamList, 4);
     }
 
     //
@@ -200,8 +192,8 @@
             { { 4, kFabric2 }, System::Clock::Timestamp(2), SecureSession::State::kActive },
         };
 
-        _this->CreateSessionTable(sessionParamList);
-        _this->AllocateSession(ScopedNodeId(2, kFabric1), sessionParamList, 1);
+        CreateSessionTable(sessionParamList);
+        AllocateSession(ScopedNodeId(2, kFabric1), sessionParamList, 1);
     }
 
     //
@@ -226,8 +218,8 @@
             { { 4, kFabric2 }, System::Clock::Timestamp(2), SecureSession::State::kActive },
         };
 
-        _this->CreateSessionTable(sessionParamList);
-        _this->AllocateSession(ScopedNodeId(2, kFabric1), sessionParamList, 3);
+        CreateSessionTable(sessionParamList);
+        AllocateSession(ScopedNodeId(2, kFabric1), sessionParamList, 3);
     }
 
     //
@@ -252,8 +244,8 @@
             { { 4, kFabric2 }, System::Clock::Timestamp(2), SecureSession::State::kActive },
         };
 
-        _this->CreateSessionTable(sessionParamList);
-        _this->AllocateSession(ScopedNodeId(2, kFabric1), sessionParamList, 4);
+        CreateSessionTable(sessionParamList);
+        AllocateSession(ScopedNodeId(2, kFabric1), sessionParamList, 4);
     }
 
     //
@@ -275,8 +267,8 @@
             { { 4, kFabric2 }, System::Clock::Timestamp(2), SecureSession::State::kActive },
         };
 
-        _this->CreateSessionTable(sessionParamList);
-        _this->AllocateSession(ScopedNodeId(3, kFabric1), sessionParamList, 2);
+        CreateSessionTable(sessionParamList);
+        AllocateSession(ScopedNodeId(3, kFabric1), sessionParamList, 2);
     }
 
     //
@@ -303,8 +295,8 @@
             { { 4, kFabric2 }, System::Clock::Timestamp(2), SecureSession::State::kDefunct },
         };
 
-        _this->CreateSessionTable(sessionParamList);
-        _this->AllocateSession(ScopedNodeId(3, kFabric1), sessionParamList, 3);
+        CreateSessionTable(sessionParamList);
+        AllocateSession(ScopedNodeId(3, kFabric1), sessionParamList, 3);
     }
 
     //
@@ -337,8 +329,8 @@
             { { 4, kFabric2 }, System::Clock::Timestamp(3), SecureSession::State::kActive },
         };
 
-        _this->CreateSessionTable(sessionParamList);
-        _this->AllocateSession(ScopedNodeId(3, kFabric1), sessionParamList, 3);
+        CreateSessionTable(sessionParamList);
+        AllocateSession(ScopedNodeId(3, kFabric1), sessionParamList, 3);
     }
 
     //
@@ -363,8 +355,8 @@
             { { 4, kFabric2 }, System::Clock::Timestamp(2), SecureSession::State::kActive },
         };
 
-        _this->CreateSessionTable(sessionParamList);
-        _this->AllocateSession(ScopedNodeId(3, kFabric1), sessionParamList, 2);
+        CreateSessionTable(sessionParamList);
+        AllocateSession(ScopedNodeId(3, kFabric1), sessionParamList, 2);
     }
 
     //
@@ -390,8 +382,8 @@
             { { 4, kFabric2 }, System::Clock::Timestamp(2), SecureSession::State::kActive },
         };
 
-        _this->CreateSessionTable(sessionParamList);
-        _this->AllocateSession(ScopedNodeId(3, kFabric1), sessionParamList, 0);
+        CreateSessionTable(sessionParamList);
+        AllocateSession(ScopedNodeId(3, kFabric1), sessionParamList, 0);
     }
 
     //
@@ -412,8 +404,8 @@
             { { 4, kFabric2 }, System::Clock::Timestamp(2), SecureSession::State::kActive },
         };
 
-        _this->CreateSessionTable(sessionParamList);
-        _this->AllocateSession(ScopedNodeId(4, kFabric1), sessionParamList, 2);
+        CreateSessionTable(sessionParamList);
+        AllocateSession(ScopedNodeId(4, kFabric1), sessionParamList, 2);
     }
 
     //
@@ -432,8 +424,8 @@
             { { 4, kFabric2 }, System::Clock::Timestamp(2), SecureSession::State::kActive },
         };
 
-        _this->CreateSessionTable(sessionParamList);
-        _this->AllocateSession(ScopedNodeId(4, kFabric3), sessionParamList, 4);
+        CreateSessionTable(sessionParamList);
+        AllocateSession(ScopedNodeId(4, kFabric3), sessionParamList, 4);
     }
 
     //
@@ -454,67 +446,19 @@
             { { 4, kFabric2 }, System::Clock::Timestamp(2), SecureSession::State::kActive },
         };
 
-        _this->CreateSessionTable(sessionParamList);
-        _this->AllocateSession(ScopedNodeId(4, kFabric3), sessionParamList, 5);
+        CreateSessionTable(sessionParamList);
+        AllocateSession(ScopedNodeId(4, kFabric3), sessionParamList, 5);
     }
 }
 
-Platform::UniquePtr<TestSecureSessionTable> gTestSecureSessionTable;
+TEST_F(TestSecureSessionTable, ValidateSessionSorting)
+{
+    // This calls TestSecureSessionTable::ValidateSessionSorting instead of just doing the
+    // tests directly in here, since the tests reference `SecureSession::State`, which is
+    // private.  Defining the function inside TestSecureSessionTable allows State to be
+    // accessible since SecureSession contains `friend class TestSecureSessionTable`.
+    ValidateSessionSorting();
+}
 
 } // namespace Transport
 } // namespace chip
-
-// Test Suite
-
-namespace {
-
-/**
- *  Test Suite that lists all the test functions.
- */
-// clang-format off
-const nlTest sTests[] =
-{
-    NL_TEST_DEF("Validate Session Sorting (Over Minima)",               chip::Transport::TestSecureSessionTable::ValidateSessionSorting),
-    NL_TEST_SENTINEL()
-};
-// clang-format on
-
-int Initialize(void * apSuite)
-{
-    VerifyOrReturnError(chip::Platform::MemoryInit() == CHIP_NO_ERROR, FAILURE);
-    chip::Transport::gTestSecureSessionTable = chip::Platform::MakeUnique<chip::Transport::TestSecureSessionTable>();
-    return SUCCESS;
-}
-
-int Finalize(void * aContext)
-{
-    chip::Transport::gTestSecureSessionTable.reset();
-    chip::Platform::MemoryShutdown();
-    return SUCCESS;
-}
-
-// clang-format off
-nlTestSuite sSuite =
-{
-    "TestSecureSessionTable",
-    &sTests[0],
-    Initialize,
-    Finalize
-};
-// clang-format on
-
-} // namespace
-
-/**
- *  Main
- */
-int SecureSessionTableTest()
-{
-    // Run test suit against one context
-    nlTestRunner(&sSuite, &chip::Transport::gTestSecureSessionTable);
-
-    int r = (nlTestRunnerStats(&sSuite));
-    return r;
-}
-
-CHIP_REGISTER_TEST_SUITE(SecureSessionTableTest);
diff --git a/src/transport/tests/TestSessionManager.cpp b/src/transport/tests/TestSessionManager.cpp
index 12dc46a..c5384a7 100644
--- a/src/transport/tests/TestSessionManager.cpp
+++ b/src/transport/tests/TestSessionManager.cpp
@@ -31,8 +31,6 @@
 #include <lib/core/CHIPCore.h>
 #include <lib/support/CodeUtils.h>
 #include <lib/support/TestPersistentStorageDelegate.h>
-#include <lib/support/UnitTestContext.h>
-#include <lib/support/UnitTestRegistration.h>
 #include <protocols/Protocols.h>
 #include <protocols/echo/Echo.h>
 #include <protocols/secure_channel/MessageCounterManager.h>
@@ -41,8 +39,7 @@
 #include <transport/TransportMgr.h>
 #include <transport/tests/LoopbackTransportManager.h>
 
-#include <nlbyteorder.h>
-#include <nlunit-test.h>
+#include <gtest/gtest.h>
 
 #include <errno.h>
 
@@ -106,51 +103,52 @@
 
         if (LargeMessageSent)
         {
-            int compare = memcmp(msgBuf->Start(), LARGE_PAYLOAD, data_len);
-            NL_TEST_ASSERT(mSuite, compare == 0);
+            EXPECT_EQ(0, memcmp(msgBuf->Start(), LARGE_PAYLOAD, data_len));
         }
         else
         {
-            int compare = memcmp(msgBuf->Start(), PAYLOAD, data_len);
-            NL_TEST_ASSERT(mSuite, compare == 0);
+            EXPECT_EQ(0, memcmp(msgBuf->Start(), PAYLOAD, data_len));
         }
 
         ReceiveHandlerCallCount++;
     }
 
-    nlTestSuite * mSuite        = nullptr;
     int ReceiveHandlerCallCount = 0;
     bool LargeMessageSent       = false;
 };
 
-void CheckSimpleInitTest(nlTestSuite * inSuite, void * inContext)
+class TestSessionManager : public ::testing::Test
 {
-    TestContext & ctx = *reinterpret_cast<TestContext *>(inContext);
+protected:
+    void SetUp() { ASSERT_EQ(mContext.Init(), CHIP_NO_ERROR); }
+    void TearDown() { mContext.Shutdown(); }
 
+    TestContext mContext;
+};
+
+TEST_F(TestSessionManager, CheckSimpleInitTest)
+{
     FabricTableHolder fabricTableHolder;
     SessionManager sessionManager;
     secure_channel::MessageCounterManager gMessageCounterManager;
     chip::TestPersistentStorageDelegate deviceStorage;
     chip::Crypto::DefaultSessionKeystore sessionKeystore;
 
-    NL_TEST_ASSERT(inSuite, CHIP_NO_ERROR == fabricTableHolder.Init());
-    NL_TEST_ASSERT(inSuite,
-                   CHIP_NO_ERROR ==
-                       sessionManager.Init(&ctx.GetSystemLayer(), &ctx.GetTransportMgr(), &gMessageCounterManager, &deviceStorage,
-                                           &fabricTableHolder.GetFabricTable(), sessionKeystore));
+    EXPECT_EQ(CHIP_NO_ERROR, fabricTableHolder.Init());
+    EXPECT_EQ(CHIP_NO_ERROR,
+              sessionManager.Init(&mContext.GetSystemLayer(), &mContext.GetTransportMgr(), &gMessageCounterManager, &deviceStorage,
+                                  &fabricTableHolder.GetFabricTable(), sessionKeystore));
 }
 
-void CheckMessageTest(nlTestSuite * inSuite, void * inContext)
+TEST_F(TestSessionManager, CheckMessageTest)
 {
-    TestContext & ctx = *reinterpret_cast<TestContext *>(inContext);
-
     uint16_t payload_len = sizeof(PAYLOAD);
 
     TestSessMgrCallback callback;
     callback.LargeMessageSent = false;
 
     chip::System::PacketBufferHandle buffer = chip::MessagePacketBuffer::NewWithData(PAYLOAD, payload_len);
-    NL_TEST_ASSERT(inSuite, !buffer.IsNull());
+    EXPECT_FALSE(buffer.IsNull());
 
     IPAddress addr;
     IPAddress::FromString("::1", addr);
@@ -165,13 +163,10 @@
     FabricIndex aliceFabricIndex = kUndefinedFabricIndex;
     FabricIndex bobFabricIndex   = kUndefinedFabricIndex;
 
-    NL_TEST_ASSERT(inSuite, CHIP_NO_ERROR == fabricTableHolder.Init());
-    NL_TEST_ASSERT(inSuite,
-                   CHIP_NO_ERROR ==
-                       sessionManager.Init(&ctx.GetSystemLayer(), &ctx.GetTransportMgr(), &gMessageCounterManager, &deviceStorage,
-                                           &fabricTableHolder.GetFabricTable(), sessionKeystore));
-
-    callback.mSuite = inSuite;
+    EXPECT_EQ(CHIP_NO_ERROR, fabricTableHolder.Init());
+    EXPECT_EQ(CHIP_NO_ERROR,
+              sessionManager.Init(&mContext.GetSystemLayer(), &mContext.GetTransportMgr(), &gMessageCounterManager, &deviceStorage,
+                                  &fabricTableHolder.GetFabricTable(), sessionKeystore));
 
     sessionManager.SetMessageDelegate(&callback);
 
@@ -180,23 +175,23 @@
     err =
         fabricTable.AddNewFabricForTestIgnoringCollisions(GetRootACertAsset().mCert, GetIAA1CertAsset().mCert,
                                                           GetNodeA1CertAsset().mCert, GetNodeA1CertAsset().mKey, &aliceFabricIndex);
-    NL_TEST_ASSERT(inSuite, CHIP_NO_ERROR == err);
+    EXPECT_EQ(CHIP_NO_ERROR, err);
 
     err = fabricTable.AddNewFabricForTestIgnoringCollisions(GetRootACertAsset().mCert, GetIAA1CertAsset().mCert,
                                                             GetNodeA2CertAsset().mCert, GetNodeA2CertAsset().mKey, &bobFabricIndex);
-    NL_TEST_ASSERT(inSuite, CHIP_NO_ERROR == err);
+    EXPECT_EQ(CHIP_NO_ERROR, err);
 
     SessionHolder aliceToBobSession;
     err = sessionManager.InjectPaseSessionWithTestKey(aliceToBobSession, 2,
                                                       fabricTable.FindFabricWithIndex(bobFabricIndex)->GetNodeId(), 1,
                                                       aliceFabricIndex, peer, CryptoContext::SessionRole::kInitiator);
-    NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
+    EXPECT_EQ(err, CHIP_NO_ERROR);
 
     SessionHolder bobToAliceSession;
     err = sessionManager.InjectPaseSessionWithTestKey(bobToAliceSession, 1,
                                                       fabricTable.FindFabricWithIndex(aliceFabricIndex)->GetNodeId(), 2,
                                                       bobFabricIndex, peer, CryptoContext::SessionRole::kResponder);
-    NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
+    EXPECT_EQ(err, CHIP_NO_ERROR);
 
     // Should be able to send a message to itself by just calling send.
     callback.ReceiveHandlerCallCount = 0;
@@ -211,55 +206,53 @@
 
     EncryptedPacketBufferHandle preparedMessage;
     err = sessionManager.PrepareMessage(aliceToBobSession.Get().Value(), payloadHeader, std::move(buffer), preparedMessage);
-    NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
+    EXPECT_EQ(err, CHIP_NO_ERROR);
 
     err = sessionManager.SendPreparedMessage(aliceToBobSession.Get().Value(), preparedMessage);
-    NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
+    EXPECT_EQ(err, CHIP_NO_ERROR);
 
-    ctx.DrainAndServiceIO();
-    NL_TEST_ASSERT(inSuite, callback.ReceiveHandlerCallCount == 1);
+    mContext.DrainAndServiceIO();
+    EXPECT_EQ(callback.ReceiveHandlerCallCount, 1);
 
     // Let's send the max sized message and make sure it is received
     chip::System::PacketBufferHandle large_buffer = chip::MessagePacketBuffer::NewWithData(LARGE_PAYLOAD, kMaxAppMessageLen);
-    NL_TEST_ASSERT(inSuite, !large_buffer.IsNull());
+    EXPECT_FALSE(large_buffer.IsNull());
 
     callback.LargeMessageSent = true;
 
     err = sessionManager.PrepareMessage(aliceToBobSession.Get().Value(), payloadHeader, std::move(large_buffer), preparedMessage);
-    NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
+    EXPECT_EQ(err, CHIP_NO_ERROR);
 
     err = sessionManager.SendPreparedMessage(aliceToBobSession.Get().Value(), preparedMessage);
-    NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
+    EXPECT_EQ(err, CHIP_NO_ERROR);
 
-    ctx.DrainAndServiceIO();
-    NL_TEST_ASSERT(inSuite, callback.ReceiveHandlerCallCount == 2);
+    mContext.DrainAndServiceIO();
+    EXPECT_EQ(callback.ReceiveHandlerCallCount, 2);
 
     uint16_t large_payload_len = sizeof(LARGE_PAYLOAD);
 
     // Let's send bigger message than supported and make sure it fails to send
     chip::System::PacketBufferHandle extra_large_buffer = chip::MessagePacketBuffer::NewWithData(LARGE_PAYLOAD, large_payload_len);
-    NL_TEST_ASSERT(inSuite, !extra_large_buffer.IsNull());
+    EXPECT_FALSE(extra_large_buffer.IsNull());
 
     callback.LargeMessageSent = true;
 
     err = sessionManager.PrepareMessage(aliceToBobSession.Get().Value(), payloadHeader, std::move(extra_large_buffer),
                                         preparedMessage);
-    NL_TEST_ASSERT(inSuite, err == CHIP_ERROR_MESSAGE_TOO_LONG);
+    EXPECT_EQ(err, CHIP_ERROR_MESSAGE_TOO_LONG);
 
     sessionManager.Shutdown();
 }
 
-void SendEncryptedPacketTest(nlTestSuite * inSuite, void * inContext)
+TEST_F(TestSessionManager, SendEncryptedPacketTest)
 {
-    TestContext & ctx = *reinterpret_cast<TestContext *>(inContext);
-
     uint16_t payload_len = sizeof(PAYLOAD);
 
     TestSessMgrCallback callback;
     callback.LargeMessageSent = false;
 
     chip::System::PacketBufferHandle buffer = chip::MessagePacketBuffer::NewWithData(PAYLOAD, payload_len);
-    NL_TEST_ASSERT(inSuite, !buffer.IsNull());
+    EXPECT_FALSE(buffer.IsNull());
 
     IPAddress addr;
     IPAddress::FromString("::1", addr);
@@ -274,13 +267,10 @@
     FabricIndex aliceFabricIndex = kUndefinedFabricIndex;
     FabricIndex bobFabricIndex   = kUndefinedFabricIndex;
 
-    NL_TEST_ASSERT(inSuite, CHIP_NO_ERROR == fabricTableHolder.Init());
-    NL_TEST_ASSERT(inSuite,
-                   CHIP_NO_ERROR ==
-                       sessionManager.Init(&ctx.GetSystemLayer(), &ctx.GetTransportMgr(), &gMessageCounterManager, &deviceStorage,
-                                           &fabricTableHolder.GetFabricTable(), sessionKeystore));
-
-    callback.mSuite = inSuite;
+    EXPECT_EQ(CHIP_NO_ERROR, fabricTableHolder.Init());
+    EXPECT_EQ(CHIP_NO_ERROR,
+              sessionManager.Init(&mContext.GetSystemLayer(), &mContext.GetTransportMgr(), &gMessageCounterManager, &deviceStorage,
+                                  &fabricTableHolder.GetFabricTable(), sessionKeystore));
 
     sessionManager.SetMessageDelegate(&callback);
 
@@ -289,23 +279,23 @@
     err =
         fabricTable.AddNewFabricForTestIgnoringCollisions(GetRootACertAsset().mCert, GetIAA1CertAsset().mCert,
                                                           GetNodeA1CertAsset().mCert, GetNodeA1CertAsset().mKey, &aliceFabricIndex);
-    NL_TEST_ASSERT(inSuite, CHIP_NO_ERROR == err);
+    EXPECT_EQ(CHIP_NO_ERROR, err);
 
     err = fabricTable.AddNewFabricForTestIgnoringCollisions(GetRootACertAsset().mCert, GetIAA1CertAsset().mCert,
                                                             GetNodeA2CertAsset().mCert, GetNodeA2CertAsset().mKey, &bobFabricIndex);
-    NL_TEST_ASSERT(inSuite, CHIP_NO_ERROR == err);
+    EXPECT_EQ(CHIP_NO_ERROR, err);
 
     SessionHolder aliceToBobSession;
     err = sessionManager.InjectPaseSessionWithTestKey(aliceToBobSession, 2,
                                                       fabricTable.FindFabricWithIndex(bobFabricIndex)->GetNodeId(), 1,
                                                       aliceFabricIndex, peer, CryptoContext::SessionRole::kInitiator);
-    NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
+    EXPECT_EQ(err, CHIP_NO_ERROR);
 
     SessionHolder bobToAliceSession;
     err = sessionManager.InjectPaseSessionWithTestKey(bobToAliceSession, 1,
                                                       fabricTable.FindFabricWithIndex(aliceFabricIndex)->GetNodeId(), 2,
                                                       bobFabricIndex, peer, CryptoContext::SessionRole::kResponder);
-    NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
+    EXPECT_EQ(err, CHIP_NO_ERROR);
 
     // Should be able to send a message to itself by just calling send.
     callback.ReceiveHandlerCallCount = 0;
@@ -322,38 +312,36 @@
     payloadHeader.SetInitiator(true);
 
     err = sessionManager.PrepareMessage(aliceToBobSession.Get().Value(), payloadHeader, std::move(buffer), preparedMessage);
-    NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
+    EXPECT_EQ(err, CHIP_NO_ERROR);
 
     err = sessionManager.SendPreparedMessage(aliceToBobSession.Get().Value(), preparedMessage);
-    NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
+    EXPECT_EQ(err, CHIP_NO_ERROR);
 
-    ctx.DrainAndServiceIO();
-    NL_TEST_ASSERT(inSuite, callback.ReceiveHandlerCallCount == 1);
+    mContext.DrainAndServiceIO();
+    EXPECT_EQ(callback.ReceiveHandlerCallCount, 1);
 
     // Reset receive side message counter, or duplicated message will be denied.
     Transport::SecureSession * session = bobToAliceSession.Get().Value()->AsSecureSession();
     session->GetSessionMessageCounter().GetPeerMessageCounter().SetCounter(1);
 
     err = sessionManager.SendPreparedMessage(aliceToBobSession.Get().Value(), preparedMessage);
-    NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
+    EXPECT_EQ(err, CHIP_NO_ERROR);
 
-    ctx.DrainAndServiceIO();
-    NL_TEST_ASSERT(inSuite, callback.ReceiveHandlerCallCount == 2);
+    mContext.DrainAndServiceIO();
+    EXPECT_EQ(callback.ReceiveHandlerCallCount, 2);
 
     sessionManager.Shutdown();
 }
 
-void SendBadEncryptedPacketTest(nlTestSuite * inSuite, void * inContext)
+TEST_F(TestSessionManager, SendBadEncryptedPacketTest)
 {
-    TestContext & ctx = *reinterpret_cast<TestContext *>(inContext);
-
     uint16_t payload_len = sizeof(PAYLOAD);
 
     TestSessMgrCallback callback;
     callback.LargeMessageSent = false;
 
     chip::System::PacketBufferHandle buffer = chip::MessagePacketBuffer::NewWithData(PAYLOAD, payload_len);
-    NL_TEST_ASSERT(inSuite, !buffer.IsNull());
+    EXPECT_FALSE(buffer.IsNull());
 
     IPAddress addr;
     IPAddress::FromString("::1", addr);
@@ -368,13 +356,10 @@
     FabricIndex aliceFabricIndex = kUndefinedFabricIndex;
     FabricIndex bobFabricIndex   = kUndefinedFabricIndex;
 
-    NL_TEST_ASSERT(inSuite, CHIP_NO_ERROR == fabricTableHolder.Init());
-    NL_TEST_ASSERT(inSuite,
-                   CHIP_NO_ERROR ==
-                       sessionManager.Init(&ctx.GetSystemLayer(), &ctx.GetTransportMgr(), &gMessageCounterManager, &deviceStorage,
-                                           &fabricTableHolder.GetFabricTable(), sessionKeystore));
-
-    callback.mSuite = inSuite;
+    EXPECT_EQ(CHIP_NO_ERROR, fabricTableHolder.Init());
+    EXPECT_EQ(CHIP_NO_ERROR,
+              sessionManager.Init(&mContext.GetSystemLayer(), &mContext.GetTransportMgr(), &gMessageCounterManager, &deviceStorage,
+                                  &fabricTableHolder.GetFabricTable(), sessionKeystore));
 
     sessionManager.SetMessageDelegate(&callback);
 
@@ -383,23 +368,23 @@
     err =
         fabricTable.AddNewFabricForTestIgnoringCollisions(GetRootACertAsset().mCert, GetIAA1CertAsset().mCert,
                                                           GetNodeA1CertAsset().mCert, GetNodeA1CertAsset().mKey, &aliceFabricIndex);
-    NL_TEST_ASSERT(inSuite, CHIP_NO_ERROR == err);
+    EXPECT_EQ(CHIP_NO_ERROR, err);
 
     err = fabricTable.AddNewFabricForTestIgnoringCollisions(GetRootACertAsset().mCert, GetIAA1CertAsset().mCert,
                                                             GetNodeA2CertAsset().mCert, GetNodeA2CertAsset().mKey, &bobFabricIndex);
-    NL_TEST_ASSERT(inSuite, CHIP_NO_ERROR == err);
+    EXPECT_EQ(CHIP_NO_ERROR, err);
 
     SessionHolder aliceToBobSession;
     err = sessionManager.InjectPaseSessionWithTestKey(aliceToBobSession, 2,
                                                       fabricTable.FindFabricWithIndex(bobFabricIndex)->GetNodeId(), 1,
                                                       aliceFabricIndex, peer, CryptoContext::SessionRole::kInitiator);
-    NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
+    EXPECT_EQ(err, CHIP_NO_ERROR);
 
     SessionHolder bobToAliceSession;
     err = sessionManager.InjectPaseSessionWithTestKey(bobToAliceSession, 1,
                                                       fabricTable.FindFabricWithIndex(aliceFabricIndex)->GetNodeId(), 2,
                                                       bobFabricIndex, peer, CryptoContext::SessionRole::kResponder);
-    NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
+    EXPECT_EQ(err, CHIP_NO_ERROR);
 
     // Should be able to send a message to itself by just calling send.
     callback.ReceiveHandlerCallCount = 0;
@@ -416,13 +401,13 @@
     payloadHeader.SetInitiator(true);
 
     err = sessionManager.PrepareMessage(aliceToBobSession.Get().Value(), payloadHeader, std::move(buffer), preparedMessage);
-    NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
+    EXPECT_EQ(err, CHIP_NO_ERROR);
 
     err = sessionManager.SendPreparedMessage(aliceToBobSession.Get().Value(), preparedMessage);
-    NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
+    EXPECT_EQ(err, CHIP_NO_ERROR);
 
-    ctx.DrainAndServiceIO();
-    NL_TEST_ASSERT(inSuite, callback.ReceiveHandlerCallCount == 1);
+    mContext.DrainAndServiceIO();
+    EXPECT_EQ(callback.ReceiveHandlerCallCount, 1);
 
     /* -------------------------------------------------------------------------------------------*/
     // Reset receive side message counter, or duplicated message will be denied.
@@ -433,59 +418,57 @@
 
     // Change Message ID
     EncryptedPacketBufferHandle badMessageCounterMsg = preparedMessage.CloneData();
-    NL_TEST_ASSERT(inSuite, badMessageCounterMsg.ExtractPacketHeader(packetHeader) == CHIP_NO_ERROR);
+    EXPECT_EQ(badMessageCounterMsg.ExtractPacketHeader(packetHeader), CHIP_NO_ERROR);
 
     uint32_t messageCounter = packetHeader.GetMessageCounter();
     packetHeader.SetMessageCounter(messageCounter + 1);
-    NL_TEST_ASSERT(inSuite, badMessageCounterMsg.InsertPacketHeader(packetHeader) == CHIP_NO_ERROR);
+    EXPECT_EQ(badMessageCounterMsg.InsertPacketHeader(packetHeader), CHIP_NO_ERROR);
 
     err = sessionManager.SendPreparedMessage(aliceToBobSession.Get().Value(), badMessageCounterMsg);
-    NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
+    EXPECT_EQ(err, CHIP_NO_ERROR);
 
-    ctx.DrainAndServiceIO();
-    NL_TEST_ASSERT(inSuite, callback.ReceiveHandlerCallCount == 1);
+    mContext.DrainAndServiceIO();
+    EXPECT_EQ(callback.ReceiveHandlerCallCount, 1);
 
     /* -------------------------------------------------------------------------------------------*/
     session->GetSessionMessageCounter().GetPeerMessageCounter().SetCounter(1);
 
     // Change Key ID
     EncryptedPacketBufferHandle badKeyIdMsg = preparedMessage.CloneData();
-    NL_TEST_ASSERT(inSuite, badKeyIdMsg.ExtractPacketHeader(packetHeader) == CHIP_NO_ERROR);
+    EXPECT_EQ(badKeyIdMsg.ExtractPacketHeader(packetHeader), CHIP_NO_ERROR);
 
     // the secure channel is setup to use key ID 1, and 2. So let's use 3 here.
     packetHeader.SetSessionId(3);
-    NL_TEST_ASSERT(inSuite, badKeyIdMsg.InsertPacketHeader(packetHeader) == CHIP_NO_ERROR);
+    EXPECT_EQ(badKeyIdMsg.InsertPacketHeader(packetHeader), CHIP_NO_ERROR);
 
     err = sessionManager.SendPreparedMessage(aliceToBobSession.Get().Value(), badKeyIdMsg);
-    NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
+    EXPECT_EQ(err, CHIP_NO_ERROR);
 
-    ctx.DrainAndServiceIO();
-    NL_TEST_ASSERT(inSuite, callback.ReceiveHandlerCallCount == 1);
+    mContext.DrainAndServiceIO();
+    EXPECT_EQ(callback.ReceiveHandlerCallCount, 1);
 
     /* -------------------------------------------------------------------------------------------*/
     session->GetSessionMessageCounter().GetPeerMessageCounter().SetCounter(1);
 
     // Send the correct encrypted msg
     err = sessionManager.SendPreparedMessage(aliceToBobSession.Get().Value(), preparedMessage);
-    NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
+    EXPECT_EQ(err, CHIP_NO_ERROR);
 
-    ctx.DrainAndServiceIO();
-    NL_TEST_ASSERT(inSuite, callback.ReceiveHandlerCallCount == 2);
+    mContext.DrainAndServiceIO();
+    EXPECT_EQ(callback.ReceiveHandlerCallCount, 2);
 
     sessionManager.Shutdown();
 }
 
-void SendPacketWithOldCounterTest(nlTestSuite * inSuite, void * inContext)
+TEST_F(TestSessionManager, SendPacketWithOldCounterTest)
 {
-    TestContext & ctx = *reinterpret_cast<TestContext *>(inContext);
-
     uint16_t payload_len = sizeof(PAYLOAD);
 
     TestSessMgrCallback callback;
     callback.LargeMessageSent = false;
 
     chip::System::PacketBufferHandle buffer = chip::MessagePacketBuffer::NewWithData(PAYLOAD, payload_len);
-    NL_TEST_ASSERT(inSuite, !buffer.IsNull());
+    EXPECT_FALSE(buffer.IsNull());
 
     IPAddress addr;
     IPAddress::FromString("::1", addr);
@@ -500,13 +483,10 @@
     FabricIndex aliceFabricIndex = kUndefinedFabricIndex;
     FabricIndex bobFabricIndex   = kUndefinedFabricIndex;
 
-    NL_TEST_ASSERT(inSuite, CHIP_NO_ERROR == fabricTableHolder.Init());
-    NL_TEST_ASSERT(inSuite,
-                   CHIP_NO_ERROR ==
-                       sessionManager.Init(&ctx.GetSystemLayer(), &ctx.GetTransportMgr(), &gMessageCounterManager, &deviceStorage,
-                                           &fabricTableHolder.GetFabricTable(), sessionKeystore));
-
-    callback.mSuite = inSuite;
+    EXPECT_EQ(CHIP_NO_ERROR, fabricTableHolder.Init());
+    EXPECT_EQ(CHIP_NO_ERROR,
+              sessionManager.Init(&mContext.GetSystemLayer(), &mContext.GetTransportMgr(), &gMessageCounterManager, &deviceStorage,
+                                  &fabricTableHolder.GetFabricTable(), sessionKeystore));
 
     sessionManager.SetMessageDelegate(&callback);
 
@@ -515,23 +495,23 @@
     err =
         fabricTable.AddNewFabricForTestIgnoringCollisions(GetRootACertAsset().mCert, GetIAA1CertAsset().mCert,
                                                           GetNodeA1CertAsset().mCert, GetNodeA1CertAsset().mKey, &aliceFabricIndex);
-    NL_TEST_ASSERT(inSuite, CHIP_NO_ERROR == err);
+    EXPECT_EQ(CHIP_NO_ERROR, err);
 
     err = fabricTable.AddNewFabricForTestIgnoringCollisions(GetRootACertAsset().mCert, GetIAA1CertAsset().mCert,
                                                             GetNodeA2CertAsset().mCert, GetNodeA2CertAsset().mKey, &bobFabricIndex);
-    NL_TEST_ASSERT(inSuite, CHIP_NO_ERROR == err);
+    EXPECT_EQ(CHIP_NO_ERROR, err);
 
     SessionHolder aliceToBobSession;
     err = sessionManager.InjectPaseSessionWithTestKey(aliceToBobSession, 2,
                                                       fabricTable.FindFabricWithIndex(bobFabricIndex)->GetNodeId(), 1,
                                                       aliceFabricIndex, peer, CryptoContext::SessionRole::kInitiator);
-    NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
+    EXPECT_EQ(err, CHIP_NO_ERROR);
 
     SessionHolder bobToAliceSession;
     err = sessionManager.InjectPaseSessionWithTestKey(bobToAliceSession, 1,
                                                       fabricTable.FindFabricWithIndex(aliceFabricIndex)->GetNodeId(), 2,
                                                       bobFabricIndex, peer, CryptoContext::SessionRole::kResponder);
-    NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
+    EXPECT_EQ(err, CHIP_NO_ERROR);
 
     callback.ReceiveHandlerCallCount = 0;
 
@@ -547,53 +527,51 @@
     payloadHeader.SetInitiator(true);
 
     err = sessionManager.PrepareMessage(aliceToBobSession.Get().Value(), payloadHeader, std::move(buffer), preparedMessage);
-    NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
+    EXPECT_EQ(err, CHIP_NO_ERROR);
 
     err = sessionManager.SendPreparedMessage(aliceToBobSession.Get().Value(), preparedMessage);
-    NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
+    EXPECT_EQ(err, CHIP_NO_ERROR);
 
-    ctx.DrainAndServiceIO();
-    NL_TEST_ASSERT(inSuite, callback.ReceiveHandlerCallCount == 1);
+    mContext.DrainAndServiceIO();
+    EXPECT_EQ(callback.ReceiveHandlerCallCount, 1);
 
     // Now advance our message counter by 5.
     EncryptedPacketBufferHandle newMessage;
     for (size_t i = 0; i < 5; ++i)
     {
         buffer = chip::MessagePacketBuffer::NewWithData(PAYLOAD, payload_len);
-        NL_TEST_ASSERT(inSuite, !buffer.IsNull());
+        EXPECT_FALSE(buffer.IsNull());
 
         err = sessionManager.PrepareMessage(aliceToBobSession.Get().Value(), payloadHeader, std::move(buffer), newMessage);
-        NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
+        EXPECT_EQ(err, CHIP_NO_ERROR);
     }
 
     err = sessionManager.SendPreparedMessage(aliceToBobSession.Get().Value(), newMessage);
-    NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
+    EXPECT_EQ(err, CHIP_NO_ERROR);
 
-    ctx.DrainAndServiceIO();
-    NL_TEST_ASSERT(inSuite, callback.ReceiveHandlerCallCount == 2);
+    mContext.DrainAndServiceIO();
+    EXPECT_EQ(callback.ReceiveHandlerCallCount, 2);
 
     // Now resend our original message.  It should be rejected as a duplicate.
 
     err = sessionManager.SendPreparedMessage(aliceToBobSession.Get().Value(), preparedMessage);
-    NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
+    EXPECT_EQ(err, CHIP_NO_ERROR);
 
-    ctx.DrainAndServiceIO();
-    NL_TEST_ASSERT(inSuite, callback.ReceiveHandlerCallCount == 2);
+    mContext.DrainAndServiceIO();
+    EXPECT_EQ(callback.ReceiveHandlerCallCount, 2);
 
     sessionManager.Shutdown();
 }
 
-void SendPacketWithTooOldCounterTest(nlTestSuite * inSuite, void * inContext)
+TEST_F(TestSessionManager, SendPacketWithTooOldCounterTest)
 {
-    TestContext & ctx = *reinterpret_cast<TestContext *>(inContext);
-
     uint16_t payload_len = sizeof(PAYLOAD);
 
     TestSessMgrCallback callback;
     callback.LargeMessageSent = false;
 
     chip::System::PacketBufferHandle buffer = chip::MessagePacketBuffer::NewWithData(PAYLOAD, payload_len);
-    NL_TEST_ASSERT(inSuite, !buffer.IsNull());
+    EXPECT_FALSE(buffer.IsNull());
 
     IPAddress addr;
     IPAddress::FromString("::1", addr);
@@ -608,13 +586,10 @@
     FabricIndex aliceFabricIndex = kUndefinedFabricIndex;
     FabricIndex bobFabricIndex   = kUndefinedFabricIndex;
 
-    NL_TEST_ASSERT(inSuite, CHIP_NO_ERROR == fabricTableHolder.Init());
-    NL_TEST_ASSERT(inSuite,
-                   CHIP_NO_ERROR ==
-                       sessionManager.Init(&ctx.GetSystemLayer(), &ctx.GetTransportMgr(), &gMessageCounterManager, &deviceStorage,
-                                           &fabricTableHolder.GetFabricTable(), sessionKeystore));
-    callback.mSuite = inSuite;
-
+    EXPECT_EQ(CHIP_NO_ERROR, fabricTableHolder.Init());
+    EXPECT_EQ(CHIP_NO_ERROR,
+              sessionManager.Init(&mContext.GetSystemLayer(), &mContext.GetTransportMgr(), &gMessageCounterManager, &deviceStorage,
+                                  &fabricTableHolder.GetFabricTable(), sessionKeystore));
     sessionManager.SetMessageDelegate(&callback);
 
     Transport::PeerAddress peer(Transport::PeerAddress::UDP(addr, CHIP_PORT));
@@ -622,23 +597,23 @@
     err =
         fabricTable.AddNewFabricForTestIgnoringCollisions(GetRootACertAsset().mCert, GetIAA1CertAsset().mCert,
                                                           GetNodeA1CertAsset().mCert, GetNodeA1CertAsset().mKey, &aliceFabricIndex);
-    NL_TEST_ASSERT(inSuite, CHIP_NO_ERROR == err);
+    EXPECT_EQ(CHIP_NO_ERROR, err);
 
     err = fabricTable.AddNewFabricForTestIgnoringCollisions(GetRootACertAsset().mCert, GetIAA1CertAsset().mCert,
                                                             GetNodeA2CertAsset().mCert, GetNodeA2CertAsset().mKey, &bobFabricIndex);
-    NL_TEST_ASSERT(inSuite, CHIP_NO_ERROR == err);
+    EXPECT_EQ(CHIP_NO_ERROR, err);
 
     SessionHolder aliceToBobSession;
     err = sessionManager.InjectPaseSessionWithTestKey(aliceToBobSession, 2,
                                                       fabricTable.FindFabricWithIndex(bobFabricIndex)->GetNodeId(), 1,
                                                       aliceFabricIndex, peer, CryptoContext::SessionRole::kInitiator);
-    NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
+    EXPECT_EQ(err, CHIP_NO_ERROR);
 
     SessionHolder bobToAliceSession;
     err = sessionManager.InjectPaseSessionWithTestKey(bobToAliceSession, 1,
                                                       fabricTable.FindFabricWithIndex(aliceFabricIndex)->GetNodeId(), 2,
                                                       bobFabricIndex, peer, CryptoContext::SessionRole::kResponder);
-    NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
+    EXPECT_EQ(err, CHIP_NO_ERROR);
 
     callback.ReceiveHandlerCallCount = 0;
 
@@ -654,13 +629,13 @@
     payloadHeader.SetInitiator(true);
 
     err = sessionManager.PrepareMessage(aliceToBobSession.Get().Value(), payloadHeader, std::move(buffer), preparedMessage);
-    NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
+    EXPECT_EQ(err, CHIP_NO_ERROR);
 
     err = sessionManager.SendPreparedMessage(aliceToBobSession.Get().Value(), preparedMessage);
-    NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
+    EXPECT_EQ(err, CHIP_NO_ERROR);
 
-    ctx.DrainAndServiceIO();
-    NL_TEST_ASSERT(inSuite, callback.ReceiveHandlerCallCount == 1);
+    mContext.DrainAndServiceIO();
+    EXPECT_EQ(callback.ReceiveHandlerCallCount, 1);
 
     // Now advance our message counter by at least
     // CHIP_CONFIG_MESSAGE_COUNTER_WINDOW_SIZE + 2, so preparedMessage will be
@@ -669,30 +644,30 @@
     for (size_t i = 0; i < CHIP_CONFIG_MESSAGE_COUNTER_WINDOW_SIZE + 2; ++i)
     {
         buffer = chip::MessagePacketBuffer::NewWithData(PAYLOAD, payload_len);
-        NL_TEST_ASSERT(inSuite, !buffer.IsNull());
+        EXPECT_FALSE(buffer.IsNull());
 
         err = sessionManager.PrepareMessage(aliceToBobSession.Get().Value(), payloadHeader, std::move(buffer), newMessage);
-        NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
+        EXPECT_EQ(err, CHIP_NO_ERROR);
     }
 
     err = sessionManager.SendPreparedMessage(aliceToBobSession.Get().Value(), newMessage);
-    NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
+    EXPECT_EQ(err, CHIP_NO_ERROR);
 
-    ctx.DrainAndServiceIO();
-    NL_TEST_ASSERT(inSuite, callback.ReceiveHandlerCallCount == 2);
+    mContext.DrainAndServiceIO();
+    EXPECT_EQ(callback.ReceiveHandlerCallCount, 2);
 
     // Now resend our original message.  It should be rejected as a duplicate.
 
     err = sessionManager.SendPreparedMessage(aliceToBobSession.Get().Value(), preparedMessage);
-    NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
+    EXPECT_EQ(err, CHIP_NO_ERROR);
 
-    ctx.DrainAndServiceIO();
-    NL_TEST_ASSERT(inSuite, callback.ReceiveHandlerCallCount == 2);
+    mContext.DrainAndServiceIO();
+    EXPECT_EQ(callback.ReceiveHandlerCallCount, 2);
 
     sessionManager.Shutdown();
 }
 
-static void RandomSessionIdAllocatorOffset(nlTestSuite * inSuite, SessionManager & sessionManager, int max)
+static void RandomSessionIdAllocatorOffset(SessionManager & sessionManager, int max)
 {
     // Allocate + free a pseudo-random number of sessions to create a
     // pseudo-random offset in mNextSessionId.
@@ -702,27 +677,24 @@
         auto handle = sessionManager.AllocateSession(
             Transport::SecureSession::Type::kPASE,
             ScopedNodeId(NodeIdFromPAKEKeyId(kDefaultCommissioningPasscodeId), kUndefinedFabricIndex));
-        NL_TEST_ASSERT(inSuite, handle.HasValue());
+        EXPECT_TRUE(handle.HasValue());
         handle.Value()->AsSecureSession()->MarkForEviction();
     }
 }
 
-void SessionAllocationTest(nlTestSuite * inSuite, void * inContext)
+TEST_F(TestSessionManager, SessionAllocationTest)
 {
-    TestContext & ctx = *reinterpret_cast<TestContext *>(inContext);
-
     FabricTableHolder fabricTableHolder;
-    NL_TEST_ASSERT(inSuite, CHIP_NO_ERROR == fabricTableHolder.Init());
+    EXPECT_EQ(CHIP_NO_ERROR, fabricTableHolder.Init());
 
     secure_channel::MessageCounterManager messageCounterManager;
     TestPersistentStorageDelegate deviceStorage1, deviceStorage2;
     chip::Crypto::DefaultSessionKeystore sessionKeystore;
     SessionManager sessionManager;
 
-    NL_TEST_ASSERT(inSuite,
-                   CHIP_NO_ERROR ==
-                       sessionManager.Init(&ctx.GetSystemLayer(), &ctx.GetTransportMgr(), &messageCounterManager, &deviceStorage1,
-                                           &fabricTableHolder.GetFabricTable(), sessionKeystore));
+    EXPECT_EQ(CHIP_NO_ERROR,
+              sessionManager.Init(&mContext.GetSystemLayer(), &mContext.GetTransportMgr(), &messageCounterManager, &deviceStorage1,
+                                  &fabricTableHolder.GetFabricTable(), sessionKeystore));
 
     // Allocate a session.
     uint16_t sessionId1;
@@ -730,7 +702,7 @@
         auto handle = sessionManager.AllocateSession(
             Transport::SecureSession::Type::kPASE,
             ScopedNodeId(NodeIdFromPAKEKeyId(kDefaultCommissioningPasscodeId), kUndefinedFabricIndex));
-        NL_TEST_ASSERT(inSuite, handle.HasValue());
+        EXPECT_TRUE(handle.HasValue());
         SessionHolder session;
         session.GrabPairingSession(handle.Value());
         sessionId1 = session->AsSecureSession()->GetLocalSessionId();
@@ -749,8 +721,8 @@
             break;
         }
         auto sessionId = handle.Value()->AsSecureSession()->GetLocalSessionId();
-        NL_TEST_ASSERT(inSuite, sessionId - prevSessionId == 1 || (sessionId == 1 && prevSessionId == 65535));
-        NL_TEST_ASSERT(inSuite, sessionId != 0);
+        EXPECT_TRUE(sessionId - prevSessionId == 1 || (sessionId == 1 && prevSessionId == 65535));
+        EXPECT_NE(sessionId, 0);
         prevSessionId = sessionId;
     }
 
@@ -758,17 +730,16 @@
     sessionManager.Shutdown();
     sessionManager.~SessionManager();
     new (&sessionManager) SessionManager();
-    NL_TEST_ASSERT(inSuite,
-                   CHIP_NO_ERROR ==
-                       sessionManager.Init(&ctx.GetSystemLayer(), &ctx.GetTransportMgr(), &messageCounterManager, &deviceStorage2,
-                                           &fabricTableHolder.GetFabricTable(), sessionKeystore));
+    EXPECT_EQ(CHIP_NO_ERROR,
+              sessionManager.Init(&mContext.GetSystemLayer(), &mContext.GetTransportMgr(), &messageCounterManager, &deviceStorage2,
+                                  &fabricTableHolder.GetFabricTable(), sessionKeystore));
 
     // Allocate a single session so we know what random id we are starting at.
     {
         auto handle = sessionManager.AllocateSession(
             Transport::SecureSession::Type::kPASE,
             ScopedNodeId(NodeIdFromPAKEKeyId(kDefaultCommissioningPasscodeId), kUndefinedFabricIndex));
-        NL_TEST_ASSERT(inSuite, handle.HasValue());
+        EXPECT_TRUE(handle.HasValue());
         prevSessionId = handle.Value()->AsSecureSession()->GetLocalSessionId();
         handle.Value()->AsSecureSession()->MarkForEviction();
     }
@@ -781,10 +752,10 @@
         auto handle = sessionManager.AllocateSession(
             Transport::SecureSession::Type::kPASE,
             ScopedNodeId(NodeIdFromPAKEKeyId(kDefaultCommissioningPasscodeId), kUndefinedFabricIndex));
-        NL_TEST_ASSERT(inSuite, handle.HasValue());
+        EXPECT_TRUE(handle.HasValue());
         auto sessionId = handle.Value()->AsSecureSession()->GetLocalSessionId();
-        NL_TEST_ASSERT(inSuite, sessionId - prevSessionId == 1 || (sessionId == 1 && prevSessionId == 65535));
-        NL_TEST_ASSERT(inSuite, sessionId != 0);
+        EXPECT_TRUE(sessionId - prevSessionId == 1 || (sessionId == 1 && prevSessionId == 65535));
+        EXPECT_NE(sessionId, 0);
         prevSessionId = sessionId;
         handle.Value()->AsSecureSession()->MarkForEviction();
     }
@@ -804,15 +775,15 @@
             handles[h]              = sessionManager.AllocateSession(
                 Transport::SecureSession::Type::kPASE,
                 ScopedNodeId(NodeIdFromPAKEKeyId(kDefaultCommissioningPasscodeId), kUndefinedFabricIndex));
-            NL_TEST_ASSERT(inSuite, handles[h].HasValue());
+            EXPECT_TRUE(handles[h].HasValue());
             sessionIds[h] = handles[h].Value()->AsSecureSession()->GetLocalSessionId();
-            RandomSessionIdAllocatorOffset(inSuite, sessionManager, maxOffset);
+            RandomSessionIdAllocatorOffset(sessionManager, maxOffset);
         }
 
         // Verify that none collide each other.
         for (size_t h = 0; h < numHandles; ++h)
         {
-            NL_TEST_ASSERT(inSuite, sessionIds[h] != sessionIds[(h + 1) % numHandles]);
+            EXPECT_NE(sessionIds[h], sessionIds[(h + 1) % numHandles]);
         }
 
         // Allocate through the entire session ID space and verify that none of
@@ -822,11 +793,11 @@
             auto handle = sessionManager.AllocateSession(
                 Transport::SecureSession::Type::kPASE,
                 ScopedNodeId(NodeIdFromPAKEKeyId(kDefaultCommissioningPasscodeId), kUndefinedFabricIndex));
-            NL_TEST_ASSERT(inSuite, handle.HasValue());
+            EXPECT_TRUE(handle.HasValue());
             auto potentialCollision = handle.Value()->AsSecureSession()->GetLocalSessionId();
             for (uint16_t sessionId : sessionIds)
             {
-                NL_TEST_ASSERT(inSuite, potentialCollision != sessionId);
+                EXPECT_NE(potentialCollision, sessionId);
             }
             handle.Value()->AsSecureSession()->MarkForEviction();
         }
@@ -841,10 +812,8 @@
     sessionManager.Shutdown();
 }
 
-void SessionCounterExhaustedTest(nlTestSuite * inSuite, void * inContext)
+TEST_F(TestSessionManager, SessionCounterExhaustedTest)
 {
-    TestContext & ctx = *reinterpret_cast<TestContext *>(inContext);
-
     IPAddress addr;
     IPAddress::FromString("::1", addr);
     CHIP_ERROR err = CHIP_NO_ERROR;
@@ -858,34 +827,33 @@
     FabricIndex aliceFabricIndex = kUndefinedFabricIndex;
     FabricIndex bobFabricIndex   = kUndefinedFabricIndex;
 
-    NL_TEST_ASSERT(inSuite, CHIP_NO_ERROR == fabricTableHolder.Init());
-    NL_TEST_ASSERT(inSuite,
-                   CHIP_NO_ERROR ==
-                       sessionManager.Init(&ctx.GetSystemLayer(), &ctx.GetTransportMgr(), &gMessageCounterManager, &deviceStorage,
-                                           &fabricTableHolder.GetFabricTable(), sessionKeystore));
+    EXPECT_EQ(CHIP_NO_ERROR, fabricTableHolder.Init());
+    EXPECT_EQ(CHIP_NO_ERROR,
+              sessionManager.Init(&mContext.GetSystemLayer(), &mContext.GetTransportMgr(), &gMessageCounterManager, &deviceStorage,
+                                  &fabricTableHolder.GetFabricTable(), sessionKeystore));
 
     Transport::PeerAddress peer(Transport::PeerAddress::UDP(addr, CHIP_PORT));
 
     err =
         fabricTable.AddNewFabricForTestIgnoringCollisions(GetRootACertAsset().mCert, GetIAA1CertAsset().mCert,
                                                           GetNodeA1CertAsset().mCert, GetNodeA1CertAsset().mKey, &aliceFabricIndex);
-    NL_TEST_ASSERT(inSuite, CHIP_NO_ERROR == err);
+    EXPECT_EQ(CHIP_NO_ERROR, err);
 
     err = fabricTable.AddNewFabricForTestIgnoringCollisions(GetRootACertAsset().mCert, GetIAA1CertAsset().mCert,
                                                             GetNodeA2CertAsset().mCert, GetNodeA2CertAsset().mKey, &bobFabricIndex);
-    NL_TEST_ASSERT(inSuite, CHIP_NO_ERROR == err);
+    EXPECT_EQ(CHIP_NO_ERROR, err);
 
     SessionHolder aliceToBobSession;
     err = sessionManager.InjectPaseSessionWithTestKey(aliceToBobSession, 2,
                                                       fabricTable.FindFabricWithIndex(bobFabricIndex)->GetNodeId(), 1,
                                                       aliceFabricIndex, peer, CryptoContext::SessionRole::kInitiator);
-    NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
+    EXPECT_EQ(err, CHIP_NO_ERROR);
 
     SessionHolder bobToAliceSession;
     err = sessionManager.InjectPaseSessionWithTestKey(bobToAliceSession, 1,
                                                       fabricTable.FindFabricWithIndex(aliceFabricIndex)->GetNodeId(), 2,
                                                       bobFabricIndex, peer, CryptoContext::SessionRole::kResponder);
-    NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
+    EXPECT_EQ(err, CHIP_NO_ERROR);
 
     // ==== Set counter value to max ====
     LocalSessionMessageCounter & counter = static_cast<LocalSessionMessageCounter &>(
@@ -894,7 +862,7 @@
 
     // ==== Build a valid message with max counter value ====
     chip::System::PacketBufferHandle buffer = chip::MessagePacketBuffer::NewWithData(PAYLOAD, sizeof(PAYLOAD));
-    NL_TEST_ASSERT(inSuite, !buffer.IsNull());
+    EXPECT_FALSE(buffer.IsNull());
 
     PayloadHeader payloadHeader;
 
@@ -906,23 +874,21 @@
 
     EncryptedPacketBufferHandle preparedMessage;
     err = sessionManager.PrepareMessage(aliceToBobSession.Get().Value(), payloadHeader, std::move(buffer), preparedMessage);
-    NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
+    EXPECT_EQ(err, CHIP_NO_ERROR);
 
     // ==== Build another message which will fail becuase message counter is exhausted ====
     chip::System::PacketBufferHandle buffer2 = chip::MessagePacketBuffer::NewWithData(PAYLOAD, sizeof(PAYLOAD));
-    NL_TEST_ASSERT(inSuite, !buffer2.IsNull());
+    EXPECT_FALSE(buffer2.IsNull());
 
     EncryptedPacketBufferHandle preparedMessage2;
     err = sessionManager.PrepareMessage(aliceToBobSession.Get().Value(), payloadHeader, std::move(buffer2), preparedMessage2);
-    NL_TEST_ASSERT(inSuite, err == CHIP_ERROR_MESSAGE_COUNTER_EXHAUSTED);
+    EXPECT_EQ(err, CHIP_ERROR_MESSAGE_COUNTER_EXHAUSTED);
 
     sessionManager.Shutdown();
 }
 
-static void SessionShiftingTest(nlTestSuite * inSuite, void * inContext)
+TEST_F(TestSessionManager, SessionShiftingTest)
 {
-    TestContext & ctx = *reinterpret_cast<TestContext *>(inContext);
-
     IPAddress addr;
     IPAddress::FromString("::1", addr);
 
@@ -937,18 +903,17 @@
     chip::Crypto::DefaultSessionKeystore sessionKeystore;
     SessionManager sessionManager;
 
-    NL_TEST_ASSERT(inSuite, CHIP_NO_ERROR == fabricTableHolder.Init());
-    NL_TEST_ASSERT(inSuite,
-                   CHIP_NO_ERROR ==
-                       sessionManager.Init(&ctx.GetSystemLayer(), &ctx.GetTransportMgr(), &messageCounterManager, &deviceStorage,
-                                           &fabricTableHolder.GetFabricTable(), sessionKeystore));
+    EXPECT_EQ(CHIP_NO_ERROR, fabricTableHolder.Init());
+    EXPECT_EQ(CHIP_NO_ERROR,
+              sessionManager.Init(&mContext.GetSystemLayer(), &mContext.GetTransportMgr(), &messageCounterManager, &deviceStorage,
+                                  &fabricTableHolder.GetFabricTable(), sessionKeystore));
 
     Transport::PeerAddress peer(Transport::PeerAddress::UDP(addr, CHIP_PORT));
 
     SessionHolder aliceToBobSession;
     CHIP_ERROR err = sessionManager.InjectCaseSessionWithTestKey(aliceToBobSession, 2, 1, aliceNodeId, bobNodeId, aliceFabricIndex,
                                                                  peer, CryptoContext::SessionRole::kInitiator);
-    NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
+    EXPECT_EQ(err, CHIP_NO_ERROR);
 
     class StickySessionDelegate : public SessionDelegate
     {
@@ -958,17 +923,17 @@
     } delegate;
 
     SessionHolderWithDelegate stickyAliceToBobSession(aliceToBobSession.Get().Value(), delegate);
-    NL_TEST_ASSERT(inSuite, aliceToBobSession.Contains(stickyAliceToBobSession.Get().Value()));
+    EXPECT_TRUE(aliceToBobSession.Contains(stickyAliceToBobSession.Get().Value()));
 
     SessionHolder bobToAliceSession;
     err = sessionManager.InjectCaseSessionWithTestKey(bobToAliceSession, 1, 2, bobNodeId, aliceNodeId, bobFabricIndex, peer,
                                                       CryptoContext::SessionRole::kResponder);
-    NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
+    EXPECT_EQ(err, CHIP_NO_ERROR);
 
     SessionHolder newAliceToBobSession;
     err = sessionManager.InjectCaseSessionWithTestKey(newAliceToBobSession, 3, 4, aliceNodeId, bobNodeId, aliceFabricIndex, peer,
                                                       CryptoContext::SessionRole::kInitiator);
-    NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
+    EXPECT_EQ(err, CHIP_NO_ERROR);
 
     // Here we got 3 sessions, and 4 holders:
     // 1. alice -> bob: aliceToBobSession, stickyAliceToBobSession
@@ -979,8 +944,8 @@
     SecureSession * session2 = bobToAliceSession->AsSecureSession();
     SecureSession * session3 = newAliceToBobSession->AsSecureSession();
 
-    NL_TEST_ASSERT(inSuite, session1 != session3);
-    NL_TEST_ASSERT(inSuite, stickyAliceToBobSession->AsSecureSession() == session1);
+    EXPECT_NE(session1, session3);
+    EXPECT_EQ(stickyAliceToBobSession->AsSecureSession(), session1);
 
     // Now shift the 1st session to the 3rd one, after shifting, holders should be:
     // 1. alice -> bob: stickyAliceToBobSession
@@ -988,22 +953,20 @@
     // 3. alice -> bob: aliceToBobSession, newAliceToBobSession
     sessionManager.GetSecureSessions().NewerSessionAvailable(newAliceToBobSession.Get().Value()->AsSecureSession());
 
-    NL_TEST_ASSERT(inSuite, aliceToBobSession);
-    NL_TEST_ASSERT(inSuite, stickyAliceToBobSession);
-    NL_TEST_ASSERT(inSuite, newAliceToBobSession);
+    EXPECT_TRUE(aliceToBobSession);
+    EXPECT_TRUE(stickyAliceToBobSession);
+    EXPECT_TRUE(newAliceToBobSession);
 
-    NL_TEST_ASSERT(inSuite, stickyAliceToBobSession->AsSecureSession() == session1);
-    NL_TEST_ASSERT(inSuite, bobToAliceSession->AsSecureSession() == session2);
-    NL_TEST_ASSERT(inSuite, aliceToBobSession->AsSecureSession() == session3);
-    NL_TEST_ASSERT(inSuite, newAliceToBobSession->AsSecureSession() == session3);
+    EXPECT_EQ(stickyAliceToBobSession->AsSecureSession(), session1);
+    EXPECT_EQ(bobToAliceSession->AsSecureSession(), session2);
+    EXPECT_EQ(aliceToBobSession->AsSecureSession(), session3);
+    EXPECT_EQ(newAliceToBobSession->AsSecureSession(), session3);
 
     sessionManager.Shutdown();
 }
 
-static void TestFindSecureSessionForNode(nlTestSuite * inSuite, void * inContext)
+TEST_F(TestSessionManager, TestFindSecureSessionForNode)
 {
-    TestContext & ctx = *reinterpret_cast<TestContext *>(inContext);
-
     IPAddress addr;
     IPAddress::FromString("::1", addr);
 
@@ -1017,24 +980,23 @@
     chip::Crypto::DefaultSessionKeystore sessionKeystore;
     SessionManager sessionManager;
 
-    NL_TEST_ASSERT(inSuite, CHIP_NO_ERROR == fabricTableHolder.Init());
-    NL_TEST_ASSERT(inSuite,
-                   CHIP_NO_ERROR ==
-                       sessionManager.Init(&ctx.GetSystemLayer(), &ctx.GetTransportMgr(), &messageCounterManager, &deviceStorage,
-                                           &fabricTableHolder.GetFabricTable(), sessionKeystore));
+    EXPECT_EQ(CHIP_NO_ERROR, fabricTableHolder.Init());
+    EXPECT_EQ(CHIP_NO_ERROR,
+              sessionManager.Init(&mContext.GetSystemLayer(), &mContext.GetTransportMgr(), &messageCounterManager, &deviceStorage,
+                                  &fabricTableHolder.GetFabricTable(), sessionKeystore));
 
     Transport::PeerAddress peer(Transport::PeerAddress::UDP(addr, CHIP_PORT));
 
     SessionHolder aliceToBobSession;
     CHIP_ERROR err = sessionManager.InjectCaseSessionWithTestKey(aliceToBobSession, 2, 1, aliceNodeId, bobNodeId, aliceFabricIndex,
                                                                  peer, CryptoContext::SessionRole::kInitiator);
-    NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
+    EXPECT_EQ(err, CHIP_NO_ERROR);
     aliceToBobSession->AsSecureSession()->MarkActive();
 
     SessionHolder newAliceToBobSession;
     err = sessionManager.InjectCaseSessionWithTestKey(newAliceToBobSession, 3, 4, aliceNodeId, bobNodeId, aliceFabricIndex, peer,
                                                       CryptoContext::SessionRole::kInitiator);
-    NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
+    EXPECT_EQ(err, CHIP_NO_ERROR);
 
     while (System::SystemClock().GetMonotonicTimestamp() <= aliceToBobSession->AsSecureSession()->GetLastActivityTime())
     {
@@ -1045,75 +1007,11 @@
 
     auto foundSession = sessionManager.FindSecureSessionForNode(ScopedNodeId(bobNodeId, aliceFabricIndex),
                                                                 MakeOptional(SecureSession::Type::kCASE));
-    NL_TEST_ASSERT(inSuite, foundSession.HasValue());
-    NL_TEST_ASSERT(inSuite, newAliceToBobSession.Contains(foundSession.Value()));
-    NL_TEST_ASSERT(inSuite, !aliceToBobSession.Contains(foundSession.Value()));
+    EXPECT_TRUE(foundSession.HasValue());
+    EXPECT_TRUE(newAliceToBobSession.Contains(foundSession.Value()));
+    EXPECT_FALSE(aliceToBobSession.Contains(foundSession.Value()));
 
     sessionManager.Shutdown();
 }
 
-// Test Suite
-
-/**
- *  Test Suite that lists all the test functions.
- */
-// clang-format off
-const nlTest sTests[] =
-{
-    NL_TEST_DEF("Simple Init Test",               CheckSimpleInitTest),
-    NL_TEST_DEF("Message Self Test",              CheckMessageTest),
-    NL_TEST_DEF("Send Encrypted Packet Test",     SendEncryptedPacketTest),
-    NL_TEST_DEF("Send Bad Encrypted Packet Test", SendBadEncryptedPacketTest),
-    NL_TEST_DEF("Old counter Test",               SendPacketWithOldCounterTest),
-    NL_TEST_DEF("Too-old counter Test",           SendPacketWithTooOldCounterTest),
-    NL_TEST_DEF("Session Allocation Test",        SessionAllocationTest),
-    NL_TEST_DEF("Session Counter Exhausted Test", SessionCounterExhaustedTest),
-    NL_TEST_DEF("SessionShiftingTest",            SessionShiftingTest),
-    NL_TEST_DEF("TestFindSecureSessionForNode",   TestFindSecureSessionForNode),
-
-    NL_TEST_SENTINEL()
-};
-// clang-format on
-
-int Initialize(void * aContext);
-int Finalize(void * aContext);
-
-// clang-format off
-nlTestSuite sSuite =
-{
-    "Test-CHIP-SessionManager",
-    &sTests[0],
-    Initialize,
-    Finalize
-};
-// clang-format on
-
-/**
- *  Initialize the test suite.
- */
-int Initialize(void * aContext)
-{
-    CHIP_ERROR err = reinterpret_cast<TestContext *>(aContext)->Init();
-    return (err == CHIP_NO_ERROR) ? SUCCESS : FAILURE;
-}
-
-/**
- *  Finalize the test suite.
- */
-int Finalize(void * aContext)
-{
-    reinterpret_cast<TestContext *>(aContext)->Shutdown();
-    return SUCCESS;
-}
-
 } // namespace
-
-/**
- *  Main
- */
-int TestSessionManager()
-{
-    return chip::ExecuteTestsWithContext<TestContext>(&sSuite);
-}
-
-CHIP_REGISTER_TEST_SUITE(TestSessionManager);
diff --git a/src/transport/tests/TestSessionManagerDispatch.cpp b/src/transport/tests/TestSessionManagerDispatch.cpp
index 9d351ab..f90cb0f 100644
--- a/src/transport/tests/TestSessionManagerDispatch.cpp
+++ b/src/transport/tests/TestSessionManagerDispatch.cpp
@@ -31,15 +31,12 @@
 #include <lib/core/CHIPCore.h>
 #include <lib/support/CodeUtils.h>
 #include <lib/support/TestPersistentStorageDelegate.h>
-#include <lib/support/UnitTestContext.h>
-#include <lib/support/UnitTestRegistration.h>
 #include <protocols/secure_channel/MessageCounterManager.h>
 #include <transport/SessionManager.h>
 #include <transport/TransportMgr.h>
 #include <transport/tests/LoopbackTransportManager.h>
 
-#include <nlbyteorder.h>
-#include <nlunit-test.h>
+#include <gtest/gtest.h>
 
 #include <errno.h>
 
@@ -472,13 +469,13 @@
         MessageTestEntry & testEntry = theMessageTestVector[mTestVectorIndex];
 
         ChipLogProgress(Test, "OnMessageReceived: sessionId=0x%04x", testEntry.sessionId);
-        NL_TEST_ASSERT(mSuite, header.GetSessionId() == testEntry.sessionId);
+        EXPECT_EQ(header.GetSessionId(), testEntry.sessionId);
 
         size_t dataLength   = msgBuf->DataLength();
         size_t expectLength = testEntry.payloadLength;
 
-        NL_TEST_ASSERT(mSuite, dataLength == expectLength);
-        NL_TEST_ASSERT(mSuite, memcmp(msgBuf->Start(), testEntry.payload, dataLength) == 0);
+        EXPECT_EQ(dataLength, expectLength);
+        EXPECT_EQ(memcmp(msgBuf->Start(), testEntry.payload, dataLength), 0);
 
         ChipLogProgress(Test, "::: TestSessionManagerDispatch[%d] PASS", mTestVectorIndex);
     }
@@ -491,7 +488,6 @@
 
     unsigned NumMessagesReceived() { return mReceivedCount; }
 
-    nlTestSuite * mSuite      = nullptr;
     unsigned mTestVectorIndex = 0;
     unsigned mReceivedCount   = 0;
 };
@@ -505,18 +501,17 @@
     return PeerAddress::UDP(addr);
 }
 
-void TestSessionManagerInit(nlTestSuite * inSuite, TestContext & ctx, SessionManager & sessionManager)
+void TestSessionManagerInit(TestContext & ctx, SessionManager & sessionManager)
 {
     static FabricTableHolder fabricTableHolder;
     static secure_channel::MessageCounterManager gMessageCounterManager;
     static chip::TestPersistentStorageDelegate deviceStorage;
     static chip::Crypto::DefaultSessionKeystore sessionKeystore;
 
-    NL_TEST_ASSERT(inSuite, CHIP_NO_ERROR == fabricTableHolder.Init());
-    NL_TEST_ASSERT(inSuite,
-                   CHIP_NO_ERROR ==
-                       sessionManager.Init(&ctx.GetSystemLayer(), &ctx.GetTransportMgr(), &gMessageCounterManager, &deviceStorage,
-                                           &fabricTableHolder.GetFabricTable(), sessionKeystore));
+    EXPECT_EQ(CHIP_NO_ERROR, fabricTableHolder.Init());
+    EXPECT_EQ(CHIP_NO_ERROR,
+              sessionManager.Init(&ctx.GetSystemLayer(), &ctx.GetTransportMgr(), &gMessageCounterManager, &deviceStorage,
+                                  &fabricTableHolder.GetFabricTable(), sessionKeystore));
 }
 
 // constexpr chip::FabricId kFabricId1               = 0x2906C908D115D362;
@@ -552,15 +547,23 @@
     return CHIP_NO_ERROR;
 }
 
-void TestSessionManagerDispatch(nlTestSuite * inSuite, void * inContext)
+class TestSessionManagerDispatch : public ::testing::Test
+{
+protected:
+    void SetUp() { ASSERT_EQ(mContext.Init(), CHIP_NO_ERROR); }
+    void TearDown() { mContext.Shutdown(); }
+
+    TestContext mContext;
+};
+
+TEST_F(TestSessionManagerDispatch, TestSessionManagerDispatch)
 {
     CHIP_ERROR err = CHIP_NO_ERROR;
 
-    TestContext & ctx = *reinterpret_cast<TestContext *>(inContext);
     SessionManager sessionManager;
     TestSessionManagerCallback callback;
 
-    TestSessionManagerInit(inSuite, ctx, sessionManager);
+    TestSessionManagerInit(mContext, sessionManager);
     sessionManager.SetMessageDelegate(&callback);
 
     IPAddress addr;
@@ -570,7 +573,6 @@
     SessionHolder aliceToBobSession;
     SessionHolder testGroupSession;
 
-    callback.mSuite = inSuite;
     for (unsigned i = 0; i < theMessageTestVectorLength; i++)
     {
         MessageTestEntry & testEntry = theMessageTestVector[i];
@@ -585,10 +587,10 @@
         err = sessionManager.InjectPaseSessionWithTestKey(aliceToBobSession, testEntry.sessionId, testEntry.peerNodeId,
                                                           testEntry.sessionId, kFabricIndex, peer,
                                                           CryptoContext::SessionRole::kResponder);
-        NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
+        EXPECT_EQ(err, CHIP_NO_ERROR);
 
         err = InjectGroupSessionWithTestKey(testGroupSession, testEntry);
-        NL_TEST_ASSERT(inSuite, CHIP_NO_ERROR == err);
+        EXPECT_EQ(CHIP_NO_ERROR, err);
 
         const char * plain = testEntry.plain;
         const ByteSpan expectedPlain(reinterpret_cast<const uint8_t *>(plain), testEntry.plainLength);
@@ -598,7 +600,7 @@
 
         const PeerAddress peerAddress = AddressFromString(testEntry.peerAddr);
         sessionManager.OnMessageReceived(peerAddress, std::move(msg));
-        NL_TEST_ASSERT(inSuite, callback.NumMessagesReceived() == testEntry.expectedMessageCount);
+        EXPECT_EQ(callback.NumMessagesReceived(), testEntry.expectedMessageCount);
 
         if ((testEntry.expectedMessageCount == 0) && (callback.NumMessagesReceived() == 0))
         {
@@ -609,56 +611,4 @@
     sessionManager.Shutdown();
 }
 
-// ============================================================================
-//              Test Suite Instrumenation
-// ============================================================================
-
-/**
- *  Initialize the test suite.
- */
-int Initialize(void * aContext)
-{
-    CHIP_ERROR err = reinterpret_cast<TestContext *>(aContext)->Init();
-    return (err == CHIP_NO_ERROR) ? SUCCESS : FAILURE;
-}
-
-/**
- *  Finalize the test suite.
- */
-int Finalize(void * aContext)
-{
-    reinterpret_cast<TestContext *>(aContext)->Shutdown();
-    return SUCCESS;
-}
-
-/**
- *  Test Suite that lists all the test functions.
- */
-// clang-format off
-const nlTest sTests[] =
-{
-    NL_TEST_DEF("Test Session Manager Dispatch",  TestSessionManagerDispatch),
-
-    NL_TEST_SENTINEL()
-};
-
-nlTestSuite sSuite =
-{
-    "TestSessionManagerDispatch",
-    &sTests[0],
-    Initialize,
-    Finalize
-};
-// clang-format on
-
 } // namespace
-
-/**
- *  Main
- */
-int TestSessionManagerDispatchSuite()
-{
-    return chip::ExecuteTestsWithContext<TestContext>(&sSuite);
-}
-
-CHIP_REGISTER_TEST_SUITE(TestSessionManagerDispatchSuite);