diff --git a/src/inet/tests/BUILD.gn b/src/inet/tests/BUILD.gn
index 0eeec84..7b0e770 100644
--- a/src/inet/tests/BUILD.gn
+++ b/src/inet/tests/BUILD.gn
@@ -15,10 +15,12 @@
 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")
 import("${chip_root}/build/chip/tests.gni")
 import("${chip_root}/src/platform/device.gni")
+import("${chip_root}/src/system/system.gni")
 
 config("tests_config") {
   include_dirs = [ "." ]
@@ -60,7 +62,7 @@
   ]
 }
 
-chip_test_suite_using_nltest("tests") {
+chip_test_suite("tests") {
   output_name = "libInetLayerTests"
 
   public_configs = [ ":tests_config" ]
@@ -69,10 +71,7 @@
     ":helpers",
     "${chip_root}/src/inet",
     "${chip_root}/src/lib/core",
-    "${chip_root}/src/lib/support:testing_nlunit",
-    "${nlunit_test_root}:nlunit-test",
   ]
-
   test_sources = [
     "TestBasicPacketFilters.cpp",
     "TestInetAddress.cpp",
@@ -80,7 +79,7 @@
   ]
   sources = []
 
-  if (current_os != "zephyr") {
+  if (chip_system_config_use_sockets && current_os != "zephyr") {
     test_sources += [ "TestInetEndPoint.cpp" ]
   }
 
diff --git a/src/inet/tests/TestBasicPacketFilters.cpp b/src/inet/tests/TestBasicPacketFilters.cpp
index ef07cab..162fe52 100644
--- a/src/inet/tests/TestBasicPacketFilters.cpp
+++ b/src/inet/tests/TestBasicPacketFilters.cpp
@@ -18,23 +18,29 @@
 #include <stdio.h>
 #include <string.h>
 
+#include <gtest/gtest.h>
+
 #include <inet/BasicPacketFilters.h>
 #include <inet/IPPacketInfo.h>
 #include <inet/InetInterface.h>
 #include <lib/support/CHIPMem.h>
 #include <lib/support/CodeUtils.h>
 #include <lib/support/Span.h>
-#include <lib/support/UnitTestRegistration.h>
 #include <lib/support/logging/CHIPLogging.h>
 #include <system/SystemPacketBuffer.h>
 
-#include <nlunit-test.h>
-
 namespace {
 
 using namespace chip;
 using namespace chip::Inet;
 
+class TestBasicPacketFilters : public ::testing::Test
+{
+public:
+    static void SetUpTestSuite() { ASSERT_EQ(chip::Platform::MemoryInit(), CHIP_NO_ERROR); }
+    static void TearDownTestSuite() { chip::Platform::MemoryShutdown(); }
+};
+
 class DropIfTooManyQueuedPacketsHarness : public DropIfTooManyQueuedPacketsFilter
 {
 public:
@@ -67,7 +73,6 @@
     }
 
     // Public bits to make testing easier
-    nlTestSuite * mTestSuite          = nullptr;
     int mNumOnDroppedCalled           = 0;
     int mNumOnLastMatchDequeuedCalled = 0;
     bool mHitCeilingWantFloor;
@@ -118,23 +123,19 @@
 DropIfTooManyQueuedPacketsHarness gFilter(0);
 int gFakeEndpointForPointer = 0;
 
-void TestBasicPacketFilter(nlTestSuite * inSuite, void * inContext)
+TEST_F(TestBasicPacketFilters, TestBasicPacketFilter)
 {
     constexpr uint16_t kMdnsPort = 5353u;
 
-    gFilter.mTestSuite = inSuite;
-
     // Predicate for test is filter that destination port is 5353 (mDNS).
     // NOTE: A non-capturing lambda is used, but a plain function could have been used as well...
     auto predicate = [](void * context, const void * endpoint, const chip::Inet::IPPacketInfo & pktInfo,
                         const chip::System::PacketBufferHandle & pktPayload) -> bool {
-        auto filter           = reinterpret_cast<DropIfTooManyQueuedPacketsHarness *>(context);
-        auto testSuite        = filter->mTestSuite;
         auto expectedEndpoint = &gFakeEndpointForPointer;
 
         // Ensure we get called with context and expected endpoint pointer
-        NL_TEST_ASSERT(testSuite, context == &gFilter);
-        NL_TEST_ASSERT(testSuite, endpoint == expectedEndpoint);
+        EXPECT_EQ(context, &gFilter);
+        EXPECT_EQ(endpoint, expectedEndpoint);
 
         // Predicate filters destination port being 5353
         return (pktInfo.DestPort == kMdnsPort);
@@ -150,9 +151,9 @@
     const uint8_t kFakePayloadData[] = { 1, 2, 3 };
     const ByteSpan kFakePayload{ kFakePayloadData };
 
-    NL_TEST_ASSERT(inSuite, IPAddress::FromString("fe80::aaaa:bbbb:cccc:dddd", fakeSrc));
-    NL_TEST_ASSERT(inSuite, IPAddress::FromString("fe80::0000:1111:2222:3333", fakeDest));
-    NL_TEST_ASSERT(inSuite, IPAddress::FromString("ff02::fb", fakeMdnsDest));
+    EXPECT_TRUE(IPAddress::FromString("fe80::aaaa:bbbb:cccc:dddd", fakeSrc));
+    EXPECT_TRUE(IPAddress::FromString("fe80::0000:1111:2222:3333", fakeDest));
+    EXPECT_TRUE(IPAddress::FromString("ff02::fb", fakeMdnsDest));
 
     // Shorthands for simplifying asserts
     constexpr EndpointQueueFilter::FilterOutcome kAllowPacket = EndpointQueueFilter::FilterOutcome::kAllowPacket;
@@ -165,131 +166,116 @@
         // Enqueue some packets that don't match filter, all allowed, never hit the drop
         for (int numPkt = 0; numPkt < (kMaxQueuedPacketsLimit + 1); ++numPkt)
         {
-            NL_TEST_ASSERT(inSuite,
-                           kAllowPacket == fakeUdpEndpoint.ProcessEnqueue(fakeSrc, kOtherPort, fakeDest, kOtherPort, kFakePayload));
+            EXPECT_EQ(kAllowPacket, fakeUdpEndpoint.ProcessEnqueue(fakeSrc, kOtherPort, fakeDest, kOtherPort, kFakePayload));
         }
-        NL_TEST_ASSERT(inSuite, gFilter.GetNumDroppedPackets() == 0);
+        EXPECT_EQ(gFilter.GetNumDroppedPackets(), 0u);
 
         // Dequeue all packets
         for (int numPkt = 0; numPkt < (kMaxQueuedPacketsLimit + 1); ++numPkt)
         {
-            NL_TEST_ASSERT(inSuite,
-                           kAllowPacket == fakeUdpEndpoint.ProcessDequeue(fakeSrc, kOtherPort, fakeDest, kOtherPort, kFakePayload));
+            EXPECT_EQ(kAllowPacket, fakeUdpEndpoint.ProcessDequeue(fakeSrc, kOtherPort, fakeDest, kOtherPort, kFakePayload));
         }
-        NL_TEST_ASSERT(inSuite, gFilter.GetNumDroppedPackets() == 0);
+        EXPECT_EQ(gFilter.GetNumDroppedPackets(), 0u);
 
         // OnDroped/OnLastMatchDequeued only ever called for matching packets, never for non-matching
-        NL_TEST_ASSERT(inSuite, gFilter.mNumOnDroppedCalled == 0);
-        NL_TEST_ASSERT(inSuite, gFilter.mNumOnLastMatchDequeuedCalled == 0);
+        EXPECT_EQ(gFilter.mNumOnDroppedCalled, 0);
+        EXPECT_EQ(gFilter.mNumOnLastMatchDequeuedCalled, 0);
     }
 
     {
         // Enqueue packets that match filter, up to watermark. None dropped
         for (int numPkt = 0; numPkt < kMaxQueuedPacketsLimit; ++numPkt)
         {
-            NL_TEST_ASSERT(inSuite,
-                           kAllowPacket ==
-                               fakeUdpEndpoint.ProcessEnqueue(fakeSrc, kOtherPort, fakeMdnsDest, kMdnsPort, kFakePayload));
+            EXPECT_EQ(kAllowPacket, fakeUdpEndpoint.ProcessEnqueue(fakeSrc, kOtherPort, fakeMdnsDest, kMdnsPort, kFakePayload));
         }
-        NL_TEST_ASSERT(inSuite, gFilter.GetNumDroppedPackets() == 0);
-        NL_TEST_ASSERT(inSuite, gFilter.mNumOnDroppedCalled == 0);
-        NL_TEST_ASSERT(inSuite, gFilter.mNumOnLastMatchDequeuedCalled == 0);
+        EXPECT_EQ(gFilter.GetNumDroppedPackets(), 0u);
+        EXPECT_EQ(gFilter.mNumOnDroppedCalled, 0);
+        EXPECT_EQ(gFilter.mNumOnLastMatchDequeuedCalled, 0);
 
         // Enqueue packets that match filter, beyond watermark: all dropped.
         for (int numPkt = 0; numPkt < 2; ++numPkt)
         {
-            NL_TEST_ASSERT(
-                inSuite, kDropPacket == fakeUdpEndpoint.ProcessEnqueue(fakeSrc, kOtherPort, fakeMdnsDest, kMdnsPort, kFakePayload));
+            EXPECT_EQ(kDropPacket, fakeUdpEndpoint.ProcessEnqueue(fakeSrc, kOtherPort, fakeMdnsDest, kMdnsPort, kFakePayload));
         }
-        NL_TEST_ASSERT(inSuite, gFilter.GetNumDroppedPackets() == 2);
-        NL_TEST_ASSERT(inSuite, gFilter.mNumOnDroppedCalled == 2);
-        NL_TEST_ASSERT(inSuite, gFilter.mNumOnLastMatchDequeuedCalled == 0);
+        EXPECT_EQ(gFilter.GetNumDroppedPackets(), 2u);
+        EXPECT_EQ(gFilter.mNumOnDroppedCalled, 2);
+        EXPECT_EQ(gFilter.mNumOnLastMatchDequeuedCalled, 0);
 
         // Dequeue 2 packets that were enqueued, matching filter
         for (int numPkt = 0; numPkt < 2; ++numPkt)
         {
-            NL_TEST_ASSERT(inSuite,
-                           kAllowPacket ==
-                               fakeUdpEndpoint.ProcessDequeue(fakeSrc, kOtherPort, fakeMdnsDest, kMdnsPort, kFakePayload));
+            EXPECT_EQ(kAllowPacket, fakeUdpEndpoint.ProcessDequeue(fakeSrc, kOtherPort, fakeMdnsDest, kMdnsPort, kFakePayload));
         }
         // Number of dropped packets didn't change
-        NL_TEST_ASSERT(inSuite, gFilter.GetNumDroppedPackets() == 2);
-        NL_TEST_ASSERT(inSuite, gFilter.mNumOnDroppedCalled == 2);
-        NL_TEST_ASSERT(inSuite, gFilter.mNumOnLastMatchDequeuedCalled == 0);
+        EXPECT_EQ(gFilter.GetNumDroppedPackets(), 2u);
+        EXPECT_EQ(gFilter.mNumOnDroppedCalled, 2);
+        EXPECT_EQ(gFilter.mNumOnLastMatchDequeuedCalled, 0);
 
         // Enqueue packets that match filter, up to watermark again. None dropped.
         for (int numPkt = 0; numPkt < 2; ++numPkt)
         {
-            NL_TEST_ASSERT(inSuite,
-                           kAllowPacket ==
-                               fakeUdpEndpoint.ProcessEnqueue(fakeSrc, kOtherPort, fakeMdnsDest, kMdnsPort, kFakePayload));
+            EXPECT_EQ(kAllowPacket, fakeUdpEndpoint.ProcessEnqueue(fakeSrc, kOtherPort, fakeMdnsDest, kMdnsPort, kFakePayload));
         }
 
         // No change from prior state
-        NL_TEST_ASSERT(inSuite, gFilter.GetNumDroppedPackets() == 2);
-        NL_TEST_ASSERT(inSuite, gFilter.mNumOnDroppedCalled == 2);
-        NL_TEST_ASSERT(inSuite, gFilter.mNumOnLastMatchDequeuedCalled == 0);
+        EXPECT_EQ(gFilter.GetNumDroppedPackets(), 2u);
+        EXPECT_EQ(gFilter.mNumOnDroppedCalled, 2);
+        EXPECT_EQ(gFilter.mNumOnLastMatchDequeuedCalled, 0);
 
         // Enqueue two more packets, expect drop
         for (int numPkt = 0; numPkt < 2; ++numPkt)
         {
-            NL_TEST_ASSERT(
-                inSuite, kDropPacket == fakeUdpEndpoint.ProcessEnqueue(fakeSrc, kOtherPort, fakeMdnsDest, kMdnsPort, kFakePayload));
+            EXPECT_EQ(kDropPacket, fakeUdpEndpoint.ProcessEnqueue(fakeSrc, kOtherPort, fakeMdnsDest, kMdnsPort, kFakePayload));
         }
 
         // Expect two more dropped total
-        NL_TEST_ASSERT(inSuite, gFilter.GetNumDroppedPackets() == 4);
-        NL_TEST_ASSERT(inSuite, gFilter.mNumOnDroppedCalled == 4);
-        NL_TEST_ASSERT(inSuite, gFilter.mNumOnLastMatchDequeuedCalled == 0);
+        EXPECT_EQ(gFilter.GetNumDroppedPackets(), 4u);
+        EXPECT_EQ(gFilter.mNumOnDroppedCalled, 4);
+        EXPECT_EQ(gFilter.mNumOnLastMatchDequeuedCalled, 0);
 
         // Enqueue non-matching packet, expect allowed.
         for (int numPkt = 0; numPkt < kMaxQueuedPacketsLimit; ++numPkt)
         {
-            NL_TEST_ASSERT(inSuite,
-                           kAllowPacket == fakeUdpEndpoint.ProcessEnqueue(fakeSrc, kOtherPort, fakeDest, kOtherPort, kFakePayload));
+            EXPECT_EQ(kAllowPacket, fakeUdpEndpoint.ProcessEnqueue(fakeSrc, kOtherPort, fakeDest, kOtherPort, kFakePayload));
         }
 
         // Expect no more dropepd
-        NL_TEST_ASSERT(inSuite, gFilter.GetNumDroppedPackets() == 4);
-        NL_TEST_ASSERT(inSuite, gFilter.mNumOnDroppedCalled == 4);
-        NL_TEST_ASSERT(inSuite, gFilter.mNumOnLastMatchDequeuedCalled == 0);
+        EXPECT_EQ(gFilter.GetNumDroppedPackets(), 4u);
+        EXPECT_EQ(gFilter.mNumOnDroppedCalled, 4);
+        EXPECT_EQ(gFilter.mNumOnLastMatchDequeuedCalled, 0);
 
         // Dequeue non-matching packet, expect allowed.
         for (int numPkt = 0; numPkt < kMaxQueuedPacketsLimit; ++numPkt)
         {
-            NL_TEST_ASSERT(inSuite,
-                           kAllowPacket == fakeUdpEndpoint.ProcessDequeue(fakeSrc, kOtherPort, fakeDest, kOtherPort, kFakePayload));
+            EXPECT_EQ(kAllowPacket, fakeUdpEndpoint.ProcessDequeue(fakeSrc, kOtherPort, fakeDest, kOtherPort, kFakePayload));
         }
 
         // Expect no change
-        NL_TEST_ASSERT(inSuite, gFilter.GetNumDroppedPackets() == 4);
-        NL_TEST_ASSERT(inSuite, gFilter.mNumOnDroppedCalled == 4);
-        NL_TEST_ASSERT(inSuite, gFilter.mNumOnLastMatchDequeuedCalled == 0);
+        EXPECT_EQ(gFilter.GetNumDroppedPackets(), 4u);
+        EXPECT_EQ(gFilter.mNumOnDroppedCalled, 4);
+        EXPECT_EQ(gFilter.mNumOnLastMatchDequeuedCalled, 0);
 
         // Dequeue all matching packets, expect allowed and one OnLastMatchDequeued on last one.
         for (int numPkt = 0; numPkt < (kMaxQueuedPacketsLimit - 1); ++numPkt)
         {
-            NL_TEST_ASSERT(inSuite,
-                           kAllowPacket ==
-                               fakeUdpEndpoint.ProcessDequeue(fakeSrc, kOtherPort, fakeMdnsDest, kMdnsPort, kFakePayload));
+            EXPECT_EQ(kAllowPacket, fakeUdpEndpoint.ProcessDequeue(fakeSrc, kOtherPort, fakeMdnsDest, kMdnsPort, kFakePayload));
         }
 
-        NL_TEST_ASSERT(inSuite, gFilter.GetNumDroppedPackets() == 4);
-        NL_TEST_ASSERT(inSuite, gFilter.mNumOnDroppedCalled == 4);
-        NL_TEST_ASSERT(inSuite, gFilter.mNumOnLastMatchDequeuedCalled == 0);
+        EXPECT_EQ(gFilter.GetNumDroppedPackets(), 4u);
+        EXPECT_EQ(gFilter.mNumOnDroppedCalled, 4);
+        EXPECT_EQ(gFilter.mNumOnLastMatchDequeuedCalled, 0);
 
-        NL_TEST_ASSERT(inSuite,
-                       kAllowPacket == fakeUdpEndpoint.ProcessDequeue(fakeSrc, kOtherPort, fakeMdnsDest, kMdnsPort, kFakePayload));
+        EXPECT_EQ(kAllowPacket, fakeUdpEndpoint.ProcessDequeue(fakeSrc, kOtherPort, fakeMdnsDest, kMdnsPort, kFakePayload));
 
-        NL_TEST_ASSERT(inSuite, gFilter.GetNumDroppedPackets() == 4);
-        NL_TEST_ASSERT(inSuite, gFilter.mNumOnDroppedCalled == 4);
-        NL_TEST_ASSERT(inSuite, gFilter.mNumOnLastMatchDequeuedCalled == 1);
+        EXPECT_EQ(gFilter.GetNumDroppedPackets(), 4u);
+        EXPECT_EQ(gFilter.mNumOnDroppedCalled, 4);
+        EXPECT_EQ(gFilter.mNumOnLastMatchDequeuedCalled, 1);
     }
 
     // Validate that clearing drop count works
     {
         gFilter.ClearNumDroppedPackets();
-        NL_TEST_ASSERT(inSuite, gFilter.GetNumDroppedPackets() == 0);
+        EXPECT_EQ(gFilter.GetNumDroppedPackets(), 0u);
 
         gFilter.mNumOnDroppedCalled           = 0;
         gFilter.mNumOnLastMatchDequeuedCalled = 0;
@@ -302,13 +288,11 @@
         // Enqueue packets up to twice the watermark. None dropped.
         for (int numPkt = 0; numPkt < (2 * kMaxQueuedPacketsLimit); ++numPkt)
         {
-            NL_TEST_ASSERT(inSuite,
-                           kAllowPacket ==
-                               fakeUdpEndpoint.ProcessEnqueue(fakeSrc, kOtherPort, fakeMdnsDest, kMdnsPort, kFakePayload));
+            EXPECT_EQ(kAllowPacket, fakeUdpEndpoint.ProcessEnqueue(fakeSrc, kOtherPort, fakeMdnsDest, kMdnsPort, kFakePayload));
         }
-        NL_TEST_ASSERT(inSuite, gFilter.GetNumDroppedPackets() == 0);
-        NL_TEST_ASSERT(inSuite, gFilter.mNumOnDroppedCalled == 0);
-        NL_TEST_ASSERT(inSuite, gFilter.mNumOnLastMatchDequeuedCalled == 0);
+        EXPECT_EQ(gFilter.GetNumDroppedPackets(), 0u);
+        EXPECT_EQ(gFilter.mNumOnDroppedCalled, 0);
+        EXPECT_EQ(gFilter.mNumOnLastMatchDequeuedCalled, 0);
 
         // Works even if max number of packets allowed is zero
         gFilter.SetMaxQueuedPacketsLimit(0);
@@ -316,13 +300,11 @@
         // Enqueue packets up to twice the watermark. None dropped.
         for (int numPkt = 0; numPkt < (2 * kMaxQueuedPacketsLimit); ++numPkt)
         {
-            NL_TEST_ASSERT(inSuite,
-                           kAllowPacket ==
-                               fakeUdpEndpoint.ProcessEnqueue(fakeSrc, kOtherPort, fakeMdnsDest, kMdnsPort, kFakePayload));
+            EXPECT_EQ(kAllowPacket, fakeUdpEndpoint.ProcessEnqueue(fakeSrc, kOtherPort, fakeMdnsDest, kMdnsPort, kFakePayload));
         }
-        NL_TEST_ASSERT(inSuite, gFilter.GetNumDroppedPackets() == 0);
-        NL_TEST_ASSERT(inSuite, gFilter.mNumOnDroppedCalled == 0);
-        NL_TEST_ASSERT(inSuite, gFilter.mNumOnLastMatchDequeuedCalled == 0);
+        EXPECT_EQ(gFilter.GetNumDroppedPackets(), 0u);
+        EXPECT_EQ(gFilter.mNumOnDroppedCalled, 0);
+        EXPECT_EQ(gFilter.mNumOnLastMatchDequeuedCalled, 0);
     }
 
     // Validate that setting max packets to zero, with a matching predicate, drops all matching packets, none of the non-matching.
@@ -333,53 +315,23 @@
         // Enqueue packets that match filter, up to watermark. All dropped
         for (int numPkt = 0; numPkt < kMaxQueuedPacketsLimit; ++numPkt)
         {
-            NL_TEST_ASSERT(
-                inSuite, kDropPacket == fakeUdpEndpoint.ProcessEnqueue(fakeSrc, kOtherPort, fakeMdnsDest, kMdnsPort, kFakePayload));
+            EXPECT_EQ(kDropPacket, fakeUdpEndpoint.ProcessEnqueue(fakeSrc, kOtherPort, fakeMdnsDest, kMdnsPort, kFakePayload));
         }
 
-        NL_TEST_ASSERT(inSuite, gFilter.GetNumDroppedPackets() == 3);
-        NL_TEST_ASSERT(inSuite, gFilter.mNumOnDroppedCalled == 3);
-        NL_TEST_ASSERT(inSuite, gFilter.mNumOnLastMatchDequeuedCalled == 0);
+        EXPECT_EQ(gFilter.GetNumDroppedPackets(), 3u);
+        EXPECT_EQ(gFilter.mNumOnDroppedCalled, 3);
+        EXPECT_EQ(gFilter.mNumOnLastMatchDequeuedCalled, 0);
 
         // Enqueue non-filter-matching, none dropped
         for (int numPkt = 0; numPkt < kMaxQueuedPacketsLimit; ++numPkt)
         {
-            NL_TEST_ASSERT(inSuite,
-                           kAllowPacket == fakeUdpEndpoint.ProcessDequeue(fakeSrc, kOtherPort, fakeDest, kOtherPort, kFakePayload));
+            EXPECT_EQ(kAllowPacket, fakeUdpEndpoint.ProcessDequeue(fakeSrc, kOtherPort, fakeDest, kOtherPort, kFakePayload));
         }
 
-        NL_TEST_ASSERT(inSuite, gFilter.GetNumDroppedPackets() == 3);
-        NL_TEST_ASSERT(inSuite, gFilter.mNumOnDroppedCalled == 3);
-        NL_TEST_ASSERT(inSuite, gFilter.mNumOnLastMatchDequeuedCalled == 0);
+        EXPECT_EQ(gFilter.GetNumDroppedPackets(), 3u);
+        EXPECT_EQ(gFilter.mNumOnDroppedCalled, 3);
+        EXPECT_EQ(gFilter.mNumOnLastMatchDequeuedCalled, 0);
     }
 }
 
-const nlTest sTests[] = {
-    NL_TEST_DEF("TestBasicPacketFilter", TestBasicPacketFilter), //
-    NL_TEST_SENTINEL()                                           //
-};
-
-int TestSuiteSetup(void * inContext)
-{
-    CHIP_ERROR error = chip::Platform::MemoryInit();
-    if (error != CHIP_NO_ERROR)
-        return FAILURE;
-    return SUCCESS;
-}
-
-int TestSuiteTeardown(void * inContext)
-{
-    chip::Platform::MemoryShutdown();
-    return SUCCESS;
-}
-
 } // namespace
-
-int TestBasicPacketFilters()
-{
-    nlTestSuite theSuite = { "TestBasicPacketFilters", sTests, &TestSuiteSetup, &TestSuiteTeardown };
-    nlTestRunner(&theSuite, nullptr);
-    return nlTestRunnerStats(&theSuite);
-}
-
-CHIP_REGISTER_TEST_SUITE(TestBasicPacketFilters)
diff --git a/src/inet/tests/TestInetAddress.cpp b/src/inet/tests/TestInetAddress.cpp
index 426d6b7..1b7e7bd 100644
--- a/src/inet/tests/TestInetAddress.cpp
+++ b/src/inet/tests/TestInetAddress.cpp
@@ -23,18 +23,19 @@
  *    a class to store and format IPV4 and IPV6 Internet Protocol addresses.
  *
  */
-#include <lib/core/CHIPConfig.h>
-
-#include <inet/IPAddress.h>
 
 #include <string.h>
 
+#include <gtest/gtest.h>
+
+#include <inet/IPAddress.h>
+#include <lib/core/CHIPConfig.h>
+
 #if CHIP_SYSTEM_CONFIG_USE_LWIP
+#include <inet/arpa-inet-compatibility.h>
 #include <lwip/init.h>
 #include <lwip/ip_addr.h>
 
-#include <inet/arpa-inet-compatibility.h>
-
 #elif CHIP_SYSTEM_CONFIG_USE_OPEN_THREAD_ENDPOINT
 #include <inet/arpa-inet-compatibility.h>
 #include <openthread/icmp6.h>
@@ -45,13 +46,9 @@
 #include <sys/socket.h>
 #endif
 
-#include <nlunit-test.h>
-
 #include <inet/IPPrefix.h>
 #include <inet/InetError.h>
-
 #include <lib/support/CodeUtils.h>
-#include <lib/support/UnitTestRegistration.h>
 
 using namespace chip;
 using namespace chip::Inet;
@@ -149,6 +146,12 @@
     const IPAddressContextRange mIPv6TransientMulticastContextRange;
     const IPAddressContextRange mIPv6PrefixMulticastContextRange;
     const IPAddressExpandedContextRange mIPAddressExpandedContextRange;
+
+    TestContext(const IPAddressContextRange IPv6WellKnown, const IPAddressContextRange IPv6Transient,
+                const IPAddressContextRange IPv6Prefix, const IPAddressExpandedContextRange IPv6AddressExpanded) :
+        mIPv6WellKnownMulticastContextRange(IPv6WellKnown),
+        mIPv6TransientMulticastContextRange(IPv6Transient), mIPv6PrefixMulticastContextRange(IPv6Prefix),
+        mIPAddressExpandedContextRange(IPv6AddressExpanded){};
 };
 
 // Global Variables
@@ -623,26 +626,32 @@
 const size_t kIPv6PrefixMulticastTestElements    = sizeof(sIPv6PrefixMulticastContext) / sizeof(struct IPAddressContext);
 const size_t kIPAddressTestElements              = sizeof(sIPAddressContext) / sizeof(struct IPAddressExpandedContext);
 
-// clang-format off
-const TestContext sTestContext = {
+const struct TestContext * pTestContext = nullptr;
+
+class TestInetAddress : public ::testing::Test
+{
+public:
+    static void SetUpTestSuite()
     {
-        &sIPv6WellKnownMulticastContext[0],
-        &sIPv6WellKnownMulticastContext[kIPv6WellKnownMulticastTestElements]
-    },
+        if (pTestContext == nullptr)
+        {
+            pTestContext = new TestContext(
+                { &sIPv6WellKnownMulticastContext[0], &sIPv6WellKnownMulticastContext[kIPv6WellKnownMulticastTestElements] },
+                { &sIPv6TransientMulticastContext[0], &sIPv6TransientMulticastContext[kIPv6TransientMulticastTestElements] },
+                { &sIPv6PrefixMulticastContext[0], &sIPv6PrefixMulticastContext[kIPv6PrefixMulticastTestElements] },
+                { &sIPAddressContext[0], &sIPAddressContext[kIPAddressTestElements] });
+            ASSERT_NE(pTestContext, nullptr);
+        }
+    }
+    static void TearDownTestSuite()
     {
-        &sIPv6TransientMulticastContext[0],
-        &sIPv6TransientMulticastContext[kIPv6TransientMulticastTestElements]
-    },
-    {
-        &sIPv6PrefixMulticastContext[0],
-        &sIPv6PrefixMulticastContext[kIPv6PrefixMulticastTestElements]
-    },
-    {
-        &sIPAddressContext[0],
-        &sIPAddressContext[kIPAddressTestElements]
+        if (pTestContext != nullptr)
+        {
+            delete pTestContext;
+            pTestContext = nullptr;
+        }
     }
 };
-// clang-format on
 
 // Utility functions.
 
@@ -665,12 +674,11 @@
     addr = IPAddress::Any;
 }
 
-void CheckAddressQuartet(nlTestSuite * inSuite, const uint32_t & inFirstAddressQuartet, const uint32_t & inSecondAddressQuartet,
-                         const size_t & inWhich)
+void CheckAddressQuartet(const uint32_t & inFirstAddressQuartet, const uint32_t & inSecondAddressQuartet, const size_t & inWhich)
 {
     const bool lResult = (inFirstAddressQuartet == inSecondAddressQuartet);
 
-    NL_TEST_ASSERT(inSuite, lResult == true);
+    EXPECT_EQ(lResult, true);
 
     if (!lResult)
     {
@@ -679,33 +687,32 @@
     }
 }
 
-void CheckAddressQuartet(nlTestSuite * inSuite, const IPAddressContext & inContext, const IPAddress & inAddress,
-                         const size_t & inWhich)
+void CheckAddressQuartet(const IPAddressContext & inContext, const IPAddress & inAddress, const size_t & inWhich)
 {
-    CheckAddressQuartet(inSuite, inAddress.Addr[inWhich], htonl(inContext.mAddrQuartets[inWhich]), inWhich);
+    CheckAddressQuartet(inAddress.Addr[inWhich], htonl(inContext.mAddrQuartets[inWhich]), inWhich);
 }
 
-void CheckAddressQuartets(nlTestSuite * inSuite, const IPAddress & inFirstAddress, const IPAddress & inSecondAddress)
+void CheckAddressQuartets(const IPAddress & inFirstAddress, const IPAddress & inSecondAddress)
 {
     for (size_t i = 0; i < 4; i++)
     {
-        CheckAddressQuartet(inSuite, inFirstAddress.Addr[i], inSecondAddress.Addr[i], i);
+        CheckAddressQuartet(inFirstAddress.Addr[i], inSecondAddress.Addr[i], i);
     }
 }
 
-void CheckAddressQuartets(nlTestSuite * inSuite, const IPAddressContext & inContext, const IPAddress & inAddress)
+void CheckAddressQuartets(const IPAddressContext & inContext, const IPAddress & inAddress)
 {
     for (size_t i = 0; i < 4; i++)
     {
-        CheckAddressQuartet(inSuite, inContext, inAddress, i);
+        CheckAddressQuartet(inContext, inAddress, i);
     }
 }
 
-void CheckAddressString(nlTestSuite * inSuite, const char * inActual, const char * inExpected)
+void CheckAddressString(const char * inActual, const char * inExpected)
 {
     const int lResult = strcasecmp(inActual, inExpected);
 
-    NL_TEST_ASSERT(inSuite, lResult == 0);
+    EXPECT_FALSE(lResult);
 
     if (lResult != 0)
     {
@@ -713,7 +720,7 @@
     }
 }
 
-void CheckAddress(nlTestSuite * inSuite, const IPAddressContext & inContext, const IPAddress & inAddress)
+void CheckAddress(const IPAddressContext & inContext, const IPAddress & inAddress)
 {
     char lAddressBuffer[INET6_ADDRSTRLEN];
     IPAddress lParsedAddress;
@@ -721,12 +728,12 @@
 
     // Compare the address quartets to their control values.
 
-    CheckAddressQuartets(inSuite, inContext, inAddress);
+    CheckAddressQuartets(inContext, inAddress);
 
     // Convert the control string to an address and compare the parsed address to the created address.
 
     lResult = IPAddress::FromString(inContext.mAddrString, lParsedAddress);
-    NL_TEST_ASSERT(inSuite, lResult == true);
+    EXPECT_EQ(lResult, true);
 
     lResult = (inAddress == lParsedAddress);
 
@@ -745,9 +752,9 @@
     char uncompressedAddrStr[INET6_ADDRSTRLEN];
     // Reconvert the previously parsed control string to an uncompressed string format
     lParsedAddress.ToString(uncompressedAddrStr);
-    CheckAddressString(inSuite, lAddressBuffer, uncompressedAddrStr);
+    CheckAddressString(lAddressBuffer, uncompressedAddrStr);
 #else
-    CheckAddressString(inSuite, lAddressBuffer, inContext.mAddrString);
+    CheckAddressString(lAddressBuffer, inContext.mAddrString);
 #endif
 }
 
@@ -756,11 +763,10 @@
 /**
  *  Test IP address conversion from a string.
  */
-void CheckFromString(nlTestSuite * inSuite, void * inContext)
+TEST_F(TestInetAddress, TestCheckFromString)
 {
-    const struct TestContext * lContext       = static_cast<const struct TestContext *>(inContext);
-    IPAddressExpandedContextIterator lCurrent = lContext->mIPAddressExpandedContextRange.mBegin;
-    IPAddressExpandedContextIterator lEnd     = lContext->mIPAddressExpandedContextRange.mEnd;
+    IPAddressExpandedContextIterator lCurrent = pTestContext->mIPAddressExpandedContextRange.mBegin;
+    IPAddressExpandedContextIterator lEnd     = pTestContext->mIPAddressExpandedContextRange.mEnd;
 
     while (lCurrent != lEnd)
     {
@@ -768,7 +774,7 @@
 
         IPAddress::FromString(lCurrent->mAddr.mAddrString, test_addr);
 
-        CheckAddressQuartets(inSuite, lCurrent->mAddr, test_addr);
+        CheckAddressQuartets(lCurrent->mAddr, test_addr);
 
         char tmpBuf[INET6_ADDRSTRLEN];
         size_t addrStrLen = strlen(lCurrent->mAddr.mAddrString);
@@ -778,7 +784,7 @@
 
         IPAddress::FromString(tmpBuf, addrStrLen, test_addr);
 
-        CheckAddressQuartets(inSuite, lCurrent->mAddr, test_addr);
+        CheckAddressQuartets(lCurrent->mAddr, test_addr);
 
         ++lCurrent;
     }
@@ -787,11 +793,10 @@
 /**
  *  Test IP address conversion to a string.
  */
-void CheckToString(nlTestSuite * inSuite, void * inContext)
+TEST_F(TestInetAddress, TestCheckToString)
 {
-    const struct TestContext * lContext       = static_cast<const struct TestContext *>(inContext);
-    IPAddressExpandedContextIterator lCurrent = lContext->mIPAddressExpandedContextRange.mBegin;
-    IPAddressExpandedContextIterator lEnd     = lContext->mIPAddressExpandedContextRange.mEnd;
+    IPAddressExpandedContextIterator lCurrent = pTestContext->mIPAddressExpandedContextRange.mBegin;
+    IPAddressExpandedContextIterator lEnd     = pTestContext->mIPAddressExpandedContextRange.mEnd;
     char lAddressBuffer[INET6_ADDRSTRLEN];
     IPAddress lAddress;
 
@@ -812,9 +817,9 @@
         IPAddress::FromString(lCurrent->mAddr.mAddrString, strlen(lCurrent->mAddr.mAddrString), tempIpAddr);
         // Reconvert the expected IPV6 String to an uncompressed string format
         tempIpAddr.ToString(uncompressedAddrStr);
-        CheckAddressString(inSuite, lAddressBuffer, uncompressedAddrStr);
+        CheckAddressString(lAddressBuffer, uncompressedAddrStr);
 #else
-        CheckAddressString(inSuite, lAddressBuffer, lCurrent->mAddr.mAddrString);
+        CheckAddressString(lAddressBuffer, lCurrent->mAddr.mAddrString);
 #endif // CHIP_SYSTEM_CONFIG_USE_OPEN_THREAD_ENDPOINT
         ++lCurrent;
     }
@@ -823,11 +828,10 @@
 /**
  *  Test correct identification of IPv6 ULA addresses.
  */
-void CheckIsIPv6ULA(nlTestSuite * inSuite, void * inContext)
+TEST_F(TestInetAddress, TestCheckIsIPv6ULA)
 {
-    const struct TestContext * lContext       = static_cast<const struct TestContext *>(inContext);
-    IPAddressExpandedContextIterator lCurrent = lContext->mIPAddressExpandedContextRange.mBegin;
-    IPAddressExpandedContextIterator lEnd     = lContext->mIPAddressExpandedContextRange.mEnd;
+    IPAddressExpandedContextIterator lCurrent = pTestContext->mIPAddressExpandedContextRange.mBegin;
+    IPAddressExpandedContextIterator lEnd     = pTestContext->mIPAddressExpandedContextRange.mEnd;
 
     while (lCurrent != lEnd)
     {
@@ -835,7 +839,7 @@
 
         SetupIPAddress(test_addr, lCurrent);
 
-        NL_TEST_ASSERT(inSuite, test_addr.IsIPv6ULA() == lCurrent->isIPv6ULA);
+        EXPECT_EQ(test_addr.IsIPv6ULA(), lCurrent->isIPv6ULA);
 
         ++lCurrent;
     }
@@ -844,11 +848,10 @@
 /**
  *  Test correct identification of IPv6 Link Local addresses.
  */
-void CheckIsIPv6LLA(nlTestSuite * inSuite, void * inContext)
+TEST_F(TestInetAddress, TestCheckIsIPv6LLA)
 {
-    const struct TestContext * lContext       = static_cast<const struct TestContext *>(inContext);
-    IPAddressExpandedContextIterator lCurrent = lContext->mIPAddressExpandedContextRange.mBegin;
-    IPAddressExpandedContextIterator lEnd     = lContext->mIPAddressExpandedContextRange.mEnd;
+    IPAddressExpandedContextIterator lCurrent = pTestContext->mIPAddressExpandedContextRange.mBegin;
+    IPAddressExpandedContextIterator lEnd     = pTestContext->mIPAddressExpandedContextRange.mEnd;
 
     while (lCurrent != lEnd)
     {
@@ -856,7 +859,7 @@
 
         SetupIPAddress(test_addr, lCurrent);
 
-        NL_TEST_ASSERT(inSuite, test_addr.IsIPv6LinkLocal() == lCurrent->isIPv6LLA);
+        EXPECT_EQ(test_addr.IsIPv6LinkLocal(), lCurrent->isIPv6LLA);
 
         ++lCurrent;
     }
@@ -865,11 +868,10 @@
 /**
  *  Test correct identification of IPv6 multicast addresses.
  */
-void CheckIsIPv6Multicast(nlTestSuite * inSuite, void * inContext)
+TEST_F(TestInetAddress, TestCheckIsIPv6Multicast)
 {
-    const struct TestContext * lContext       = static_cast<const struct TestContext *>(inContext);
-    IPAddressExpandedContextIterator lCurrent = lContext->mIPAddressExpandedContextRange.mBegin;
-    IPAddressExpandedContextIterator lEnd     = lContext->mIPAddressExpandedContextRange.mEnd;
+    IPAddressExpandedContextIterator lCurrent = pTestContext->mIPAddressExpandedContextRange.mBegin;
+    IPAddressExpandedContextIterator lEnd     = pTestContext->mIPAddressExpandedContextRange.mEnd;
 
     while (lCurrent != lEnd)
     {
@@ -877,7 +879,7 @@
 
         SetupIPAddress(test_addr, lCurrent);
 
-        NL_TEST_ASSERT(inSuite, test_addr.IsIPv6Multicast() == lCurrent->isIPv6Multicast);
+        EXPECT_EQ(test_addr.IsIPv6Multicast(), lCurrent->isIPv6Multicast);
 
         ++lCurrent;
     }
@@ -886,11 +888,10 @@
 /**
  *  Test correct identification of multicast addresses.
  */
-void CheckIsMulticast(nlTestSuite * inSuite, void * inContext)
+TEST_F(TestInetAddress, TestCheckIsMulticast)
 {
-    const struct TestContext * lContext       = static_cast<const struct TestContext *>(inContext);
-    IPAddressExpandedContextIterator lCurrent = lContext->mIPAddressExpandedContextRange.mBegin;
-    IPAddressExpandedContextIterator lEnd     = lContext->mIPAddressExpandedContextRange.mEnd;
+    IPAddressExpandedContextIterator lCurrent = pTestContext->mIPAddressExpandedContextRange.mBegin;
+    IPAddressExpandedContextIterator lEnd     = pTestContext->mIPAddressExpandedContextRange.mEnd;
 
     while (lCurrent != lEnd)
     {
@@ -898,7 +899,7 @@
 
         SetupIPAddress(test_addr, lCurrent);
 
-        NL_TEST_ASSERT(inSuite, test_addr.IsMulticast() == lCurrent->isMulticast);
+        EXPECT_EQ(test_addr.IsMulticast(), lCurrent->isMulticast);
 
         ++lCurrent;
     }
@@ -907,16 +908,15 @@
 /**
  *  Test IPAddress equal operator.
  */
-void CheckOperatorEqual(nlTestSuite * inSuite, void * inContext)
+TEST_F(TestInetAddress, TestCheckOperatorEqual)
 {
-    const struct TestContext * lContext            = static_cast<const struct TestContext *>(inContext);
-    IPAddressExpandedContextIterator lFirstCurrent = lContext->mIPAddressExpandedContextRange.mBegin;
-    IPAddressExpandedContextIterator lFirstEnd     = lContext->mIPAddressExpandedContextRange.mEnd;
+    IPAddressExpandedContextIterator lFirstCurrent = pTestContext->mIPAddressExpandedContextRange.mBegin;
+    IPAddressExpandedContextIterator lFirstEnd     = pTestContext->mIPAddressExpandedContextRange.mEnd;
 
     while (lFirstCurrent != lFirstEnd)
     {
-        IPAddressExpandedContextIterator lSecondCurrent = lContext->mIPAddressExpandedContextRange.mBegin;
-        IPAddressExpandedContextIterator lSecondEnd     = lContext->mIPAddressExpandedContextRange.mEnd;
+        IPAddressExpandedContextIterator lSecondCurrent = pTestContext->mIPAddressExpandedContextRange.mBegin;
+        IPAddressExpandedContextIterator lSecondEnd     = pTestContext->mIPAddressExpandedContextRange.mEnd;
         IPAddress test_addr_1;
 
         SetupIPAddress(test_addr_1, lFirstCurrent);
@@ -929,11 +929,11 @@
 
             if (lFirstCurrent == lSecondCurrent)
             {
-                NL_TEST_ASSERT(inSuite, test_addr_1 == test_addr_2);
+                EXPECT_EQ(test_addr_1, test_addr_2);
             }
             else
             {
-                NL_TEST_ASSERT(inSuite, !(test_addr_1 == test_addr_2));
+                EXPECT_FALSE(test_addr_1 == test_addr_2);
             }
 
             ++lSecondCurrent;
@@ -946,16 +946,15 @@
 /**
  *  Test IPAddress not-equal operator.
  */
-void CheckOperatorNotEqual(nlTestSuite * inSuite, void * inContext)
+TEST_F(TestInetAddress, TestCheckOperatorNotEqual)
 {
-    const struct TestContext * lContext            = static_cast<const struct TestContext *>(inContext);
-    IPAddressExpandedContextIterator lFirstCurrent = lContext->mIPAddressExpandedContextRange.mBegin;
-    IPAddressExpandedContextIterator lFirstEnd     = lContext->mIPAddressExpandedContextRange.mEnd;
+    IPAddressExpandedContextIterator lFirstCurrent = pTestContext->mIPAddressExpandedContextRange.mBegin;
+    IPAddressExpandedContextIterator lFirstEnd     = pTestContext->mIPAddressExpandedContextRange.mEnd;
 
     while (lFirstCurrent != lFirstEnd)
     {
-        IPAddressExpandedContextIterator lSecondCurrent = lContext->mIPAddressExpandedContextRange.mBegin;
-        IPAddressExpandedContextIterator lSecondEnd     = lContext->mIPAddressExpandedContextRange.mEnd;
+        IPAddressExpandedContextIterator lSecondCurrent = pTestContext->mIPAddressExpandedContextRange.mBegin;
+        IPAddressExpandedContextIterator lSecondEnd     = pTestContext->mIPAddressExpandedContextRange.mEnd;
         IPAddress test_addr_1;
 
         SetupIPAddress(test_addr_1, lFirstCurrent);
@@ -968,11 +967,11 @@
 
             if (lFirstCurrent == lSecondCurrent)
             {
-                NL_TEST_ASSERT(inSuite, !(test_addr_1 != test_addr_2));
+                EXPECT_FALSE(test_addr_1 != test_addr_2);
             }
             else
             {
-                NL_TEST_ASSERT(inSuite, test_addr_1 != test_addr_2);
+                EXPECT_NE(test_addr_1, test_addr_2);
             }
 
             ++lSecondCurrent;
@@ -985,16 +984,15 @@
 /**
  *  Test IPAddress assign operator.
  */
-void CheckOperatorAssign(nlTestSuite * inSuite, void * inContext)
+TEST_F(TestInetAddress, TestCheckOperatorAssign)
 {
-    const struct TestContext * lContext            = static_cast<const struct TestContext *>(inContext);
-    IPAddressExpandedContextIterator lFirstCurrent = lContext->mIPAddressExpandedContextRange.mBegin;
-    IPAddressExpandedContextIterator lFirstEnd     = lContext->mIPAddressExpandedContextRange.mEnd;
+    IPAddressExpandedContextIterator lFirstCurrent = pTestContext->mIPAddressExpandedContextRange.mBegin;
+    IPAddressExpandedContextIterator lFirstEnd     = pTestContext->mIPAddressExpandedContextRange.mEnd;
 
     while (lFirstCurrent != lFirstEnd)
     {
-        IPAddressExpandedContextIterator lSecondCurrent = lContext->mIPAddressExpandedContextRange.mBegin;
-        IPAddressExpandedContextIterator lSecondEnd     = lContext->mIPAddressExpandedContextRange.mEnd;
+        IPAddressExpandedContextIterator lSecondCurrent = pTestContext->mIPAddressExpandedContextRange.mBegin;
+        IPAddressExpandedContextIterator lSecondEnd     = pTestContext->mIPAddressExpandedContextRange.mEnd;
 
         while (lSecondCurrent != lSecondEnd)
         {
@@ -1006,7 +1004,7 @@
             // Use operator to assign IPAddress from test_addr_2 to test_addr_1
             test_addr_1 = test_addr_2;
 
-            CheckAddressQuartets(inSuite, test_addr_1, test_addr_2);
+            CheckAddressQuartets(test_addr_1, test_addr_2);
 
             ++lSecondCurrent;
         }
@@ -1018,11 +1016,10 @@
 /**
  *   Test IPAddress v6 conversion to native representation.
  */
-void CheckToIPv6(nlTestSuite * inSuite, void * inContext)
+TEST_F(TestInetAddress, TestCheckToIPv6)
 {
-    const struct TestContext * lContext       = static_cast<const struct TestContext *>(inContext);
-    IPAddressExpandedContextIterator lCurrent = lContext->mIPAddressExpandedContextRange.mBegin;
-    IPAddressExpandedContextIterator lEnd     = lContext->mIPAddressExpandedContextRange.mEnd;
+    IPAddressExpandedContextIterator lCurrent = pTestContext->mIPAddressExpandedContextRange.mBegin;
+    IPAddressExpandedContextIterator lEnd     = pTestContext->mIPAddressExpandedContextRange.mEnd;
 
     while (lCurrent != lEnd)
     {
@@ -1051,7 +1048,7 @@
 #endif
         ip_addr_2 = test_addr.ToIPv6();
 
-        NL_TEST_ASSERT(inSuite, !memcmp(&ip_addr_1, &ip_addr_2, sizeof(ip_addr_1)));
+        EXPECT_EQ(memcmp(&ip_addr_1, &ip_addr_2, sizeof(ip_addr_1)), 0);
 
         ++lCurrent;
     }
@@ -1060,11 +1057,10 @@
 /**
  *   Test native IPv6 conversion into IPAddress.
  */
-void CheckFromIPv6(nlTestSuite * inSuite, void * inContext)
+TEST_F(TestInetAddress, TestCheckFromIPv6)
 {
-    const struct TestContext * lContext       = static_cast<const struct TestContext *>(inContext);
-    IPAddressExpandedContextIterator lCurrent = lContext->mIPAddressExpandedContextRange.mBegin;
-    IPAddressExpandedContextIterator lEnd     = lContext->mIPAddressExpandedContextRange.mEnd;
+    IPAddressExpandedContextIterator lCurrent = pTestContext->mIPAddressExpandedContextRange.mBegin;
+    IPAddressExpandedContextIterator lEnd     = pTestContext->mIPAddressExpandedContextRange.mEnd;
 
     while (lCurrent != lEnd)
     {
@@ -1091,7 +1087,7 @@
 #endif
         test_addr_2 = IPAddress(ip_addr);
 
-        CheckAddressQuartets(inSuite, test_addr_1, test_addr_2);
+        CheckAddressQuartets(test_addr_1, test_addr_2);
 
         ++lCurrent;
     }
@@ -1101,11 +1097,10 @@
 /**
  *  Test correct identification of IPv4 addresses.
  */
-void CheckIsIPv4(nlTestSuite * inSuite, void * inContext)
+TEST_F(TestInetAddress, TestCheckIsIPv4)
 {
-    const struct TestContext * lContext       = static_cast<const struct TestContext *>(inContext);
-    IPAddressExpandedContextIterator lCurrent = lContext->mIPAddressExpandedContextRange.mBegin;
-    IPAddressExpandedContextIterator lEnd     = lContext->mIPAddressExpandedContextRange.mEnd;
+    IPAddressExpandedContextIterator lCurrent = pTestContext->mIPAddressExpandedContextRange.mBegin;
+    IPAddressExpandedContextIterator lEnd     = pTestContext->mIPAddressExpandedContextRange.mEnd;
 
     while (lCurrent != lEnd)
     {
@@ -1113,7 +1108,7 @@
 
         SetupIPAddress(test_addr, lCurrent);
 
-        NL_TEST_ASSERT(inSuite, test_addr.IsIPv4() == lCurrent->isIPv4);
+        EXPECT_EQ(test_addr.IsIPv4(), lCurrent->isIPv4);
 
         ++lCurrent;
     }
@@ -1122,11 +1117,10 @@
 /**
  *  Test correct identification of IPv4 multicast addresses.
  */
-void CheckIsIPv4Multicast(nlTestSuite * inSuite, void * inContext)
+TEST_F(TestInetAddress, TestCheckIsIPv4Multicast)
 {
-    const struct TestContext * lContext       = static_cast<const struct TestContext *>(inContext);
-    IPAddressExpandedContextIterator lCurrent = lContext->mIPAddressExpandedContextRange.mBegin;
-    IPAddressExpandedContextIterator lEnd     = lContext->mIPAddressExpandedContextRange.mEnd;
+    IPAddressExpandedContextIterator lCurrent = pTestContext->mIPAddressExpandedContextRange.mBegin;
+    IPAddressExpandedContextIterator lEnd     = pTestContext->mIPAddressExpandedContextRange.mEnd;
 
     while (lCurrent != lEnd)
     {
@@ -1134,7 +1128,7 @@
 
         SetupIPAddress(test_addr, lCurrent);
 
-        NL_TEST_ASSERT(inSuite, test_addr.IsIPv4Multicast() == lCurrent->isIPv4Multicast);
+        EXPECT_EQ(test_addr.IsIPv4Multicast(), lCurrent->isIPv4Multicast);
 
         ++lCurrent;
     }
@@ -1143,11 +1137,10 @@
 /**
  *  Test correct identification of IPv4 broadcast addresses.
  */
-void CheckIsIPv4Broadcast(nlTestSuite * inSuite, void * inContext)
+TEST_F(TestInetAddress, TestCheckIsIPv4Broadcast)
 {
-    const struct TestContext * lContext       = static_cast<const struct TestContext *>(inContext);
-    IPAddressExpandedContextIterator lCurrent = lContext->mIPAddressExpandedContextRange.mBegin;
-    IPAddressExpandedContextIterator lEnd     = lContext->mIPAddressExpandedContextRange.mEnd;
+    IPAddressExpandedContextIterator lCurrent = pTestContext->mIPAddressExpandedContextRange.mBegin;
+    IPAddressExpandedContextIterator lEnd     = pTestContext->mIPAddressExpandedContextRange.mEnd;
 
     while (lCurrent != lEnd)
     {
@@ -1155,7 +1148,7 @@
 
         SetupIPAddress(test_addr, lCurrent);
 
-        NL_TEST_ASSERT(inSuite, test_addr.IsIPv4Broadcast() == lCurrent->isIPv4Broadcast);
+        EXPECT_EQ(test_addr.IsIPv4Broadcast(), lCurrent->isIPv4Broadcast);
 
         ++lCurrent;
     }
@@ -1164,11 +1157,10 @@
 /**
  *   Test IPAddress v4 conversion to native representation.
  */
-void CheckToIPv4(nlTestSuite * inSuite, void * inContext)
+TEST_F(TestInetAddress, TestCheckToIPv4)
 {
-    const struct TestContext * lContext       = static_cast<const struct TestContext *>(inContext);
-    IPAddressExpandedContextIterator lCurrent = lContext->mIPAddressExpandedContextRange.mBegin;
-    IPAddressExpandedContextIterator lEnd     = lContext->mIPAddressExpandedContextRange.mEnd;
+    IPAddressExpandedContextIterator lCurrent = pTestContext->mIPAddressExpandedContextRange.mBegin;
+    IPAddressExpandedContextIterator lEnd     = pTestContext->mIPAddressExpandedContextRange.mEnd;
 
     while (lCurrent != lEnd)
     {
@@ -1187,7 +1179,7 @@
 #endif
         ip_addr_2 = test_addr.ToIPv4();
 
-        NL_TEST_ASSERT(inSuite, !memcmp(&ip_addr_1, &ip_addr_2, sizeof(ip_addr_1)));
+        EXPECT_EQ(memcmp(&ip_addr_1, &ip_addr_2, sizeof(ip_addr_1)), 0);
 
         ++lCurrent;
     }
@@ -1196,11 +1188,10 @@
 /**
  *   Test native IPv4 conversion into IPAddress.
  */
-void CheckFromIPv4(nlTestSuite * inSuite, void * inContext)
+TEST_F(TestInetAddress, TestCheckFromIPv4)
 {
-    const struct TestContext * lContext       = static_cast<const struct TestContext *>(inContext);
-    IPAddressExpandedContextIterator lCurrent = lContext->mIPAddressExpandedContextRange.mBegin;
-    IPAddressExpandedContextIterator lEnd     = lContext->mIPAddressExpandedContextRange.mEnd;
+    IPAddressExpandedContextIterator lCurrent = pTestContext->mIPAddressExpandedContextRange.mBegin;
+    IPAddressExpandedContextIterator lEnd     = pTestContext->mIPAddressExpandedContextRange.mEnd;
 
     while (lCurrent != lEnd)
     {
@@ -1224,7 +1215,7 @@
 #endif
         test_addr_2 = IPAddress(ip_addr);
 
-        CheckAddressQuartets(inSuite, test_addr_1, test_addr_2);
+        CheckAddressQuartets(test_addr_1, test_addr_2);
 
         ++lCurrent;
     }
@@ -1234,15 +1225,13 @@
 /**
  *   Test IPAddress address conversion from socket.
  */
-void CheckFromSocket(nlTestSuite * inSuite, void * inContext)
+TEST_F(TestInetAddress, TestCheckFromSocket)
 {
 #if CHIP_SYSTEM_CONFIG_USE_LWIP || CHIP_SYSTEM_CONFIG_USE_OPEN_THREAD_ENDPOINT
-    (void) inSuite;
     // This test is not supported LWIP or OPEN_THREAD_ENDPOINT stacks.
 #else // CHIP_SYSTEM_CONFIG_USE_LWIP
-    const struct TestContext * lContext       = static_cast<const struct TestContext *>(inContext);
-    IPAddressExpandedContextIterator lCurrent = lContext->mIPAddressExpandedContextRange.mBegin;
-    IPAddressExpandedContextIterator lEnd     = lContext->mIPAddressExpandedContextRange.mEnd;
+    IPAddressExpandedContextIterator lCurrent = pTestContext->mIPAddressExpandedContextRange.mBegin;
+    IPAddressExpandedContextIterator lEnd     = pTestContext->mIPAddressExpandedContextRange.mEnd;
 
     while (lCurrent != lEnd)
     {
@@ -1290,7 +1279,7 @@
             continue;
         }
 
-        CheckAddressQuartets(inSuite, test_addr_1, test_addr_2);
+        CheckAddressQuartets(test_addr_1, test_addr_2);
 
         ++lCurrent;
     }
@@ -1300,11 +1289,10 @@
 /**
  *  Test IP address type.
  */
-void CheckType(nlTestSuite * inSuite, void * inContext)
+TEST_F(TestInetAddress, TestCheckType)
 {
-    const struct TestContext * lContext       = static_cast<const struct TestContext *>(inContext);
-    IPAddressExpandedContextIterator lCurrent = lContext->mIPAddressExpandedContextRange.mBegin;
-    IPAddressExpandedContextIterator lEnd     = lContext->mIPAddressExpandedContextRange.mEnd;
+    IPAddressExpandedContextIterator lCurrent = pTestContext->mIPAddressExpandedContextRange.mBegin;
+    IPAddressExpandedContextIterator lEnd     = pTestContext->mIPAddressExpandedContextRange.mEnd;
 
     while (lCurrent != lEnd)
     {
@@ -1312,7 +1300,7 @@
 
         SetupIPAddress(test_addr, lCurrent);
 
-        NL_TEST_ASSERT(inSuite, test_addr.Type() == lCurrent->mAddr.mAddrType);
+        EXPECT_EQ(test_addr.Type(), lCurrent->mAddr.mAddrType);
 
         ++lCurrent;
     }
@@ -1321,22 +1309,21 @@
 /**
  *  Test the Any address global.
  */
-void CheckAnyAddress(nlTestSuite * inSuite, void * inContext)
+TEST_F(TestInetAddress, TestCheckAnyAddress)
 {
     const IPAddress test_addr = IPAddress::Any;
     IPAddressType test_type   = test_addr.Type();
 
-    NL_TEST_ASSERT(inSuite, test_type == IPAddressType::kAny);
+    EXPECT_EQ(test_type, IPAddressType::kAny);
 }
 
 /**
  *  Test IP address interface ID.
  */
-void CheckInterface(nlTestSuite * inSuite, void * inContext)
+TEST_F(TestInetAddress, TestCheckInterface)
 {
-    const struct TestContext * lContext       = static_cast<const struct TestContext *>(inContext);
-    IPAddressExpandedContextIterator lCurrent = lContext->mIPAddressExpandedContextRange.mBegin;
-    IPAddressExpandedContextIterator lEnd     = lContext->mIPAddressExpandedContextRange.mEnd;
+    IPAddressExpandedContextIterator lCurrent = pTestContext->mIPAddressExpandedContextRange.mBegin;
+    IPAddressExpandedContextIterator lEnd     = pTestContext->mIPAddressExpandedContextRange.mEnd;
 
     while (lCurrent != lEnd)
     {
@@ -1344,7 +1331,7 @@
 
         SetupIPAddress(test_addr, lCurrent);
 
-        NL_TEST_ASSERT(inSuite, test_addr.InterfaceId() == lCurrent->interface);
+        EXPECT_EQ(test_addr.InterfaceId(), lCurrent->interface);
 
         ++lCurrent;
     }
@@ -1353,11 +1340,10 @@
 /**
  *  Test IP address subnet.
  */
-void CheckSubnet(nlTestSuite * inSuite, void * inContext)
+TEST_F(TestInetAddress, TestCheckSubnet)
 {
-    const struct TestContext * lContext       = static_cast<const struct TestContext *>(inContext);
-    IPAddressExpandedContextIterator lCurrent = lContext->mIPAddressExpandedContextRange.mBegin;
-    IPAddressExpandedContextIterator lEnd     = lContext->mIPAddressExpandedContextRange.mEnd;
+    IPAddressExpandedContextIterator lCurrent = pTestContext->mIPAddressExpandedContextRange.mBegin;
+    IPAddressExpandedContextIterator lEnd     = pTestContext->mIPAddressExpandedContextRange.mEnd;
 
     while (lCurrent != lEnd)
     {
@@ -1365,7 +1351,7 @@
 
         SetupIPAddress(test_addr, lCurrent);
 
-        NL_TEST_ASSERT(inSuite, test_addr.Subnet() == lCurrent->subnet);
+        EXPECT_EQ(test_addr.Subnet(), lCurrent->subnet);
 
         ++lCurrent;
     }
@@ -1374,11 +1360,10 @@
 /**
  *  Test IP address global ID.
  */
-void CheckGlobal(nlTestSuite * inSuite, void * inContext)
+TEST_F(TestInetAddress, TestCheckGlobal)
 {
-    const struct TestContext * lContext       = static_cast<const struct TestContext *>(inContext);
-    IPAddressExpandedContextIterator lCurrent = lContext->mIPAddressExpandedContextRange.mBegin;
-    IPAddressExpandedContextIterator lEnd     = lContext->mIPAddressExpandedContextRange.mEnd;
+    IPAddressExpandedContextIterator lCurrent = pTestContext->mIPAddressExpandedContextRange.mBegin;
+    IPAddressExpandedContextIterator lEnd     = pTestContext->mIPAddressExpandedContextRange.mEnd;
 
     while (lCurrent != lEnd)
     {
@@ -1386,7 +1371,7 @@
 
         SetupIPAddress(test_addr, lCurrent);
 
-        NL_TEST_ASSERT(inSuite, test_addr.GlobalId() == lCurrent->global);
+        EXPECT_EQ(test_addr.GlobalId(), lCurrent->global);
 
         ++lCurrent;
     }
@@ -1395,11 +1380,10 @@
 /**
  *  Test address encoding with chip::Encoding.
  */
-void CheckEncoding(nlTestSuite * inSuite, void * inContext)
+TEST_F(TestInetAddress, TestCheckEncoding)
 {
-    const struct TestContext * lContext       = static_cast<const struct TestContext *>(inContext);
-    IPAddressExpandedContextIterator lCurrent = lContext->mIPAddressExpandedContextRange.mBegin;
-    IPAddressExpandedContextIterator lEnd     = lContext->mIPAddressExpandedContextRange.mEnd;
+    IPAddressExpandedContextIterator lCurrent = pTestContext->mIPAddressExpandedContextRange.mBegin;
+    IPAddressExpandedContextIterator lEnd     = pTestContext->mIPAddressExpandedContextRange.mEnd;
 
     while (lCurrent != lEnd)
     {
@@ -1415,25 +1399,25 @@
         test_addr.WriteAddress(p);
 
         // buffer has address in network byte order
-        NL_TEST_ASSERT(inSuite, buffer[3] == (uint8_t) (lCurrent->mAddr.mAddrQuartets[0]));
-        NL_TEST_ASSERT(inSuite, buffer[2] == (uint8_t) (lCurrent->mAddr.mAddrQuartets[0] >> 8));
-        NL_TEST_ASSERT(inSuite, buffer[1] == (uint8_t) (lCurrent->mAddr.mAddrQuartets[0] >> 16));
-        NL_TEST_ASSERT(inSuite, buffer[0] == (uint8_t) (lCurrent->mAddr.mAddrQuartets[0] >> 24));
+        EXPECT_EQ(buffer[3], (uint8_t) (lCurrent->mAddr.mAddrQuartets[0]));
+        EXPECT_EQ(buffer[2], (uint8_t) (lCurrent->mAddr.mAddrQuartets[0] >> 8));
+        EXPECT_EQ(buffer[1], (uint8_t) (lCurrent->mAddr.mAddrQuartets[0] >> 16));
+        EXPECT_EQ(buffer[0], (uint8_t) (lCurrent->mAddr.mAddrQuartets[0] >> 24));
 
-        NL_TEST_ASSERT(inSuite, buffer[7] == (uint8_t) (lCurrent->mAddr.mAddrQuartets[1]));
-        NL_TEST_ASSERT(inSuite, buffer[6] == (uint8_t) (lCurrent->mAddr.mAddrQuartets[1] >> 8));
-        NL_TEST_ASSERT(inSuite, buffer[5] == (uint8_t) (lCurrent->mAddr.mAddrQuartets[1] >> 16));
-        NL_TEST_ASSERT(inSuite, buffer[4] == (uint8_t) (lCurrent->mAddr.mAddrQuartets[1] >> 24));
+        EXPECT_EQ(buffer[7], (uint8_t) (lCurrent->mAddr.mAddrQuartets[1]));
+        EXPECT_EQ(buffer[6], (uint8_t) (lCurrent->mAddr.mAddrQuartets[1] >> 8));
+        EXPECT_EQ(buffer[5], (uint8_t) (lCurrent->mAddr.mAddrQuartets[1] >> 16));
+        EXPECT_EQ(buffer[4], (uint8_t) (lCurrent->mAddr.mAddrQuartets[1] >> 24));
 
-        NL_TEST_ASSERT(inSuite, buffer[11] == (uint8_t) (lCurrent->mAddr.mAddrQuartets[2]));
-        NL_TEST_ASSERT(inSuite, buffer[10] == (uint8_t) (lCurrent->mAddr.mAddrQuartets[2] >> 8));
-        NL_TEST_ASSERT(inSuite, buffer[9] == (uint8_t) (lCurrent->mAddr.mAddrQuartets[2] >> 16));
-        NL_TEST_ASSERT(inSuite, buffer[8] == (uint8_t) (lCurrent->mAddr.mAddrQuartets[2] >> 24));
+        EXPECT_EQ(buffer[11], (uint8_t) (lCurrent->mAddr.mAddrQuartets[2]));
+        EXPECT_EQ(buffer[10], (uint8_t) (lCurrent->mAddr.mAddrQuartets[2] >> 8));
+        EXPECT_EQ(buffer[9], (uint8_t) (lCurrent->mAddr.mAddrQuartets[2] >> 16));
+        EXPECT_EQ(buffer[8], (uint8_t) (lCurrent->mAddr.mAddrQuartets[2] >> 24));
 
-        NL_TEST_ASSERT(inSuite, buffer[15] == (uint8_t) (lCurrent->mAddr.mAddrQuartets[3]));
-        NL_TEST_ASSERT(inSuite, buffer[14] == (uint8_t) (lCurrent->mAddr.mAddrQuartets[3] >> 8));
-        NL_TEST_ASSERT(inSuite, buffer[13] == (uint8_t) (lCurrent->mAddr.mAddrQuartets[3] >> 16));
-        NL_TEST_ASSERT(inSuite, buffer[12] == (uint8_t) (lCurrent->mAddr.mAddrQuartets[3] >> 24));
+        EXPECT_EQ(buffer[15], (uint8_t) (lCurrent->mAddr.mAddrQuartets[3]));
+        EXPECT_EQ(buffer[14], (uint8_t) (lCurrent->mAddr.mAddrQuartets[3] >> 8));
+        EXPECT_EQ(buffer[13], (uint8_t) (lCurrent->mAddr.mAddrQuartets[3] >> 16));
+        EXPECT_EQ(buffer[12], (uint8_t) (lCurrent->mAddr.mAddrQuartets[3] >> 24));
 
         ++lCurrent;
     }
@@ -1442,11 +1426,10 @@
 /**
  *  Test address decoding with chip::Decoding.
  */
-void CheckDecoding(nlTestSuite * inSuite, void * inContext)
+TEST_F(TestInetAddress, TestCheckDecoding)
 {
-    const struct TestContext * lContext       = static_cast<const struct TestContext *>(inContext);
-    IPAddressExpandedContextIterator lCurrent = lContext->mIPAddressExpandedContextRange.mBegin;
-    IPAddressExpandedContextIterator lEnd     = lContext->mIPAddressExpandedContextRange.mEnd;
+    IPAddressExpandedContextIterator lCurrent = pTestContext->mIPAddressExpandedContextRange.mBegin;
+    IPAddressExpandedContextIterator lEnd     = pTestContext->mIPAddressExpandedContextRange.mEnd;
 
     while (lCurrent != lEnd)
     {
@@ -1468,7 +1451,7 @@
         // Call ReadAddress function that we test.
         IPAddress::ReadAddress(const_cast<const uint8_t *&>(p), test_addr_2);
 
-        CheckAddressQuartets(inSuite, test_addr_1, test_addr_2);
+        CheckAddressQuartets(test_addr_1, test_addr_2);
 
         ++lCurrent;
     }
@@ -1477,11 +1460,10 @@
 /**
  *  Test address symmetricity of encoding and decoding with chip::(De/En)code.
  */
-void CheckEcodeDecodeSymmetricity(nlTestSuite * inSuite, void * inContext)
+TEST_F(TestInetAddress, TestCheckEcodeDecodeSymmetricity)
 {
-    const struct TestContext * lContext       = static_cast<const struct TestContext *>(inContext);
-    IPAddressExpandedContextIterator lCurrent = lContext->mIPAddressExpandedContextRange.mBegin;
-    IPAddressExpandedContextIterator lEnd     = lContext->mIPAddressExpandedContextRange.mEnd;
+    IPAddressExpandedContextIterator lCurrent = pTestContext->mIPAddressExpandedContextRange.mBegin;
+    IPAddressExpandedContextIterator lEnd     = pTestContext->mIPAddressExpandedContextRange.mEnd;
 
     while (lCurrent != lEnd)
     {
@@ -1504,7 +1486,7 @@
         // Call ReadAddress function that we test.
         IPAddress::ReadAddress(const_cast<const uint8_t *&>(p), test_addr_2);
 
-        CheckAddressQuartets(inSuite, test_addr_1, test_addr_2);
+        CheckAddressQuartets(test_addr_1, test_addr_2);
 
         ++lCurrent;
     }
@@ -1513,11 +1495,10 @@
 /**
  *  Test assembling ULA address.
  */
-void CheckMakeULA(nlTestSuite * inSuite, void * inContext)
+TEST_F(TestInetAddress, TestCheckMakeULA)
 {
-    const struct TestContext * lContext       = static_cast<const struct TestContext *>(inContext);
-    IPAddressExpandedContextIterator lCurrent = lContext->mIPAddressExpandedContextRange.mBegin;
-    IPAddressExpandedContextIterator lEnd     = lContext->mIPAddressExpandedContextRange.mEnd;
+    IPAddressExpandedContextIterator lCurrent = pTestContext->mIPAddressExpandedContextRange.mBegin;
+    IPAddressExpandedContextIterator lEnd     = pTestContext->mIPAddressExpandedContextRange.mEnd;
 
     while (lCurrent != lEnd)
     {
@@ -1526,13 +1507,11 @@
         // Call MakeULA function that we test.
         test_addr = IPAddress::MakeULA(lCurrent->global, lCurrent->subnet, lCurrent->interface);
 
-        NL_TEST_ASSERT(
-            inSuite, test_addr.Addr[0] == htonl(static_cast<uint32_t>(ULA_PREFIX | (lCurrent->global & ULA_UP_24_BIT_MASK) >> 16)));
-        NL_TEST_ASSERT(inSuite,
-                       test_addr.Addr[1] ==
-                           htonl(static_cast<uint32_t>((lCurrent->global & ULA_LO_16_BIT_MASK) << 16 | lCurrent->subnet)));
-        NL_TEST_ASSERT(inSuite, test_addr.Addr[2] == htonl(static_cast<uint32_t>(lCurrent->interface >> 32)));
-        NL_TEST_ASSERT(inSuite, test_addr.Addr[3] == htonl(static_cast<uint32_t>(lCurrent->interface)));
+        EXPECT_EQ(test_addr.Addr[0], htonl(static_cast<uint32_t>(ULA_PREFIX | (lCurrent->global & ULA_UP_24_BIT_MASK) >> 16)));
+        EXPECT_EQ(test_addr.Addr[1],
+                  htonl(static_cast<uint32_t>((lCurrent->global & ULA_LO_16_BIT_MASK) << 16 | lCurrent->subnet)));
+        EXPECT_EQ(test_addr.Addr[2], htonl(static_cast<uint32_t>(lCurrent->interface >> 32)));
+        EXPECT_EQ(test_addr.Addr[3], htonl(static_cast<uint32_t>(lCurrent->interface)));
 
         ++lCurrent;
     }
@@ -1541,11 +1520,10 @@
 /**
  *  Test assembling LLA address.
  */
-void CheckMakeLLA(nlTestSuite * inSuite, void * inContext)
+TEST_F(TestInetAddress, TestCheckMakeLLA)
 {
-    const struct TestContext * lContext       = static_cast<const struct TestContext *>(inContext);
-    IPAddressExpandedContextIterator lCurrent = lContext->mIPAddressExpandedContextRange.mBegin;
-    IPAddressExpandedContextIterator lEnd     = lContext->mIPAddressExpandedContextRange.mEnd;
+    IPAddressExpandedContextIterator lCurrent = pTestContext->mIPAddressExpandedContextRange.mBegin;
+    IPAddressExpandedContextIterator lEnd     = pTestContext->mIPAddressExpandedContextRange.mEnd;
 
     while (lCurrent != lEnd)
     {
@@ -1554,20 +1532,19 @@
         // Call MakeLLA function that we test.
         test_addr = IPAddress::MakeLLA(lCurrent->interface);
 
-        NL_TEST_ASSERT(inSuite, test_addr.Addr[0] == htonl(LLA_PREFIX));
-        NL_TEST_ASSERT(inSuite, test_addr.Addr[1] == 0);
-        NL_TEST_ASSERT(inSuite, test_addr.Addr[2] == htonl(static_cast<uint32_t>(lCurrent->interface >> 32)));
-        NL_TEST_ASSERT(inSuite, test_addr.Addr[3] == htonl(static_cast<uint32_t>(lCurrent->interface)));
+        EXPECT_EQ(test_addr.Addr[0], htonl(LLA_PREFIX));
+        EXPECT_EQ(test_addr.Addr[1], 0u);
+        EXPECT_EQ(test_addr.Addr[2], htonl(static_cast<uint32_t>(lCurrent->interface >> 32)));
+        EXPECT_EQ(test_addr.Addr[3], htonl(static_cast<uint32_t>(lCurrent->interface)));
 
         ++lCurrent;
     }
 }
 
-void CheckMakeIPv6WellKnownMulticast(nlTestSuite * inSuite, void * inContext)
+TEST_F(TestInetAddress, TestCheckMakeIPv6WellKnownMulticast)
 {
-    const struct TestContext * lContext = static_cast<const struct TestContext *>(inContext);
-    IPAddressContextIterator lCurrent   = lContext->mIPv6WellKnownMulticastContextRange.mBegin;
-    IPAddressContextIterator lEnd       = lContext->mIPv6WellKnownMulticastContextRange.mEnd;
+    IPAddressContextIterator lCurrent = pTestContext->mIPv6WellKnownMulticastContextRange.mBegin;
+    IPAddressContextIterator lEnd     = pTestContext->mIPv6WellKnownMulticastContextRange.mEnd;
     size_t lGroupIndex;
     size_t lScopeIndex;
     IPAddress lAddress;
@@ -1583,7 +1560,7 @@
 
                 lAddress = IPAddress::MakeIPv6WellKnownMulticast(lScope, lGroup);
 
-                CheckAddress(inSuite, *lCurrent, lAddress);
+                CheckAddress(*lCurrent, lAddress);
 
                 ++lCurrent;
             }
@@ -1591,11 +1568,10 @@
     }
 }
 
-void CheckMakeIPv6TransientMulticast(nlTestSuite * inSuite, void * inContext)
+TEST_F(TestInetAddress, TestCheckMakeIPv6TransientMulticast)
 {
-    const struct TestContext * lContext = static_cast<const struct TestContext *>(inContext);
-    IPAddressContextIterator lCurrent   = lContext->mIPv6TransientMulticastContextRange.mBegin;
-    IPAddressContextIterator lEnd       = lContext->mIPv6TransientMulticastContextRange.mEnd;
+    IPAddressContextIterator lCurrent = pTestContext->mIPv6TransientMulticastContextRange.mBegin;
+    IPAddressContextIterator lEnd     = pTestContext->mIPv6TransientMulticastContextRange.mEnd;
     constexpr IPv6MulticastFlags lFlags;
     size_t lScopeIndex;
     IPAddress lAddress;
@@ -1612,7 +1588,7 @@
 
             lAddress = IPAddress::MakeIPv6TransientMulticast(lFlags, lScope, lGroup);
 
-            CheckAddress(inSuite, *lCurrent, lAddress);
+            CheckAddress(*lCurrent, lAddress);
 
             ++lCurrent;
         }
@@ -1627,18 +1603,17 @@
 
             lAddress = IPAddress::MakeIPv6TransientMulticast(lFlags, lScope, lGroup);
 
-            CheckAddress(inSuite, *lCurrent, lAddress);
+            CheckAddress(*lCurrent, lAddress);
 
             ++lCurrent;
         }
     }
 }
 
-void CheckMakeIPv6PrefixMulticast(nlTestSuite * inSuite, void * inContext)
+TEST_F(TestInetAddress, TestCheckMakeIPv6PrefixMulticast)
 {
-    const struct TestContext * lContext = static_cast<const struct TestContext *>(inContext);
-    IPAddressContextIterator lCurrent   = lContext->mIPv6PrefixMulticastContextRange.mBegin;
-    IPAddressContextIterator lEnd       = lContext->mIPv6PrefixMulticastContextRange.mEnd;
+    IPAddressContextIterator lCurrent = pTestContext->mIPv6PrefixMulticastContextRange.mBegin;
+    IPAddressContextIterator lEnd     = pTestContext->mIPv6PrefixMulticastContextRange.mEnd;
     uint8_t lPrefixLength;
     uint64_t lPrefix;
     uint32_t lGroup;
@@ -1659,7 +1634,7 @@
 
             lAddress = IPAddress::MakeIPv6PrefixMulticast(lScope, lPrefixLength, lPrefix, lGroup);
 
-            CheckAddress(inSuite, *lCurrent, lAddress);
+            CheckAddress(*lCurrent, lAddress);
 
             ++lCurrent;
         }
@@ -1676,7 +1651,7 @@
 
             lAddress = IPAddress::MakeIPv6PrefixMulticast(lScope, lPrefixLength, lPrefix, lGroup);
 
-            CheckAddress(inSuite, *lCurrent, lAddress);
+            CheckAddress(*lCurrent, lAddress);
 
             ++lCurrent;
         }
@@ -1693,7 +1668,7 @@
 
             lAddress = IPAddress::MakeIPv6PrefixMulticast(lScope, lPrefixLength, lPrefix, lGroup);
 
-            CheckAddress(inSuite, *lCurrent, lAddress);
+            CheckAddress(*lCurrent, lAddress);
 
             ++lCurrent;
         }
@@ -1710,7 +1685,7 @@
 
             lAddress = IPAddress::MakeIPv6PrefixMulticast(lScope, lPrefixLength, lPrefix, lGroup);
 
-            CheckAddress(inSuite, *lCurrent, lAddress);
+            CheckAddress(*lCurrent, lAddress);
 
             ++lCurrent;
         }
@@ -1720,11 +1695,10 @@
 /**
  *  Test IPPrefix.
  */
-void CheckIPPrefix(nlTestSuite * inSuite, void * inContext)
+TEST_F(TestInetAddress, TestCheckIPPrefix)
 {
-    const struct TestContext * lContext       = static_cast<const struct TestContext *>(inContext);
-    IPAddressExpandedContextIterator lCurrent = lContext->mIPAddressExpandedContextRange.mBegin;
-    IPAddressExpandedContextIterator lEnd     = lContext->mIPAddressExpandedContextRange.mEnd;
+    IPAddressExpandedContextIterator lCurrent = pTestContext->mIPAddressExpandedContextRange.mBegin;
+    IPAddressExpandedContextIterator lEnd     = pTestContext->mIPAddressExpandedContextRange.mEnd;
     size_t i                                  = 0;
 
     while (lCurrent != lEnd)
@@ -1738,12 +1712,12 @@
         ipprefix_1.Length = static_cast<uint8_t>(128 - (i++ % 128));
         ipprefix_2        = ipprefix_1;
 
-        NL_TEST_ASSERT(inSuite, !ipprefix_1.IsZero());
-        NL_TEST_ASSERT(inSuite, !ipprefix_2.IsZero());
-        NL_TEST_ASSERT(inSuite, ipprefix_1 == ipprefix_2);
-        NL_TEST_ASSERT(inSuite, !(ipprefix_1 != ipprefix_2));
+        EXPECT_FALSE(ipprefix_1.IsZero());
+        EXPECT_FALSE(ipprefix_2.IsZero());
+        EXPECT_EQ(ipprefix_1, ipprefix_2);
+        EXPECT_FALSE(ipprefix_1 != ipprefix_2);
 #if !CHIP_SYSTEM_CONFIG_USE_LWIP
-        NL_TEST_ASSERT(inSuite, ipprefix_1.MatchAddress(test_addr_1));
+        EXPECT_TRUE(ipprefix_1.MatchAddress(test_addr_1));
 #endif
         ++lCurrent;
     }
@@ -1774,11 +1748,10 @@
 /**
  * Test ToLwIPAddress()
  */
-void CheckToLwIPAddr(nlTestSuite * inSuite, void * inContext)
+TEST_F(TestInetAddress, TestCheckToLwIPAddr)
 {
-    const struct TestContext * lContext       = static_cast<const struct TestContext *>(inContext);
-    IPAddressExpandedContextIterator lCurrent = lContext->mIPAddressExpandedContextRange.mBegin;
-    IPAddressExpandedContextIterator lEnd     = lContext->mIPAddressExpandedContextRange.mEnd;
+    IPAddressExpandedContextIterator lCurrent = pTestContext->mIPAddressExpandedContextRange.mBegin;
+    IPAddressExpandedContextIterator lEnd     = pTestContext->mIPAddressExpandedContextRange.mEnd;
     CHIP_ERROR err;
     ip_addr_t lwip_expected_addr, lwip_check_addr;
 
@@ -1793,18 +1766,18 @@
         {
             ip_addr_copy_from_ip4(lwip_expected_addr, test_addr.ToIPv4());
             lwip_check_addr = test_addr.ToLwIPAddr();
-            NL_TEST_ASSERT(inSuite, sameLwIPAddress(lwip_expected_addr, lwip_check_addr));
+            EXPECT_TRUE(sameLwIPAddress(lwip_expected_addr, lwip_check_addr));
 
             err = test_addr.ToLwIPAddr(IPAddressType::kAny, lwip_check_addr);
-            NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
-            NL_TEST_ASSERT(inSuite, sameLwIPAddress(lwip_expected_addr, lwip_check_addr));
+            EXPECT_EQ(err, CHIP_NO_ERROR);
+            EXPECT_TRUE(sameLwIPAddress(lwip_expected_addr, lwip_check_addr));
 
             err = test_addr.ToLwIPAddr(IPAddressType::kIPv4, lwip_check_addr);
-            NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
-            NL_TEST_ASSERT(inSuite, sameLwIPAddress(lwip_expected_addr, lwip_check_addr));
+            EXPECT_EQ(err, CHIP_NO_ERROR);
+            EXPECT_TRUE(sameLwIPAddress(lwip_expected_addr, lwip_check_addr));
 
             err = test_addr.ToLwIPAddr(IPAddressType::kIPv6, lwip_check_addr);
-            NL_TEST_ASSERT(inSuite, err == INET_ERROR_WRONG_ADDRESS_TYPE);
+            EXPECT_EQ(err, INET_ERROR_WRONG_ADDRESS_TYPE);
         }
         else
 #endif // INET_CONFIG_ENABLE_IPV4
@@ -1812,38 +1785,38 @@
             {
                 ip_addr_copy_from_ip6(lwip_expected_addr, test_addr.ToIPv6());
                 lwip_check_addr = test_addr.ToLwIPAddr();
-                NL_TEST_ASSERT(inSuite, sameLwIPAddress(lwip_expected_addr, lwip_check_addr));
+                EXPECT_TRUE(sameLwIPAddress(lwip_expected_addr, lwip_check_addr));
 
                 err = test_addr.ToLwIPAddr(IPAddressType::kAny, lwip_check_addr);
-                NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
-                NL_TEST_ASSERT(inSuite, sameLwIPAddress(lwip_expected_addr, lwip_check_addr));
+                EXPECT_EQ(err, CHIP_NO_ERROR);
+                EXPECT_TRUE(sameLwIPAddress(lwip_expected_addr, lwip_check_addr));
 
                 err = test_addr.ToLwIPAddr(IPAddressType::kIPv6, lwip_check_addr);
-                NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
-                NL_TEST_ASSERT(inSuite, sameLwIPAddress(lwip_expected_addr, lwip_check_addr));
+                EXPECT_EQ(err, CHIP_NO_ERROR);
+                EXPECT_TRUE(sameLwIPAddress(lwip_expected_addr, lwip_check_addr));
 
 #if INET_CONFIG_ENABLE_IPV4
                 err = test_addr.ToLwIPAddr(IPAddressType::kIPv4, lwip_check_addr);
-                NL_TEST_ASSERT(inSuite, err == INET_ERROR_WRONG_ADDRESS_TYPE);
+                EXPECT_EQ(err, INET_ERROR_WRONG_ADDRESS_TYPE);
 #endif // INET_CONFIG_ENABLE_IPV4
             }
             else if (lCurrent->mAddr.mAddrType == IPAddressType::kAny)
             {
                 lwip_check_addr = test_addr.ToLwIPAddr();
-                NL_TEST_ASSERT(inSuite, sameLwIPAddress(*IP6_ADDR_ANY, lwip_check_addr));
+                EXPECT_TRUE(sameLwIPAddress(*IP6_ADDR_ANY, lwip_check_addr));
 
                 err = test_addr.ToLwIPAddr(IPAddressType::kAny, lwip_check_addr);
-                NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
-                NL_TEST_ASSERT(inSuite, sameLwIPAddress(*IP6_ADDR_ANY, lwip_check_addr));
+                EXPECT_EQ(err, CHIP_NO_ERROR);
+                EXPECT_TRUE(sameLwIPAddress(*IP6_ADDR_ANY, lwip_check_addr));
 
                 err = test_addr.ToLwIPAddr(IPAddressType::kIPv6, lwip_check_addr);
-                NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
-                NL_TEST_ASSERT(inSuite, sameLwIPAddress(*IP6_ADDR_ANY, lwip_check_addr));
+                EXPECT_EQ(err, CHIP_NO_ERROR);
+                EXPECT_TRUE(sameLwIPAddress(*IP6_ADDR_ANY, lwip_check_addr));
 
 #if INET_CONFIG_ENABLE_IPV4
                 err = test_addr.ToLwIPAddr(IPAddressType::kIPv4, lwip_check_addr);
-                NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
-                NL_TEST_ASSERT(inSuite, sameLwIPAddress(*IP4_ADDR_ANY, lwip_check_addr));
+                EXPECT_EQ(err, CHIP_NO_ERROR);
+                EXPECT_TRUE(sameLwIPAddress(*IP4_ADDR_ANY, lwip_check_addr));
 #endif // INET_CONFIG_ENABLE_IPV4
             }
 
@@ -1852,86 +1825,4 @@
 }
 #endif // CHIP_SYSTEM_CONFIG_USE_LWIP
 
-/**
- *   Test Suite. It lists all the test functions.
- */
-
-// clang-format off
-const nlTest sTests[] =
-{
-    NL_TEST_DEF("Address Type",                                CheckType),
-    NL_TEST_DEF("Any Address Global",                          CheckAnyAddress),
-    NL_TEST_DEF("Address Encoding (Writing)",                  CheckEncoding),
-    NL_TEST_DEF("Address Decoding (Reading)",                  CheckDecoding),
-    NL_TEST_DEF("Address Encode / Decode Symmetricity",        CheckEcodeDecodeSymmetricity),
-    NL_TEST_DEF("From String Conversion",                      CheckFromString),
-    NL_TEST_DEF("To String Conversion",                        CheckToString),
-#if INET_CONFIG_ENABLE_IPV4
-    NL_TEST_DEF("IPv4 Detection",                              CheckIsIPv4),
-    NL_TEST_DEF("IPv4 Multicast Detection",                    CheckIsIPv4Multicast),
-    NL_TEST_DEF("IPv4 Broadcast Detection",                    CheckIsIPv4Broadcast),
-    NL_TEST_DEF("Convert IPv4 to IPAddress",                   CheckFromIPv4),
-    NL_TEST_DEF("Convert IPAddress to IPv4",                   CheckToIPv4),
-#endif // INET_CONFIG_ENABLE_IPV4
-    NL_TEST_DEF("IPv6 ULA Detection",                          CheckIsIPv6ULA),
-    NL_TEST_DEF("IPv6 Link Local Detection",                   CheckIsIPv6LLA),
-    NL_TEST_DEF("IPv6 Multicast Detection",                    CheckIsIPv6Multicast),
-    NL_TEST_DEF("Multicast Detection",                         CheckIsMulticast),
-    NL_TEST_DEF("Equivalence Operator",                        CheckOperatorEqual),
-    NL_TEST_DEF("Non-Equivalence Operator",                    CheckOperatorNotEqual),
-    NL_TEST_DEF("Assign Operator",                             CheckOperatorAssign),
-    NL_TEST_DEF("Convert IPv6 to IPAddress",                   CheckFromIPv6),
-    NL_TEST_DEF("Convert IPAddress to IPv6",                   CheckToIPv6),
-    NL_TEST_DEF("Assign address from socket",                  CheckFromSocket),
-    NL_TEST_DEF("Address Interface ID",                        CheckInterface),
-    NL_TEST_DEF("Address Subnet",                              CheckSubnet),
-    NL_TEST_DEF("Address Global ID",                           CheckGlobal),
-    NL_TEST_DEF("Assemble IPv6 ULA address",                   CheckMakeULA),
-    NL_TEST_DEF("Assemble IPv6 LLA address",                   CheckMakeLLA),
-    NL_TEST_DEF("Assemble IPv6 Well-known Multicast address",  CheckMakeIPv6WellKnownMulticast),
-    NL_TEST_DEF("Assemble IPv6 Transient Multicast address",   CheckMakeIPv6TransientMulticast),
-    NL_TEST_DEF("Assemble IPv6 Prefix Multicast address",      CheckMakeIPv6PrefixMulticast),
-    NL_TEST_DEF("IPPrefix test",                               CheckIPPrefix),
-#if CHIP_SYSTEM_CONFIG_USE_LWIP
-    NL_TEST_DEF("Convert IPAddress to LwIP address",           CheckToLwIPAddr),
-#endif
-    NL_TEST_SENTINEL()
-};
-// clang-format on
-
-/**
- *  Set up the test suite.
- */
-int TestSetup(void * inContext)
-{
-    return (SUCCESS);
-}
-
-/**
- *  Tear down the test suite.
- */
-int TestTeardown(void * inContext)
-{
-    return (SUCCESS);
-}
-
 } // namespace
-
-int TestInetAddress()
-{
-    // clang-format off
-    nlTestSuite theSuite = {
-        "inet-address",
-        &sTests[0],
-        TestSetup,
-        TestTeardown
-    };
-    // clang-format on
-
-    // Run test suite against one context.
-    nlTestRunner(&theSuite, const_cast<TestContext *>(&sTestContext));
-
-    return (nlTestRunnerStats(&theSuite));
-}
-
-CHIP_REGISTER_TEST_SUITE(TestInetAddress)
diff --git a/src/inet/tests/TestInetEndPoint.cpp b/src/inet/tests/TestInetEndPoint.cpp
index f168438..3e6f613 100644
--- a/src/inet/tests/TestInetEndPoint.cpp
+++ b/src/inet/tests/TestInetEndPoint.cpp
@@ -29,21 +29,16 @@
 #include <stdint.h>
 #include <string.h>
 
-#include <CHIPVersion.h>
+#include <gtest/gtest.h>
 
+#include <CHIPVersion.h>
 #include <inet/IPPrefix.h>
 #include <inet/InetError.h>
-
 #include <lib/support/CHIPArgParser.hpp>
 #include <lib/support/CHIPMem.h>
 #include <lib/support/CodeUtils.h>
-#include <lib/support/UnitTestContext.h>
-#include <lib/support/UnitTestRegistration.h>
-
 #include <system/SystemError.h>
 
-#include <nlunit-test.h>
-
 #include "TestInetCommon.h"
 #include "TestSetupSignalling.h"
 
@@ -75,8 +70,24 @@
     printf("    timer handler\n");
 }
 
+class TestInetEndPoint : public ::testing::Test
+{
+public:
+    static void SetUpTestSuite()
+    {
+        SetSIGUSR1Handler();
+        ASSERT_EQ(chip::Platform::MemoryInit(), CHIP_NO_ERROR);
+    }
+    static void TearDownTestSuite()
+    {
+        ShutdownNetwork();
+        ShutdownSystemLayer();
+        chip::Platform::MemoryShutdown();
+    }
+};
+
 // Test before init network, Inet is not initialized
-static void TestInetPre(nlTestSuite * inSuite, void * inContext)
+TEST_F(TestInetEndPoint, TestInetPre)
 {
 #if INET_CONFIG_ENABLE_UDP_ENDPOINT
     UDPEndPoint * testUDPEP = nullptr;
@@ -95,32 +106,32 @@
 
 #if INET_CONFIG_ENABLE_UDP_ENDPOINT
     err = gUDP.NewEndPoint(&testUDPEP);
-    NL_TEST_ASSERT(inSuite, err == CHIP_ERROR_INCORRECT_STATE);
+    EXPECT_EQ(err, CHIP_ERROR_INCORRECT_STATE);
 #endif // INET_CONFIG_ENABLE_UDP_ENDPOINT
 
 #if INET_CONFIG_ENABLE_TCP_ENDPOINT
     err = gTCP.NewEndPoint(&testTCPEP);
-    NL_TEST_ASSERT(inSuite, err == CHIP_ERROR_INCORRECT_STATE);
+    EXPECT_EQ(err, CHIP_ERROR_INCORRECT_STATE);
 #endif // INET_CONFIG_ENABLE_TCP_ENDPOINT
 
     err = gSystemLayer.StartTimer(10_ms32, HandleTimer, nullptr);
-    NL_TEST_ASSERT(inSuite, err == CHIP_ERROR_INCORRECT_STATE);
+    EXPECT_EQ(err, CHIP_ERROR_INCORRECT_STATE);
 
     // then init network
     InitSystemLayer();
     InitNetwork();
 }
 
-static void TestInetError(nlTestSuite * inSuite, void * inContext)
+TEST_F(TestInetEndPoint, TestInetError)
 {
     CHIP_ERROR err = CHIP_NO_ERROR;
 
     err = CHIP_ERROR_POSIX(EPERM);
-    NL_TEST_ASSERT(inSuite, DescribeErrorPOSIX(err));
-    NL_TEST_ASSERT(inSuite, err.IsRange(ChipError::Range::kPOSIX));
+    EXPECT_TRUE(DescribeErrorPOSIX(err));
+    EXPECT_TRUE(err.IsRange(ChipError::Range::kPOSIX));
 }
 
-static void TestInetInterface(nlTestSuite * inSuite, void * inContext)
+TEST_F(TestInetEndPoint, TestInetInterface)
 {
     InterfaceIterator intIterator;
     InterfaceAddressIterator addrIterator;
@@ -138,29 +149,30 @@
 #ifndef __MBED__
     // Mbed interface name has different format
     err = InterfaceId::InterfaceNameToId("0", intId);
-    NL_TEST_ASSERT(inSuite, err != CHIP_NO_ERROR);
+    EXPECT_NE(err, CHIP_NO_ERROR);
 #endif
 
     err = InterfaceId::Null().GetInterfaceName(intName, 0);
-    NL_TEST_ASSERT(inSuite, err == CHIP_ERROR_BUFFER_TOO_SMALL);
+    EXPECT_EQ(err, CHIP_ERROR_BUFFER_TOO_SMALL);
 
     err = InterfaceId::Null().GetInterfaceName(intName, sizeof(intName));
-    NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR && intName[0] == '\0');
+    EXPECT_EQ(err, CHIP_NO_ERROR);
+    EXPECT_EQ(intName[0], '\0');
 
     intId = InterfaceId::FromIPAddress(addr);
-    NL_TEST_ASSERT(inSuite, !intId.IsPresent());
+    EXPECT_FALSE(intId.IsPresent());
 
     err = intId.GetLinkLocalAddr(nullptr);
-    NL_TEST_ASSERT(inSuite, err == CHIP_ERROR_INVALID_ARGUMENT);
+    EXPECT_EQ(err, CHIP_ERROR_INVALID_ARGUMENT);
 
     printf("    Interfaces:\n");
     for (; intIterator.HasCurrent(); intIterator.Next())
     {
         intId = intIterator.GetInterfaceId();
-        NL_TEST_ASSERT(inSuite, intId.IsPresent());
+        EXPECT_TRUE(intId.IsPresent());
         memset(intName, 42, sizeof(intName));
         err = intIterator.GetInterfaceName(intName, sizeof(intName));
-        NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
+        EXPECT_EQ(err, CHIP_NO_ERROR);
         printf("     interface id: 0x%" PRIxPTR ", interface name: %s, interface state: %s, %s multicast, %s broadcast addr\n",
 #if CHIP_SYSTEM_CONFIG_USE_LWIP
                reinterpret_cast<uintptr_t>(intId.GetPlatformInterface()),
@@ -175,47 +187,44 @@
 
         // Not all platforms support getting interface type and hardware address
         err = intIterator.GetInterfaceType(intType);
-        NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR || err == CHIP_ERROR_NOT_IMPLEMENTED);
+        EXPECT_TRUE(err == CHIP_NO_ERROR || err == CHIP_ERROR_NOT_IMPLEMENTED);
 
         err = intIterator.GetHardwareAddress(intHwAddress, intHwAddressSize, sizeof(intHwAddress));
-        NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR || err == CHIP_ERROR_NOT_IMPLEMENTED);
+        EXPECT_TRUE(err == CHIP_NO_ERROR || err == CHIP_ERROR_NOT_IMPLEMENTED);
         if (err == CHIP_NO_ERROR)
         {
-            NL_TEST_ASSERT(inSuite, intHwAddressSize == 6 || intHwAddressSize == 8);
-            NL_TEST_ASSERT(inSuite,
-                           intIterator.GetHardwareAddress(nullptr, intHwAddressSize, sizeof(intHwAddress)) ==
-                               CHIP_ERROR_INVALID_ARGUMENT);
-            NL_TEST_ASSERT(inSuite,
-                           intIterator.GetHardwareAddress(intHwAddress, intHwAddressSize, 4) == CHIP_ERROR_BUFFER_TOO_SMALL);
+            EXPECT_TRUE(intHwAddressSize == 6 || intHwAddressSize == 8);
+            EXPECT_EQ(intIterator.GetHardwareAddress(nullptr, intHwAddressSize, sizeof(intHwAddress)), CHIP_ERROR_INVALID_ARGUMENT);
+            EXPECT_EQ(intIterator.GetHardwareAddress(intHwAddress, intHwAddressSize, 4), CHIP_ERROR_BUFFER_TOO_SMALL);
         }
     }
 
-    NL_TEST_ASSERT(inSuite, !intIterator.Next());
-    NL_TEST_ASSERT(inSuite, intIterator.GetInterfaceId() == InterfaceId::Null());
-    NL_TEST_ASSERT(inSuite, intIterator.GetInterfaceName(intName, sizeof(intName)) == CHIP_ERROR_INCORRECT_STATE);
-    NL_TEST_ASSERT(inSuite, !intIterator.SupportsMulticast());
-    NL_TEST_ASSERT(inSuite, !intIterator.HasBroadcastAddress());
+    EXPECT_FALSE(intIterator.Next());
+    EXPECT_EQ(intIterator.GetInterfaceId(), InterfaceId::Null());
+    EXPECT_EQ(intIterator.GetInterfaceName(intName, sizeof(intName)), CHIP_ERROR_INCORRECT_STATE);
+    EXPECT_FALSE(intIterator.SupportsMulticast());
+    EXPECT_FALSE(intIterator.HasBroadcastAddress());
 
     // Not all platforms support getting interface type and hardware address
     err = intIterator.GetInterfaceType(intType);
-    NL_TEST_ASSERT(inSuite, err == CHIP_ERROR_INCORRECT_STATE || err == CHIP_ERROR_NOT_IMPLEMENTED);
+    EXPECT_TRUE(err == CHIP_ERROR_INCORRECT_STATE || err == CHIP_ERROR_NOT_IMPLEMENTED);
     err = intIterator.GetHardwareAddress(intHwAddress, intHwAddressSize, sizeof(intHwAddress));
-    NL_TEST_ASSERT(inSuite, err == CHIP_ERROR_INCORRECT_STATE || err == CHIP_ERROR_NOT_IMPLEMENTED);
+    EXPECT_TRUE(err == CHIP_ERROR_INCORRECT_STATE || err == CHIP_ERROR_NOT_IMPLEMENTED);
 
     printf("    Addresses:\n");
     for (; addrIterator.HasCurrent(); addrIterator.Next())
     {
         err = addrIterator.GetAddress(addr);
-        NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
+        EXPECT_EQ(err, CHIP_NO_ERROR);
         IPPrefix addrWithPrefix(addr, addrIterator.GetPrefixLength());
         char addrStr[80];
         addrWithPrefix.IPAddr.ToString(addrStr);
         intId = addrIterator.GetInterfaceId();
-        NL_TEST_ASSERT(inSuite, intId.IsPresent());
+        EXPECT_TRUE(intId.IsPresent());
         memset(intName, 42, sizeof(intName));
         err = addrIterator.GetInterfaceName(intName, sizeof(intName));
-        NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
-        NL_TEST_ASSERT(inSuite, intName[0] != '\0' && memchr(intName, '\0', sizeof(intName)) != nullptr);
+        EXPECT_EQ(err, CHIP_NO_ERROR);
+        EXPECT_TRUE(intName[0] != '\0' && memchr(intName, '\0', sizeof(intName)) != nullptr);
         printf("     %s/%d, interface id: 0x%" PRIxPTR
                ", interface name: %s, interface state: %s, %s multicast, %s broadcast addr\n",
                addrStr, addrWithPrefix.Length,
@@ -227,15 +236,15 @@
                intName, addrIterator.IsUp() ? "UP" : "DOWN", addrIterator.SupportsMulticast() ? "supports" : "no",
                addrIterator.HasBroadcastAddress() ? "has" : "no");
     }
-    NL_TEST_ASSERT(inSuite, !addrIterator.Next());
-    NL_TEST_ASSERT(inSuite, addrIterator.GetAddress(addr) == CHIP_ERROR_SENTINEL);
-    NL_TEST_ASSERT(inSuite, addrIterator.GetInterfaceId() == InterfaceId::Null());
-    NL_TEST_ASSERT(inSuite, addrIterator.GetInterfaceName(intName, sizeof(intName)) == CHIP_ERROR_INCORRECT_STATE);
-    NL_TEST_ASSERT(inSuite, !addrIterator.SupportsMulticast());
-    NL_TEST_ASSERT(inSuite, !addrIterator.HasBroadcastAddress());
+    EXPECT_FALSE(addrIterator.Next());
+    EXPECT_EQ(addrIterator.GetAddress(addr), CHIP_ERROR_SENTINEL);
+    EXPECT_EQ(addrIterator.GetInterfaceId(), InterfaceId::Null());
+    EXPECT_EQ(addrIterator.GetInterfaceName(intName, sizeof(intName)), CHIP_ERROR_INCORRECT_STATE);
+    EXPECT_FALSE(addrIterator.SupportsMulticast());
+    EXPECT_FALSE(addrIterator.HasBroadcastAddress());
 }
 
-static void TestInetEndPointInternal(nlTestSuite * inSuite, void * inContext)
+TEST_F(TestInetEndPoint, TestInetEndPointInternal)
 {
     CHIP_ERROR err;
     IPAddress addr_any = IPAddress::Any;
@@ -253,113 +262,110 @@
     // init all the EndPoints
     SYSTEM_STATS_RESET(System::Stats::kInetLayer_NumUDPEps);
     err = gUDP.NewEndPoint(&testUDPEP);
-    NL_TEST_EXIT_ON_FAILED_ASSERT(inSuite, err == CHIP_NO_ERROR);
-    NL_TEST_ASSERT(inSuite, SYSTEM_STATS_TEST_IN_USE(System::Stats::kInetLayer_NumUDPEps, 1));
+    ASSERT_EQ(err, CHIP_NO_ERROR);
+    EXPECT_TRUE(SYSTEM_STATS_TEST_IN_USE(System::Stats::kInetLayer_NumUDPEps, 1));
 
     SYSTEM_STATS_RESET(System::Stats::kInetLayer_NumTCPEps);
     err = gTCP.NewEndPoint(&testTCPEP1);
-    NL_TEST_EXIT_ON_FAILED_ASSERT(inSuite, err == CHIP_NO_ERROR);
-    NL_TEST_ASSERT(inSuite, SYSTEM_STATS_TEST_IN_USE(System::Stats::kInetLayer_NumUDPEps, 1));
+    ASSERT_EQ(err, CHIP_NO_ERROR);
+    EXPECT_TRUE(SYSTEM_STATS_TEST_IN_USE(System::Stats::kInetLayer_NumUDPEps, 1));
 
     err = InterfaceId::Null().GetLinkLocalAddr(&addr);
 
     // We should skip the following checks if the interface does not have the Link local address
-    if (err == INET_ERROR_ADDRESS_NOT_FOUND)
-    {
-        return;
-    }
+    ASSERT_NE(err, INET_ERROR_ADDRESS_NOT_FOUND);
 
-    NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
+    EXPECT_EQ(err, CHIP_NO_ERROR);
     intId = InterfaceId::FromIPAddress(addr);
-    NL_TEST_ASSERT(inSuite, intId.IsPresent());
+    EXPECT_TRUE(intId.IsPresent());
 
 #if INET_CONFIG_ENABLE_IPV4
-    NL_TEST_ASSERT(inSuite, IPAddress::FromString("10.0.0.1", addr_v4));
+    EXPECT_TRUE(IPAddress::FromString("10.0.0.1", addr_v4));
 #endif // INET_CONFIG_ENABLE_IPV4
 
     // UdpEndPoint special cases to cover the error branch
     err = testUDPEP->Listen(nullptr /*OnMessageReceived*/, nullptr /*OnReceiveError*/);
-    NL_TEST_ASSERT(inSuite, err == CHIP_ERROR_INCORRECT_STATE);
+    EXPECT_EQ(err, CHIP_ERROR_INCORRECT_STATE);
     err = testUDPEP->Bind(IPAddressType::kUnknown, addr_any, 3000);
-    NL_TEST_ASSERT(inSuite, err == INET_ERROR_WRONG_ADDRESS_TYPE);
+    EXPECT_EQ(err, INET_ERROR_WRONG_ADDRESS_TYPE);
     err = testUDPEP->Bind(IPAddressType::kUnknown, addr, 3000);
-    NL_TEST_ASSERT(inSuite, err == INET_ERROR_WRONG_ADDRESS_TYPE);
+    EXPECT_EQ(err, INET_ERROR_WRONG_ADDRESS_TYPE);
 #if INET_CONFIG_ENABLE_IPV4
     err = testUDPEP->Bind(IPAddressType::kIPv4, addr, 3000);
-    NL_TEST_ASSERT(inSuite, err == INET_ERROR_WRONG_ADDRESS_TYPE);
+    EXPECT_EQ(err, INET_ERROR_WRONG_ADDRESS_TYPE);
 #endif // INET_CONFIG_ENABLE_IPV4
 
     err            = testUDPEP->Bind(IPAddressType::kIPv6, addr, 3000, intId);
     err            = testUDPEP->BindInterface(IPAddressType::kIPv6, intId);
     InterfaceId id = testUDPEP->GetBoundInterface();
-    NL_TEST_ASSERT(inSuite, id == intId);
+    EXPECT_EQ(id, intId);
 
     err = testUDPEP->Listen(nullptr /*OnMessageReceived*/, nullptr /*OnReceiveError*/);
     err = testUDPEP->Listen(nullptr /*OnMessageReceived*/, nullptr /*OnReceiveError*/);
     err = testUDPEP->Bind(IPAddressType::kIPv6, addr, 3000, intId);
-    NL_TEST_ASSERT(inSuite, err == CHIP_ERROR_INCORRECT_STATE);
+    EXPECT_EQ(err, CHIP_ERROR_INCORRECT_STATE);
     err = testUDPEP->BindInterface(IPAddressType::kIPv6, intId);
-    NL_TEST_ASSERT(inSuite, err == CHIP_ERROR_INCORRECT_STATE);
+    EXPECT_EQ(err, CHIP_ERROR_INCORRECT_STATE);
     testUDPEP->Free();
-    NL_TEST_ASSERT(inSuite, SYSTEM_STATS_TEST_IN_USE(System::Stats::kInetLayer_NumUDPEps, 0));
-    NL_TEST_ASSERT(inSuite, SYSTEM_STATS_TEST_HIGH_WATER_MARK(System::Stats::kInetLayer_NumUDPEps, 1));
+    EXPECT_TRUE(SYSTEM_STATS_TEST_IN_USE(System::Stats::kInetLayer_NumUDPEps, 0));
+    EXPECT_TRUE(SYSTEM_STATS_TEST_HIGH_WATER_MARK(System::Stats::kInetLayer_NumUDPEps, 1));
 
     err = gUDP.NewEndPoint(&testUDPEP);
-    NL_TEST_EXIT_ON_FAILED_ASSERT(inSuite, err == CHIP_NO_ERROR);
-    NL_TEST_ASSERT(inSuite, SYSTEM_STATS_TEST_IN_USE(System::Stats::kInetLayer_NumUDPEps, 1));
+    ASSERT_EQ(err, CHIP_NO_ERROR);
+    EXPECT_TRUE(SYSTEM_STATS_TEST_IN_USE(System::Stats::kInetLayer_NumUDPEps, 1));
 #if INET_CONFIG_ENABLE_IPV4
     err = testUDPEP->Bind(IPAddressType::kIPv4, addr_v4, 3000, intId);
-    NL_TEST_ASSERT(inSuite, err != CHIP_NO_ERROR);
+    EXPECT_NE(err, CHIP_NO_ERROR);
     buf = PacketBufferHandle::New(PacketBuffer::kMaxSize);
     err = testUDPEP->SendTo(addr_v4, 3000, std::move(buf));
 #endif // INET_CONFIG_ENABLE_IPV4
     testUDPEP->Free();
-    NL_TEST_ASSERT(inSuite, SYSTEM_STATS_TEST_IN_USE(System::Stats::kInetLayer_NumUDPEps, 0));
+    EXPECT_TRUE(SYSTEM_STATS_TEST_IN_USE(System::Stats::kInetLayer_NumUDPEps, 0));
 
     // TcpEndPoint special cases to cover the error branch
     err = testTCPEP1->GetPeerInfo(nullptr, nullptr);
-    NL_TEST_ASSERT(inSuite, err == CHIP_ERROR_INCORRECT_STATE);
+    EXPECT_EQ(err, CHIP_ERROR_INCORRECT_STATE);
     buf = PacketBufferHandle::New(PacketBuffer::kMaxSize);
     err = testTCPEP1->Send(std::move(buf), false);
-    NL_TEST_ASSERT(inSuite, err == CHIP_ERROR_INCORRECT_STATE);
+    EXPECT_EQ(err, CHIP_ERROR_INCORRECT_STATE);
     err = testTCPEP1->EnableKeepAlive(10, 100);
-    NL_TEST_ASSERT(inSuite, err == CHIP_ERROR_INCORRECT_STATE);
+    EXPECT_EQ(err, CHIP_ERROR_INCORRECT_STATE);
     err = testTCPEP1->DisableKeepAlive();
-    NL_TEST_ASSERT(inSuite, err == CHIP_ERROR_INCORRECT_STATE);
+    EXPECT_EQ(err, CHIP_ERROR_INCORRECT_STATE);
     err = testTCPEP1->AckReceive(10);
-    NL_TEST_ASSERT(inSuite, err == CHIP_ERROR_INCORRECT_STATE);
-    NL_TEST_ASSERT(inSuite, !testTCPEP1->PendingReceiveLength());
+    EXPECT_EQ(err, CHIP_ERROR_INCORRECT_STATE);
+    EXPECT_FALSE(testTCPEP1->PendingReceiveLength());
     err = testTCPEP1->Listen(4);
-    NL_TEST_ASSERT(inSuite, err == CHIP_ERROR_INCORRECT_STATE);
+    EXPECT_EQ(err, CHIP_ERROR_INCORRECT_STATE);
     err = testTCPEP1->GetLocalInfo(nullptr, nullptr);
-    NL_TEST_ASSERT(inSuite, err == CHIP_ERROR_INCORRECT_STATE);
+    EXPECT_EQ(err, CHIP_ERROR_INCORRECT_STATE);
 
     err = testTCPEP1->Bind(IPAddressType::kUnknown, addr_any, 3000, true);
-    NL_TEST_ASSERT(inSuite, err == INET_ERROR_WRONG_ADDRESS_TYPE);
+    EXPECT_EQ(err, INET_ERROR_WRONG_ADDRESS_TYPE);
 #if INET_CONFIG_ENABLE_IPV4
     err = testTCPEP1->Bind(IPAddressType::kIPv4, addr, 3000, true);
-    NL_TEST_ASSERT(inSuite, err == INET_ERROR_WRONG_ADDRESS_TYPE);
+    EXPECT_EQ(err, INET_ERROR_WRONG_ADDRESS_TYPE);
 #endif // INET_CONFIG_ENABLE_IPV4
     err = testTCPEP1->Bind(IPAddressType::kUnknown, addr, 3000, true);
-    NL_TEST_ASSERT(inSuite, err == INET_ERROR_WRONG_ADDRESS_TYPE);
+    EXPECT_EQ(err, INET_ERROR_WRONG_ADDRESS_TYPE);
 
     err = testTCPEP1->Bind(IPAddressType::kIPv6, addr_any, 3000, true);
     err = testTCPEP1->Bind(IPAddressType::kIPv6, addr_any, 3000, true);
-    NL_TEST_ASSERT(inSuite, err == CHIP_ERROR_INCORRECT_STATE);
+    EXPECT_EQ(err, CHIP_ERROR_INCORRECT_STATE);
     err = testTCPEP1->Listen(4);
 #if INET_CONFIG_ENABLE_IPV4
     err = testTCPEP1->Connect(addr_v4, 4000, intId);
-    NL_TEST_ASSERT(inSuite, err == CHIP_ERROR_INCORRECT_STATE);
+    EXPECT_EQ(err, CHIP_ERROR_INCORRECT_STATE);
 #endif // INET_CONFIG_ENABLE_IPV4
 
     testTCPEP1->Free();
-    NL_TEST_ASSERT(inSuite, SYSTEM_STATS_TEST_IN_USE(System::Stats::kInetLayer_NumTCPEps, 0));
-    NL_TEST_ASSERT(inSuite, SYSTEM_STATS_TEST_HIGH_WATER_MARK(System::Stats::kInetLayer_NumTCPEps, 1));
+    EXPECT_TRUE(SYSTEM_STATS_TEST_IN_USE(System::Stats::kInetLayer_NumTCPEps, 0));
+    EXPECT_TRUE(SYSTEM_STATS_TEST_HIGH_WATER_MARK(System::Stats::kInetLayer_NumTCPEps, 1));
 }
 
 #if !CHIP_SYSTEM_CONFIG_POOL_USE_HEAP
 // Test the Inet resource limitations.
-static void TestInetEndPointLimit(nlTestSuite * inSuite, void * inContext)
+TEST_F(TestInetEndPoint, TestInetEndPointLimit)
 {
     UDPEndPoint * testUDPEP[INET_CONFIG_NUM_UDP_ENDPOINTS + 1] = { nullptr };
     TCPEndPoint * testTCPEP[INET_CONFIG_NUM_TCP_ENDPOINTS + 1] = { nullptr };
@@ -371,43 +377,43 @@
     for (int i = INET_CONFIG_NUM_UDP_ENDPOINTS; i >= 0; --i)
     {
         err = gUDP.NewEndPoint(&testUDPEP[i]);
-        NL_TEST_ASSERT(inSuite, err == (i ? CHIP_NO_ERROR : CHIP_ERROR_ENDPOINT_POOL_FULL));
+        EXPECT_EQ(err, (i ? CHIP_NO_ERROR : CHIP_ERROR_ENDPOINT_POOL_FULL));
         if (err == CHIP_NO_ERROR)
         {
             ++udpCount;
-            NL_TEST_ASSERT(inSuite, SYSTEM_STATS_TEST_IN_USE(System::Stats::kInetLayer_NumUDPEps, udpCount));
+            EXPECT_TRUE(SYSTEM_STATS_TEST_IN_USE(System::Stats::kInetLayer_NumUDPEps, udpCount));
         }
     }
     const int udpHighWaterMark = udpCount;
-    NL_TEST_ASSERT(inSuite, SYSTEM_STATS_TEST_HIGH_WATER_MARK(System::Stats::kInetLayer_NumUDPEps, udpHighWaterMark));
+    EXPECT_TRUE(SYSTEM_STATS_TEST_HIGH_WATER_MARK(System::Stats::kInetLayer_NumUDPEps, udpHighWaterMark));
 
     int tcpCount = 0;
     SYSTEM_STATS_RESET(System::Stats::kInetLayer_NumTCPEps);
     for (int i = INET_CONFIG_NUM_TCP_ENDPOINTS; i >= 0; --i)
     {
         err = gTCP.NewEndPoint(&testTCPEP[i]);
-        NL_TEST_ASSERT(inSuite, err == (i ? CHIP_NO_ERROR : CHIP_ERROR_ENDPOINT_POOL_FULL));
+        EXPECT_EQ(err, (i ? CHIP_NO_ERROR : CHIP_ERROR_ENDPOINT_POOL_FULL));
         if (err == CHIP_NO_ERROR)
         {
             ++tcpCount;
-            NL_TEST_ASSERT(inSuite, SYSTEM_STATS_TEST_IN_USE(System::Stats::kInetLayer_NumTCPEps, tcpCount));
+            EXPECT_TRUE(SYSTEM_STATS_TEST_IN_USE(System::Stats::kInetLayer_NumTCPEps, tcpCount));
         }
     }
     const int tcpHighWaterMark = tcpCount;
-    NL_TEST_ASSERT(inSuite, SYSTEM_STATS_TEST_HIGH_WATER_MARK(System::Stats::kInetLayer_NumTCPEps, tcpHighWaterMark));
+    EXPECT_TRUE(SYSTEM_STATS_TEST_HIGH_WATER_MARK(System::Stats::kInetLayer_NumTCPEps, tcpHighWaterMark));
 
 #if CHIP_SYSTEM_CONFIG_NUM_TIMERS
     // Verify same aComplete and aAppState args do not exhaust timer pool
     for (int i = 0; i < CHIP_SYSTEM_CONFIG_NUM_TIMERS + 1; i++)
     {
         err = gSystemLayer.StartTimer(10_ms32, HandleTimer, nullptr);
-        NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
+        EXPECT_EQ(err, CHIP_NO_ERROR);
     }
 
     char numTimersTest[CHIP_SYSTEM_CONFIG_NUM_TIMERS + 1];
     for (int i = 0; i < CHIP_SYSTEM_CONFIG_NUM_TIMERS + 1; i++)
         err = gSystemLayer.StartTimer(10_ms32, HandleTimer, &numTimersTest[i]);
-    NL_TEST_ASSERT(inSuite, err == CHIP_ERROR_NO_MEMORY);
+    EXPECT_EQ(err, CHIP_ERROR_NO_MEMORY);
 #endif // CHIP_SYSTEM_CONFIG_NUM_TIMERS
 
     // Release UDP endpoints
@@ -417,10 +423,10 @@
         {
             testUDPEP[i]->Free();
             --udpCount;
-            NL_TEST_ASSERT(inSuite, SYSTEM_STATS_TEST_IN_USE(System::Stats::kInetLayer_NumUDPEps, udpCount));
+            EXPECT_TRUE(SYSTEM_STATS_TEST_IN_USE(System::Stats::kInetLayer_NumUDPEps, udpCount));
         }
     }
-    NL_TEST_ASSERT(inSuite, SYSTEM_STATS_TEST_HIGH_WATER_MARK(System::Stats::kInetLayer_NumUDPEps, udpHighWaterMark));
+    EXPECT_TRUE(SYSTEM_STATS_TEST_HIGH_WATER_MARK(System::Stats::kInetLayer_NumUDPEps, udpHighWaterMark));
 
     // Release TCP endpoints
     for (int i = 0; i <= INET_CONFIG_NUM_TCP_ENDPOINTS; i++)
@@ -429,84 +435,12 @@
         {
             testTCPEP[i]->Free();
             --tcpCount;
-            NL_TEST_ASSERT(inSuite, SYSTEM_STATS_TEST_IN_USE(System::Stats::kInetLayer_NumTCPEps, tcpCount));
+            EXPECT_TRUE(SYSTEM_STATS_TEST_IN_USE(System::Stats::kInetLayer_NumTCPEps, tcpCount));
         }
     }
-    NL_TEST_ASSERT(inSuite, SYSTEM_STATS_TEST_HIGH_WATER_MARK(System::Stats::kInetLayer_NumTCPEps, tcpHighWaterMark));
+    EXPECT_TRUE(SYSTEM_STATS_TEST_HIGH_WATER_MARK(System::Stats::kInetLayer_NumTCPEps, tcpHighWaterMark));
 
     ShutdownNetwork();
     ShutdownSystemLayer();
 }
-#endif
-
-// Test Suite
-
-/**
- *   Test Suite. It lists all the test functions.
- */
-static const nlTest sTests[] = { NL_TEST_DEF("InetEndPoint::PreTest", TestInetPre),
-                                 NL_TEST_DEF("InetEndPoint::TestInetError", TestInetError),
-                                 NL_TEST_DEF("InetEndPoint::TestInetInterface", TestInetInterface),
-                                 NL_TEST_DEF("InetEndPoint::TestInetEndPoint", TestInetEndPointInternal),
-#if !CHIP_SYSTEM_CONFIG_POOL_USE_HEAP
-                                 NL_TEST_DEF("InetEndPoint::TestEndPointLimit", TestInetEndPointLimit),
-#endif
-                                 NL_TEST_SENTINEL() };
-
-#if CHIP_SYSTEM_CONFIG_USE_SOCKETS
-/**
- *  Set up the test suite.
- */
-static int TestSetup(void * inContext)
-{
-    CHIP_ERROR error = chip::Platform::MemoryInit();
-    if (error != CHIP_NO_ERROR)
-        return FAILURE;
-    return SUCCESS;
-}
-
-/**
- *  Tear down the test suite.
- */
-static int TestTeardown(void * inContext)
-{
-    ShutdownNetwork();
-    ShutdownSystemLayer();
-    chip::Platform::MemoryShutdown();
-    return SUCCESS;
-}
-#endif // CHIP_SYSTEM_CONFIG_USE_SOCKETS
-
-int TestInetEndPointInternal()
-{
-#if CHIP_SYSTEM_CONFIG_USE_SOCKETS
-    // clang-format off
-    nlTestSuite theSuite =
-    {
-        "inet-endpoint",
-        &sTests[0],
-        TestSetup,
-        TestTeardown
-    };
-    // clang-format on
-
-    // Run test suite against one context.
-    nlTestRunner(&theSuite, nullptr);
-
-    return nlTestRunnerStats(&theSuite);
-#else  // !CHIP_SYSTEM_CONFIG_USE_SOCKETS
-    return (0);
-#endif // !CHIP_SYSTEM_CONFIG_USE_SOCKETS
-}
-
-CHIP_REGISTER_TEST_SUITE(TestInetEndPointInternal)
-
-int TestInetEndPoint()
-{
-    SetSIGUSR1Handler();
-
-    // Generate machine-readable, comma-separated value (CSV) output.
-    nlTestSetOutputStyle(OUTPUT_CSV);
-
-    return (TestInetEndPointInternal());
-}
+#endif // !CHIP_SYSTEM_CONFIG_POOL_USE_HEAP
diff --git a/src/inet/tests/TestInetErrorStr.cpp b/src/inet/tests/TestInetErrorStr.cpp
index 5689267..8e92a04 100644
--- a/src/inet/tests/TestInetErrorStr.cpp
+++ b/src/inet/tests/TestInetErrorStr.cpp
@@ -28,12 +28,11 @@
 #include <stdint.h>
 #include <string.h>
 
+#include <gtest/gtest.h>
+
 #include <inet/InetError.h>
 #include <lib/core/ErrorStr.h>
 #include <lib/support/CodeUtils.h>
-#include <lib/support/UnitTestRegistration.h>
-
-#include <nlunit-test.h>
 
 using namespace chip;
 
@@ -61,7 +60,7 @@
 };
 // clang-format on
 
-static void CheckInetErrorStr(nlTestSuite * inSuite, void * inContext)
+TEST(TestInetErrorStr, CheckInetErrorStr)
 {
     // Register the layer error formatter
     Inet::RegisterLayerErrorFormatter();
@@ -74,45 +73,12 @@
 
         // Assert that the error string contains the error number in hex.
         snprintf(expectedText, sizeof(expectedText), "%08" PRIX32, err.AsInteger());
-        NL_TEST_ASSERT(inSuite, (strstr(errStr, expectedText) != nullptr));
+        EXPECT_NE(strstr(errStr, expectedText), nullptr);
 
 #if !CHIP_CONFIG_SHORT_ERROR_STR
         // Assert that the error string contains a description, which is signaled
         // by a presence of a colon proceeding the description.
-        NL_TEST_ASSERT(inSuite, (strchr(errStr, ':') != nullptr));
+        EXPECT_NE(strchr(errStr, ':'), nullptr);
 #endif // !CHIP_CONFIG_SHORT_ERROR_STR
     }
 }
-
-/**
- *   Test Suite. It lists all the test functions.
- */
-
-// clang-format off
-static const nlTest sTests[] =
-{
-    NL_TEST_DEF("InetErrorStr", CheckInetErrorStr),
-
-    NL_TEST_SENTINEL()
-};
-// clang-format on
-
-int TestInetErrorStr()
-{
-    // clang-format off
-    nlTestSuite theSuite =
-	{
-        "Inet-Error-Strings",
-        &sTests[0],
-        nullptr,
-        nullptr
-    };
-    // clang-format on
-
-    // Run test suite against one context.
-    nlTestRunner(&theSuite, nullptr);
-
-    return (nlTestRunnerStats(&theSuite));
-}
-
-CHIP_REGISTER_TEST_SUITE(TestInetErrorStr)
diff --git a/src/test_driver/openiotsdk/unit-tests/test_components.txt b/src/test_driver/openiotsdk/unit-tests/test_components.txt
index 5887de7..db6d92b 100644
--- a/src/test_driver/openiotsdk/unit-tests/test_components.txt
+++ b/src/test_driver/openiotsdk/unit-tests/test_components.txt
@@ -18,3 +18,4 @@
 UserDirectedCommissioningTests
 SecureChannelTests
 ICDServerTests
+InetLayerTests
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 9408e84..e00ff91 100644
--- a/src/test_driver/openiotsdk/unit-tests/test_components_nl.txt
+++ b/src/test_driver/openiotsdk/unit-tests/test_components_nl.txt
@@ -1,6 +1,5 @@
 AppTests
 DataModelTests
-InetLayerTests
 MessagingLayerTests
 SecureChannelTestsNL
 TransportLayerTests