diff --git a/src/credentials/tests/BUILD.gn b/src/credentials/tests/BUILD.gn
index 2de5d99..766557d 100644
--- a/src/credentials/tests/BUILD.gn
+++ b/src/credentials/tests/BUILD.gn
@@ -14,7 +14,6 @@
 
 import("//build_overrides/build.gni")
 import("//build_overrides/chip.gni")
-import("//build_overrides/nlunit_test.gni")
 
 import("${chip_root}/build/chip/chip_test_suite.gni")
 import("${chip_root}/build/chip/fuzz_test.gni")
@@ -42,7 +41,7 @@
   ]
 }
 
-chip_test_suite_using_nltest("tests") {
+chip_test_suite("tests") {
   output_name = "libCredentialsTest"
   output_dir = "${root_out_dir}/lib"
 
@@ -71,8 +70,6 @@
     "${chip_root}/src/credentials:default_attestation_verifier",
     "${chip_root}/src/lib/core",
     "${chip_root}/src/lib/support:testing",
-    "${chip_root}/src/lib/support:testing_nlunit",
-    "${nlunit_test_root}:nlunit-test",
   ]
 }
 
diff --git a/src/credentials/tests/TestCertificationDeclaration.cpp b/src/credentials/tests/TestCertificationDeclaration.cpp
index 4500354..45c8d50 100644
--- a/src/credentials/tests/TestCertificationDeclaration.cpp
+++ b/src/credentials/tests/TestCertificationDeclaration.cpp
@@ -30,10 +30,8 @@
 #include <credentials/attestation_verifier/DefaultDeviceAttestationVerifier.h>
 #include <crypto/CHIPCryptoPAL.h>
 #include <lib/support/Span.h>
-#include <lib/support/UnitTestExtendedAssertions.h>
-#include <lib/support/UnitTestRegistration.h>
 
-#include <nlunit-test.h>
+#include <gtest/gtest.h>
 
 using namespace chip;
 using namespace chip::ASN1;
@@ -263,59 +261,57 @@
       ByteSpan(sTestCMS_CDContent02), ByteSpan(sTestCMS_SignedMessage02) },
 };
 
-static void TestCD_EncodeDecode(nlTestSuite * inSuite, void * inContext)
+TEST(TestCertificationDeclaration, TestCD_EncodeDecode)
 {
     for (const auto & testCase : sTestCases)
     {
         uint8_t encodedCertElemBuf[kCertificationElements_TLVEncodedMaxLength];
         MutableByteSpan encodedCDPayload(encodedCertElemBuf);
 
-        NL_TEST_ASSERT(inSuite, EncodeCertificationElements(testCase.cdElements, encodedCDPayload) == CHIP_NO_ERROR);
-        NL_TEST_ASSERT(inSuite, testCase.cdContent.data_equal(encodedCDPayload));
+        EXPECT_EQ(EncodeCertificationElements(testCase.cdElements, encodedCDPayload), CHIP_NO_ERROR);
+        EXPECT_TRUE(testCase.cdContent.data_equal(encodedCDPayload));
 
         CertificationElements decodedElements;
-        NL_TEST_ASSERT(inSuite, DecodeCertificationElements(encodedCDPayload, decodedElements) == CHIP_NO_ERROR);
+        EXPECT_EQ(DecodeCertificationElements(encodedCDPayload, decodedElements), CHIP_NO_ERROR);
 
-        NL_TEST_ASSERT(inSuite, decodedElements.FormatVersion == testCase.cdElements.FormatVersion);
-        NL_TEST_ASSERT(inSuite, decodedElements.VendorId == testCase.cdElements.VendorId);
-        NL_TEST_ASSERT(inSuite, decodedElements.ProductIdsCount == testCase.cdElements.ProductIdsCount);
+        EXPECT_EQ(decodedElements.FormatVersion, testCase.cdElements.FormatVersion);
+        EXPECT_EQ(decodedElements.VendorId, testCase.cdElements.VendorId);
+        EXPECT_EQ(decodedElements.ProductIdsCount, testCase.cdElements.ProductIdsCount);
         for (uint8_t j = 0; j < decodedElements.ProductIdsCount; j++)
         {
-            NL_TEST_ASSERT(inSuite, decodedElements.ProductIds[j] == testCase.cdElements.ProductIds[j]);
+            EXPECT_EQ(decodedElements.ProductIds[j], testCase.cdElements.ProductIds[j]);
         }
-        NL_TEST_ASSERT(inSuite, decodedElements.DeviceTypeId == testCase.cdElements.DeviceTypeId);
-        NL_TEST_ASSERT(inSuite,
-                       memcmp(decodedElements.CertificateId, testCase.cdElements.CertificateId, kCertificateIdLength) == 0);
-        NL_TEST_ASSERT(inSuite, decodedElements.SecurityLevel == testCase.cdElements.SecurityLevel);
-        NL_TEST_ASSERT(inSuite, decodedElements.SecurityInformation == testCase.cdElements.SecurityInformation);
-        NL_TEST_ASSERT(inSuite, decodedElements.VersionNumber == testCase.cdElements.VersionNumber);
-        NL_TEST_ASSERT(inSuite, decodedElements.CertificationType == testCase.cdElements.CertificationType);
-        NL_TEST_ASSERT(inSuite, decodedElements.DACOriginVIDandPIDPresent == testCase.cdElements.DACOriginVIDandPIDPresent);
+        EXPECT_EQ(decodedElements.DeviceTypeId, testCase.cdElements.DeviceTypeId);
+        EXPECT_EQ(memcmp(decodedElements.CertificateId, testCase.cdElements.CertificateId, kCertificateIdLength), 0);
+        EXPECT_EQ(decodedElements.SecurityLevel, testCase.cdElements.SecurityLevel);
+        EXPECT_EQ(decodedElements.SecurityInformation, testCase.cdElements.SecurityInformation);
+        EXPECT_EQ(decodedElements.VersionNumber, testCase.cdElements.VersionNumber);
+        EXPECT_EQ(decodedElements.CertificationType, testCase.cdElements.CertificationType);
+        EXPECT_EQ(decodedElements.DACOriginVIDandPIDPresent, testCase.cdElements.DACOriginVIDandPIDPresent);
         if (decodedElements.DACOriginVIDandPIDPresent)
         {
-            NL_TEST_ASSERT(inSuite, decodedElements.DACOriginVendorId == testCase.cdElements.DACOriginVendorId);
-            NL_TEST_ASSERT(inSuite, decodedElements.DACOriginProductId == testCase.cdElements.DACOriginProductId);
+            EXPECT_EQ(decodedElements.DACOriginVendorId, testCase.cdElements.DACOriginVendorId);
+            EXPECT_EQ(decodedElements.DACOriginProductId, testCase.cdElements.DACOriginProductId);
         }
-        NL_TEST_ASSERT(inSuite, decodedElements.AuthorizedPAAListCount == testCase.cdElements.AuthorizedPAAListCount);
+        EXPECT_EQ(decodedElements.AuthorizedPAAListCount, testCase.cdElements.AuthorizedPAAListCount);
         for (uint8_t j = 0; j < decodedElements.AuthorizedPAAListCount; j++)
         {
-            NL_TEST_ASSERT(
-                inSuite,
-                memcmp(decodedElements.AuthorizedPAAList[j], testCase.cdElements.AuthorizedPAAList[j], kKeyIdentifierLength) == 0);
+            EXPECT_EQ(memcmp(decodedElements.AuthorizedPAAList[j], testCase.cdElements.AuthorizedPAAList[j], kKeyIdentifierLength),
+                      0);
         }
     }
 }
 
-static void TestCD_EncodeDecode_Errors(nlTestSuite * inSuite, void * inContext)
+TEST(TestCertificationDeclaration, TestCD_EncodeDecode_Errors)
 {
     uint8_t encodedCertElemBuf[kCertificationElements_TLVEncodedMaxLength];
     MutableByteSpan encodedCDPayload(encodedCertElemBuf);
-    NL_TEST_ASSERT(inSuite, EncodeCertificationElements(sTestCMS_CertElements01, encodedCDPayload) == CHIP_NO_ERROR);
+    EXPECT_EQ(EncodeCertificationElements(sTestCMS_CertElements01, encodedCDPayload), CHIP_NO_ERROR);
 
     // Test Encode Error: CHIP_ERROR_BUFFER_TOO_SMALL
     // Provide a smaller buffer as an input.
     encodedCDPayload.reduce_size(encodedCDPayload.size() - 4);
-    NL_TEST_ASSERT(inSuite, EncodeCertificationElements(sTestCMS_CertElements01, encodedCDPayload) == CHIP_ERROR_BUFFER_TOO_SMALL);
+    EXPECT_EQ(EncodeCertificationElements(sTestCMS_CertElements01, encodedCDPayload), CHIP_ERROR_BUFFER_TOO_SMALL);
 
     // Test Decode Error: CHIP_ERROR_INVALID_INTEGER_VALUE
     // Manually modified sTestCMS_CDContent01[]: updated VendorId element to 4-octet
@@ -327,9 +323,7 @@
     };
 
     CertificationElements certElementsOut;
-    NL_TEST_ASSERT(inSuite,
-                   DecodeCertificationElements(ByteSpan(sTestCMS_CDContent01_Err01), certElementsOut) ==
-                       CHIP_ERROR_INVALID_INTEGER_VALUE);
+    EXPECT_EQ(DecodeCertificationElements(ByteSpan(sTestCMS_CDContent01_Err01), certElementsOut), CHIP_ERROR_INVALID_INTEGER_VALUE);
 
     // Test Decode Error: CHIP_ERROR_UNEXPECTED_TLV_ELEMENT
     // Manually modified sTestCMS_CDContent01[]: switched ProductIds and DeviceTypeId elements tag (0x02 <--> 0x03)
@@ -338,12 +332,11 @@
                                                               0x49, 0x47, 0x32, 0x30, 0x31, 0x34, 0x31, 0x5a, 0x42, 0x33, 0x33,
                                                               0x30, 0x30, 0x30, 0x31, 0x2d, 0x32, 0x34, 0x24, 0x05, 0x00, 0x24,
                                                               0x06, 0x00, 0x25, 0x07, 0x94, 0x26, 0x24, 0x08, 0x00, 0x18 };
-    NL_TEST_ASSERT(inSuite,
-                   DecodeCertificationElements(ByteSpan(sTestCMS_CDContent01_Err02), certElementsOut) ==
-                       CHIP_ERROR_UNEXPECTED_TLV_ELEMENT);
+    EXPECT_EQ(DecodeCertificationElements(ByteSpan(sTestCMS_CDContent01_Err02), certElementsOut),
+              CHIP_ERROR_UNEXPECTED_TLV_ELEMENT);
 }
 
-static void TestCD_CMSSignAndVerify(nlTestSuite * inSuite, void * inContext)
+TEST(TestCertificationDeclaration, TestCD_CMSSignAndVerify)
 {
     ByteSpan cdContentIn(sTestCMS_CDContent01);
     ByteSpan cdContentOut;
@@ -352,14 +345,14 @@
     uint8_t signedMessageBuf[kMaxCMSSignedCDMessage];
     MutableByteSpan signedMessage(signedMessageBuf);
 
-    NL_TEST_ASSERT(inSuite, ExtractSKIDFromX509Cert(ByteSpan(sTestCMS_SignerCert), signerKeyId) == CHIP_NO_ERROR);
+    EXPECT_EQ(ExtractSKIDFromX509Cert(ByteSpan(sTestCMS_SignerCert), signerKeyId), CHIP_NO_ERROR);
 
     // Test with random key
     P256Keypair keypair;
-    NL_TEST_ASSERT(inSuite, keypair.Initialize(ECPKeyTarget::ECDSA) == CHIP_NO_ERROR);
-    NL_TEST_ASSERT(inSuite, CMS_Sign(cdContentIn, signerKeyId, keypair, signedMessage) == CHIP_NO_ERROR);
-    NL_TEST_ASSERT(inSuite, CMS_Verify(signedMessage, keypair.Pubkey(), cdContentOut) == CHIP_NO_ERROR);
-    NL_TEST_ASSERT(inSuite, cdContentIn.data_equal(cdContentOut));
+    EXPECT_EQ(keypair.Initialize(ECPKeyTarget::ECDSA), CHIP_NO_ERROR);
+    EXPECT_EQ(CMS_Sign(cdContentIn, signerKeyId, keypair, signedMessage), CHIP_NO_ERROR);
+    EXPECT_EQ(CMS_Verify(signedMessage, keypair.Pubkey(), cdContentOut), CHIP_NO_ERROR);
+    EXPECT_TRUE(cdContentIn.data_equal(cdContentOut));
 
     // Test with known key
     P256Keypair keypair2;
@@ -368,93 +361,89 @@
     serializedKeypair.SetLength(sizeof(sTestCMS_SignerSerializedKeypair));
     cdContentIn   = ByteSpan(sTestCMS_CDContent02);
     signedMessage = MutableByteSpan(signedMessageBuf);
-    NL_TEST_ASSERT(inSuite, keypair2.Deserialize(serializedKeypair) == CHIP_NO_ERROR);
-    NL_TEST_ASSERT(inSuite, CMS_Sign(cdContentIn, signerKeyId, keypair2, signedMessage) == CHIP_NO_ERROR);
-    NL_TEST_ASSERT(inSuite, CMS_Verify(signedMessage, keypair2.Pubkey(), cdContentOut) == CHIP_NO_ERROR);
-    NL_TEST_ASSERT(inSuite, cdContentIn.data_equal(cdContentOut));
+    EXPECT_EQ(keypair2.Deserialize(serializedKeypair), CHIP_NO_ERROR);
+    EXPECT_EQ(CMS_Sign(cdContentIn, signerKeyId, keypair2, signedMessage), CHIP_NO_ERROR);
+    EXPECT_EQ(CMS_Verify(signedMessage, keypair2.Pubkey(), cdContentOut), CHIP_NO_ERROR);
+    EXPECT_TRUE(cdContentIn.data_equal(cdContentOut));
 }
 
-static void TestCD_CMSVerifyAndExtract(nlTestSuite * inSuite, void * inContext)
+TEST(TestCertificationDeclaration, TestCD_CMSVerifyAndExtract)
 {
     for (const auto & testCase : sTestCases)
     {
         // Verify using signer P256PublicKey
         ByteSpan cdContentOut;
-        NL_TEST_ASSERT(inSuite,
-                       CMS_Verify(testCase.cdCMSSigned, P256PublicKey(testCase.signerPubkey), cdContentOut) == CHIP_NO_ERROR);
-        NL_TEST_ASSERT(inSuite, testCase.cdContent.data_equal(cdContentOut));
+        EXPECT_EQ(CMS_Verify(testCase.cdCMSSigned, P256PublicKey(testCase.signerPubkey), cdContentOut), CHIP_NO_ERROR);
+        EXPECT_TRUE(testCase.cdContent.data_equal(cdContentOut));
 
         // Verify using signer X509 Certificate
         cdContentOut = ByteSpan();
-        NL_TEST_ASSERT(inSuite, CMS_Verify(testCase.cdCMSSigned, testCase.signerCert, cdContentOut) == CHIP_NO_ERROR);
-        NL_TEST_ASSERT(inSuite, testCase.cdContent.data_equal(cdContentOut));
+        EXPECT_EQ(CMS_Verify(testCase.cdCMSSigned, testCase.signerCert, cdContentOut), CHIP_NO_ERROR);
+        EXPECT_TRUE(testCase.cdContent.data_equal(cdContentOut));
 
         // Test CMS_ExtractCDContent()
         cdContentOut = ByteSpan();
-        NL_TEST_ASSERT(inSuite, CMS_ExtractCDContent(testCase.cdCMSSigned, cdContentOut) == CHIP_NO_ERROR);
-        NL_TEST_ASSERT(inSuite, testCase.cdContent.data_equal(cdContentOut));
+        EXPECT_EQ(CMS_ExtractCDContent(testCase.cdCMSSigned, cdContentOut), CHIP_NO_ERROR);
+        EXPECT_TRUE(testCase.cdContent.data_equal(cdContentOut));
 
         // Test CMS_ExtractKeyId()
         uint8_t signerKeyIdBuf[Crypto::kSubjectKeyIdentifierLength];
         MutableByteSpan signerKeyId(signerKeyIdBuf);
-        NL_TEST_ASSERT(inSuite, ExtractSKIDFromX509Cert(testCase.signerCert, signerKeyId) == CHIP_NO_ERROR);
+        EXPECT_EQ(ExtractSKIDFromX509Cert(testCase.signerCert, signerKeyId), CHIP_NO_ERROR);
 
         ByteSpan signerKeyIdOut;
-        NL_TEST_ASSERT(inSuite, CMS_ExtractKeyId(testCase.cdCMSSigned, signerKeyIdOut) == CHIP_NO_ERROR);
-        NL_TEST_ASSERT(inSuite, signerKeyId.data_equal(signerKeyIdOut));
+        EXPECT_EQ(CMS_ExtractKeyId(testCase.cdCMSSigned, signerKeyIdOut), CHIP_NO_ERROR);
+        EXPECT_TRUE(signerKeyId.data_equal(signerKeyIdOut));
     }
 }
 
-static void TestCD_CertificationElementsDecoder(nlTestSuite * inSuite, void * inContext)
+TEST(TestCertificationDeclaration, TestCD_CertificationElementsDecoder)
 {
     for (const auto & testCase : sTestCases)
     {
         uint8_t encodedCertElemBuf[kCertificationElements_TLVEncodedMaxLength];
         MutableByteSpan encodedCDPayload(encodedCertElemBuf);
 
-        NL_TEST_ASSERT(inSuite, EncodeCertificationElements(testCase.cdElements, encodedCDPayload) == CHIP_NO_ERROR);
-        NL_TEST_ASSERT(inSuite, testCase.cdContent.data_equal(encodedCDPayload));
+        EXPECT_EQ(EncodeCertificationElements(testCase.cdElements, encodedCDPayload), CHIP_NO_ERROR);
+        EXPECT_TRUE(testCase.cdContent.data_equal(encodedCDPayload));
 
         CertificationElementsWithoutPIDs certificationDeclarationContent;
         CertificationElementsDecoder certificationElementsDecoder;
-        NL_TEST_ASSERT(inSuite, DecodeCertificationElements(encodedCDPayload, certificationDeclarationContent) == CHIP_NO_ERROR);
+        EXPECT_EQ(DecodeCertificationElements(encodedCDPayload, certificationDeclarationContent), CHIP_NO_ERROR);
 
-        NL_TEST_ASSERT(inSuite, certificationDeclarationContent.formatVersion == testCase.cdElements.FormatVersion);
-        NL_TEST_ASSERT(inSuite, certificationDeclarationContent.vendorId == testCase.cdElements.VendorId);
+        EXPECT_EQ(certificationDeclarationContent.formatVersion, testCase.cdElements.FormatVersion);
+        EXPECT_EQ(certificationDeclarationContent.vendorId, testCase.cdElements.VendorId);
         for (uint8_t j = 0; j < testCase.cdElements.ProductIdsCount; j++)
         {
-            NL_TEST_ASSERT(inSuite,
-                           certificationElementsDecoder.IsProductIdIn(encodedCDPayload, testCase.cdElements.ProductIds[j]));
+            EXPECT_TRUE(certificationElementsDecoder.IsProductIdIn(encodedCDPayload, testCase.cdElements.ProductIds[j]));
             // now test for an unexistent ProductId
-            NL_TEST_ASSERT(inSuite, certificationElementsDecoder.IsProductIdIn(encodedCDPayload, 0x9000) == false);
+            EXPECT_FALSE(certificationElementsDecoder.IsProductIdIn(encodedCDPayload, 0x9000));
         }
-        NL_TEST_ASSERT(inSuite, certificationDeclarationContent.deviceTypeId == testCase.cdElements.DeviceTypeId);
-        NL_TEST_ASSERT(
-            inSuite,
-            memcmp(certificationDeclarationContent.certificateId, testCase.cdElements.CertificateId, kCertificateIdLength) == 0);
-        NL_TEST_ASSERT(inSuite, certificationDeclarationContent.securityLevel == testCase.cdElements.SecurityLevel);
-        NL_TEST_ASSERT(inSuite, certificationDeclarationContent.securityInformation == testCase.cdElements.SecurityInformation);
-        NL_TEST_ASSERT(inSuite, certificationDeclarationContent.versionNumber == testCase.cdElements.VersionNumber);
-        NL_TEST_ASSERT(inSuite, certificationDeclarationContent.certificationType == testCase.cdElements.CertificationType);
-        NL_TEST_ASSERT(inSuite,
-                       certificationDeclarationContent.dacOriginVIDandPIDPresent == testCase.cdElements.DACOriginVIDandPIDPresent);
+        EXPECT_EQ(certificationDeclarationContent.deviceTypeId, testCase.cdElements.DeviceTypeId);
+        EXPECT_EQ(memcmp(certificationDeclarationContent.certificateId, testCase.cdElements.CertificateId, kCertificateIdLength),
+                  0);
+        EXPECT_EQ(certificationDeclarationContent.securityLevel, testCase.cdElements.SecurityLevel);
+        EXPECT_EQ(certificationDeclarationContent.securityInformation, testCase.cdElements.SecurityInformation);
+        EXPECT_EQ(certificationDeclarationContent.versionNumber, testCase.cdElements.VersionNumber);
+        EXPECT_EQ(certificationDeclarationContent.certificationType, testCase.cdElements.CertificationType);
+        EXPECT_EQ(certificationDeclarationContent.dacOriginVIDandPIDPresent, testCase.cdElements.DACOriginVIDandPIDPresent);
         if (certificationDeclarationContent.dacOriginVIDandPIDPresent)
         {
-            NL_TEST_ASSERT(inSuite, certificationDeclarationContent.dacOriginVendorId == testCase.cdElements.DACOriginVendorId);
-            NL_TEST_ASSERT(inSuite, certificationDeclarationContent.dacOriginProductId == testCase.cdElements.DACOriginProductId);
+            EXPECT_EQ(certificationDeclarationContent.dacOriginVendorId, testCase.cdElements.DACOriginVendorId);
+            EXPECT_EQ(certificationDeclarationContent.dacOriginProductId, testCase.cdElements.DACOriginProductId);
         }
         if (testCase.cdElements.AuthorizedPAAListCount > 0)
         {
-            NL_TEST_ASSERT(inSuite, certificationDeclarationContent.authorizedPAAListPresent);
+            EXPECT_TRUE(certificationDeclarationContent.authorizedPAAListPresent);
         }
         else
         {
-            NL_TEST_ASSERT(inSuite, !certificationDeclarationContent.authorizedPAAListPresent);
+            EXPECT_FALSE(certificationDeclarationContent.authorizedPAAListPresent);
         }
     }
 }
 
-static void TestCD_EncodeDecode_Random(nlTestSuite * inSuite, void * inContext)
+TEST(TestCertificationDeclaration, TestCD_EncodeDecode_Random)
 {
     CertificationElements randomElements = { .FormatVersion             = 0x6F,
                                              .VendorId                  = 0x88EA,
@@ -489,97 +478,95 @@
     MutableByteSpan encodedCDPayload(encodedCertElemBuf);
     CertificationElements decodedElements;
 
-    NL_TEST_ASSERT(inSuite, EncodeCertificationElements(randomElements, encodedCDPayload) == CHIP_NO_ERROR);
+    EXPECT_EQ(EncodeCertificationElements(randomElements, encodedCDPayload), CHIP_NO_ERROR);
 
-    NL_TEST_ASSERT(inSuite, DecodeCertificationElements(encodedCDPayload, decodedElements) == CHIP_NO_ERROR);
-    NL_TEST_ASSERT(inSuite, decodedElements.FormatVersion == randomElements.FormatVersion);
-    NL_TEST_ASSERT(inSuite, decodedElements.VendorId == randomElements.VendorId);
-    NL_TEST_ASSERT(inSuite, decodedElements.ProductIdsCount == randomElements.ProductIdsCount);
+    EXPECT_EQ(DecodeCertificationElements(encodedCDPayload, decodedElements), CHIP_NO_ERROR);
+    EXPECT_EQ(decodedElements.FormatVersion, randomElements.FormatVersion);
+    EXPECT_EQ(decodedElements.VendorId, randomElements.VendorId);
+    EXPECT_EQ(decodedElements.ProductIdsCount, randomElements.ProductIdsCount);
     for (uint8_t j = 0; j < decodedElements.ProductIdsCount; j++)
     {
-        NL_TEST_ASSERT(inSuite, decodedElements.ProductIds[j] == randomElements.ProductIds[j]);
+        EXPECT_EQ(decodedElements.ProductIds[j], randomElements.ProductIds[j]);
     }
-    NL_TEST_ASSERT(inSuite, decodedElements.DeviceTypeId == randomElements.DeviceTypeId);
-    NL_TEST_ASSERT(inSuite, memcmp(decodedElements.CertificateId, randomElements.CertificateId, kCertificateIdLength) == 0);
-    NL_TEST_ASSERT(inSuite, decodedElements.SecurityLevel == randomElements.SecurityLevel);
-    NL_TEST_ASSERT(inSuite, decodedElements.SecurityInformation == randomElements.SecurityInformation);
-    NL_TEST_ASSERT(inSuite, decodedElements.VersionNumber == randomElements.VersionNumber);
-    NL_TEST_ASSERT(inSuite, decodedElements.CertificationType == randomElements.CertificationType);
-    NL_TEST_ASSERT(inSuite, decodedElements.DACOriginVIDandPIDPresent == randomElements.DACOriginVIDandPIDPresent);
+    EXPECT_EQ(decodedElements.DeviceTypeId, randomElements.DeviceTypeId);
+    EXPECT_EQ(memcmp(decodedElements.CertificateId, randomElements.CertificateId, kCertificateIdLength), 0);
+    EXPECT_EQ(decodedElements.SecurityLevel, randomElements.SecurityLevel);
+    EXPECT_EQ(decodedElements.SecurityInformation, randomElements.SecurityInformation);
+    EXPECT_EQ(decodedElements.VersionNumber, randomElements.VersionNumber);
+    EXPECT_EQ(decodedElements.CertificationType, randomElements.CertificationType);
+    EXPECT_EQ(decodedElements.DACOriginVIDandPIDPresent, randomElements.DACOriginVIDandPIDPresent);
     if (decodedElements.DACOriginVIDandPIDPresent)
     {
-        NL_TEST_ASSERT(inSuite, decodedElements.DACOriginVendorId == randomElements.DACOriginVendorId);
-        NL_TEST_ASSERT(inSuite, decodedElements.DACOriginProductId == randomElements.DACOriginProductId);
+        EXPECT_EQ(decodedElements.DACOriginVendorId, randomElements.DACOriginVendorId);
+        EXPECT_EQ(decodedElements.DACOriginProductId, randomElements.DACOriginProductId);
     }
-    NL_TEST_ASSERT(inSuite, decodedElements.AuthorizedPAAListCount == randomElements.AuthorizedPAAListCount);
+    EXPECT_EQ(decodedElements.AuthorizedPAAListCount, randomElements.AuthorizedPAAListCount);
     for (uint8_t j = 0; j < decodedElements.AuthorizedPAAListCount; j++)
     {
-        NL_TEST_ASSERT(
-            inSuite, memcmp(decodedElements.AuthorizedPAAList[j], randomElements.AuthorizedPAAList[j], kKeyIdentifierLength) == 0);
+        EXPECT_EQ(memcmp(decodedElements.AuthorizedPAAList[j], randomElements.AuthorizedPAAList[j], kKeyIdentifierLength), 0);
     }
 
     CertificationElementsWithoutPIDs decodedElements2;
     CertificationElementsDecoder cdElementsDecoder;
-    NL_TEST_ASSERT(inSuite, DecodeCertificationElements(encodedCDPayload, decodedElements2) == CHIP_NO_ERROR);
+    EXPECT_EQ(DecodeCertificationElements(encodedCDPayload, decodedElements2), CHIP_NO_ERROR);
 
-    NL_TEST_ASSERT(inSuite, decodedElements2.formatVersion == randomElements.FormatVersion);
-    NL_TEST_ASSERT(inSuite, decodedElements2.vendorId == randomElements.VendorId);
+    EXPECT_EQ(decodedElements2.formatVersion, randomElements.FormatVersion);
+    EXPECT_EQ(decodedElements2.vendorId, randomElements.VendorId);
     for (uint8_t j = 0; j < randomElements.ProductIdsCount; j++)
     {
-        NL_TEST_ASSERT(inSuite, cdElementsDecoder.IsProductIdIn(encodedCDPayload, randomElements.ProductIds[j]));
+        EXPECT_TRUE(cdElementsDecoder.IsProductIdIn(encodedCDPayload, randomElements.ProductIds[j]));
         // now test for an unexistent ProductId
-        NL_TEST_ASSERT(inSuite, cdElementsDecoder.IsProductIdIn(encodedCDPayload, pid++) == false);
+        EXPECT_FALSE(cdElementsDecoder.IsProductIdIn(encodedCDPayload, pid++));
     }
-    NL_TEST_ASSERT(inSuite, decodedElements2.deviceTypeId == randomElements.DeviceTypeId);
-    NL_TEST_ASSERT(inSuite, memcmp(decodedElements2.certificateId, randomElements.CertificateId, kCertificateIdLength) == 0);
-    NL_TEST_ASSERT(inSuite, decodedElements2.securityLevel == randomElements.SecurityLevel);
-    NL_TEST_ASSERT(inSuite, decodedElements2.securityInformation == randomElements.SecurityInformation);
-    NL_TEST_ASSERT(inSuite, decodedElements2.versionNumber == randomElements.VersionNumber);
-    NL_TEST_ASSERT(inSuite, decodedElements2.certificationType == randomElements.CertificationType);
-    NL_TEST_ASSERT(inSuite, decodedElements2.dacOriginVIDandPIDPresent == randomElements.DACOriginVIDandPIDPresent);
+    EXPECT_EQ(decodedElements2.deviceTypeId, randomElements.DeviceTypeId);
+    EXPECT_EQ(memcmp(decodedElements2.certificateId, randomElements.CertificateId, kCertificateIdLength), 0);
+    EXPECT_EQ(decodedElements2.securityLevel, randomElements.SecurityLevel);
+    EXPECT_EQ(decodedElements2.securityInformation, randomElements.SecurityInformation);
+    EXPECT_EQ(decodedElements2.versionNumber, randomElements.VersionNumber);
+    EXPECT_EQ(decodedElements2.certificationType, randomElements.CertificationType);
+    EXPECT_EQ(decodedElements2.dacOriginVIDandPIDPresent, randomElements.DACOriginVIDandPIDPresent);
     if (decodedElements2.dacOriginVIDandPIDPresent)
     {
-        NL_TEST_ASSERT(inSuite, decodedElements2.dacOriginVendorId == randomElements.DACOriginVendorId);
-        NL_TEST_ASSERT(inSuite, decodedElements2.dacOriginProductId == randomElements.DACOriginProductId);
+        EXPECT_EQ(decodedElements2.dacOriginVendorId, randomElements.DACOriginVendorId);
+        EXPECT_EQ(decodedElements2.dacOriginProductId, randomElements.DACOriginProductId);
     }
-    NL_TEST_ASSERT(inSuite, decodedElements2.authorizedPAAListPresent);
+    EXPECT_TRUE(decodedElements2.authorizedPAAListPresent);
     for (uint8_t j = 0; j < randomElements.AuthorizedPAAListCount; j++)
     {
-        NL_TEST_ASSERT(inSuite,
-                       cdElementsDecoder.HasAuthorizedPAA(encodedCDPayload, ByteSpan(randomElements.AuthorizedPAAList[j])));
+        EXPECT_TRUE(cdElementsDecoder.HasAuthorizedPAA(encodedCDPayload, ByteSpan(randomElements.AuthorizedPAAList[j])));
         // now test for an unexistent PAA
         kid[(kKeyIdentifierLength - 1 - j) % kKeyIdentifierLength] ^= 0x5A;
-        NL_TEST_ASSERT(inSuite, cdElementsDecoder.HasAuthorizedPAA(encodedCDPayload, ByteSpan(kid)) == false);
+        EXPECT_FALSE(cdElementsDecoder.HasAuthorizedPAA(encodedCDPayload, ByteSpan(kid)));
     }
 }
 
-static void TestCD_DefaultCdTrustStore(nlTestSuite * inSuite, void * inContext)
+TEST(TestCertificationDeclaration, TestCD_DefaultCdTrustStore)
 {
     chip::Credentials::CsaCdKeysTrustStore trustStore;
 
     // Make sure that for an untrusted CD, whose key is not in truststore, we cannot find the key.
     {
         ByteSpan signerKeyIdOut;
-        NL_TEST_ASSERT_SUCCESS(inSuite, CMS_ExtractKeyId(ByteSpan(gUntrustedCd), signerKeyIdOut));
-        NL_TEST_ASSERT(inSuite, !trustStore.IsCdTestKey(signerKeyIdOut));
+        EXPECT_EQ(CMS_ExtractKeyId(ByteSpan(gUntrustedCd), signerKeyIdOut), CHIP_NO_ERROR);
+        EXPECT_FALSE(trustStore.IsCdTestKey(signerKeyIdOut));
 
         P256PublicKey pubKey;
-        NL_TEST_ASSERT(inSuite, CHIP_ERROR_KEY_NOT_FOUND == trustStore.LookupVerifyingKey(signerKeyIdOut, pubKey));
+        EXPECT_EQ(CHIP_ERROR_KEY_NOT_FOUND, trustStore.LookupVerifyingKey(signerKeyIdOut, pubKey));
     }
 
     // Verify that a payload known to use the test key passes verification w/ default truststore
     {
         const auto & testCase = sTestCases[0];
         ByteSpan signerKeyIdOut;
-        NL_TEST_ASSERT_SUCCESS(inSuite, CMS_ExtractKeyId(testCase.cdCMSSigned, signerKeyIdOut));
-        NL_TEST_ASSERT(inSuite, trustStore.IsCdTestKey(signerKeyIdOut));
+        EXPECT_EQ(CMS_ExtractKeyId(testCase.cdCMSSigned, signerKeyIdOut), CHIP_NO_ERROR);
+        EXPECT_TRUE(trustStore.IsCdTestKey(signerKeyIdOut));
 
         P256PublicKey pubKey;
         ByteSpan cdContentOut;
-        NL_TEST_ASSERT_SUCCESS(inSuite, trustStore.LookupVerifyingKey(signerKeyIdOut, pubKey));
+        EXPECT_EQ(trustStore.LookupVerifyingKey(signerKeyIdOut, pubKey), CHIP_NO_ERROR);
 
-        NL_TEST_ASSERT(inSuite, CMS_Verify(testCase.cdCMSSigned, pubKey, cdContentOut) == CHIP_NO_ERROR);
-        NL_TEST_ASSERT(inSuite, testCase.cdContent.data_equal(cdContentOut));
+        EXPECT_EQ(CMS_Verify(testCase.cdCMSSigned, pubKey, cdContentOut), CHIP_NO_ERROR);
+        EXPECT_TRUE(testCase.cdContent.data_equal(cdContentOut));
     }
 
     // Verify that after adding the verifying key to the trust store, it is now possible to
@@ -587,49 +574,25 @@
     {
         P256PublicKey pubKey;
         ByteSpan cdContentOut;
-        NL_TEST_ASSERT_SUCCESS(inSuite, trustStore.AddTrustedKey(ByteSpan(gUntrustedCdKid), gUntrustedCdVerifyingKey));
+        EXPECT_EQ(trustStore.AddTrustedKey(ByteSpan(gUntrustedCdKid), gUntrustedCdVerifyingKey), CHIP_NO_ERROR);
 
         ByteSpan signerKeyIdOut;
-        NL_TEST_ASSERT_SUCCESS(inSuite, CMS_ExtractKeyId(ByteSpan(gUntrustedCd), signerKeyIdOut));
-        NL_TEST_ASSERT(inSuite, signerKeyIdOut.data_equal(ByteSpan(gUntrustedCdKid)));
+        EXPECT_EQ(CMS_ExtractKeyId(ByteSpan(gUntrustedCd), signerKeyIdOut), CHIP_NO_ERROR);
+        EXPECT_TRUE(signerKeyIdOut.data_equal(ByteSpan(gUntrustedCdKid)));
 
-        NL_TEST_ASSERT_SUCCESS(inSuite, trustStore.LookupVerifyingKey(signerKeyIdOut, pubKey));
-        NL_TEST_ASSERT(inSuite, pubKey.Matches(gUntrustedCdVerifyingKey));
+        EXPECT_EQ(trustStore.LookupVerifyingKey(signerKeyIdOut, pubKey), CHIP_NO_ERROR);
+        EXPECT_TRUE(pubKey.Matches(gUntrustedCdVerifyingKey));
 
-        NL_TEST_ASSERT_SUCCESS(inSuite, CMS_Verify(ByteSpan(gUntrustedCd), pubKey, cdContentOut));
+        EXPECT_EQ(CMS_Verify(ByteSpan(gUntrustedCd), pubKey, cdContentOut), CHIP_NO_ERROR);
     }
 
     // Verify that untrusted certificate key cannot be added to the trust store.
     {
-        NL_TEST_ASSERT(inSuite, CHIP_ERROR_INVALID_ARGUMENT == trustStore.AddTrustedKey(ByteSpan(gUntrustedCdCert)));
+        EXPECT_EQ(CHIP_ERROR_INVALID_ARGUMENT, trustStore.AddTrustedKey(ByteSpan(gUntrustedCdCert)));
     }
 
     // Verify that trusted certificate key can be added to the trust store.
     {
-        NL_TEST_ASSERT_SUCCESS(inSuite, trustStore.AddTrustedKey(ByteSpan(gCdSigningCert001)));
+        EXPECT_EQ(trustStore.AddTrustedKey(ByteSpan(gCdSigningCert001)), CHIP_NO_ERROR);
     }
 }
-
-#define NL_TEST_DEF_FN(fn) NL_TEST_DEF("Test " #fn, fn)
-/**
- *   Test Suite. It lists all the test functions.
- */
-static const nlTest sTests[] = { NL_TEST_DEF_FN(TestCD_EncodeDecode),
-                                 NL_TEST_DEF_FN(TestCD_EncodeDecode_Errors),
-                                 NL_TEST_DEF_FN(TestCD_CMSSignAndVerify),
-                                 NL_TEST_DEF_FN(TestCD_CMSVerifyAndExtract),
-                                 NL_TEST_DEF_FN(TestCD_CertificationElementsDecoder),
-                                 NL_TEST_DEF_FN(TestCD_EncodeDecode_Random),
-                                 NL_TEST_DEF_FN(TestCD_DefaultCdTrustStore),
-                                 NL_TEST_SENTINEL() };
-
-int TestCertificationDeclaration()
-{
-    nlTestSuite theSuite = { "CHIP Certification Declaration tests", &sTests[0], nullptr, nullptr };
-
-    // Run test suite against one context.
-    nlTestRunner(&theSuite, nullptr);
-    return nlTestRunnerStats(&theSuite);
-}
-
-CHIP_REGISTER_TEST_SUITE(TestCertificationDeclaration);
diff --git a/src/credentials/tests/TestChipCert.cpp b/src/credentials/tests/TestChipCert.cpp
index 2b0319f..9a6e50b 100644
--- a/src/credentials/tests/TestChipCert.cpp
+++ b/src/credentials/tests/TestChipCert.cpp
@@ -33,10 +33,8 @@
 #include <lib/core/TLV.h>
 #include <lib/support/CHIPMem.h>
 #include <lib/support/CodeUtils.h>
-#include <lib/support/UnitTestExtendedAssertions.h>
-#include <lib/support/UnitTestRegistration.h>
 
-#include <nlunit-test.h>
+#include <gtest/gtest.h>
 
 #include "CHIPCert_error_test_vectors.h"
 #include "CHIPCert_test_vectors.h"
@@ -163,7 +161,13 @@
     validContext.mEffectiveTime = EffectiveTime{};
 }
 
-static void TestChipCert_ChipToX509(nlTestSuite * inSuite, void * inContext)
+struct TestChipCert : public ::testing::Test
+{
+    static void SetUpTestSuite() { ASSERT_EQ(chip::Platform::MemoryInit(), CHIP_NO_ERROR); }
+    static void TearDownTestSuite() { chip::Platform::MemoryShutdown(); }
+};
+
+TEST_F(TestChipCert, TestChipCert_ChipToX509)
 {
     CHIP_ERROR err;
     ByteSpan inCert;
@@ -175,23 +179,23 @@
         TestCert certType = gTestCerts[i];
 
         err = GetTestCert(certType, sNullLoadFlag, inCert);
-        NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
+        EXPECT_EQ(err, CHIP_NO_ERROR);
         err = GetTestCert(certType, sDerFormFlag, expectedOutCert);
-        NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
+        EXPECT_EQ(err, CHIP_NO_ERROR);
 
         MutableByteSpan outCert(outCertBuf);
         err = ConvertChipCertToX509Cert(inCert, outCert);
-        NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
-        NL_TEST_ASSERT(inSuite, expectedOutCert.data_equal(outCert));
+        EXPECT_EQ(err, CHIP_NO_ERROR);
+        EXPECT_TRUE(expectedOutCert.data_equal(outCert));
     }
 
     // Error Case:
     MutableByteSpan outCert(outCertBuf);
     err = ConvertChipCertToX509Cert(sTestCert_Node01_01_Err01_Chip, outCert);
-    NL_TEST_ASSERT(inSuite, err == CHIP_ERROR_INVALID_TLV_TAG);
+    EXPECT_EQ(err, CHIP_ERROR_INVALID_TLV_TAG);
 }
 
-static void TestChipCert_ChipToX509_ErrorCases(nlTestSuite * inSuite, void * inContext)
+TEST_F(TestChipCert, TestChipCert_ChipToX509_ErrorCases)
 {
     CHIP_ERROR err;
     uint8_t outCertBuf[kMaxDERCertLength];
@@ -201,22 +205,22 @@
         MutableByteSpan outCert(outCertBuf);
 
         err = ConvertChipCertToX509Cert(chipCert, outCert);
-        NL_TEST_ASSERT(inSuite, err != CHIP_NO_ERROR);
+        EXPECT_NE(err, CHIP_NO_ERROR);
     }
 }
 
-static void TestChipCert_ChipCertLoad_ErrorCases(nlTestSuite * inSuite, void * inContext)
+TEST_F(TestChipCert, TestChipCert_ChipCertLoad_ErrorCases)
 {
     CHIP_ERROR err;
     ChipCertificateSet certSet;
 
     err = certSet.Init(1);
-    NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
+    EXPECT_EQ(err, CHIP_NO_ERROR);
 
     for (auto chipCert : gTestCert_ChipCertLoad_ErrorCases)
     {
         err = certSet.LoadCert(chipCert, sNullDecodeFlag);
-        NL_TEST_ASSERT(inSuite, err != CHIP_NO_ERROR);
+        EXPECT_NE(err, CHIP_NO_ERROR);
 
         certSet.Clear();
     }
@@ -224,34 +228,34 @@
     certSet.Release();
 }
 
-static void TestChipCert_ValidateChipRCAC_ErrorCases(nlTestSuite * inSuite, void * inContext)
+TEST_F(TestChipCert, TestChipCert_ValidateChipRCAC_ErrorCases)
 {
     CHIP_ERROR err;
 
     for (auto chipCert : gTestCert_ValidateChipRCAC_ErrorCases)
     {
         err = ValidateChipRCAC(chipCert);
-        NL_TEST_ASSERT(inSuite, err != CHIP_NO_ERROR);
+        EXPECT_NE(err, CHIP_NO_ERROR);
     }
 }
 
-static void TestChipCert_GetCertType_ErrorCases(nlTestSuite * inSuite, void * inContext)
+TEST_F(TestChipCert, TestChipCert_GetCertType_ErrorCases)
 {
     CHIP_ERROR err;
     ChipCertificateSet certSet;
 
     err = certSet.Init(1);
-    NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
+    EXPECT_EQ(err, CHIP_NO_ERROR);
 
     for (auto chipCert : gTestCert_GetCertType_ErrorCases)
     {
         CertType certType;
 
         err = certSet.LoadCert(chipCert, sNullDecodeFlag);
-        NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
+        EXPECT_EQ(err, CHIP_NO_ERROR);
 
         err = certSet.GetCertSet()->mSubjectDN.GetCertType(certType);
-        NL_TEST_ASSERT(inSuite, err != CHIP_NO_ERROR || certType == CertType::kNotSpecified);
+        EXPECT_TRUE(err != CHIP_NO_ERROR || certType == CertType::kNotSpecified);
 
         certSet.Clear();
     }
@@ -259,7 +263,7 @@
     certSet.Release();
 }
 
-static void TestChipCert_X509ToChip(nlTestSuite * inSuite, void * inContext)
+TEST_F(TestChipCert, TestChipCert_X509ToChip)
 {
     CHIP_ERROR err;
     ByteSpan inCert;
@@ -271,18 +275,18 @@
         TestCert certType = gTestCerts[i];
 
         err = GetTestCert(certType, sDerFormFlag, inCert);
-        NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
+        EXPECT_EQ(err, CHIP_NO_ERROR);
         err = GetTestCert(certType, sNullLoadFlag, expectedOutCert);
-        NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
+        EXPECT_EQ(err, CHIP_NO_ERROR);
 
         MutableByteSpan outCert(outCertBuf);
         err = ConvertX509CertToChipCert(inCert, outCert);
-        NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
-        NL_TEST_ASSERT(inSuite, expectedOutCert.data_equal(outCert));
+        EXPECT_EQ(err, CHIP_NO_ERROR);
+        EXPECT_TRUE(expectedOutCert.data_equal(outCert));
     }
 }
 
-static void TestChipCert_X509ToChip_ErrorCases(nlTestSuite * inSuite, void * inContext)
+TEST_F(TestChipCert, TestChipCert_X509ToChip_ErrorCases)
 {
     CHIP_ERROR err;
     uint8_t outCertBuf[kMaxCHIPCertLength];
@@ -292,11 +296,11 @@
         MutableByteSpan outCert(outCertBuf);
 
         err = ConvertX509CertToChipCert(derCert, outCert);
-        NL_TEST_ASSERT(inSuite, err != CHIP_NO_ERROR);
+        EXPECT_NE(err, CHIP_NO_ERROR);
     }
 }
 
-static void TestChipCert_ChipDN(nlTestSuite * inSuite, void * inContext)
+TEST_F(TestChipCert, TestChipCert_ChipDN)
 {
     const static char noc_rdn[]     = "Test NOC";
     const static char noc_rdn2[]    = "John";
@@ -305,51 +309,51 @@
     ChipDN chip_dn;
     CertType certType = CertType::kFirmwareSigning; // Start with non-default value
 
-    NL_TEST_ASSERT(inSuite, chip_dn.IsEmpty());
-    NL_TEST_ASSERT(inSuite, chip_dn.RDNCount() == 0);
-    NL_TEST_ASSERT(inSuite, chip_dn.GetCertType(certType) == CHIP_NO_ERROR);
-    NL_TEST_ASSERT(inSuite, chip_dn.IsEmpty() == true);
-    NL_TEST_ASSERT(inSuite, certType == CertType::kNotSpecified);
+    EXPECT_TRUE(chip_dn.IsEmpty());
+    EXPECT_EQ(chip_dn.RDNCount(), 0);
+    EXPECT_EQ(chip_dn.GetCertType(certType), CHIP_NO_ERROR);
+    EXPECT_TRUE(chip_dn.IsEmpty());
+    EXPECT_EQ(certType, CertType::kNotSpecified);
 
-    NL_TEST_ASSERT(inSuite, chip_dn.AddAttribute_CommonName(CharSpan(noc_rdn, strlen(noc_rdn)), false) == CHIP_NO_ERROR);
-    NL_TEST_ASSERT(inSuite, chip_dn.AddAttribute_MatterNodeId(0xAAAABBBBCCCCDDDD) == CHIP_NO_ERROR);
-    NL_TEST_ASSERT(inSuite, chip_dn.AddAttribute_MatterFabricId(0xFAB00000FAB00001) == CHIP_NO_ERROR);
-    NL_TEST_ASSERT(inSuite, chip_dn.AddAttribute_GivenName(CharSpan(noc_rdn2, strlen(noc_rdn2)), true) == CHIP_NO_ERROR);
-    NL_TEST_ASSERT(inSuite, chip_dn.AddCATs(noc_cats) == CHIP_NO_ERROR);
-    NL_TEST_ASSERT(inSuite, chip_dn.RDNCount() == 5);
+    EXPECT_EQ(chip_dn.AddAttribute_CommonName(CharSpan(noc_rdn, strlen(noc_rdn)), false), CHIP_NO_ERROR);
+    EXPECT_EQ(chip_dn.AddAttribute_MatterNodeId(0xAAAABBBBCCCCDDDD), CHIP_NO_ERROR);
+    EXPECT_EQ(chip_dn.AddAttribute_MatterFabricId(0xFAB00000FAB00001), CHIP_NO_ERROR);
+    EXPECT_EQ(chip_dn.AddAttribute_GivenName(CharSpan(noc_rdn2, strlen(noc_rdn2)), true), CHIP_NO_ERROR);
+    EXPECT_EQ(chip_dn.AddCATs(noc_cats), CHIP_NO_ERROR);
+    EXPECT_EQ(chip_dn.RDNCount(), 5);
 
-    NL_TEST_ASSERT(inSuite, chip_dn.AddAttribute_GivenName(CharSpan(noc_rdn2, strlen(noc_rdn2)), true) == CHIP_ERROR_NO_MEMORY);
-    NL_TEST_ASSERT(inSuite, chip_dn.RDNCount() == 5);
+    EXPECT_EQ(chip_dn.AddAttribute_GivenName(CharSpan(noc_rdn2, strlen(noc_rdn2)), true), CHIP_ERROR_NO_MEMORY);
+    EXPECT_EQ(chip_dn.RDNCount(), 5);
 
-    NL_TEST_ASSERT(inSuite, chip_dn.GetCertType(certType) == CHIP_NO_ERROR);
-    NL_TEST_ASSERT(inSuite, certType == CertType::kNode);
+    EXPECT_EQ(chip_dn.GetCertType(certType), CHIP_NO_ERROR);
+    EXPECT_EQ(certType, CertType::kNode);
 
     uint64_t certId;
-    NL_TEST_ASSERT(inSuite, chip_dn.GetCertChipId(certId) == CHIP_NO_ERROR);
-    NL_TEST_ASSERT(inSuite, certId == 0xAAAABBBBCCCCDDDD);
+    EXPECT_EQ(chip_dn.GetCertChipId(certId), CHIP_NO_ERROR);
+    EXPECT_EQ(certId, 0xAAAABBBBCCCCDDDD);
 
     uint64_t fabricId;
-    NL_TEST_ASSERT(inSuite, chip_dn.GetCertFabricId(fabricId) == CHIP_NO_ERROR);
-    NL_TEST_ASSERT(inSuite, fabricId == 0xFAB00000FAB00001);
+    EXPECT_EQ(chip_dn.GetCertFabricId(fabricId), CHIP_NO_ERROR);
+    EXPECT_EQ(fabricId, 0xFAB00000FAB00001);
 
     chip_dn.Clear();
-    NL_TEST_ASSERT(inSuite, chip_dn.GetCertType(certType) == CHIP_NO_ERROR);
-    NL_TEST_ASSERT(inSuite, chip_dn.IsEmpty() == true);
-    NL_TEST_ASSERT(inSuite, certType == CertType::kNotSpecified);
+    EXPECT_EQ(chip_dn.GetCertType(certType), CHIP_NO_ERROR);
+    EXPECT_TRUE(chip_dn.IsEmpty());
+    EXPECT_EQ(certType, CertType::kNotSpecified);
 
     CATValues noc_cats2;
     chip::CATValues::Serialized serializedCATs;
-    NL_TEST_ASSERT(inSuite, noc_cats.Serialize(serializedCATs) == CHIP_NO_ERROR);
-    NL_TEST_ASSERT(inSuite, noc_cats2.Deserialize(serializedCATs) == CHIP_NO_ERROR);
-    NL_TEST_ASSERT(inSuite, memcmp(&noc_cats, &noc_cats2, chip::CATValues::kSerializedLength) == 0);
+    EXPECT_EQ(noc_cats.Serialize(serializedCATs), CHIP_NO_ERROR);
+    EXPECT_EQ(noc_cats2.Deserialize(serializedCATs), CHIP_NO_ERROR);
+    EXPECT_EQ(memcmp(&noc_cats, &noc_cats2, chip::CATValues::kSerializedLength), 0);
 
     CATValues noc_cats3 = { { 0xABCD0001, 0xFFEEAA00, 0x0001F012 } };
-    NL_TEST_ASSERT(inSuite, noc_cats3.Serialize(serializedCATs) == CHIP_NO_ERROR);
-    NL_TEST_ASSERT(inSuite, noc_cats2.Deserialize(serializedCATs) == CHIP_NO_ERROR);
-    NL_TEST_ASSERT(inSuite, memcmp(&noc_cats3, &noc_cats2, chip::CATValues::kSerializedLength) == 0);
+    EXPECT_EQ(noc_cats3.Serialize(serializedCATs), CHIP_NO_ERROR);
+    EXPECT_EQ(noc_cats2.Deserialize(serializedCATs), CHIP_NO_ERROR);
+    EXPECT_EQ(memcmp(&noc_cats3, &noc_cats2, chip::CATValues::kSerializedLength), 0);
 }
 
-static void TestChipCert_CertValidation(nlTestSuite * inSuite, void * inContext)
+TEST_F(TestChipCert, TestChipCert_CertValidation)
 {
     CHIP_ERROR err;
     ChipCertificateSet certSet;
@@ -512,29 +516,28 @@
     {
         const ChipCertificateData * resultCert = nullptr;
         err                                    = certSet.Init(kMaxCertsPerTestCase);
-        NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
+        EXPECT_EQ(err, CHIP_NO_ERROR);
 
         for (auto inputCert : testCase.InputCerts)
         {
             if (inputCert.Type != TestCert::kNone)
             {
                 err = LoadTestCert(certSet, inputCert.Type, inputCert.LoadFlags, inputCert.DecodeFlags);
-                NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
+                EXPECT_EQ(err, CHIP_NO_ERROR);
             }
         }
         // Make sure the test case is valid.
-        NL_TEST_ASSERT(inSuite, testCase.mSubjectCertIndex >= 0 && testCase.mSubjectCertIndex < certSet.GetCertCount());
+        EXPECT_TRUE(testCase.mSubjectCertIndex >= 0 && testCase.mSubjectCertIndex < certSet.GetCertCount());
         if (testCase.mExpectedResult == CHIP_NO_ERROR)
         {
-            NL_TEST_ASSERT(inSuite, testCase.mExpectedCertIndex >= 0 && testCase.mExpectedCertIndex < certSet.GetCertCount());
-            NL_TEST_ASSERT(inSuite,
-                           testCase.mExpectedTrustAnchorIndex >= 0 && testCase.mExpectedTrustAnchorIndex < certSet.GetCertCount());
+            EXPECT_TRUE(testCase.mExpectedCertIndex >= 0 && testCase.mExpectedCertIndex < certSet.GetCertCount());
+            EXPECT_TRUE(testCase.mExpectedTrustAnchorIndex >= 0 && testCase.mExpectedTrustAnchorIndex < certSet.GetCertCount());
         }
 
         // Initialize the validation context.
         validContext.Reset();
         err = SetCurrentTime(validContext, 2021, 1, 1);
-        NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
+        EXPECT_EQ(err, CHIP_NO_ERROR);
         validContext.mRequiredKeyUsages.Set(KeyUsageFlags::kDigitalSignature);
         validContext.mRequiredKeyPurposes.Set(KeyPurposeFlags::kServerAuth);
         validContext.mRequiredKeyPurposes.Set(KeyPurposeFlags::kClientAuth);
@@ -546,16 +549,16 @@
 
         // Invoke the FindValidCert() method (the method being tested).
         err = certSet.FindValidCert(subjectDN, subjectKeyId, validContext, &resultCert);
-        NL_TEST_ASSERT(inSuite, err == testCase.mExpectedResult);
+        EXPECT_EQ(err, testCase.mExpectedResult);
 
         // If the test case is expected to be successful...
         if (err == CHIP_NO_ERROR)
         {
             // Verify that the method found the correct certificate.
-            NL_TEST_ASSERT(inSuite, resultCert == &certSet.GetCertSet()[testCase.mExpectedCertIndex]);
+            EXPECT_EQ(resultCert, &certSet.GetCertSet()[testCase.mExpectedCertIndex]);
 
             // Verify that the method selected the correct trust anchor.
-            NL_TEST_ASSERT(inSuite, validContext.mTrustAnchor == &certSet.GetCertSet()[testCase.mExpectedTrustAnchorIndex]);
+            EXPECT_EQ(validContext.mTrustAnchor, &certSet.GetCertSet()[testCase.mExpectedTrustAnchorIndex]);
         }
 
         // Clear the certificate set.
@@ -563,17 +566,17 @@
     }
 }
 
-static void TestChipCert_CertValidTime(nlTestSuite * inSuite, void * inContext)
+TEST_F(TestChipCert, TestChipCert_CertValidTime)
 {
     CHIP_ERROR err;
     ChipCertificateSet certSet;
     ValidationContext validContext;
 
     err = certSet.Init(kStandardCertsCount);
-    NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
+    EXPECT_EQ(err, CHIP_NO_ERROR);
 
     err = LoadTestCertSet01(certSet);
-    NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
+    EXPECT_EQ(err, CHIP_NO_ERROR);
 
     validContext.Reset();
     validContext.mRequiredKeyUsages.Set(KeyUsageFlags::kDigitalSignature);
@@ -588,248 +591,248 @@
     // Default policy
     validContext.mValidityPolicy = nullptr;
     err                          = certSet.ValidateCert(certSet.GetLastCert(), validContext);
-    NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
+    EXPECT_EQ(err, CHIP_NO_ERROR);
     // Strict policy
     validContext.mValidityPolicy = &strictCertificateValidityPolicy;
     err                          = certSet.ValidateCert(certSet.GetLastCert(), validContext);
-    NL_TEST_ASSERT(inSuite, err == CHIP_ERROR_CERT_EXPIRED);
+    EXPECT_EQ(err, CHIP_ERROR_CERT_EXPIRED);
     // Last Known Good Time policy
     validContext.mValidityPolicy = &lastKnownGoodTimeValidityPolicy;
     err                          = certSet.ValidateCert(certSet.GetLastCert(), validContext);
-    NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
+    EXPECT_EQ(err, CHIP_NO_ERROR);
 
     // Current time before certificate validity period.
     err = SetCurrentTime(validContext, 2020, 1, 3);
-    NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
+    EXPECT_EQ(err, CHIP_NO_ERROR);
     // Default policy
     validContext.mValidityPolicy = nullptr;
     err                          = certSet.ValidateCert(certSet.GetLastCert(), validContext);
-    NL_TEST_ASSERT(inSuite, err == CHIP_ERROR_CERT_NOT_VALID_YET);
+    EXPECT_EQ(err, CHIP_ERROR_CERT_NOT_VALID_YET);
     // Strict policy
     validContext.mValidityPolicy = &strictCertificateValidityPolicy;
     err                          = certSet.ValidateCert(certSet.GetLastCert(), validContext);
-    NL_TEST_ASSERT(inSuite, err == CHIP_ERROR_CERT_NOT_VALID_YET);
+    EXPECT_EQ(err, CHIP_ERROR_CERT_NOT_VALID_YET);
     // Last Known Good Time policy
     validContext.mValidityPolicy = &lastKnownGoodTimeValidityPolicy;
     err                          = certSet.ValidateCert(certSet.GetLastCert(), validContext);
-    NL_TEST_ASSERT(inSuite, err == CHIP_ERROR_CERT_NOT_VALID_YET);
+    EXPECT_EQ(err, CHIP_ERROR_CERT_NOT_VALID_YET);
 
     // Current time 1 second before validity period.
     err = SetCurrentTime(validContext, 2020, 10, 15, 14, 23, 42);
-    NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
+    EXPECT_EQ(err, CHIP_NO_ERROR);
     // Default policy
     validContext.mValidityPolicy = nullptr;
     err                          = certSet.ValidateCert(certSet.GetLastCert(), validContext);
-    NL_TEST_ASSERT(inSuite, err == CHIP_ERROR_CERT_NOT_VALID_YET);
+    EXPECT_EQ(err, CHIP_ERROR_CERT_NOT_VALID_YET);
     // Strict policy
     validContext.mValidityPolicy = &strictCertificateValidityPolicy;
     err                          = certSet.ValidateCert(certSet.GetLastCert(), validContext);
-    NL_TEST_ASSERT(inSuite, err == CHIP_ERROR_CERT_NOT_VALID_YET);
+    EXPECT_EQ(err, CHIP_ERROR_CERT_NOT_VALID_YET);
     // Last Known Good Time policy
     validContext.mValidityPolicy = &lastKnownGoodTimeValidityPolicy;
     err                          = certSet.ValidateCert(certSet.GetLastCert(), validContext);
-    NL_TEST_ASSERT(inSuite, err == CHIP_ERROR_CERT_NOT_VALID_YET);
+    EXPECT_EQ(err, CHIP_ERROR_CERT_NOT_VALID_YET);
 
     // Current time 1st second of validity period.
     err = SetCurrentTime(validContext, 2020, 10, 15, 14, 23, 43);
-    NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
+    EXPECT_EQ(err, CHIP_NO_ERROR);
     // Default policy
     validContext.mValidityPolicy = nullptr;
     err                          = certSet.ValidateCert(certSet.GetLastCert(), validContext);
-    NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
+    EXPECT_EQ(err, CHIP_NO_ERROR);
     // Strict policy
     validContext.mValidityPolicy = &strictCertificateValidityPolicy;
     err                          = certSet.ValidateCert(certSet.GetLastCert(), validContext);
-    NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
+    EXPECT_EQ(err, CHIP_NO_ERROR);
     // Last Known Good Time policy
     validContext.mValidityPolicy = &lastKnownGoodTimeValidityPolicy;
     err                          = certSet.ValidateCert(certSet.GetLastCert(), validContext);
-    NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
+    EXPECT_EQ(err, CHIP_NO_ERROR);
 
     // Current time within validity period.
     err = SetCurrentTime(validContext, 2022, 02, 23, 12, 30, 01);
-    NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
+    EXPECT_EQ(err, CHIP_NO_ERROR);
     // Default policy
     validContext.mValidityPolicy = nullptr;
     err                          = certSet.ValidateCert(certSet.GetLastCert(), validContext);
-    NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
+    EXPECT_EQ(err, CHIP_NO_ERROR);
     // Strict policy
     validContext.mValidityPolicy = &strictCertificateValidityPolicy;
     err                          = certSet.ValidateCert(certSet.GetLastCert(), validContext);
-    NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
+    EXPECT_EQ(err, CHIP_NO_ERROR);
     // Last Known Good Time policy
     validContext.mValidityPolicy = &lastKnownGoodTimeValidityPolicy;
     err                          = certSet.ValidateCert(certSet.GetLastCert(), validContext);
-    NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
+    EXPECT_EQ(err, CHIP_NO_ERROR);
 
     // Current time at last second of validity period.
     err = SetCurrentTime(validContext, 2040, 10, 15, 14, 23, 42);
-    NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
+    EXPECT_EQ(err, CHIP_NO_ERROR);
     // Default policy
     validContext.mValidityPolicy = nullptr;
     err                          = certSet.ValidateCert(certSet.GetLastCert(), validContext);
-    NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
+    EXPECT_EQ(err, CHIP_NO_ERROR);
     // Strict policy
     validContext.mValidityPolicy = &strictCertificateValidityPolicy;
     err                          = certSet.ValidateCert(certSet.GetLastCert(), validContext);
-    NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
+    EXPECT_EQ(err, CHIP_NO_ERROR);
     // Last Known Good Time policy
     validContext.mValidityPolicy = &lastKnownGoodTimeValidityPolicy;
     err                          = certSet.ValidateCert(certSet.GetLastCert(), validContext);
-    NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
+    EXPECT_EQ(err, CHIP_NO_ERROR);
 
     // Current time at 1 second after end of certificate validity period.
     err = SetCurrentTime(validContext, 2040, 10, 15, 14, 23, 43);
-    NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
+    EXPECT_EQ(err, CHIP_NO_ERROR);
     // Default policy
     validContext.mValidityPolicy = nullptr;
     err                          = certSet.ValidateCert(certSet.GetLastCert(), validContext);
-    NL_TEST_ASSERT(inSuite, err == CHIP_ERROR_CERT_EXPIRED);
+    EXPECT_EQ(err, CHIP_ERROR_CERT_EXPIRED);
     // Strict policy
     validContext.mValidityPolicy = &strictCertificateValidityPolicy;
     err                          = certSet.ValidateCert(certSet.GetLastCert(), validContext);
-    NL_TEST_ASSERT(inSuite, err == CHIP_ERROR_CERT_EXPIRED);
+    EXPECT_EQ(err, CHIP_ERROR_CERT_EXPIRED);
     // Last Known Good Time policy
     validContext.mValidityPolicy = &lastKnownGoodTimeValidityPolicy;
     err                          = certSet.ValidateCert(certSet.GetLastCert(), validContext);
-    NL_TEST_ASSERT(inSuite, err == CHIP_ERROR_CERT_EXPIRED);
+    EXPECT_EQ(err, CHIP_ERROR_CERT_EXPIRED);
 
     // Current time after end of certificate validity period.
     err = SetCurrentTime(validContext, 2042, 4, 25, 0, 0, 0);
-    NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
+    EXPECT_EQ(err, CHIP_NO_ERROR);
     // Default policy
     validContext.mValidityPolicy = nullptr;
     err                          = certSet.ValidateCert(certSet.GetLastCert(), validContext);
-    NL_TEST_ASSERT(inSuite, err == CHIP_ERROR_CERT_EXPIRED);
+    EXPECT_EQ(err, CHIP_ERROR_CERT_EXPIRED);
     // Strict policy
     validContext.mValidityPolicy = &strictCertificateValidityPolicy;
     err                          = certSet.ValidateCert(certSet.GetLastCert(), validContext);
-    NL_TEST_ASSERT(inSuite, err == CHIP_ERROR_CERT_EXPIRED);
+    EXPECT_EQ(err, CHIP_ERROR_CERT_EXPIRED);
     // Last Known Good Time policy
     validContext.mValidityPolicy = &lastKnownGoodTimeValidityPolicy;
     err                          = certSet.ValidateCert(certSet.GetLastCert(), validContext);
-    NL_TEST_ASSERT(inSuite, err == CHIP_ERROR_CERT_EXPIRED);
+    EXPECT_EQ(err, CHIP_ERROR_CERT_EXPIRED);
 
     // Last known good time before certificate validity period.
     // We can't invalidate based on NotBefore with Last Known Good Time.
     // Hence, we expect CHIP_NO_ERROR.
     err = SetLastKnownGoodTime(validContext, 2020, 1, 3);
-    NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
+    EXPECT_EQ(err, CHIP_NO_ERROR);
     // Default policy
     validContext.mValidityPolicy = nullptr;
     err                          = certSet.ValidateCert(certSet.GetLastCert(), validContext);
-    NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
+    EXPECT_EQ(err, CHIP_NO_ERROR);
     // Strict policy
     validContext.mValidityPolicy = &strictCertificateValidityPolicy;
     err                          = certSet.ValidateCert(certSet.GetLastCert(), validContext);
-    NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
+    EXPECT_EQ(err, CHIP_NO_ERROR);
     // Last Known Good Time policy
     validContext.mValidityPolicy = &lastKnownGoodTimeValidityPolicy;
     err                          = certSet.ValidateCert(certSet.GetLastCert(), validContext);
-    NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
+    EXPECT_EQ(err, CHIP_NO_ERROR);
 
     // Last known good time 1 second before certificate validity period.
     // We can't invalidate based on NotBefore with Last Known Good Time.
     // Hence, we expect CHIP_NO_ERROR.
     err = SetLastKnownGoodTime(validContext, 2020, 10, 15, 14, 23, 42);
-    NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
+    EXPECT_EQ(err, CHIP_NO_ERROR);
     // Default policy
     validContext.mValidityPolicy = nullptr;
     err                          = certSet.ValidateCert(certSet.GetLastCert(), validContext);
-    NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
+    EXPECT_EQ(err, CHIP_NO_ERROR);
     // Strict policy
     validContext.mValidityPolicy = &strictCertificateValidityPolicy;
     err                          = certSet.ValidateCert(certSet.GetLastCert(), validContext);
-    NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
+    EXPECT_EQ(err, CHIP_NO_ERROR);
     // Last Known Good Time policy
     validContext.mValidityPolicy = &lastKnownGoodTimeValidityPolicy;
     err                          = certSet.ValidateCert(certSet.GetLastCert(), validContext);
-    NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
+    EXPECT_EQ(err, CHIP_NO_ERROR);
 
     // Last Known Good Time 1st second of validity period.
     err = SetLastKnownGoodTime(validContext, 2020, 10, 15, 14, 23, 43);
-    NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
+    EXPECT_EQ(err, CHIP_NO_ERROR);
     // Default policy
     validContext.mValidityPolicy = nullptr;
     err                          = certSet.ValidateCert(certSet.GetLastCert(), validContext);
-    NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
+    EXPECT_EQ(err, CHIP_NO_ERROR);
     // Strict policy
     validContext.mValidityPolicy = &strictCertificateValidityPolicy;
     err                          = certSet.ValidateCert(certSet.GetLastCert(), validContext);
-    NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
+    EXPECT_EQ(err, CHIP_NO_ERROR);
     // Last Known Good Time policy
     validContext.mValidityPolicy = &lastKnownGoodTimeValidityPolicy;
     err                          = certSet.ValidateCert(certSet.GetLastCert(), validContext);
-    NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
+    EXPECT_EQ(err, CHIP_NO_ERROR);
 
     // Last Known Good Time within validity period.
     err = SetLastKnownGoodTime(validContext, 2022, 02, 23, 12, 30, 01);
-    NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
+    EXPECT_EQ(err, CHIP_NO_ERROR);
     // Default policy
     validContext.mValidityPolicy = nullptr;
     err                          = certSet.ValidateCert(certSet.GetLastCert(), validContext);
-    NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
+    EXPECT_EQ(err, CHIP_NO_ERROR);
     // Strict policy
     validContext.mValidityPolicy = &strictCertificateValidityPolicy;
     err                          = certSet.ValidateCert(certSet.GetLastCert(), validContext);
-    NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
+    EXPECT_EQ(err, CHIP_NO_ERROR);
     // Last Known Good Time policy
     validContext.mValidityPolicy = &lastKnownGoodTimeValidityPolicy;
     err                          = certSet.ValidateCert(certSet.GetLastCert(), validContext);
-    NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
+    EXPECT_EQ(err, CHIP_NO_ERROR);
 
     // Last Known Good Time at last second of validity period.
     err = SetLastKnownGoodTime(validContext, 2040, 10, 15, 14, 23, 42);
-    NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
+    EXPECT_EQ(err, CHIP_NO_ERROR);
     // Default policy
     validContext.mValidityPolicy = nullptr;
     err                          = certSet.ValidateCert(certSet.GetLastCert(), validContext);
-    NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
+    EXPECT_EQ(err, CHIP_NO_ERROR);
     // Strict policy
     validContext.mValidityPolicy = &strictCertificateValidityPolicy;
     err                          = certSet.ValidateCert(certSet.GetLastCert(), validContext);
-    NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
+    EXPECT_EQ(err, CHIP_NO_ERROR);
     // Last Known Good Time policy
     validContext.mValidityPolicy = &lastKnownGoodTimeValidityPolicy;
     err                          = certSet.ValidateCert(certSet.GetLastCert(), validContext);
-    NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
+    EXPECT_EQ(err, CHIP_NO_ERROR);
 
     // Last Known Good Time at 1 second after end of certificate validity period.
     err = SetLastKnownGoodTime(validContext, 2040, 10, 15, 14, 23, 43);
-    NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
+    EXPECT_EQ(err, CHIP_NO_ERROR);
     // Default policy
     validContext.mValidityPolicy = nullptr;
     err                          = certSet.ValidateCert(certSet.GetLastCert(), validContext);
-    NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
+    EXPECT_EQ(err, CHIP_NO_ERROR);
     // Strict policy
     validContext.mValidityPolicy = &strictCertificateValidityPolicy;
     err                          = certSet.ValidateCert(certSet.GetLastCert(), validContext);
-    NL_TEST_ASSERT(inSuite, err == CHIP_ERROR_CERT_EXPIRED);
+    EXPECT_EQ(err, CHIP_ERROR_CERT_EXPIRED);
     // Last Known Good Time policy
     validContext.mValidityPolicy = &lastKnownGoodTimeValidityPolicy;
     err                          = certSet.ValidateCert(certSet.GetLastCert(), validContext);
-    NL_TEST_ASSERT(inSuite, err == CHIP_ERROR_CERT_EXPIRED);
+    EXPECT_EQ(err, CHIP_ERROR_CERT_EXPIRED);
 
     // Last Known Good Time after end of certificate validity period.
     err = SetLastKnownGoodTime(validContext, 2042, 4, 25, 0, 0, 0);
-    NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
+    EXPECT_EQ(err, CHIP_NO_ERROR);
     // Default policy
     validContext.mValidityPolicy = nullptr;
     err                          = certSet.ValidateCert(certSet.GetLastCert(), validContext);
-    NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
+    EXPECT_EQ(err, CHIP_NO_ERROR);
     // Strict policy
     validContext.mValidityPolicy = &strictCertificateValidityPolicy;
     err                          = certSet.ValidateCert(certSet.GetLastCert(), validContext);
-    NL_TEST_ASSERT(inSuite, err == CHIP_ERROR_CERT_EXPIRED);
+    EXPECT_EQ(err, CHIP_ERROR_CERT_EXPIRED);
     // Last Known Good Time policy
     validContext.mValidityPolicy = &lastKnownGoodTimeValidityPolicy;
     err                          = certSet.ValidateCert(certSet.GetLastCert(), validContext);
-    NL_TEST_ASSERT(inSuite, err == CHIP_ERROR_CERT_EXPIRED);
+    EXPECT_EQ(err, CHIP_ERROR_CERT_EXPIRED);
 
     certSet.Release();
 }
 
-static void TestChipCert_ValidateChipRCAC(nlTestSuite * inSuite, void * inContext)
+TEST_F(TestChipCert, TestChipCert_ValidateChipRCAC)
 {
     struct RCACTestCase
     {
@@ -855,8 +858,8 @@
     for (auto & testCase : sRCACTestCases)
     {
         ByteSpan cert;
-        NL_TEST_ASSERT(inSuite, GetTestCert(testCase.Cert, sNullLoadFlag, cert) == CHIP_NO_ERROR);
-        NL_TEST_ASSERT(inSuite, ValidateChipRCAC(cert) == testCase.mExpectedResult);
+        EXPECT_EQ(GetTestCert(testCase.Cert, sNullLoadFlag, cert), CHIP_NO_ERROR);
+        EXPECT_EQ(ValidateChipRCAC(cert), testCase.mExpectedResult);
     }
 }
 
@@ -884,7 +887,7 @@
     }
 };
 
-static void TestChipCert_CertValidityPolicyInjection(nlTestSuite * inSuite, void * inContext)
+TEST_F(TestChipCert, TestChipCert_CertValidityPolicyInjection)
 {
     CHIP_ERROR err;
     ChipCertificateSet certSet;
@@ -895,10 +898,10 @@
     AlwaysRejectValidityPolicy alwaysRejectPolicy;
 
     err = certSet.Init(kStandardCertsCount);
-    NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
+    EXPECT_EQ(err, CHIP_NO_ERROR);
 
     err = LoadTestCertSet01(certSet);
-    NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
+    EXPECT_EQ(err, CHIP_NO_ERROR);
 
     validContext.Reset();
     validContext.mRequiredKeyUsages.Set(KeyUsageFlags::kDigitalSignature);
@@ -910,170 +913,170 @@
     // Default policy
     validContext.mValidityPolicy = nullptr;
     err                          = certSet.ValidateCert(certSet.GetLastCert(), validContext);
-    NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
+    EXPECT_EQ(err, CHIP_NO_ERROR);
     // Strict policy
     validContext.mValidityPolicy = &strictPolicy;
     err                          = certSet.ValidateCert(certSet.GetLastCert(), validContext);
-    NL_TEST_ASSERT(inSuite, err == CHIP_ERROR_CERT_EXPIRED);
+    EXPECT_EQ(err, CHIP_ERROR_CERT_EXPIRED);
     // Last Known Good Time policy
     validContext.mValidityPolicy = &lastKnownGoodTimePolicy;
     err                          = certSet.ValidateCert(certSet.GetLastCert(), validContext);
-    NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
+    EXPECT_EQ(err, CHIP_NO_ERROR);
     // Always accept policy
     validContext.mValidityPolicy = &alwaysAcceptPolicy;
     err                          = certSet.ValidateCert(certSet.GetLastCert(), validContext);
-    NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
+    EXPECT_EQ(err, CHIP_NO_ERROR);
     // Always reject policy
     validContext.mValidityPolicy = &alwaysRejectPolicy;
     err                          = certSet.ValidateCert(certSet.GetLastCert(), validContext);
-    NL_TEST_ASSERT(inSuite, err != CHIP_NO_ERROR);
+    EXPECT_NE(err, CHIP_NO_ERROR);
 
     // Curent time before certificate validity period.
     err = SetCurrentTime(validContext, 2020, 1, 3);
-    NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
+    EXPECT_EQ(err, CHIP_NO_ERROR);
 
     // Default policy
     validContext.mValidityPolicy = nullptr;
     err                          = certSet.ValidateCert(certSet.GetLastCert(), validContext);
-    NL_TEST_ASSERT(inSuite, err == CHIP_ERROR_CERT_NOT_VALID_YET);
+    EXPECT_EQ(err, CHIP_ERROR_CERT_NOT_VALID_YET);
     // Strict policy
     validContext.mValidityPolicy = &strictPolicy;
     err                          = certSet.ValidateCert(certSet.GetLastCert(), validContext);
-    NL_TEST_ASSERT(inSuite, err == CHIP_ERROR_CERT_NOT_VALID_YET);
+    EXPECT_EQ(err, CHIP_ERROR_CERT_NOT_VALID_YET);
     // Last Known Good Time policy
     validContext.mValidityPolicy = &lastKnownGoodTimePolicy;
     err                          = certSet.ValidateCert(certSet.GetLastCert(), validContext);
-    NL_TEST_ASSERT(inSuite, err == CHIP_ERROR_CERT_NOT_VALID_YET);
+    EXPECT_EQ(err, CHIP_ERROR_CERT_NOT_VALID_YET);
     // Always accept policy
     validContext.mValidityPolicy = &alwaysAcceptPolicy;
     err                          = certSet.ValidateCert(certSet.GetLastCert(), validContext);
-    NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
+    EXPECT_EQ(err, CHIP_NO_ERROR);
     // Always reject policy
     validContext.mValidityPolicy = &alwaysRejectPolicy;
     err                          = certSet.ValidateCert(certSet.GetLastCert(), validContext);
-    NL_TEST_ASSERT(inSuite, err != CHIP_NO_ERROR);
+    EXPECT_NE(err, CHIP_NO_ERROR);
 
     // Last known good time before certificate validity period.
     err = SetLastKnownGoodTime(validContext, 2020, 1, 3);
-    NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
+    EXPECT_EQ(err, CHIP_NO_ERROR);
 
     // Default policy
     validContext.mValidityPolicy = nullptr;
     err                          = certSet.ValidateCert(certSet.GetLastCert(), validContext);
-    NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
+    EXPECT_EQ(err, CHIP_NO_ERROR);
     // Strict policy
     validContext.mValidityPolicy = &strictPolicy;
     err                          = certSet.ValidateCert(certSet.GetLastCert(), validContext);
-    NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
+    EXPECT_EQ(err, CHIP_NO_ERROR);
     // Always accept policy
     validContext.mValidityPolicy = &alwaysAcceptPolicy;
     err                          = certSet.ValidateCert(certSet.GetLastCert(), validContext);
-    NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
+    EXPECT_EQ(err, CHIP_NO_ERROR);
     // Always reject policy
     validContext.mValidityPolicy = &alwaysRejectPolicy;
     err                          = certSet.ValidateCert(certSet.GetLastCert(), validContext);
-    NL_TEST_ASSERT(inSuite, err != CHIP_NO_ERROR);
+    EXPECT_NE(err, CHIP_NO_ERROR);
 
     // Current time during validity period
     err = SetCurrentTime(validContext, 2022, 02, 23, 12, 30, 01);
-    NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
+    EXPECT_EQ(err, CHIP_NO_ERROR);
 
     // Default policy
     validContext.mValidityPolicy = nullptr;
     err                          = certSet.ValidateCert(certSet.GetLastCert(), validContext);
-    NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
+    EXPECT_EQ(err, CHIP_NO_ERROR);
     // Strict policy
     validContext.mValidityPolicy = &strictPolicy;
     err                          = certSet.ValidateCert(certSet.GetLastCert(), validContext);
-    NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
+    EXPECT_EQ(err, CHIP_NO_ERROR);
     // Always accept policy
     validContext.mValidityPolicy = &alwaysAcceptPolicy;
     err                          = certSet.ValidateCert(certSet.GetLastCert(), validContext);
-    NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
+    EXPECT_EQ(err, CHIP_NO_ERROR);
     // Always reject policy
     validContext.mValidityPolicy = &alwaysRejectPolicy;
     err                          = certSet.ValidateCert(certSet.GetLastCert(), validContext);
-    NL_TEST_ASSERT(inSuite, err != CHIP_NO_ERROR);
+    EXPECT_NE(err, CHIP_NO_ERROR);
 
     // Last Known Good Time during validity period
     err = SetLastKnownGoodTime(validContext, 2022, 02, 23, 12, 30, 01);
-    NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
+    EXPECT_EQ(err, CHIP_NO_ERROR);
 
     // Default policy
     validContext.mValidityPolicy = nullptr;
     err                          = certSet.ValidateCert(certSet.GetLastCert(), validContext);
-    NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
+    EXPECT_EQ(err, CHIP_NO_ERROR);
     // Strict policy
     validContext.mValidityPolicy = &strictPolicy;
     err                          = certSet.ValidateCert(certSet.GetLastCert(), validContext);
-    NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
+    EXPECT_EQ(err, CHIP_NO_ERROR);
     // Last Known Good Time policy
     validContext.mValidityPolicy = &lastKnownGoodTimePolicy;
     err                          = certSet.ValidateCert(certSet.GetLastCert(), validContext);
-    NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
+    EXPECT_EQ(err, CHIP_NO_ERROR);
     // Always accept policy
     validContext.mValidityPolicy = &alwaysAcceptPolicy;
     err                          = certSet.ValidateCert(certSet.GetLastCert(), validContext);
-    NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
+    EXPECT_EQ(err, CHIP_NO_ERROR);
     // Always reject policy
     validContext.mValidityPolicy = &alwaysRejectPolicy;
     err                          = certSet.ValidateCert(certSet.GetLastCert(), validContext);
-    NL_TEST_ASSERT(inSuite, err != CHIP_NO_ERROR);
+    EXPECT_NE(err, CHIP_NO_ERROR);
 
     // Current time after end of certificate validity period.
     err = SetCurrentTime(validContext, 2042, 4, 25, 0, 0, 0);
-    NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
+    EXPECT_EQ(err, CHIP_NO_ERROR);
 
     // Default policy
     validContext.mValidityPolicy = nullptr;
     err                          = certSet.ValidateCert(certSet.GetLastCert(), validContext);
-    NL_TEST_ASSERT(inSuite, err == CHIP_ERROR_CERT_EXPIRED);
+    EXPECT_EQ(err, CHIP_ERROR_CERT_EXPIRED);
     // Strict policy
     validContext.mValidityPolicy = &strictPolicy;
     err                          = certSet.ValidateCert(certSet.GetLastCert(), validContext);
-    NL_TEST_ASSERT(inSuite, err == CHIP_ERROR_CERT_EXPIRED);
+    EXPECT_EQ(err, CHIP_ERROR_CERT_EXPIRED);
     // Last Known Good Time policy
     validContext.mValidityPolicy = &lastKnownGoodTimePolicy;
     err                          = certSet.ValidateCert(certSet.GetLastCert(), validContext);
-    NL_TEST_ASSERT(inSuite, err == CHIP_ERROR_CERT_EXPIRED);
+    EXPECT_EQ(err, CHIP_ERROR_CERT_EXPIRED);
     // Always accept policy
     validContext.mValidityPolicy = &alwaysAcceptPolicy;
     err                          = certSet.ValidateCert(certSet.GetLastCert(), validContext);
-    NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
+    EXPECT_EQ(err, CHIP_NO_ERROR);
     // Always reject policy
     validContext.mValidityPolicy = &alwaysRejectPolicy;
     err                          = certSet.ValidateCert(certSet.GetLastCert(), validContext);
-    NL_TEST_ASSERT(inSuite, err != CHIP_NO_ERROR);
+    EXPECT_NE(err, CHIP_NO_ERROR);
 
     // Last Known Good Time after end of certificate validity period.
     err = SetLastKnownGoodTime(validContext, 2042, 4, 25, 0, 0, 0);
-    NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
+    EXPECT_EQ(err, CHIP_NO_ERROR);
 
     // Default policy
     validContext.mValidityPolicy = nullptr;
     err                          = certSet.ValidateCert(certSet.GetLastCert(), validContext);
-    NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
+    EXPECT_EQ(err, CHIP_NO_ERROR);
     // Strict policy
     validContext.mValidityPolicy = &strictPolicy;
     err                          = certSet.ValidateCert(certSet.GetLastCert(), validContext);
-    NL_TEST_ASSERT(inSuite, err == CHIP_ERROR_CERT_EXPIRED);
+    EXPECT_EQ(err, CHIP_ERROR_CERT_EXPIRED);
     // Last Known Good Time policy
     validContext.mValidityPolicy = &lastKnownGoodTimePolicy;
     err                          = certSet.ValidateCert(certSet.GetLastCert(), validContext);
-    NL_TEST_ASSERT(inSuite, err == CHIP_ERROR_CERT_EXPIRED);
+    EXPECT_EQ(err, CHIP_ERROR_CERT_EXPIRED);
     // Always accept policy
     validContext.mValidityPolicy = &alwaysAcceptPolicy;
     err                          = certSet.ValidateCert(certSet.GetLastCert(), validContext);
-    NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
+    EXPECT_EQ(err, CHIP_NO_ERROR);
     // Always reject policy
     validContext.mValidityPolicy = &alwaysRejectPolicy;
     err                          = certSet.ValidateCert(certSet.GetLastCert(), validContext);
-    NL_TEST_ASSERT(inSuite, err != CHIP_NO_ERROR);
+    EXPECT_NE(err, CHIP_NO_ERROR);
 
     certSet.Release();
 }
 
-static void TestChipCert_CertUsage(nlTestSuite * inSuite, void * inContext)
+TEST_F(TestChipCert, TestChipCert_CertUsage)
 {
     CHIP_ERROR err;
     ChipCertificateSet certSet;
@@ -1164,10 +1167,10 @@
     size_t sNumUsageTestCases = ArraySize(sUsageTestCases);
 
     err = certSet.Init(certDataArray, ArraySize(certDataArray));
-    NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
+    EXPECT_EQ(err, CHIP_NO_ERROR);
 
     err = LoadTestCertSet01(certSet);
-    NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
+    EXPECT_EQ(err, CHIP_NO_ERROR);
 
     for (size_t i = 0; i < sNumUsageTestCases; i++)
     {
@@ -1176,16 +1179,16 @@
         validContext.mRequiredKeyPurposes = sUsageTestCases[i].mRequiredKeyPurposes;
 
         err = SetCurrentTime(validContext, 2020, 10, 16);
-        NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
+        EXPECT_EQ(err, CHIP_NO_ERROR);
 
         err = certSet.ValidateCert(&certSet.GetCertSet()[sUsageTestCases[i].mCertIndex], validContext);
-        NL_TEST_ASSERT(inSuite, err == sUsageTestCases[i].mExpectedResult);
+        EXPECT_EQ(err, sUsageTestCases[i].mExpectedResult);
     }
 
     certSet.Release();
 }
 
-static void TestChipCert_CertType(nlTestSuite * inSuite, void * inContext)
+TEST_F(TestChipCert, TestChipCert_CertType)
 {
     CHIP_ERROR err;
     ChipCertificateData certData;
@@ -1218,16 +1221,16 @@
         CertType certType;
 
         err = DecodeTestCert(certData, testCase.Cert);
-        NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
+        EXPECT_EQ(err, CHIP_NO_ERROR);
 
         err = certData.mSubjectDN.GetCertType(certType);
-        NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
+        EXPECT_EQ(err, CHIP_NO_ERROR);
 
-        NL_TEST_ASSERT(inSuite, certType == testCase.ExpectedCertType);
+        EXPECT_EQ(certType, testCase.ExpectedCertType);
     }
 }
 
-static void TestChipCert_CertId(nlTestSuite * inSuite, void * inContext)
+TEST_F(TestChipCert, TestChipCert_CertId)
 {
     CHIP_ERROR err;
     ChipCertificateData certData;
@@ -1260,114 +1263,114 @@
         uint64_t chipId;
 
         err = DecodeTestCert(certData, testCase.Cert);
-        NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
+        EXPECT_EQ(err, CHIP_NO_ERROR);
 
         err = certData.mSubjectDN.GetCertChipId(chipId);
         if (testCase.ExpectedCertId != 0)
         {
-            NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
-            NL_TEST_ASSERT(inSuite, chipId == testCase.ExpectedCertId);
+            EXPECT_EQ(err, CHIP_NO_ERROR);
+            EXPECT_EQ(chipId, testCase.ExpectedCertId);
         }
         else
         {
-            NL_TEST_ASSERT(inSuite, err == CHIP_ERROR_WRONG_CERT_DN);
+            EXPECT_EQ(err, CHIP_ERROR_WRONG_CERT_DN);
         }
     }
 }
 
-static void TestChipCert_DecodingOptions(nlTestSuite * inSuite, void * inContext)
+TEST_F(TestChipCert, TestChipCert_DecodingOptions)
 {
     CHIP_ERROR err;
     ByteSpan cert;
     ChipCertificateData certData;
 
     err = GetTestCert(TestCert::kRoot01, sNullLoadFlag, cert);
-    NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
+    EXPECT_EQ(err, CHIP_NO_ERROR);
 
     // Decode with default (null) options
     err = DecodeChipCert(cert, certData);
-    NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
-    NL_TEST_ASSERT(inSuite, !certData.mCertFlags.Has(CertFlags::kIsTrustAnchor));
+    EXPECT_EQ(err, CHIP_NO_ERROR);
+    EXPECT_FALSE(certData.mCertFlags.Has(CertFlags::kIsTrustAnchor));
 
     // Decode as trust anchor
     err = DecodeChipCert(cert, certData, CertDecodeFlags::kIsTrustAnchor);
-    NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
-    NL_TEST_ASSERT(inSuite, certData.mCertFlags.Has(CertFlags::kIsTrustAnchor));
+    EXPECT_EQ(err, CHIP_NO_ERROR);
+    EXPECT_TRUE(certData.mCertFlags.Has(CertFlags::kIsTrustAnchor));
 
     // Decode with TBS Hash calculation
     err = DecodeChipCert(cert, certData, CertDecodeFlags::kGenerateTBSHash);
-    NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
-    NL_TEST_ASSERT(inSuite, certData.mCertFlags.Has(CertFlags::kTBSHashPresent));
+    EXPECT_EQ(err, CHIP_NO_ERROR);
+    EXPECT_TRUE(certData.mCertFlags.Has(CertFlags::kTBSHashPresent));
     // When the TBS hash is available signature verification should work
     err = VerifyCertSignature(certData, certData); // test cert is a self-signed root
-    NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
+    EXPECT_EQ(err, CHIP_NO_ERROR);
 }
 
-static void TestChipCert_LoadDuplicateCerts(nlTestSuite * inSuite, void * inContext)
+TEST_F(TestChipCert, TestChipCert_LoadDuplicateCerts)
 {
     CHIP_ERROR err;
     ChipCertificateSet certSet;
     ValidationContext validContext;
 
     err = certSet.Init(kStandardCertsCount);
-    NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
+    EXPECT_EQ(err, CHIP_NO_ERROR);
 
     // Let's load two distinct certificates, and make sure cert count is 2
     err = LoadTestCert(certSet, TestCert::kRoot01, sNullLoadFlag, sTrustAnchorFlag);
-    NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
+    EXPECT_EQ(err, CHIP_NO_ERROR);
 
     err = LoadTestCert(certSet, TestCert::kICA01, sNullLoadFlag, sGenTBSHashFlag);
-    NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
-    NL_TEST_ASSERT(inSuite, certSet.GetCertCount() == 2);
+    EXPECT_EQ(err, CHIP_NO_ERROR);
+    EXPECT_EQ(certSet.GetCertCount(), 2);
 
     // Let's load a previously loaded cert and make sure cert count is still 2
     err = LoadTestCert(certSet, TestCert::kRoot01, sNullLoadFlag, sTrustAnchorFlag);
-    NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
-    NL_TEST_ASSERT(inSuite, certSet.GetCertCount() == 2);
+    EXPECT_EQ(err, CHIP_NO_ERROR);
+    EXPECT_EQ(certSet.GetCertCount(), 2);
 
     // Let's load the other previously loaded cert and make sure cert count is still 2
     err = LoadTestCert(certSet, TestCert::kICA01, sNullLoadFlag, sGenTBSHashFlag);
-    NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
-    NL_TEST_ASSERT(inSuite, certSet.GetCertCount() == 2);
+    EXPECT_EQ(err, CHIP_NO_ERROR);
+    EXPECT_EQ(certSet.GetCertCount(), 2);
 
     // Let's load a new cert and make sure cert count updates to 3
     err = LoadTestCert(certSet, TestCert::kNode01_01, sNullLoadFlag, sGenTBSHashFlag);
-    NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
-    NL_TEST_ASSERT(inSuite, certSet.GetCertCount() == 3);
+    EXPECT_EQ(err, CHIP_NO_ERROR);
+    EXPECT_EQ(certSet.GetCertCount(), 3);
 }
 
-static void TestChipCert_GenerateRootCert(nlTestSuite * inSuite, void * inContext)
+TEST_F(TestChipCert, TestChipCert_GenerateRootCert)
 {
     // Generate a new keypair for cert signing
     P256Keypair keypair;
-    NL_TEST_ASSERT(inSuite, keypair.Initialize(ECPKeyTarget::ECDSA) == CHIP_NO_ERROR);
+    EXPECT_EQ(keypair.Initialize(ECPKeyTarget::ECDSA), CHIP_NO_ERROR);
 
     uint8_t signed_cert[kMaxDERCertLength];
 
     ChipCertificateData certData;
 
     ChipDN root_dn;
-    NL_TEST_ASSERT(inSuite, root_dn.AddAttribute_MatterRCACId(0xabcdabcd) == CHIP_NO_ERROR);
+    EXPECT_EQ(root_dn.AddAttribute_MatterRCACId(0xabcdabcd), CHIP_NO_ERROR);
 
     X509CertRequestParams root_params = { 1234, 631161876, 729942000, root_dn, root_dn };
     MutableByteSpan signed_cert_span(signed_cert);
-    NL_TEST_ASSERT(inSuite, NewRootX509Cert(root_params, keypair, signed_cert_span) == CHIP_NO_ERROR);
+    EXPECT_EQ(NewRootX509Cert(root_params, keypair, signed_cert_span), CHIP_NO_ERROR);
 
     uint8_t outCertBuf[kMaxCHIPCertLength];
     MutableByteSpan outCert(outCertBuf);
 
-    NL_TEST_ASSERT(inSuite, ConvertX509CertToChipCert(signed_cert_span, outCert) == CHIP_NO_ERROR);
+    EXPECT_EQ(ConvertX509CertToChipCert(signed_cert_span, outCert), CHIP_NO_ERROR);
 
-    NL_TEST_ASSERT(inSuite, DecodeChipCert(outCert, certData) == CHIP_NO_ERROR);
+    EXPECT_EQ(DecodeChipCert(outCert, certData), CHIP_NO_ERROR);
 
     // Test with FutureExtension
     X509CertRequestParams root_params2 = { 1234, 631161876, 729942000, root_dn, root_dn, kSubjectAltNameAsFutureExt };
     MutableByteSpan signed_cert_span2(signed_cert);
-    NL_TEST_ASSERT(inSuite, NewRootX509Cert(root_params2, keypair, signed_cert_span2) == CHIP_NO_ERROR);
+    EXPECT_EQ(NewRootX509Cert(root_params2, keypair, signed_cert_span2), CHIP_NO_ERROR);
     outCert = MutableByteSpan(outCertBuf);
 
-    NL_TEST_ASSERT(inSuite, ConvertX509CertToChipCert(signed_cert_span2, outCert) == CHIP_NO_ERROR);
-    NL_TEST_ASSERT(inSuite, DecodeChipCert(outCert, certData) == CHIP_NO_ERROR);
+    EXPECT_EQ(ConvertX509CertToChipCert(signed_cert_span2, outCert), CHIP_NO_ERROR);
+    EXPECT_EQ(DecodeChipCert(outCert, certData), CHIP_NO_ERROR);
 
     // Test with no defined notAfter time.
     {
@@ -1378,41 +1381,41 @@
                                                .IssuerDN      = root_dn };
         MutableByteSpan signed_cert_span_no_expiry(signed_cert);
 
-        NL_TEST_ASSERT(inSuite, NewRootX509Cert(root_params3, keypair, signed_cert_span_no_expiry) == CHIP_NO_ERROR);
+        EXPECT_EQ(NewRootX509Cert(root_params3, keypair, signed_cert_span_no_expiry), CHIP_NO_ERROR);
         outCert = MutableByteSpan(outCertBuf);
 
-        NL_TEST_ASSERT(inSuite, ConvertX509CertToChipCert(signed_cert_span_no_expiry, outCert) == CHIP_NO_ERROR);
-        NL_TEST_ASSERT(inSuite, DecodeChipCert(outCert, certData) == CHIP_NO_ERROR);
-        NL_TEST_ASSERT(inSuite, certData.mNotAfterTime == kNullCertTime);
+        EXPECT_EQ(ConvertX509CertToChipCert(signed_cert_span_no_expiry, outCert), CHIP_NO_ERROR);
+        EXPECT_EQ(DecodeChipCert(outCert, certData), CHIP_NO_ERROR);
+        EXPECT_EQ(certData.mNotAfterTime, kNullCertTime);
     }
 
     // Test error case: root cert subject provided ICA OID Attribute.
     root_params.SubjectDN.Clear();
-    NL_TEST_ASSERT(inSuite, root_params.SubjectDN.AddAttribute_MatterICACId(0xabcdabcd) == CHIP_NO_ERROR);
+    EXPECT_EQ(root_params.SubjectDN.AddAttribute_MatterICACId(0xabcdabcd), CHIP_NO_ERROR);
     root_params.IssuerDN.Clear();
-    NL_TEST_ASSERT(inSuite, root_params.IssuerDN.AddAttribute_MatterICACId(0xabcdabcd) == CHIP_NO_ERROR);
+    EXPECT_EQ(root_params.IssuerDN.AddAttribute_MatterICACId(0xabcdabcd), CHIP_NO_ERROR);
     MutableByteSpan signed_cert_span1(signed_cert);
-    NL_TEST_ASSERT(inSuite, NewRootX509Cert(root_params, keypair, signed_cert_span1) == CHIP_ERROR_INVALID_ARGUMENT);
+    EXPECT_EQ(NewRootX509Cert(root_params, keypair, signed_cert_span1), CHIP_ERROR_INVALID_ARGUMENT);
 
     // Test error case: root cert provided different subject and issuer DNs.
     root_params.SubjectDN.Clear();
-    NL_TEST_ASSERT(inSuite, root_params.SubjectDN.AddAttribute_MatterRCACId(0xabcdabcd) == CHIP_NO_ERROR);
+    EXPECT_EQ(root_params.SubjectDN.AddAttribute_MatterRCACId(0xabcdabcd), CHIP_NO_ERROR);
     root_params.IssuerDN.Clear();
-    NL_TEST_ASSERT(inSuite, root_params.IssuerDN.AddAttribute_MatterRCACId(0xffffeeee) == CHIP_NO_ERROR);
-    NL_TEST_ASSERT(inSuite, NewRootX509Cert(root_params, keypair, signed_cert_span1) == CHIP_ERROR_INVALID_ARGUMENT);
+    EXPECT_EQ(root_params.IssuerDN.AddAttribute_MatterRCACId(0xffffeeee), CHIP_NO_ERROR);
+    EXPECT_EQ(NewRootX509Cert(root_params, keypair, signed_cert_span1), CHIP_ERROR_INVALID_ARGUMENT);
 
     // Test that serial number cannot be negative
     root_params.IssuerDN.Clear();
-    NL_TEST_ASSERT(inSuite, root_params.IssuerDN.AddAttribute_MatterRCACId(0xabcdabcd) == CHIP_NO_ERROR);
+    EXPECT_EQ(root_params.IssuerDN.AddAttribute_MatterRCACId(0xabcdabcd), CHIP_NO_ERROR);
     root_params.SerialNumber = -1;
-    NL_TEST_ASSERT(inSuite, NewRootX509Cert(root_params, keypair, signed_cert_span1) == CHIP_ERROR_INVALID_ARGUMENT);
+    EXPECT_EQ(NewRootX509Cert(root_params, keypair, signed_cert_span1), CHIP_ERROR_INVALID_ARGUMENT);
 }
 
-static void TestChipCert_GenerateRootFabCert(nlTestSuite * inSuite, void * inContext)
+TEST_F(TestChipCert, TestChipCert_GenerateRootFabCert)
 {
     // Generate a new keypair for cert signing
     P256Keypair keypair;
-    NL_TEST_ASSERT(inSuite, keypair.Initialize(ECPKeyTarget::ECDSA) == CHIP_NO_ERROR);
+    EXPECT_EQ(keypair.Initialize(ECPKeyTarget::ECDSA), CHIP_NO_ERROR);
 
     uint8_t signed_cert[kMaxDERCertLength];
 
@@ -1422,24 +1425,24 @@
     MutableByteSpan outCert(outCertBuf);
 
     ChipDN root_dn;
-    NL_TEST_ASSERT(inSuite, root_dn.AddAttribute_MatterRCACId(0xabcdabcd) == CHIP_NO_ERROR);
-    NL_TEST_ASSERT(inSuite, root_dn.AddAttribute_MatterFabricId(0xabcd) == CHIP_NO_ERROR);
+    EXPECT_EQ(root_dn.AddAttribute_MatterRCACId(0xabcdabcd), CHIP_NO_ERROR);
+    EXPECT_EQ(root_dn.AddAttribute_MatterFabricId(0xabcd), CHIP_NO_ERROR);
 
     X509CertRequestParams root_params_fabric = { 1234, 631161876, 729942000, root_dn, root_dn };
 
     MutableByteSpan signed_cert_span(signed_cert);
-    NL_TEST_ASSERT(inSuite, NewRootX509Cert(root_params_fabric, keypair, signed_cert_span) == CHIP_NO_ERROR);
+    EXPECT_EQ(NewRootX509Cert(root_params_fabric, keypair, signed_cert_span), CHIP_NO_ERROR);
 
-    NL_TEST_ASSERT(inSuite, ConvertX509CertToChipCert(signed_cert_span, outCert) == CHIP_NO_ERROR);
+    EXPECT_EQ(ConvertX509CertToChipCert(signed_cert_span, outCert), CHIP_NO_ERROR);
 
-    NL_TEST_ASSERT(inSuite, DecodeChipCert(outCert, certData) == CHIP_NO_ERROR);
+    EXPECT_EQ(DecodeChipCert(outCert, certData), CHIP_NO_ERROR);
 }
 
-static void TestChipCert_GenerateICACert(nlTestSuite * inSuite, void * inContext)
+TEST_F(TestChipCert, TestChipCert_GenerateICACert)
 {
     // Generate a new keypair for cert signing
     P256Keypair keypair;
-    NL_TEST_ASSERT(inSuite, keypair.Initialize(ECPKeyTarget::ECDSA) == CHIP_NO_ERROR);
+    EXPECT_EQ(keypair.Initialize(ECPKeyTarget::ECDSA), CHIP_NO_ERROR);
 
     uint8_t signed_cert[kMaxDERCertLength];
 
@@ -1449,51 +1452,49 @@
     ChipCertificateData certData;
 
     ChipDN ica_dn;
-    NL_TEST_ASSERT(inSuite, ica_dn.AddAttribute_MatterICACId(0xABCDABCDABCDABCD) == CHIP_NO_ERROR);
+    EXPECT_EQ(ica_dn.AddAttribute_MatterICACId(0xABCDABCDABCDABCD), CHIP_NO_ERROR);
     ChipDN issuer_dn;
-    NL_TEST_ASSERT(inSuite, issuer_dn.AddAttribute_MatterRCACId(0x43215678FEDCABCD) == CHIP_NO_ERROR);
+    EXPECT_EQ(issuer_dn.AddAttribute_MatterRCACId(0x43215678FEDCABCD), CHIP_NO_ERROR);
 
     X509CertRequestParams ica_params = { 1234, 631161876, 729942000, ica_dn, issuer_dn };
     P256Keypair ica_keypair;
-    NL_TEST_ASSERT(inSuite, ica_keypair.Initialize(ECPKeyTarget::ECDSA) == CHIP_NO_ERROR);
+    EXPECT_EQ(ica_keypair.Initialize(ECPKeyTarget::ECDSA), CHIP_NO_ERROR);
 
     MutableByteSpan signed_cert_span(signed_cert);
-    NL_TEST_ASSERT(inSuite, NewICAX509Cert(ica_params, ica_keypair.Pubkey(), keypair, signed_cert_span) == CHIP_NO_ERROR);
+    EXPECT_EQ(NewICAX509Cert(ica_params, ica_keypair.Pubkey(), keypair, signed_cert_span), CHIP_NO_ERROR);
 
-    NL_TEST_ASSERT(inSuite, ConvertX509CertToChipCert(signed_cert_span, outCert) == CHIP_NO_ERROR);
+    EXPECT_EQ(ConvertX509CertToChipCert(signed_cert_span, outCert), CHIP_NO_ERROR);
 
-    NL_TEST_ASSERT(inSuite, DecodeChipCert(outCert, certData) == CHIP_NO_ERROR);
+    EXPECT_EQ(DecodeChipCert(outCert, certData), CHIP_NO_ERROR);
 
     // Test with FutureExtension
     X509CertRequestParams ica_params2 = { 1234, 631161876, 729942000, ica_dn, issuer_dn, kSubjectAltNameAsFutureExt };
     MutableByteSpan signed_cert_span2(signed_cert);
-    NL_TEST_ASSERT(inSuite, NewICAX509Cert(ica_params2, ica_keypair.Pubkey(), keypair, signed_cert_span2) == CHIP_NO_ERROR);
+    EXPECT_EQ(NewICAX509Cert(ica_params2, ica_keypair.Pubkey(), keypair, signed_cert_span2), CHIP_NO_ERROR);
     outCert = MutableByteSpan(outCertBuf);
 
-    NL_TEST_ASSERT(inSuite, ConvertX509CertToChipCert(signed_cert_span2, outCert) == CHIP_NO_ERROR);
-    NL_TEST_ASSERT(inSuite, DecodeChipCert(outCert, certData) == CHIP_NO_ERROR);
+    EXPECT_EQ(ConvertX509CertToChipCert(signed_cert_span2, outCert), CHIP_NO_ERROR);
+    EXPECT_EQ(DecodeChipCert(outCert, certData), CHIP_NO_ERROR);
 
     // Test error case: ICA cert subject provided a node ID attribute
     ica_params.SubjectDN.Clear();
-    NL_TEST_ASSERT(inSuite, ica_params.SubjectDN.AddAttribute_MatterNodeId(0xABCDABCDABCDABCD) == CHIP_NO_ERROR);
-    NL_TEST_ASSERT(inSuite, ica_params.SubjectDN.AddAttribute_MatterFabricId(0xFAB00000FAB00001) == CHIP_NO_ERROR);
+    EXPECT_EQ(ica_params.SubjectDN.AddAttribute_MatterNodeId(0xABCDABCDABCDABCD), CHIP_NO_ERROR);
+    EXPECT_EQ(ica_params.SubjectDN.AddAttribute_MatterFabricId(0xFAB00000FAB00001), CHIP_NO_ERROR);
     MutableByteSpan signed_cert_span1(signed_cert);
-    NL_TEST_ASSERT(inSuite,
-                   NewICAX509Cert(ica_params, ica_keypair.Pubkey(), keypair, signed_cert_span1) == CHIP_ERROR_INVALID_ARGUMENT);
+    EXPECT_EQ(NewICAX509Cert(ica_params, ica_keypair.Pubkey(), keypair, signed_cert_span1), CHIP_ERROR_INVALID_ARGUMENT);
 
     // Test that serial number cannot be negative
     ica_params.SubjectDN.Clear();
-    NL_TEST_ASSERT(inSuite, ica_params.SubjectDN.AddAttribute_MatterICACId(0xABCDABCDABCDABCD) == CHIP_NO_ERROR);
+    EXPECT_EQ(ica_params.SubjectDN.AddAttribute_MatterICACId(0xABCDABCDABCDABCD), CHIP_NO_ERROR);
     ica_params.SerialNumber = -1;
-    NL_TEST_ASSERT(inSuite,
-                   NewICAX509Cert(ica_params, ica_keypair.Pubkey(), keypair, signed_cert_span1) == CHIP_ERROR_INVALID_ARGUMENT);
+    EXPECT_EQ(NewICAX509Cert(ica_params, ica_keypair.Pubkey(), keypair, signed_cert_span1), CHIP_ERROR_INVALID_ARGUMENT);
 }
 
-static void TestChipCert_GenerateNOCRoot(nlTestSuite * inSuite, void * inContext)
+TEST_F(TestChipCert, TestChipCert_GenerateNOCRoot)
 {
     // Generate a new keypair for cert signing
     P256Keypair keypair;
-    NL_TEST_ASSERT(inSuite, keypair.Initialize(ECPKeyTarget::ECDSA) == CHIP_NO_ERROR);
+    EXPECT_EQ(keypair.Initialize(ECPKeyTarget::ECDSA), CHIP_NO_ERROR);
 
     uint8_t signed_cert[kMaxDERCertLength];
 
@@ -1503,68 +1504,62 @@
     ChipCertificateData certData;
 
     ChipDN noc_dn;
-    NL_TEST_ASSERT(inSuite, noc_dn.AddAttribute_MatterNodeId(0xABCDABCDABCDABCD) == CHIP_NO_ERROR);
-    NL_TEST_ASSERT(inSuite, noc_dn.AddAttribute_MatterFabricId(0xFAB00000FAB00001) == CHIP_NO_ERROR);
+    EXPECT_EQ(noc_dn.AddAttribute_MatterNodeId(0xABCDABCDABCDABCD), CHIP_NO_ERROR);
+    EXPECT_EQ(noc_dn.AddAttribute_MatterFabricId(0xFAB00000FAB00001), CHIP_NO_ERROR);
     ChipDN issuer_dn;
-    NL_TEST_ASSERT(inSuite, issuer_dn.AddAttribute_MatterRCACId(0x8888999944442222) == CHIP_NO_ERROR);
+    EXPECT_EQ(issuer_dn.AddAttribute_MatterRCACId(0x8888999944442222), CHIP_NO_ERROR);
 
     X509CertRequestParams noc_params = { 123456, 631161876, 729942000, noc_dn, issuer_dn };
     P256Keypair noc_keypair;
-    NL_TEST_ASSERT(inSuite, noc_keypair.Initialize(ECPKeyTarget::ECDSA) == CHIP_NO_ERROR);
+    EXPECT_EQ(noc_keypair.Initialize(ECPKeyTarget::ECDSA), CHIP_NO_ERROR);
 
     MutableByteSpan signed_cert_span(signed_cert, sizeof(signed_cert));
-    NL_TEST_ASSERT(inSuite,
-                   NewNodeOperationalX509Cert(noc_params, noc_keypair.Pubkey(), keypair, signed_cert_span) == CHIP_NO_ERROR);
+    EXPECT_EQ(NewNodeOperationalX509Cert(noc_params, noc_keypair.Pubkey(), keypair, signed_cert_span), CHIP_NO_ERROR);
 
-    NL_TEST_ASSERT(inSuite, ConvertX509CertToChipCert(signed_cert_span, outCert) == CHIP_NO_ERROR);
+    EXPECT_EQ(ConvertX509CertToChipCert(signed_cert_span, outCert), CHIP_NO_ERROR);
 
-    NL_TEST_ASSERT(inSuite, DecodeChipCert(outCert, certData) == CHIP_NO_ERROR);
+    EXPECT_EQ(DecodeChipCert(outCert, certData), CHIP_NO_ERROR);
 
     // Test with FutureExtension
     X509CertRequestParams noc_params2 = { 123456, 631161876, 729942000, noc_dn, issuer_dn, kSubjectAltNameAsFutureExt };
     MutableByteSpan signed_cert_span2(signed_cert);
-    NL_TEST_ASSERT(inSuite,
-                   NewNodeOperationalX509Cert(noc_params2, noc_keypair.Pubkey(), keypair, signed_cert_span2) == CHIP_NO_ERROR);
+    EXPECT_EQ(NewNodeOperationalX509Cert(noc_params2, noc_keypair.Pubkey(), keypair, signed_cert_span2), CHIP_NO_ERROR);
     outCert = MutableByteSpan(outCertBuf);
 
-    NL_TEST_ASSERT(inSuite, ConvertX509CertToChipCert(signed_cert_span2, outCert) == CHIP_NO_ERROR);
-    NL_TEST_ASSERT(inSuite, DecodeChipCert(outCert, certData) == CHIP_NO_ERROR);
+    EXPECT_EQ(ConvertX509CertToChipCert(signed_cert_span2, outCert), CHIP_NO_ERROR);
+    EXPECT_EQ(DecodeChipCert(outCert, certData), CHIP_NO_ERROR);
 
     // Test error case: NOC cert subject doesn't have NodeId attribute
     noc_params.SubjectDN.Clear();
-    NL_TEST_ASSERT(inSuite, noc_params.SubjectDN.AddAttribute_MatterFabricId(0xFAB00000FAB00001) == CHIP_NO_ERROR);
+    EXPECT_EQ(noc_params.SubjectDN.AddAttribute_MatterFabricId(0xFAB00000FAB00001), CHIP_NO_ERROR);
 
     MutableByteSpan signed_cert_span1(signed_cert, sizeof(signed_cert));
-    NL_TEST_ASSERT(inSuite,
-                   NewNodeOperationalX509Cert(noc_params, noc_keypair.Pubkey(), keypair, signed_cert_span1) ==
-                       CHIP_ERROR_INVALID_ARGUMENT);
+    EXPECT_EQ(NewNodeOperationalX509Cert(noc_params, noc_keypair.Pubkey(), keypair, signed_cert_span1),
+              CHIP_ERROR_INVALID_ARGUMENT);
 
     // Test error case: NOC cert subject doesn't have fabric ID attribute
     noc_params.SubjectDN.Clear();
-    NL_TEST_ASSERT(inSuite, noc_params.SubjectDN.AddAttribute_MatterNodeId(0xABCDABCDABCDABCD) == CHIP_NO_ERROR);
+    EXPECT_EQ(noc_params.SubjectDN.AddAttribute_MatterNodeId(0xABCDABCDABCDABCD), CHIP_NO_ERROR);
 
-    NL_TEST_ASSERT(inSuite,
-                   NewNodeOperationalX509Cert(noc_params, noc_keypair.Pubkey(), keypair, signed_cert_span1) ==
-                       CHIP_ERROR_WRONG_CERT_DN);
+    EXPECT_EQ(NewNodeOperationalX509Cert(noc_params, noc_keypair.Pubkey(), keypair, signed_cert_span1), CHIP_ERROR_WRONG_CERT_DN);
 
     // Test error case: issuer cert DN type is Node certificate
     noc_params.SubjectDN.Clear();
-    NL_TEST_ASSERT(inSuite, noc_params.SubjectDN.AddAttribute_MatterNodeId(0xABCDABCDABCDABCD) == CHIP_NO_ERROR);
-    NL_TEST_ASSERT(inSuite, noc_params.SubjectDN.AddAttribute_MatterFabricId(0xFAB00000FAB00001) == CHIP_NO_ERROR);
+    EXPECT_EQ(noc_params.SubjectDN.AddAttribute_MatterNodeId(0xABCDABCDABCDABCD), CHIP_NO_ERROR);
+    EXPECT_EQ(noc_params.SubjectDN.AddAttribute_MatterFabricId(0xFAB00000FAB00001), CHIP_NO_ERROR);
     noc_params.IssuerDN.Clear();
-    NL_TEST_ASSERT(inSuite, noc_params.IssuerDN.AddAttribute_MatterNodeId(0x8888999944442222) == CHIP_NO_ERROR);
-    NL_TEST_ASSERT(inSuite, noc_params.IssuerDN.AddAttribute_MatterFabricId(0xFAB00000FAB00001) == CHIP_NO_ERROR);
+    EXPECT_EQ(noc_params.IssuerDN.AddAttribute_MatterNodeId(0x8888999944442222), CHIP_NO_ERROR);
+    EXPECT_EQ(noc_params.IssuerDN.AddAttribute_MatterFabricId(0xFAB00000FAB00001), CHIP_NO_ERROR);
 
-    NL_TEST_ASSERT(inSuite,
-                   NewNodeOperationalX509Cert(noc_params, noc_keypair.Pubkey(), keypair, signed_cert_span1) ==
-                       CHIP_ERROR_INVALID_ARGUMENT);
+    EXPECT_EQ(NewNodeOperationalX509Cert(noc_params, noc_keypair.Pubkey(), keypair, signed_cert_span1),
+              CHIP_ERROR_INVALID_ARGUMENT);
 }
 
-static void TestChipCert_GenerateNOCICA(nlTestSuite * inSuite, void * inContext)
+TEST_F(TestChipCert, TestChipCert_GenerateNOCICA)
 {
     // Generate a new keypair for cert signing
     P256Keypair keypair;
-    NL_TEST_ASSERT(inSuite, keypair.Initialize(ECPKeyTarget::ECDSA) == CHIP_NO_ERROR);
+    EXPECT_EQ(keypair.Initialize(ECPKeyTarget::ECDSA), CHIP_NO_ERROR);
 
     uint8_t signed_cert[kMaxDERCertLength];
 
@@ -1581,78 +1576,75 @@
     const static char noc_name_rdn[]      = "Smith";
 
     ChipDN noc_dn;
-    NL_TEST_ASSERT(inSuite, noc_dn.AddAttribute_CommonName(CharSpan(noc_cn_rdn, strlen(noc_cn_rdn)), false) == CHIP_NO_ERROR);
-    NL_TEST_ASSERT(inSuite, noc_dn.AddAttribute_MatterNodeId(0xAAAABBBBCCCCDDDD) == CHIP_NO_ERROR);
-    NL_TEST_ASSERT(inSuite, noc_dn.AddAttribute_MatterFabricId(0xFAB00000FAB00001) == CHIP_NO_ERROR);
-    NL_TEST_ASSERT(inSuite,
-                   noc_dn.AddAttribute_GivenName(CharSpan(noc_givenname_rdn, strlen(noc_givenname_rdn)), true) == CHIP_NO_ERROR);
-    NL_TEST_ASSERT(inSuite, noc_dn.AddAttribute_Name(CharSpan(noc_name_rdn, strlen(noc_name_rdn)), true) == CHIP_NO_ERROR);
+    EXPECT_EQ(noc_dn.AddAttribute_CommonName(CharSpan(noc_cn_rdn, strlen(noc_cn_rdn)), false), CHIP_NO_ERROR);
+    EXPECT_EQ(noc_dn.AddAttribute_MatterNodeId(0xAAAABBBBCCCCDDDD), CHIP_NO_ERROR);
+    EXPECT_EQ(noc_dn.AddAttribute_MatterFabricId(0xFAB00000FAB00001), CHIP_NO_ERROR);
+    EXPECT_EQ(noc_dn.AddAttribute_GivenName(CharSpan(noc_givenname_rdn, strlen(noc_givenname_rdn)), true), CHIP_NO_ERROR);
+    EXPECT_EQ(noc_dn.AddAttribute_Name(CharSpan(noc_name_rdn, strlen(noc_name_rdn)), true), CHIP_NO_ERROR);
 
     ChipDN ica_dn;
-    NL_TEST_ASSERT(inSuite, ica_dn.AddAttribute_MatterICACId(0x8888999944442222) == CHIP_NO_ERROR);
-    NL_TEST_ASSERT(inSuite, ica_dn.AddAttribute_MatterFabricId(0xFAB00000FAB00001) == CHIP_NO_ERROR);
+    EXPECT_EQ(ica_dn.AddAttribute_MatterICACId(0x8888999944442222), CHIP_NO_ERROR);
+    EXPECT_EQ(ica_dn.AddAttribute_MatterFabricId(0xFAB00000FAB00001), CHIP_NO_ERROR);
 
     X509CertRequestParams noc_params = { 12348765, 631161876, 729942000, noc_dn, ica_dn };
     P256Keypair noc_keypair;
-    NL_TEST_ASSERT(inSuite, noc_keypair.Initialize(ECPKeyTarget::ECDSA) == CHIP_NO_ERROR);
+    EXPECT_EQ(noc_keypair.Initialize(ECPKeyTarget::ECDSA), CHIP_NO_ERROR);
 
     MutableByteSpan signed_cert_span(signed_cert);
-    NL_TEST_ASSERT(inSuite,
-                   NewNodeOperationalX509Cert(noc_params, noc_keypair.Pubkey(), keypair, signed_cert_span) == CHIP_NO_ERROR);
+    EXPECT_EQ(NewNodeOperationalX509Cert(noc_params, noc_keypair.Pubkey(), keypair, signed_cert_span), CHIP_NO_ERROR);
 
-    NL_TEST_ASSERT(inSuite, ConvertX509CertToChipCert(signed_cert_span, outCert) == CHIP_NO_ERROR);
+    EXPECT_EQ(ConvertX509CertToChipCert(signed_cert_span, outCert), CHIP_NO_ERROR);
 
-    NL_TEST_ASSERT(inSuite, ConvertChipCertToX509Cert(outCert, outCertDER) == CHIP_NO_ERROR);
-    NL_TEST_ASSERT(inSuite, signed_cert_span.data_equal(outCertDER));
+    EXPECT_EQ(ConvertChipCertToX509Cert(outCert, outCertDER), CHIP_NO_ERROR);
+    EXPECT_TRUE(signed_cert_span.data_equal(outCertDER));
 
-    NL_TEST_ASSERT(inSuite, DecodeChipCert(outCert, certData) == CHIP_NO_ERROR);
+    EXPECT_EQ(DecodeChipCert(outCert, certData), CHIP_NO_ERROR);
 }
 
-static void TestChipCert_VerifyGeneratedCerts(nlTestSuite * inSuite, void * inContext)
+TEST_F(TestChipCert, TestChipCert_VerifyGeneratedCerts)
 {
     // Generate a new keypair for cert signing
     P256Keypair keypair;
-    NL_TEST_ASSERT(inSuite, keypair.Initialize(ECPKeyTarget::ECDSA) == CHIP_NO_ERROR);
+    EXPECT_EQ(keypair.Initialize(ECPKeyTarget::ECDSA), CHIP_NO_ERROR);
 
     static uint8_t root_cert[kMaxDERCertLength];
 
     ChipDN root_dn;
-    NL_TEST_ASSERT(inSuite, root_dn.AddAttribute_MatterRCACId(0xAAAABBBBCCCCDDDD) == CHIP_NO_ERROR);
-    NL_TEST_ASSERT(inSuite, root_dn.AddAttribute_MatterFabricId(0xFAB0000000008888) == CHIP_NO_ERROR);
+    EXPECT_EQ(root_dn.AddAttribute_MatterRCACId(0xAAAABBBBCCCCDDDD), CHIP_NO_ERROR);
+    EXPECT_EQ(root_dn.AddAttribute_MatterFabricId(0xFAB0000000008888), CHIP_NO_ERROR);
 
     X509CertRequestParams root_params = { 1234, 631161876, 729942000, root_dn, root_dn };
     MutableByteSpan root_cert_span(root_cert);
-    NL_TEST_ASSERT(inSuite, NewRootX509Cert(root_params, keypair, root_cert_span) == CHIP_NO_ERROR);
+    EXPECT_EQ(NewRootX509Cert(root_params, keypair, root_cert_span), CHIP_NO_ERROR);
 
     static uint8_t ica_cert[kMaxDERCertLength];
 
     ChipDN ica_dn;
-    NL_TEST_ASSERT(inSuite, ica_dn.AddAttribute_MatterICACId(0xAABBCCDDAABBCCDD) == CHIP_NO_ERROR);
-    NL_TEST_ASSERT(inSuite, ica_dn.AddAttribute_MatterFabricId(0xFAB0000000008888) == CHIP_NO_ERROR);
+    EXPECT_EQ(ica_dn.AddAttribute_MatterICACId(0xAABBCCDDAABBCCDD), CHIP_NO_ERROR);
+    EXPECT_EQ(ica_dn.AddAttribute_MatterFabricId(0xFAB0000000008888), CHIP_NO_ERROR);
 
     X509CertRequestParams ica_params = { 12345, 631161876, 729942000, ica_dn, root_dn };
     P256Keypair ica_keypair;
-    NL_TEST_ASSERT(inSuite, ica_keypair.Initialize(ECPKeyTarget::ECDSA) == CHIP_NO_ERROR);
+    EXPECT_EQ(ica_keypair.Initialize(ECPKeyTarget::ECDSA), CHIP_NO_ERROR);
 
     MutableByteSpan ica_cert_span(ica_cert);
-    NL_TEST_ASSERT(inSuite, NewICAX509Cert(ica_params, ica_keypair.Pubkey(), keypair, ica_cert_span) == CHIP_NO_ERROR);
+    EXPECT_EQ(NewICAX509Cert(ica_params, ica_keypair.Pubkey(), keypair, ica_cert_span), CHIP_NO_ERROR);
 
     static uint8_t noc_cert[kMaxDERCertLength];
 
     ChipDN noc_dn;
-    NL_TEST_ASSERT(inSuite, noc_dn.AddAttribute_MatterNodeId(0xAABBCCDDAABBCCDD) == CHIP_NO_ERROR);
-    NL_TEST_ASSERT(inSuite, noc_dn.AddAttribute_MatterFabricId(0xFAB0000000008888) == CHIP_NO_ERROR);
+    EXPECT_EQ(noc_dn.AddAttribute_MatterNodeId(0xAABBCCDDAABBCCDD), CHIP_NO_ERROR);
+    EXPECT_EQ(noc_dn.AddAttribute_MatterFabricId(0xFAB0000000008888), CHIP_NO_ERROR);
 
     X509CertRequestParams noc_params = { 123456, 631161876, 729942000, noc_dn, ica_dn };
     P256Keypair noc_keypair;
-    NL_TEST_ASSERT(inSuite, noc_keypair.Initialize(ECPKeyTarget::ECDSA) == CHIP_NO_ERROR);
+    EXPECT_EQ(noc_keypair.Initialize(ECPKeyTarget::ECDSA), CHIP_NO_ERROR);
 
     MutableByteSpan noc_cert_span(noc_cert, sizeof(noc_cert));
-    NL_TEST_ASSERT(inSuite,
-                   NewNodeOperationalX509Cert(noc_params, noc_keypair.Pubkey(), ica_keypair, noc_cert_span) == CHIP_NO_ERROR);
+    EXPECT_EQ(NewNodeOperationalX509Cert(noc_params, noc_keypair.Pubkey(), ica_keypair, noc_cert_span), CHIP_NO_ERROR);
 
     ChipCertificateSet certSet;
-    NL_TEST_ASSERT(inSuite, certSet.Init(3) == CHIP_NO_ERROR);
+    EXPECT_EQ(certSet.Init(3), CHIP_NO_ERROR);
 
     static uint8_t chipRootCertBuf[kMaxCHIPCertLength];
     static uint8_t chipICACertBuf[kMaxCHIPCertLength];
@@ -1661,19 +1653,19 @@
     MutableByteSpan chipICACert(chipICACertBuf);
     MutableByteSpan chipNOCCert(chipNOCCertBuf);
 
-    NL_TEST_ASSERT(inSuite, ConvertX509CertToChipCert(root_cert_span, chipRootCert) == CHIP_NO_ERROR);
-    NL_TEST_ASSERT(inSuite, certSet.LoadCert(chipRootCert, sTrustAnchorFlag) == CHIP_NO_ERROR);
+    EXPECT_EQ(ConvertX509CertToChipCert(root_cert_span, chipRootCert), CHIP_NO_ERROR);
+    EXPECT_EQ(certSet.LoadCert(chipRootCert, sTrustAnchorFlag), CHIP_NO_ERROR);
 
-    NL_TEST_ASSERT(inSuite, ConvertX509CertToChipCert(ica_cert_span, chipICACert) == CHIP_NO_ERROR);
-    NL_TEST_ASSERT(inSuite, certSet.LoadCert(chipICACert, sGenTBSHashFlag) == CHIP_NO_ERROR);
+    EXPECT_EQ(ConvertX509CertToChipCert(ica_cert_span, chipICACert), CHIP_NO_ERROR);
+    EXPECT_EQ(certSet.LoadCert(chipICACert, sGenTBSHashFlag), CHIP_NO_ERROR);
 
-    NL_TEST_ASSERT(inSuite, ConvertX509CertToChipCert(noc_cert_span, chipNOCCert) == CHIP_NO_ERROR);
-    NL_TEST_ASSERT(inSuite, certSet.LoadCert(chipNOCCert, sGenTBSHashFlag) == CHIP_NO_ERROR);
+    EXPECT_EQ(ConvertX509CertToChipCert(noc_cert_span, chipNOCCert), CHIP_NO_ERROR);
+    EXPECT_EQ(certSet.LoadCert(chipNOCCert, sGenTBSHashFlag), CHIP_NO_ERROR);
 
     ValidationContext validContext;
 
     validContext.Reset();
-    NL_TEST_ASSERT(inSuite, SetCurrentTime(validContext, 2022, 1, 1) == CHIP_NO_ERROR);
+    EXPECT_EQ(SetCurrentTime(validContext, 2022, 1, 1), CHIP_NO_ERROR);
     validContext.mRequiredKeyUsages.Set(KeyUsageFlags::kDigitalSignature);
     validContext.mRequiredKeyPurposes.Set(KeyPurposeFlags::kServerAuth);
     validContext.mRequiredKeyPurposes.Set(KeyPurposeFlags::kClientAuth);
@@ -1683,63 +1675,63 @@
     const CertificateKeyId & subjectKeyId = certSet.GetCertSet()[2].mSubjectKeyId;
 
     const ChipCertificateData * resultCert = nullptr;
-    NL_TEST_ASSERT(inSuite, certSet.FindValidCert(subjectDN, subjectKeyId, validContext, &resultCert) == CHIP_NO_ERROR);
+    EXPECT_EQ(certSet.FindValidCert(subjectDN, subjectKeyId, validContext, &resultCert), CHIP_NO_ERROR);
 }
 
-static void TestChipCert_VerifyGeneratedCertsNoICA(nlTestSuite * inSuite, void * inContext)
+TEST_F(TestChipCert, TestChipCert_VerifyGeneratedCertsNoICA)
 {
     // Generate a new keypair for cert signing
     P256Keypair keypair;
-    NL_TEST_ASSERT(inSuite, keypair.Initialize(ECPKeyTarget::ECDSA) == CHIP_NO_ERROR);
+    EXPECT_EQ(keypair.Initialize(ECPKeyTarget::ECDSA), CHIP_NO_ERROR);
 
     static uint8_t root_cert[kMaxDERCertLength];
 
     const static char root_cn_rdn[] = "Test Root Operational Cert";
 
     ChipDN root_dn;
-    NL_TEST_ASSERT(inSuite, root_dn.AddAttribute_CommonName(CharSpan(root_cn_rdn, strlen(root_cn_rdn)), false) == CHIP_NO_ERROR);
-    NL_TEST_ASSERT(inSuite, root_dn.AddAttribute_MatterRCACId(0xAAAABBBBCCCCDDDD) == CHIP_NO_ERROR);
-    NL_TEST_ASSERT(inSuite, root_dn.AddAttribute_MatterFabricId(0xFAB0000000008888) == CHIP_NO_ERROR);
+    EXPECT_EQ(root_dn.AddAttribute_CommonName(CharSpan(root_cn_rdn, strlen(root_cn_rdn)), false), CHIP_NO_ERROR);
+    EXPECT_EQ(root_dn.AddAttribute_MatterRCACId(0xAAAABBBBCCCCDDDD), CHIP_NO_ERROR);
+    EXPECT_EQ(root_dn.AddAttribute_MatterFabricId(0xFAB0000000008888), CHIP_NO_ERROR);
 
     X509CertRequestParams root_params = { 1234, 631161876, 729942000, root_dn, root_dn };
     MutableByteSpan root_cert_span(root_cert);
-    NL_TEST_ASSERT(inSuite, NewRootX509Cert(root_params, keypair, root_cert_span) == CHIP_NO_ERROR);
+    EXPECT_EQ(NewRootX509Cert(root_params, keypair, root_cert_span), CHIP_NO_ERROR);
 
     static uint8_t noc_cert[kMaxDERCertLength];
 
     const static char noc_cn_rdn[] = "Test NOC";
 
     ChipDN noc_dn;
-    NL_TEST_ASSERT(inSuite, noc_dn.AddAttribute_CommonName(CharSpan(noc_cn_rdn, strlen(noc_cn_rdn)), true) == CHIP_NO_ERROR);
-    NL_TEST_ASSERT(inSuite, noc_dn.AddAttribute_MatterNodeId(0xAABBCCDDAABBCCDD) == CHIP_NO_ERROR);
-    NL_TEST_ASSERT(inSuite, noc_dn.AddAttribute_MatterFabricId(0xFAB0000000008888) == CHIP_NO_ERROR);
-    NL_TEST_ASSERT(inSuite, noc_dn.AddAttribute_MatterCASEAuthTag(0xABCD0010) == CHIP_NO_ERROR);
+    EXPECT_EQ(noc_dn.AddAttribute_CommonName(CharSpan(noc_cn_rdn, strlen(noc_cn_rdn)), true), CHIP_NO_ERROR);
+    EXPECT_EQ(noc_dn.AddAttribute_MatterNodeId(0xAABBCCDDAABBCCDD), CHIP_NO_ERROR);
+    EXPECT_EQ(noc_dn.AddAttribute_MatterFabricId(0xFAB0000000008888), CHIP_NO_ERROR);
+    EXPECT_EQ(noc_dn.AddAttribute_MatterCASEAuthTag(0xABCD0010), CHIP_NO_ERROR);
 
     X509CertRequestParams noc_params = { 1234, 631161876, 729942000, noc_dn, root_dn };
     P256Keypair noc_keypair;
-    NL_TEST_ASSERT(inSuite, noc_keypair.Initialize(ECPKeyTarget::ECDSA) == CHIP_NO_ERROR);
+    EXPECT_EQ(noc_keypair.Initialize(ECPKeyTarget::ECDSA), CHIP_NO_ERROR);
 
     MutableByteSpan noc_cert_span(noc_cert);
-    NL_TEST_ASSERT(inSuite, NewNodeOperationalX509Cert(noc_params, noc_keypair.Pubkey(), keypair, noc_cert_span) == CHIP_NO_ERROR);
+    EXPECT_EQ(NewNodeOperationalX509Cert(noc_params, noc_keypair.Pubkey(), keypair, noc_cert_span), CHIP_NO_ERROR);
 
     ChipCertificateSet certSet;
-    NL_TEST_ASSERT(inSuite, certSet.Init(2) == CHIP_NO_ERROR);
+    EXPECT_EQ(certSet.Init(2), CHIP_NO_ERROR);
 
     static uint8_t chipRootCertBuf[kMaxCHIPCertLength];
     static uint8_t chipNOCCertBuf[kMaxCHIPCertLength];
     MutableByteSpan chipRootCert(chipRootCertBuf);
     MutableByteSpan chipNOCCert(chipNOCCertBuf);
 
-    NL_TEST_ASSERT(inSuite, ConvertX509CertToChipCert(root_cert_span, chipRootCert) == CHIP_NO_ERROR);
-    NL_TEST_ASSERT(inSuite, certSet.LoadCert(chipRootCert, sTrustAnchorFlag) == CHIP_NO_ERROR);
+    EXPECT_EQ(ConvertX509CertToChipCert(root_cert_span, chipRootCert), CHIP_NO_ERROR);
+    EXPECT_EQ(certSet.LoadCert(chipRootCert, sTrustAnchorFlag), CHIP_NO_ERROR);
 
-    NL_TEST_ASSERT(inSuite, ConvertX509CertToChipCert(noc_cert_span, chipNOCCert) == CHIP_NO_ERROR);
-    NL_TEST_ASSERT(inSuite, certSet.LoadCert(chipNOCCert, sGenTBSHashFlag) == CHIP_NO_ERROR);
+    EXPECT_EQ(ConvertX509CertToChipCert(noc_cert_span, chipNOCCert), CHIP_NO_ERROR);
+    EXPECT_EQ(certSet.LoadCert(chipNOCCert, sGenTBSHashFlag), CHIP_NO_ERROR);
 
     ValidationContext validContext;
 
     validContext.Reset();
-    NL_TEST_ASSERT(inSuite, SetCurrentTime(validContext, 2022, 1, 1) == CHIP_NO_ERROR);
+    EXPECT_EQ(SetCurrentTime(validContext, 2022, 1, 1), CHIP_NO_ERROR);
     validContext.mRequiredKeyUsages.Set(KeyUsageFlags::kDigitalSignature);
     validContext.mRequiredKeyPurposes.Set(KeyPurposeFlags::kServerAuth);
     validContext.mRequiredKeyPurposes.Set(KeyPurposeFlags::kClientAuth);
@@ -1749,10 +1741,10 @@
     const CertificateKeyId & subjectKeyId = certSet.GetCertSet()[1].mSubjectKeyId;
 
     const ChipCertificateData * resultCert = nullptr;
-    NL_TEST_ASSERT(inSuite, certSet.FindValidCert(subjectDN, subjectKeyId, validContext, &resultCert) == CHIP_NO_ERROR);
+    EXPECT_EQ(certSet.FindValidCert(subjectDN, subjectKeyId, validContext, &resultCert), CHIP_NO_ERROR);
 }
 
-static void TestChipCert_ExtractNodeIdFabricId(nlTestSuite * inSuite, void * inContext)
+TEST_F(TestChipCert, TestChipCert_ExtractNodeIdFabricId)
 {
     struct TestCase
     {
@@ -1784,14 +1776,14 @@
     {
         ByteSpan cert;
         CHIP_ERROR err = GetTestCert(testCase.Cert, sNullLoadFlag, cert);
-        NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
+        EXPECT_EQ(err, CHIP_NO_ERROR);
 
         NodeId nodeId;
         FabricId fabricId;
         err = ExtractNodeIdFabricIdFromOpCert(cert, &nodeId, &fabricId);
-        NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
-        NL_TEST_ASSERT(inSuite, nodeId == testCase.ExpectedNodeId);
-        NL_TEST_ASSERT(inSuite, fabricId == testCase.ExpectedFabricId);
+        EXPECT_EQ(err, CHIP_NO_ERROR);
+        EXPECT_EQ(nodeId, testCase.ExpectedNodeId);
+        EXPECT_EQ(fabricId, testCase.ExpectedFabricId);
     }
 
     // Test node ID and fabric ID extraction from the parsed form.
@@ -1799,17 +1791,17 @@
     for (auto & testCase : sTestCases)
     {
         CHIP_ERROR err = certSet.Init(1);
-        NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
+        EXPECT_EQ(err, CHIP_NO_ERROR);
 
         err = LoadTestCert(certSet, testCase.Cert, sNullLoadFlag, sNullDecodeFlag);
-        NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
+        EXPECT_EQ(err, CHIP_NO_ERROR);
 
         NodeId nodeId;
         FabricId fabricId;
         err = ExtractNodeIdFabricIdFromOpCert(certSet.GetCertSet()[0], &nodeId, &fabricId);
-        NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
-        NL_TEST_ASSERT(inSuite, nodeId == testCase.ExpectedNodeId);
-        NL_TEST_ASSERT(inSuite, fabricId == testCase.ExpectedFabricId);
+        EXPECT_EQ(err, CHIP_NO_ERROR);
+        EXPECT_EQ(nodeId, testCase.ExpectedNodeId);
+        EXPECT_EQ(fabricId, testCase.ExpectedFabricId);
         certSet.Release();
     }
 
@@ -1818,27 +1810,27 @@
     {
         ByteSpan cert;
         CHIP_ERROR err = GetTestCert(testCase.Cert, sNullLoadFlag, cert);
-        NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
+        EXPECT_EQ(err, CHIP_NO_ERROR);
 
         FabricId fabricId;
         err = ExtractFabricIdFromCert(cert, &fabricId);
-        NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
-        NL_TEST_ASSERT(inSuite, fabricId == testCase.ExpectedFabricId);
+        EXPECT_EQ(err, CHIP_NO_ERROR);
+        EXPECT_EQ(fabricId, testCase.ExpectedFabricId);
     }
 
     // Test fabric ID extraction from the parsed form.
     for (auto & testCase : sTestCases)
     {
         CHIP_ERROR err = certSet.Init(1);
-        NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
+        EXPECT_EQ(err, CHIP_NO_ERROR);
 
         err = LoadTestCert(certSet, testCase.Cert, sNullLoadFlag, sNullDecodeFlag);
-        NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
+        EXPECT_EQ(err, CHIP_NO_ERROR);
 
         FabricId fabricId;
         err = ExtractFabricIdFromCert(certSet.GetCertSet()[0], &fabricId);
-        NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
-        NL_TEST_ASSERT(inSuite, fabricId == testCase.ExpectedFabricId);
+        EXPECT_EQ(err, CHIP_NO_ERROR);
+        EXPECT_EQ(fabricId, testCase.ExpectedFabricId);
         certSet.Release();
     }
 
@@ -1846,29 +1838,29 @@
     {
         ByteSpan cert;
         CHIP_ERROR err = GetTestCert(TestCert::kICA01, sNullLoadFlag, cert);
-        NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
+        EXPECT_EQ(err, CHIP_NO_ERROR);
 
         FabricId fabricId;
         err = ExtractFabricIdFromCert(cert, &fabricId);
-        NL_TEST_ASSERT(inSuite, err == CHIP_ERROR_NOT_FOUND);
+        EXPECT_EQ(err, CHIP_ERROR_NOT_FOUND);
     }
 
     // Test extraction from the parsed form of ICA Cert that doesn't have FabricId.
     {
         CHIP_ERROR err = certSet.Init(1);
-        NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
+        EXPECT_EQ(err, CHIP_NO_ERROR);
 
         err = LoadTestCert(certSet, TestCert::kICA01, sNullLoadFlag, sNullDecodeFlag);
-        NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
+        EXPECT_EQ(err, CHIP_NO_ERROR);
 
         FabricId fabricId;
         err = ExtractFabricIdFromCert(certSet.GetCertSet()[0], &fabricId);
-        NL_TEST_ASSERT(inSuite, err == CHIP_ERROR_NOT_FOUND);
+        EXPECT_EQ(err, CHIP_ERROR_NOT_FOUND);
         certSet.Release();
     }
 }
 
-static void TestChipCert_ExtractOperationalDiscoveryId(nlTestSuite * inSuite, void * inContext)
+TEST_F(TestChipCert, TestChipCert_ExtractOperationalDiscoveryId)
 {
     struct TestCase
     {
@@ -1901,30 +1893,30 @@
         ByteSpan noc;
         ByteSpan rcac;
         CHIP_ERROR err = GetTestCert(testCase.Noc, sNullLoadFlag, noc);
-        NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
+        EXPECT_EQ(err, CHIP_NO_ERROR);
         err = GetTestCert(testCase.Rcac, sNullLoadFlag, rcac);
-        NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
+        EXPECT_EQ(err, CHIP_NO_ERROR);
 
         // Extract Node ID and Fabric ID from the leaf node certificate.
         NodeId nodeId;
         FabricId fabricId;
         err = ExtractNodeIdFabricIdFromOpCert(noc, &nodeId, &fabricId);
-        NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
-        NL_TEST_ASSERT(inSuite, nodeId == testCase.ExpectedNodeId);
-        NL_TEST_ASSERT(inSuite, fabricId == testCase.ExpectedFabricId);
+        EXPECT_EQ(err, CHIP_NO_ERROR);
+        EXPECT_EQ(nodeId, testCase.ExpectedNodeId);
+        EXPECT_EQ(fabricId, testCase.ExpectedFabricId);
 
         // Extract Node ID, Fabric ID and Compressed Fabric ID from the
         // NOC and root certificate.
         CompressedFabricId compressedFabricId;
         err = ExtractNodeIdFabricIdCompressedFabricIdFromOpCerts(rcac, noc, compressedFabricId, fabricId, nodeId);
-        NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
-        NL_TEST_ASSERT(inSuite, compressedFabricId == testCase.ExpectedCompressedFabricId);
-        NL_TEST_ASSERT(inSuite, fabricId == testCase.ExpectedFabricId);
-        NL_TEST_ASSERT(inSuite, nodeId == testCase.ExpectedNodeId);
+        EXPECT_EQ(err, CHIP_NO_ERROR);
+        EXPECT_EQ(compressedFabricId, testCase.ExpectedCompressedFabricId);
+        EXPECT_EQ(fabricId, testCase.ExpectedFabricId);
+        EXPECT_EQ(nodeId, testCase.ExpectedNodeId);
     }
 }
 
-static void TestChipCert_ExtractAndValidateCATsFromOpCert(nlTestSuite * inSuite, void * inContext)
+TEST_F(TestChipCert, TestChipCert_ExtractAndValidateCATsFromOpCert)
 {
     struct TestCase
     {
@@ -1954,12 +1946,12 @@
     {
         ByteSpan cert;
         CHIP_ERROR err = GetTestCert(testCase.Cert, sNullLoadFlag, cert);
-        NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
+        EXPECT_EQ(err, CHIP_NO_ERROR);
 
         CATValues cats;
         err = ExtractCATsFromOpCert(cert, cats);
-        NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
-        NL_TEST_ASSERT(inSuite, memcmp(&cats, &testCase.ExpectedCATs, sizeof(cats)) == 0);
+        EXPECT_EQ(err, CHIP_NO_ERROR);
+        EXPECT_EQ(memcmp(&cats, &testCase.ExpectedCATs, sizeof(cats)), 0);
     }
 
     // Test extraction from the parsed form.
@@ -1967,15 +1959,15 @@
     for (auto & testCase : sTestCases)
     {
         CHIP_ERROR err = certSet.Init(1);
-        NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
+        EXPECT_EQ(err, CHIP_NO_ERROR);
 
         err = LoadTestCert(certSet, testCase.Cert, sNullLoadFlag, sNullDecodeFlag);
-        NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
+        EXPECT_EQ(err, CHIP_NO_ERROR);
 
         CATValues cats;
         err = ExtractCATsFromOpCert(certSet.GetCertSet()[0], cats);
-        NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
-        NL_TEST_ASSERT(inSuite, memcmp(&cats, &testCase.ExpectedCATs, sizeof(cats)) == 0);
+        EXPECT_EQ(err, CHIP_NO_ERROR);
+        EXPECT_EQ(memcmp(&cats, &testCase.ExpectedCATs, sizeof(cats)), 0);
 
         certSet.Release();
     }
@@ -1983,14 +1975,14 @@
     // Error case: trying to extract CAT from Root Cert.
     {
         CHIP_ERROR err = certSet.Init(1);
-        NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
+        EXPECT_EQ(err, CHIP_NO_ERROR);
 
         err = LoadTestCert(certSet, TestCert::kRoot01, sNullLoadFlag, sNullDecodeFlag);
-        NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
+        EXPECT_EQ(err, CHIP_NO_ERROR);
 
         CATValues cats;
         err = ExtractCATsFromOpCert(certSet.GetCertSet()[0], cats);
-        NL_TEST_ASSERT(inSuite, err == CHIP_ERROR_INVALID_ARGUMENT);
+        EXPECT_EQ(err, CHIP_ERROR_INVALID_ARGUMENT);
 
         certSet.Release();
     }
@@ -1999,18 +1991,18 @@
     {
         CATValues cats;
         CHIP_ERROR err = ExtractCATsFromOpCert(ByteSpan(sChipTest_NOC_Subject_CAT_Invalid_Cert_CHIP), cats);
-        NL_TEST_ASSERT(inSuite, err == CHIP_ERROR_INVALID_ARGUMENT);
+        EXPECT_EQ(err, CHIP_ERROR_INVALID_ARGUMENT);
     }
 
     // Error case: NOC with multiple versions of the same CAT tag.
     {
         CATValues cats;
         CHIP_ERROR err = ExtractCATsFromOpCert(ByteSpan(sChipTest_NOC_Subject_CAT_Twice_Cert_CHIP), cats);
-        NL_TEST_ASSERT(inSuite, err == CHIP_ERROR_WRONG_CERT_DN);
+        EXPECT_EQ(err, CHIP_ERROR_WRONG_CERT_DN);
     }
 }
 
-static void TestChipCert_ExtractSubjectDNFromChipCert(nlTestSuite * inSuite, void * inContext)
+TEST_F(TestChipCert, TestChipCert_ExtractSubjectDNFromChipCert)
 {
     struct TestCase
     {
@@ -2019,29 +2011,28 @@
     };
 
     ChipDN expectedSubjectDN_Root01;
-    NL_TEST_ASSERT(inSuite, expectedSubjectDN_Root01.AddAttribute_MatterRCACId(0xCACACACA00000001) == CHIP_NO_ERROR);
+    EXPECT_EQ(expectedSubjectDN_Root01.AddAttribute_MatterRCACId(0xCACACACA00000001), CHIP_NO_ERROR);
 
     ChipDN expectedSubjectDN_Root02;
-    NL_TEST_ASSERT(inSuite, expectedSubjectDN_Root02.AddAttribute_MatterRCACId(0xCACACACA00000002) == CHIP_NO_ERROR);
-    NL_TEST_ASSERT(inSuite, expectedSubjectDN_Root02.AddAttribute_MatterFabricId(0xFAB000000000001D) == CHIP_NO_ERROR);
+    EXPECT_EQ(expectedSubjectDN_Root02.AddAttribute_MatterRCACId(0xCACACACA00000002), CHIP_NO_ERROR);
+    EXPECT_EQ(expectedSubjectDN_Root02.AddAttribute_MatterFabricId(0xFAB000000000001D), CHIP_NO_ERROR);
 
     ChipDN expectedSubjectDN_ICA02;
-    NL_TEST_ASSERT(inSuite, expectedSubjectDN_ICA02.AddAttribute_MatterICACId(0xCACACACA00000004) == CHIP_NO_ERROR);
-    NL_TEST_ASSERT(inSuite, expectedSubjectDN_ICA02.AddAttribute_MatterFabricId(0xFAB000000000001D) == CHIP_NO_ERROR);
+    EXPECT_EQ(expectedSubjectDN_ICA02.AddAttribute_MatterICACId(0xCACACACA00000004), CHIP_NO_ERROR);
+    EXPECT_EQ(expectedSubjectDN_ICA02.AddAttribute_MatterFabricId(0xFAB000000000001D), CHIP_NO_ERROR);
 
     ChipDN expectedSubjectDN_Node01_01;
-    NL_TEST_ASSERT(inSuite, expectedSubjectDN_Node01_01.AddAttribute_MatterNodeId(0xDEDEDEDE00010001) == CHIP_NO_ERROR);
-    NL_TEST_ASSERT(inSuite, expectedSubjectDN_Node01_01.AddAttribute_MatterFabricId(0xFAB000000000001D) == CHIP_NO_ERROR);
+    EXPECT_EQ(expectedSubjectDN_Node01_01.AddAttribute_MatterNodeId(0xDEDEDEDE00010001), CHIP_NO_ERROR);
+    EXPECT_EQ(expectedSubjectDN_Node01_01.AddAttribute_MatterFabricId(0xFAB000000000001D), CHIP_NO_ERROR);
 
     const static char commonName_RDN[] = "TestCert02_03";
 
     ChipDN expectedSubjectDN_Node02_03;
-    NL_TEST_ASSERT(inSuite, expectedSubjectDN_Node02_03.AddAttribute_MatterNodeId(0xDEDEDEDE00020003) == CHIP_NO_ERROR);
-    NL_TEST_ASSERT(inSuite, expectedSubjectDN_Node02_03.AddAttribute_MatterFabricId(0xFAB000000000001D) == CHIP_NO_ERROR);
-    NL_TEST_ASSERT(inSuite,
-                   expectedSubjectDN_Node02_03.AddAttribute_CommonName(CharSpan(commonName_RDN, strlen(commonName_RDN)), false) ==
-                       CHIP_NO_ERROR);
-    NL_TEST_ASSERT(inSuite, expectedSubjectDN_Node02_03.AddAttribute_MatterCASEAuthTag(0xABCD0001) == CHIP_NO_ERROR);
+    EXPECT_EQ(expectedSubjectDN_Node02_03.AddAttribute_MatterNodeId(0xDEDEDEDE00020003), CHIP_NO_ERROR);
+    EXPECT_EQ(expectedSubjectDN_Node02_03.AddAttribute_MatterFabricId(0xFAB000000000001D), CHIP_NO_ERROR);
+    EXPECT_EQ(expectedSubjectDN_Node02_03.AddAttribute_CommonName(CharSpan(commonName_RDN, strlen(commonName_RDN)), false),
+              CHIP_NO_ERROR);
+    EXPECT_EQ(expectedSubjectDN_Node02_03.AddAttribute_MatterCASEAuthTag(0xABCD0001), CHIP_NO_ERROR);
 
     // clang-format off
     TestCase sTestCases[] = {
@@ -2061,15 +2052,15 @@
     {
         ByteSpan cert;
         CHIP_ERROR err = GetTestCert(testCase.Cert, sNullLoadFlag, cert);
-        NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
+        EXPECT_EQ(err, CHIP_NO_ERROR);
 
         ChipDN subjectDN;
         err = ExtractSubjectDNFromChipCert(cert, subjectDN);
-        NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
+        EXPECT_EQ(err, CHIP_NO_ERROR);
 
         if (!testCase.ExpectedSubjectDN.IsEmpty())
         {
-            NL_TEST_ASSERT(inSuite, subjectDN.IsEqual(testCase.ExpectedSubjectDN));
+            EXPECT_TRUE(subjectDN.IsEqual(testCase.ExpectedSubjectDN));
         }
     }
 
@@ -2078,20 +2069,20 @@
     {
         ByteSpan cert;
         CHIP_ERROR err = GetTestCert(testCase.Cert, TestCertLoadFlags::kDERForm, cert);
-        NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
+        EXPECT_EQ(err, CHIP_NO_ERROR);
 
         ChipDN subjectDN;
         err = ExtractSubjectDNFromX509Cert(cert, subjectDN);
-        NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
+        EXPECT_EQ(err, CHIP_NO_ERROR);
 
         if (!testCase.ExpectedSubjectDN.IsEmpty())
         {
-            NL_TEST_ASSERT(inSuite, subjectDN.IsEqual(testCase.ExpectedSubjectDN));
+            EXPECT_TRUE(subjectDN.IsEqual(testCase.ExpectedSubjectDN));
         }
     }
 }
 
-static void TestChipCert_ExtractPublicKeyAndSKID(nlTestSuite * inSuite, void * inContext)
+TEST_F(TestChipCert, TestChipCert_ExtractPublicKeyAndSKID)
 {
     struct TestCase
     {
@@ -2127,28 +2118,28 @@
     {
         ByteSpan cert;
         CHIP_ERROR err = GetTestCert(testCase.Cert, sNullLoadFlag, cert);
-        NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
+        EXPECT_EQ(err, CHIP_NO_ERROR);
 
         P256PublicKeySpan publicKey;
         err = ExtractPublicKeyFromChipCert(cert, publicKey);
-        NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
-        NL_TEST_ASSERT(inSuite, publicKey.data_equal(testCase.ExpectedPublicKey));
+        EXPECT_EQ(err, CHIP_NO_ERROR);
+        EXPECT_TRUE(publicKey.data_equal(testCase.ExpectedPublicKey));
 
         CertificateKeyId skid;
         err = ExtractSKIDFromChipCert(cert, skid);
         if (!testCase.ExpectedSKID.empty())
         {
-            NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
-            NL_TEST_ASSERT(inSuite, skid.data_equal(testCase.ExpectedSKID));
+            EXPECT_EQ(err, CHIP_NO_ERROR);
+            EXPECT_TRUE(skid.data_equal(testCase.ExpectedSKID));
         }
         else
         {
-            NL_TEST_ASSERT(inSuite, err == CHIP_ERROR_NOT_FOUND);
+            EXPECT_EQ(err, CHIP_ERROR_NOT_FOUND);
         }
     }
 }
 
-static void TestChipCert_PDCIdentityValidation(nlTestSuite * inSuite, void * inContext)
+TEST_F(TestChipCert, TestChipCert_PDCIdentityValidation)
 {
     CertificateKeyIdStorage keyId;
 
@@ -2156,134 +2147,52 @@
     for (auto && cert : { sTestCert_PDCID01_Chip, sTestCert_PDCID01_ChipCompact })
     {
         // Validate only
-        NL_TEST_ASSERT(inSuite, ValidateChipNetworkIdentity(cert) == CHIP_NO_ERROR);
+        EXPECT_EQ(ValidateChipNetworkIdentity(cert), CHIP_NO_ERROR);
 
         // Validate and calculate identifier
         keyId.fill(0xaa);
-        NL_TEST_ASSERT(inSuite, ValidateChipNetworkIdentity(cert, keyId) == CHIP_NO_ERROR);
-        NL_TEST_ASSERT(inSuite, CertificateKeyId(keyId).data_equal(sTestCert_PDCID01_KeyId));
+        EXPECT_EQ(ValidateChipNetworkIdentity(cert, keyId), CHIP_NO_ERROR);
+        EXPECT_TRUE(CertificateKeyId(keyId).data_equal(sTestCert_PDCID01_KeyId));
 
         // Extract identifier only
         keyId.fill(0xaa);
-        NL_TEST_ASSERT(inSuite, ExtractIdentifierFromChipNetworkIdentity(cert, keyId) == CHIP_NO_ERROR);
-        NL_TEST_ASSERT(inSuite, CertificateKeyId(keyId).data_equal(sTestCert_PDCID01_KeyId));
+        EXPECT_EQ(ExtractIdentifierFromChipNetworkIdentity(cert, keyId), CHIP_NO_ERROR);
+        EXPECT_TRUE(CertificateKeyId(keyId).data_equal(sTestCert_PDCID01_KeyId));
     }
 }
 
-static void TestChipCert_PDCIdentityGeneration(nlTestSuite * inSuite, void * inContext)
+TEST_F(TestChipCert, TestChipCert_PDCIdentityGeneration)
 {
     // Generate a new keypair
     P256Keypair keypair;
-    NL_TEST_ASSERT(inSuite, keypair.Initialize(ECPKeyTarget::ECDSA) == CHIP_NO_ERROR);
+    EXPECT_EQ(keypair.Initialize(ECPKeyTarget::ECDSA), CHIP_NO_ERROR);
 
     // Generate an identity certificate based on the keypair
     uint8_t buffer[kMaxCHIPCompactNetworkIdentityLength];
     MutableByteSpan cert(buffer);
-    NL_TEST_ASSERT(inSuite, NewChipNetworkIdentity(keypair, cert) == CHIP_NO_ERROR);
-    NL_TEST_ASSERT(inSuite, ValidateChipNetworkIdentity(cert) == CHIP_NO_ERROR);
+    EXPECT_EQ(NewChipNetworkIdentity(keypair, cert), CHIP_NO_ERROR);
+    EXPECT_EQ(ValidateChipNetworkIdentity(cert), CHIP_NO_ERROR);
 
     // It should round-trip to X.509 DER and back, and remain valid.
     uint8_t derBuffer[kMaxDERCertLength];
     MutableByteSpan derCert(derBuffer);
-    NL_TEST_ASSERT(inSuite, ConvertChipCertToX509Cert(cert, derCert) == CHIP_NO_ERROR);
+    EXPECT_EQ(ConvertChipCertToX509Cert(cert, derCert), CHIP_NO_ERROR);
     uint8_t tlvBuffer[kMaxCHIPCertLength];
     MutableByteSpan tlvCert(tlvBuffer); // won't be compact after round-tripping
-    NL_TEST_ASSERT(inSuite, ConvertX509CertToChipCert(derCert, tlvCert) == CHIP_NO_ERROR);
-    NL_TEST_ASSERT(inSuite, ValidateChipNetworkIdentity(tlvCert) == CHIP_NO_ERROR);
+    EXPECT_EQ(ConvertX509CertToChipCert(derCert, tlvCert), CHIP_NO_ERROR);
+    EXPECT_EQ(ValidateChipNetworkIdentity(tlvCert), CHIP_NO_ERROR);
 }
 
-static void TestChipCert_KeypairConversion(nlTestSuite * inSuite, void * inContext)
+TEST_F(TestChipCert, TestChipCert_KeypairConversion)
 {
     P256SerializedKeypair keypair;
-    NL_TEST_ASSERT_SUCCESS(inSuite, GetTestCertKeypair(kPDCID01, keypair));
+    EXPECT_EQ(GetTestCertKeypair(kPDCID01, keypair), CHIP_NO_ERROR);
 
     uint8_t buffer[kP256ECPrivateKeyDERLength];
     MutableByteSpan keypairDer(buffer);
-    NL_TEST_ASSERT_SUCCESS(inSuite, ConvertECDSAKeypairRawToDER(keypair, keypairDer));
+    EXPECT_EQ(ConvertECDSAKeypairRawToDER(keypair, keypairDer), CHIP_NO_ERROR);
 
     // Technically the curve name and public key are optional in the DER format,
     // but both our code and standard tools include them, so we can just compare.
-    NL_TEST_ASSERT(inSuite, keypairDer.data_equal(sTestCert_PDCID01_KeypairDER));
+    EXPECT_TRUE(keypairDer.data_equal(sTestCert_PDCID01_KeypairDER));
 }
-
-/**
- *  Set up the test suite.
- */
-int TestChipCert_Setup(void * inContext)
-{
-    CHIP_ERROR error = chip::Platform::MemoryInit();
-
-    if (error != CHIP_NO_ERROR)
-    {
-        return FAILURE;
-    }
-
-    return SUCCESS;
-}
-
-/**
- *  Tear down the test suite.
- */
-int TestChipCert_Teardown(void * inContext)
-{
-    chip::Platform::MemoryShutdown();
-    return SUCCESS;
-}
-
-/**
- *   Test Suite. It lists all the test functions.
- */
-// clang-format off
-static const nlTest sTests[] = {
-    NL_TEST_DEF("Test CHIP Certificate CHIP to X509 Conversion", TestChipCert_ChipToX509),
-    NL_TEST_DEF("Test CHIP Certificate CHIP to X509 Conversion - Error Cases", TestChipCert_ChipToX509_ErrorCases),
-    NL_TEST_DEF("Test CHIP Certificate Loading - Error Cases", TestChipCert_ChipCertLoad_ErrorCases),
-    NL_TEST_DEF("Test CHIP Certificate Validate RCAC - Error Cases", TestChipCert_ValidateChipRCAC_ErrorCases),
-    NL_TEST_DEF("Test CHIP Certificate Get Cert Type from Subject - Error Cases", TestChipCert_GetCertType_ErrorCases),
-    NL_TEST_DEF("Test CHIP Certificate X509 to CHIP Conversion", TestChipCert_X509ToChip),
-    NL_TEST_DEF("Test CHIP Certificate X509 to CHIP Conversion - Error Cases", TestChipCert_X509ToChip_ErrorCases),
-    NL_TEST_DEF("Test CHIP Certificate Distinguish Name", TestChipCert_ChipDN),
-    NL_TEST_DEF("Test CHIP Certificate Validation", TestChipCert_CertValidation),
-    NL_TEST_DEF("Test CHIP Certificate Validation time", TestChipCert_CertValidTime),
-    NL_TEST_DEF("Test CHIP Root Certificate Validation", TestChipCert_ValidateChipRCAC),
-    NL_TEST_DEF("Test CHIP Certificate Validity Policy injection", TestChipCert_CertValidityPolicyInjection),
-    NL_TEST_DEF("Test CHIP Certificate Usage", TestChipCert_CertUsage),
-    NL_TEST_DEF("Test CHIP Certificate Type", TestChipCert_CertType),
-    NL_TEST_DEF("Test CHIP Certificate ID", TestChipCert_CertId),
-    NL_TEST_DEF("Test CHIP Certificate Decoding Options", TestChipCert_DecodingOptions),
-    NL_TEST_DEF("Test Loading Duplicate Certificates", TestChipCert_LoadDuplicateCerts),
-    NL_TEST_DEF("Test CHIP Generate Root Certificate", TestChipCert_GenerateRootCert),
-    NL_TEST_DEF("Test CHIP Generate Root Certificate with Fabric", TestChipCert_GenerateRootFabCert),
-    NL_TEST_DEF("Test CHIP Generate ICA Certificate", TestChipCert_GenerateICACert),
-    NL_TEST_DEF("Test CHIP Generate NOC using Root", TestChipCert_GenerateNOCRoot),
-    NL_TEST_DEF("Test CHIP Generate NOC using ICA", TestChipCert_GenerateNOCICA),
-    NL_TEST_DEF("Test CHIP Verify Generated Cert Chain", TestChipCert_VerifyGeneratedCerts),
-    NL_TEST_DEF("Test CHIP Verify Generated Cert Chain No ICA", TestChipCert_VerifyGeneratedCertsNoICA),
-    NL_TEST_DEF("Test extracting Node ID and Fabric ID from node certificate", TestChipCert_ExtractNodeIdFabricId),
-    NL_TEST_DEF("Test extracting Operational Discovery ID from node and root certificate", TestChipCert_ExtractOperationalDiscoveryId),
-    NL_TEST_DEF("Test extracting and validating CASE Authenticated Tags from NOC", TestChipCert_ExtractAndValidateCATsFromOpCert),
-    NL_TEST_DEF("Test extracting Subject DN from chip certificate", TestChipCert_ExtractSubjectDNFromChipCert),
-    NL_TEST_DEF("Test extracting PublicKey and SKID from chip certificate", TestChipCert_ExtractPublicKeyAndSKID),
-    NL_TEST_DEF("Test PDC Identity Validation", TestChipCert_PDCIdentityValidation),
-    NL_TEST_DEF("Test PDC Identity Generation", TestChipCert_PDCIdentityGeneration),
-    NL_TEST_DEF("Test keypair conversion", TestChipCert_KeypairConversion),
-    NL_TEST_SENTINEL()
-};
-// clang-format on
-
-int TestChipCert()
-{
-    // clang-format off
-    nlTestSuite theSuite =
-    {
-        "Credentials-CHIP-Certs",
-        &sTests[0],
-        TestChipCert_Setup,
-        TestChipCert_Teardown
-    };
-    // clang-format on
-    nlTestRunner(&theSuite, nullptr);
-    return (nlTestRunnerStats(&theSuite));
-}
-
-CHIP_REGISTER_TEST_SUITE(TestChipCert);
diff --git a/src/credentials/tests/TestCommissionerDUTVectors.cpp b/src/credentials/tests/TestCommissionerDUTVectors.cpp
index 4c7efea..55beafd 100644
--- a/src/credentials/tests/TestCommissionerDUTVectors.cpp
+++ b/src/credentials/tests/TestCommissionerDUTVectors.cpp
@@ -29,10 +29,8 @@
 #include <lib/core/CHIPError.h>
 #include <lib/support/CHIPMem.h>
 #include <lib/support/Span.h>
-#include <lib/support/UnitTestExtendedAssertions.h>
-#include <lib/support/UnitTestRegistration.h>
 
-#include <nlunit-test.h>
+#include <gtest/gtest.h>
 
 #include <dirent.h>
 #include <stdio.h>
@@ -49,10 +47,17 @@
     *pResult                                = result;
 }
 
-static void TestCommissionerDUTVectors(nlTestSuite * inSuite, void * inContext)
+struct TestCommissionerDUTVectors : public ::testing::Test
+{
+    static void SetUpTestSuite() { ASSERT_EQ(chip::Platform::MemoryInit(), CHIP_NO_ERROR); }
+
+    static void TearDownTestSuite() { chip::Platform::MemoryShutdown(); }
+};
+
+TEST_F(TestCommissionerDUTVectors, TestCommissionerDUTVectors)
 {
     DeviceAttestationVerifier * example_dac_verifier = GetDefaultDACVerifier(GetTestAttestationTrustStore());
-    NL_TEST_ASSERT(inSuite, example_dac_verifier != nullptr);
+    ASSERT_NE(example_dac_verifier, nullptr);
 
     std::string dirPath("../../../../../credentials/development/commissioner_dut/");
     DIR * dir = opendir(dirPath.c_str());
@@ -105,14 +110,14 @@
         VendorId vid = TestVendor1;
         uint16_t pid = strstr(entry->d_name, "_vidpid_fallback_encoding_") ? 0x00B1 : 0x8000;
 
-        NL_TEST_ASSERT_SUCCESS(inSuite, dacProvider.GetCertificationDeclaration(certDeclSpan));
-        NL_TEST_ASSERT_SUCCESS(inSuite, dacProvider.GetDeviceAttestationCert(dacCertSpan));
-        NL_TEST_ASSERT_SUCCESS(inSuite, dacProvider.GetProductAttestationIntermediateCert(paiCertSpan));
+        EXPECT_EQ(dacProvider.GetCertificationDeclaration(certDeclSpan), CHIP_NO_ERROR);
+        EXPECT_EQ(dacProvider.GetDeviceAttestationCert(dacCertSpan), CHIP_NO_ERROR);
+        EXPECT_EQ(dacProvider.GetProductAttestationIntermediateCert(paiCertSpan), CHIP_NO_ERROR);
 
         size_t attestationElementsLen =
             TLV::EstimateStructOverhead(certDeclSpan.size(), attestationNonceSpan.size(), sizeof(uint64_t) * 8);
         Platform::ScopedMemoryBuffer<uint8_t> attestationElements;
-        NL_TEST_ASSERT(inSuite, attestationElements.Alloc(attestationElementsLen + attestationChallengeSpan.size()));
+        EXPECT_TRUE(attestationElements.Alloc(attestationElementsLen + attestationChallengeSpan.size()));
         MutableByteSpan attestationElementsSpan(attestationElements.Get(), attestationElementsLen);
 
         // Construct attestation elements
@@ -121,10 +126,9 @@
             Credentials::DeviceAttestationVendorReservedConstructor emptyVendorReserved(nullptr, 0);
             const ByteSpan kEmptyFirmwareInfo;
 
-            NL_TEST_ASSERT_SUCCESS(inSuite,
-                                   Credentials::ConstructAttestationElements(certDeclSpan, attestationNonceSpan, timestamp,
-                                                                             kEmptyFirmwareInfo, emptyVendorReserved,
-                                                                             attestationElementsSpan));
+            EXPECT_EQ(Credentials::ConstructAttestationElements(certDeclSpan, attestationNonceSpan, timestamp, kEmptyFirmwareInfo,
+                                                                emptyVendorReserved, attestationElementsSpan),
+                      CHIP_NO_ERROR);
         }
 
         // Generate attestation signature
@@ -134,8 +138,8 @@
                    attestationChallengeSpan.size());
             ByteSpan tbsSpan(attestationElementsSpan.data(), attestationElementsSpan.size() + attestationChallengeSpan.size());
 
-            NL_TEST_ASSERT_SUCCESS(inSuite, dacProvider.SignWithDeviceAttestationKey(tbsSpan, attestationSignatureSpan));
-            NL_TEST_ASSERT(inSuite, attestationSignatureSpan.size() == signature.Capacity());
+            EXPECT_EQ(dacProvider.SignWithDeviceAttestationKey(tbsSpan, attestationSignatureSpan), CHIP_NO_ERROR);
+            EXPECT_EQ(attestationSignatureSpan.size(), signature.Capacity());
         }
 
         AttestationVerificationResult attestationResult = AttestationVerificationResult::kNotImplemented;
@@ -167,63 +171,12 @@
 
         if (isSuccessCase)
         {
-            NL_TEST_ASSERT(inSuite, attestationResult == AttestationVerificationResult::kSuccess);
+            EXPECT_EQ(attestationResult, AttestationVerificationResult::kSuccess);
         }
         else
         {
-            NL_TEST_ASSERT(inSuite, attestationResult != AttestationVerificationResult::kSuccess);
+            EXPECT_NE(attestationResult, AttestationVerificationResult::kSuccess);
         }
     }
     closedir(dir);
 }
-
-/**
- *  Set up the test suite.
- */
-int TestCommissionerDUT_Setup(void * inContext)
-{
-    CHIP_ERROR error = chip::Platform::MemoryInit();
-
-    if (error != CHIP_NO_ERROR)
-    {
-        return FAILURE;
-    }
-
-    return SUCCESS;
-}
-
-/**
- *  Tear down the test suite.
- */
-int TestCommissionerDUT_Teardown(void * inContext)
-{
-    chip::Platform::MemoryShutdown();
-    return SUCCESS;
-}
-
-/**
- *   Test Suite. It lists all the test functions.
- */
-// clang-format off
-static const nlTest sTests[] = {
-    NL_TEST_DEF("Test Device Attestation Credentials Vectors", TestCommissionerDUTVectors),
-    NL_TEST_SENTINEL()
-};
-// clang-format on
-
-int TestCommissionerDUT()
-{
-    // clang-format off
-    nlTestSuite theSuite =
-    {
-        "Device Attestation Credentials Test Vectors",
-        &sTests[0],
-        TestCommissionerDUT_Setup,
-        TestCommissionerDUT_Teardown
-    };
-    // clang-format on
-    nlTestRunner(&theSuite, nullptr);
-    return (nlTestRunnerStats(&theSuite));
-}
-
-CHIP_REGISTER_TEST_SUITE(TestCommissionerDUT);
diff --git a/src/credentials/tests/TestDeviceAttestationConstruction.cpp b/src/credentials/tests/TestDeviceAttestationConstruction.cpp
index 8d1b017..e624b25 100644
--- a/src/credentials/tests/TestDeviceAttestationConstruction.cpp
+++ b/src/credentials/tests/TestDeviceAttestationConstruction.cpp
@@ -22,15 +22,20 @@
 #include <lib/support/CodeUtils.h>
 #include <lib/support/ScopedBuffer.h>
 #include <lib/support/Span.h>
-#include <lib/support/UnitTestRegistration.h>
 
 #include <cstdio>
-#include <nlunit-test.h>
+#include <gtest/gtest.h>
 
 using namespace chip;
 using namespace chip::Credentials;
 
-static void TestAttestationElements_Roundtrip(nlTestSuite * inSuite, void * inContext)
+struct TestDeviceAttestationConstruction : public ::testing::Test
+{
+    static void SetUpTestSuite() { ASSERT_EQ(chip::Platform::MemoryInit(), CHIP_NO_ERROR); }
+    static void TearDownTestSuite() { chip::Platform::MemoryShutdown(); }
+};
+
+TEST_F(TestDeviceAttestationConstruction, TestAttestationElements_Roundtrip)
 {
     CHIP_ERROR err = CHIP_NO_ERROR;
     chip::Platform::ScopedMemoryBuffer<uint8_t> attestationElements;
@@ -67,7 +72,7 @@
     attestationElements.Alloc(attestationElementsLen);
     vendorReservedConstructor.addVendorReservedElement(vendorId, profileNum, 1, ByteSpan(vendorReserved1));
     vendorReservedConstructor.addVendorReservedElement(vendorId, profileNum, 3, ByteSpan(vendorReserved3));
-    NL_TEST_ASSERT(inSuite, attestationElements);
+    EXPECT_TRUE(attestationElements);
 
     {
         MutableByteSpan attestationElementsSpan(attestationElements.Get(), attestationElementsLen);
@@ -76,22 +81,22 @@
         err = ConstructAttestationElements(ByteSpan(certificationDeclaration),
                                            ByteSpan(attestationNonce, sizeof(attestationNonce) - 1), timestamp, ByteSpan(),
                                            vendorReservedConstructor, attestationElementsSpan);
-        NL_TEST_ASSERT(inSuite, err == CHIP_ERROR_INVALID_ARGUMENT);
+        EXPECT_EQ(err, CHIP_ERROR_INVALID_ARGUMENT);
 
         // Test with missing mandatory TLV entries
         err = ConstructAttestationElements(ByteSpan(), ByteSpan(attestationNonce), timestamp, ByteSpan(), vendorReservedConstructor,
                                            attestationElementsSpan);
-        NL_TEST_ASSERT(inSuite, err == CHIP_ERROR_INVALID_ARGUMENT);
+        EXPECT_EQ(err, CHIP_ERROR_INVALID_ARGUMENT);
 
         // Test with missing mandatory TLV entries
         err = ConstructAttestationElements(ByteSpan(certificationDeclaration), ByteSpan(), timestamp, ByteSpan(),
                                            vendorReservedConstructor, attestationElementsSpan);
-        NL_TEST_ASSERT(inSuite, err == CHIP_ERROR_INVALID_ARGUMENT);
+        EXPECT_EQ(err, CHIP_ERROR_INVALID_ARGUMENT);
 
         // Test for success with entirely valid arguments
         err = ConstructAttestationElements(ByteSpan(certificationDeclaration), ByteSpan(attestationNonce), timestamp, ByteSpan(),
                                            vendorReservedConstructor, attestationElementsSpan);
-        NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
+        EXPECT_EQ(err, CHIP_NO_ERROR);
         attestationElementsLen = attestationElementsSpan.size();
     }
 
@@ -104,13 +109,13 @@
     err =
         DeconstructAttestationElements(ByteSpan(attestationElements.Get(), attestationElementsLen), certificationDeclarationSpan,
                                        attestationNonceSpan, timestampDeconstructed, firmwareInfoSpan, vendorReservedDeconstructor);
-    NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
-    NL_TEST_ASSERT(inSuite, certificationDeclarationSpan.data_equal(ByteSpan(certificationDeclaration)));
-    NL_TEST_ASSERT(inSuite, attestationNonceSpan.data_equal(ByteSpan(attestationNonce)));
-    NL_TEST_ASSERT(inSuite, timestamp == timestampDeconstructed);
-    NL_TEST_ASSERT(inSuite, firmwareInfoSpan.empty());
+    EXPECT_EQ(err, CHIP_NO_ERROR);
+    EXPECT_TRUE(certificationDeclarationSpan.data_equal(ByteSpan(certificationDeclaration)));
+    EXPECT_TRUE(attestationNonceSpan.data_equal(ByteSpan(attestationNonce)));
+    EXPECT_EQ(timestamp, timestampDeconstructed);
+    EXPECT_TRUE(firmwareInfoSpan.empty());
 
-    NL_TEST_ASSERT(inSuite, vendorReservedConstructor.GetNumberOfElements() == vendorReservedDeconstructor.GetNumberOfElements());
+    EXPECT_EQ(vendorReservedConstructor.GetNumberOfElements(), vendorReservedDeconstructor.GetNumberOfElements());
 
     const VendorReservedElement * constructionElement = vendorReservedConstructor.cbegin();
     VendorReservedElement deconstructionElement;
@@ -118,13 +123,13 @@
     while ((constructionElement = vendorReservedConstructor.Next()) != nullptr &&
            vendorReservedDeconstructor.GetNextVendorReservedElement(deconstructionElement) == CHIP_NO_ERROR)
     {
-        NL_TEST_ASSERT(inSuite, constructionElement->vendorId == deconstructionElement.vendorId);
-        NL_TEST_ASSERT(inSuite, constructionElement->profileNum == deconstructionElement.profileNum);
-        NL_TEST_ASSERT(inSuite, constructionElement->vendorReservedData.data_equal(deconstructionElement.vendorReservedData));
+        EXPECT_EQ(constructionElement->vendorId, deconstructionElement.vendorId);
+        EXPECT_EQ(constructionElement->profileNum, deconstructionElement.profileNum);
+        EXPECT_TRUE(constructionElement->vendorReservedData.data_equal(deconstructionElement.vendorReservedData));
     }
 }
 
-static void TestAttestationElements_Construction(nlTestSuite * inSuite, void * inContext)
+TEST_F(TestDeviceAttestationConstruction, TestAttestationElements_Construction)
 {
     CHIP_ERROR err = CHIP_NO_ERROR;
     Platform::ScopedMemoryBuffer<uint8_t> attestationElements;
@@ -175,21 +180,21 @@
     attestationElementsLen = sizeof(certificationDeclaration) + sizeof(attestationNonce) + sizeof(timestamp) +
         sizeof(vendorReserved1) + sizeof(vendorReserved3) + sizeof(uint64_t) * 5;
     attestationElements.Alloc(attestationElementsLen);
-    NL_TEST_ASSERT(inSuite, attestationElements);
+    EXPECT_TRUE(attestationElements);
 
     {
         MutableByteSpan attestationElementsSpan(attestationElements.Get(), attestationElementsLen);
 
         err = ConstructAttestationElements(ByteSpan(certificationDeclaration), ByteSpan(attestationNonce), timestamp, ByteSpan(),
                                            vendorReserved, attestationElementsSpan);
-        NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
+        EXPECT_EQ(err, CHIP_NO_ERROR);
         attestationElementsLen = attestationElementsSpan.size();
 
-        NL_TEST_ASSERT(inSuite, attestationElementsSpan.data_equal(ByteSpan(attestationElementsTestVector)));
+        EXPECT_TRUE(attestationElementsSpan.data_equal(ByteSpan(attestationElementsTestVector)));
     }
 }
 
-static void TestAttestationElements_Deconstruction(nlTestSuite * inSuite, void * inContext)
+TEST_F(TestDeviceAttestationConstruction, TestAttestationElements_Deconstruction)
 {
     // This is a test case with only the known TLV tags fields
     constexpr uint8_t attestationElementsTestVectorOnlyKnownTags[] = {
@@ -266,36 +271,36 @@
         err = DeconstructAttestationElements(attestationElementsTestCase, certificationDeclarationDeconstructed,
                                              attestationNonceDeconstructed, timestampDeconstructed, firmwareInfoDeconstructed,
                                              vendorReserved);
-        NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
+        EXPECT_EQ(err, CHIP_NO_ERROR);
 
-        NL_TEST_ASSERT(inSuite, certificationDeclarationDeconstructed.data_equal(ByteSpan(certificationDeclarationTestVector)));
-        NL_TEST_ASSERT(inSuite, attestationNonceDeconstructed.data_equal(ByteSpan(attestationNonceTestVector)));
-        NL_TEST_ASSERT(inSuite, timestampTestVector == timestampDeconstructed);
-        NL_TEST_ASSERT(inSuite, firmwareInfoDeconstructed.empty());
-        NL_TEST_ASSERT(inSuite, ArraySize(vendorReservedArrayTestVector) == vendorReserved.GetNumberOfElements());
+        EXPECT_TRUE(certificationDeclarationDeconstructed.data_equal(ByteSpan(certificationDeclarationTestVector)));
+        EXPECT_TRUE(attestationNonceDeconstructed.data_equal(ByteSpan(attestationNonceTestVector)));
+        EXPECT_EQ(timestampTestVector, timestampDeconstructed);
+        EXPECT_TRUE(firmwareInfoDeconstructed.empty());
+        EXPECT_EQ(ArraySize(vendorReservedArrayTestVector), vendorReserved.GetNumberOfElements());
         struct VendorReservedElement element;
 
         while (vendorReserved.GetNextVendorReservedElement(element) == CHIP_NO_ERROR)
         {
-            NL_TEST_ASSERT(inSuite, vendorIdTestVector == element.vendorId);
-            NL_TEST_ASSERT(inSuite, profileNumTestVector == element.profileNum);
+            EXPECT_EQ(vendorIdTestVector, element.vendorId);
+            EXPECT_EQ(profileNumTestVector, element.profileNum);
             switch (element.tagNum)
             {
             case 1:
-                NL_TEST_ASSERT(inSuite, element.vendorReservedData.data_equal(vendorReservedArrayTestVector[0]));
+                EXPECT_TRUE(element.vendorReservedData.data_equal(vendorReservedArrayTestVector[0]));
                 break;
             case 3:
-                NL_TEST_ASSERT(inSuite, element.vendorReservedData.data_equal(vendorReservedArrayTestVector[1]));
+                EXPECT_TRUE(element.vendorReservedData.data_equal(vendorReservedArrayTestVector[1]));
                 break;
             default:
-                NL_TEST_ASSERT(inSuite, 0);
+                EXPECT_TRUE(0);
                 break;
             }
         }
     }
 }
 
-static void TestAttestationElements_DeconstructionNoVendorReserved(nlTestSuite * inSuite, void * inContext)
+TEST_F(TestDeviceAttestationConstruction, TestAttestationElements_DeconstructionNoVendorReserved)
 {
     // This is a test case with only the known TLV tags fields
     constexpr uint8_t attestationElementsTestVectorNoVendor[] = {
@@ -333,19 +338,19 @@
     err = DeconstructAttestationElements(ByteSpan{ attestationElementsTestVectorNoVendor }, certificationDeclarationDeconstructed,
                                          attestationNonceDeconstructed, timestampDeconstructed, firmwareInfoDeconstructed,
                                          vendorReserved);
-    NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
+    EXPECT_EQ(err, CHIP_NO_ERROR);
 
-    NL_TEST_ASSERT(inSuite, certificationDeclarationDeconstructed.data_equal(ByteSpan(certificationDeclarationTestVector)));
-    NL_TEST_ASSERT(inSuite, attestationNonceDeconstructed.data_equal(ByteSpan(attestationNonceTestVector)));
-    NL_TEST_ASSERT(inSuite, timestampTestVector == timestampDeconstructed);
-    NL_TEST_ASSERT(inSuite, firmwareInfoDeconstructed.empty());
-    NL_TEST_ASSERT(inSuite, 0 == vendorReserved.GetNumberOfElements());
+    EXPECT_TRUE(certificationDeclarationDeconstructed.data_equal(ByteSpan(certificationDeclarationTestVector)));
+    EXPECT_TRUE(attestationNonceDeconstructed.data_equal(ByteSpan(attestationNonceTestVector)));
+    EXPECT_EQ(timestampTestVector, timestampDeconstructed);
+    EXPECT_TRUE(firmwareInfoDeconstructed.empty());
+    EXPECT_EQ(vendorReserved.GetNumberOfElements(), 0u);
     struct VendorReservedElement element;
 
-    NL_TEST_ASSERT(inSuite, vendorReserved.GetNextVendorReservedElement(element) == CHIP_END_OF_TLV);
+    EXPECT_EQ(vendorReserved.GetNextVendorReservedElement(element), CHIP_END_OF_TLV);
 }
 
-static void TestVendorReservedData(nlTestSuite * inSuite, void * inContext)
+TEST_F(TestDeviceAttestationConstruction, TestVendorReservedData)
 {
 
     struct VendorReservedElement inputArray[] = { { 3000, 100, 10 }, { 2999, 99, 10 },  { 10, 20, 100 },
@@ -363,7 +368,7 @@
             vendorReserved.addVendorReservedElement(inputArray[i].vendorId, inputArray[i].profileNum, inputArray[i].tagNum,
                                                     ByteSpan(strings[i], strlen(reinterpret_cast<char *>(strings[i]))));
 
-        NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
+        EXPECT_EQ(err, CHIP_NO_ERROR);
     }
 
     // manually figure out the order these should be read out in when sorted
@@ -372,24 +377,23 @@
     };
 
     const struct VendorReservedElement * element = vendorReserved.cbegin();
-    NL_TEST_ASSERT(inSuite, element);
-    NL_TEST_ASSERT(inSuite, element = vendorReserved.Next());
+    EXPECT_TRUE(element);
+    EXPECT_TRUE(element = vendorReserved.Next());
 
     for (i = 0; element && i < ArraySize(desiredOrder); element = vendorReserved.Next(), i++)
     {
-        NL_TEST_ASSERT(inSuite,
-                       element->vendorId == desiredOrder[i]->vendorId && element->profileNum == desiredOrder[i]->profileNum &&
-                           element->tagNum == desiredOrder[i]->tagNum);
+        EXPECT_TRUE(element->vendorId == desiredOrder[i]->vendorId && element->profileNum == desiredOrder[i]->profileNum &&
+                    element->tagNum == desiredOrder[i]->tagNum);
     }
-    NL_TEST_ASSERT(inSuite, i == ArraySize(desiredOrder)); // check if previous loop matched for every array entry.
+    EXPECT_EQ(i, ArraySize(desiredOrder)); // check if previous loop matched for every array entry.
 
     // add another element, it should fail
     uint8_t testByteSpan[] = { 0x1, 0x2, 0x3 };
     CHIP_ERROR err         = vendorReserved.addVendorReservedElement(5, 10, 20, ByteSpan(testByteSpan));
-    NL_TEST_ASSERT(inSuite, err == CHIP_ERROR_NO_MEMORY);
+    EXPECT_EQ(err, CHIP_ERROR_NO_MEMORY);
 }
 
-static void TestAttestationElements_DeconstructionWithFirmwareInfo(nlTestSuite * inSuite, void * inContext)
+TEST_F(TestDeviceAttestationConstruction, TestAttestationElements_DeconstructionWithFirmwareInfo)
 {
     CHIP_ERROR err = CHIP_NO_ERROR;
 
@@ -456,39 +460,39 @@
     err = DeconstructAttestationElements(ByteSpan(attestationElementsTestVectorWithFirmwareInfo),
                                          certificationDeclarationDeconstructed, attestationNonceDeconstructed,
                                          timestampDeconstructed, firmwareInfoDeconstructed, vendorReserved);
-    NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
+    EXPECT_EQ(err, CHIP_NO_ERROR);
 
-    NL_TEST_ASSERT(inSuite, certificationDeclarationDeconstructed.data_equal(ByteSpan(certificationDeclarationTestVector)));
-    NL_TEST_ASSERT(inSuite, attestationNonceDeconstructed.data_equal(ByteSpan(attestationNonceTestVector)));
-    NL_TEST_ASSERT(inSuite, timestampTestVector == timestampDeconstructed);
-    NL_TEST_ASSERT(inSuite, firmwareInfoDeconstructed.data_equal(ByteSpan(firmwareInfoTestVector)));
-    NL_TEST_ASSERT(inSuite, ArraySize(vendorReservedArrayTestVector) == vendorReserved.GetNumberOfElements());
+    EXPECT_TRUE(certificationDeclarationDeconstructed.data_equal(ByteSpan(certificationDeclarationTestVector)));
+    EXPECT_TRUE(attestationNonceDeconstructed.data_equal(ByteSpan(attestationNonceTestVector)));
+    EXPECT_EQ(timestampTestVector, timestampDeconstructed);
+    EXPECT_TRUE(firmwareInfoDeconstructed.data_equal(ByteSpan(firmwareInfoTestVector)));
+    EXPECT_EQ(ArraySize(vendorReservedArrayTestVector), vendorReserved.GetNumberOfElements());
     struct VendorReservedElement element;
     size_t elementsSeen = 0;
 
     while (vendorReserved.GetNextVendorReservedElement(element) == CHIP_NO_ERROR)
     {
-        NL_TEST_ASSERT(inSuite, vendorIdTestVector == element.vendorId);
-        NL_TEST_ASSERT(inSuite, profileNumTestVector == element.profileNum);
+        EXPECT_EQ(vendorIdTestVector, element.vendorId);
+        EXPECT_EQ(profileNumTestVector, element.profileNum);
         switch (element.tagNum)
         {
         case 1:
-            NL_TEST_ASSERT(inSuite, element.vendorReservedData.data_equal(vendorReservedArrayTestVector[0]));
+            EXPECT_TRUE(element.vendorReservedData.data_equal(vendorReservedArrayTestVector[0]));
             elementsSeen++;
             break;
         case 3:
-            NL_TEST_ASSERT(inSuite, element.vendorReservedData.data_equal(vendorReservedArrayTestVector[1]));
+            EXPECT_TRUE(element.vendorReservedData.data_equal(vendorReservedArrayTestVector[1]));
             elementsSeen++;
             break;
         default:
-            NL_TEST_ASSERT(inSuite, 0);
+            EXPECT_TRUE(0);
             break;
         }
     }
-    NL_TEST_ASSERT(inSuite, elementsSeen == ArraySize(vendorReservedArrayTestVector));
+    EXPECT_EQ(elementsSeen, ArraySize(vendorReservedArrayTestVector));
 }
 
-static void TestAttestationElements_DeconstructionUnordered(nlTestSuite * inSuite, void * inContext)
+TEST_F(TestDeviceAttestationConstruction, TestAttestationElements_DeconstructionUnordered)
 {
     CHIP_ERROR err = CHIP_NO_ERROR;
 
@@ -516,10 +520,10 @@
     err = DeconstructAttestationElements(ByteSpan(attestationElementsUnorderedTestVector), certificationDeclarationDeconstructed,
                                          attestationNonceDeconstructed, timestampDeconstructed, firmwareInfoDeconstructed,
                                          vendorReserved);
-    NL_TEST_ASSERT(inSuite, err == CHIP_ERROR_UNEXPECTED_TLV_ELEMENT);
+    EXPECT_EQ(err, CHIP_ERROR_UNEXPECTED_TLV_ELEMENT);
 }
 
-static void TestAttestationElements_DeconstructionCorruptedTLV(nlTestSuite * inSuite, void * inContext)
+TEST_F(TestDeviceAttestationConstruction, TestAttestationElements_DeconstructionCorruptedTLV)
 {
     CHIP_ERROR err = CHIP_NO_ERROR;
     using chip::FormatCHIPError;
@@ -541,10 +545,10 @@
     DeviceAttestationVendorReservedDeconstructor vendorReserved;
     size_t count = 2;
     err          = vendorReserved.PrepareToReadVendorReservedElements(ByteSpan(attestationElementsCorruptedTLVTestVector), count);
-    NL_TEST_ASSERT(inSuite, err == CHIP_ERROR_TLV_UNDERRUN);
+    EXPECT_EQ(err, CHIP_ERROR_TLV_UNDERRUN);
 }
 
-static void TestNocsrElements_Construction(nlTestSuite * inSuite, void * inContext)
+TEST_F(TestDeviceAttestationConstruction, TestNocsrElements_Construction)
 {
     static constexpr uint8_t kNocsrNonce[] = {
         0x81, 0x4a, 0x4d, 0x4c, 0x1c, 0x4a, 0x8e, 0xbb, 0xea, 0xdb, 0x0a, 0xe2, 0x82, 0xf9, 0x91, 0xeb,
@@ -600,18 +604,18 @@
         TLV::EstimateStructOverhead(sizeof(kExampleCsr), sizeof(kNocsrNonce), sizeof(kVendorReserved1), sizeof(kVendorReserved3));
 
     nocsrElements.Alloc(nocsrElementsLen);
-    NL_TEST_ASSERT(inSuite, nocsrElements.Get() != nullptr);
+    ASSERT_NE(nocsrElements.Get(), nullptr);
 
     MutableByteSpan nocsrElementsSpan(nocsrElements.Get(), nocsrElementsLen);
 
     CHIP_ERROR err = ConstructNOCSRElements(ByteSpan(kExampleCsr), ByteSpan(kNocsrNonce), ByteSpan{ kVendorReserved1 }, ByteSpan{},
                                             ByteSpan{ kVendorReserved3 }, nocsrElementsSpan);
-    NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
-    NL_TEST_ASSERT(inSuite, nocsrElementsSpan.size() <= nocsrElementsLen);
-    NL_TEST_ASSERT(inSuite, nocsrElementsSpan.data_equal(ByteSpan(kNoCsrElementsVector)));
+    EXPECT_EQ(err, CHIP_NO_ERROR);
+    EXPECT_LE(nocsrElementsSpan.size(), nocsrElementsLen);
+    EXPECT_TRUE(nocsrElementsSpan.data_equal(ByteSpan(kNoCsrElementsVector)));
 }
 
-static void TestNocsrElements_Deconstruction(nlTestSuite * inSuite, void * inContext)
+TEST_F(TestDeviceAttestationConstruction, TestNocsrElements_Deconstruction)
 {
     static constexpr uint8_t kNocsrNonce[] = {
         0x81, 0x4a, 0x4d, 0x4c, 0x1c, 0x4a, 0x8e, 0xbb, 0xea, 0xdb, 0x0a, 0xe2, 0x82, 0xf9, 0x91, 0xeb,
@@ -669,66 +673,10 @@
     ByteSpan vendorReserved3Span;
     CHIP_ERROR err = DeconstructNOCSRElements(ByteSpan(kNoCsrElementsVector), csrSpan, csrNonceSpan, vendorReserved1Span,
                                               vendorReserved2Span, vendorReserved3Span);
-    NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
-    NL_TEST_ASSERT(inSuite, csrSpan.data_equal(ByteSpan(kExampleCsr)));
-    NL_TEST_ASSERT(inSuite, csrNonceSpan.data_equal(ByteSpan(kNocsrNonce)));
-    NL_TEST_ASSERT(inSuite, vendorReserved1Span.data_equal(ByteSpan(kVendorReserved1)));
-    NL_TEST_ASSERT(inSuite, vendorReserved2Span.empty());
-    NL_TEST_ASSERT(inSuite, vendorReserved3Span.data_equal(ByteSpan(kVendorReserved3)));
+    EXPECT_EQ(err, CHIP_NO_ERROR);
+    EXPECT_TRUE(csrSpan.data_equal(ByteSpan(kExampleCsr)));
+    EXPECT_TRUE(csrNonceSpan.data_equal(ByteSpan(kNocsrNonce)));
+    EXPECT_TRUE(vendorReserved1Span.data_equal(ByteSpan(kVendorReserved1)));
+    EXPECT_TRUE(vendorReserved2Span.empty());
+    EXPECT_TRUE(vendorReserved3Span.data_equal(ByteSpan(kVendorReserved3)));
 }
-
-/**
- *   Test Suite. It lists all the test functions.
- */
-// clang-format off
-static const nlTest sTests[] = {
-    NL_TEST_DEF("Test Device Attestation Elements Roundtrip", TestAttestationElements_Roundtrip),
-    NL_TEST_DEF("Test Device Attestation Elements Construction", TestAttestationElements_Construction),
-    NL_TEST_DEF("Test Device Attestation Elements Deconstruction", TestAttestationElements_Deconstruction),
-    NL_TEST_DEF("Test Vendor Reserved Data Ordering", TestVendorReservedData),
-    NL_TEST_DEF("Test Device Attestation Elements Deconstruction with Firmware Information", TestAttestationElements_DeconstructionWithFirmwareInfo),
-    NL_TEST_DEF("Test Device Attestation Elements Deconstruction - Corrupted/Out of Order TLV", TestAttestationElements_DeconstructionUnordered),
-    NL_TEST_DEF("Test Device Attestation Elements Deconstruction - Corrupted TLV -- vendor reserved elements", TestAttestationElements_DeconstructionCorruptedTLV),
-    NL_TEST_DEF("Test Device Attestation Elements Deconstruction - No vendor reserved", TestAttestationElements_DeconstructionNoVendorReserved),
-    NL_TEST_DEF("Test Device NOCSR Elements Construction", TestNocsrElements_Construction),
-    NL_TEST_DEF("Test Device NOCSR Elements Deconstruction", TestNocsrElements_Deconstruction),
-    NL_TEST_SENTINEL()
-};
-// clang-format on
-
-/**
- *  Set up the test suite.
- */
-int TestDeviceAttestationElementsConstruction_Setup(void * inContext)
-{
-    CHIP_ERROR error = chip::Platform::MemoryInit();
-    if (error != CHIP_NO_ERROR)
-        return FAILURE;
-    return SUCCESS;
-}
-
-/**
- *  Tear down the test suite.
- */
-int TestDeviceAttestationElementsConstruction_Teardown(void * inContext)
-{
-    chip::Platform::MemoryShutdown();
-    return SUCCESS;
-}
-
-int TestDeviceAttestationElementsConstruction()
-{
-    // clang-format off
-    nlTestSuite theSuite =
-    {
-        "Device Attestation Elements Construction",
-        &sTests[0],
-        TestDeviceAttestationElementsConstruction_Setup,
-        TestDeviceAttestationElementsConstruction_Teardown
-    };
-    // clang-format on
-    nlTestRunner(&theSuite, nullptr);
-    return (nlTestRunnerStats(&theSuite));
-}
-
-CHIP_REGISTER_TEST_SUITE(TestDeviceAttestationElementsConstruction);
diff --git a/src/credentials/tests/TestDeviceAttestationCredentials.cpp b/src/credentials/tests/TestDeviceAttestationCredentials.cpp
index 4707caa..bf203c8 100644
--- a/src/credentials/tests/TestDeviceAttestationCredentials.cpp
+++ b/src/credentials/tests/TestDeviceAttestationCredentials.cpp
@@ -30,9 +30,8 @@
 #include <lib/core/CHIPError.h>
 #include <lib/support/CHIPMem.h>
 #include <lib/support/Span.h>
-#include <lib/support/UnitTestRegistration.h>
 
-#include <nlunit-test.h>
+#include <gtest/gtest.h>
 
 #include "CHIPAttCert_test_vectors.h"
 
@@ -48,49 +47,55 @@
 
 } // namespace
 
-static void TestDACProvidersExample_Providers(nlTestSuite * inSuite, void * inContext)
+struct TestDeviceAttestationCredentials : public ::testing::Test
+{
+    static void SetUpTestSuite() { ASSERT_EQ(chip::Platform::MemoryInit(), CHIP_NO_ERROR); }
+    static void TearDownTestSuite() { chip::Platform::MemoryShutdown(); }
+};
+
+TEST_F(TestDeviceAttestationCredentials, TestDACProvidersExample_Providers)
 {
     uint8_t der_cert_buf[kMaxDERCertLength];
     MutableByteSpan der_cert_span(der_cert_buf);
 
     // Make sure default provider exists and is not implemented on at least one method
     DeviceAttestationCredentialsProvider * default_provider = GetDeviceAttestationCredentialsProvider();
-    NL_TEST_ASSERT(inSuite, default_provider != nullptr);
+    ASSERT_NE(default_provider, nullptr);
 
     CHIP_ERROR err = default_provider->GetDeviceAttestationCert(der_cert_span);
-    NL_TEST_ASSERT(inSuite, err == CHIP_ERROR_NOT_IMPLEMENTED);
+    EXPECT_EQ(err, CHIP_ERROR_NOT_IMPLEMENTED);
 
     // Replace default provider with example provider
     DeviceAttestationCredentialsProvider * example_dac_provider = Examples::GetExampleDACProvider();
-    NL_TEST_ASSERT(inSuite, example_dac_provider != nullptr);
-    NL_TEST_ASSERT(inSuite, default_provider != example_dac_provider);
+    ASSERT_NE(example_dac_provider, nullptr);
+    EXPECT_NE(default_provider, example_dac_provider);
 
     SetDeviceAttestationCredentialsProvider(example_dac_provider);
     default_provider = GetDeviceAttestationCredentialsProvider();
-    NL_TEST_ASSERT(inSuite, default_provider == example_dac_provider);
+    EXPECT_EQ(default_provider, example_dac_provider);
 
     // Make sure DAC is what we expect, by validating public key
     memset(der_cert_span.data(), 0, der_cert_span.size());
     err = example_dac_provider->GetDeviceAttestationCert(der_cert_span);
-    NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
+    EXPECT_EQ(err, CHIP_NO_ERROR);
 
     P256PublicKey dac_public_key;
     err = ExtractPubkeyFromX509Cert(der_cert_span, dac_public_key);
-    NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
-    NL_TEST_ASSERT(inSuite, dac_public_key.Length() == kExpectedDacPublicKey.size());
-    NL_TEST_ASSERT(inSuite, 0 == memcmp(dac_public_key.ConstBytes(), kExpectedDacPublicKey.data(), kExpectedDacPublicKey.size()));
+    EXPECT_EQ(err, CHIP_NO_ERROR);
+    EXPECT_EQ(dac_public_key.Length(), kExpectedDacPublicKey.size());
+    EXPECT_EQ(0, memcmp(dac_public_key.ConstBytes(), kExpectedDacPublicKey.data(), kExpectedDacPublicKey.size()));
 
     // Make sure PAI is what we expect, by validating public key
     der_cert_span = MutableByteSpan{ der_cert_span };
     memset(der_cert_span.data(), 0, der_cert_span.size());
     err = example_dac_provider->GetProductAttestationIntermediateCert(der_cert_span);
-    NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
+    EXPECT_EQ(err, CHIP_NO_ERROR);
 
     P256PublicKey pai_public_key;
     err = ExtractPubkeyFromX509Cert(der_cert_span, pai_public_key);
-    NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
-    NL_TEST_ASSERT(inSuite, pai_public_key.Length() == kExpectedPaiPublicKey.size());
-    NL_TEST_ASSERT(inSuite, 0 == memcmp(pai_public_key.ConstBytes(), kExpectedPaiPublicKey.data(), kExpectedPaiPublicKey.size()));
+    EXPECT_EQ(err, CHIP_NO_ERROR);
+    EXPECT_EQ(pai_public_key.Length(), kExpectedPaiPublicKey.size());
+    EXPECT_EQ(0, memcmp(pai_public_key.ConstBytes(), kExpectedPaiPublicKey.data(), kExpectedPaiPublicKey.size()));
 
     // Check for CD presence
     uint8_t other_data_buf[kMaxCMSSignedCDMessage];
@@ -98,35 +103,35 @@
     memset(other_data_span.data(), 0, other_data_span.size());
 
     err = example_dac_provider->GetCertificationDeclaration(other_data_span);
-    NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
-    NL_TEST_ASSERT(inSuite, other_data_span.size() > 0);
-    NL_TEST_ASSERT(inSuite, other_data_span.data()[0] != 0);
+    EXPECT_EQ(err, CHIP_NO_ERROR);
+    EXPECT_GT(other_data_span.size(), 0u);
+    EXPECT_NE(other_data_span.data()[0], 0);
 
     // Check for firmware information presence
     other_data_span = MutableByteSpan{ other_data_buf };
     memset(other_data_span.data(), 0, other_data_span.size());
 
     err = example_dac_provider->GetFirmwareInformation(other_data_span);
-    NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
-    NL_TEST_ASSERT(inSuite, other_data_span.size() == 0);
+    EXPECT_EQ(err, CHIP_NO_ERROR);
+    EXPECT_EQ(other_data_span.size(), 0u);
 }
 
-static void TestDACProvidersExample_Signature(nlTestSuite * inSuite, void * inContext)
+TEST_F(TestDeviceAttestationCredentials, TestDACProvidersExample_Signature)
 {
     constexpr uint8_t kExampleMessage[] = { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x10, 0x11, 0x12,
                                             0x13, 0x14, 0x15, 0x16, 0x17, 0x20, 0x21, 0x22, 0x23, 0x24, 0x25,
                                             0x26, 0x27, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37 };
 
     DeviceAttestationCredentialsProvider * example_dac_provider = Examples::GetExampleDACProvider();
-    NL_TEST_ASSERT(inSuite, example_dac_provider != nullptr);
+    ASSERT_NE(example_dac_provider, nullptr);
 
     // Sign using the example attestation private key
     P256ECDSASignature da_signature;
     MutableByteSpan out_sig_span(da_signature.Bytes(), da_signature.Capacity());
     CHIP_ERROR err = example_dac_provider->SignWithDeviceAttestationKey(ByteSpan{ kExampleMessage }, out_sig_span);
-    NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
+    EXPECT_EQ(err, CHIP_NO_ERROR);
 
-    NL_TEST_ASSERT(inSuite, out_sig_span.size() == kP256_ECDSA_Signature_Length_Raw);
+    EXPECT_EQ(out_sig_span.size(), kP256_ECDSA_Signature_Length_Raw);
     da_signature.SetLength(out_sig_span.size());
 
     // Get DAC from the provider
@@ -135,18 +140,18 @@
 
     memset(dac_cert_span.data(), 0, dac_cert_span.size());
     err = example_dac_provider->GetDeviceAttestationCert(dac_cert_span);
-    NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
+    EXPECT_EQ(err, CHIP_NO_ERROR);
 
     // Extract public key from DAC, prior to signature verification
     P256PublicKey dac_public_key;
     err = ExtractPubkeyFromX509Cert(dac_cert_span, dac_public_key);
-    NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
-    NL_TEST_ASSERT(inSuite, dac_public_key.Length() == kExpectedDacPublicKey.size());
-    NL_TEST_ASSERT(inSuite, 0 == memcmp(dac_public_key.ConstBytes(), kExpectedDacPublicKey.data(), kExpectedDacPublicKey.size()));
+    EXPECT_EQ(err, CHIP_NO_ERROR);
+    EXPECT_EQ(dac_public_key.Length(), kExpectedDacPublicKey.size());
+    EXPECT_EQ(memcmp(dac_public_key.ConstBytes(), kExpectedDacPublicKey.data(), kExpectedDacPublicKey.size()), 0);
 
     // Verify round trip signature
     err = dac_public_key.ECDSA_validate_msg_signature(&kExampleMessage[0], sizeof(kExampleMessage), da_signature);
-    NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
+    EXPECT_EQ(err, CHIP_NO_ERROR);
 }
 
 static void OnAttestationInformationVerificationCallback(void * context, const DeviceAttestationVerifier::AttestationInfo & info,
@@ -156,7 +161,7 @@
     *pResult                                = result;
 }
 
-static void TestDACVerifierExample_AttestationInfoVerification(nlTestSuite * inSuite, void * inContext)
+TEST_F(TestDeviceAttestationCredentials, TestDACVerifierExample_AttestationInfoVerification)
 {
     uint8_t attestationElementsTestVector[] = {
         0x15, 0x30, 0x01, 0xeb, 0x30, 0x81, 0xe8, 0x06, 0x09, 0x2a, 0x86, 0x48, 0x86, 0xf7, 0x0d, 0x01, 0x07, 0x02, 0xa0, 0x81,
@@ -191,20 +196,20 @@
 
     // Make sure default verifier exists and is not implemented on at least one method
     DeviceAttestationVerifier * default_verifier = GetDeviceAttestationVerifier();
-    NL_TEST_ASSERT(inSuite, default_verifier != nullptr);
+    ASSERT_NE(default_verifier, nullptr);
 
     AttestationVerificationResult attestationResult = AttestationVerificationResult::kSuccess;
     ByteSpan emptyByteSpan;
     attestationResult = default_verifier->ValidateCertificationDeclarationSignature(ByteSpan(), emptyByteSpan);
-    NL_TEST_ASSERT(inSuite, attestationResult == AttestationVerificationResult::kNotImplemented);
+    EXPECT_EQ(attestationResult, AttestationVerificationResult::kNotImplemented);
 
     DeviceAttestationVerifier * example_dac_verifier = GetDefaultDACVerifier(GetTestAttestationTrustStore());
-    NL_TEST_ASSERT(inSuite, example_dac_verifier != nullptr);
-    NL_TEST_ASSERT(inSuite, default_verifier != example_dac_verifier);
+    ASSERT_NE(example_dac_verifier, nullptr);
+    EXPECT_NE(default_verifier, example_dac_verifier);
 
     SetDeviceAttestationVerifier(example_dac_verifier);
     default_verifier = GetDeviceAttestationVerifier();
-    NL_TEST_ASSERT(inSuite, default_verifier == example_dac_verifier);
+    EXPECT_EQ(default_verifier, example_dac_verifier);
 
     attestationResult = AttestationVerificationResult::kNotImplemented;
     Callback::Callback<DeviceAttestationVerifier::OnAttestationInformationVerification> attestationInformationVerificationCallback(
@@ -216,10 +221,10 @@
         static_cast<VendorId>(0xFFF1), 0x8000);
     default_verifier->VerifyAttestationInformation(info, &attestationInformationVerificationCallback);
 
-    NL_TEST_ASSERT(inSuite, attestationResult == AttestationVerificationResult::kSuccess);
+    EXPECT_EQ(attestationResult, AttestationVerificationResult::kSuccess);
 }
 
-static void TestDACVerifierExample_CertDeclarationVerification(nlTestSuite * inSuite, void * inContext)
+TEST_F(TestDeviceAttestationCredentials, TestDACVerifierExample_CertDeclarationVerification)
 {
     // -> format_version = 1
     // -> vendor_id = 0xFFF1
@@ -258,11 +263,11 @@
 
     // Replace default verifier with example verifier
     DeviceAttestationVerifier * example_dac_verifier = GetDefaultDACVerifier(GetTestAttestationTrustStore());
-    NL_TEST_ASSERT(inSuite, example_dac_verifier != nullptr);
+    ASSERT_NE(example_dac_verifier, nullptr);
 
     SetDeviceAttestationVerifier(example_dac_verifier);
     DeviceAttestationVerifier * default_verifier = GetDeviceAttestationVerifier();
-    NL_TEST_ASSERT(inSuite, default_verifier == example_dac_verifier);
+    EXPECT_EQ(default_verifier, example_dac_verifier);
 
     // Check for CD presence
     uint8_t cd_data_buf[kMaxCMSSignedCDMessage] = { 0 };
@@ -271,9 +276,9 @@
     ByteSpan cd_payload;
     AttestationVerificationResult attestation_result =
         default_verifier->ValidateCertificationDeclarationSignature(ByteSpan(sTest_CD), cd_payload);
-    NL_TEST_ASSERT(inSuite, attestation_result == AttestationVerificationResult::kSuccess);
+    EXPECT_EQ(attestation_result, AttestationVerificationResult::kSuccess);
 
-    NL_TEST_ASSERT(inSuite, cd_payload.data_equal(ByteSpan(sTestCMS_CDContent)));
+    EXPECT_TRUE(cd_payload.data_equal(ByteSpan(sTestCMS_CDContent)));
 
     DeviceInfoForAttestation deviceInfo{
         .vendorId     = sTestCMS_CertElements.VendorId,
@@ -285,10 +290,10 @@
         .paaVendorId  = sTestCMS_CertElements.VendorId,
     };
     attestation_result = default_verifier->ValidateCertificateDeclarationPayload(cd_payload, ByteSpan(), deviceInfo);
-    NL_TEST_ASSERT(inSuite, attestation_result == AttestationVerificationResult::kSuccess);
+    EXPECT_EQ(attestation_result, AttestationVerificationResult::kSuccess);
 }
 
-static void TestDACVerifierExample_NocsrInformationVerification(nlTestSuite * inSuite, void * inContext)
+TEST_F(TestDeviceAttestationCredentials, TestDACVerifierExample_NocsrInformationVerification)
 {
     CHIP_ERROR err = CHIP_NO_ERROR;
 
@@ -335,25 +340,25 @@
                                                  0x8d, 0x85, 0xfb, 0xd7, 0xa0, 0x7c, 0x8e, 0x83, 0x7d, 0xa4, 0xd5, 0xa8, 0xb9 };
 
     DeviceAttestationVerifier * exampleDacVerifier = GetDefaultDACVerifier(GetTestAttestationTrustStore());
-    NL_TEST_ASSERT(inSuite, exampleDacVerifier != nullptr);
+    ASSERT_NE(exampleDacVerifier, nullptr);
 
     P256PublicKey dacPubkey;
-    NL_TEST_ASSERT(inSuite, sizeof(attestationPublicKey) == dacPubkey.Length());
+    EXPECT_EQ(sizeof(attestationPublicKey), dacPubkey.Length());
     memcpy(dacPubkey.Bytes(), attestationPublicKey, dacPubkey.Length());
 
     err = exampleDacVerifier->VerifyNodeOperationalCSRInformation(
         ByteSpan(nocsrElementsTestVector), ByteSpan(attestationChallengeTestVector), ByteSpan(attestationSignatureTestVector),
         dacPubkey, ByteSpan(csrNonceTestVector));
-    NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
+    EXPECT_EQ(err, CHIP_NO_ERROR);
 
     // now test with invalid signature
     err = exampleDacVerifier->VerifyNodeOperationalCSRInformation(
         ByteSpan(nocsrElementsTestVector), ByteSpan(attestationChallengeTestVector), ByteSpan(wrongAttestationSignatureTestVector),
         dacPubkey, ByteSpan(csrNonceTestVector));
-    NL_TEST_ASSERT(inSuite, err == CHIP_ERROR_INVALID_SIGNATURE);
+    EXPECT_EQ(err, CHIP_ERROR_INVALID_SIGNATURE);
 }
 
-static void TestAttestationTrustStore(nlTestSuite * inSuite, void * inContext)
+TEST_F(TestDeviceAttestationCredentials, TestAttestationTrustStore)
 {
     // SKID to trigger CHIP_ERROR_INVALID_ARGUMENT
     ByteSpan kPaaFFF1BadSkidSpan1{ TestCerts::sTestCert_PAA_FFF1_Cert.data(), TestCerts::sTestCert_PAA_FFF1_Cert.size() - 1 };
@@ -383,7 +388,7 @@
     };
 
     const AttestationTrustStore * testAttestationTrustStore = GetTestAttestationTrustStore();
-    NL_TEST_ASSERT(inSuite, testAttestationTrustStore != nullptr);
+    ASSERT_NE(testAttestationTrustStore, nullptr);
 
     for (const auto & testCase : kTestCases)
     {
@@ -397,68 +402,12 @@
 
         // Try to obtain cert
         CHIP_ERROR result = testAttestationTrustStore->GetProductAttestationAuthorityCert(testCase.skidSpan, paaCertSpan);
-        NL_TEST_ASSERT(inSuite, result == testCase.expectedResult);
+        EXPECT_EQ(result, testCase.expectedResult);
 
         // In success cases, make sure the cert matches expectation.
         if (testCase.expectedResult == CHIP_NO_ERROR)
         {
-            NL_TEST_ASSERT(inSuite, paaCertSpan.data_equal(testCase.expectedCertSpan) == true);
+            EXPECT_TRUE(paaCertSpan.data_equal(testCase.expectedCertSpan));
         }
     }
 }
-
-/**
- *  Set up the test suite.
- */
-int TestDeviceAttestation_Setup(void * inContext)
-{
-    CHIP_ERROR error = chip::Platform::MemoryInit();
-
-    if (error != CHIP_NO_ERROR)
-    {
-        return FAILURE;
-    }
-
-    return SUCCESS;
-}
-
-/**
- *  Tear down the test suite.
- */
-int TestDeviceAttestation_Teardown(void * inContext)
-{
-    chip::Platform::MemoryShutdown();
-    return SUCCESS;
-}
-
-/**
- *   Test Suite. It lists all the test functions.
- */
-// clang-format off
-static const nlTest sTests[] = {
-    NL_TEST_DEF("Test Example Device Attestation Credentials Providers", TestDACProvidersExample_Providers),
-    NL_TEST_DEF("Test Example Device Attestation Signature", TestDACProvidersExample_Signature),
-    NL_TEST_DEF("Test the 'for testing' Paa Root Store", TestAttestationTrustStore),
-    NL_TEST_DEF("Test Example Device Attestation Information Verification", TestDACVerifierExample_AttestationInfoVerification),
-    NL_TEST_DEF("Test Example Device Attestation Certification Declaration Verification", TestDACVerifierExample_CertDeclarationVerification),
-    NL_TEST_DEF("Test Example Device Attestation Node Operational CSR Information Verification", TestDACVerifierExample_NocsrInformationVerification),
-    NL_TEST_SENTINEL()
-};
-// clang-format on
-
-int TestDeviceAttestation()
-{
-    // clang-format off
-    nlTestSuite theSuite =
-    {
-        "Device Attestation Credentials",
-        &sTests[0],
-        TestDeviceAttestation_Setup,
-        TestDeviceAttestation_Teardown
-    };
-    // clang-format on
-    nlTestRunner(&theSuite, nullptr);
-    return (nlTestRunnerStats(&theSuite));
-}
-
-CHIP_REGISTER_TEST_SUITE(TestDeviceAttestation);
diff --git a/src/credentials/tests/TestFabricTable.cpp b/src/credentials/tests/TestFabricTable.cpp
index 8dd6519..a6b9f2e 100644
--- a/src/credentials/tests/TestFabricTable.cpp
+++ b/src/credentials/tests/TestFabricTable.cpp
@@ -22,7 +22,7 @@
  */
 
 #include <errno.h>
-#include <nlunit-test.h>
+#include <gtest/gtest.h>
 
 #include <lib/core/CHIPCore.h>
 
@@ -36,8 +36,7 @@
 #include <lib/asn1/ASN1.h>
 #include <lib/support/CodeUtils.h>
 #include <lib/support/TestPersistentStorageDelegate.h>
-#include <lib/support/UnitTestExtendedAssertions.h>
-#include <lib/support/UnitTestRegistration.h>
+
 #include <platform/ConfigurationManager.h>
 
 #include <lib/support/BytesToHex.h>
@@ -83,7 +82,7 @@
 /**
  * Load a single test fabric with with the Root01:ICA01:Node01_01 identity.
  */
-static CHIP_ERROR LoadTestFabric_Node01_01(nlTestSuite * inSuite, FabricTable & fabricTable, bool doCommit)
+static CHIP_ERROR LoadTestFabric_Node01_01(FabricTable & fabricTable, bool doCommit)
 {
     Crypto::P256SerializedKeypair opKeysSerialized;
     static Crypto::P256Keypair opKey_Node01_01;
@@ -114,7 +113,7 @@
     return CHIP_NO_ERROR;
 }
 
-static CHIP_ERROR LoadTestFabric_Node01_02(nlTestSuite * inSuite, FabricTable & fabricTable, bool doCommit)
+static CHIP_ERROR LoadTestFabric_Node01_02(FabricTable & fabricTable, bool doCommit)
 {
     Crypto::P256SerializedKeypair opKeysSerialized;
     FabricIndex fabricIndex;
@@ -147,7 +146,7 @@
 /**
  * Load a single test fabric with with the Root02:ICA02:Node02_01 identity.
  */
-static CHIP_ERROR LoadTestFabric_Node02_01(nlTestSuite * inSuite, FabricTable & fabricTable, bool doCommit,
+static CHIP_ERROR LoadTestFabric_Node02_01(FabricTable & fabricTable, bool doCommit,
                                            FabricTable::AdvertiseIdentity advertiseIdentity = FabricTable::AdvertiseIdentity::Yes)
 {
     Crypto::P256SerializedKeypair opKeysSerialized;
@@ -163,55 +162,67 @@
     ByteSpan icacSpan(TestCerts::sTestCert_ICA02_Chip);
     ByteSpan nocSpan(TestCerts::sTestCert_Node02_01_Chip);
 
-    NL_TEST_ASSERT(inSuite,
-                   opKeysSerialized.SetLength(TestCerts::sTestCert_Node02_01_PublicKey.size() +
-                                              TestCerts::sTestCert_Node02_01_PrivateKey.size()) == CHIP_NO_ERROR);
-    NL_TEST_ASSERT(inSuite, opKey_Node02_01.Deserialize(opKeysSerialized) == CHIP_NO_ERROR);
+    EXPECT_EQ(opKeysSerialized.SetLength(TestCerts::sTestCert_Node02_01_PublicKey.size() +
+                                         TestCerts::sTestCert_Node02_01_PrivateKey.size()),
+              CHIP_NO_ERROR);
+    EXPECT_EQ(opKey_Node02_01.Deserialize(opKeysSerialized), CHIP_NO_ERROR);
 
-    NL_TEST_ASSERT(inSuite, fabricTable.AddNewPendingTrustedRootCert(rcacSpan) == CHIP_NO_ERROR);
+    EXPECT_EQ(fabricTable.AddNewPendingTrustedRootCert(rcacSpan), CHIP_NO_ERROR);
 
     CHIP_ERROR err =
         fabricTable.AddNewPendingFabricWithProvidedOpKey(nocSpan, icacSpan, VendorId::TestVendor1, &opKey_Node02_01,
                                                          /*isExistingOpKeyExternallyOwned =*/true, &fabricIndex, advertiseIdentity);
-    NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
+    EXPECT_EQ(err, CHIP_NO_ERROR);
 
     if (doCommit)
     {
         err = fabricTable.CommitPendingFabricData();
-        NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
+        EXPECT_EQ(err, CHIP_NO_ERROR);
     }
 
     return err;
 }
-void TestLastKnownGoodTimeInit(nlTestSuite * inSuite, void * inContext)
+
+struct TestFabricTable : public ::testing::Test
+{
+
+    static void SetUpTestSuite()
+    {
+        DeviceLayer::SetConfigurationMgr(&DeviceLayer::ConfigurationManagerImpl::GetDefaultInstance());
+        ASSERT_EQ(chip::Platform::MemoryInit(), CHIP_NO_ERROR);
+    }
+    static void TearDownTestSuite() { chip::Platform::MemoryShutdown(); }
+};
+
+TEST_F(TestFabricTable, TestLastKnownGoodTimeInit)
 {
     // Fabric table init should init Last Known Good Time to the firmware build time.
     chip::TestPersistentStorageDelegate testStorage;
     ScopedFabricTable fabricTableHolder;
 
-    NL_TEST_ASSERT(inSuite, fabricTableHolder.Init(&testStorage) == CHIP_NO_ERROR);
+    EXPECT_EQ(fabricTableHolder.Init(&testStorage), CHIP_NO_ERROR);
     System::Clock::Seconds32 lastKnownGoodChipEpochTime;
 
     FabricTable & fabricTable = fabricTableHolder.GetFabricTable();
-    NL_TEST_ASSERT(inSuite, fabricTable.GetLastKnownGoodChipEpochTime(lastKnownGoodChipEpochTime) == CHIP_NO_ERROR);
+    EXPECT_EQ(fabricTable.GetLastKnownGoodChipEpochTime(lastKnownGoodChipEpochTime), CHIP_NO_ERROR);
     System::Clock::Seconds32 firmwareBuildTime;
-    NL_TEST_ASSERT(inSuite, DeviceLayer::ConfigurationMgr().GetFirmwareBuildChipEpochTime(firmwareBuildTime) == CHIP_NO_ERROR);
-    NL_TEST_ASSERT(inSuite, lastKnownGoodChipEpochTime == firmwareBuildTime);
+    EXPECT_EQ(DeviceLayer::ConfigurationMgr().GetFirmwareBuildChipEpochTime(firmwareBuildTime), CHIP_NO_ERROR);
+    EXPECT_EQ(lastKnownGoodChipEpochTime, firmwareBuildTime);
 }
 
-void TestCollidingFabrics(nlTestSuite * inSuite, void * inContext)
+TEST_F(TestFabricTable, TestCollidingFabrics)
 {
     chip::TestPersistentStorageDelegate testStorage;
     ScopedFabricTable fabricTableHolder;
-    NL_TEST_ASSERT(inSuite, fabricTableHolder.Init(&testStorage) == CHIP_NO_ERROR);
+    EXPECT_EQ(fabricTableHolder.Init(&testStorage), CHIP_NO_ERROR);
     FabricTable & fabricTable = fabricTableHolder.GetFabricTable();
 
     //
     // Start by loading NOCs for two nodes on the same fabric. The second one should fail since the FabricTable by default
     // doesn't permit colliding fabrics.
     //
-    NL_TEST_ASSERT(inSuite, LoadTestFabric_Node01_01(inSuite, fabricTable, /* doCommit = */ true) == CHIP_NO_ERROR);
-    NL_TEST_ASSERT(inSuite, LoadTestFabric_Node01_02(inSuite, fabricTable, /* doCommit = */ true) != CHIP_NO_ERROR);
+    EXPECT_EQ(LoadTestFabric_Node01_01(fabricTable, /* doCommit = */ true), CHIP_NO_ERROR);
+    EXPECT_NE(LoadTestFabric_Node01_02(fabricTable, /* doCommit = */ true), CHIP_NO_ERROR);
 
     //
     // Revert the partially added NOC from the last call, permit colliding fabrics in the FabricTable and try again.
@@ -219,12 +230,12 @@
     //
     fabricTable.RevertPendingFabricData();
     fabricTable.PermitCollidingFabrics();
-    NL_TEST_ASSERT(inSuite, LoadTestFabric_Node01_02(inSuite, fabricTable, /* doCommit = */ true) == CHIP_NO_ERROR);
+    EXPECT_EQ(LoadTestFabric_Node01_02(fabricTable, /* doCommit = */ true), CHIP_NO_ERROR);
 
     ByteSpan rcacSpan(TestCerts::sTestCert_Root01_Chip);
     Credentials::P256PublicKeySpan rootPublicKeySpan;
 
-    NL_TEST_ASSERT(inSuite, Credentials::ExtractPublicKeyFromChipCert(rcacSpan, rootPublicKeySpan) == CHIP_NO_ERROR);
+    EXPECT_EQ(Credentials::ExtractPublicKeyFromChipCert(rcacSpan, rootPublicKeySpan), CHIP_NO_ERROR);
 
     //
     // Ensure we can find both node identities in the FabricTable.
@@ -235,8 +246,8 @@
         NodeId nodeId;
         FabricId fabricId;
 
-        NL_TEST_ASSERT(inSuite, ExtractNodeIdFabricIdFromOpCert(origNocSpan, &nodeId, &fabricId) == CHIP_NO_ERROR);
-        NL_TEST_ASSERT(inSuite, fabricTable.FindIdentity(rootPublicKeySpan, fabricId, nodeId) != nullptr);
+        EXPECT_EQ(ExtractNodeIdFabricIdFromOpCert(origNocSpan, &nodeId, &fabricId), CHIP_NO_ERROR);
+        EXPECT_NE(fabricTable.FindIdentity(rootPublicKeySpan, fabricId, nodeId), nullptr);
     }
 
     {
@@ -245,12 +256,12 @@
         NodeId nodeId;
         FabricId fabricId;
 
-        NL_TEST_ASSERT(inSuite, ExtractNodeIdFabricIdFromOpCert(origNocSpan, &nodeId, &fabricId) == CHIP_NO_ERROR);
-        NL_TEST_ASSERT(inSuite, fabricTable.FindIdentity(rootPublicKeySpan, fabricId, nodeId) != nullptr);
+        EXPECT_EQ(ExtractNodeIdFabricIdFromOpCert(origNocSpan, &nodeId, &fabricId), CHIP_NO_ERROR);
+        EXPECT_NE(fabricTable.FindIdentity(rootPublicKeySpan, fabricId, nodeId), nullptr);
     }
 }
 
-void TestUpdateLastKnownGoodTime(nlTestSuite * inSuite, void * inContext)
+TEST_F(TestFabricTable, TestUpdateLastKnownGoodTime)
 {
     // Adding a fabric should advance Last Known Good Time if any certificate's
     // NotBefore time is later than the build time, and else should leave it
@@ -259,7 +270,7 @@
     // Test certs all have this NotBefore: Oct 15 14:23:43 2020 GMT
     const ASN1::ASN1UniversalTime asn1Expected = { 2020, 10, 15, 14, 23, 43 };
     uint32_t testCertNotBeforeSeconds;
-    NL_TEST_ASSERT(inSuite, Credentials::ASN1ToChipEpochTime(asn1Expected, testCertNotBeforeSeconds) == CHIP_NO_ERROR);
+    EXPECT_EQ(Credentials::ASN1ToChipEpochTime(asn1Expected, testCertNotBeforeSeconds), CHIP_NO_ERROR);
     System::Clock::Seconds32 testCertNotBeforeTime = System::Clock::Seconds32(testCertNotBeforeSeconds);
 
     // Test that certificate NotBefore times that are before the Firmware build time
@@ -270,22 +281,22 @@
     for (auto buildTime : afterNotBeforeBuildTimes)
     {
         // Set build time to the desired value.
-        NL_TEST_ASSERT(inSuite, DeviceLayer::ConfigurationMgr().SetFirmwareBuildChipEpochTime(buildTime) == CHIP_NO_ERROR);
+        EXPECT_EQ(DeviceLayer::ConfigurationMgr().SetFirmwareBuildChipEpochTime(buildTime), CHIP_NO_ERROR);
         chip::TestPersistentStorageDelegate testStorage;
 
         {
             // Initialize a fabric table.
             ScopedFabricTable fabricTableHolder;
-            NL_TEST_ASSERT(inSuite, fabricTableHolder.Init(&testStorage) == CHIP_NO_ERROR);
+            EXPECT_EQ(fabricTableHolder.Init(&testStorage), CHIP_NO_ERROR);
             FabricTable & fabricTable = fabricTableHolder.GetFabricTable();
 
             // Read back Last Known Good Time, which will have been initialized to firmware build time.
             System::Clock::Seconds32 lastKnownGoodTime;
-            NL_TEST_ASSERT(inSuite, fabricTable.GetLastKnownGoodChipEpochTime(lastKnownGoodTime) == CHIP_NO_ERROR);
-            NL_TEST_ASSERT(inSuite, lastKnownGoodTime == buildTime);
+            EXPECT_EQ(fabricTable.GetLastKnownGoodChipEpochTime(lastKnownGoodTime), CHIP_NO_ERROR);
+            EXPECT_EQ(lastKnownGoodTime, buildTime);
 
             // Load a test fabric, but do not commit.
-            NL_TEST_ASSERT(inSuite, LoadTestFabric_Node01_01(inSuite, fabricTable, /* doCommit = */ false) == CHIP_NO_ERROR);
+            EXPECT_EQ(LoadTestFabric_Node01_01(fabricTable, /* doCommit = */ false), CHIP_NO_ERROR);
 
             // Read Last Known Good Time and verify that it hasn't moved forward.
             // This test case was written after the test certs' NotBefore time and we
@@ -293,17 +304,17 @@
             // Therefore, we expect that build time is after NotBefore and so Last
             // Known Good Time will be set to the later of these, build time, even
             // after installing the new fabric.
-            NL_TEST_ASSERT(inSuite, fabricTable.GetLastKnownGoodChipEpochTime(lastKnownGoodTime) == CHIP_NO_ERROR);
-            NL_TEST_ASSERT(inSuite, lastKnownGoodTime == buildTime);
+            EXPECT_EQ(fabricTable.GetLastKnownGoodChipEpochTime(lastKnownGoodTime), CHIP_NO_ERROR);
+            EXPECT_EQ(lastKnownGoodTime, buildTime);
 
             // Verify that calling the fail-safe roll back interface does not change
             // last known good time, as it hadn't been updated in the first place.
             fabricTable.RevertPendingFabricData();
-            NL_TEST_ASSERT(inSuite, fabricTable.GetLastKnownGoodChipEpochTime(lastKnownGoodTime) == CHIP_NO_ERROR);
-            NL_TEST_ASSERT(inSuite, lastKnownGoodTime == buildTime);
+            EXPECT_EQ(fabricTable.GetLastKnownGoodChipEpochTime(lastKnownGoodTime), CHIP_NO_ERROR);
+            EXPECT_EQ(lastKnownGoodTime, buildTime);
 
             // Now reload the test fabric and commit this time.
-            NL_TEST_ASSERT(inSuite, LoadTestFabric_Node01_01(inSuite, fabricTable, /* doCommit = */ true) == CHIP_NO_ERROR);
+            EXPECT_EQ(LoadTestFabric_Node01_01(fabricTable, /* doCommit = */ true), CHIP_NO_ERROR);
 
             // Read Last Known Good Time and verify that it hasn't moved forward.
             // This test case was written after the test certs' NotBefore time and we
@@ -311,25 +322,25 @@
             // Therefore, we expect that build time is after NotBefore and so Last
             // Known Good Time will be set to the later of these, build time, even
             // after installing the new fabric.
-            NL_TEST_ASSERT(inSuite, fabricTable.GetLastKnownGoodChipEpochTime(lastKnownGoodTime) == CHIP_NO_ERROR);
-            NL_TEST_ASSERT(inSuite, lastKnownGoodTime == buildTime);
+            EXPECT_EQ(fabricTable.GetLastKnownGoodChipEpochTime(lastKnownGoodTime), CHIP_NO_ERROR);
+            EXPECT_EQ(lastKnownGoodTime, buildTime);
 
             // Call revert again.  Since we've committed, this is a no-op.
             // Last known good time should again be unchanged.
             fabricTable.RevertPendingFabricData();
-            NL_TEST_ASSERT(inSuite, fabricTable.GetLastKnownGoodChipEpochTime(lastKnownGoodTime) == CHIP_NO_ERROR);
-            NL_TEST_ASSERT(inSuite, lastKnownGoodTime == buildTime);
+            EXPECT_EQ(fabricTable.GetLastKnownGoodChipEpochTime(lastKnownGoodTime), CHIP_NO_ERROR);
+            EXPECT_EQ(lastKnownGoodTime, buildTime);
         }
         {
             // Test reloading last known good time from persistence.
             ScopedFabricTable fabricTableHolder;
-            NL_TEST_ASSERT(inSuite, fabricTableHolder.Init(&testStorage) == CHIP_NO_ERROR);
+            EXPECT_EQ(fabricTableHolder.Init(&testStorage), CHIP_NO_ERROR);
             FabricTable & fabricTable = fabricTableHolder.GetFabricTable();
 
             // Verify that last known good time was retained.
             System::Clock::Seconds32 lastKnownGoodTime;
-            NL_TEST_ASSERT(inSuite, fabricTable.GetLastKnownGoodChipEpochTime(lastKnownGoodTime) == CHIP_NO_ERROR);
-            NL_TEST_ASSERT(inSuite, lastKnownGoodTime == buildTime);
+            EXPECT_EQ(fabricTable.GetLastKnownGoodChipEpochTime(lastKnownGoodTime), CHIP_NO_ERROR);
+            EXPECT_EQ(lastKnownGoodTime, buildTime);
         }
     }
 
@@ -343,75 +354,75 @@
     for (auto buildTime : beforeNotBeforeBuildTimes)
     {
         // Set build time to the desired value.
-        NL_TEST_ASSERT(inSuite, DeviceLayer::ConfigurationMgr().SetFirmwareBuildChipEpochTime(buildTime) == CHIP_NO_ERROR);
+        EXPECT_EQ(DeviceLayer::ConfigurationMgr().SetFirmwareBuildChipEpochTime(buildTime), CHIP_NO_ERROR);
         chip::TestPersistentStorageDelegate testStorage;
         {
             // Initialize a fabric table.
             ScopedFabricTable fabricTableHolder;
-            NL_TEST_ASSERT(inSuite, fabricTableHolder.Init(&testStorage) == CHIP_NO_ERROR);
+            EXPECT_EQ(fabricTableHolder.Init(&testStorage), CHIP_NO_ERROR);
             FabricTable & fabricTable = fabricTableHolder.GetFabricTable();
 
             // Load a test fabric, but do not commit.
-            NL_TEST_ASSERT(inSuite, LoadTestFabric_Node01_01(inSuite, fabricTable, /* doCommit = */ false) == CHIP_NO_ERROR);
+            EXPECT_EQ(LoadTestFabric_Node01_01(fabricTable, /* doCommit = */ false), CHIP_NO_ERROR);
 
             // Read Last Known Good Time and verify that it is now set to the certificate
             // NotBefore time, as this should be at or after firmware build time.
             System::Clock::Seconds32 lastKnownGoodTime;
-            NL_TEST_ASSERT(inSuite, fabricTable.GetLastKnownGoodChipEpochTime(lastKnownGoodTime) == CHIP_NO_ERROR);
-            NL_TEST_ASSERT(inSuite, lastKnownGoodTime == testCertNotBeforeTime);
+            EXPECT_EQ(fabricTable.GetLastKnownGoodChipEpochTime(lastKnownGoodTime), CHIP_NO_ERROR);
+            EXPECT_EQ(lastKnownGoodTime, testCertNotBeforeTime);
 
             // Now test revert.  Last known good time should change back to the
             // previous value.
             fabricTable.RevertPendingFabricData();
-            NL_TEST_ASSERT(inSuite, fabricTable.GetLastKnownGoodChipEpochTime(lastKnownGoodTime) == CHIP_NO_ERROR);
-            NL_TEST_ASSERT(inSuite, lastKnownGoodTime == buildTime);
+            EXPECT_EQ(fabricTable.GetLastKnownGoodChipEpochTime(lastKnownGoodTime), CHIP_NO_ERROR);
+            EXPECT_EQ(lastKnownGoodTime, buildTime);
         }
         {
             // Test reloading last known good time from persistence.
             ScopedFabricTable fabricTableHolder;
-            NL_TEST_ASSERT(inSuite, fabricTableHolder.Init(&testStorage) == CHIP_NO_ERROR);
+            EXPECT_EQ(fabricTableHolder.Init(&testStorage), CHIP_NO_ERROR);
             FabricTable & fabricTable = fabricTableHolder.GetFabricTable();
 
             // Verify that the original last known good time was retained, since
             // we reverted before.
             System::Clock::Seconds32 lastKnownGoodTime;
-            NL_TEST_ASSERT(inSuite, fabricTable.GetLastKnownGoodChipEpochTime(lastKnownGoodTime) == CHIP_NO_ERROR);
+            EXPECT_EQ(fabricTable.GetLastKnownGoodChipEpochTime(lastKnownGoodTime), CHIP_NO_ERROR);
         }
         {
             // Now test loading a fabric and committing.
             ScopedFabricTable fabricTableHolder;
-            NL_TEST_ASSERT(inSuite, fabricTableHolder.Init(&testStorage) == CHIP_NO_ERROR);
+            EXPECT_EQ(fabricTableHolder.Init(&testStorage), CHIP_NO_ERROR);
             FabricTable & fabricTable = fabricTableHolder.GetFabricTable();
-            NL_TEST_ASSERT(inSuite, LoadTestFabric_Node01_01(inSuite, fabricTable, /* doCommit = */ true) == CHIP_NO_ERROR);
+            EXPECT_EQ(LoadTestFabric_Node01_01(fabricTable, /* doCommit = */ true), CHIP_NO_ERROR);
 
             // Read Last Known Good Time and verify that it is now set to the certificate
             // NotBefore time, as this should be at or after firmware build time.
             System::Clock::Seconds32 lastKnownGoodTime;
-            NL_TEST_ASSERT(inSuite, fabricTable.GetLastKnownGoodChipEpochTime(lastKnownGoodTime) == CHIP_NO_ERROR);
-            NL_TEST_ASSERT(inSuite, lastKnownGoodTime == testCertNotBeforeTime);
+            EXPECT_EQ(fabricTable.GetLastKnownGoodChipEpochTime(lastKnownGoodTime), CHIP_NO_ERROR);
+            EXPECT_EQ(lastKnownGoodTime, testCertNotBeforeTime);
 
             // Now test revert, which will be a no-op because we already
             // committed.  Verify that Last Known Good time is retained.
             fabricTable.RevertPendingFabricData();
-            NL_TEST_ASSERT(inSuite, fabricTable.GetLastKnownGoodChipEpochTime(lastKnownGoodTime) == CHIP_NO_ERROR);
-            NL_TEST_ASSERT(inSuite, lastKnownGoodTime == testCertNotBeforeTime);
+            EXPECT_EQ(fabricTable.GetLastKnownGoodChipEpochTime(lastKnownGoodTime), CHIP_NO_ERROR);
+            EXPECT_EQ(lastKnownGoodTime, testCertNotBeforeTime);
         }
         {
             // Test reloading last known good time from persistence.
             ScopedFabricTable fabricTableHolder;
-            NL_TEST_ASSERT(inSuite, fabricTableHolder.Init(&testStorage) == CHIP_NO_ERROR);
+            EXPECT_EQ(fabricTableHolder.Init(&testStorage), CHIP_NO_ERROR);
             FabricTable & fabricTable = fabricTableHolder.GetFabricTable();
 
             // Verify that the new last known good time was retained, since
             // we committed.
             System::Clock::Seconds32 lastKnownGoodTime;
-            NL_TEST_ASSERT(inSuite, fabricTable.GetLastKnownGoodChipEpochTime(lastKnownGoodTime) == CHIP_NO_ERROR);
-            NL_TEST_ASSERT(inSuite, lastKnownGoodTime == testCertNotBeforeTime);
+            EXPECT_EQ(fabricTable.GetLastKnownGoodChipEpochTime(lastKnownGoodTime), CHIP_NO_ERROR);
+            EXPECT_EQ(lastKnownGoodTime, testCertNotBeforeTime);
         }
     }
 }
 
-void TestSetLastKnownGoodTime(nlTestSuite * inSuite, void * inContext)
+TEST_F(TestFabricTable, TestSetLastKnownGoodTime)
 {
     // It is desirable for nodes to set Last Known Good Time whenever a good
     // time source is available, including cases where this would set the time
@@ -422,7 +433,7 @@
     // Test certs all have this NotBefore: Oct 15 14:23:43 2020 GMT
     const ASN1::ASN1UniversalTime asn1Expected = { 2020, 10, 15, 14, 23, 43 };
     uint32_t testCertNotBeforeSeconds;
-    NL_TEST_ASSERT(inSuite, Credentials::ASN1ToChipEpochTime(asn1Expected, testCertNotBeforeSeconds) == CHIP_NO_ERROR);
+    EXPECT_EQ(Credentials::ASN1ToChipEpochTime(asn1Expected, testCertNotBeforeSeconds), CHIP_NO_ERROR);
     System::Clock::Seconds32 testCertNotBeforeTime = System::Clock::Seconds32(testCertNotBeforeSeconds);
 
     // Iterate over two cases: one with build time prior to our certificates' NotBefore, one with build time after.
@@ -432,77 +443,77 @@
     for (auto buildTime : testCaseFirmwareBuildTimes)
     {
         // Set build time to the desired value.
-        NL_TEST_ASSERT(inSuite, DeviceLayer::ConfigurationMgr().SetFirmwareBuildChipEpochTime(buildTime) == CHIP_NO_ERROR);
+        EXPECT_EQ(DeviceLayer::ConfigurationMgr().SetFirmwareBuildChipEpochTime(buildTime), CHIP_NO_ERROR);
         chip::TestPersistentStorageDelegate testStorage;
         System::Clock::Seconds32 newTime;
         {
             // Initialize a fabric table.
             ScopedFabricTable fabricTableHolder;
-            NL_TEST_ASSERT(inSuite, fabricTableHolder.Init(&testStorage) == CHIP_NO_ERROR);
+            EXPECT_EQ(fabricTableHolder.Init(&testStorage), CHIP_NO_ERROR);
             FabricTable & fabricTable = fabricTableHolder.GetFabricTable();
 
             // Load a test fabric
-            NL_TEST_ASSERT(inSuite, LoadTestFabric_Node01_01(inSuite, fabricTable, /* doCommit= */ true) == CHIP_NO_ERROR);
+            EXPECT_EQ(LoadTestFabric_Node01_01(fabricTable, /* doCommit= */ true), CHIP_NO_ERROR);
 
             // Verify the Last Known Good Time matches our expected initial value.
             System::Clock::Seconds32 initialLastKnownGoodTime =
                 buildTime > testCertNotBeforeTime ? buildTime : testCertNotBeforeTime;
             System::Clock::Seconds32 lastKnownGoodTime;
-            NL_TEST_ASSERT(inSuite, fabricTable.GetLastKnownGoodChipEpochTime(lastKnownGoodTime) == CHIP_NO_ERROR);
-            NL_TEST_ASSERT(inSuite, lastKnownGoodTime == initialLastKnownGoodTime);
+            EXPECT_EQ(fabricTable.GetLastKnownGoodChipEpochTime(lastKnownGoodTime), CHIP_NO_ERROR);
+            EXPECT_EQ(lastKnownGoodTime, initialLastKnownGoodTime);
 
             // Read Last Known Good Time and verify that it hasn't moved forward, since
             // build time is later than the test certs' NotBefore times.
-            NL_TEST_ASSERT(inSuite, fabricTable.GetLastKnownGoodChipEpochTime(lastKnownGoodTime) == CHIP_NO_ERROR);
-            NL_TEST_ASSERT(inSuite, lastKnownGoodTime == initialLastKnownGoodTime);
+            EXPECT_EQ(fabricTable.GetLastKnownGoodChipEpochTime(lastKnownGoodTime), CHIP_NO_ERROR);
+            EXPECT_EQ(lastKnownGoodTime, initialLastKnownGoodTime);
 
             // Attempt to set a Last Known Good Time that is before the firmware build time.  This should fail.
             newTime = System::Clock::Seconds32(buildTime.count() - 1000);
-            NL_TEST_ASSERT(inSuite, fabricTable.SetLastKnownGoodChipEpochTime(newTime) != CHIP_NO_ERROR);
+            EXPECT_NE(fabricTable.SetLastKnownGoodChipEpochTime(newTime), CHIP_NO_ERROR);
 
             // Verify Last Known Good Time is unchanged.
-            NL_TEST_ASSERT(inSuite, fabricTable.GetLastKnownGoodChipEpochTime(lastKnownGoodTime) == CHIP_NO_ERROR);
-            NL_TEST_ASSERT(inSuite, lastKnownGoodTime == initialLastKnownGoodTime);
+            EXPECT_EQ(fabricTable.GetLastKnownGoodChipEpochTime(lastKnownGoodTime), CHIP_NO_ERROR);
+            EXPECT_EQ(lastKnownGoodTime, initialLastKnownGoodTime);
 
             // Attempt to set a Last Known Good Time that is before our certificates' NotBefore times.  This should fail.
             newTime = System::Clock::Seconds32(testCertNotBeforeTime.count() - 1000);
-            NL_TEST_ASSERT(inSuite, fabricTable.SetLastKnownGoodChipEpochTime(newTime) != CHIP_NO_ERROR);
+            EXPECT_NE(fabricTable.SetLastKnownGoodChipEpochTime(newTime), CHIP_NO_ERROR);
 
             // Verify Last Known Good Time is unchanged.
-            NL_TEST_ASSERT(inSuite, fabricTable.GetLastKnownGoodChipEpochTime(lastKnownGoodTime) == CHIP_NO_ERROR);
-            NL_TEST_ASSERT(inSuite, lastKnownGoodTime == initialLastKnownGoodTime);
+            EXPECT_EQ(fabricTable.GetLastKnownGoodChipEpochTime(lastKnownGoodTime), CHIP_NO_ERROR);
+            EXPECT_EQ(lastKnownGoodTime, initialLastKnownGoodTime);
 
             // Attempt to set a Last Known Good Time that at our current value.
-            NL_TEST_ASSERT(inSuite, fabricTable.SetLastKnownGoodChipEpochTime(lastKnownGoodTime) == CHIP_NO_ERROR);
+            EXPECT_EQ(fabricTable.SetLastKnownGoodChipEpochTime(lastKnownGoodTime), CHIP_NO_ERROR);
 
             // Verify Last Known Good Time is unchanged.
-            NL_TEST_ASSERT(inSuite, fabricTable.GetLastKnownGoodChipEpochTime(lastKnownGoodTime) == CHIP_NO_ERROR);
-            NL_TEST_ASSERT(inSuite, lastKnownGoodTime == initialLastKnownGoodTime);
+            EXPECT_EQ(fabricTable.GetLastKnownGoodChipEpochTime(lastKnownGoodTime), CHIP_NO_ERROR);
+            EXPECT_EQ(lastKnownGoodTime, initialLastKnownGoodTime);
 
             // Attempt to set Last Known Good Times that is after our current value.
             newTime = System::Clock::Seconds32(initialLastKnownGoodTime.count() + 1000);
-            NL_TEST_ASSERT(inSuite, fabricTable.SetLastKnownGoodChipEpochTime(newTime) == CHIP_NO_ERROR);
+            EXPECT_EQ(fabricTable.SetLastKnownGoodChipEpochTime(newTime), CHIP_NO_ERROR);
 
             // Verify Last Known Good Time is updated.
-            NL_TEST_ASSERT(inSuite, fabricTable.GetLastKnownGoodChipEpochTime(lastKnownGoodTime) == CHIP_NO_ERROR);
-            NL_TEST_ASSERT(inSuite, lastKnownGoodTime == newTime);
+            EXPECT_EQ(fabricTable.GetLastKnownGoodChipEpochTime(lastKnownGoodTime), CHIP_NO_ERROR);
+            EXPECT_EQ(lastKnownGoodTime, newTime);
         }
         {
             // Verify that Last Known Good Time was persisted.
 
             ScopedFabricTable fabricTableHolder;
-            NL_TEST_ASSERT(inSuite, fabricTableHolder.Init(&testStorage) == CHIP_NO_ERROR);
+            EXPECT_EQ(fabricTableHolder.Init(&testStorage), CHIP_NO_ERROR);
             FabricTable & fabricTable = fabricTableHolder.GetFabricTable();
 
             System::Clock::Seconds32 lastKnownGoodTime;
-            NL_TEST_ASSERT(inSuite, fabricTable.GetLastKnownGoodChipEpochTime(lastKnownGoodTime) == CHIP_NO_ERROR);
-            NL_TEST_ASSERT(inSuite, lastKnownGoodTime == newTime);
+            EXPECT_EQ(fabricTable.GetLastKnownGoodChipEpochTime(lastKnownGoodTime), CHIP_NO_ERROR);
+            EXPECT_EQ(lastKnownGoodTime, newTime);
         }
     }
 }
 
 // Test adding 2 fabrics, updating 1, removing 1
-void TestBasicAddNocUpdateNocFlow(nlTestSuite * inSuite, void * inContext)
+TEST_F(TestFabricTable, TestBasicAddNocUpdateNocFlow)
 {
     Credentials::TestOnlyLocalCertificateAuthority fabric11CertAuthority;
     Credentials::TestOnlyLocalCertificateAuthority fabric44CertAuthority;
@@ -513,25 +524,25 @@
     // storage.SetLoggingLevel(chip::TestPersistentStorageDelegate::LoggingLevel::kLogMutation);
 
     // Initialize test CA and a Fabric 11 externally owned key
-    NL_TEST_ASSERT(inSuite, fabric11CertAuthority.Init().IsSuccess());
-    NL_TEST_ASSERT(inSuite, fabric44CertAuthority.Init().IsSuccess());
+    EXPECT_TRUE(fabric11CertAuthority.Init().IsSuccess());
+    EXPECT_TRUE(fabric44CertAuthority.Init().IsSuccess());
 
     constexpr uint16_t kVendorId = 0xFFF1u;
 
     chip::Crypto::P256Keypair fabric11Node55Keypair; // Fabric ID 11,
-    NL_TEST_ASSERT(inSuite, fabric11Node55Keypair.Initialize(Crypto::ECPKeyTarget::ECDSA) == CHIP_NO_ERROR);
+    EXPECT_EQ(fabric11Node55Keypair.Initialize(Crypto::ECPKeyTarget::ECDSA), CHIP_NO_ERROR);
 
     // Initialize a fabric table.
     ScopedFabricTable fabricTableHolder;
-    NL_TEST_ASSERT(inSuite, fabricTableHolder.Init(&storage) == CHIP_NO_ERROR);
+    EXPECT_EQ(fabricTableHolder.Init(&storage), CHIP_NO_ERROR);
     FabricTable & fabricTable = fabricTableHolder.GetFabricTable();
 
-    NL_TEST_ASSERT_EQUALS(inSuite, fabricTable.FabricCount(), 0);
+    EXPECT_EQ(fabricTable.FabricCount(), 0);
 
     {
         FabricIndex nextFabricIndex = kUndefinedFabricIndex;
-        NL_TEST_ASSERT(inSuite, fabricTable.PeekFabricIndexForNextAddition(nextFabricIndex) == CHIP_NO_ERROR);
-        NL_TEST_ASSERT_EQUALS(inSuite, nextFabricIndex, 1);
+        EXPECT_EQ(fabricTable.PeekFabricIndexForNextAddition(nextFabricIndex), CHIP_NO_ERROR);
+        EXPECT_EQ(nextFabricIndex, 1);
     }
 
     size_t numFabricsIterated = 0;
@@ -542,10 +553,10 @@
     {
         FabricId fabricId = 11;
         NodeId nodeId     = 55;
-        NL_TEST_ASSERT_SUCCESS(inSuite,
-                               fabric11CertAuthority.SetIncludeIcac(false)
-                                   .GenerateNocChain(fabricId, nodeId, fabric11Node55Keypair.Pubkey())
-                                   .GetStatus());
+        EXPECT_EQ(fabric11CertAuthority.SetIncludeIcac(false)
+                      .GenerateNocChain(fabricId, nodeId, fabric11Node55Keypair.Pubkey())
+                      .GetStatus(),
+                  CHIP_NO_ERROR);
         ByteSpan rcac = fabric11CertAuthority.GetRcac();
         ByteSpan noc  = fabric11CertAuthority.GetNoc();
 
@@ -562,48 +573,48 @@
                 }
             }
 
-            NL_TEST_ASSERT(inSuite, numFabricsIterated == 0);
-            NL_TEST_ASSERT(inSuite, saw1 == false);
+            EXPECT_EQ(numFabricsIterated, 0u);
+            EXPECT_FALSE(saw1);
         }
 
         uint8_t rcacBuf[Credentials::kMaxCHIPCertLength];
         {
             // No pending root cert yet.
             MutableByteSpan fetchedSpan{ rcacBuf };
-            NL_TEST_ASSERT(inSuite, fabricTable.FetchPendingNonFabricAssociatedRootCert(fetchedSpan) == CHIP_ERROR_NOT_FOUND);
+            EXPECT_EQ(fabricTable.FetchPendingNonFabricAssociatedRootCert(fetchedSpan), CHIP_ERROR_NOT_FOUND);
         }
 
-        NL_TEST_ASSERT_SUCCESS(inSuite, fabricTable.AddNewPendingTrustedRootCert(rcac));
+        EXPECT_EQ(fabricTable.AddNewPendingTrustedRootCert(rcac), CHIP_NO_ERROR);
         {
             // Now have a pending root cert.
             MutableByteSpan fetchedSpan{ rcacBuf };
-            NL_TEST_ASSERT_SUCCESS(inSuite, fabricTable.FetchPendingNonFabricAssociatedRootCert(fetchedSpan));
-            NL_TEST_ASSERT(inSuite, fetchedSpan.data_equal(rcac));
+            EXPECT_EQ(fabricTable.FetchPendingNonFabricAssociatedRootCert(fetchedSpan), CHIP_NO_ERROR);
+            EXPECT_TRUE(fetchedSpan.data_equal(rcac));
         }
 
         FabricIndex newFabricIndex = kUndefinedFabricIndex;
         bool keyIsExternallyOwned  = true;
 
-        NL_TEST_ASSERT_EQUALS(inSuite, fabricTable.FabricCount(), 0);
-        NL_TEST_ASSERT_SUCCESS(inSuite,
-                               fabricTable.AddNewPendingFabricWithProvidedOpKey(noc, ByteSpan{}, kVendorId, &fabric11Node55Keypair,
-                                                                                keyIsExternallyOwned, &newFabricIndex));
-        NL_TEST_ASSERT(inSuite, newFabricIndex == 1);
-        NL_TEST_ASSERT_EQUALS(inSuite, fabricTable.FabricCount(), 1);
+        EXPECT_EQ(fabricTable.FabricCount(), 0);
+        EXPECT_EQ(fabricTable.AddNewPendingFabricWithProvidedOpKey(noc, ByteSpan{}, kVendorId, &fabric11Node55Keypair,
+                                                                   keyIsExternallyOwned, &newFabricIndex),
+                  CHIP_NO_ERROR);
+        EXPECT_EQ(newFabricIndex, 1);
+        EXPECT_EQ(fabricTable.FabricCount(), 1);
         {
             // No more pending root cert; it's associated with a fabric now.
             MutableByteSpan fetchedSpan{ rcacBuf };
-            NL_TEST_ASSERT(inSuite, fabricTable.FetchPendingNonFabricAssociatedRootCert(fetchedSpan) == CHIP_ERROR_NOT_FOUND);
+            EXPECT_EQ(fabricTable.FetchPendingNonFabricAssociatedRootCert(fetchedSpan), CHIP_ERROR_NOT_FOUND);
         }
 
         // No storage yet
-        NL_TEST_ASSERT(inSuite, storage.GetNumKeys() == numStorageKeysAtStart);
+        EXPECT_EQ(storage.GetNumKeys(), numStorageKeysAtStart);
 
         // Next fabric index has not been updated yet.
         {
             FabricIndex nextFabricIndex = kUndefinedFabricIndex;
-            NL_TEST_ASSERT(inSuite, fabricTable.PeekFabricIndexForNextAddition(nextFabricIndex) == CHIP_NO_ERROR);
-            NL_TEST_ASSERT_EQUALS(inSuite, nextFabricIndex, 1);
+            EXPECT_EQ(fabricTable.PeekFabricIndexForNextAddition(nextFabricIndex), CHIP_NO_ERROR);
+            EXPECT_EQ(nextFabricIndex, 1);
         }
 
         // Validate iterator sees pending
@@ -615,56 +626,51 @@
                 ++numFabricsIterated;
                 if (iterFabricInfo.GetFabricIndex() == 1)
                 {
-                    NL_TEST_ASSERT(inSuite, iterFabricInfo.GetNodeId() == nodeId);
-                    NL_TEST_ASSERT(inSuite, iterFabricInfo.GetFabricId() == fabricId);
+                    EXPECT_EQ(iterFabricInfo.GetNodeId(), nodeId);
+                    EXPECT_EQ(iterFabricInfo.GetFabricId(), fabricId);
                     saw1 = true;
                 }
             }
 
-            NL_TEST_ASSERT(inSuite, numFabricsIterated == 1);
-            NL_TEST_ASSERT(inSuite, saw1 == true);
+            EXPECT_EQ(numFabricsIterated, 1u);
+            EXPECT_TRUE(saw1);
         }
 
         // Commit, now storage should have keys
-        NL_TEST_ASSERT_SUCCESS(inSuite, fabricTable.CommitPendingFabricData());
+        EXPECT_EQ(fabricTable.CommitPendingFabricData(), CHIP_NO_ERROR);
 
-        NL_TEST_ASSERT(inSuite, storage.GetNumKeys() == (numStorageKeysAtStart + 4)); // 2 opcerts + fabric metadata + index
+        EXPECT_EQ(storage.GetNumKeys(), (numStorageKeysAtStart + 4)); // 2 opcerts + fabric metadata + index
 
         // Next fabric index has been updated.
         {
             FabricIndex nextFabricIndex = kUndefinedFabricIndex;
-            NL_TEST_ASSERT(inSuite, fabricTable.PeekFabricIndexForNextAddition(nextFabricIndex) == CHIP_NO_ERROR);
-            NL_TEST_ASSERT_EQUALS(inSuite, nextFabricIndex, 2);
+            EXPECT_EQ(fabricTable.PeekFabricIndexForNextAddition(nextFabricIndex), CHIP_NO_ERROR);
+            EXPECT_EQ(nextFabricIndex, 2);
         }
 
         // Validate contents
         const auto * fabricInfo = fabricTable.FindFabricWithIndex(1);
-        NL_TEST_ASSERT(inSuite, fabricInfo != nullptr);
-        if (fabricInfo != nullptr)
-        {
-            Credentials::ChipCertificateSet certificates;
-            NL_TEST_ASSERT_SUCCESS(inSuite, certificates.Init(1));
-            NL_TEST_ASSERT_SUCCESS(inSuite,
-                                   certificates.LoadCert(rcac, BitFlags<CertDecodeFlags>(CertDecodeFlags::kIsTrustAnchor)));
-            Crypto::P256PublicKey rcacPublicKey(certificates.GetCertSet()[0].mPublicKey);
+        ASSERT_NE(fabricInfo, nullptr);
+        Credentials::ChipCertificateSet certificates;
+        EXPECT_EQ(certificates.Init(1), CHIP_NO_ERROR);
+        EXPECT_EQ(certificates.LoadCert(rcac, BitFlags<CertDecodeFlags>(CertDecodeFlags::kIsTrustAnchor)), CHIP_NO_ERROR);
+        Crypto::P256PublicKey rcacPublicKey(certificates.GetCertSet()[0].mPublicKey);
 
-            NL_TEST_ASSERT(inSuite, fabricInfo->GetFabricIndex() == newFabricIndex);
-            NL_TEST_ASSERT(inSuite, fabricInfo->GetNodeId() == nodeId);
-            NL_TEST_ASSERT(inSuite, fabricInfo->GetFabricId() == fabricId);
-            NL_TEST_ASSERT(inSuite, fabricInfo->GetVendorId() == kVendorId);
-            NL_TEST_ASSERT(inSuite, fabricInfo->GetFabricLabel().size() == 0);
+        EXPECT_EQ(fabricInfo->GetFabricIndex(), newFabricIndex);
+        EXPECT_EQ(fabricInfo->GetNodeId(), nodeId);
+        EXPECT_EQ(fabricInfo->GetFabricId(), fabricId);
+        EXPECT_EQ(fabricInfo->GetVendorId(), kVendorId);
+        EXPECT_EQ(fabricInfo->GetFabricLabel().size(), 0u);
 
-            Crypto::P256PublicKey rootPublicKeyOfFabric;
-            NL_TEST_ASSERT_SUCCESS(inSuite, fabricTable.FetchRootPubkey(newFabricIndex, rootPublicKeyOfFabric));
-            NL_TEST_ASSERT(inSuite, rootPublicKeyOfFabric.Matches(rcacPublicKey));
-        }
+        Crypto::P256PublicKey rootPublicKeyOfFabric;
+        EXPECT_EQ(fabricTable.FetchRootPubkey(newFabricIndex, rootPublicKeyOfFabric), CHIP_NO_ERROR);
+        EXPECT_TRUE(rootPublicKeyOfFabric.Matches(rcacPublicKey));
 
         // Validate that fabric has the correct operational key by verifying a signature
         Crypto::P256ECDSASignature sig;
         uint8_t message[] = { 'm', 's', 'g' };
-        NL_TEST_ASSERT_SUCCESS(inSuite, fabricTable.SignWithOpKeypair(newFabricIndex, ByteSpan{ message }, sig));
-        NL_TEST_ASSERT_SUCCESS(inSuite,
-                               fabric11Node55Keypair.Pubkey().ECDSA_validate_msg_signature(&message[0], sizeof(message), sig));
+        EXPECT_EQ(fabricTable.SignWithOpKeypair(newFabricIndex, ByteSpan{ message }, sig), CHIP_NO_ERROR);
+        EXPECT_EQ(fabric11Node55Keypair.Pubkey().ECDSA_validate_msg_signature(&message[0], sizeof(message), sig), CHIP_NO_ERROR);
 
         // Validate iterator sees committed
         {
@@ -675,14 +681,14 @@
                 ++numFabricsIterated;
                 if (iterFabricInfo.GetFabricIndex() == 1)
                 {
-                    NL_TEST_ASSERT(inSuite, iterFabricInfo.GetNodeId() == nodeId);
-                    NL_TEST_ASSERT(inSuite, iterFabricInfo.GetFabricId() == fabricId);
+                    EXPECT_EQ(iterFabricInfo.GetNodeId(), nodeId);
+                    EXPECT_EQ(iterFabricInfo.GetFabricId(), fabricId);
                     saw1 = true;
                 }
             }
 
-            NL_TEST_ASSERT(inSuite, numFabricsIterated == 1);
-            NL_TEST_ASSERT(inSuite, saw1 == true);
+            EXPECT_EQ(numFabricsIterated, 1u);
+            EXPECT_TRUE(saw1);
         }
     }
 
@@ -695,75 +701,70 @@
 
         uint8_t csrBuf[chip::Crypto::kMIN_CSR_Buffer_Size];
         MutableByteSpan csrSpan{ csrBuf };
-        NL_TEST_ASSERT_SUCCESS(inSuite, fabricTable.AllocatePendingOperationalKey(chip::NullOptional, csrSpan));
+        EXPECT_EQ(fabricTable.AllocatePendingOperationalKey(chip::NullOptional, csrSpan), CHIP_NO_ERROR);
 
-        NL_TEST_ASSERT_SUCCESS(inSuite,
-                               fabric44CertAuthority.SetIncludeIcac(true).GenerateNocChain(fabricId, nodeId, csrSpan).GetStatus());
+        EXPECT_EQ(fabric44CertAuthority.SetIncludeIcac(true).GenerateNocChain(fabricId, nodeId, csrSpan).GetStatus(),
+                  CHIP_NO_ERROR);
         ByteSpan rcac = fabric44CertAuthority.GetRcac();
         ByteSpan icac = fabric44CertAuthority.GetIcac();
         ByteSpan noc  = fabric44CertAuthority.GetNoc();
 
-        NL_TEST_ASSERT_EQUALS(inSuite, fabricTable.FabricCount(), 1);
+        EXPECT_EQ(fabricTable.FabricCount(), 1);
 
         // Next fabric index should still be the same as before.
         {
             FabricIndex nextFabricIndex = kUndefinedFabricIndex;
-            NL_TEST_ASSERT(inSuite, fabricTable.PeekFabricIndexForNextAddition(nextFabricIndex) == CHIP_NO_ERROR);
-            NL_TEST_ASSERT_EQUALS(inSuite, nextFabricIndex, 2);
+            EXPECT_EQ(fabricTable.PeekFabricIndexForNextAddition(nextFabricIndex), CHIP_NO_ERROR);
+            EXPECT_EQ(nextFabricIndex, 2);
         }
 
-        NL_TEST_ASSERT_SUCCESS(inSuite, fabricTable.AddNewPendingTrustedRootCert(rcac));
+        EXPECT_EQ(fabricTable.AddNewPendingTrustedRootCert(rcac), CHIP_NO_ERROR);
         FabricIndex newFabricIndex = kUndefinedFabricIndex;
 
-        NL_TEST_ASSERT_EQUALS(inSuite, fabricTable.FabricCount(), 1);
-        NL_TEST_ASSERT_SUCCESS(inSuite,
-                               fabricTable.AddNewPendingFabricWithOperationalKeystore(noc, icac, kVendorId, &newFabricIndex));
-        NL_TEST_ASSERT_EQUALS(inSuite, fabricTable.FabricCount(), 2);
-        NL_TEST_ASSERT(inSuite, newFabricIndex == 2);
+        EXPECT_EQ(fabricTable.FabricCount(), 1);
+        EXPECT_EQ(fabricTable.AddNewPendingFabricWithOperationalKeystore(noc, icac, kVendorId, &newFabricIndex), CHIP_NO_ERROR);
+        EXPECT_EQ(fabricTable.FabricCount(), 2);
+        EXPECT_EQ(newFabricIndex, 2);
         // No storage yet
-        NL_TEST_ASSERT(inSuite, storage.GetNumKeys() == numStorageAfterFirstAdd);
+        EXPECT_EQ(storage.GetNumKeys(), numStorageAfterFirstAdd);
         // Next fabric index has not been updated yet.
         {
             FabricIndex nextFabricIndex = kUndefinedFabricIndex;
-            NL_TEST_ASSERT(inSuite, fabricTable.PeekFabricIndexForNextAddition(nextFabricIndex) == CHIP_NO_ERROR);
-            NL_TEST_ASSERT_EQUALS(inSuite, nextFabricIndex, 2);
+            EXPECT_EQ(fabricTable.PeekFabricIndexForNextAddition(nextFabricIndex), CHIP_NO_ERROR);
+            EXPECT_EQ(nextFabricIndex, 2);
         }
 
         // Commit, now storage should have keys
-        NL_TEST_ASSERT_SUCCESS(inSuite, fabricTable.CommitPendingFabricData());
-        NL_TEST_ASSERT_EQUALS(inSuite, fabricTable.FabricCount(), 2);
+        EXPECT_EQ(fabricTable.CommitPendingFabricData(), CHIP_NO_ERROR);
+        EXPECT_EQ(fabricTable.FabricCount(), 2);
 
-        NL_TEST_ASSERT_EQUALS(inSuite, storage.GetNumKeys(),
-                              (numStorageAfterFirstAdd + 5)); // 3 opcerts + fabric metadata + 1 operational key
+        EXPECT_EQ(storage.GetNumKeys(),
+                  (numStorageAfterFirstAdd + 5)); // 3 opcerts + fabric metadata + 1 operational key
 
         // Next fabric index has been updated.
         {
             FabricIndex nextFabricIndex = kUndefinedFabricIndex;
-            NL_TEST_ASSERT(inSuite, fabricTable.PeekFabricIndexForNextAddition(nextFabricIndex) == CHIP_NO_ERROR);
-            NL_TEST_ASSERT_EQUALS(inSuite, nextFabricIndex, 3);
+            EXPECT_EQ(fabricTable.PeekFabricIndexForNextAddition(nextFabricIndex), CHIP_NO_ERROR);
+            EXPECT_EQ(nextFabricIndex, 3);
         }
 
         // Validate contents
         const auto * fabricInfo = fabricTable.FindFabricWithIndex(2);
-        NL_TEST_ASSERT(inSuite, fabricInfo != nullptr);
-        if (fabricInfo != nullptr)
-        {
-            Credentials::ChipCertificateSet certificates;
-            NL_TEST_ASSERT_SUCCESS(inSuite, certificates.Init(1));
-            NL_TEST_ASSERT_SUCCESS(inSuite,
-                                   certificates.LoadCert(rcac, BitFlags<CertDecodeFlags>(CertDecodeFlags::kIsTrustAnchor)));
-            Crypto::P256PublicKey rcacPublicKey(certificates.GetCertSet()[0].mPublicKey);
+        ASSERT_NE(fabricInfo, nullptr);
+        Credentials::ChipCertificateSet certificates;
+        EXPECT_EQ(certificates.Init(1), CHIP_NO_ERROR);
+        EXPECT_EQ(certificates.LoadCert(rcac, BitFlags<CertDecodeFlags>(CertDecodeFlags::kIsTrustAnchor)), CHIP_NO_ERROR);
+        Crypto::P256PublicKey rcacPublicKey(certificates.GetCertSet()[0].mPublicKey);
 
-            NL_TEST_ASSERT(inSuite, fabricInfo->GetFabricIndex() == newFabricIndex);
-            NL_TEST_ASSERT(inSuite, fabricInfo->GetNodeId() == nodeId);
-            NL_TEST_ASSERT(inSuite, fabricInfo->GetFabricId() == fabricId);
-            NL_TEST_ASSERT(inSuite, fabricInfo->GetVendorId() == kVendorId);
-            NL_TEST_ASSERT(inSuite, fabricInfo->GetFabricLabel().size() == 0);
+        EXPECT_EQ(fabricInfo->GetFabricIndex(), newFabricIndex);
+        EXPECT_EQ(fabricInfo->GetNodeId(), nodeId);
+        EXPECT_EQ(fabricInfo->GetFabricId(), fabricId);
+        EXPECT_EQ(fabricInfo->GetVendorId(), kVendorId);
+        EXPECT_EQ(fabricInfo->GetFabricLabel().size(), 0u);
 
-            Crypto::P256PublicKey rootPublicKeyOfFabric;
-            NL_TEST_ASSERT_SUCCESS(inSuite, fabricTable.FetchRootPubkey(newFabricIndex, rootPublicKeyOfFabric));
-            NL_TEST_ASSERT(inSuite, rootPublicKeyOfFabric.Matches(rcacPublicKey));
-        }
+        Crypto::P256PublicKey rootPublicKeyOfFabric;
+        EXPECT_EQ(fabricTable.FetchRootPubkey(newFabricIndex, rootPublicKeyOfFabric), CHIP_NO_ERROR);
+        EXPECT_TRUE(rootPublicKeyOfFabric.Matches(rcacPublicKey));
 
         // Validate that fabric has the correct operational key by verifying a signature
         {
@@ -771,10 +772,10 @@
             uint8_t message[] = { 'm', 's', 'g' };
 
             Crypto::P256PublicKey nocPubKey;
-            NL_TEST_ASSERT_SUCCESS(inSuite, VerifyCertificateSigningRequest(csrSpan.data(), csrSpan.size(), nocPubKey));
+            EXPECT_EQ(VerifyCertificateSigningRequest(csrSpan.data(), csrSpan.size(), nocPubKey), CHIP_NO_ERROR);
 
-            NL_TEST_ASSERT_SUCCESS(inSuite, fabricTable.SignWithOpKeypair(newFabricIndex, ByteSpan{ message }, sig));
-            NL_TEST_ASSERT_SUCCESS(inSuite, nocPubKey.ECDSA_validate_msg_signature(&message[0], sizeof(message), sig));
+            EXPECT_EQ(fabricTable.SignWithOpKeypair(newFabricIndex, ByteSpan{ message }, sig), CHIP_NO_ERROR);
+            EXPECT_EQ(nocPubKey.ECDSA_validate_msg_signature(&message[0], sizeof(message), sig), CHIP_NO_ERROR);
         }
 
         // Verify we can now see 2 fabrics with the iterator
@@ -787,21 +788,21 @@
                 ++numFabricsIterated;
                 if (iterFabricInfo.GetFabricIndex() == 1)
                 {
-                    NL_TEST_ASSERT(inSuite, iterFabricInfo.GetNodeId() == 55);
-                    NL_TEST_ASSERT(inSuite, iterFabricInfo.GetFabricId() == 11);
+                    EXPECT_EQ(iterFabricInfo.GetNodeId(), 55u);
+                    EXPECT_EQ(iterFabricInfo.GetFabricId(), 11u);
                     saw1 = true;
                 }
                 if (iterFabricInfo.GetFabricIndex() == 2)
                 {
-                    NL_TEST_ASSERT(inSuite, iterFabricInfo.GetNodeId() == 999);
-                    NL_TEST_ASSERT(inSuite, iterFabricInfo.GetFabricId() == 44);
+                    EXPECT_EQ(iterFabricInfo.GetNodeId(), 999u);
+                    EXPECT_EQ(iterFabricInfo.GetFabricId(), 44u);
                     saw2 = true;
                 }
             }
 
-            NL_TEST_ASSERT(inSuite, numFabricsIterated == 2);
-            NL_TEST_ASSERT(inSuite, saw1 == true);
-            NL_TEST_ASSERT(inSuite, saw2 == true);
+            EXPECT_EQ(numFabricsIterated, 2u);
+            EXPECT_TRUE(saw1);
+            EXPECT_TRUE(saw2);
         }
     }
 
@@ -817,22 +818,21 @@
         MutableByteSpan csrSpan{ csrBuf };
 
         // Make sure to tag fabric index to pending opkey: otherwise the UpdateNOC fails
-        NL_TEST_ASSERT_SUCCESS(inSuite,
-                               fabricTable.AllocatePendingOperationalKey(chip::MakeOptional(static_cast<FabricIndex>(2)), csrSpan));
+        EXPECT_EQ(fabricTable.AllocatePendingOperationalKey(chip::MakeOptional(static_cast<FabricIndex>(2)), csrSpan),
+                  CHIP_NO_ERROR);
 
-        NL_TEST_ASSERT_SUCCESS(inSuite,
-                               fabric44CertAuthority.SetIncludeIcac(false).GenerateNocChain(fabricId, nodeId, csrSpan).GetStatus());
+        EXPECT_EQ(fabric44CertAuthority.SetIncludeIcac(false).GenerateNocChain(fabricId, nodeId, csrSpan).GetStatus(),
+                  CHIP_NO_ERROR);
         ByteSpan rcac = fabric44CertAuthority.GetRcac();
         ByteSpan noc  = fabric44CertAuthority.GetNoc();
 
-        NL_TEST_ASSERT_EQUALS(inSuite, fabricTable.FabricCount(), 2);
-        NL_TEST_ASSERT_SUCCESS(
-            inSuite,
-            fabricTable.UpdatePendingFabricWithOperationalKeystore(2, noc, ByteSpan{}, FabricTable::AdvertiseIdentity::No));
-        NL_TEST_ASSERT_EQUALS(inSuite, fabricTable.FabricCount(), 2);
+        EXPECT_EQ(fabricTable.FabricCount(), 2);
+        EXPECT_EQ(fabricTable.UpdatePendingFabricWithOperationalKeystore(2, noc, ByteSpan{}, FabricTable::AdvertiseIdentity::No),
+                  CHIP_NO_ERROR);
+        EXPECT_EQ(fabricTable.FabricCount(), 2);
 
         // No storage yet
-        NL_TEST_ASSERT(inSuite, storage.GetNumKeys() == numStorageAfterSecondAdd);
+        EXPECT_EQ(storage.GetNumKeys(), numStorageAfterSecondAdd);
 
         // Validate iterator sees the pending data
         {
@@ -844,52 +844,48 @@
                 ++numFabricsIterated;
                 if (iterFabricInfo.GetFabricIndex() == 1)
                 {
-                    NL_TEST_ASSERT(inSuite, iterFabricInfo.GetNodeId() == 55);
-                    NL_TEST_ASSERT(inSuite, iterFabricInfo.GetFabricId() == 11);
-                    NL_TEST_ASSERT(inSuite, iterFabricInfo.ShouldAdvertiseIdentity());
+                    EXPECT_EQ(iterFabricInfo.GetNodeId(), 55u);
+                    EXPECT_EQ(iterFabricInfo.GetFabricId(), 11u);
+                    EXPECT_TRUE(iterFabricInfo.ShouldAdvertiseIdentity());
                     saw1 = true;
                 }
                 if (iterFabricInfo.GetFabricIndex() == 2)
                 {
-                    NL_TEST_ASSERT(inSuite, iterFabricInfo.GetNodeId() == 1000);
-                    NL_TEST_ASSERT(inSuite, iterFabricInfo.GetFabricId() == 44);
-                    NL_TEST_ASSERT(inSuite, !iterFabricInfo.ShouldAdvertiseIdentity());
+                    EXPECT_EQ(iterFabricInfo.GetNodeId(), 1000u);
+                    EXPECT_EQ(iterFabricInfo.GetFabricId(), 44u);
+                    EXPECT_FALSE(iterFabricInfo.ShouldAdvertiseIdentity());
                     saw2 = true;
                 }
             }
 
-            NL_TEST_ASSERT(inSuite, numFabricsIterated == 2);
-            NL_TEST_ASSERT(inSuite, saw1 == true);
-            NL_TEST_ASSERT(inSuite, saw2 == true);
+            EXPECT_EQ(numFabricsIterated, 2u);
+            EXPECT_TRUE(saw1);
+            EXPECT_TRUE(saw2);
         }
 
         // Commit, now storage should have keys
-        NL_TEST_ASSERT_SUCCESS(inSuite, fabricTable.CommitPendingFabricData());
-        NL_TEST_ASSERT_EQUALS(inSuite, fabricTable.FabricCount(), 2);
+        EXPECT_EQ(fabricTable.CommitPendingFabricData(), CHIP_NO_ERROR);
+        EXPECT_EQ(fabricTable.FabricCount(), 2);
 
-        NL_TEST_ASSERT_EQUALS(inSuite, storage.GetNumKeys(), (numStorageAfterSecondAdd - 1)); // ICAC got deleted
+        EXPECT_EQ(storage.GetNumKeys(), (numStorageAfterSecondAdd - 1)); // ICAC got deleted
 
         // Validate contents
         const auto * fabricInfo = fabricTable.FindFabricWithIndex(2);
-        NL_TEST_ASSERT(inSuite, fabricInfo != nullptr);
-        if (fabricInfo != nullptr)
-        {
-            Credentials::ChipCertificateSet certificates;
-            NL_TEST_ASSERT_SUCCESS(inSuite, certificates.Init(1));
-            NL_TEST_ASSERT_SUCCESS(inSuite,
-                                   certificates.LoadCert(rcac, BitFlags<CertDecodeFlags>(CertDecodeFlags::kIsTrustAnchor)));
-            Crypto::P256PublicKey rcacPublicKey(certificates.GetCertSet()[0].mPublicKey);
+        ASSERT_NE(fabricInfo, nullptr);
+        Credentials::ChipCertificateSet certificates;
+        EXPECT_EQ(certificates.Init(1), CHIP_NO_ERROR);
+        EXPECT_EQ(certificates.LoadCert(rcac, BitFlags<CertDecodeFlags>(CertDecodeFlags::kIsTrustAnchor)), CHIP_NO_ERROR);
+        Crypto::P256PublicKey rcacPublicKey(certificates.GetCertSet()[0].mPublicKey);
 
-            NL_TEST_ASSERT(inSuite, fabricInfo->GetFabricIndex() == fabricIndex);
-            NL_TEST_ASSERT(inSuite, fabricInfo->GetNodeId() == nodeId);
-            NL_TEST_ASSERT(inSuite, fabricInfo->GetFabricId() == fabricId);
-            NL_TEST_ASSERT(inSuite, fabricInfo->GetVendorId() == kVendorId);
-            NL_TEST_ASSERT(inSuite, fabricInfo->GetFabricLabel().size() == 0);
+        EXPECT_EQ(fabricInfo->GetFabricIndex(), fabricIndex);
+        EXPECT_EQ(fabricInfo->GetNodeId(), nodeId);
+        EXPECT_EQ(fabricInfo->GetFabricId(), fabricId);
+        EXPECT_EQ(fabricInfo->GetVendorId(), kVendorId);
+        EXPECT_EQ(fabricInfo->GetFabricLabel().size(), 0u);
 
-            Crypto::P256PublicKey rootPublicKeyOfFabric;
-            NL_TEST_ASSERT_SUCCESS(inSuite, fabricTable.FetchRootPubkey(fabricIndex, rootPublicKeyOfFabric));
-            NL_TEST_ASSERT(inSuite, rootPublicKeyOfFabric.Matches(rcacPublicKey));
-        }
+        Crypto::P256PublicKey rootPublicKeyOfFabric;
+        EXPECT_EQ(fabricTable.FetchRootPubkey(fabricIndex, rootPublicKeyOfFabric), CHIP_NO_ERROR);
+        EXPECT_TRUE(rootPublicKeyOfFabric.Matches(rcacPublicKey));
 
         // Validate that fabric has the correct operational key by verifying a signature
         {
@@ -897,10 +893,10 @@
             uint8_t message[] = { 'm', 's', 'g' };
 
             Crypto::P256PublicKey nocPubKey;
-            NL_TEST_ASSERT_SUCCESS(inSuite, VerifyCertificateSigningRequest(csrSpan.data(), csrSpan.size(), nocPubKey));
+            EXPECT_EQ(VerifyCertificateSigningRequest(csrSpan.data(), csrSpan.size(), nocPubKey), CHIP_NO_ERROR);
 
-            NL_TEST_ASSERT_SUCCESS(inSuite, fabricTable.SignWithOpKeypair(fabricIndex, ByteSpan{ message }, sig));
-            NL_TEST_ASSERT_SUCCESS(inSuite, nocPubKey.ECDSA_validate_msg_signature(&message[0], sizeof(message), sig));
+            EXPECT_EQ(fabricTable.SignWithOpKeypair(fabricIndex, ByteSpan{ message }, sig), CHIP_NO_ERROR);
+            EXPECT_EQ(nocPubKey.ECDSA_validate_msg_signature(&message[0], sizeof(message), sig), CHIP_NO_ERROR);
         }
 
         // Validate iterator sees the committed update
@@ -913,28 +909,28 @@
                 ++numFabricsIterated;
                 if (iterFabricInfo.GetFabricIndex() == 1)
                 {
-                    NL_TEST_ASSERT(inSuite, iterFabricInfo.GetNodeId() == 55);
-                    NL_TEST_ASSERT(inSuite, iterFabricInfo.GetFabricId() == 11);
+                    EXPECT_EQ(iterFabricInfo.GetNodeId(), 55u);
+                    EXPECT_EQ(iterFabricInfo.GetFabricId(), 11u);
                     saw1 = true;
                 }
                 if (iterFabricInfo.GetFabricIndex() == 2)
                 {
-                    NL_TEST_ASSERT(inSuite, iterFabricInfo.GetNodeId() == 1000);
-                    NL_TEST_ASSERT(inSuite, iterFabricInfo.GetFabricId() == 44);
+                    EXPECT_EQ(iterFabricInfo.GetNodeId(), 1000u);
+                    EXPECT_EQ(iterFabricInfo.GetFabricId(), 44u);
                     saw2 = true;
                 }
             }
 
-            NL_TEST_ASSERT(inSuite, numFabricsIterated == 2);
-            NL_TEST_ASSERT(inSuite, saw1 == true);
-            NL_TEST_ASSERT(inSuite, saw2 == true);
+            EXPECT_EQ(numFabricsIterated, 2u);
+            EXPECT_TRUE(saw1);
+            EXPECT_TRUE(saw2);
         }
 
         // Next fabric index has stayed the same.
         {
             FabricIndex nextFabricIndex = kUndefinedFabricIndex;
-            NL_TEST_ASSERT(inSuite, fabricTable.PeekFabricIndexForNextAddition(nextFabricIndex) == CHIP_NO_ERROR);
-            NL_TEST_ASSERT_EQUALS(inSuite, nextFabricIndex, 3);
+            EXPECT_EQ(fabricTable.PeekFabricIndexForNextAddition(nextFabricIndex), CHIP_NO_ERROR);
+            EXPECT_EQ(nextFabricIndex, 3);
         }
     }
 
@@ -942,31 +938,28 @@
 
     // Sequence 4: Rename fabric index 2, applies immediately when nothing pending
     {
-        NL_TEST_ASSERT_EQUALS(inSuite, fabricTable.FabricCount(), 2);
-        NL_TEST_ASSERT_SUCCESS(inSuite, fabricTable.SetFabricLabel(2, "roboto"_span));
-        NL_TEST_ASSERT_EQUALS(inSuite, fabricTable.FabricCount(), 2);
+        EXPECT_EQ(fabricTable.FabricCount(), 2);
+        EXPECT_EQ(fabricTable.SetFabricLabel(2, "roboto"_span), CHIP_NO_ERROR);
+        EXPECT_EQ(fabricTable.FabricCount(), 2);
 
-        NL_TEST_ASSERT_EQUALS(inSuite, storage.GetNumKeys(), numStorageAfterUpdate); // Number of keys unchanged
+        EXPECT_EQ(storage.GetNumKeys(), numStorageAfterUpdate); // Number of keys unchanged
 
         // Validate basic contents
         {
             const auto * fabricInfo = fabricTable.FindFabricWithIndex(2);
-            NL_TEST_ASSERT(inSuite, fabricInfo != nullptr);
-            if (fabricInfo != nullptr)
-            {
-                NL_TEST_ASSERT(inSuite, fabricInfo->GetFabricIndex() == 2);
-                NL_TEST_ASSERT(inSuite, fabricInfo->GetNodeId() == 1000);
-                NL_TEST_ASSERT(inSuite, fabricInfo->GetFabricId() == 44);
-                NL_TEST_ASSERT(inSuite, fabricInfo->GetVendorId() == kVendorId);
-                NL_TEST_ASSERT(inSuite, fabricInfo->GetFabricLabel().data_equal(CharSpan{ "roboto", strlen("roboto") }));
-            }
+            ASSERT_NE(fabricInfo, nullptr);
+            EXPECT_EQ(fabricInfo->GetFabricIndex(), 2);
+            EXPECT_EQ(fabricInfo->GetNodeId(), 1000u);
+            EXPECT_EQ(fabricInfo->GetFabricId(), 44u);
+            EXPECT_EQ(fabricInfo->GetVendorId(), kVendorId);
+            EXPECT_TRUE(fabricInfo->GetFabricLabel().data_equal(CharSpan{ "roboto", strlen("roboto") }));
         }
 
         // Next fabric index has stayed the same.
         {
             FabricIndex nextFabricIndex = kUndefinedFabricIndex;
-            NL_TEST_ASSERT(inSuite, fabricTable.PeekFabricIndexForNextAddition(nextFabricIndex) == CHIP_NO_ERROR);
-            NL_TEST_ASSERT_EQUALS(inSuite, nextFabricIndex, 3);
+            EXPECT_EQ(fabricTable.PeekFabricIndexForNextAddition(nextFabricIndex), CHIP_NO_ERROR);
+            EXPECT_EQ(nextFabricIndex, 3);
         }
     }
 
@@ -974,52 +967,48 @@
     {
         // Remove the fabric: no commit needed
         {
-            NL_TEST_ASSERT_EQUALS(inSuite, fabricTable.FabricCount(), 2);
-            NL_TEST_ASSERT_SUCCESS(inSuite, fabricTable.Delete(1));
-            NL_TEST_ASSERT_EQUALS(inSuite, fabricTable.FabricCount(), 1);
+            EXPECT_EQ(fabricTable.FabricCount(), 2);
+            EXPECT_EQ(fabricTable.Delete(1), CHIP_NO_ERROR);
+            EXPECT_EQ(fabricTable.FabricCount(), 1);
 
-            NL_TEST_ASSERT_EQUALS(inSuite, storage.GetNumKeys(), (numStorageAfterUpdate - 3)); // Deleted NOC, RCAC, Metadata
+            EXPECT_EQ(storage.GetNumKeys(), (numStorageAfterUpdate - 3)); // Deleted NOC, RCAC, Metadata
         }
 
         // Next fabric index has stayed the same.
         {
             FabricIndex nextFabricIndex = kUndefinedFabricIndex;
-            NL_TEST_ASSERT(inSuite, fabricTable.PeekFabricIndexForNextAddition(nextFabricIndex) == CHIP_NO_ERROR);
-            NL_TEST_ASSERT_EQUALS(inSuite, nextFabricIndex, 3);
+            EXPECT_EQ(fabricTable.PeekFabricIndexForNextAddition(nextFabricIndex), CHIP_NO_ERROR);
+            EXPECT_EQ(nextFabricIndex, 3);
         }
 
         // Validate contents of Fabric Index 2 is still OK
         const auto * fabricInfo = fabricTable.FindFabricWithIndex(2);
-        NL_TEST_ASSERT(inSuite, fabricInfo != nullptr);
-        if (fabricInfo != nullptr)
-        {
-            NL_TEST_ASSERT(inSuite, fabricInfo->GetFabricIndex() == 2);
-            NL_TEST_ASSERT(inSuite, fabricInfo->GetNodeId() == 1000);
-            NL_TEST_ASSERT(inSuite, fabricInfo->GetFabricId() == 44);
-            NL_TEST_ASSERT(inSuite, fabricInfo->GetVendorId() == kVendorId);
-            NL_TEST_ASSERT(inSuite, fabricInfo->GetFabricLabel().data_equal(CharSpan{ "roboto", strlen("roboto") }));
+        ASSERT_NE(fabricInfo, nullptr);
+        EXPECT_EQ(fabricInfo->GetFabricIndex(), 2);
+        EXPECT_EQ(fabricInfo->GetNodeId(), 1000u);
+        EXPECT_EQ(fabricInfo->GetFabricId(), 44u);
+        EXPECT_EQ(fabricInfo->GetVendorId(), kVendorId);
+        EXPECT_TRUE(fabricInfo->GetFabricLabel().data_equal(CharSpan{ "roboto", strlen("roboto") }));
 
-            Crypto::P256PublicKey rootPublicKeyOfFabric;
-            NL_TEST_ASSERT_SUCCESS(inSuite, fabricTable.FetchRootPubkey(2, rootPublicKeyOfFabric));
-        }
+        Crypto::P256PublicKey rootPublicKeyOfFabric;
+        EXPECT_EQ(fabricTable.FetchRootPubkey(2, rootPublicKeyOfFabric), CHIP_NO_ERROR);
 
         // Validate that fabric has the correct operational key by verifying a signature
         {
             uint8_t nocBuf[Credentials::kMaxCHIPCertLength];
             MutableByteSpan nocSpan{ nocBuf };
-            NL_TEST_ASSERT_SUCCESS(inSuite, fabricTable.FetchNOCCert(2, nocSpan));
+            EXPECT_EQ(fabricTable.FetchNOCCert(2, nocSpan), CHIP_NO_ERROR);
 
             Credentials::ChipCertificateSet certificates;
-            NL_TEST_ASSERT_SUCCESS(inSuite, certificates.Init(1));
-            NL_TEST_ASSERT_SUCCESS(inSuite,
-                                   certificates.LoadCert(nocSpan, BitFlags<CertDecodeFlags>(CertDecodeFlags::kIsTrustAnchor)));
+            EXPECT_EQ(certificates.Init(1), CHIP_NO_ERROR);
+            EXPECT_EQ(certificates.LoadCert(nocSpan, BitFlags<CertDecodeFlags>(CertDecodeFlags::kIsTrustAnchor)), CHIP_NO_ERROR);
             Crypto::P256PublicKey nocPubKey(certificates.GetCertSet()[0].mPublicKey);
 
             Crypto::P256ECDSASignature sig;
             uint8_t message[] = { 'm', 's', 'g' };
 
-            NL_TEST_ASSERT_SUCCESS(inSuite, fabricTable.SignWithOpKeypair(2, ByteSpan{ message }, sig));
-            NL_TEST_ASSERT_SUCCESS(inSuite, nocPubKey.ECDSA_validate_msg_signature(&message[0], sizeof(message), sig));
+            EXPECT_EQ(fabricTable.SignWithOpKeypair(2, ByteSpan{ message }, sig), CHIP_NO_ERROR);
+            EXPECT_EQ(nocPubKey.ECDSA_validate_msg_signature(&message[0], sizeof(message), sig), CHIP_NO_ERROR);
         }
 
         // Validate iterator only sees the remaining fabric
@@ -1036,34 +1025,34 @@
                 }
                 if (iterFabricInfo.GetFabricIndex() == 2)
                 {
-                    NL_TEST_ASSERT(inSuite, iterFabricInfo.GetNodeId() == 1000);
-                    NL_TEST_ASSERT(inSuite, iterFabricInfo.GetFabricId() == 44);
+                    EXPECT_EQ(iterFabricInfo.GetNodeId(), 1000u);
+                    EXPECT_EQ(iterFabricInfo.GetFabricId(), 44u);
                     saw2 = true;
                 }
             }
 
-            NL_TEST_ASSERT(inSuite, numFabricsIterated == 1);
-            NL_TEST_ASSERT(inSuite, saw1 == false);
-            NL_TEST_ASSERT(inSuite, saw2 == true);
+            EXPECT_EQ(numFabricsIterated, 1u);
+            EXPECT_FALSE(saw1);
+            EXPECT_TRUE(saw2);
         }
     }
 }
 
-void TestAddMultipleSameRootDifferentFabricId(nlTestSuite * inSuite, void * inContext)
+TEST_F(TestFabricTable, TestAddMultipleSameRootDifferentFabricId)
 {
     Credentials::TestOnlyLocalCertificateAuthority fabricCertAuthority;
 
     chip::TestPersistentStorageDelegate storage;
-    NL_TEST_ASSERT(inSuite, fabricCertAuthority.Init().IsSuccess());
+    EXPECT_TRUE(fabricCertAuthority.Init().IsSuccess());
 
     constexpr uint16_t kVendorId = 0xFFF1u;
 
     // Initialize a fabric table.
     ScopedFabricTable fabricTableHolder;
-    NL_TEST_ASSERT(inSuite, fabricTableHolder.Init(&storage) == CHIP_NO_ERROR);
+    EXPECT_EQ(fabricTableHolder.Init(&storage), CHIP_NO_ERROR);
     FabricTable & fabricTable = fabricTableHolder.GetFabricTable();
 
-    NL_TEST_ASSERT_EQUALS(inSuite, fabricTable.FabricCount(), 0);
+    EXPECT_EQ(fabricTable.FabricCount(), 0);
 
     uint8_t rcac1Buf[kMaxCHIPCertLength];
     MutableByteSpan rcac1Span{ rcac1Buf };
@@ -1075,10 +1064,9 @@
 
         uint8_t csrBuf[chip::Crypto::kMIN_CSR_Buffer_Size];
         MutableByteSpan csrSpan{ csrBuf };
-        NL_TEST_ASSERT_SUCCESS(inSuite, fabricTable.AllocatePendingOperationalKey(chip::NullOptional, csrSpan));
+        EXPECT_EQ(fabricTable.AllocatePendingOperationalKey(chip::NullOptional, csrSpan), CHIP_NO_ERROR);
 
-        NL_TEST_ASSERT_SUCCESS(inSuite,
-                               fabricCertAuthority.SetIncludeIcac(true).GenerateNocChain(fabricId, nodeId, csrSpan).GetStatus());
+        EXPECT_EQ(fabricCertAuthority.SetIncludeIcac(true).GenerateNocChain(fabricId, nodeId, csrSpan).GetStatus(), CHIP_NO_ERROR);
         ByteSpan rcac = fabricCertAuthority.GetRcac();
         // Keep a copy for second scope check
         CopySpanToMutableSpan(rcac, rcac1Span);
@@ -1086,30 +1074,26 @@
         ByteSpan icac = fabricCertAuthority.GetIcac();
         ByteSpan noc  = fabricCertAuthority.GetNoc();
 
-        NL_TEST_ASSERT_EQUALS(inSuite, fabricTable.FabricCount(), 0);
-        NL_TEST_ASSERT_SUCCESS(inSuite, fabricTable.AddNewPendingTrustedRootCert(rcac));
+        EXPECT_EQ(fabricTable.FabricCount(), 0);
+        EXPECT_EQ(fabricTable.AddNewPendingTrustedRootCert(rcac), CHIP_NO_ERROR);
         FabricIndex newFabricIndex = kUndefinedFabricIndex;
-        NL_TEST_ASSERT_SUCCESS(inSuite,
-                               fabricTable.AddNewPendingFabricWithOperationalKeystore(noc, icac, kVendorId, &newFabricIndex));
-        NL_TEST_ASSERT_EQUALS(inSuite, fabricTable.FabricCount(), 1);
-        NL_TEST_ASSERT(inSuite, newFabricIndex == 1);
+        EXPECT_EQ(fabricTable.AddNewPendingFabricWithOperationalKeystore(noc, icac, kVendorId, &newFabricIndex), CHIP_NO_ERROR);
+        EXPECT_EQ(fabricTable.FabricCount(), 1);
+        EXPECT_EQ(newFabricIndex, 1);
 
-        NL_TEST_ASSERT_SUCCESS(inSuite, fabricTable.CommitPendingFabricData());
+        EXPECT_EQ(fabricTable.CommitPendingFabricData(), CHIP_NO_ERROR);
 
         // Validate contents
         const auto * fabricInfo = fabricTable.FindFabricWithIndex(1);
-        NL_TEST_ASSERT(inSuite, fabricInfo != nullptr);
-        if (fabricInfo != nullptr)
-        {
-            NL_TEST_ASSERT(inSuite, fabricInfo->GetFabricIndex() == 1);
-            NL_TEST_ASSERT(inSuite, fabricInfo->GetNodeId() == 55);
-            NL_TEST_ASSERT(inSuite, fabricInfo->GetFabricId() == 1111);
-            NL_TEST_ASSERT(inSuite, fabricInfo->GetVendorId() == kVendorId);
-            NL_TEST_ASSERT(inSuite, fabricInfo->GetFabricLabel().size() == 0);
-        }
+        ASSERT_NE(fabricInfo, nullptr);
+        EXPECT_EQ(fabricInfo->GetFabricIndex(), 1);
+        EXPECT_EQ(fabricInfo->GetNodeId(), 55u);
+        EXPECT_EQ(fabricInfo->GetFabricId(), 1111u);
+        EXPECT_EQ(fabricInfo->GetVendorId(), kVendorId);
+        EXPECT_EQ(fabricInfo->GetFabricLabel().size(), 0u);
     }
     size_t numStorageKeysAfterFirstAdd = storage.GetNumKeys();
-    NL_TEST_ASSERT(inSuite, numStorageKeysAfterFirstAdd == 7); // Metadata, index, 3 certs, 1 opkey, last known good time
+    EXPECT_EQ(numStorageKeysAfterFirstAdd, 7u); // Metadata, index, 3 certs, 1 opkey, last known good time
 
     // Second scope: add FabricID 2222, node ID 66, same root as first
     {
@@ -1118,59 +1102,54 @@
 
         uint8_t csrBuf[chip::Crypto::kMIN_CSR_Buffer_Size];
         MutableByteSpan csrSpan{ csrBuf };
-        NL_TEST_ASSERT_SUCCESS(inSuite, fabricTable.AllocatePendingOperationalKey(chip::NullOptional, csrSpan));
+        EXPECT_EQ(fabricTable.AllocatePendingOperationalKey(chip::NullOptional, csrSpan), CHIP_NO_ERROR);
 
-        NL_TEST_ASSERT_SUCCESS(inSuite,
-                               fabricCertAuthority.SetIncludeIcac(true).GenerateNocChain(fabricId, nodeId, csrSpan).GetStatus());
+        EXPECT_EQ(fabricCertAuthority.SetIncludeIcac(true).GenerateNocChain(fabricId, nodeId, csrSpan).GetStatus(), CHIP_NO_ERROR);
         ByteSpan rcac2 = fabricCertAuthority.GetRcac();
-        NL_TEST_ASSERT(inSuite, rcac2.data_equal(rcac1Span));
+        EXPECT_TRUE(rcac2.data_equal(rcac1Span));
 
         ByteSpan icac = fabricCertAuthority.GetIcac();
         ByteSpan noc  = fabricCertAuthority.GetNoc();
 
-        NL_TEST_ASSERT_EQUALS(inSuite, fabricTable.FabricCount(), 1);
-        NL_TEST_ASSERT_SUCCESS(inSuite, fabricTable.AddNewPendingTrustedRootCert(rcac2));
+        EXPECT_EQ(fabricTable.FabricCount(), 1);
+        EXPECT_EQ(fabricTable.AddNewPendingTrustedRootCert(rcac2), CHIP_NO_ERROR);
         FabricIndex newFabricIndex = kUndefinedFabricIndex;
-        NL_TEST_ASSERT_SUCCESS(inSuite,
-                               fabricTable.AddNewPendingFabricWithOperationalKeystore(noc, icac, kVendorId, &newFabricIndex));
-        NL_TEST_ASSERT_EQUALS(inSuite, fabricTable.FabricCount(), 2);
-        NL_TEST_ASSERT(inSuite, newFabricIndex == 2);
+        EXPECT_EQ(fabricTable.AddNewPendingFabricWithOperationalKeystore(noc, icac, kVendorId, &newFabricIndex), CHIP_NO_ERROR);
+        EXPECT_EQ(fabricTable.FabricCount(), 2);
+        EXPECT_EQ(newFabricIndex, 2);
 
-        NL_TEST_ASSERT_SUCCESS(inSuite, fabricTable.CommitPendingFabricData());
+        EXPECT_EQ(fabricTable.CommitPendingFabricData(), CHIP_NO_ERROR);
 
         // Validate contents
         const auto * fabricInfo = fabricTable.FindFabricWithIndex(2);
-        NL_TEST_ASSERT(inSuite, fabricInfo != nullptr);
-        if (fabricInfo != nullptr)
-        {
-            NL_TEST_ASSERT(inSuite, fabricInfo->GetFabricIndex() == 2);
-            NL_TEST_ASSERT(inSuite, fabricInfo->GetNodeId() == 66);
-            NL_TEST_ASSERT(inSuite, fabricInfo->GetFabricId() == 2222);
-            NL_TEST_ASSERT(inSuite, fabricInfo->GetVendorId() == kVendorId);
-            NL_TEST_ASSERT(inSuite, fabricInfo->GetFabricLabel().size() == 0);
-        }
+        ASSERT_NE(fabricInfo, nullptr);
+        EXPECT_EQ(fabricInfo->GetFabricIndex(), 2);
+        EXPECT_EQ(fabricInfo->GetNodeId(), 66u);
+        EXPECT_EQ(fabricInfo->GetFabricId(), 2222u);
+        EXPECT_EQ(fabricInfo->GetVendorId(), kVendorId);
+        EXPECT_EQ(fabricInfo->GetFabricLabel().size(), 0u);
     }
     size_t numStorageKeysAfterSecondAdd = storage.GetNumKeys();
-    NL_TEST_ASSERT(inSuite, numStorageKeysAfterSecondAdd == (numStorageKeysAfterFirstAdd + 5)); // Add 3 certs, 1 metadata, 1 opkey
+    EXPECT_EQ(numStorageKeysAfterSecondAdd, (numStorageKeysAfterFirstAdd + 5)); // Add 3 certs, 1 metadata, 1 opkey
 }
 
-void TestAddMultipleSameFabricIdDifferentRoot(nlTestSuite * inSuite, void * inContext)
+TEST_F(TestFabricTable, TestAddMultipleSameFabricIdDifferentRoot)
 {
     Credentials::TestOnlyLocalCertificateAuthority fabricCertAuthority1;
     Credentials::TestOnlyLocalCertificateAuthority fabricCertAuthority2;
 
     chip::TestPersistentStorageDelegate storage;
-    NL_TEST_ASSERT(inSuite, fabricCertAuthority1.Init().IsSuccess());
-    NL_TEST_ASSERT(inSuite, fabricCertAuthority2.Init().IsSuccess());
+    EXPECT_TRUE(fabricCertAuthority1.Init().IsSuccess());
+    EXPECT_TRUE(fabricCertAuthority2.Init().IsSuccess());
 
     constexpr uint16_t kVendorId = 0xFFF1u;
 
     // Initialize a fabric table.
     ScopedFabricTable fabricTableHolder;
-    NL_TEST_ASSERT(inSuite, fabricTableHolder.Init(&storage) == CHIP_NO_ERROR);
+    EXPECT_EQ(fabricTableHolder.Init(&storage), CHIP_NO_ERROR);
     FabricTable & fabricTable = fabricTableHolder.GetFabricTable();
 
-    NL_TEST_ASSERT_EQUALS(inSuite, fabricTable.FabricCount(), 0);
+    EXPECT_EQ(fabricTable.FabricCount(), 0);
 
     uint8_t rcac1Buf[kMaxCHIPCertLength];
     MutableByteSpan rcac1Span{ rcac1Buf };
@@ -1182,10 +1161,9 @@
 
         uint8_t csrBuf[chip::Crypto::kMIN_CSR_Buffer_Size];
         MutableByteSpan csrSpan{ csrBuf };
-        NL_TEST_ASSERT_SUCCESS(inSuite, fabricTable.AllocatePendingOperationalKey(chip::NullOptional, csrSpan));
+        EXPECT_EQ(fabricTable.AllocatePendingOperationalKey(chip::NullOptional, csrSpan), CHIP_NO_ERROR);
 
-        NL_TEST_ASSERT_SUCCESS(inSuite,
-                               fabricCertAuthority1.SetIncludeIcac(true).GenerateNocChain(fabricId, nodeId, csrSpan).GetStatus());
+        EXPECT_EQ(fabricCertAuthority1.SetIncludeIcac(true).GenerateNocChain(fabricId, nodeId, csrSpan).GetStatus(), CHIP_NO_ERROR);
         ByteSpan rcac = fabricCertAuthority1.GetRcac();
         // Keep a copy for second scope check
         CopySpanToMutableSpan(rcac, rcac1Span);
@@ -1193,30 +1171,26 @@
         ByteSpan icac = fabricCertAuthority1.GetIcac();
         ByteSpan noc  = fabricCertAuthority1.GetNoc();
 
-        NL_TEST_ASSERT_EQUALS(inSuite, fabricTable.FabricCount(), 0);
-        NL_TEST_ASSERT_SUCCESS(inSuite, fabricTable.AddNewPendingTrustedRootCert(rcac));
+        EXPECT_EQ(fabricTable.FabricCount(), 0);
+        EXPECT_EQ(fabricTable.AddNewPendingTrustedRootCert(rcac), CHIP_NO_ERROR);
         FabricIndex newFabricIndex = kUndefinedFabricIndex;
-        NL_TEST_ASSERT_SUCCESS(inSuite,
-                               fabricTable.AddNewPendingFabricWithOperationalKeystore(noc, icac, kVendorId, &newFabricIndex));
-        NL_TEST_ASSERT_EQUALS(inSuite, fabricTable.FabricCount(), 1);
-        NL_TEST_ASSERT(inSuite, newFabricIndex == 1);
+        EXPECT_EQ(fabricTable.AddNewPendingFabricWithOperationalKeystore(noc, icac, kVendorId, &newFabricIndex), CHIP_NO_ERROR);
+        EXPECT_EQ(fabricTable.FabricCount(), 1);
+        EXPECT_EQ(newFabricIndex, 1);
 
-        NL_TEST_ASSERT_SUCCESS(inSuite, fabricTable.CommitPendingFabricData());
+        EXPECT_EQ(fabricTable.CommitPendingFabricData(), CHIP_NO_ERROR);
 
         // Validate contents
         const auto * fabricInfo = fabricTable.FindFabricWithIndex(1);
-        NL_TEST_ASSERT(inSuite, fabricInfo != nullptr);
-        if (fabricInfo != nullptr)
-        {
-            NL_TEST_ASSERT(inSuite, fabricInfo->GetFabricIndex() == 1);
-            NL_TEST_ASSERT(inSuite, fabricInfo->GetNodeId() == 55);
-            NL_TEST_ASSERT(inSuite, fabricInfo->GetFabricId() == 1111);
-            NL_TEST_ASSERT(inSuite, fabricInfo->GetVendorId() == kVendorId);
-            NL_TEST_ASSERT(inSuite, fabricInfo->GetFabricLabel().size() == 0);
-        }
+        ASSERT_NE(fabricInfo, nullptr);
+        EXPECT_EQ(fabricInfo->GetFabricIndex(), 1);
+        EXPECT_EQ(fabricInfo->GetNodeId(), 55u);
+        EXPECT_EQ(fabricInfo->GetFabricId(), 1111u);
+        EXPECT_EQ(fabricInfo->GetVendorId(), kVendorId);
+        EXPECT_EQ(fabricInfo->GetFabricLabel().size(), 0u);
     }
     size_t numStorageKeysAfterFirstAdd = storage.GetNumKeys();
-    NL_TEST_ASSERT(inSuite, numStorageKeysAfterFirstAdd == 7); // Metadata, index, 3 certs, 1 opkey, last known good time
+    EXPECT_EQ(numStorageKeysAfterFirstAdd, 7u); // Metadata, index, 3 certs, 1 opkey, last known good time
 
     // Second scope: add FabricID 1111, node ID 66, different root from first
     {
@@ -1225,43 +1199,38 @@
 
         uint8_t csrBuf[chip::Crypto::kMIN_CSR_Buffer_Size];
         MutableByteSpan csrSpan{ csrBuf };
-        NL_TEST_ASSERT_SUCCESS(inSuite, fabricTable.AllocatePendingOperationalKey(chip::NullOptional, csrSpan));
+        EXPECT_EQ(fabricTable.AllocatePendingOperationalKey(chip::NullOptional, csrSpan), CHIP_NO_ERROR);
 
-        NL_TEST_ASSERT_SUCCESS(inSuite,
-                               fabricCertAuthority2.SetIncludeIcac(true).GenerateNocChain(fabricId, nodeId, csrSpan).GetStatus());
+        EXPECT_EQ(fabricCertAuthority2.SetIncludeIcac(true).GenerateNocChain(fabricId, nodeId, csrSpan).GetStatus(), CHIP_NO_ERROR);
         ByteSpan rcac2 = fabricCertAuthority2.GetRcac();
-        NL_TEST_ASSERT(inSuite, !rcac2.data_equal(rcac1Span));
+        EXPECT_FALSE(rcac2.data_equal(rcac1Span));
 
         ByteSpan icac = fabricCertAuthority2.GetIcac();
         ByteSpan noc  = fabricCertAuthority2.GetNoc();
 
-        NL_TEST_ASSERT_EQUALS(inSuite, fabricTable.FabricCount(), 1);
-        NL_TEST_ASSERT_SUCCESS(inSuite, fabricTable.AddNewPendingTrustedRootCert(rcac2));
+        EXPECT_EQ(fabricTable.FabricCount(), 1);
+        EXPECT_EQ(fabricTable.AddNewPendingTrustedRootCert(rcac2), CHIP_NO_ERROR);
         FabricIndex newFabricIndex = kUndefinedFabricIndex;
-        NL_TEST_ASSERT_SUCCESS(inSuite,
-                               fabricTable.AddNewPendingFabricWithOperationalKeystore(noc, icac, kVendorId, &newFabricIndex));
-        NL_TEST_ASSERT_EQUALS(inSuite, fabricTable.FabricCount(), 2);
-        NL_TEST_ASSERT(inSuite, newFabricIndex == 2);
+        EXPECT_EQ(fabricTable.AddNewPendingFabricWithOperationalKeystore(noc, icac, kVendorId, &newFabricIndex), CHIP_NO_ERROR);
+        EXPECT_EQ(fabricTable.FabricCount(), 2);
+        EXPECT_EQ(newFabricIndex, 2);
 
-        NL_TEST_ASSERT_SUCCESS(inSuite, fabricTable.CommitPendingFabricData());
+        EXPECT_EQ(fabricTable.CommitPendingFabricData(), CHIP_NO_ERROR);
 
         // Validate contents
         const auto * fabricInfo = fabricTable.FindFabricWithIndex(2);
-        NL_TEST_ASSERT(inSuite, fabricInfo != nullptr);
-        if (fabricInfo != nullptr)
-        {
-            NL_TEST_ASSERT(inSuite, fabricInfo->GetFabricIndex() == 2);
-            NL_TEST_ASSERT(inSuite, fabricInfo->GetNodeId() == 66);
-            NL_TEST_ASSERT(inSuite, fabricInfo->GetFabricId() == 1111);
-            NL_TEST_ASSERT(inSuite, fabricInfo->GetVendorId() == kVendorId);
-            NL_TEST_ASSERT(inSuite, fabricInfo->GetFabricLabel().size() == 0);
-        }
+        ASSERT_NE(fabricInfo, nullptr);
+        EXPECT_EQ(fabricInfo->GetFabricIndex(), 2);
+        EXPECT_EQ(fabricInfo->GetNodeId(), 66u);
+        EXPECT_EQ(fabricInfo->GetFabricId(), 1111u);
+        EXPECT_EQ(fabricInfo->GetVendorId(), kVendorId);
+        EXPECT_EQ(fabricInfo->GetFabricLabel().size(), 0u);
     }
     size_t numStorageKeysAfterSecondAdd = storage.GetNumKeys();
-    NL_TEST_ASSERT(inSuite, numStorageKeysAfterSecondAdd == (numStorageKeysAfterFirstAdd + 5)); // Add 3 certs, 1 metadata, 1 opkey
+    EXPECT_EQ(numStorageKeysAfterSecondAdd, (numStorageKeysAfterFirstAdd + 5)); // Add 3 certs, 1 metadata, 1 opkey
 }
 
-void TestPersistence(nlTestSuite * inSuite, void * inContext)
+TEST_F(TestFabricTable, TestPersistence)
 {
     /**
      *
@@ -1287,7 +1256,7 @@
 
     chip::TestPersistentStorageDelegate storage;
 
-    NL_TEST_ASSERT(inSuite, fabricCertAuthority.Init().IsSuccess());
+    EXPECT_TRUE(fabricCertAuthority.Init().IsSuccess());
 
     constexpr uint16_t kVendorId = 0xFFF1u;
 
@@ -1295,10 +1264,10 @@
     {
         // Initialize a FabricTable
         ScopedFabricTable fabricTableHolder;
-        NL_TEST_ASSERT(inSuite, fabricTableHolder.Init(&storage) == CHIP_NO_ERROR);
+        EXPECT_EQ(fabricTableHolder.Init(&storage), CHIP_NO_ERROR);
         FabricTable & fabricTable = fabricTableHolder.GetFabricTable();
 
-        NL_TEST_ASSERT_EQUALS(inSuite, fabricTable.FabricCount(), 0);
+        EXPECT_EQ(fabricTable.FabricCount(), 0);
 
         // Add Fabric 1111 Node Id 55
         {
@@ -1307,55 +1276,50 @@
 
             uint8_t csrBuf[chip::Crypto::kMIN_CSR_Buffer_Size];
             MutableByteSpan csrSpan{ csrBuf };
-            NL_TEST_ASSERT_SUCCESS(inSuite, fabricTable.AllocatePendingOperationalKey(chip::NullOptional, csrSpan));
+            EXPECT_EQ(fabricTable.AllocatePendingOperationalKey(chip::NullOptional, csrSpan), CHIP_NO_ERROR);
 
-            NL_TEST_ASSERT_SUCCESS(
-                inSuite, fabricCertAuthority.SetIncludeIcac(true).GenerateNocChain(fabricId, nodeId, csrSpan).GetStatus());
+            EXPECT_EQ(fabricCertAuthority.SetIncludeIcac(true).GenerateNocChain(fabricId, nodeId, csrSpan).GetStatus(),
+                      CHIP_NO_ERROR);
             ByteSpan rcac = fabricCertAuthority.GetRcac();
             ByteSpan icac = fabricCertAuthority.GetIcac();
             ByteSpan noc  = fabricCertAuthority.GetNoc();
 
-            NL_TEST_ASSERT_EQUALS(inSuite, fabricTable.FabricCount(), 0);
-            NL_TEST_ASSERT_SUCCESS(inSuite, fabricTable.AddNewPendingTrustedRootCert(rcac));
+            EXPECT_EQ(fabricTable.FabricCount(), 0);
+            EXPECT_EQ(fabricTable.AddNewPendingTrustedRootCert(rcac), CHIP_NO_ERROR);
             FabricIndex newFabricIndex = kUndefinedFabricIndex;
-            NL_TEST_ASSERT_SUCCESS(inSuite,
-                                   fabricTable.AddNewPendingFabricWithOperationalKeystore(noc, icac, kVendorId, &newFabricIndex));
-            NL_TEST_ASSERT_EQUALS(inSuite, fabricTable.FabricCount(), 1);
-            NL_TEST_ASSERT(inSuite, newFabricIndex == 1);
+            EXPECT_EQ(fabricTable.AddNewPendingFabricWithOperationalKeystore(noc, icac, kVendorId, &newFabricIndex), CHIP_NO_ERROR);
+            EXPECT_EQ(fabricTable.FabricCount(), 1);
+            EXPECT_EQ(newFabricIndex, 1);
 
-            NL_TEST_ASSERT_SUCCESS(inSuite, fabricTable.CommitPendingFabricData());
+            EXPECT_EQ(fabricTable.CommitPendingFabricData(), CHIP_NO_ERROR);
 
             // Validate contents
             const auto * fabricInfo = fabricTable.FindFabricWithIndex(1);
-            NL_TEST_ASSERT(inSuite, fabricInfo != nullptr);
-            if (fabricInfo != nullptr)
-            {
-                Credentials::ChipCertificateSet certificates;
-                NL_TEST_ASSERT_SUCCESS(inSuite, certificates.Init(1));
-                NL_TEST_ASSERT_SUCCESS(inSuite,
-                                       certificates.LoadCert(rcac, BitFlags<CertDecodeFlags>(CertDecodeFlags::kIsTrustAnchor)));
-                Crypto::P256PublicKey rcacPublicKey(certificates.GetCertSet()[0].mPublicKey);
+            ASSERT_NE(fabricInfo, nullptr);
+            Credentials::ChipCertificateSet certificates;
+            EXPECT_EQ(certificates.Init(1), CHIP_NO_ERROR);
+            EXPECT_EQ(certificates.LoadCert(rcac, BitFlags<CertDecodeFlags>(CertDecodeFlags::kIsTrustAnchor)), CHIP_NO_ERROR);
+            Crypto::P256PublicKey rcacPublicKey(certificates.GetCertSet()[0].mPublicKey);
 
-                NL_TEST_ASSERT(inSuite, fabricInfo->GetFabricIndex() == 1);
-                NL_TEST_ASSERT(inSuite, fabricInfo->GetNodeId() == 55);
-                NL_TEST_ASSERT(inSuite, fabricInfo->GetFabricId() == 1111);
-                NL_TEST_ASSERT(inSuite, fabricInfo->GetVendorId() == kVendorId);
-                NL_TEST_ASSERT(inSuite, fabricInfo->GetFabricLabel().size() == 0);
+            EXPECT_EQ(fabricInfo->GetFabricIndex(), 1);
+            EXPECT_EQ(fabricInfo->GetNodeId(), 55u);
+            EXPECT_EQ(fabricInfo->GetFabricId(), 1111u);
+            EXPECT_EQ(fabricInfo->GetVendorId(), kVendorId);
+            EXPECT_EQ(fabricInfo->GetFabricLabel().size(), 0u);
 
-                Crypto::P256PublicKey rootPublicKeyOfFabric;
-                NL_TEST_ASSERT_SUCCESS(inSuite, fabricTable.FetchRootPubkey(newFabricIndex, rootPublicKeyOfFabric));
-                NL_TEST_ASSERT(inSuite, rootPublicKeyOfFabric.Matches(rcacPublicKey));
-            }
+            Crypto::P256PublicKey rootPublicKeyOfFabric;
+            EXPECT_EQ(fabricTable.FetchRootPubkey(newFabricIndex, rootPublicKeyOfFabric), CHIP_NO_ERROR);
+            EXPECT_TRUE(rootPublicKeyOfFabric.Matches(rcacPublicKey));
 
             // Validate that fabric has the correct operational key by verifying a signature
             {
                 Crypto::P256ECDSASignature sig;
                 uint8_t message[] = { 'm', 's', 'g' };
 
-                NL_TEST_ASSERT_SUCCESS(inSuite, VerifyCertificateSigningRequest(csrSpan.data(), csrSpan.size(), fIdx1PublicKey));
+                EXPECT_EQ(VerifyCertificateSigningRequest(csrSpan.data(), csrSpan.size(), fIdx1PublicKey), CHIP_NO_ERROR);
 
-                NL_TEST_ASSERT_SUCCESS(inSuite, fabricTable.SignWithOpKeypair(newFabricIndex, ByteSpan{ message }, sig));
-                NL_TEST_ASSERT_SUCCESS(inSuite, fIdx1PublicKey.ECDSA_validate_msg_signature(&message[0], sizeof(message), sig));
+                EXPECT_EQ(fabricTable.SignWithOpKeypair(newFabricIndex, ByteSpan{ message }, sig), CHIP_NO_ERROR);
+                EXPECT_EQ(fIdx1PublicKey.ECDSA_validate_msg_signature(&message[0], sizeof(message), sig), CHIP_NO_ERROR);
             }
         }
 
@@ -1366,58 +1330,54 @@
 
             uint8_t csrBuf[chip::Crypto::kMIN_CSR_Buffer_Size];
             MutableByteSpan csrSpan{ csrBuf };
-            NL_TEST_ASSERT_SUCCESS(inSuite, fabricTable.AllocatePendingOperationalKey(chip::NullOptional, csrSpan));
+            EXPECT_EQ(fabricTable.AllocatePendingOperationalKey(chip::NullOptional, csrSpan), CHIP_NO_ERROR);
 
-            NL_TEST_ASSERT_SUCCESS(
-                inSuite, fabricCertAuthority.SetIncludeIcac(false).GenerateNocChain(fabricId, nodeId, csrSpan).GetStatus());
+            EXPECT_EQ(fabricCertAuthority.SetIncludeIcac(false).GenerateNocChain(fabricId, nodeId, csrSpan).GetStatus(),
+                      CHIP_NO_ERROR);
             ByteSpan rcac = fabricCertAuthority.GetRcac();
             ByteSpan noc  = fabricCertAuthority.GetNoc();
 
-            NL_TEST_ASSERT_EQUALS(inSuite, fabricTable.FabricCount(), 1);
-            NL_TEST_ASSERT_SUCCESS(inSuite, fabricTable.AddNewPendingTrustedRootCert(rcac));
+            EXPECT_EQ(fabricTable.FabricCount(), 1);
+            EXPECT_EQ(fabricTable.AddNewPendingTrustedRootCert(rcac), CHIP_NO_ERROR);
             FabricIndex newFabricIndex = kUndefinedFabricIndex;
-            NL_TEST_ASSERT_SUCCESS(
-                inSuite, fabricTable.AddNewPendingFabricWithOperationalKeystore(noc, ByteSpan{}, kVendorId, &newFabricIndex));
-            NL_TEST_ASSERT_EQUALS(inSuite, fabricTable.FabricCount(), 2);
-            NL_TEST_ASSERT(inSuite, newFabricIndex == 2);
+            EXPECT_EQ(fabricTable.AddNewPendingFabricWithOperationalKeystore(noc, ByteSpan{}, kVendorId, &newFabricIndex),
+                      CHIP_NO_ERROR);
+            EXPECT_EQ(fabricTable.FabricCount(), 2);
+            EXPECT_EQ(newFabricIndex, 2);
 
-            NL_TEST_ASSERT_SUCCESS(inSuite, fabricTable.CommitPendingFabricData());
+            EXPECT_EQ(fabricTable.CommitPendingFabricData(), CHIP_NO_ERROR);
 
             // Validate contents
             const auto * fabricInfo = fabricTable.FindFabricWithIndex(2);
-            NL_TEST_ASSERT(inSuite, fabricInfo != nullptr);
-            if (fabricInfo != nullptr)
-            {
-                Credentials::ChipCertificateSet certificates;
-                NL_TEST_ASSERT_SUCCESS(inSuite, certificates.Init(1));
-                NL_TEST_ASSERT_SUCCESS(inSuite,
-                                       certificates.LoadCert(rcac, BitFlags<CertDecodeFlags>(CertDecodeFlags::kIsTrustAnchor)));
-                Crypto::P256PublicKey rcacPublicKey(certificates.GetCertSet()[0].mPublicKey);
+            ASSERT_NE(fabricInfo, nullptr);
+            Credentials::ChipCertificateSet certificates;
+            EXPECT_EQ(certificates.Init(1), CHIP_NO_ERROR);
+            EXPECT_EQ(certificates.LoadCert(rcac, BitFlags<CertDecodeFlags>(CertDecodeFlags::kIsTrustAnchor)), CHIP_NO_ERROR);
+            Crypto::P256PublicKey rcacPublicKey(certificates.GetCertSet()[0].mPublicKey);
 
-                NL_TEST_ASSERT(inSuite, fabricInfo->GetFabricIndex() == 2);
-                NL_TEST_ASSERT(inSuite, fabricInfo->GetNodeId() == 66);
-                NL_TEST_ASSERT(inSuite, fabricInfo->GetFabricId() == 2222);
-                NL_TEST_ASSERT(inSuite, fabricInfo->GetVendorId() == kVendorId);
-                NL_TEST_ASSERT(inSuite, fabricInfo->GetFabricLabel().size() == 0);
+            EXPECT_EQ(fabricInfo->GetFabricIndex(), 2);
+            EXPECT_EQ(fabricInfo->GetNodeId(), 66u);
+            EXPECT_EQ(fabricInfo->GetFabricId(), 2222u);
+            EXPECT_EQ(fabricInfo->GetVendorId(), kVendorId);
+            EXPECT_EQ(fabricInfo->GetFabricLabel().size(), 0u);
 
-                Crypto::P256PublicKey rootPublicKeyOfFabric;
-                NL_TEST_ASSERT_SUCCESS(inSuite, fabricTable.FetchRootPubkey(newFabricIndex, rootPublicKeyOfFabric));
-                NL_TEST_ASSERT(inSuite, rootPublicKeyOfFabric.Matches(rcacPublicKey));
-            }
+            Crypto::P256PublicKey rootPublicKeyOfFabric;
+            EXPECT_EQ(fabricTable.FetchRootPubkey(newFabricIndex, rootPublicKeyOfFabric), CHIP_NO_ERROR);
+            EXPECT_TRUE(rootPublicKeyOfFabric.Matches(rcacPublicKey));
 
             // Validate that fabric has the correct operational key by verifying a signature
             {
                 Crypto::P256ECDSASignature sig;
                 uint8_t message[] = { 'm', 's', 'g' };
 
-                NL_TEST_ASSERT_SUCCESS(inSuite, VerifyCertificateSigningRequest(csrSpan.data(), csrSpan.size(), fIdx2PublicKey));
+                EXPECT_EQ(VerifyCertificateSigningRequest(csrSpan.data(), csrSpan.size(), fIdx2PublicKey), CHIP_NO_ERROR);
 
-                NL_TEST_ASSERT_SUCCESS(inSuite, fabricTable.SignWithOpKeypair(newFabricIndex, ByteSpan{ message }, sig));
-                NL_TEST_ASSERT_SUCCESS(inSuite, fIdx2PublicKey.ECDSA_validate_msg_signature(&message[0], sizeof(message), sig));
+                EXPECT_EQ(fabricTable.SignWithOpKeypair(newFabricIndex, ByteSpan{ message }, sig), CHIP_NO_ERROR);
+                EXPECT_EQ(fIdx2PublicKey.ECDSA_validate_msg_signature(&message[0], sizeof(message), sig), CHIP_NO_ERROR);
             }
         }
 
-        NL_TEST_ASSERT(inSuite, fabricTable.FabricCount() == 2);
+        EXPECT_EQ(fabricTable.FabricCount(), 2);
 
         // Verify we can now see 2 fabrics with the iterator
         {
@@ -1429,44 +1389,44 @@
                 ++numFabricsIterated;
                 if (iterFabricInfo.GetFabricIndex() == 1)
                 {
-                    NL_TEST_ASSERT(inSuite, iterFabricInfo.GetNodeId() == 55);
-                    NL_TEST_ASSERT(inSuite, iterFabricInfo.GetFabricId() == 1111);
+                    EXPECT_EQ(iterFabricInfo.GetNodeId(), 55u);
+                    EXPECT_EQ(iterFabricInfo.GetFabricId(), 1111u);
                     saw1 = true;
                 }
                 if (iterFabricInfo.GetFabricIndex() == 2)
                 {
-                    NL_TEST_ASSERT(inSuite, iterFabricInfo.GetNodeId() == 66);
-                    NL_TEST_ASSERT(inSuite, iterFabricInfo.GetFabricId() == 2222);
+                    EXPECT_EQ(iterFabricInfo.GetNodeId(), 66u);
+                    EXPECT_EQ(iterFabricInfo.GetFabricId(), 2222u);
                     saw2 = true;
                 }
             }
 
-            NL_TEST_ASSERT(inSuite, numFabricsIterated == 2);
-            NL_TEST_ASSERT(inSuite, saw1 == true);
-            NL_TEST_ASSERT(inSuite, saw2 == true);
+            EXPECT_EQ(numFabricsIterated, 2u);
+            EXPECT_TRUE(saw1);
+            EXPECT_TRUE(saw2);
         }
 
         // Next fabric index should now be 3, since we added 1 and 2 above.
         {
             FabricIndex nextFabricIndex = kUndefinedFabricIndex;
-            NL_TEST_ASSERT(inSuite, fabricTable.PeekFabricIndexForNextAddition(nextFabricIndex) == CHIP_NO_ERROR);
-            NL_TEST_ASSERT_EQUALS(inSuite, nextFabricIndex, 3);
+            EXPECT_EQ(fabricTable.PeekFabricIndexForNextAddition(nextFabricIndex), CHIP_NO_ERROR);
+            EXPECT_EQ(nextFabricIndex, 3);
         }
     }
 
     // Global: Last known good time + fabric index = 2
     // Fabric 1111: Metadata, 1 opkey, RCAC/ICAC/NOC = 5
     // Fabric 2222: Metadata, 1 opkey, RCAC/NOC = 4
-    NL_TEST_ASSERT(inSuite, storage.GetNumKeys() == (2 + 5 + 4));
+    EXPECT_EQ(storage.GetNumKeys(), (2u + 5u + 4u));
 
     // Second scope: Validate that a fresh FabricTable loads the previously committed fabrics on Init.
     {
         // Initialize a FabricTable
         ScopedFabricTable fabricTableHolder;
-        NL_TEST_ASSERT(inSuite, fabricTableHolder.Init(&storage) == CHIP_NO_ERROR);
+        EXPECT_EQ(fabricTableHolder.Init(&storage), CHIP_NO_ERROR);
         FabricTable & fabricTable = fabricTableHolder.GetFabricTable();
 
-        NL_TEST_ASSERT_EQUALS(inSuite, fabricTable.FabricCount(), 2);
+        EXPECT_EQ(fabricTable.FabricCount(), 2);
 
         // Verify we can see 2 fabrics with the iterator
         {
@@ -1478,57 +1438,53 @@
                 ++numFabricsIterated;
                 if (iterFabricInfo.GetFabricIndex() == 1)
                 {
-                    NL_TEST_ASSERT(inSuite, iterFabricInfo.GetNodeId() == 55);
-                    NL_TEST_ASSERT(inSuite, iterFabricInfo.GetFabricId() == 1111);
+                    EXPECT_EQ(iterFabricInfo.GetNodeId(), 55u);
+                    EXPECT_EQ(iterFabricInfo.GetFabricId(), 1111u);
                     saw1 = true;
                 }
                 if (iterFabricInfo.GetFabricIndex() == 2)
                 {
-                    NL_TEST_ASSERT(inSuite, iterFabricInfo.GetNodeId() == 66);
-                    NL_TEST_ASSERT(inSuite, iterFabricInfo.GetFabricId() == 2222);
+                    EXPECT_EQ(iterFabricInfo.GetNodeId(), 66u);
+                    EXPECT_EQ(iterFabricInfo.GetFabricId(), 2222u);
                     saw2 = true;
                 }
             }
 
-            NL_TEST_ASSERT(inSuite, numFabricsIterated == 2);
-            NL_TEST_ASSERT(inSuite, saw1 == true);
-            NL_TEST_ASSERT(inSuite, saw2 == true);
+            EXPECT_EQ(numFabricsIterated, 2u);
+            EXPECT_TRUE(saw1);
+            EXPECT_TRUE(saw2);
         }
 
         // Validate contents of Fabric 2222
         {
             uint8_t rcacBuf[Credentials::kMaxCHIPCertLength];
             MutableByteSpan rcacSpan{ rcacBuf };
-            NL_TEST_ASSERT_SUCCESS(inSuite, fabricTable.FetchRootCert(2, rcacSpan));
+            EXPECT_EQ(fabricTable.FetchRootCert(2, rcacSpan), CHIP_NO_ERROR);
 
             const auto * fabricInfo = fabricTable.FindFabricWithIndex(2);
-            NL_TEST_ASSERT(inSuite, fabricInfo != nullptr);
-            if (fabricInfo != nullptr)
-            {
-                Credentials::ChipCertificateSet certificates;
-                NL_TEST_ASSERT_SUCCESS(inSuite, certificates.Init(1));
-                NL_TEST_ASSERT_SUCCESS(inSuite,
-                                       certificates.LoadCert(rcacSpan, BitFlags<CertDecodeFlags>(CertDecodeFlags::kIsTrustAnchor)));
-                Crypto::P256PublicKey rcacPublicKey(certificates.GetCertSet()[0].mPublicKey);
+            ASSERT_NE(fabricInfo, nullptr);
+            Credentials::ChipCertificateSet certificates;
+            EXPECT_EQ(certificates.Init(1), CHIP_NO_ERROR);
+            EXPECT_EQ(certificates.LoadCert(rcacSpan, BitFlags<CertDecodeFlags>(CertDecodeFlags::kIsTrustAnchor)), CHIP_NO_ERROR);
+            Crypto::P256PublicKey rcacPublicKey(certificates.GetCertSet()[0].mPublicKey);
 
-                NL_TEST_ASSERT(inSuite, fabricInfo->GetFabricIndex() == 2);
-                NL_TEST_ASSERT(inSuite, fabricInfo->GetNodeId() == 66);
-                NL_TEST_ASSERT(inSuite, fabricInfo->GetFabricId() == 2222);
-                NL_TEST_ASSERT(inSuite, fabricInfo->GetVendorId() == kVendorId);
-                NL_TEST_ASSERT(inSuite, fabricInfo->GetFabricLabel().size() == 0);
+            EXPECT_EQ(fabricInfo->GetFabricIndex(), 2);
+            EXPECT_EQ(fabricInfo->GetNodeId(), 66u);
+            EXPECT_EQ(fabricInfo->GetFabricId(), 2222u);
+            EXPECT_EQ(fabricInfo->GetVendorId(), kVendorId);
+            EXPECT_EQ(fabricInfo->GetFabricLabel().size(), 0u);
 
-                Crypto::P256PublicKey rootPublicKeyOfFabric;
-                NL_TEST_ASSERT_SUCCESS(inSuite, fabricTable.FetchRootPubkey(2, rootPublicKeyOfFabric));
-                NL_TEST_ASSERT(inSuite, rootPublicKeyOfFabric.Matches(rcacPublicKey));
-            }
+            Crypto::P256PublicKey rootPublicKeyOfFabric;
+            EXPECT_EQ(fabricTable.FetchRootPubkey(2, rootPublicKeyOfFabric), CHIP_NO_ERROR);
+            EXPECT_TRUE(rootPublicKeyOfFabric.Matches(rcacPublicKey));
 
             // Validate that fabric has the correct operational key by verifying a signature
             {
                 Crypto::P256ECDSASignature sig;
                 uint8_t message[] = { 'm', 's', 'g' };
 
-                NL_TEST_ASSERT_SUCCESS(inSuite, fabricTable.SignWithOpKeypair(2, ByteSpan{ message }, sig));
-                NL_TEST_ASSERT_SUCCESS(inSuite, fIdx2PublicKey.ECDSA_validate_msg_signature(&message[0], sizeof(message), sig));
+                EXPECT_EQ(fabricTable.SignWithOpKeypair(2, ByteSpan{ message }, sig), CHIP_NO_ERROR);
+                EXPECT_EQ(fIdx2PublicKey.ECDSA_validate_msg_signature(&message[0], sizeof(message), sig), CHIP_NO_ERROR);
             }
         }
 
@@ -1536,36 +1492,32 @@
         {
             uint8_t rcacBuf[Credentials::kMaxCHIPCertLength];
             MutableByteSpan rcacSpan{ rcacBuf };
-            NL_TEST_ASSERT_SUCCESS(inSuite, fabricTable.FetchRootCert(1, rcacSpan));
+            EXPECT_EQ(fabricTable.FetchRootCert(1, rcacSpan), CHIP_NO_ERROR);
 
             const auto * fabricInfo = fabricTable.FindFabricWithIndex(1);
-            NL_TEST_ASSERT(inSuite, fabricInfo != nullptr);
-            if (fabricInfo != nullptr)
-            {
-                Credentials::ChipCertificateSet certificates;
-                NL_TEST_ASSERT_SUCCESS(inSuite, certificates.Init(1));
-                NL_TEST_ASSERT_SUCCESS(inSuite,
-                                       certificates.LoadCert(rcacSpan, BitFlags<CertDecodeFlags>(CertDecodeFlags::kIsTrustAnchor)));
-                Crypto::P256PublicKey rcacPublicKey(certificates.GetCertSet()[0].mPublicKey);
+            ASSERT_NE(fabricInfo, nullptr);
+            Credentials::ChipCertificateSet certificates;
+            EXPECT_EQ(certificates.Init(1), CHIP_NO_ERROR);
+            EXPECT_EQ(certificates.LoadCert(rcacSpan, BitFlags<CertDecodeFlags>(CertDecodeFlags::kIsTrustAnchor)), CHIP_NO_ERROR);
+            Crypto::P256PublicKey rcacPublicKey(certificates.GetCertSet()[0].mPublicKey);
 
-                NL_TEST_ASSERT(inSuite, fabricInfo->GetFabricIndex() == 1);
-                NL_TEST_ASSERT(inSuite, fabricInfo->GetNodeId() == 55);
-                NL_TEST_ASSERT(inSuite, fabricInfo->GetFabricId() == 1111);
-                NL_TEST_ASSERT(inSuite, fabricInfo->GetVendorId() == kVendorId);
-                NL_TEST_ASSERT(inSuite, fabricInfo->GetFabricLabel().size() == 0);
+            EXPECT_EQ(fabricInfo->GetFabricIndex(), 1);
+            EXPECT_EQ(fabricInfo->GetNodeId(), 55u);
+            EXPECT_EQ(fabricInfo->GetFabricId(), 1111u);
+            EXPECT_EQ(fabricInfo->GetVendorId(), kVendorId);
+            EXPECT_EQ(fabricInfo->GetFabricLabel().size(), 0u);
 
-                Crypto::P256PublicKey rootPublicKeyOfFabric;
-                NL_TEST_ASSERT_SUCCESS(inSuite, fabricTable.FetchRootPubkey(1, rootPublicKeyOfFabric));
-                NL_TEST_ASSERT(inSuite, rootPublicKeyOfFabric.Matches(rcacPublicKey));
-            }
+            Crypto::P256PublicKey rootPublicKeyOfFabric;
+            EXPECT_EQ(fabricTable.FetchRootPubkey(1, rootPublicKeyOfFabric), CHIP_NO_ERROR);
+            EXPECT_TRUE(rootPublicKeyOfFabric.Matches(rcacPublicKey));
 
             // Validate that fabric has the correct operational key by verifying a signature
             {
                 Crypto::P256ECDSASignature sig;
                 uint8_t message[] = { 'm', 's', 'g' };
 
-                NL_TEST_ASSERT_SUCCESS(inSuite, fabricTable.SignWithOpKeypair(1, ByteSpan{ message }, sig));
-                NL_TEST_ASSERT_SUCCESS(inSuite, fIdx1PublicKey.ECDSA_validate_msg_signature(&message[0], sizeof(message), sig));
+                EXPECT_EQ(fabricTable.SignWithOpKeypair(1, ByteSpan{ message }, sig), CHIP_NO_ERROR);
+                EXPECT_EQ(fIdx1PublicKey.ECDSA_validate_msg_signature(&message[0], sizeof(message), sig), CHIP_NO_ERROR);
             }
 
             // Validate that signing with Fabric index 2 fails to verify with fabric index 1
@@ -1573,40 +1525,39 @@
                 Crypto::P256ECDSASignature sig;
                 uint8_t message[] = { 'm', 's', 'g' };
 
-                NL_TEST_ASSERT_SUCCESS(inSuite, fabricTable.SignWithOpKeypair(2, ByteSpan{ message }, sig));
-                NL_TEST_ASSERT(inSuite,
-                               fIdx1PublicKey.ECDSA_validate_msg_signature(&message[0], sizeof(message), sig) ==
-                                   CHIP_ERROR_INVALID_SIGNATURE);
+                EXPECT_EQ(fabricTable.SignWithOpKeypair(2, ByteSpan{ message }, sig), CHIP_NO_ERROR);
+                EXPECT_EQ(fIdx1PublicKey.ECDSA_validate_msg_signature(&message[0], sizeof(message), sig),
+                          CHIP_ERROR_INVALID_SIGNATURE);
             }
         }
 
         // Validate that next fabric index is still 3;
         {
             FabricIndex nextFabricIndex = kUndefinedFabricIndex;
-            NL_TEST_ASSERT(inSuite, fabricTable.PeekFabricIndexForNextAddition(nextFabricIndex) == CHIP_NO_ERROR);
-            NL_TEST_ASSERT_EQUALS(inSuite, nextFabricIndex, 3);
+            EXPECT_EQ(fabricTable.PeekFabricIndexForNextAddition(nextFabricIndex), CHIP_NO_ERROR);
+            EXPECT_EQ(nextFabricIndex, 3);
         }
     }
 }
 
-void TestAddNocFailSafe(nlTestSuite * inSuite, void * inContext)
+TEST_F(TestFabricTable, TestAddNocFailSafe)
 {
     Credentials::TestOnlyLocalCertificateAuthority fabric11CertAuthority;
     Credentials::TestOnlyLocalCertificateAuthority fabric44CertAuthority;
 
     chip::TestPersistentStorageDelegate storage;
 
-    NL_TEST_ASSERT(inSuite, fabric11CertAuthority.Init().IsSuccess());
-    NL_TEST_ASSERT(inSuite, fabric44CertAuthority.Init().IsSuccess());
+    EXPECT_TRUE(fabric11CertAuthority.Init().IsSuccess());
+    EXPECT_TRUE(fabric44CertAuthority.Init().IsSuccess());
 
     constexpr uint16_t kVendorId = 0xFFF1u;
 
     // Initialize a fabric table.
     ScopedFabricTable fabricTableHolder;
-    NL_TEST_ASSERT(inSuite, fabricTableHolder.Init(&storage) == CHIP_NO_ERROR);
+    EXPECT_EQ(fabricTableHolder.Init(&storage), CHIP_NO_ERROR);
     FabricTable & fabricTable = fabricTableHolder.GetFabricTable();
 
-    NL_TEST_ASSERT_EQUALS(inSuite, fabricTable.FabricCount(), 0);
+    EXPECT_EQ(fabricTable.FabricCount(), 0);
 
     size_t numFabricsIterated = 0;
 
@@ -1619,30 +1570,30 @@
 
         uint8_t csrBuf[chip::Crypto::kMIN_CSR_Buffer_Size];
         MutableByteSpan csrSpan{ csrBuf };
-        NL_TEST_ASSERT_SUCCESS(inSuite, fabricTable.AllocatePendingOperationalKey(chip::NullOptional, csrSpan));
+        EXPECT_EQ(fabricTable.AllocatePendingOperationalKey(chip::NullOptional, csrSpan), CHIP_NO_ERROR);
 
-        NL_TEST_ASSERT_SUCCESS(inSuite,
-                               fabric11CertAuthority.SetIncludeIcac(false).GenerateNocChain(fabricId, nodeId, csrSpan).GetStatus());
+        EXPECT_EQ(fabric11CertAuthority.SetIncludeIcac(false).GenerateNocChain(fabricId, nodeId, csrSpan).GetStatus(),
+                  CHIP_NO_ERROR);
         ByteSpan rcac = fabric11CertAuthority.GetRcac();
         ByteSpan noc  = fabric11CertAuthority.GetNoc();
 
-        NL_TEST_ASSERT_SUCCESS(inSuite, fabricTable.AddNewPendingTrustedRootCert(rcac));
+        EXPECT_EQ(fabricTable.AddNewPendingTrustedRootCert(rcac), CHIP_NO_ERROR);
         FabricIndex newFabricIndex = kUndefinedFabricIndex;
 
         {
             FabricIndex nextFabricIndex = kUndefinedFabricIndex;
-            NL_TEST_ASSERT(inSuite, fabricTable.PeekFabricIndexForNextAddition(nextFabricIndex) == CHIP_NO_ERROR);
-            NL_TEST_ASSERT_EQUALS(inSuite, nextFabricIndex, 1);
+            EXPECT_EQ(fabricTable.PeekFabricIndexForNextAddition(nextFabricIndex), CHIP_NO_ERROR);
+            EXPECT_EQ(nextFabricIndex, 1);
         }
 
-        NL_TEST_ASSERT_EQUALS(inSuite, fabricTable.FabricCount(), 0);
-        NL_TEST_ASSERT_SUCCESS(inSuite,
-                               fabricTable.AddNewPendingFabricWithOperationalKeystore(noc, ByteSpan{}, kVendorId, &newFabricIndex));
-        NL_TEST_ASSERT(inSuite, newFabricIndex == 1);
-        NL_TEST_ASSERT_EQUALS(inSuite, fabricTable.FabricCount(), 1);
+        EXPECT_EQ(fabricTable.FabricCount(), 0);
+        EXPECT_EQ(fabricTable.AddNewPendingFabricWithOperationalKeystore(noc, ByteSpan{}, kVendorId, &newFabricIndex),
+                  CHIP_NO_ERROR);
+        EXPECT_EQ(newFabricIndex, 1);
+        EXPECT_EQ(fabricTable.FabricCount(), 1);
 
         // No storage yet
-        NL_TEST_ASSERT(inSuite, storage.GetNumKeys() == numStorageKeysAtStart); // Nothing yet
+        EXPECT_EQ(storage.GetNumKeys(), numStorageKeysAtStart); // Nothing yet
 
         // Validate iterator sees pending
         {
@@ -1653,23 +1604,23 @@
                 ++numFabricsIterated;
                 if (iterFabricInfo.GetFabricIndex() == 1)
                 {
-                    NL_TEST_ASSERT(inSuite, iterFabricInfo.GetNodeId() == nodeId);
-                    NL_TEST_ASSERT(inSuite, iterFabricInfo.GetFabricId() == fabricId);
+                    EXPECT_EQ(iterFabricInfo.GetNodeId(), nodeId);
+                    EXPECT_EQ(iterFabricInfo.GetFabricId(), fabricId);
                     saw1 = true;
                 }
             }
 
-            NL_TEST_ASSERT(inSuite, numFabricsIterated == 1);
-            NL_TEST_ASSERT(inSuite, saw1 == true);
+            EXPECT_EQ(numFabricsIterated, 1u);
+            EXPECT_TRUE(saw1);
         }
 
         // Revert, should see nothing yet
         fabricTable.RevertPendingFabricData();
 
-        NL_TEST_ASSERT_EQUALS(inSuite, fabricTable.FabricCount(), 0);
+        EXPECT_EQ(fabricTable.FabricCount(), 0);
 
         // No started except fabric index metadata
-        NL_TEST_ASSERT(inSuite, storage.GetNumKeys() == (numStorageKeysAtStart + 1));
+        EXPECT_EQ(storage.GetNumKeys(), (numStorageKeysAtStart + 1));
 
         // Validate iterator sees nothing
         {
@@ -1684,15 +1635,15 @@
                 }
             }
 
-            NL_TEST_ASSERT(inSuite, numFabricsIterated == 0);
-            NL_TEST_ASSERT(inSuite, saw1 == false);
+            EXPECT_EQ(numFabricsIterated, 0u);
+            EXPECT_FALSE(saw1);
         }
 
         // Validate next fabric index has not changed.
         {
             FabricIndex nextFabricIndex = kUndefinedFabricIndex;
-            NL_TEST_ASSERT(inSuite, fabricTable.PeekFabricIndexForNextAddition(nextFabricIndex) == CHIP_NO_ERROR);
-            NL_TEST_ASSERT_EQUALS(inSuite, nextFabricIndex, 1);
+            EXPECT_EQ(fabricTable.PeekFabricIndexForNextAddition(nextFabricIndex), CHIP_NO_ERROR);
+            EXPECT_EQ(nextFabricIndex, 1);
         }
     }
 
@@ -1705,54 +1656,49 @@
 
         uint8_t csrBuf[chip::Crypto::kMIN_CSR_Buffer_Size];
         MutableByteSpan csrSpan{ csrBuf };
-        NL_TEST_ASSERT_SUCCESS(inSuite, fabricTable.AllocatePendingOperationalKey(chip::NullOptional, csrSpan));
+        EXPECT_EQ(fabricTable.AllocatePendingOperationalKey(chip::NullOptional, csrSpan), CHIP_NO_ERROR);
 
-        NL_TEST_ASSERT_SUCCESS(inSuite,
-                               fabric44CertAuthority.SetIncludeIcac(true).GenerateNocChain(fabricId, nodeId, csrSpan).GetStatus());
+        EXPECT_EQ(fabric44CertAuthority.SetIncludeIcac(true).GenerateNocChain(fabricId, nodeId, csrSpan).GetStatus(),
+                  CHIP_NO_ERROR);
         ByteSpan rcac = fabric44CertAuthority.GetRcac();
         ByteSpan icac = fabric44CertAuthority.GetIcac();
         ByteSpan noc  = fabric44CertAuthority.GetNoc();
 
-        NL_TEST_ASSERT_EQUALS(inSuite, fabricTable.FabricCount(), 0);
-        NL_TEST_ASSERT_SUCCESS(inSuite, fabricTable.AddNewPendingTrustedRootCert(rcac));
+        EXPECT_EQ(fabricTable.FabricCount(), 0);
+        EXPECT_EQ(fabricTable.AddNewPendingTrustedRootCert(rcac), CHIP_NO_ERROR);
         FabricIndex newFabricIndex = kUndefinedFabricIndex;
 
-        NL_TEST_ASSERT_EQUALS(inSuite, fabricTable.FabricCount(), 0);
-        NL_TEST_ASSERT_SUCCESS(inSuite,
-                               fabricTable.AddNewPendingFabricWithOperationalKeystore(noc, icac, kVendorId, &newFabricIndex));
-        NL_TEST_ASSERT_EQUALS(inSuite, fabricTable.FabricCount(), 1);
-        NL_TEST_ASSERT(inSuite, newFabricIndex == 1);
+        EXPECT_EQ(fabricTable.FabricCount(), 0);
+        EXPECT_EQ(fabricTable.AddNewPendingFabricWithOperationalKeystore(noc, icac, kVendorId, &newFabricIndex), CHIP_NO_ERROR);
+        EXPECT_EQ(fabricTable.FabricCount(), 1);
+        EXPECT_EQ(newFabricIndex, 1);
         // No storage yet
-        NL_TEST_ASSERT(inSuite, storage.GetNumKeys() == numStorageAfterRevert);
+        EXPECT_EQ(storage.GetNumKeys(), numStorageAfterRevert);
 
         // Commit, now storage should have keys
-        NL_TEST_ASSERT_SUCCESS(inSuite, fabricTable.CommitPendingFabricData());
-        NL_TEST_ASSERT_EQUALS(inSuite, fabricTable.FabricCount(), 1);
+        EXPECT_EQ(fabricTable.CommitPendingFabricData(), CHIP_NO_ERROR);
+        EXPECT_EQ(fabricTable.FabricCount(), 1);
 
-        NL_TEST_ASSERT_EQUALS(inSuite, storage.GetNumKeys(),
-                              (numStorageAfterRevert + 5)); // 3 opcerts + fabric metadata + 1 operational key
+        EXPECT_EQ(storage.GetNumKeys(),
+                  (numStorageAfterRevert + 5)); // 3 opcerts + fabric metadata + 1 operational key
 
         // Validate contents
         const auto * fabricInfo = fabricTable.FindFabricWithIndex(1);
-        NL_TEST_ASSERT(inSuite, fabricInfo != nullptr);
-        if (fabricInfo != nullptr)
-        {
-            Credentials::ChipCertificateSet certificates;
-            NL_TEST_ASSERT_SUCCESS(inSuite, certificates.Init(1));
-            NL_TEST_ASSERT_SUCCESS(inSuite,
-                                   certificates.LoadCert(rcac, BitFlags<CertDecodeFlags>(CertDecodeFlags::kIsTrustAnchor)));
-            Crypto::P256PublicKey rcacPublicKey(certificates.GetCertSet()[0].mPublicKey);
+        ASSERT_NE(fabricInfo, nullptr);
+        Credentials::ChipCertificateSet certificates;
+        EXPECT_EQ(certificates.Init(1), CHIP_NO_ERROR);
+        EXPECT_EQ(certificates.LoadCert(rcac, BitFlags<CertDecodeFlags>(CertDecodeFlags::kIsTrustAnchor)), CHIP_NO_ERROR);
+        Crypto::P256PublicKey rcacPublicKey(certificates.GetCertSet()[0].mPublicKey);
 
-            NL_TEST_ASSERT(inSuite, fabricInfo->GetFabricIndex() == newFabricIndex);
-            NL_TEST_ASSERT(inSuite, fabricInfo->GetNodeId() == nodeId);
-            NL_TEST_ASSERT(inSuite, fabricInfo->GetFabricId() == fabricId);
-            NL_TEST_ASSERT(inSuite, fabricInfo->GetVendorId() == kVendorId);
-            NL_TEST_ASSERT(inSuite, fabricInfo->GetFabricLabel().size() == 0);
+        EXPECT_EQ(fabricInfo->GetFabricIndex(), newFabricIndex);
+        EXPECT_EQ(fabricInfo->GetNodeId(), nodeId);
+        EXPECT_EQ(fabricInfo->GetFabricId(), fabricId);
+        EXPECT_EQ(fabricInfo->GetVendorId(), kVendorId);
+        EXPECT_EQ(fabricInfo->GetFabricLabel().size(), 0u);
 
-            Crypto::P256PublicKey rootPublicKeyOfFabric;
-            NL_TEST_ASSERT_SUCCESS(inSuite, fabricTable.FetchRootPubkey(newFabricIndex, rootPublicKeyOfFabric));
-            NL_TEST_ASSERT(inSuite, rootPublicKeyOfFabric.Matches(rcacPublicKey));
-        }
+        Crypto::P256PublicKey rootPublicKeyOfFabric;
+        EXPECT_EQ(fabricTable.FetchRootPubkey(newFabricIndex, rootPublicKeyOfFabric), CHIP_NO_ERROR);
+        EXPECT_TRUE(rootPublicKeyOfFabric.Matches(rcacPublicKey));
 
         // Validate that fabric has the correct operational key by verifying a signature
         {
@@ -1760,10 +1706,10 @@
             uint8_t message[] = { 'm', 's', 'g' };
 
             Crypto::P256PublicKey nocPubKey;
-            NL_TEST_ASSERT_SUCCESS(inSuite, VerifyCertificateSigningRequest(csrSpan.data(), csrSpan.size(), nocPubKey));
+            EXPECT_EQ(VerifyCertificateSigningRequest(csrSpan.data(), csrSpan.size(), nocPubKey), CHIP_NO_ERROR);
 
-            NL_TEST_ASSERT_SUCCESS(inSuite, fabricTable.SignWithOpKeypair(newFabricIndex, ByteSpan{ message }, sig));
-            NL_TEST_ASSERT_SUCCESS(inSuite, nocPubKey.ECDSA_validate_msg_signature(&message[0], sizeof(message), sig));
+            EXPECT_EQ(fabricTable.SignWithOpKeypair(newFabricIndex, ByteSpan{ message }, sig), CHIP_NO_ERROR);
+            EXPECT_EQ(nocPubKey.ECDSA_validate_msg_signature(&message[0], sizeof(message), sig), CHIP_NO_ERROR);
         }
 
         // Verify we can now see the fabric with the iterator
@@ -1775,14 +1721,14 @@
                 ++numFabricsIterated;
                 if (iterFabricInfo.GetFabricIndex() == 1)
                 {
-                    NL_TEST_ASSERT(inSuite, iterFabricInfo.GetNodeId() == 999);
-                    NL_TEST_ASSERT(inSuite, iterFabricInfo.GetFabricId() == 44);
+                    EXPECT_EQ(iterFabricInfo.GetNodeId(), 999u);
+                    EXPECT_EQ(iterFabricInfo.GetFabricId(), 44u);
                     saw1 = true;
                 }
             }
 
-            NL_TEST_ASSERT(inSuite, numFabricsIterated == 1);
-            NL_TEST_ASSERT(inSuite, saw1 == true);
+            EXPECT_EQ(numFabricsIterated, 1u);
+            EXPECT_TRUE(saw1);
         }
     }
 
@@ -1795,8 +1741,8 @@
         fabricTable.RevertPendingFabricData();
 
         // No change of storage
-        NL_TEST_ASSERT_EQUALS(inSuite, fabricTable.FabricCount(), 1);
-        NL_TEST_ASSERT(inSuite, storage.GetNumKeys() == numStorageAfterAdd);
+        EXPECT_EQ(fabricTable.FabricCount(), 1);
+        EXPECT_EQ(storage.GetNumKeys(), numStorageAfterAdd);
 
         // Verify we can still see the fabric with the iterator
         {
@@ -1807,19 +1753,19 @@
                 ++numFabricsIterated;
                 if (iterFabricInfo.GetFabricIndex() == 1)
                 {
-                    NL_TEST_ASSERT(inSuite, iterFabricInfo.GetNodeId() == 999);
-                    NL_TEST_ASSERT(inSuite, iterFabricInfo.GetFabricId() == 44);
+                    EXPECT_EQ(iterFabricInfo.GetNodeId(), 999u);
+                    EXPECT_EQ(iterFabricInfo.GetFabricId(), 44u);
                     saw1 = true;
                 }
             }
 
-            NL_TEST_ASSERT(inSuite, numFabricsIterated == 1);
-            NL_TEST_ASSERT(inSuite, saw1 == true);
+            EXPECT_EQ(numFabricsIterated, 1u);
+            EXPECT_TRUE(saw1);
         }
     }
 }
 
-void TestUpdateNocFailSafe(nlTestSuite * inSuite, void * inContext)
+TEST_F(TestFabricTable, TestUpdateNocFailSafe)
 {
     Credentials::TestOnlyLocalCertificateAuthority fabric11CertAuthority;
     Credentials::TestOnlyLocalCertificateAuthority fabric44CertAuthority;
@@ -1828,17 +1774,17 @@
 
     storage.SetLoggingLevel(chip::TestPersistentStorageDelegate::LoggingLevel::kLogMutation);
 
-    NL_TEST_ASSERT(inSuite, fabric11CertAuthority.Init().IsSuccess());
-    NL_TEST_ASSERT(inSuite, fabric44CertAuthority.Init().IsSuccess());
+    EXPECT_TRUE(fabric11CertAuthority.Init().IsSuccess());
+    EXPECT_TRUE(fabric44CertAuthority.Init().IsSuccess());
 
     constexpr uint16_t kVendorId = 0xFFF1u;
 
     // Initialize a fabric table.
     ScopedFabricTable fabricTableHolder;
-    NL_TEST_ASSERT(inSuite, fabricTableHolder.Init(&storage) == CHIP_NO_ERROR);
+    EXPECT_EQ(fabricTableHolder.Init(&storage), CHIP_NO_ERROR);
     FabricTable & fabricTable = fabricTableHolder.GetFabricTable();
 
-    NL_TEST_ASSERT_EQUALS(inSuite, fabricTable.FabricCount(), 0);
+    EXPECT_EQ(fabricTable.FabricCount(), 0);
 
     size_t numFabricsIterated = 0;
 
@@ -1851,54 +1797,49 @@
 
         uint8_t csrBuf[chip::Crypto::kMIN_CSR_Buffer_Size];
         MutableByteSpan csrSpan{ csrBuf };
-        NL_TEST_ASSERT_SUCCESS(inSuite, fabricTable.AllocatePendingOperationalKey(chip::NullOptional, csrSpan));
+        EXPECT_EQ(fabricTable.AllocatePendingOperationalKey(chip::NullOptional, csrSpan), CHIP_NO_ERROR);
 
-        NL_TEST_ASSERT_SUCCESS(inSuite,
-                               fabric44CertAuthority.SetIncludeIcac(true).GenerateNocChain(fabricId, nodeId, csrSpan).GetStatus());
+        EXPECT_EQ(fabric44CertAuthority.SetIncludeIcac(true).GenerateNocChain(fabricId, nodeId, csrSpan).GetStatus(),
+                  CHIP_NO_ERROR);
         ByteSpan rcac = fabric44CertAuthority.GetRcac();
         ByteSpan icac = fabric44CertAuthority.GetIcac();
         ByteSpan noc  = fabric44CertAuthority.GetNoc();
 
-        NL_TEST_ASSERT_EQUALS(inSuite, fabricTable.FabricCount(), 0);
-        NL_TEST_ASSERT_SUCCESS(inSuite, fabricTable.AddNewPendingTrustedRootCert(rcac));
+        EXPECT_EQ(fabricTable.FabricCount(), 0);
+        EXPECT_EQ(fabricTable.AddNewPendingTrustedRootCert(rcac), CHIP_NO_ERROR);
         FabricIndex newFabricIndex = kUndefinedFabricIndex;
 
-        NL_TEST_ASSERT_EQUALS(inSuite, fabricTable.FabricCount(), 0);
-        NL_TEST_ASSERT_SUCCESS(inSuite,
-                               fabricTable.AddNewPendingFabricWithOperationalKeystore(noc, icac, kVendorId, &newFabricIndex));
-        NL_TEST_ASSERT_EQUALS(inSuite, fabricTable.FabricCount(), 1);
-        NL_TEST_ASSERT(inSuite, newFabricIndex == 1);
+        EXPECT_EQ(fabricTable.FabricCount(), 0);
+        EXPECT_EQ(fabricTable.AddNewPendingFabricWithOperationalKeystore(noc, icac, kVendorId, &newFabricIndex), CHIP_NO_ERROR);
+        EXPECT_EQ(fabricTable.FabricCount(), 1);
+        EXPECT_EQ(newFabricIndex, 1);
         // No storage yet
-        NL_TEST_ASSERT(inSuite, storage.GetNumKeys() == numStorageKeysAtStart);
+        EXPECT_EQ(storage.GetNumKeys(), numStorageKeysAtStart);
 
         // Commit, now storage should have keys
-        NL_TEST_ASSERT_SUCCESS(inSuite, fabricTable.CommitPendingFabricData());
-        NL_TEST_ASSERT_EQUALS(inSuite, fabricTable.FabricCount(), 1);
+        EXPECT_EQ(fabricTable.CommitPendingFabricData(), CHIP_NO_ERROR);
+        EXPECT_EQ(fabricTable.FabricCount(), 1);
 
-        NL_TEST_ASSERT_EQUALS(inSuite, storage.GetNumKeys(),
-                              (numStorageKeysAtStart + 6)); // 3 opcerts + fabric metadata + 1 operational key + LKGT + fabric index
+        EXPECT_EQ(storage.GetNumKeys(),
+                  (numStorageKeysAtStart + 6)); // 3 opcerts + fabric metadata + 1 operational key + LKGT + fabric index
 
         // Validate contents
         const auto * fabricInfo = fabricTable.FindFabricWithIndex(1);
-        NL_TEST_ASSERT(inSuite, fabricInfo != nullptr);
-        if (fabricInfo != nullptr)
-        {
-            Credentials::ChipCertificateSet certificates;
-            NL_TEST_ASSERT_SUCCESS(inSuite, certificates.Init(1));
-            NL_TEST_ASSERT_SUCCESS(inSuite,
-                                   certificates.LoadCert(rcac, BitFlags<CertDecodeFlags>(CertDecodeFlags::kIsTrustAnchor)));
-            Crypto::P256PublicKey rcacPublicKey(certificates.GetCertSet()[0].mPublicKey);
+        ASSERT_NE(fabricInfo, nullptr);
+        Credentials::ChipCertificateSet certificates;
+        EXPECT_EQ(certificates.Init(1), CHIP_NO_ERROR);
+        EXPECT_EQ(certificates.LoadCert(rcac, BitFlags<CertDecodeFlags>(CertDecodeFlags::kIsTrustAnchor)), CHIP_NO_ERROR);
+        Crypto::P256PublicKey rcacPublicKey(certificates.GetCertSet()[0].mPublicKey);
 
-            NL_TEST_ASSERT(inSuite, fabricInfo->GetFabricIndex() == newFabricIndex);
-            NL_TEST_ASSERT(inSuite, fabricInfo->GetNodeId() == nodeId);
-            NL_TEST_ASSERT(inSuite, fabricInfo->GetFabricId() == fabricId);
-            NL_TEST_ASSERT(inSuite, fabricInfo->GetVendorId() == kVendorId);
-            NL_TEST_ASSERT(inSuite, fabricInfo->GetFabricLabel().size() == 0);
+        EXPECT_EQ(fabricInfo->GetFabricIndex(), newFabricIndex);
+        EXPECT_EQ(fabricInfo->GetNodeId(), nodeId);
+        EXPECT_EQ(fabricInfo->GetFabricId(), fabricId);
+        EXPECT_EQ(fabricInfo->GetVendorId(), kVendorId);
+        EXPECT_EQ(fabricInfo->GetFabricLabel().size(), 0u);
 
-            Crypto::P256PublicKey rootPublicKeyOfFabric;
-            NL_TEST_ASSERT_SUCCESS(inSuite, fabricTable.FetchRootPubkey(newFabricIndex, rootPublicKeyOfFabric));
-            NL_TEST_ASSERT(inSuite, rootPublicKeyOfFabric.Matches(rcacPublicKey));
-        }
+        Crypto::P256PublicKey rootPublicKeyOfFabric;
+        EXPECT_EQ(fabricTable.FetchRootPubkey(newFabricIndex, rootPublicKeyOfFabric), CHIP_NO_ERROR);
+        EXPECT_TRUE(rootPublicKeyOfFabric.Matches(rcacPublicKey));
 
         // Validate that fabric has the correct operational key by verifying a signature
         {
@@ -1906,10 +1847,10 @@
             uint8_t message[] = { 'm', 's', 'g' };
 
             Crypto::P256PublicKey nocPubKey;
-            NL_TEST_ASSERT_SUCCESS(inSuite, VerifyCertificateSigningRequest(csrSpan.data(), csrSpan.size(), nocPubKey));
+            EXPECT_EQ(VerifyCertificateSigningRequest(csrSpan.data(), csrSpan.size(), nocPubKey), CHIP_NO_ERROR);
 
-            NL_TEST_ASSERT_SUCCESS(inSuite, fabricTable.SignWithOpKeypair(newFabricIndex, ByteSpan{ message }, sig));
-            NL_TEST_ASSERT_SUCCESS(inSuite, nocPubKey.ECDSA_validate_msg_signature(&message[0], sizeof(message), sig));
+            EXPECT_EQ(fabricTable.SignWithOpKeypair(newFabricIndex, ByteSpan{ message }, sig), CHIP_NO_ERROR);
+            EXPECT_EQ(nocPubKey.ECDSA_validate_msg_signature(&message[0], sizeof(message), sig), CHIP_NO_ERROR);
         }
 
         // Verify we can now see the fabric with the iterator
@@ -1921,14 +1862,14 @@
                 ++numFabricsIterated;
                 if (iterFabricInfo.GetFabricIndex() == 1)
                 {
-                    NL_TEST_ASSERT(inSuite, iterFabricInfo.GetNodeId() == 999);
-                    NL_TEST_ASSERT(inSuite, iterFabricInfo.GetFabricId() == 44);
+                    EXPECT_EQ(iterFabricInfo.GetNodeId(), 999u);
+                    EXPECT_EQ(iterFabricInfo.GetFabricId(), 44u);
                     saw1 = true;
                 }
             }
 
-            NL_TEST_ASSERT(inSuite, numFabricsIterated == 1);
-            NL_TEST_ASSERT(inSuite, saw1 == true);
+            EXPECT_EQ(numFabricsIterated, 1u);
+            EXPECT_TRUE(saw1);
         }
     }
 
@@ -1944,20 +1885,20 @@
         MutableByteSpan csrSpan{ csrBuf };
 
         // Make sure to tag fabric index to pending opkey: otherwise the UpdateNOC fails
-        NL_TEST_ASSERT_SUCCESS(inSuite,
-                               fabricTable.AllocatePendingOperationalKey(chip::MakeOptional(static_cast<FabricIndex>(1)), csrSpan));
+        EXPECT_EQ(fabricTable.AllocatePendingOperationalKey(chip::MakeOptional(static_cast<FabricIndex>(1)), csrSpan),
+                  CHIP_NO_ERROR);
 
-        NL_TEST_ASSERT_SUCCESS(inSuite,
-                               fabric44CertAuthority.SetIncludeIcac(false).GenerateNocChain(fabricId, nodeId, csrSpan).GetStatus());
+        EXPECT_EQ(fabric44CertAuthority.SetIncludeIcac(false).GenerateNocChain(fabricId, nodeId, csrSpan).GetStatus(),
+                  CHIP_NO_ERROR);
         ByteSpan rcac = fabric44CertAuthority.GetRcac();
         ByteSpan noc  = fabric44CertAuthority.GetNoc();
 
-        NL_TEST_ASSERT_EQUALS(inSuite, fabricTable.FabricCount(), 1);
-        NL_TEST_ASSERT_SUCCESS(inSuite, fabricTable.UpdatePendingFabricWithOperationalKeystore(1, noc, ByteSpan{}));
-        NL_TEST_ASSERT_EQUALS(inSuite, fabricTable.FabricCount(), 1);
+        EXPECT_EQ(fabricTable.FabricCount(), 1);
+        EXPECT_EQ(fabricTable.UpdatePendingFabricWithOperationalKeystore(1, noc, ByteSpan{}), CHIP_NO_ERROR);
+        EXPECT_EQ(fabricTable.FabricCount(), 1);
 
         // No storage yet
-        NL_TEST_ASSERT(inSuite, storage.GetNumKeys() == numStorageAfterAdd);
+        EXPECT_EQ(storage.GetNumKeys(), numStorageAfterAdd);
 
         // Validate iterator sees the pending data
         {
@@ -1968,62 +1909,58 @@
                 ++numFabricsIterated;
                 if (iterFabricInfo.GetFabricIndex() == 1)
                 {
-                    NL_TEST_ASSERT(inSuite, iterFabricInfo.GetNodeId() == 1000);
-                    NL_TEST_ASSERT(inSuite, iterFabricInfo.GetFabricId() == 44);
-                    NL_TEST_ASSERT(inSuite, iterFabricInfo.ShouldAdvertiseIdentity());
+                    EXPECT_EQ(iterFabricInfo.GetNodeId(), 1000u);
+                    EXPECT_EQ(iterFabricInfo.GetFabricId(), 44u);
+                    EXPECT_TRUE(iterFabricInfo.ShouldAdvertiseIdentity());
                     saw1 = true;
                 }
             }
 
-            NL_TEST_ASSERT(inSuite, numFabricsIterated == 1);
-            NL_TEST_ASSERT(inSuite, saw1 == true);
+            EXPECT_EQ(numFabricsIterated, 1u);
+            EXPECT_TRUE(saw1);
         }
 
         // Revert, should see Node ID 999 again
         fabricTable.RevertPendingFabricData();
-        NL_TEST_ASSERT_EQUALS(inSuite, fabricTable.FabricCount(), 1);
+        EXPECT_EQ(fabricTable.FabricCount(), 1);
 
-        NL_TEST_ASSERT_EQUALS(inSuite, storage.GetNumKeys(), numStorageAfterAdd);
+        EXPECT_EQ(storage.GetNumKeys(), numStorageAfterAdd);
 
         // Validate contents
         const auto * fabricInfo = fabricTable.FindFabricWithIndex(1);
-        NL_TEST_ASSERT(inSuite, fabricInfo != nullptr);
-        if (fabricInfo != nullptr)
+        ASSERT_NE(fabricInfo, nullptr);
         {
             Credentials::ChipCertificateSet certificates;
-            NL_TEST_ASSERT_SUCCESS(inSuite, certificates.Init(1));
-            NL_TEST_ASSERT_SUCCESS(inSuite,
-                                   certificates.LoadCert(rcac, BitFlags<CertDecodeFlags>(CertDecodeFlags::kIsTrustAnchor)));
+            EXPECT_EQ(certificates.Init(1), CHIP_NO_ERROR);
+            EXPECT_EQ(certificates.LoadCert(rcac, BitFlags<CertDecodeFlags>(CertDecodeFlags::kIsTrustAnchor)), CHIP_NO_ERROR);
             Crypto::P256PublicKey rcacPublicKey(certificates.GetCertSet()[0].mPublicKey);
 
-            NL_TEST_ASSERT(inSuite, fabricInfo->GetFabricIndex() == fabricIndex);
-            NL_TEST_ASSERT(inSuite, fabricInfo->GetNodeId() == 999);
-            NL_TEST_ASSERT(inSuite, fabricInfo->GetFabricId() == 44);
-            NL_TEST_ASSERT(inSuite, fabricInfo->GetVendorId() == kVendorId);
-            NL_TEST_ASSERT(inSuite, fabricInfo->GetFabricLabel().size() == 0);
+            EXPECT_EQ(fabricInfo->GetFabricIndex(), fabricIndex);
+            EXPECT_EQ(fabricInfo->GetNodeId(), 999u);
+            EXPECT_EQ(fabricInfo->GetFabricId(), 44u);
+            EXPECT_EQ(fabricInfo->GetVendorId(), kVendorId);
+            EXPECT_EQ(fabricInfo->GetFabricLabel().size(), 0u);
 
             Crypto::P256PublicKey rootPublicKeyOfFabric;
-            NL_TEST_ASSERT_SUCCESS(inSuite, fabricTable.FetchRootPubkey(fabricIndex, rootPublicKeyOfFabric));
-            NL_TEST_ASSERT(inSuite, rootPublicKeyOfFabric.Matches(rcacPublicKey));
+            EXPECT_EQ(fabricTable.FetchRootPubkey(fabricIndex, rootPublicKeyOfFabric), CHIP_NO_ERROR);
+            EXPECT_TRUE(rootPublicKeyOfFabric.Matches(rcacPublicKey));
         }
 
         // Validate that fabric has the correct operational key by verifying a signature
         {
             uint8_t nocBuf[Credentials::kMaxCHIPCertLength];
             MutableByteSpan nocSpan{ nocBuf };
-            NL_TEST_ASSERT_SUCCESS(inSuite, fabricTable.FetchNOCCert(1, nocSpan));
-
+            EXPECT_EQ(fabricTable.FetchNOCCert(1, nocSpan), CHIP_NO_ERROR);
             Credentials::ChipCertificateSet certificates;
-            NL_TEST_ASSERT_SUCCESS(inSuite, certificates.Init(1));
-            NL_TEST_ASSERT_SUCCESS(inSuite,
-                                   certificates.LoadCert(nocSpan, BitFlags<CertDecodeFlags>(CertDecodeFlags::kIsTrustAnchor)));
+            EXPECT_EQ(certificates.Init(1), CHIP_NO_ERROR);
+            EXPECT_EQ(certificates.LoadCert(nocSpan, BitFlags<CertDecodeFlags>(CertDecodeFlags::kIsTrustAnchor)), CHIP_NO_ERROR);
             Crypto::P256PublicKey nocPubKey(certificates.GetCertSet()[0].mPublicKey);
 
             Crypto::P256ECDSASignature sig;
             uint8_t message[] = { 'm', 's', 'g' };
 
-            NL_TEST_ASSERT_SUCCESS(inSuite, fabricTable.SignWithOpKeypair(fabricIndex, ByteSpan{ message }, sig));
-            NL_TEST_ASSERT_SUCCESS(inSuite, nocPubKey.ECDSA_validate_msg_signature(&message[0], sizeof(message), sig));
+            EXPECT_EQ(fabricTable.SignWithOpKeypair(fabricIndex, ByteSpan{ message }, sig), CHIP_NO_ERROR);
+            EXPECT_EQ(nocPubKey.ECDSA_validate_msg_signature(&message[0], sizeof(message), sig), CHIP_NO_ERROR);
         }
 
         // Validate iterator sees the previous fabric
@@ -2035,14 +1972,14 @@
                 ++numFabricsIterated;
                 if (iterFabricInfo.GetFabricIndex() == 1)
                 {
-                    NL_TEST_ASSERT(inSuite, iterFabricInfo.GetNodeId() == 999);
-                    NL_TEST_ASSERT(inSuite, iterFabricInfo.GetFabricId() == 44);
+                    EXPECT_EQ(iterFabricInfo.GetNodeId(), 999u);
+                    EXPECT_EQ(iterFabricInfo.GetFabricId(), 44u);
                     saw1 = true;
                 }
             }
 
-            NL_TEST_ASSERT(inSuite, numFabricsIterated == 1);
-            NL_TEST_ASSERT(inSuite, saw1 == true);
+            EXPECT_EQ(numFabricsIterated, 1u);
+            EXPECT_TRUE(saw1);
         }
     }
 
@@ -2056,20 +1993,20 @@
         MutableByteSpan csrSpan{ csrBuf };
 
         // Make sure to tag fabric index to pending opkey: otherwise the UpdateNOC fails
-        NL_TEST_ASSERT_SUCCESS(inSuite,
-                               fabricTable.AllocatePendingOperationalKey(chip::MakeOptional(static_cast<FabricIndex>(1)), csrSpan));
+        EXPECT_EQ(fabricTable.AllocatePendingOperationalKey(chip::MakeOptional(static_cast<FabricIndex>(1)), csrSpan),
+                  CHIP_NO_ERROR);
 
-        NL_TEST_ASSERT_SUCCESS(inSuite,
-                               fabric44CertAuthority.SetIncludeIcac(false).GenerateNocChain(fabricId, nodeId, csrSpan).GetStatus());
+        EXPECT_EQ(fabric44CertAuthority.SetIncludeIcac(false).GenerateNocChain(fabricId, nodeId, csrSpan).GetStatus(),
+                  CHIP_NO_ERROR);
         ByteSpan rcac = fabric44CertAuthority.GetRcac();
         ByteSpan noc  = fabric44CertAuthority.GetNoc();
 
-        NL_TEST_ASSERT_EQUALS(inSuite, fabricTable.FabricCount(), 1);
-        NL_TEST_ASSERT_SUCCESS(inSuite, fabricTable.UpdatePendingFabricWithOperationalKeystore(1, noc, ByteSpan{}));
-        NL_TEST_ASSERT_EQUALS(inSuite, fabricTable.FabricCount(), 1);
+        EXPECT_EQ(fabricTable.FabricCount(), 1);
+        EXPECT_EQ(fabricTable.UpdatePendingFabricWithOperationalKeystore(1, noc, ByteSpan{}), CHIP_NO_ERROR);
+        EXPECT_EQ(fabricTable.FabricCount(), 1);
 
         // No storage yet
-        NL_TEST_ASSERT(inSuite, storage.GetNumKeys() == numStorageAfterAdd);
+        EXPECT_EQ(storage.GetNumKeys(), numStorageAfterAdd);
 
         // Validate iterator sees the pending data
         {
@@ -2080,55 +2017,51 @@
                 ++numFabricsIterated;
                 if (iterFabricInfo.GetFabricIndex() == 1)
                 {
-                    NL_TEST_ASSERT(inSuite, iterFabricInfo.GetNodeId() == 1001);
-                    NL_TEST_ASSERT(inSuite, iterFabricInfo.GetFabricId() == 44);
-                    NL_TEST_ASSERT(inSuite, iterFabricInfo.ShouldAdvertiseIdentity());
+                    EXPECT_EQ(iterFabricInfo.GetNodeId(), 1001u);
+                    EXPECT_EQ(iterFabricInfo.GetFabricId(), 44u);
+                    EXPECT_TRUE(iterFabricInfo.ShouldAdvertiseIdentity());
                     saw1 = true;
                 }
             }
 
-            NL_TEST_ASSERT(inSuite, numFabricsIterated == 1);
-            NL_TEST_ASSERT(inSuite, saw1 == true);
+            EXPECT_EQ(numFabricsIterated, 1u);
+            EXPECT_TRUE(saw1);
         }
 
         // Commit, should see Node ID 1001, and 1 less cert in the storage
-        NL_TEST_ASSERT_SUCCESS(inSuite, fabricTable.CommitPendingFabricData());
+        EXPECT_EQ(fabricTable.CommitPendingFabricData(), CHIP_NO_ERROR);
 
-        NL_TEST_ASSERT_EQUALS(inSuite, fabricTable.FabricCount(), 1);
-        NL_TEST_ASSERT_EQUALS(inSuite, storage.GetNumKeys(), numStorageAfterAdd - 1);
+        EXPECT_EQ(fabricTable.FabricCount(), 1);
+        EXPECT_EQ(storage.GetNumKeys(), numStorageAfterAdd - 1);
 
         // Validate contents
         const auto * fabricInfo = fabricTable.FindFabricWithIndex(1);
-        NL_TEST_ASSERT(inSuite, fabricInfo != nullptr);
-        if (fabricInfo != nullptr)
-        {
-            Credentials::ChipCertificateSet certificates;
-            NL_TEST_ASSERT_SUCCESS(inSuite, certificates.Init(1));
-            NL_TEST_ASSERT_SUCCESS(inSuite,
-                                   certificates.LoadCert(rcac, BitFlags<CertDecodeFlags>(CertDecodeFlags::kIsTrustAnchor)));
-            Crypto::P256PublicKey rcacPublicKey(certificates.GetCertSet()[0].mPublicKey);
+        ASSERT_NE(fabricInfo, nullptr);
+        Credentials::ChipCertificateSet certificates;
+        EXPECT_EQ(certificates.Init(1), CHIP_NO_ERROR);
+        EXPECT_EQ(certificates.LoadCert(rcac, BitFlags<CertDecodeFlags>(CertDecodeFlags::kIsTrustAnchor)), CHIP_NO_ERROR);
+        Crypto::P256PublicKey rcacPublicKey(certificates.GetCertSet()[0].mPublicKey);
 
-            NL_TEST_ASSERT(inSuite, fabricInfo->GetFabricIndex() == fabricIndex);
-            NL_TEST_ASSERT(inSuite, fabricInfo->GetNodeId() == 1001);
-            NL_TEST_ASSERT(inSuite, fabricInfo->GetFabricId() == 44);
-            NL_TEST_ASSERT(inSuite, fabricInfo->GetVendorId() == kVendorId);
-            NL_TEST_ASSERT(inSuite, fabricInfo->GetFabricLabel().size() == 0);
+        EXPECT_EQ(fabricInfo->GetFabricIndex(), fabricIndex);
+        EXPECT_EQ(fabricInfo->GetNodeId(), 1001u);
+        EXPECT_EQ(fabricInfo->GetFabricId(), 44u);
+        EXPECT_EQ(fabricInfo->GetVendorId(), kVendorId);
+        EXPECT_EQ(fabricInfo->GetFabricLabel().size(), 0u);
 
-            Crypto::P256PublicKey rootPublicKeyOfFabric;
-            NL_TEST_ASSERT_SUCCESS(inSuite, fabricTable.FetchRootPubkey(fabricIndex, rootPublicKeyOfFabric));
-            NL_TEST_ASSERT(inSuite, rootPublicKeyOfFabric.Matches(rcacPublicKey));
-        }
+        Crypto::P256PublicKey rootPublicKeyOfFabric;
+        EXPECT_EQ(fabricTable.FetchRootPubkey(fabricIndex, rootPublicKeyOfFabric), CHIP_NO_ERROR);
+        EXPECT_TRUE(rootPublicKeyOfFabric.Matches(rcacPublicKey));
 
         // Validate that fabric has the correct operational key by verifying a signature
         {
             Crypto::P256PublicKey nocPubKey;
-            NL_TEST_ASSERT_SUCCESS(inSuite, VerifyCertificateSigningRequest(csrSpan.data(), csrSpan.size(), nocPubKey));
+            EXPECT_EQ(VerifyCertificateSigningRequest(csrSpan.data(), csrSpan.size(), nocPubKey), CHIP_NO_ERROR);
 
             Crypto::P256ECDSASignature sig;
             uint8_t message[] = { 'm', 's', 'g' };
 
-            NL_TEST_ASSERT_SUCCESS(inSuite, fabricTable.SignWithOpKeypair(fabricIndex, ByteSpan{ message }, sig));
-            NL_TEST_ASSERT_SUCCESS(inSuite, nocPubKey.ECDSA_validate_msg_signature(&message[0], sizeof(message), sig));
+            EXPECT_EQ(fabricTable.SignWithOpKeypair(fabricIndex, ByteSpan{ message }, sig), CHIP_NO_ERROR);
+            EXPECT_EQ(nocPubKey.ECDSA_validate_msg_signature(&message[0], sizeof(message), sig), CHIP_NO_ERROR);
         }
 
         // Validate iterator sees the updated fabric
@@ -2140,32 +2073,32 @@
                 ++numFabricsIterated;
                 if (iterFabricInfo.GetFabricIndex() == 1)
                 {
-                    NL_TEST_ASSERT(inSuite, iterFabricInfo.GetNodeId() == 1001);
-                    NL_TEST_ASSERT(inSuite, iterFabricInfo.GetFabricId() == 44);
+                    EXPECT_EQ(iterFabricInfo.GetNodeId(), 1001u);
+                    EXPECT_EQ(iterFabricInfo.GetFabricId(), 44u);
                     saw1 = true;
                 }
             }
 
-            NL_TEST_ASSERT(inSuite, numFabricsIterated == 1);
-            NL_TEST_ASSERT(inSuite, saw1 == true);
+            EXPECT_EQ(numFabricsIterated, 1u);
+            EXPECT_TRUE(saw1);
         }
     }
 }
 
-void TestAddRootCertFailSafe(nlTestSuite * inSuite, void * inContext)
+TEST_F(TestFabricTable, TestAddRootCertFailSafe)
 {
     Credentials::TestOnlyLocalCertificateAuthority fabric11CertAuthority;
 
     chip::TestPersistentStorageDelegate storage;
 
-    NL_TEST_ASSERT(inSuite, fabric11CertAuthority.Init().IsSuccess());
+    EXPECT_TRUE(fabric11CertAuthority.Init().IsSuccess());
 
     // Initialize a fabric table.
     ScopedFabricTable fabricTableHolder;
-    NL_TEST_ASSERT(inSuite, fabricTableHolder.Init(&storage) == CHIP_NO_ERROR);
+    EXPECT_EQ(fabricTableHolder.Init(&storage), CHIP_NO_ERROR);
     FabricTable & fabricTable = fabricTableHolder.GetFabricTable();
 
-    NL_TEST_ASSERT_EQUALS(inSuite, fabricTable.FabricCount(), 0);
+    EXPECT_EQ(fabricTable.FabricCount(), 0);
 
     // Add a root cert, see that pending works, and that revert works
     {
@@ -2175,15 +2108,15 @@
         {
             // No pending root cert yet.
             MutableByteSpan fetchedSpan{ rcacBuf };
-            NL_TEST_ASSERT(inSuite, fabricTable.FetchPendingNonFabricAssociatedRootCert(fetchedSpan) == CHIP_ERROR_NOT_FOUND);
+            EXPECT_EQ(fabricTable.FetchPendingNonFabricAssociatedRootCert(fetchedSpan), CHIP_ERROR_NOT_FOUND);
         }
 
-        NL_TEST_ASSERT_SUCCESS(inSuite, fabricTable.AddNewPendingTrustedRootCert(rcac));
+        EXPECT_EQ(fabricTable.AddNewPendingTrustedRootCert(rcac), CHIP_NO_ERROR);
         {
             // Now have a pending root cert.
             MutableByteSpan fetchedSpan{ rcacBuf };
-            NL_TEST_ASSERT_SUCCESS(inSuite, fabricTable.FetchPendingNonFabricAssociatedRootCert(fetchedSpan));
-            NL_TEST_ASSERT(inSuite, fetchedSpan.data_equal(rcac));
+            EXPECT_EQ(fabricTable.FetchPendingNonFabricAssociatedRootCert(fetchedSpan), CHIP_NO_ERROR);
+            EXPECT_TRUE(fetchedSpan.data_equal(rcac));
         }
 
         // Revert
@@ -2192,31 +2125,31 @@
         {
             // No pending root cert anymore.
             MutableByteSpan fetchedSpan{ rcacBuf };
-            NL_TEST_ASSERT(inSuite, fabricTable.FetchPendingNonFabricAssociatedRootCert(fetchedSpan) == CHIP_ERROR_NOT_FOUND);
+            EXPECT_EQ(fabricTable.FetchPendingNonFabricAssociatedRootCert(fetchedSpan), CHIP_ERROR_NOT_FOUND);
         }
     }
 }
 
-void TestSequenceErrors(nlTestSuite * inSuite, void * inContext)
+TEST_F(TestFabricTable, TestSequenceErrors)
 {
     // TODO: Write test
 }
 
-void TestFabricLabelChange(nlTestSuite * inSuite, void * inContext)
+TEST_F(TestFabricTable, TestFabricLabelChange)
 {
     Credentials::TestOnlyLocalCertificateAuthority fabricCertAuthority;
 
     chip::TestPersistentStorageDelegate storage;
-    NL_TEST_ASSERT(inSuite, fabricCertAuthority.Init().IsSuccess());
+    EXPECT_TRUE(fabricCertAuthority.Init().IsSuccess());
 
     constexpr uint16_t kVendorId = 0xFFF1u;
 
     // Initialize a fabric table.
     ScopedFabricTable fabricTableHolder;
-    NL_TEST_ASSERT(inSuite, fabricTableHolder.Init(&storage) == CHIP_NO_ERROR);
+    EXPECT_EQ(fabricTableHolder.Init(&storage), CHIP_NO_ERROR);
     FabricTable & fabricTable = fabricTableHolder.GetFabricTable();
 
-    NL_TEST_ASSERT_EQUALS(inSuite, fabricTable.FabricCount(), 0);
+    EXPECT_EQ(fabricTable.FabricCount(), 0);
 
     // First scope: add FabricID 1111, node ID 55
     {
@@ -2225,68 +2158,63 @@
 
         uint8_t csrBuf[chip::Crypto::kMIN_CSR_Buffer_Size];
         MutableByteSpan csrSpan{ csrBuf };
-        NL_TEST_ASSERT_SUCCESS(inSuite, fabricTable.AllocatePendingOperationalKey(chip::NullOptional, csrSpan));
+        EXPECT_EQ(fabricTable.AllocatePendingOperationalKey(chip::NullOptional, csrSpan), CHIP_NO_ERROR);
 
-        NL_TEST_ASSERT_SUCCESS(inSuite,
-                               fabricCertAuthority.SetIncludeIcac(true).GenerateNocChain(fabricId, nodeId, csrSpan).GetStatus());
+        EXPECT_EQ(fabricCertAuthority.SetIncludeIcac(true).GenerateNocChain(fabricId, nodeId, csrSpan).GetStatus(), CHIP_NO_ERROR);
         ByteSpan rcac = fabricCertAuthority.GetRcac();
         ByteSpan icac = fabricCertAuthority.GetIcac();
         ByteSpan noc  = fabricCertAuthority.GetNoc();
 
-        NL_TEST_ASSERT_EQUALS(inSuite, fabricTable.FabricCount(), 0);
-        NL_TEST_ASSERT_SUCCESS(inSuite, fabricTable.AddNewPendingTrustedRootCert(rcac));
+        EXPECT_EQ(fabricTable.FabricCount(), 0);
+        EXPECT_EQ(fabricTable.AddNewPendingTrustedRootCert(rcac), CHIP_NO_ERROR);
         FabricIndex newFabricIndex = kUndefinedFabricIndex;
-        NL_TEST_ASSERT_SUCCESS(inSuite,
-                               fabricTable.AddNewPendingFabricWithOperationalKeystore(noc, icac, kVendorId, &newFabricIndex));
-        NL_TEST_ASSERT_EQUALS(inSuite, fabricTable.FabricCount(), 1);
-        NL_TEST_ASSERT(inSuite, newFabricIndex == 1);
+        EXPECT_EQ(fabricTable.AddNewPendingFabricWithOperationalKeystore(noc, icac, kVendorId, &newFabricIndex), CHIP_NO_ERROR);
+        EXPECT_EQ(fabricTable.FabricCount(), 1);
+        EXPECT_EQ(newFabricIndex, 1);
 
-        NL_TEST_ASSERT_SUCCESS(inSuite, fabricTable.CommitPendingFabricData());
+        EXPECT_EQ(fabricTable.CommitPendingFabricData(), CHIP_NO_ERROR);
 
         // Validate contents
         const auto * fabricInfo = fabricTable.FindFabricWithIndex(1);
-        NL_TEST_ASSERT(inSuite, fabricInfo != nullptr);
-        if (fabricInfo != nullptr)
-        {
-            NL_TEST_ASSERT(inSuite, fabricInfo->GetFabricIndex() == 1);
-            NL_TEST_ASSERT(inSuite, fabricInfo->GetNodeId() == 55);
-            NL_TEST_ASSERT(inSuite, fabricInfo->GetFabricId() == 1111);
-            NL_TEST_ASSERT(inSuite, fabricInfo->GetVendorId() == kVendorId);
-            NL_TEST_ASSERT(inSuite, fabricInfo->GetFabricLabel().size() == 0);
-        }
+        ASSERT_NE(fabricInfo, nullptr);
+        EXPECT_EQ(fabricInfo->GetFabricIndex(), 1);
+        EXPECT_EQ(fabricInfo->GetNodeId(), 55u);
+        EXPECT_EQ(fabricInfo->GetFabricId(), 1111u);
+        EXPECT_EQ(fabricInfo->GetVendorId(), kVendorId);
+        EXPECT_EQ(fabricInfo->GetFabricLabel().size(), 0u);
     }
     size_t numStorageKeysAfterFirstAdd = storage.GetNumKeys();
-    NL_TEST_ASSERT(inSuite, numStorageKeysAfterFirstAdd == 7); // Metadata, index, 3 certs, 1 opkey, last known good time
+    EXPECT_EQ(numStorageKeysAfterFirstAdd, 7u); // Metadata, index, 3 certs, 1 opkey, last known good time
 
     // Second scope: set FabricLabel to "acme fabric", make sure it cannot be reverted
     {
         // Fabric label starts unset from prior scope
         CharSpan fabricLabel = "placeholder"_span;
 
-        NL_TEST_ASSERT_SUCCESS(inSuite, fabricTable.GetFabricLabel(1, fabricLabel));
-        NL_TEST_ASSERT(inSuite, fabricLabel.size() == 0);
+        EXPECT_EQ(fabricTable.GetFabricLabel(1, fabricLabel), CHIP_NO_ERROR);
+        EXPECT_EQ(fabricLabel.size(), 0u);
 
         // Set a valid name
-        NL_TEST_ASSERT_SUCCESS(inSuite, fabricTable.SetFabricLabel(1, "acme fabric"_span));
-        NL_TEST_ASSERT_SUCCESS(inSuite, fabricTable.GetFabricLabel(1, fabricLabel));
-        NL_TEST_ASSERT(inSuite, fabricLabel.data_equal("acme fabric"_span) == true);
+        EXPECT_EQ(fabricTable.SetFabricLabel(1, "acme fabric"_span), CHIP_NO_ERROR);
+        EXPECT_EQ(fabricTable.GetFabricLabel(1, fabricLabel), CHIP_NO_ERROR);
+        EXPECT_TRUE(fabricLabel.data_equal("acme fabric"_span));
 
         // Revert pending fabric data. Should not revert name since nothing pending.
         fabricTable.RevertPendingFabricData();
 
         fabricLabel = "placeholder"_span;
-        NL_TEST_ASSERT_SUCCESS(inSuite, fabricTable.GetFabricLabel(1, fabricLabel));
-        NL_TEST_ASSERT(inSuite, fabricLabel.data_equal("acme fabric"_span) == true);
+        EXPECT_EQ(fabricTable.GetFabricLabel(1, fabricLabel), CHIP_NO_ERROR);
+        EXPECT_TRUE(fabricLabel.data_equal("acme fabric"_span));
 
         // Verify we fail to set too large a label (> kFabricLabelMaxLengthInBytes)
         CharSpan fabricLabelTooBig = "012345678901234567890123456789123456"_span;
-        NL_TEST_ASSERT(inSuite, fabricLabelTooBig.size() > chip::kFabricLabelMaxLengthInBytes);
+        EXPECT_GT(fabricLabelTooBig.size(), chip::kFabricLabelMaxLengthInBytes);
 
-        NL_TEST_ASSERT(inSuite, fabricTable.SetFabricLabel(1, fabricLabelTooBig) == CHIP_ERROR_INVALID_ARGUMENT);
+        EXPECT_EQ(fabricTable.SetFabricLabel(1, fabricLabelTooBig), CHIP_ERROR_INVALID_ARGUMENT);
 
         fabricLabel = "placeholder"_span;
-        NL_TEST_ASSERT_SUCCESS(inSuite, fabricTable.GetFabricLabel(1, fabricLabel));
-        NL_TEST_ASSERT(inSuite, fabricLabel.data_equal("acme fabric"_span) == true);
+        EXPECT_EQ(fabricTable.GetFabricLabel(1, fabricLabel), CHIP_NO_ERROR);
+        EXPECT_TRUE(fabricLabel.data_equal("acme fabric"_span));
     }
 
     // Third scope: set fabric label after an update, it sticks, but then goes back after revert
@@ -2296,156 +2224,144 @@
 
         uint8_t csrBuf[chip::Crypto::kMIN_CSR_Buffer_Size];
         MutableByteSpan csrSpan{ csrBuf };
-        NL_TEST_ASSERT_SUCCESS(inSuite,
-                               fabricTable.AllocatePendingOperationalKey(chip::MakeOptional(static_cast<FabricIndex>(1)), csrSpan));
+        EXPECT_EQ(fabricTable.AllocatePendingOperationalKey(chip::MakeOptional(static_cast<FabricIndex>(1)), csrSpan),
+                  CHIP_NO_ERROR);
 
-        NL_TEST_ASSERT_SUCCESS(inSuite,
-                               fabricCertAuthority.SetIncludeIcac(true).GenerateNocChain(fabricId, nodeId, csrSpan).GetStatus());
+        EXPECT_EQ(fabricCertAuthority.SetIncludeIcac(true).GenerateNocChain(fabricId, nodeId, csrSpan).GetStatus(), CHIP_NO_ERROR);
         ByteSpan icac = fabricCertAuthority.GetIcac();
         ByteSpan noc  = fabricCertAuthority.GetNoc();
 
-        NL_TEST_ASSERT_EQUALS(inSuite, fabricTable.FabricCount(), 1);
-        NL_TEST_ASSERT_SUCCESS(inSuite, fabricTable.UpdatePendingFabricWithOperationalKeystore(1, noc, icac));
-        NL_TEST_ASSERT_EQUALS(inSuite, fabricTable.FabricCount(), 1);
+        EXPECT_EQ(fabricTable.FabricCount(), 1);
+        EXPECT_EQ(fabricTable.UpdatePendingFabricWithOperationalKeystore(1, noc, icac), CHIP_NO_ERROR);
+        EXPECT_EQ(fabricTable.FabricCount(), 1);
 
         // Validate contents prior to change/revert
         const auto * fabricInfo = fabricTable.FindFabricWithIndex(1);
-        NL_TEST_ASSERT(inSuite, fabricInfo != nullptr);
 
-        if (fabricInfo != nullptr)
-        {
-            NL_TEST_ASSERT(inSuite, fabricInfo->GetFabricIndex() == 1);
-            NL_TEST_ASSERT(inSuite, fabricInfo->GetNodeId() == 66);
-            NL_TEST_ASSERT(inSuite, fabricInfo->GetFabricId() == 1111);
-            NL_TEST_ASSERT(inSuite, fabricInfo->GetVendorId() == kVendorId);
+        ASSERT_NE(fabricInfo, nullptr);
+        EXPECT_EQ(fabricInfo->GetFabricIndex(), 1);
+        EXPECT_EQ(fabricInfo->GetNodeId(), 66u);
+        EXPECT_EQ(fabricInfo->GetFabricId(), 1111u);
+        EXPECT_EQ(fabricInfo->GetVendorId(), kVendorId);
 
-            CharSpan fabricLabel = fabricInfo->GetFabricLabel();
-            NL_TEST_ASSERT(inSuite, fabricLabel.data_equal("acme fabric"_span) == true);
-        }
+        CharSpan fabricLabel = fabricInfo->GetFabricLabel();
+        EXPECT_TRUE(fabricLabel.data_equal("acme fabric"_span));
 
         // Update fabric label
-        CharSpan fabricLabel = "placeholder"_span;
-        NL_TEST_ASSERT_SUCCESS(inSuite, fabricTable.SetFabricLabel(1, "roboto fabric"_span));
+        fabricLabel = "placeholder"_span;
+        EXPECT_EQ(fabricTable.SetFabricLabel(1, "roboto fabric"_span), CHIP_NO_ERROR);
 
         fabricLabel = "placeholder"_span;
-        NL_TEST_ASSERT_SUCCESS(inSuite, fabricTable.GetFabricLabel(1, fabricLabel));
-        NL_TEST_ASSERT(inSuite, fabricLabel.data_equal("roboto fabric"_span) == true);
+        EXPECT_EQ(fabricTable.GetFabricLabel(1, fabricLabel), CHIP_NO_ERROR);
+        EXPECT_TRUE(fabricLabel.data_equal("roboto fabric"_span));
 
         // Revert pending fabric data. Should revert name to "acme fabric"
         fabricTable.RevertPendingFabricData();
 
         fabricLabel = "placeholder"_span;
-        NL_TEST_ASSERT_SUCCESS(inSuite, fabricTable.GetFabricLabel(1, fabricLabel));
-        NL_TEST_ASSERT(inSuite, fabricLabel.data_equal("acme fabric"_span) == true);
+        EXPECT_EQ(fabricTable.GetFabricLabel(1, fabricLabel), CHIP_NO_ERROR);
+        EXPECT_TRUE(fabricLabel.data_equal("acme fabric"_span));
     }
 }
 
-void TestCompressedFabricId(nlTestSuite * inSuite, void * inContext)
+TEST_F(TestFabricTable, TestCompressedFabricId)
 {
     // TODO: Write test
 }
 
-void TestFabricLookup(nlTestSuite * inSuite, void * inContext)
+TEST_F(TestFabricTable, TestFabricLookup)
 {
     // Initialize a fabric table.
     chip::TestPersistentStorageDelegate testStorage;
     ScopedFabricTable fabricTableHolder;
-    NL_TEST_ASSERT(inSuite, fabricTableHolder.Init(&testStorage) == CHIP_NO_ERROR);
+    EXPECT_EQ(fabricTableHolder.Init(&testStorage), CHIP_NO_ERROR);
     FabricTable & fabricTable = fabricTableHolder.GetFabricTable();
-    NL_TEST_ASSERT(inSuite, LoadTestFabric_Node01_01(inSuite, fabricTable, /* doCommit = */ true) == CHIP_NO_ERROR);
-    NL_TEST_ASSERT(inSuite,
-                   LoadTestFabric_Node02_01(inSuite, fabricTable, /* doCommit = */ true, FabricTable::AdvertiseIdentity::No) ==
-                       CHIP_NO_ERROR);
+    EXPECT_EQ(LoadTestFabric_Node01_01(fabricTable, /* doCommit = */ true), CHIP_NO_ERROR);
+    EXPECT_EQ(LoadTestFabric_Node02_01(fabricTable, /* doCommit = */ true, FabricTable::AdvertiseIdentity::No), CHIP_NO_ERROR);
 
     // Attempt lookup of the Root01 fabric.
     {
         Crypto::P256PublicKey key;
-        NL_TEST_ASSERT(inSuite, key.Length() >= TestCerts::sTestCert_Root01_PublicKey.size());
+        EXPECT_GE(key.Length(), TestCerts::sTestCert_Root01_PublicKey.size());
         if (key.Length() < TestCerts::sTestCert_Root01_PublicKey.size())
         {
             return;
         }
         memcpy(key.Bytes(), TestCerts::sTestCert_Root01_PublicKey.data(), TestCerts::sTestCert_Root01_PublicKey.size());
         auto fabricInfo = fabricTable.FindFabric(key, 0xFAB000000000001D);
-        NL_TEST_ASSERT(inSuite, fabricInfo != nullptr);
-        if (fabricInfo == nullptr)
-        {
-            return;
-        }
-        NL_TEST_ASSERT(inSuite, fabricInfo->GetFabricIndex() == 1);
-        NL_TEST_ASSERT(inSuite, fabricInfo->ShouldAdvertiseIdentity());
+        ASSERT_NE(fabricInfo, nullptr);
+
+        EXPECT_EQ(fabricInfo->GetFabricIndex(), 1);
+        EXPECT_TRUE(fabricInfo->ShouldAdvertiseIdentity());
     }
 
     // Attempt lookup of the Root02 fabric.
     {
         Crypto::P256PublicKey key;
-        NL_TEST_ASSERT(inSuite, key.Length() >= TestCerts::sTestCert_Root02_PublicKey.size());
+        EXPECT_GE(key.Length(), TestCerts::sTestCert_Root02_PublicKey.size());
         if (key.Length() < TestCerts::sTestCert_Root02_PublicKey.size())
         {
             return;
         }
         memcpy(key.Bytes(), TestCerts::sTestCert_Root02_PublicKey.data(), TestCerts::sTestCert_Root02_PublicKey.size());
         auto fabricInfo = fabricTable.FindFabric(key, 0xFAB000000000001D);
-        NL_TEST_ASSERT(inSuite, fabricInfo != nullptr);
-        if (fabricInfo == nullptr)
-        {
-            return;
-        }
-        NL_TEST_ASSERT(inSuite, fabricInfo->GetFabricIndex() == 2);
-        NL_TEST_ASSERT(inSuite, !fabricInfo->ShouldAdvertiseIdentity());
+        ASSERT_NE(fabricInfo, nullptr);
+
+        EXPECT_EQ(fabricInfo->GetFabricIndex(), 2);
+        EXPECT_FALSE(fabricInfo->ShouldAdvertiseIdentity());
     }
 
     // Attempt lookup of FabricIndex 0 --> should always fail.
     {
-        NL_TEST_ASSERT(inSuite, fabricTable.FindFabricWithIndex(0) == nullptr);
+        EXPECT_EQ(fabricTable.FindFabricWithIndex(0), nullptr);
     }
 }
 
-void TestFetchCATs(nlTestSuite * inSuite, void * inContext)
+TEST_F(TestFabricTable, TestFetchCATs)
 {
     // Initialize a fabric table.
     chip::TestPersistentStorageDelegate testStorage;
     ScopedFabricTable fabricTableHolder;
-    NL_TEST_ASSERT(inSuite, fabricTableHolder.Init(&testStorage) == CHIP_NO_ERROR);
+    EXPECT_EQ(fabricTableHolder.Init(&testStorage), CHIP_NO_ERROR);
     FabricTable & fabricTable = fabricTableHolder.GetFabricTable();
-    NL_TEST_ASSERT(inSuite, LoadTestFabric_Node01_01(inSuite, fabricTable, /* doCommit = */ true) == CHIP_NO_ERROR);
-    NL_TEST_ASSERT(inSuite, LoadTestFabric_Node02_01(inSuite, fabricTable, /* doCommit = */ true) == CHIP_NO_ERROR);
+    EXPECT_EQ(LoadTestFabric_Node01_01(fabricTable, /* doCommit = */ true), CHIP_NO_ERROR);
+    EXPECT_EQ(LoadTestFabric_Node02_01(fabricTable, /* doCommit = */ true), CHIP_NO_ERROR);
 
     // Attempt Fetching fabric index 1 CATs and verify contents.
     {
         CATValues cats;
-        NL_TEST_ASSERT(inSuite, fabricTable.FetchCATs(1, cats) == CHIP_NO_ERROR);
+        EXPECT_EQ(fabricTable.FetchCATs(1, cats), CHIP_NO_ERROR);
         // Test fabric NOCs don't contain any CATs.
-        NL_TEST_ASSERT(inSuite, cats == kUndefinedCATs);
+        EXPECT_EQ(cats, kUndefinedCATs);
     }
 
     // Attempt Fetching fabric index 2 CATs and verify contents.
     {
         CATValues cats;
-        NL_TEST_ASSERT(inSuite, fabricTable.FetchCATs(2, cats) == CHIP_NO_ERROR);
+        EXPECT_EQ(fabricTable.FetchCATs(2, cats), CHIP_NO_ERROR);
         // Test fabric NOCs don't contain any CATs.
-        NL_TEST_ASSERT(inSuite, cats == kUndefinedCATs);
+        EXPECT_EQ(cats, kUndefinedCATs);
     }
 
     // TODO(#20335): Add test cases for NOCs that actually embed CATs
 }
 
 // Validate that adding the same fabric twice fails (same root, same FabricId)
-void TestAddNocRootCollision(nlTestSuite * inSuite, void * inContext)
+TEST_F(TestFabricTable, TestAddNocRootCollision)
 {
     Credentials::TestOnlyLocalCertificateAuthority fabricCertAuthority;
 
     chip::TestPersistentStorageDelegate storage;
-    NL_TEST_ASSERT(inSuite, fabricCertAuthority.Init().IsSuccess());
+    EXPECT_TRUE(fabricCertAuthority.Init().IsSuccess());
 
     constexpr uint16_t kVendorId = 0xFFF1u;
 
     // Initialize a fabric table.
     ScopedFabricTable fabricTableHolder;
-    NL_TEST_ASSERT(inSuite, fabricTableHolder.Init(&storage) == CHIP_NO_ERROR);
+    EXPECT_EQ(fabricTableHolder.Init(&storage), CHIP_NO_ERROR);
     FabricTable & fabricTable = fabricTableHolder.GetFabricTable();
 
-    NL_TEST_ASSERT_EQUALS(inSuite, fabricTable.FabricCount(), 0);
+    EXPECT_EQ(fabricTable.FabricCount(), 0);
 
     // First scope: add FabricID 1111, node ID 55
     {
@@ -2454,51 +2370,46 @@
 
         uint8_t csrBuf[chip::Crypto::kMIN_CSR_Buffer_Size];
         MutableByteSpan csrSpan{ csrBuf };
-        NL_TEST_ASSERT_SUCCESS(inSuite, fabricTable.AllocatePendingOperationalKey(chip::NullOptional, csrSpan));
+        EXPECT_EQ(fabricTable.AllocatePendingOperationalKey(chip::NullOptional, csrSpan), CHIP_NO_ERROR);
 
-        NL_TEST_ASSERT_SUCCESS(inSuite,
-                               fabricCertAuthority.SetIncludeIcac(true).GenerateNocChain(fabricId, nodeId, csrSpan).GetStatus());
+        EXPECT_EQ(fabricCertAuthority.SetIncludeIcac(true).GenerateNocChain(fabricId, nodeId, csrSpan).GetStatus(), CHIP_NO_ERROR);
         ByteSpan rcac = fabricCertAuthority.GetRcac();
         ByteSpan icac = fabricCertAuthority.GetIcac();
         ByteSpan noc  = fabricCertAuthority.GetNoc();
 
-        NL_TEST_ASSERT_EQUALS(inSuite, fabricTable.FabricCount(), 0);
-        NL_TEST_ASSERT_SUCCESS(inSuite, fabricTable.AddNewPendingTrustedRootCert(rcac));
+        EXPECT_EQ(fabricTable.FabricCount(), 0);
+        EXPECT_EQ(fabricTable.AddNewPendingTrustedRootCert(rcac), CHIP_NO_ERROR);
         FabricIndex newFabricIndex = kUndefinedFabricIndex;
-        NL_TEST_ASSERT_SUCCESS(inSuite,
-                               fabricTable.AddNewPendingFabricWithOperationalKeystore(noc, icac, kVendorId, &newFabricIndex,
-                                                                                      FabricTable::AdvertiseIdentity::No));
-        NL_TEST_ASSERT_EQUALS(inSuite, fabricTable.FabricCount(), 1);
-        NL_TEST_ASSERT(inSuite, newFabricIndex == 1);
+        EXPECT_EQ(fabricTable.AddNewPendingFabricWithOperationalKeystore(noc, icac, kVendorId, &newFabricIndex,
+                                                                         FabricTable::AdvertiseIdentity::No),
+                  CHIP_NO_ERROR);
+        EXPECT_EQ(fabricTable.FabricCount(), 1);
+        EXPECT_EQ(newFabricIndex, 1);
 
-        NL_TEST_ASSERT_SUCCESS(inSuite, fabricTable.CommitPendingFabricData());
+        EXPECT_EQ(fabricTable.CommitPendingFabricData(), CHIP_NO_ERROR);
 
         // Validate contents
         const auto * fabricInfo = fabricTable.FindFabricWithIndex(1);
-        NL_TEST_ASSERT(inSuite, fabricInfo != nullptr);
-        if (fabricInfo != nullptr)
-        {
-            NL_TEST_ASSERT(inSuite, !fabricInfo->ShouldAdvertiseIdentity());
+        ASSERT_NE(fabricInfo, nullptr);
+        EXPECT_FALSE(fabricInfo->ShouldAdvertiseIdentity());
 
-            Credentials::ChipCertificateSet certificates;
-            NL_TEST_ASSERT_SUCCESS(inSuite, certificates.Init(1));
-            NL_TEST_ASSERT_SUCCESS(inSuite,
-                                   certificates.LoadCert(rcac, BitFlags<CertDecodeFlags>(CertDecodeFlags::kIsTrustAnchor)));
-            Crypto::P256PublicKey rcacPublicKey(certificates.GetCertSet()[0].mPublicKey);
+        Credentials::ChipCertificateSet certificates;
+        EXPECT_EQ(certificates.Init(1), CHIP_NO_ERROR);
+        EXPECT_EQ(certificates.LoadCert(rcac, BitFlags<CertDecodeFlags>(CertDecodeFlags::kIsTrustAnchor)), CHIP_NO_ERROR);
+        Crypto::P256PublicKey rcacPublicKey(certificates.GetCertSet()[0].mPublicKey);
 
-            NL_TEST_ASSERT(inSuite, fabricInfo->GetFabricIndex() == 1);
-            NL_TEST_ASSERT(inSuite, fabricInfo->GetNodeId() == 55);
-            NL_TEST_ASSERT(inSuite, fabricInfo->GetFabricId() == 1111);
-            NL_TEST_ASSERT(inSuite, fabricInfo->GetVendorId() == kVendorId);
-            NL_TEST_ASSERT(inSuite, fabricInfo->GetFabricLabel().size() == 0);
+        EXPECT_EQ(fabricInfo->GetFabricIndex(), 1);
+        EXPECT_EQ(fabricInfo->GetNodeId(), 55u);
+        EXPECT_EQ(fabricInfo->GetFabricId(), 1111u);
+        EXPECT_EQ(fabricInfo->GetVendorId(), kVendorId);
+        EXPECT_EQ(fabricInfo->GetFabricLabel().size(), 0u);
 
-            Crypto::P256PublicKey rootPublicKeyOfFabric;
-            NL_TEST_ASSERT_SUCCESS(inSuite, fabricTable.FetchRootPubkey(newFabricIndex, rootPublicKeyOfFabric));
-            NL_TEST_ASSERT(inSuite, rootPublicKeyOfFabric.Matches(rcacPublicKey));
-        }
+        Crypto::P256PublicKey rootPublicKeyOfFabric;
+        EXPECT_EQ(fabricTable.FetchRootPubkey(newFabricIndex, rootPublicKeyOfFabric), CHIP_NO_ERROR);
+        EXPECT_TRUE(rootPublicKeyOfFabric.Matches(rcacPublicKey));
     }
     size_t numStorageKeysAfterFirstAdd = storage.GetNumKeys();
-    NL_TEST_ASSERT(inSuite, numStorageKeysAfterFirstAdd == 7); // Metadata, index, 3 certs, 1 opkey, last known good time
+    EXPECT_EQ(numStorageKeysAfterFirstAdd, 7u); // Metadata, index, 3 certs, 1 opkey, last known good time
 
     // Second scope: add FabricID 1111, node ID 55 *again* --> Collision of Root/FabricID with existing
     {
@@ -2507,51 +2418,45 @@
 
         uint8_t csrBuf[chip::Crypto::kMIN_CSR_Buffer_Size];
         MutableByteSpan csrSpan{ csrBuf };
-        NL_TEST_ASSERT_SUCCESS(inSuite, fabricTable.AllocatePendingOperationalKey(chip::NullOptional, csrSpan));
+        EXPECT_EQ(fabricTable.AllocatePendingOperationalKey(chip::NullOptional, csrSpan), CHIP_NO_ERROR);
 
-        NL_TEST_ASSERT_SUCCESS(inSuite,
-                               fabricCertAuthority.SetIncludeIcac(true).GenerateNocChain(fabricId, nodeId, csrSpan).GetStatus());
+        EXPECT_EQ(fabricCertAuthority.SetIncludeIcac(true).GenerateNocChain(fabricId, nodeId, csrSpan).GetStatus(), CHIP_NO_ERROR);
         ByteSpan rcac = fabricCertAuthority.GetRcac();
         ByteSpan icac = fabricCertAuthority.GetIcac();
         ByteSpan noc  = fabricCertAuthority.GetNoc();
 
-        NL_TEST_ASSERT_EQUALS(inSuite, fabricTable.FabricCount(), 1);
-        NL_TEST_ASSERT_SUCCESS(inSuite, fabricTable.AddNewPendingTrustedRootCert(rcac));
+        EXPECT_EQ(fabricTable.FabricCount(), 1);
+        EXPECT_EQ(fabricTable.AddNewPendingTrustedRootCert(rcac), CHIP_NO_ERROR);
         FabricIndex newFabricIndex = kUndefinedFabricIndex;
-        NL_TEST_ASSERT(inSuite,
-                       fabricTable.AddNewPendingFabricWithOperationalKeystore(noc, icac, kVendorId, &newFabricIndex) ==
-                           CHIP_ERROR_FABRIC_EXISTS);
-        NL_TEST_ASSERT_EQUALS(inSuite, fabricTable.FabricCount(), 1);
+        EXPECT_EQ(fabricTable.AddNewPendingFabricWithOperationalKeystore(noc, icac, kVendorId, &newFabricIndex),
+                  CHIP_ERROR_FABRIC_EXISTS);
+        EXPECT_EQ(fabricTable.FabricCount(), 1);
 
         CHIP_ERROR err = fabricTable.CommitPendingFabricData();
         printf("err = %" CHIP_ERROR_FORMAT "\n", err.Format());
-        NL_TEST_ASSERT(inSuite, err == CHIP_ERROR_INCORRECT_STATE);
+        EXPECT_EQ(err, CHIP_ERROR_INCORRECT_STATE);
 
         // Validate contents of Fabric index 1 still valid
         const auto * fabricInfo = fabricTable.FindFabricWithIndex(1);
-        NL_TEST_ASSERT(inSuite, fabricInfo != nullptr);
-        if (fabricInfo != nullptr)
-        {
-            Credentials::ChipCertificateSet certificates;
-            NL_TEST_ASSERT_SUCCESS(inSuite, certificates.Init(1));
-            NL_TEST_ASSERT_SUCCESS(inSuite,
-                                   certificates.LoadCert(rcac, BitFlags<CertDecodeFlags>(CertDecodeFlags::kIsTrustAnchor)));
-            Crypto::P256PublicKey rcacPublicKey(certificates.GetCertSet()[0].mPublicKey);
+        ASSERT_NE(fabricInfo, nullptr);
+        Credentials::ChipCertificateSet certificates;
+        EXPECT_EQ(certificates.Init(1), CHIP_NO_ERROR);
+        EXPECT_EQ(certificates.LoadCert(rcac, BitFlags<CertDecodeFlags>(CertDecodeFlags::kIsTrustAnchor)), CHIP_NO_ERROR);
+        Crypto::P256PublicKey rcacPublicKey(certificates.GetCertSet()[0].mPublicKey);
 
-            NL_TEST_ASSERT(inSuite, fabricInfo->GetFabricIndex() == 1);
-            NL_TEST_ASSERT(inSuite, fabricInfo->GetNodeId() == 55);
-            NL_TEST_ASSERT(inSuite, fabricInfo->GetFabricId() == 1111);
-            NL_TEST_ASSERT(inSuite, fabricInfo->GetVendorId() == kVendorId);
-            NL_TEST_ASSERT(inSuite, fabricInfo->GetFabricLabel().size() == 0);
+        EXPECT_EQ(fabricInfo->GetFabricIndex(), 1);
+        EXPECT_EQ(fabricInfo->GetNodeId(), 55u);
+        EXPECT_EQ(fabricInfo->GetFabricId(), 1111u);
+        EXPECT_EQ(fabricInfo->GetVendorId(), kVendorId);
+        EXPECT_EQ(fabricInfo->GetFabricLabel().size(), 0u);
 
-            Crypto::P256PublicKey rootPublicKeyOfFabric;
-            NL_TEST_ASSERT_SUCCESS(inSuite, fabricTable.FetchRootPubkey(1, rootPublicKeyOfFabric));
-            NL_TEST_ASSERT(inSuite, rootPublicKeyOfFabric.Matches(rcacPublicKey));
-        }
+        Crypto::P256PublicKey rootPublicKeyOfFabric;
+        EXPECT_EQ(fabricTable.FetchRootPubkey(1, rootPublicKeyOfFabric), CHIP_NO_ERROR);
+        EXPECT_TRUE(rootPublicKeyOfFabric.Matches(rcacPublicKey));
     }
 
     // Ensure no new persisted keys after failed colliding add
-    NL_TEST_ASSERT(inSuite, storage.GetNumKeys() == numStorageKeysAfterFirstAdd);
+    EXPECT_EQ(storage.GetNumKeys(), numStorageKeysAfterFirstAdd);
 
     // Third scope: add FabricID 2222, node ID 55 --> Not colliding, should work. The failing commit above]
     // should have been enough of a revert that this scope succeeds without any additional revert.
@@ -2561,70 +2466,64 @@
 
         uint8_t csrBuf[chip::Crypto::kMIN_CSR_Buffer_Size];
         MutableByteSpan csrSpan{ csrBuf };
-        NL_TEST_ASSERT_SUCCESS(inSuite, fabricTable.AllocatePendingOperationalKey(chip::NullOptional, csrSpan));
+        EXPECT_EQ(fabricTable.AllocatePendingOperationalKey(chip::NullOptional, csrSpan), CHIP_NO_ERROR);
 
-        NL_TEST_ASSERT_SUCCESS(inSuite,
-                               fabricCertAuthority.SetIncludeIcac(true).GenerateNocChain(fabricId, nodeId, csrSpan).GetStatus());
+        EXPECT_EQ(fabricCertAuthority.SetIncludeIcac(true).GenerateNocChain(fabricId, nodeId, csrSpan).GetStatus(), CHIP_NO_ERROR);
         ByteSpan rcac = fabricCertAuthority.GetRcac();
         ByteSpan icac = fabricCertAuthority.GetIcac();
         ByteSpan noc  = fabricCertAuthority.GetNoc();
 
-        NL_TEST_ASSERT_EQUALS(inSuite, fabricTable.FabricCount(), 1);
-        NL_TEST_ASSERT_SUCCESS(inSuite, fabricTable.AddNewPendingTrustedRootCert(rcac));
+        EXPECT_EQ(fabricTable.FabricCount(), 1);
+        EXPECT_EQ(fabricTable.AddNewPendingTrustedRootCert(rcac), CHIP_NO_ERROR);
         FabricIndex newFabricIndex = kUndefinedFabricIndex;
-        NL_TEST_ASSERT_SUCCESS(inSuite,
-                               fabricTable.AddNewPendingFabricWithOperationalKeystore(noc, icac, kVendorId, &newFabricIndex));
-        NL_TEST_ASSERT_EQUALS(inSuite, fabricTable.FabricCount(), 2);
-        NL_TEST_ASSERT(inSuite, newFabricIndex == 2);
+        EXPECT_EQ(fabricTable.AddNewPendingFabricWithOperationalKeystore(noc, icac, kVendorId, &newFabricIndex), CHIP_NO_ERROR);
+        EXPECT_EQ(fabricTable.FabricCount(), 2);
+        EXPECT_EQ(newFabricIndex, 2);
 
-        NL_TEST_ASSERT_SUCCESS(inSuite, fabricTable.CommitPendingFabricData());
+        EXPECT_EQ(fabricTable.CommitPendingFabricData(), CHIP_NO_ERROR);
 
         // Validate contents
         const auto * fabricInfo = fabricTable.FindFabricWithIndex(2);
-        NL_TEST_ASSERT(inSuite, fabricInfo != nullptr);
-        if (fabricInfo != nullptr)
-        {
-            NL_TEST_ASSERT(inSuite, fabricInfo->ShouldAdvertiseIdentity());
+        ASSERT_NE(fabricInfo, nullptr);
+        EXPECT_TRUE(fabricInfo->ShouldAdvertiseIdentity());
 
-            Credentials::ChipCertificateSet certificates;
-            NL_TEST_ASSERT_SUCCESS(inSuite, certificates.Init(1));
-            NL_TEST_ASSERT_SUCCESS(inSuite,
-                                   certificates.LoadCert(rcac, BitFlags<CertDecodeFlags>(CertDecodeFlags::kIsTrustAnchor)));
-            Crypto::P256PublicKey rcacPublicKey(certificates.GetCertSet()[0].mPublicKey);
+        Credentials::ChipCertificateSet certificates;
+        EXPECT_EQ(certificates.Init(1), CHIP_NO_ERROR);
+        EXPECT_EQ(certificates.LoadCert(rcac, BitFlags<CertDecodeFlags>(CertDecodeFlags::kIsTrustAnchor)), CHIP_NO_ERROR);
+        Crypto::P256PublicKey rcacPublicKey(certificates.GetCertSet()[0].mPublicKey);
 
-            NL_TEST_ASSERT(inSuite, fabricInfo->GetFabricIndex() == 2);
-            NL_TEST_ASSERT(inSuite, fabricInfo->GetNodeId() == 55);
-            NL_TEST_ASSERT(inSuite, fabricInfo->GetFabricId() == 2222);
-            NL_TEST_ASSERT(inSuite, fabricInfo->GetVendorId() == kVendorId);
-            NL_TEST_ASSERT(inSuite, fabricInfo->GetFabricLabel().size() == 0);
+        EXPECT_EQ(fabricInfo->GetFabricIndex(), 2);
+        EXPECT_EQ(fabricInfo->GetNodeId(), 55u);
+        EXPECT_EQ(fabricInfo->GetFabricId(), 2222u);
+        EXPECT_EQ(fabricInfo->GetVendorId(), kVendorId);
+        EXPECT_EQ(fabricInfo->GetFabricLabel().size(), 0u);
 
-            Crypto::P256PublicKey rootPublicKeyOfFabric;
-            NL_TEST_ASSERT_SUCCESS(inSuite, fabricTable.FetchRootPubkey(newFabricIndex, rootPublicKeyOfFabric));
-            NL_TEST_ASSERT(inSuite, rootPublicKeyOfFabric.Matches(rcacPublicKey));
-        }
+        Crypto::P256PublicKey rootPublicKeyOfFabric;
+        EXPECT_EQ(fabricTable.FetchRootPubkey(newFabricIndex, rootPublicKeyOfFabric), CHIP_NO_ERROR);
+        EXPECT_TRUE(rootPublicKeyOfFabric.Matches(rcacPublicKey));
     }
     size_t numStorageKeysAfterSecondAdd = storage.GetNumKeys();
 
-    NL_TEST_ASSERT(inSuite, numStorageKeysAfterSecondAdd == (numStorageKeysAfterFirstAdd + 5)); // Metadata, 3 certs, 1 opkey
+    EXPECT_EQ(numStorageKeysAfterSecondAdd, (numStorageKeysAfterFirstAdd + 5)); // Metadata, 3 certs, 1 opkey
 }
 
-void TestInvalidChaining(nlTestSuite * inSuite, void * inContext)
+TEST_F(TestFabricTable, TestInvalidChaining)
 {
     Credentials::TestOnlyLocalCertificateAuthority fabricCertAuthority;
     Credentials::TestOnlyLocalCertificateAuthority differentCertAuthority;
 
     chip::TestPersistentStorageDelegate storage;
-    NL_TEST_ASSERT(inSuite, fabricCertAuthority.Init().IsSuccess());
-    NL_TEST_ASSERT(inSuite, differentCertAuthority.Init().IsSuccess());
+    EXPECT_TRUE(fabricCertAuthority.Init().IsSuccess());
+    EXPECT_TRUE(differentCertAuthority.Init().IsSuccess());
 
     constexpr uint16_t kVendorId = 0xFFF1u;
 
     // Initialize a fabric table.
     ScopedFabricTable fabricTableHolder;
-    NL_TEST_ASSERT(inSuite, fabricTableHolder.Init(&storage) == CHIP_NO_ERROR);
+    EXPECT_EQ(fabricTableHolder.Init(&storage), CHIP_NO_ERROR);
     FabricTable & fabricTable = fabricTableHolder.GetFabricTable();
 
-    NL_TEST_ASSERT_EQUALS(inSuite, fabricTable.FabricCount(), 0);
+    EXPECT_EQ(fabricTable.FabricCount(), 0);
 
     // Try to add fabric with either the NOC not chaining properly, or ICAC not chaining properly, fail,
     // then succeed with proper chaining
@@ -2634,13 +2533,12 @@
 
         uint8_t csrBuf[chip::Crypto::kMIN_CSR_Buffer_Size];
         MutableByteSpan csrSpan{ csrBuf };
-        NL_TEST_ASSERT_SUCCESS(inSuite, fabricTable.AllocatePendingOperationalKey(chip::NullOptional, csrSpan));
+        EXPECT_EQ(fabricTable.AllocatePendingOperationalKey(chip::NullOptional, csrSpan), CHIP_NO_ERROR);
 
         // Generate same cert chain from two different roots
-        NL_TEST_ASSERT_SUCCESS(inSuite,
-                               fabricCertAuthority.SetIncludeIcac(true).GenerateNocChain(fabricId, nodeId, csrSpan).GetStatus());
-        NL_TEST_ASSERT_SUCCESS(inSuite,
-                               differentCertAuthority.SetIncludeIcac(true).GenerateNocChain(fabricId, nodeId, csrSpan).GetStatus());
+        EXPECT_EQ(fabricCertAuthority.SetIncludeIcac(true).GenerateNocChain(fabricId, nodeId, csrSpan).GetStatus(), CHIP_NO_ERROR);
+        EXPECT_EQ(differentCertAuthority.SetIncludeIcac(true).GenerateNocChain(fabricId, nodeId, csrSpan).GetStatus(),
+                  CHIP_NO_ERROR);
 
         ByteSpan rcac = fabricCertAuthority.GetRcac();
         ByteSpan icac = fabricCertAuthority.GetIcac();
@@ -2649,23 +2547,23 @@
         ByteSpan otherIcac = differentCertAuthority.GetIcac();
         ByteSpan otherNoc  = differentCertAuthority.GetNoc();
 
-        NL_TEST_ASSERT_EQUALS(inSuite, fabricTable.FabricCount(), 0);
-        NL_TEST_ASSERT_SUCCESS(inSuite, fabricTable.AddNewPendingTrustedRootCert(rcac));
+        EXPECT_EQ(fabricTable.FabricCount(), 0);
+        EXPECT_EQ(fabricTable.AddNewPendingTrustedRootCert(rcac), CHIP_NO_ERROR);
 
         // Add with NOC not chaining to ICAC: fail
         {
             FabricIndex newFabricIndex = kUndefinedFabricIndex;
             CHIP_ERROR err = fabricTable.AddNewPendingFabricWithOperationalKeystore(otherNoc, icac, kVendorId, &newFabricIndex);
-            NL_TEST_ASSERT(inSuite, err != CHIP_NO_ERROR);
-            NL_TEST_ASSERT_EQUALS(inSuite, fabricTable.FabricCount(), 0);
+            EXPECT_NE(err, CHIP_NO_ERROR);
+            EXPECT_EQ(fabricTable.FabricCount(), 0);
         }
 
         // Add with ICAC not chaining to root: fail
         {
             FabricIndex newFabricIndex = kUndefinedFabricIndex;
             CHIP_ERROR err = fabricTable.AddNewPendingFabricWithOperationalKeystore(noc, otherIcac, kVendorId, &newFabricIndex);
-            NL_TEST_ASSERT(inSuite, err != CHIP_NO_ERROR);
-            NL_TEST_ASSERT_EQUALS(inSuite, fabricTable.FabricCount(), 0);
+            EXPECT_NE(err, CHIP_NO_ERROR);
+            EXPECT_EQ(fabricTable.FabricCount(), 0);
         }
 
         // Add with NOC and ICAC chaining together, but not to root: fail
@@ -2673,8 +2571,8 @@
             FabricIndex newFabricIndex = kUndefinedFabricIndex;
             CHIP_ERROR err =
                 fabricTable.AddNewPendingFabricWithOperationalKeystore(otherNoc, otherIcac, kVendorId, &newFabricIndex);
-            NL_TEST_ASSERT(inSuite, err != CHIP_NO_ERROR);
-            NL_TEST_ASSERT_EQUALS(inSuite, fabricTable.FabricCount(), 0);
+            EXPECT_NE(err, CHIP_NO_ERROR);
+            EXPECT_EQ(fabricTable.FabricCount(), 0);
         }
 
         // Revert state, start tests without ICAC
@@ -2683,52 +2581,48 @@
         // Generate same cert chain from two different roots
 
         csrSpan = MutableByteSpan{ csrBuf };
-        NL_TEST_ASSERT_SUCCESS(inSuite, fabricTable.AllocatePendingOperationalKey(chip::NullOptional, csrSpan));
-        NL_TEST_ASSERT_SUCCESS(inSuite,
-                               fabricCertAuthority.SetIncludeIcac(false).GenerateNocChain(fabricId, nodeId, csrSpan).GetStatus());
-        NL_TEST_ASSERT_SUCCESS(
-            inSuite, differentCertAuthority.SetIncludeIcac(false).GenerateNocChain(fabricId, nodeId, csrSpan).GetStatus());
+        EXPECT_EQ(fabricTable.AllocatePendingOperationalKey(chip::NullOptional, csrSpan), CHIP_NO_ERROR);
+        EXPECT_EQ(fabricCertAuthority.SetIncludeIcac(false).GenerateNocChain(fabricId, nodeId, csrSpan).GetStatus(), CHIP_NO_ERROR);
+        EXPECT_EQ(differentCertAuthority.SetIncludeIcac(false).GenerateNocChain(fabricId, nodeId, csrSpan).GetStatus(),
+                  CHIP_NO_ERROR);
 
         rcac = fabricCertAuthority.GetRcac();
         noc  = fabricCertAuthority.GetNoc();
 
         otherNoc = differentCertAuthority.GetNoc();
 
-        NL_TEST_ASSERT_SUCCESS(inSuite, fabricTable.AddNewPendingTrustedRootCert(rcac));
+        EXPECT_EQ(fabricTable.AddNewPendingTrustedRootCert(rcac), CHIP_NO_ERROR);
 
         // Add with NOC not chaining to RCAC: fail
         {
             FabricIndex newFabricIndex = kUndefinedFabricIndex;
             CHIP_ERROR err =
                 fabricTable.AddNewPendingFabricWithOperationalKeystore(otherNoc, ByteSpan{}, kVendorId, &newFabricIndex);
-            NL_TEST_ASSERT(inSuite, err != CHIP_NO_ERROR);
-            NL_TEST_ASSERT_EQUALS(inSuite, fabricTable.FabricCount(), 0);
+            EXPECT_NE(err, CHIP_NO_ERROR);
+            EXPECT_EQ(fabricTable.FabricCount(), 0);
         }
 
         // Add properly now
         FabricIndex newFabricIndex = kUndefinedFabricIndex;
-        NL_TEST_ASSERT_SUCCESS(inSuite,
-                               fabricTable.AddNewPendingFabricWithOperationalKeystore(noc, ByteSpan{}, kVendorId, &newFabricIndex));
-        NL_TEST_ASSERT_EQUALS(inSuite, fabricTable.FabricCount(), 1);
-        NL_TEST_ASSERT(inSuite, newFabricIndex == 1);
+        EXPECT_EQ(fabricTable.AddNewPendingFabricWithOperationalKeystore(noc, ByteSpan{}, kVendorId, &newFabricIndex),
+                  CHIP_NO_ERROR);
+        EXPECT_EQ(fabricTable.FabricCount(), 1);
+        EXPECT_EQ(newFabricIndex, 1);
 
-        NL_TEST_ASSERT_SUCCESS(inSuite, fabricTable.CommitPendingFabricData());
+        EXPECT_EQ(fabricTable.CommitPendingFabricData(), CHIP_NO_ERROR);
 
         // Validate contents
         const auto * fabricInfo = fabricTable.FindFabricWithIndex(1);
-        NL_TEST_ASSERT(inSuite, fabricInfo != nullptr);
-        if (fabricInfo != nullptr)
-        {
-            NL_TEST_ASSERT(inSuite, fabricInfo->GetFabricIndex() == 1);
-            NL_TEST_ASSERT(inSuite, fabricInfo->GetNodeId() == 55);
-            NL_TEST_ASSERT(inSuite, fabricInfo->GetFabricId() == 1111);
-            NL_TEST_ASSERT(inSuite, fabricInfo->GetVendorId() == kVendorId);
-            NL_TEST_ASSERT(inSuite, fabricInfo->GetFabricLabel().size() == 0);
-        }
+        ASSERT_NE(fabricInfo, nullptr);
+        EXPECT_EQ(fabricInfo->GetFabricIndex(), 1);
+        EXPECT_EQ(fabricInfo->GetNodeId(), 55u);
+        EXPECT_EQ(fabricInfo->GetFabricId(), 1111u);
+        EXPECT_EQ(fabricInfo->GetVendorId(), kVendorId);
+        EXPECT_EQ(fabricInfo->GetFabricLabel().size(), 0u);
     }
 }
 
-void TestEphemeralKeys(nlTestSuite * inSuite, void * inContext)
+TEST_F(TestFabricTable, TestEphemeralKeys)
 {
     // Initialize a fabric table with operational keystore
     {
@@ -2736,18 +2630,18 @@
 
         // Initialize a FabricTable
         ScopedFabricTable fabricTableHolder;
-        NL_TEST_ASSERT(inSuite, fabricTableHolder.Init(&storage) == CHIP_NO_ERROR);
+        EXPECT_EQ(fabricTableHolder.Init(&storage), CHIP_NO_ERROR);
         FabricTable & fabricTable = fabricTableHolder.GetFabricTable();
 
         Crypto::P256ECDSASignature sig;
         uint8_t message[] = { 'm', 's', 'g' };
 
         Crypto::P256Keypair * ephemeralKeypair = fabricTable.AllocateEphemeralKeypairForCASE();
-        NL_TEST_ASSERT(inSuite, ephemeralKeypair != nullptr);
-        NL_TEST_ASSERT_SUCCESS(inSuite, ephemeralKeypair->Initialize(Crypto::ECPKeyTarget::ECDSA));
+        ASSERT_NE(ephemeralKeypair, nullptr);
+        EXPECT_EQ(ephemeralKeypair->Initialize(Crypto::ECPKeyTarget::ECDSA), CHIP_NO_ERROR);
 
-        NL_TEST_ASSERT_SUCCESS(inSuite, ephemeralKeypair->ECDSA_sign_msg(message, sizeof(message), sig));
-        NL_TEST_ASSERT_SUCCESS(inSuite, ephemeralKeypair->Pubkey().ECDSA_validate_msg_signature(message, sizeof(message), sig));
+        EXPECT_EQ(ephemeralKeypair->ECDSA_sign_msg(message, sizeof(message), sig), CHIP_NO_ERROR);
+        EXPECT_EQ(ephemeralKeypair->Pubkey().ECDSA_validate_msg_signature(message, sizeof(message), sig), CHIP_NO_ERROR);
 
         fabricTable.ReleaseEphemeralKeypair(ephemeralKeypair);
     }
@@ -2757,24 +2651,24 @@
         chip::TestPersistentStorageDelegate storage;
 
         chip::Credentials::PersistentStorageOpCertStore opCertStore;
-        NL_TEST_ASSERT_SUCCESS(inSuite, opCertStore.Init(&storage));
+        EXPECT_EQ(opCertStore.Init(&storage), CHIP_NO_ERROR);
 
         FabricTable fabricTable;
         FabricTable::InitParams initParams;
         initParams.storage     = &storage;
         initParams.opCertStore = &opCertStore;
 
-        NL_TEST_ASSERT_SUCCESS(inSuite, fabricTable.Init(initParams));
+        EXPECT_EQ(fabricTable.Init(initParams), CHIP_NO_ERROR);
 
         Crypto::P256ECDSASignature sig;
         uint8_t message[] = { 'm', 's', 'g' };
 
         Crypto::P256Keypair * ephemeralKeypair = fabricTable.AllocateEphemeralKeypairForCASE();
-        NL_TEST_ASSERT(inSuite, ephemeralKeypair != nullptr);
-        NL_TEST_ASSERT_SUCCESS(inSuite, ephemeralKeypair->Initialize(Crypto::ECPKeyTarget::ECDSA));
+        ASSERT_NE(ephemeralKeypair, nullptr);
+        EXPECT_EQ(ephemeralKeypair->Initialize(Crypto::ECPKeyTarget::ECDSA), CHIP_NO_ERROR);
 
-        NL_TEST_ASSERT_SUCCESS(inSuite, ephemeralKeypair->ECDSA_sign_msg(message, sizeof(message), sig));
-        NL_TEST_ASSERT_SUCCESS(inSuite, ephemeralKeypair->Pubkey().ECDSA_validate_msg_signature(message, sizeof(message), sig));
+        EXPECT_EQ(ephemeralKeypair->ECDSA_sign_msg(message, sizeof(message), sig), CHIP_NO_ERROR);
+        EXPECT_EQ(ephemeralKeypair->Pubkey().ECDSA_validate_msg_signature(message, sizeof(message), sig), CHIP_NO_ERROR);
 
         fabricTable.ReleaseEphemeralKeypair(ephemeralKeypair);
 
@@ -2783,7 +2677,7 @@
     }
 }
 
-void TestCommitMarker(nlTestSuite * inSuite, void * inContext)
+TEST_F(TestFabricTable, TestCommitMarker)
 {
     Crypto::P256PublicKey fIdx1PublicKey;
     Crypto::P256PublicKey fIdx2PublicKey;
@@ -2795,7 +2689,7 @@
     // Log verbosity on this test helps debug significantly
     storage.SetLoggingLevel(chip::TestPersistentStorageDelegate::LoggingLevel::kLogMutationAndReads);
 
-    NL_TEST_ASSERT(inSuite, fabricCertAuthority.Init().IsSuccess());
+    EXPECT_TRUE(fabricCertAuthority.Init().IsSuccess());
 
     constexpr uint16_t kVendorId = 0xFFF1u;
 
@@ -2808,11 +2702,11 @@
     {
         // Initialize a fabric table
         ScopedFabricTable fabricTableHolder;
-        NL_TEST_ASSERT(inSuite, fabricTableHolder.Init(&storage) == CHIP_NO_ERROR);
+        EXPECT_EQ(fabricTableHolder.Init(&storage), CHIP_NO_ERROR);
         FabricTable & fabricTable = fabricTableHolder.GetFabricTable();
 
-        NL_TEST_ASSERT(inSuite, fabricTable.GetDeletedFabricFromCommitMarker() == kUndefinedFabricIndex);
-        NL_TEST_ASSERT_EQUALS(inSuite, fabricTable.FabricCount(), 0);
+        EXPECT_EQ(fabricTable.GetDeletedFabricFromCommitMarker(), kUndefinedFabricIndex);
+        EXPECT_EQ(fabricTable.FabricCount(), 0);
 
         // Add Fabric 1111 Node Id 55
         {
@@ -2821,60 +2715,55 @@
 
             uint8_t csrBuf[chip::Crypto::kMIN_CSR_Buffer_Size];
             MutableByteSpan csrSpan{ csrBuf };
-            NL_TEST_ASSERT_SUCCESS(inSuite, fabricTable.AllocatePendingOperationalKey(chip::NullOptional, csrSpan));
+            EXPECT_EQ(fabricTable.AllocatePendingOperationalKey(chip::NullOptional, csrSpan), CHIP_NO_ERROR);
 
-            NL_TEST_ASSERT_SUCCESS(
-                inSuite, fabricCertAuthority.SetIncludeIcac(true).GenerateNocChain(fabricId, nodeId, csrSpan).GetStatus());
+            EXPECT_EQ(fabricCertAuthority.SetIncludeIcac(true).GenerateNocChain(fabricId, nodeId, csrSpan).GetStatus(),
+                      CHIP_NO_ERROR);
             ByteSpan rcac = fabricCertAuthority.GetRcac();
             ByteSpan icac = fabricCertAuthority.GetIcac();
             ByteSpan noc  = fabricCertAuthority.GetNoc();
 
-            NL_TEST_ASSERT_EQUALS(inSuite, fabricTable.FabricCount(), 0);
-            NL_TEST_ASSERT_SUCCESS(inSuite, fabricTable.AddNewPendingTrustedRootCert(rcac));
+            EXPECT_EQ(fabricTable.FabricCount(), 0);
+            EXPECT_EQ(fabricTable.AddNewPendingTrustedRootCert(rcac), CHIP_NO_ERROR);
             FabricIndex newFabricIndex = kUndefinedFabricIndex;
-            NL_TEST_ASSERT_SUCCESS(inSuite,
-                                   fabricTable.AddNewPendingFabricWithOperationalKeystore(noc, icac, kVendorId, &newFabricIndex));
-            NL_TEST_ASSERT_EQUALS(inSuite, fabricTable.FabricCount(), 1);
-            NL_TEST_ASSERT(inSuite, newFabricIndex == 1);
+            EXPECT_EQ(fabricTable.AddNewPendingFabricWithOperationalKeystore(noc, icac, kVendorId, &newFabricIndex), CHIP_NO_ERROR);
+            EXPECT_EQ(fabricTable.FabricCount(), 1);
+            EXPECT_EQ(newFabricIndex, 1);
 
-            NL_TEST_ASSERT_SUCCESS(inSuite, fabricTable.CommitPendingFabricData());
+            EXPECT_EQ(fabricTable.CommitPendingFabricData(), CHIP_NO_ERROR);
 
             // Validate contents
             const auto * fabricInfo = fabricTable.FindFabricWithIndex(1);
-            NL_TEST_ASSERT(inSuite, fabricInfo != nullptr);
-            if (fabricInfo != nullptr)
-            {
-                Credentials::ChipCertificateSet certificates;
-                NL_TEST_ASSERT_SUCCESS(inSuite, certificates.Init(1));
-                NL_TEST_ASSERT_SUCCESS(inSuite,
-                                       certificates.LoadCert(rcac, BitFlags<CertDecodeFlags>(CertDecodeFlags::kIsTrustAnchor)));
-                Crypto::P256PublicKey rcacPublicKey(certificates.GetCertSet()[0].mPublicKey);
+            ASSERT_NE(fabricInfo, nullptr);
+            Credentials::ChipCertificateSet certificates;
+            EXPECT_EQ(certificates.Init(1), CHIP_NO_ERROR);
+            EXPECT_EQ(certificates.LoadCert(rcac, BitFlags<CertDecodeFlags>(CertDecodeFlags::kIsTrustAnchor)), CHIP_NO_ERROR);
+            Crypto::P256PublicKey rcacPublicKey(certificates.GetCertSet()[0].mPublicKey);
 
-                NL_TEST_ASSERT(inSuite, fabricInfo->GetFabricIndex() == 1);
-                NL_TEST_ASSERT(inSuite, fabricInfo->GetNodeId() == 55);
-                NL_TEST_ASSERT(inSuite, fabricInfo->GetFabricId() == 1111);
-                NL_TEST_ASSERT(inSuite, fabricInfo->GetVendorId() == kVendorId);
-                NL_TEST_ASSERT(inSuite, fabricInfo->GetFabricLabel().size() == 0);
+            EXPECT_EQ(fabricInfo->GetFabricIndex(), 1);
+            EXPECT_EQ(fabricInfo->GetNodeId(), 55u);
+            EXPECT_EQ(fabricInfo->GetFabricId(), 1111u);
+            EXPECT_EQ(fabricInfo->GetVendorId(), kVendorId);
+            EXPECT_EQ(fabricInfo->GetFabricLabel().size(), 0u);
 
-                Crypto::P256PublicKey rootPublicKeyOfFabric;
-                NL_TEST_ASSERT_SUCCESS(inSuite, fabricTable.FetchRootPubkey(newFabricIndex, rootPublicKeyOfFabric));
-                NL_TEST_ASSERT(inSuite, rootPublicKeyOfFabric.Matches(rcacPublicKey));
-            }
+            Crypto::P256PublicKey rootPublicKeyOfFabric;
+            EXPECT_EQ(fabricTable.FetchRootPubkey(newFabricIndex, rootPublicKeyOfFabric), CHIP_NO_ERROR);
+            EXPECT_TRUE(rootPublicKeyOfFabric.Matches(rcacPublicKey));
 
             // Validate that fabric has the correct operational key by verifying a signature
             {
                 Crypto::P256ECDSASignature sig;
                 uint8_t message[] = { 'm', 's', 'g' };
 
-                NL_TEST_ASSERT_SUCCESS(inSuite, VerifyCertificateSigningRequest(csrSpan.data(), csrSpan.size(), fIdx1PublicKey));
+                EXPECT_EQ(VerifyCertificateSigningRequest(csrSpan.data(), csrSpan.size(), fIdx1PublicKey), CHIP_NO_ERROR);
 
-                NL_TEST_ASSERT_SUCCESS(inSuite, fabricTable.SignWithOpKeypair(newFabricIndex, ByteSpan{ message }, sig));
-                NL_TEST_ASSERT_SUCCESS(inSuite, fIdx1PublicKey.ECDSA_validate_msg_signature(&message[0], sizeof(message), sig));
+                EXPECT_EQ(fabricTable.SignWithOpKeypair(newFabricIndex, ByteSpan{ message }, sig), CHIP_NO_ERROR);
+                EXPECT_EQ(fIdx1PublicKey.ECDSA_validate_msg_signature(&message[0], sizeof(message), sig), CHIP_NO_ERROR);
             }
         }
         numStorageKeysAfterFirstAdd = storage.GetNumKeys();
 
-        NL_TEST_ASSERT(inSuite, numStorageKeysAfterFirstAdd == 7); // Metadata, index, 3 certs, 1 opkey, last known good time
+        EXPECT_EQ(numStorageKeysAfterFirstAdd, 7u); // Metadata, index, 3 certs, 1 opkey, last known good time
 
         // The following test requires test methods not available on all builds.
         // TODO: Debug why some CI jobs don't set it properly.
@@ -2887,53 +2776,49 @@
 
             uint8_t csrBuf[chip::Crypto::kMIN_CSR_Buffer_Size];
             MutableByteSpan csrSpan{ csrBuf };
-            NL_TEST_ASSERT_SUCCESS(inSuite, fabricTable.AllocatePendingOperationalKey(chip::NullOptional, csrSpan));
+            EXPECT_EQ(fabricTable.AllocatePendingOperationalKey(chip::NullOptional, csrSpan), CHIP_NO_ERROR);
 
-            NL_TEST_ASSERT_SUCCESS(
-                inSuite, fabricCertAuthority.SetIncludeIcac(false).GenerateNocChain(fabricId, nodeId, csrSpan).GetStatus());
+            EXPECT_EQ(fabricCertAuthority.SetIncludeIcac(false).GenerateNocChain(fabricId, nodeId, csrSpan).GetStatus(),
+                      CHIP_NO_ERROR);
             ByteSpan rcac = fabricCertAuthority.GetRcac();
             ByteSpan noc  = fabricCertAuthority.GetNoc();
 
-            NL_TEST_ASSERT_EQUALS(inSuite, fabricTable.FabricCount(), 1);
-            NL_TEST_ASSERT_SUCCESS(inSuite, fabricTable.AddNewPendingTrustedRootCert(rcac));
+            EXPECT_EQ(fabricTable.FabricCount(), 1);
+            EXPECT_EQ(fabricTable.AddNewPendingTrustedRootCert(rcac), CHIP_NO_ERROR);
             FabricIndex newFabricIndex = kUndefinedFabricIndex;
-            NL_TEST_ASSERT_SUCCESS(
-                inSuite, fabricTable.AddNewPendingFabricWithOperationalKeystore(noc, ByteSpan{}, kVendorId, &newFabricIndex));
-            NL_TEST_ASSERT_EQUALS(inSuite, fabricTable.FabricCount(), 2);
-            NL_TEST_ASSERT(inSuite, newFabricIndex == 2);
+            EXPECT_EQ(fabricTable.AddNewPendingFabricWithOperationalKeystore(noc, ByteSpan{}, kVendorId, &newFabricIndex),
+                      CHIP_NO_ERROR);
+            EXPECT_EQ(fabricTable.FabricCount(), 2);
+            EXPECT_EQ(newFabricIndex, 2);
 
             // Validate contents of pending
             const auto * fabricInfo = fabricTable.FindFabricWithIndex(2);
-            NL_TEST_ASSERT(inSuite, fabricInfo != nullptr);
-            if (fabricInfo != nullptr)
-            {
-                Credentials::ChipCertificateSet certificates;
-                NL_TEST_ASSERT_SUCCESS(inSuite, certificates.Init(1));
-                NL_TEST_ASSERT_SUCCESS(inSuite,
-                                       certificates.LoadCert(rcac, BitFlags<CertDecodeFlags>(CertDecodeFlags::kIsTrustAnchor)));
-                Crypto::P256PublicKey rcacPublicKey(certificates.GetCertSet()[0].mPublicKey);
+            ASSERT_NE(fabricInfo, nullptr);
+            Credentials::ChipCertificateSet certificates;
+            EXPECT_EQ(certificates.Init(1), CHIP_NO_ERROR);
+            EXPECT_EQ(certificates.LoadCert(rcac, BitFlags<CertDecodeFlags>(CertDecodeFlags::kIsTrustAnchor)), CHIP_NO_ERROR);
+            Crypto::P256PublicKey rcacPublicKey(certificates.GetCertSet()[0].mPublicKey);
 
-                NL_TEST_ASSERT(inSuite, fabricInfo->GetFabricIndex() == 2);
-                NL_TEST_ASSERT(inSuite, fabricInfo->GetNodeId() == 66);
-                NL_TEST_ASSERT(inSuite, fabricInfo->GetFabricId() == 2222);
-                NL_TEST_ASSERT(inSuite, fabricInfo->GetVendorId() == kVendorId);
-                NL_TEST_ASSERT(inSuite, fabricInfo->GetFabricLabel().size() == 0);
+            EXPECT_EQ(fabricInfo->GetFabricIndex(), 2);
+            EXPECT_EQ(fabricInfo->GetNodeId(), 66u);
+            EXPECT_EQ(fabricInfo->GetFabricId(), 2222u);
+            EXPECT_EQ(fabricInfo->GetVendorId(), kVendorId);
+            EXPECT_EQ(fabricInfo->GetFabricLabel().size(), 0u);
 
-                Crypto::P256PublicKey rootPublicKeyOfFabric;
-                NL_TEST_ASSERT_SUCCESS(inSuite, fabricTable.FetchRootPubkey(newFabricIndex, rootPublicKeyOfFabric));
-                NL_TEST_ASSERT(inSuite, rootPublicKeyOfFabric.Matches(rcacPublicKey));
-            }
+            Crypto::P256PublicKey rootPublicKeyOfFabric;
+            EXPECT_EQ(fabricTable.FetchRootPubkey(newFabricIndex, rootPublicKeyOfFabric), CHIP_NO_ERROR);
+            EXPECT_TRUE(rootPublicKeyOfFabric.Matches(rcacPublicKey));
 
             // Make sure no additional storage yet
-            NL_TEST_ASSERT(inSuite, storage.GetNumKeys() == numStorageKeysAfterFirstAdd);
+            EXPECT_EQ(storage.GetNumKeys(), numStorageKeysAfterFirstAdd);
 
             // --> FORCE AN ERROR ON COMMIT that will BYPASS commit clean-up (similar to reboot during commit)
             fabricTable.SetForceAbortCommitForTest(true);
-            NL_TEST_ASSERT(inSuite, fabricTable.CommitPendingFabricData() == CHIP_ERROR_INTERNAL);
+            EXPECT_EQ(fabricTable.CommitPendingFabricData(), CHIP_ERROR_INTERNAL);
 
             // Check that there are more keys now, partially committed: at least a Commit Marker (+1)
             // and some more keys from the aborted process.
-            NL_TEST_ASSERT(inSuite, storage.GetNumKeys() > (numStorageKeysAfterFirstAdd + 1));
+            EXPECT_GT(storage.GetNumKeys(), (numStorageKeysAfterFirstAdd + 1));
         }
 #endif // CONFIG_BUILD_FOR_HOST_UNIT_TEST
     }
@@ -2945,19 +2830,19 @@
         // Initialize a FabricTable again. Make sure it succeeds in initing.
         ScopedFabricTable fabricTableHolder;
 
-        NL_TEST_ASSERT(inSuite, storage.GetNumKeys() > (numStorageKeysAfterFirstAdd + 1));
+        EXPECT_GT(storage.GetNumKeys(), (numStorageKeysAfterFirstAdd + 1));
 
-        NL_TEST_ASSERT(inSuite, fabricTableHolder.Init(&storage) == CHIP_NO_ERROR);
+        EXPECT_EQ(fabricTableHolder.Init(&storage), CHIP_NO_ERROR);
         FabricTable & fabricTable = fabricTableHolder.GetFabricTable();
 
         // Make sure that after init, the fabricTable has only 1 fabric
-        NL_TEST_ASSERT_EQUALS(inSuite, fabricTable.FabricCount(), 1);
+        EXPECT_EQ(fabricTable.FabricCount(), 1);
 
         // Make sure it caught the last partially committed fabric
-        NL_TEST_ASSERT(inSuite, fabricTable.GetDeletedFabricFromCommitMarker() == 2);
+        EXPECT_EQ(fabricTable.GetDeletedFabricFromCommitMarker(), 2);
 
         // Second read must return kUndefinedFabricIndex
-        NL_TEST_ASSERT(inSuite, fabricTable.GetDeletedFabricFromCommitMarker() == kUndefinedFabricIndex);
+        EXPECT_EQ(fabricTable.GetDeletedFabricFromCommitMarker(), kUndefinedFabricIndex);
 
         {
             // Here we would do other clean-ups (e.g. see Server.cpp that uses the above) and then
@@ -2966,7 +2851,7 @@
         }
 
         // Make sure that all other pending storage got deleted
-        NL_TEST_ASSERT(inSuite, storage.GetNumKeys() == numStorageKeysAfterFirstAdd);
+        EXPECT_EQ(storage.GetNumKeys(), numStorageKeysAfterFirstAdd);
 
         // Verify we can only see 1 fabric with the iterator
         {
@@ -2978,8 +2863,8 @@
                 ++numFabricsIterated;
                 if (iterFabricInfo.GetFabricIndex() == 1)
                 {
-                    NL_TEST_ASSERT(inSuite, iterFabricInfo.GetNodeId() == 55);
-                    NL_TEST_ASSERT(inSuite, iterFabricInfo.GetFabricId() == 1111);
+                    EXPECT_EQ(iterFabricInfo.GetNodeId(), 55u);
+                    EXPECT_EQ(iterFabricInfo.GetFabricId(), 1111u);
                     saw1 = true;
                 }
                 if (iterFabricInfo.GetFabricIndex() == 2)
@@ -2988,90 +2873,12 @@
                 }
             }
 
-            NL_TEST_ASSERT(inSuite, numFabricsIterated == 1);
-            NL_TEST_ASSERT(inSuite, saw1 == true);
-            NL_TEST_ASSERT(inSuite, saw2 == false);
+            EXPECT_EQ(numFabricsIterated, 1u);
+            EXPECT_TRUE(saw1);
+            EXPECT_FALSE(saw2);
         }
     }
 #endif // CONFIG_BUILD_FOR_HOST_UNIT_TEST
 }
 
-// Test Suite
-
-/**
- *  Test Suite that lists all the test functions.
- */
-// clang-format off
-static const nlTest sTests[] =
-{
-    NL_TEST_DEF("Last Known Good Time Init", TestLastKnownGoodTimeInit),
-    NL_TEST_DEF("Update Last Known Good Time", TestUpdateLastKnownGoodTime),
-    NL_TEST_DEF("Set Last Known Good Time", TestSetLastKnownGoodTime),
-    NL_TEST_DEF("Test basic AddNOC flow", TestBasicAddNocUpdateNocFlow),
-    NL_TEST_DEF("Test adding multiple fabrics that chain to same root, different fabric ID", TestAddMultipleSameRootDifferentFabricId),
-    NL_TEST_DEF("Test adding multiple fabrics that chain to different roots, same fabric ID", TestAddMultipleSameFabricIdDifferentRoot),
-    NL_TEST_DEF("Validate fabrics are loaded from persistence at FabricTable::init", TestPersistence),
-    NL_TEST_DEF("Test fail-safe handling during AddNOC", TestAddNocFailSafe),
-    NL_TEST_DEF("Test fail-safe handling during UpdateNoc", TestUpdateNocFailSafe),
-    NL_TEST_DEF("Test fail-safe handling for root cert", TestAddRootCertFailSafe),
-    NL_TEST_DEF("Test interlock sequencing errors", TestSequenceErrors),
-    NL_TEST_DEF("Test fabric label changes", TestFabricLabelChange),
-    NL_TEST_DEF("Test compressed fabric ID is properly generated", TestCompressedFabricId),
-    NL_TEST_DEF("Test fabric lookup by <root public key, fabric ID>", TestFabricLookup),
-    NL_TEST_DEF("Test Fetching CATs", TestFetchCATs),
-    NL_TEST_DEF("Test AddNOC root collision", TestAddNocRootCollision),
-    NL_TEST_DEF("Test invalid chaining in AddNOC and UpdateNOC", TestInvalidChaining),
-    NL_TEST_DEF("Test ephemeral keys allocation", TestEphemeralKeys),
-    NL_TEST_DEF("Test proper detection of Commit Marker on init", TestCommitMarker),
-    NL_TEST_DEF("Test colliding fabrics in the fabric table", TestCollidingFabrics),
-
-    NL_TEST_SENTINEL()
-};
-
-// clang-format on
-
-int TestFabricTable_Setup(void * inContext);
-int TestFabricTable_Teardown(void * inContext);
-
-// clang-format off
-static nlTestSuite sSuite =
-{
-    "Test-CHIP-FabricTable",
-    &sTests[0],
-    TestFabricTable_Setup,
-    TestFabricTable_Teardown,
-};
-// clang-format on
-
-/**
- *  Set up the test suite.
- */
-int TestFabricTable_Setup(void * inContext)
-{
-    DeviceLayer::SetConfigurationMgr(&DeviceLayer::ConfigurationManagerImpl::GetDefaultInstance());
-    return chip::Platform::MemoryInit() == CHIP_NO_ERROR ? SUCCESS : FAILURE;
-}
-
-/**
- *  Tear down the test suite.
- */
-int TestFabricTable_Teardown(void * inContext)
-{
-    chip::Platform::MemoryShutdown();
-    return SUCCESS;
-}
-
 } // namespace
-
-/**
- *  Main
- */
-int TestFabricTable()
-{
-    // Run test suit against one context
-    nlTestRunner(&sSuite, nullptr);
-
-    return (nlTestRunnerStats(&sSuite));
-}
-
-CHIP_REGISTER_TEST_SUITE(TestFabricTable)
diff --git a/src/credentials/tests/TestGroupDataProvider.cpp b/src/credentials/tests/TestGroupDataProvider.cpp
index f3f44d8..7718cf0 100644
--- a/src/credentials/tests/TestGroupDataProvider.cpp
+++ b/src/credentials/tests/TestGroupDataProvider.cpp
@@ -18,11 +18,10 @@
 
 #include <credentials/GroupDataProviderImpl.h>
 #include <crypto/DefaultSessionKeystore.h>
+#include <gtest/gtest.h>
 #include <lib/core/TLV.h>
 #include <lib/support/CHIPMem.h>
 #include <lib/support/TestPersistentStorageDelegate.h>
-#include <lib/support/UnitTestRegistration.h>
-#include <nlunit-test.h>
 #include <platform/KeyValueStoreManager.h>
 #include <set>
 #include <string.h>
@@ -187,41 +186,100 @@
     return true;
 }
 
-void TestStorageDelegate(nlTestSuite * apSuite, void * apContext)
+struct TestGroupDataProvider : public ::testing::Test
+{
+
+    static chip::TestPersistentStorageDelegate sDelegate;
+    static chip::Crypto::DefaultSessionKeystore sSessionKeystore;
+    static GroupDataProviderImpl sProvider;
+
+    constexpr static EpochKey kEpochKeys0[] = {
+        { 0x0000000000000000, { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 } },
+        { 0x1111111111111111, { 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f } },
+        { 0x2222222222222222, { 0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f } }
+    };
+    constexpr static EpochKey kEpochKeys1[] = {
+        { 0x3333333333333333, { 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f } },
+        { 0x4444444444444444, { 0x40, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f } },
+        { 0x5555555555555555, { 0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x5b, 0x5c, 0x5d, 0x5e, 0x5f } },
+    };
+    constexpr static EpochKey kEpochKeys2[] = {
+        { 0xaaaaaaaaaaaaaaaa, { 0xa0, 0xa1, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7, 0xa8, 0xa9, 0xaa, 0xab, 0xac, 0xad, 0xae, 0xaf } },
+        { 0xbbbbbbbbbbbbbbbb, { 0xb0, 0xb1, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6, 0xb7, 0xb8, 0xb9, 0xba, 0xbb, 0xbc, 0xbd, 0xbe, 0xbf } },
+        { 0xcccccccccccccccc, { 0xc0, 0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xcb, 0xcc, 0xcd, 0xce, 0xcf } },
+    };
+    constexpr static EpochKey kEpochKeys3[] = {
+        { 0xdddddddddddddddd, { 0xd0, 0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8, 0xd9, 0xda, 0xdb, 0xdc, 0xdd, 0xde, 0xdf } },
+        { 0xeeeeeeeeeeeeeeee, { 0xe0, 0xe1, 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0xea, 0xeb, 0xec, 0xed, 0xee, 0xef } },
+        { 0xffffffffffffffff, { 0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff } },
+    };
+    static void SetUpTestSuite()
+    {
+
+        EXPECT_EQ(chip::Platform::MemoryInit(), CHIP_NO_ERROR);
+
+        // Initialize Group Data Provider
+        sProvider.SetStorageDelegate(&sDelegate);
+        sProvider.SetSessionKeystore(&sSessionKeystore);
+        sProvider.SetListener(&chip::app::TestGroups::sListener);
+        EXPECT_EQ(sProvider.Init(), CHIP_NO_ERROR);
+        SetGroupDataProvider(&sProvider);
+
+        memcpy(chip::app::TestGroups::kKeySet0.epoch_keys, kEpochKeys0, sizeof(kEpochKeys0));
+        memcpy(chip::app::TestGroups::kKeySet1.epoch_keys, kEpochKeys1, sizeof(kEpochKeys1));
+        memcpy(chip::app::TestGroups::kKeySet2.epoch_keys, kEpochKeys2, sizeof(kEpochKeys2));
+        memcpy(chip::app::TestGroups::kKeySet3.epoch_keys, kEpochKeys3, sizeof(kEpochKeys3));
+    }
+    static void TearDownTestSuite()
+    {
+        GroupDataProvider * provider = GetGroupDataProvider();
+        if (nullptr != provider)
+        {
+            provider->Finish();
+        }
+        chip::Platform::MemoryShutdown();
+    }
+};
+
+chip::TestPersistentStorageDelegate TestGroupDataProvider::sDelegate;
+chip::Crypto::DefaultSessionKeystore TestGroupDataProvider::sSessionKeystore;
+GroupDataProviderImpl TestGroupDataProvider::sProvider(kMaxGroupsPerFabric, kMaxGroupKeysPerFabric);
+
+TEST_F(TestGroupDataProvider, TestStorageDelegate)
 {
     chip::TestPersistentStorageDelegate delegate;
 
     char out[128];
     uint16_t size = static_cast<uint16_t>(sizeof(out));
 
-    NL_TEST_ASSERT(apSuite, CHIP_ERROR_PERSISTED_STORAGE_VALUE_NOT_FOUND == delegate.SyncGetKeyValue(kKey1, out, size));
+    EXPECT_EQ(CHIP_ERROR_PERSISTED_STORAGE_VALUE_NOT_FOUND, delegate.SyncGetKeyValue(kKey1, out, size));
 
     size = static_cast<uint16_t>(kSize1);
-    NL_TEST_ASSERT(apSuite, CHIP_NO_ERROR == delegate.SyncSetKeyValue(kKey1, kValue1, size));
+    EXPECT_EQ(delegate.SyncSetKeyValue(kKey1, kValue1, size), CHIP_NO_ERROR);
 
     size = static_cast<uint16_t>(sizeof(out));
-    NL_TEST_ASSERT(apSuite, CHIP_NO_ERROR == delegate.SyncGetKeyValue(kKey1, out, size));
-    NL_TEST_ASSERT(apSuite, size == kSize1);
-    NL_TEST_ASSERT(apSuite, !memcmp(out, kValue1, kSize1));
+    EXPECT_EQ(delegate.SyncGetKeyValue(kKey1, out, size), CHIP_NO_ERROR);
+    EXPECT_EQ(size, kSize1);
+    EXPECT_FALSE(memcmp(out, kValue1, kSize1));
 
     size = static_cast<uint16_t>(kSize2);
-    NL_TEST_ASSERT(apSuite, CHIP_NO_ERROR == delegate.SyncSetKeyValue(kKey1, kValue2, size));
+    EXPECT_EQ(delegate.SyncSetKeyValue(kKey1, kValue2, size), CHIP_NO_ERROR);
 
     size = static_cast<uint16_t>(sizeof(out));
-    NL_TEST_ASSERT(apSuite, CHIP_NO_ERROR == delegate.SyncGetKeyValue(kKey1, out, size));
-    NL_TEST_ASSERT(apSuite, size == kSize2);
-    NL_TEST_ASSERT(apSuite, !memcmp(out, kValue2, kSize2));
+    EXPECT_EQ(delegate.SyncGetKeyValue(kKey1, out, size), CHIP_NO_ERROR);
+    EXPECT_EQ(size, kSize2);
+    EXPECT_FALSE(memcmp(out, kValue2, kSize2));
 
-    NL_TEST_ASSERT(apSuite, CHIP_NO_ERROR == delegate.SyncDeleteKeyValue(kKey1));
+    EXPECT_EQ(delegate.SyncDeleteKeyValue(kKey1), CHIP_NO_ERROR);
 
     size = static_cast<uint16_t>(sizeof(out));
-    NL_TEST_ASSERT(apSuite, CHIP_ERROR_PERSISTED_STORAGE_VALUE_NOT_FOUND == delegate.SyncGetKeyValue(kKey1, out, size));
+    EXPECT_EQ(CHIP_ERROR_PERSISTED_STORAGE_VALUE_NOT_FOUND, delegate.SyncGetKeyValue(kKey1, out, size));
 }
 
-void TestGroupInfo(nlTestSuite * apSuite, void * apContext)
+TEST_F(TestGroupDataProvider, TestGroupInfo)
 {
     GroupDataProvider * provider = GetGroupDataProvider();
-    NL_TEST_ASSERT(apSuite, provider);
+    EXPECT_TRUE(provider);
 
     // Reset test
     ResetProvider(provider);
@@ -233,114 +291,114 @@
     sListener.Reset();
 
     // Out-of-order
-    NL_TEST_ASSERT(apSuite, CHIP_ERROR_INVALID_ARGUMENT == provider->SetGroupInfoAt(kFabric1, 2, kGroupInfo1_1));
+    EXPECT_EQ(CHIP_ERROR_INVALID_ARGUMENT, provider->SetGroupInfoAt(kFabric1, 2, kGroupInfo1_1));
 
-    NL_TEST_ASSERT(apSuite, CHIP_NO_ERROR == provider->SetGroupInfoAt(kFabric1, 0, kGroupInfo1_1));
-    NL_TEST_ASSERT(apSuite, CHIP_NO_ERROR == provider->SetGroupInfoAt(kFabric1, 1, kGroupInfo1_2));
-    NL_TEST_ASSERT(apSuite, CHIP_NO_ERROR == provider->SetGroupInfoAt(kFabric1, 2, kGroupInfo1_3));
-    NL_TEST_ASSERT(apSuite, CHIP_NO_ERROR == provider->SetGroupInfoAt(kFabric2, 0, kGroupInfo2_1));
-    NL_TEST_ASSERT(apSuite, CHIP_NO_ERROR == provider->SetGroupInfoAt(kFabric2, 1, kGroupInfo2_2));
-    NL_TEST_ASSERT(apSuite, CHIP_NO_ERROR == provider->SetGroupInfoAt(kFabric2, 2, kGroupInfo2_3));
+    EXPECT_EQ(provider->SetGroupInfoAt(kFabric1, 0, kGroupInfo1_1), CHIP_NO_ERROR);
+    EXPECT_EQ(provider->SetGroupInfoAt(kFabric1, 1, kGroupInfo1_2), CHIP_NO_ERROR);
+    EXPECT_EQ(provider->SetGroupInfoAt(kFabric1, 2, kGroupInfo1_3), CHIP_NO_ERROR);
+    EXPECT_EQ(provider->SetGroupInfoAt(kFabric2, 0, kGroupInfo2_1), CHIP_NO_ERROR);
+    EXPECT_EQ(provider->SetGroupInfoAt(kFabric2, 1, kGroupInfo2_2), CHIP_NO_ERROR);
+    EXPECT_EQ(provider->SetGroupInfoAt(kFabric2, 2, kGroupInfo2_3), CHIP_NO_ERROR);
 
     // Duplicated
-    NL_TEST_ASSERT(apSuite, CHIP_ERROR_DUPLICATE_KEY_ID == provider->SetGroupInfoAt(kFabric1, 3, kGroupInfo1_1));
-    NL_TEST_ASSERT(apSuite, CHIP_ERROR_DUPLICATE_KEY_ID == provider->SetGroupInfoAt(kFabric2, 3, kGroupInfo2_3));
+    EXPECT_EQ(CHIP_ERROR_DUPLICATE_KEY_ID, provider->SetGroupInfoAt(kFabric1, 3, kGroupInfo1_1));
+    EXPECT_EQ(CHIP_ERROR_DUPLICATE_KEY_ID, provider->SetGroupInfoAt(kFabric2, 3, kGroupInfo2_3));
 
     // Get Group Info
 
-    NL_TEST_ASSERT(apSuite, CHIP_ERROR_INVALID_FABRIC_INDEX == provider->GetGroupInfoAt(kUndefinedFabricIndex, 0, group));
-    NL_TEST_ASSERT(apSuite, CHIP_ERROR_NOT_FOUND == provider->GetGroupInfoAt(kFabric2, 999, group));
+    EXPECT_EQ(CHIP_ERROR_INVALID_FABRIC_INDEX, provider->GetGroupInfoAt(kUndefinedFabricIndex, 0, group));
+    EXPECT_EQ(CHIP_ERROR_NOT_FOUND, provider->GetGroupInfoAt(kFabric2, 999, group));
 
-    NL_TEST_ASSERT(apSuite, sListener.latest == kGroupInfo2_3);
-    NL_TEST_ASSERT(apSuite, 6 == sListener.added_count);
-    NL_TEST_ASSERT(apSuite, 0 == sListener.removed_count);
+    EXPECT_EQ(sListener.latest, kGroupInfo2_3);
+    EXPECT_EQ(sListener.added_count, 6u);
+    EXPECT_EQ(sListener.removed_count, 0u);
 
-    NL_TEST_ASSERT(apSuite, CHIP_NO_ERROR == provider->GetGroupInfoAt(kFabric2, 2, group));
-    NL_TEST_ASSERT(apSuite, group == kGroupInfo2_3);
-    NL_TEST_ASSERT(apSuite, CHIP_NO_ERROR == provider->GetGroupInfoAt(kFabric2, 1, group));
-    NL_TEST_ASSERT(apSuite, group == kGroupInfo2_2);
-    NL_TEST_ASSERT(apSuite, CHIP_NO_ERROR == provider->GetGroupInfoAt(kFabric2, 0, group));
-    NL_TEST_ASSERT(apSuite, group == kGroupInfo2_1);
-    NL_TEST_ASSERT(apSuite, CHIP_NO_ERROR == provider->GetGroupInfoAt(kFabric1, 1, group));
-    NL_TEST_ASSERT(apSuite, group == kGroupInfo1_2);
-    NL_TEST_ASSERT(apSuite, CHIP_NO_ERROR == provider->GetGroupInfoAt(kFabric1, 0, group));
-    NL_TEST_ASSERT(apSuite, group == kGroupInfo1_1);
-    NL_TEST_ASSERT(apSuite, CHIP_NO_ERROR == provider->GetGroupInfoAt(kFabric1, 2, group));
-    NL_TEST_ASSERT(apSuite, group == kGroupInfo1_3);
+    EXPECT_EQ(provider->GetGroupInfoAt(kFabric2, 2, group), CHIP_NO_ERROR);
+    EXPECT_EQ(group, kGroupInfo2_3);
+    EXPECT_EQ(provider->GetGroupInfoAt(kFabric2, 1, group), CHIP_NO_ERROR);
+    EXPECT_EQ(group, kGroupInfo2_2);
+    EXPECT_EQ(provider->GetGroupInfoAt(kFabric2, 0, group), CHIP_NO_ERROR);
+    EXPECT_EQ(group, kGroupInfo2_1);
+    EXPECT_EQ(provider->GetGroupInfoAt(kFabric1, 1, group), CHIP_NO_ERROR);
+    EXPECT_EQ(group, kGroupInfo1_2);
+    EXPECT_EQ(provider->GetGroupInfoAt(kFabric1, 0, group), CHIP_NO_ERROR);
+    EXPECT_EQ(group, kGroupInfo1_1);
+    EXPECT_EQ(provider->GetGroupInfoAt(kFabric1, 2, group), CHIP_NO_ERROR);
+    EXPECT_EQ(group, kGroupInfo1_3);
 
     // Remove Groups
 
-    NL_TEST_ASSERT(apSuite, CHIP_NO_ERROR == provider->RemoveGroupInfo(kFabric1, kGroup3));
-    NL_TEST_ASSERT(apSuite, CHIP_NO_ERROR == provider->RemoveGroupInfoAt(kFabric2, 0));
-    NL_TEST_ASSERT(apSuite, sListener.latest == kGroupInfo2_1);
-    NL_TEST_ASSERT(apSuite, 6 == sListener.added_count);
-    NL_TEST_ASSERT(apSuite, 2 == sListener.removed_count);
+    EXPECT_EQ(provider->RemoveGroupInfo(kFabric1, kGroup3), CHIP_NO_ERROR);
+    EXPECT_EQ(provider->RemoveGroupInfoAt(kFabric2, 0), CHIP_NO_ERROR);
+    EXPECT_EQ(sListener.latest, kGroupInfo2_1);
+    EXPECT_EQ(sListener.added_count, 6u);
+    EXPECT_EQ(sListener.removed_count, 2u);
 
     // Remaining entries shift up
 
-    NL_TEST_ASSERT(apSuite, CHIP_ERROR_NOT_FOUND == provider->GetGroupInfoAt(kFabric2, 2, group));
-    NL_TEST_ASSERT(apSuite, CHIP_NO_ERROR == provider->GetGroupInfoAt(kFabric2, 1, group));
-    NL_TEST_ASSERT(apSuite, group == kGroupInfo2_3);
-    NL_TEST_ASSERT(apSuite, CHIP_NO_ERROR == provider->GetGroupInfoAt(kFabric2, 0, group));
-    NL_TEST_ASSERT(apSuite, group == kGroupInfo2_2);
-    NL_TEST_ASSERT(apSuite, CHIP_NO_ERROR == provider->GetGroupInfoAt(kFabric1, 1, group));
-    NL_TEST_ASSERT(apSuite, group == kGroupInfo1_2);
-    NL_TEST_ASSERT(apSuite, CHIP_NO_ERROR == provider->GetGroupInfoAt(kFabric1, 0, group));
-    NL_TEST_ASSERT(apSuite, group == kGroupInfo1_1);
-    NL_TEST_ASSERT(apSuite, CHIP_ERROR_NOT_FOUND == provider->GetGroupInfoAt(kFabric1, 3, group));
+    EXPECT_EQ(CHIP_ERROR_NOT_FOUND, provider->GetGroupInfoAt(kFabric2, 2, group));
+    EXPECT_EQ(provider->GetGroupInfoAt(kFabric2, 1, group), CHIP_NO_ERROR);
+    EXPECT_EQ(group, kGroupInfo2_3);
+    EXPECT_EQ(provider->GetGroupInfoAt(kFabric2, 0, group), CHIP_NO_ERROR);
+    EXPECT_EQ(group, kGroupInfo2_2);
+    EXPECT_EQ(provider->GetGroupInfoAt(kFabric1, 1, group), CHIP_NO_ERROR);
+    EXPECT_EQ(group, kGroupInfo1_2);
+    EXPECT_EQ(provider->GetGroupInfoAt(kFabric1, 0, group), CHIP_NO_ERROR);
+    EXPECT_EQ(group, kGroupInfo1_1);
+    EXPECT_EQ(CHIP_ERROR_NOT_FOUND, provider->GetGroupInfoAt(kFabric1, 3, group));
 
     // Overwrite with new group
 
-    NL_TEST_ASSERT(apSuite, CHIP_NO_ERROR == provider->SetGroupInfoAt(kFabric1, 2, kGroupInfo3_4));
+    EXPECT_EQ(provider->SetGroupInfoAt(kFabric1, 2, kGroupInfo3_4), CHIP_NO_ERROR);
     // Replace existing group (implicit group remove)
-    NL_TEST_ASSERT(apSuite, CHIP_NO_ERROR == provider->SetGroupInfoAt(kFabric2, 0, kGroupInfo3_4));
+    EXPECT_EQ(provider->SetGroupInfoAt(kFabric2, 0, kGroupInfo3_4), CHIP_NO_ERROR);
 
-    NL_TEST_ASSERT(apSuite, CHIP_NO_ERROR == provider->GetGroupInfoAt(kFabric1, 2, group));
-    NL_TEST_ASSERT(apSuite, group == kGroupInfo3_4);
+    EXPECT_EQ(provider->GetGroupInfoAt(kFabric1, 2, group), CHIP_NO_ERROR);
+    EXPECT_EQ(group, kGroupInfo3_4);
 
-    NL_TEST_ASSERT(apSuite, CHIP_NO_ERROR == provider->GetGroupInfoAt(kFabric2, 0, group));
-    NL_TEST_ASSERT(apSuite, group == kGroupInfo3_4);
-    NL_TEST_ASSERT(apSuite, sListener.latest == kGroupInfo3_4);
-    NL_TEST_ASSERT(apSuite, 8 == sListener.added_count);
-    NL_TEST_ASSERT(apSuite, 3 == sListener.removed_count);
+    EXPECT_EQ(provider->GetGroupInfoAt(kFabric2, 0, group), CHIP_NO_ERROR);
+    EXPECT_EQ(group, kGroupInfo3_4);
+    EXPECT_EQ(sListener.latest, kGroupInfo3_4);
+    EXPECT_EQ(sListener.added_count, 8u);
+    EXPECT_EQ(sListener.removed_count, 3u);
 
     // Overwrite existing group, index must match
 
-    NL_TEST_ASSERT(apSuite, CHIP_ERROR_DUPLICATE_KEY_ID == provider->SetGroupInfoAt(kFabric1, 1, kGroupInfo1_1));
-    NL_TEST_ASSERT(apSuite, CHIP_NO_ERROR == provider->SetGroupInfoAt(kFabric1, 1, kGroupInfo2_2));
+    EXPECT_EQ(CHIP_ERROR_DUPLICATE_KEY_ID, provider->SetGroupInfoAt(kFabric1, 1, kGroupInfo1_1));
+    EXPECT_EQ(provider->SetGroupInfoAt(kFabric1, 1, kGroupInfo2_2), CHIP_NO_ERROR);
 
-    NL_TEST_ASSERT(apSuite, CHIP_ERROR_DUPLICATE_KEY_ID == provider->SetGroupInfoAt(kFabric2, 1, kGroupInfo3_4));
-    NL_TEST_ASSERT(apSuite, CHIP_NO_ERROR == provider->SetGroupInfoAt(kFabric2, 1, kGroupInfo1_3));
+    EXPECT_EQ(CHIP_ERROR_DUPLICATE_KEY_ID, provider->SetGroupInfoAt(kFabric2, 1, kGroupInfo3_4));
+    EXPECT_EQ(provider->SetGroupInfoAt(kFabric2, 1, kGroupInfo1_3), CHIP_NO_ERROR);
 
-    NL_TEST_ASSERT(apSuite, CHIP_NO_ERROR == provider->GetGroupInfoAt(kFabric1, 1, group));
-    NL_TEST_ASSERT(apSuite, group == kGroupInfo2_2);
+    EXPECT_EQ(provider->GetGroupInfoAt(kFabric1, 1, group), CHIP_NO_ERROR);
+    EXPECT_EQ(group, kGroupInfo2_2);
 
-    NL_TEST_ASSERT(apSuite, CHIP_NO_ERROR == provider->GetGroupInfoAt(kFabric2, 1, group));
-    NL_TEST_ASSERT(apSuite, group == kGroupInfo1_3);
-    NL_TEST_ASSERT(apSuite, sListener.latest == kGroupInfo3_4);
-    NL_TEST_ASSERT(apSuite, 8 == sListener.added_count);
-    NL_TEST_ASSERT(apSuite, 3 == sListener.removed_count);
+    EXPECT_EQ(provider->GetGroupInfoAt(kFabric2, 1, group), CHIP_NO_ERROR);
+    EXPECT_EQ(group, kGroupInfo1_3);
+    EXPECT_EQ(sListener.latest, kGroupInfo3_4);
+    EXPECT_EQ(sListener.added_count, 8u);
+    EXPECT_EQ(sListener.removed_count, 3u);
 
     // By group_id
 
     // Override existing
-    NL_TEST_ASSERT(apSuite, CHIP_NO_ERROR == provider->SetGroupInfo(kFabric1, kGroupInfo3_5));
+    EXPECT_EQ(provider->SetGroupInfo(kFabric1, kGroupInfo3_5), CHIP_NO_ERROR);
     // New group
-    NL_TEST_ASSERT(apSuite, CHIP_NO_ERROR == provider->SetGroupInfo(kFabric2, kGroupInfo3_2));
+    EXPECT_EQ(provider->SetGroupInfo(kFabric2, kGroupInfo3_2), CHIP_NO_ERROR);
     // Not found
-    NL_TEST_ASSERT(apSuite, CHIP_ERROR_NOT_FOUND == provider->GetGroupInfo(kFabric2, kGroup5, group));
+    EXPECT_EQ(CHIP_ERROR_NOT_FOUND, provider->GetGroupInfo(kFabric2, kGroup5, group));
     // Existing
-    NL_TEST_ASSERT(apSuite, CHIP_NO_ERROR == provider->GetGroupInfo(kFabric2, kGroup2, group));
-    NL_TEST_ASSERT(apSuite, group == kGroupInfo3_2);
-    NL_TEST_ASSERT(apSuite, sListener.latest == kGroupInfo3_2);
-    NL_TEST_ASSERT(apSuite, 9 == sListener.added_count);
-    NL_TEST_ASSERT(apSuite, 3 == sListener.removed_count);
+    EXPECT_EQ(provider->GetGroupInfo(kFabric2, kGroup2, group), CHIP_NO_ERROR);
+    EXPECT_EQ(group, kGroupInfo3_2);
+    EXPECT_EQ(sListener.latest, kGroupInfo3_2);
+    EXPECT_EQ(sListener.added_count, 9u);
+    EXPECT_EQ(sListener.removed_count, 3u);
 }
 
-void TestGroupInfoIterator(nlTestSuite * apSuite, void * apContext)
+TEST_F(TestGroupDataProvider, TestGroupInfoIterator)
 {
     GroupDataProvider * provider = GetGroupDataProvider();
-    NL_TEST_ASSERT(apSuite, provider);
+    EXPECT_TRUE(provider);
 
     // Reset test
     ResetProvider(provider);
@@ -349,12 +407,12 @@
 
     // Set Group Info
 
-    NL_TEST_ASSERT(apSuite, CHIP_NO_ERROR == provider->SetGroupInfoAt(kFabric1, 0, kGroupInfo1_3));
-    NL_TEST_ASSERT(apSuite, CHIP_NO_ERROR == provider->SetGroupInfoAt(kFabric1, 1, kGroupInfo1_2));
-    NL_TEST_ASSERT(apSuite, CHIP_NO_ERROR == provider->SetGroupInfoAt(kFabric1, 2, kGroupInfo1_1));
-    NL_TEST_ASSERT(apSuite, CHIP_NO_ERROR == provider->SetGroupInfoAt(kFabric2, 0, kGroupInfo2_1));
-    NL_TEST_ASSERT(apSuite, CHIP_NO_ERROR == provider->SetGroupInfoAt(kFabric2, 1, kGroupInfo2_3));
-    NL_TEST_ASSERT(apSuite, CHIP_NO_ERROR == provider->SetGroupInfoAt(kFabric2, 2, kGroupInfo2_2));
+    EXPECT_EQ(provider->SetGroupInfoAt(kFabric1, 0, kGroupInfo1_3), CHIP_NO_ERROR);
+    EXPECT_EQ(provider->SetGroupInfoAt(kFabric1, 1, kGroupInfo1_2), CHIP_NO_ERROR);
+    EXPECT_EQ(provider->SetGroupInfoAt(kFabric1, 2, kGroupInfo1_1), CHIP_NO_ERROR);
+    EXPECT_EQ(provider->SetGroupInfoAt(kFabric2, 0, kGroupInfo2_1), CHIP_NO_ERROR);
+    EXPECT_EQ(provider->SetGroupInfoAt(kFabric2, 1, kGroupInfo2_3), CHIP_NO_ERROR);
+    EXPECT_EQ(provider->SetGroupInfoAt(kFabric2, 2, kGroupInfo2_2), CHIP_NO_ERROR);
 
     // Iterate fabric 1
 
@@ -363,17 +421,14 @@
 
     auto it  = provider->IterateGroupInfo(kFabric1);
     size_t i = 0;
-    NL_TEST_ASSERT(apSuite, it);
-    if (it)
+    ASSERT_TRUE(it);
+    EXPECT_EQ(expected_f1_count, it->Count());
+    while (it->Next(group) && i < expected_f1_count)
     {
-        NL_TEST_ASSERT(apSuite, expected_f1_count == it->Count());
-        while (it->Next(group) && i < expected_f1_count)
-        {
-            NL_TEST_ASSERT(apSuite, expected_f1[i++] == group);
-        }
-        NL_TEST_ASSERT(apSuite, i == it->Count());
-        it->Release();
+        EXPECT_EQ(expected_f1[i++], group);
     }
+    EXPECT_EQ(i, it->Count());
+    it->Release();
 
     // Iterate fabric 2
 
@@ -381,24 +436,21 @@
     size_t expected_f2_count = sizeof(expected_f2) / sizeof(GroupInfo);
 
     it = provider->IterateGroupInfo(kFabric2);
-    NL_TEST_ASSERT(apSuite, it);
-    if (it)
+    ASSERT_TRUE(it);
+    i = 0;
+    EXPECT_EQ(expected_f2_count, it->Count());
+    while (it->Next(group) && i < expected_f2_count)
     {
-        i = 0;
-        NL_TEST_ASSERT(apSuite, expected_f2_count == it->Count());
-        while (it->Next(group) && i < expected_f2_count)
-        {
-            NL_TEST_ASSERT(apSuite, expected_f2[i++] == group);
-        }
-        NL_TEST_ASSERT(apSuite, i == it->Count());
-        it->Release();
+        EXPECT_EQ(expected_f2[i++], group);
     }
+    EXPECT_EQ(i, it->Count());
+    it->Release();
 }
 
-void TestEndpoints(nlTestSuite * apSuite, void * apContext)
+TEST_F(TestGroupDataProvider, TestEndpoints)
 {
     GroupDataProvider * provider = GetGroupDataProvider();
-    NL_TEST_ASSERT(apSuite, provider);
+    EXPECT_TRUE(provider);
 
     // Reset test
     ResetProvider(provider);
@@ -407,92 +459,92 @@
 
     // Existing groups
 
-    NL_TEST_ASSERT(apSuite, CHIP_NO_ERROR == provider->SetGroupInfoAt(kFabric1, 0, kGroupInfo1_1));
-    NL_TEST_ASSERT(apSuite, CHIP_NO_ERROR == provider->SetGroupInfoAt(kFabric1, 1, kGroupInfo1_2));
-    NL_TEST_ASSERT(apSuite, CHIP_NO_ERROR == provider->SetGroupInfoAt(kFabric1, 2, kGroupInfo1_3));
+    EXPECT_EQ(provider->SetGroupInfoAt(kFabric1, 0, kGroupInfo1_1), CHIP_NO_ERROR);
+    EXPECT_EQ(provider->SetGroupInfoAt(kFabric1, 1, kGroupInfo1_2), CHIP_NO_ERROR);
+    EXPECT_EQ(provider->SetGroupInfoAt(kFabric1, 2, kGroupInfo1_3), CHIP_NO_ERROR);
 
-    NL_TEST_ASSERT(apSuite, !provider->HasEndpoint(kFabric1, kGroup1, kEndpointId0));
-    NL_TEST_ASSERT(apSuite, !provider->HasEndpoint(kFabric1, kGroup1, kEndpointId1));
-    NL_TEST_ASSERT(apSuite, !provider->HasEndpoint(kFabric1, kGroup2, kEndpointId2));
-    NL_TEST_ASSERT(apSuite, !provider->HasEndpoint(kFabric1, kGroup2, kEndpointId3));
+    EXPECT_FALSE(provider->HasEndpoint(kFabric1, kGroup1, kEndpointId0));
+    EXPECT_FALSE(provider->HasEndpoint(kFabric1, kGroup1, kEndpointId1));
+    EXPECT_FALSE(provider->HasEndpoint(kFabric1, kGroup2, kEndpointId2));
+    EXPECT_FALSE(provider->HasEndpoint(kFabric1, kGroup2, kEndpointId3));
 
-    NL_TEST_ASSERT(apSuite, CHIP_NO_ERROR == provider->AddEndpoint(kFabric1, kGroup1, kEndpointId0));
-    NL_TEST_ASSERT(apSuite, CHIP_NO_ERROR == provider->AddEndpoint(kFabric1, kGroup1, kEndpointId1));
-    NL_TEST_ASSERT(apSuite, CHIP_NO_ERROR == provider->AddEndpoint(kFabric1, kGroup2, kEndpointId2));
-    NL_TEST_ASSERT(apSuite, CHIP_NO_ERROR == provider->AddEndpoint(kFabric1, kGroup2, kEndpointId3));
+    EXPECT_EQ(provider->AddEndpoint(kFabric1, kGroup1, kEndpointId0), CHIP_NO_ERROR);
+    EXPECT_EQ(provider->AddEndpoint(kFabric1, kGroup1, kEndpointId1), CHIP_NO_ERROR);
+    EXPECT_EQ(provider->AddEndpoint(kFabric1, kGroup2, kEndpointId2), CHIP_NO_ERROR);
+    EXPECT_EQ(provider->AddEndpoint(kFabric1, kGroup2, kEndpointId3), CHIP_NO_ERROR);
 
-    NL_TEST_ASSERT(apSuite, provider->HasEndpoint(kFabric1, kGroup2, kEndpointId3));
-    NL_TEST_ASSERT(apSuite, provider->HasEndpoint(kFabric1, kGroup2, kEndpointId2));
-    NL_TEST_ASSERT(apSuite, provider->HasEndpoint(kFabric1, kGroup1, kEndpointId1));
-    NL_TEST_ASSERT(apSuite, provider->HasEndpoint(kFabric1, kGroup1, kEndpointId0));
+    EXPECT_TRUE(provider->HasEndpoint(kFabric1, kGroup2, kEndpointId3));
+    EXPECT_TRUE(provider->HasEndpoint(kFabric1, kGroup2, kEndpointId2));
+    EXPECT_TRUE(provider->HasEndpoint(kFabric1, kGroup1, kEndpointId1));
+    EXPECT_TRUE(provider->HasEndpoint(kFabric1, kGroup1, kEndpointId0));
 
     // New groups
 
-    NL_TEST_ASSERT(apSuite, !provider->HasEndpoint(kFabric2, kGroup1, kEndpointId0));
-    NL_TEST_ASSERT(apSuite, !provider->HasEndpoint(kFabric2, kGroup2, kEndpointId1));
-    NL_TEST_ASSERT(apSuite, !provider->HasEndpoint(kFabric2, kGroup3, kEndpointId2));
-    NL_TEST_ASSERT(apSuite, !provider->HasEndpoint(kFabric2, kGroup4, kEndpointId3));
+    EXPECT_FALSE(provider->HasEndpoint(kFabric2, kGroup1, kEndpointId0));
+    EXPECT_FALSE(provider->HasEndpoint(kFabric2, kGroup2, kEndpointId1));
+    EXPECT_FALSE(provider->HasEndpoint(kFabric2, kGroup3, kEndpointId2));
+    EXPECT_FALSE(provider->HasEndpoint(kFabric2, kGroup4, kEndpointId3));
 
-    NL_TEST_ASSERT(apSuite, CHIP_NO_ERROR == provider->AddEndpoint(kFabric2, kGroup1, kEndpointId0));
-    NL_TEST_ASSERT(apSuite, CHIP_NO_ERROR == provider->AddEndpoint(kFabric2, kGroup2, kEndpointId1));
-    NL_TEST_ASSERT(apSuite, CHIP_NO_ERROR == provider->AddEndpoint(kFabric2, kGroup3, kEndpointId2));
-    NL_TEST_ASSERT(apSuite, CHIP_NO_ERROR == provider->AddEndpoint(kFabric2, kGroup4, kEndpointId3));
+    EXPECT_EQ(provider->AddEndpoint(kFabric2, kGroup1, kEndpointId0), CHIP_NO_ERROR);
+    EXPECT_EQ(provider->AddEndpoint(kFabric2, kGroup2, kEndpointId1), CHIP_NO_ERROR);
+    EXPECT_EQ(provider->AddEndpoint(kFabric2, kGroup3, kEndpointId2), CHIP_NO_ERROR);
+    EXPECT_EQ(provider->AddEndpoint(kFabric2, kGroup4, kEndpointId3), CHIP_NO_ERROR);
 
-    NL_TEST_ASSERT(apSuite, provider->HasEndpoint(kFabric2, kGroup1, kEndpointId0));
-    NL_TEST_ASSERT(apSuite, provider->HasEndpoint(kFabric2, kGroup2, kEndpointId1));
-    NL_TEST_ASSERT(apSuite, provider->HasEndpoint(kFabric2, kGroup3, kEndpointId2));
-    NL_TEST_ASSERT(apSuite, provider->HasEndpoint(kFabric2, kGroup4, kEndpointId3));
+    EXPECT_TRUE(provider->HasEndpoint(kFabric2, kGroup1, kEndpointId0));
+    EXPECT_TRUE(provider->HasEndpoint(kFabric2, kGroup2, kEndpointId1));
+    EXPECT_TRUE(provider->HasEndpoint(kFabric2, kGroup3, kEndpointId2));
+    EXPECT_TRUE(provider->HasEndpoint(kFabric2, kGroup4, kEndpointId3));
 
     // Remove
 
-    NL_TEST_ASSERT(apSuite, CHIP_ERROR_NOT_FOUND == provider->RemoveEndpoint(kFabric1, kGroup1, kEndpointId4));
-    NL_TEST_ASSERT(apSuite, CHIP_NO_ERROR == provider->RemoveEndpoint(kFabric1, kGroup1, kEndpointId0));
-    NL_TEST_ASSERT(apSuite, CHIP_NO_ERROR == provider->RemoveEndpoint(kFabric1, kGroup2, kEndpointId3));
+    EXPECT_EQ(CHIP_ERROR_NOT_FOUND, provider->RemoveEndpoint(kFabric1, kGroup1, kEndpointId4));
+    EXPECT_EQ(provider->RemoveEndpoint(kFabric1, kGroup1, kEndpointId0), CHIP_NO_ERROR);
+    EXPECT_EQ(provider->RemoveEndpoint(kFabric1, kGroup2, kEndpointId3), CHIP_NO_ERROR);
 
-    NL_TEST_ASSERT(apSuite, CHIP_ERROR_NOT_FOUND == provider->RemoveEndpoint(kFabric2, kGroup5, kEndpointId0));
-    NL_TEST_ASSERT(apSuite, CHIP_NO_ERROR == provider->RemoveEndpoint(kFabric2, kGroup2, kEndpointId1));
-    NL_TEST_ASSERT(apSuite, CHIP_NO_ERROR == provider->RemoveEndpoint(kFabric2, kGroup3, kEndpointId2));
+    EXPECT_EQ(CHIP_ERROR_NOT_FOUND, provider->RemoveEndpoint(kFabric2, kGroup5, kEndpointId0));
+    EXPECT_EQ(provider->RemoveEndpoint(kFabric2, kGroup2, kEndpointId1), CHIP_NO_ERROR);
+    EXPECT_EQ(provider->RemoveEndpoint(kFabric2, kGroup3, kEndpointId2), CHIP_NO_ERROR);
 
     // Check removed
 
-    NL_TEST_ASSERT(apSuite, !provider->HasEndpoint(kFabric1, kGroup1, kEndpointId0));
-    NL_TEST_ASSERT(apSuite, provider->HasEndpoint(kFabric1, kGroup1, kEndpointId1));
-    NL_TEST_ASSERT(apSuite, provider->HasEndpoint(kFabric1, kGroup2, kEndpointId2));
-    NL_TEST_ASSERT(apSuite, !provider->HasEndpoint(kFabric1, kGroup2, kEndpointId3));
+    EXPECT_FALSE(provider->HasEndpoint(kFabric1, kGroup1, kEndpointId0));
+    EXPECT_TRUE(provider->HasEndpoint(kFabric1, kGroup1, kEndpointId1));
+    EXPECT_TRUE(provider->HasEndpoint(kFabric1, kGroup2, kEndpointId2));
+    EXPECT_FALSE(provider->HasEndpoint(kFabric1, kGroup2, kEndpointId3));
 
-    NL_TEST_ASSERT(apSuite, provider->HasEndpoint(kFabric2, kGroup1, kEndpointId0));
-    NL_TEST_ASSERT(apSuite, !provider->HasEndpoint(kFabric2, kGroup2, kEndpointId1));
-    NL_TEST_ASSERT(apSuite, !provider->HasEndpoint(kFabric2, kGroup3, kEndpointId2));
-    NL_TEST_ASSERT(apSuite, provider->HasEndpoint(kFabric2, kGroup4, kEndpointId3));
+    EXPECT_TRUE(provider->HasEndpoint(kFabric2, kGroup1, kEndpointId0));
+    EXPECT_FALSE(provider->HasEndpoint(kFabric2, kGroup2, kEndpointId1));
+    EXPECT_FALSE(provider->HasEndpoint(kFabric2, kGroup3, kEndpointId2));
+    EXPECT_TRUE(provider->HasEndpoint(kFabric2, kGroup4, kEndpointId3));
 
     // Remove All
 
-    NL_TEST_ASSERT(apSuite, CHIP_NO_ERROR == provider->AddEndpoint(kFabric1, kGroup1, kEndpointId3));
-    NL_TEST_ASSERT(apSuite, CHIP_NO_ERROR == provider->AddEndpoint(kFabric1, kGroup2, kEndpointId3));
-    NL_TEST_ASSERT(apSuite, CHIP_NO_ERROR == provider->AddEndpoint(kFabric1, kGroup3, kEndpointId3));
-    NL_TEST_ASSERT(apSuite, CHIP_NO_ERROR == provider->AddEndpoint(kFabric1, kGroup4, kEndpointId3));
+    EXPECT_EQ(provider->AddEndpoint(kFabric1, kGroup1, kEndpointId3), CHIP_NO_ERROR);
+    EXPECT_EQ(provider->AddEndpoint(kFabric1, kGroup2, kEndpointId3), CHIP_NO_ERROR);
+    EXPECT_EQ(provider->AddEndpoint(kFabric1, kGroup3, kEndpointId3), CHIP_NO_ERROR);
+    EXPECT_EQ(provider->AddEndpoint(kFabric1, kGroup4, kEndpointId3), CHIP_NO_ERROR);
 
-    NL_TEST_ASSERT(apSuite, provider->HasEndpoint(kFabric1, kGroup1, kEndpointId1));
-    NL_TEST_ASSERT(apSuite, provider->HasEndpoint(kFabric1, kGroup1, kEndpointId3));
-    NL_TEST_ASSERT(apSuite, provider->HasEndpoint(kFabric1, kGroup2, kEndpointId3));
-    NL_TEST_ASSERT(apSuite, provider->HasEndpoint(kFabric1, kGroup2, kEndpointId2));
-    NL_TEST_ASSERT(apSuite, provider->HasEndpoint(kFabric1, kGroup3, kEndpointId3));
-    NL_TEST_ASSERT(apSuite, provider->HasEndpoint(kFabric1, kGroup4, kEndpointId3));
+    EXPECT_TRUE(provider->HasEndpoint(kFabric1, kGroup1, kEndpointId1));
+    EXPECT_TRUE(provider->HasEndpoint(kFabric1, kGroup1, kEndpointId3));
+    EXPECT_TRUE(provider->HasEndpoint(kFabric1, kGroup2, kEndpointId3));
+    EXPECT_TRUE(provider->HasEndpoint(kFabric1, kGroup2, kEndpointId2));
+    EXPECT_TRUE(provider->HasEndpoint(kFabric1, kGroup3, kEndpointId3));
+    EXPECT_TRUE(provider->HasEndpoint(kFabric1, kGroup4, kEndpointId3));
 
-    NL_TEST_ASSERT(apSuite, CHIP_NO_ERROR == provider->RemoveEndpoint(kFabric1, kEndpointId3));
+    EXPECT_EQ(provider->RemoveEndpoint(kFabric1, kEndpointId3), CHIP_NO_ERROR);
 
-    NL_TEST_ASSERT(apSuite, provider->HasEndpoint(kFabric1, kGroup1, kEndpointId1));
-    NL_TEST_ASSERT(apSuite, !provider->HasEndpoint(kFabric1, kGroup1, kEndpointId3));
-    NL_TEST_ASSERT(apSuite, !provider->HasEndpoint(kFabric1, kGroup2, kEndpointId3));
-    NL_TEST_ASSERT(apSuite, provider->HasEndpoint(kFabric1, kGroup2, kEndpointId2));
-    NL_TEST_ASSERT(apSuite, !provider->HasEndpoint(kFabric1, kGroup3, kEndpointId3));
-    NL_TEST_ASSERT(apSuite, !provider->HasEndpoint(kFabric1, kGroup4, kEndpointId3));
+    EXPECT_TRUE(provider->HasEndpoint(kFabric1, kGroup1, kEndpointId1));
+    EXPECT_FALSE(provider->HasEndpoint(kFabric1, kGroup1, kEndpointId3));
+    EXPECT_FALSE(provider->HasEndpoint(kFabric1, kGroup2, kEndpointId3));
+    EXPECT_TRUE(provider->HasEndpoint(kFabric1, kGroup2, kEndpointId2));
+    EXPECT_FALSE(provider->HasEndpoint(kFabric1, kGroup3, kEndpointId3));
+    EXPECT_FALSE(provider->HasEndpoint(kFabric1, kGroup4, kEndpointId3));
 }
 
-void TestEndpointIterator(nlTestSuite * apSuite, void * apContext)
+TEST_F(TestGroupDataProvider, TestEndpointIterator)
 {
     GroupDataProvider * provider = GetGroupDataProvider();
-    NL_TEST_ASSERT(apSuite, provider);
+    EXPECT_TRUE(provider);
 
     // Reset test
     ResetProvider(provider);
@@ -501,18 +553,18 @@
 
     // Set Endpoints
 
-    NL_TEST_ASSERT(apSuite, CHIP_NO_ERROR == provider->AddEndpoint(kFabric1, kGroup1, kEndpointId0));
-    NL_TEST_ASSERT(apSuite, CHIP_NO_ERROR == provider->AddEndpoint(kFabric1, kGroup1, kEndpointId2));
-    NL_TEST_ASSERT(apSuite, CHIP_NO_ERROR == provider->AddEndpoint(kFabric1, kGroup1, kEndpointId4));
-    NL_TEST_ASSERT(apSuite, CHIP_NO_ERROR == provider->AddEndpoint(kFabric1, kGroup2, kEndpointId1));
-    NL_TEST_ASSERT(apSuite, CHIP_NO_ERROR == provider->AddEndpoint(kFabric1, kGroup2, kEndpointId2));
-    NL_TEST_ASSERT(apSuite, CHIP_NO_ERROR == provider->AddEndpoint(kFabric1, kGroup2, kEndpointId3));
+    EXPECT_EQ(provider->AddEndpoint(kFabric1, kGroup1, kEndpointId0), CHIP_NO_ERROR);
+    EXPECT_EQ(provider->AddEndpoint(kFabric1, kGroup1, kEndpointId2), CHIP_NO_ERROR);
+    EXPECT_EQ(provider->AddEndpoint(kFabric1, kGroup1, kEndpointId4), CHIP_NO_ERROR);
+    EXPECT_EQ(provider->AddEndpoint(kFabric1, kGroup2, kEndpointId1), CHIP_NO_ERROR);
+    EXPECT_EQ(provider->AddEndpoint(kFabric1, kGroup2, kEndpointId2), CHIP_NO_ERROR);
+    EXPECT_EQ(provider->AddEndpoint(kFabric1, kGroup2, kEndpointId3), CHIP_NO_ERROR);
 
-    NL_TEST_ASSERT(apSuite, CHIP_NO_ERROR == provider->AddEndpoint(kFabric2, kGroup3, kEndpointId0));
-    NL_TEST_ASSERT(apSuite, CHIP_NO_ERROR == provider->AddEndpoint(kFabric2, kGroup3, kEndpointId1));
-    NL_TEST_ASSERT(apSuite, CHIP_NO_ERROR == provider->AddEndpoint(kFabric2, kGroup3, kEndpointId2));
-    NL_TEST_ASSERT(apSuite, CHIP_NO_ERROR == provider->AddEndpoint(kFabric2, kGroup3, kEndpointId3));
-    NL_TEST_ASSERT(apSuite, CHIP_NO_ERROR == provider->AddEndpoint(kFabric2, kGroup3, kEndpointId4));
+    EXPECT_EQ(provider->AddEndpoint(kFabric2, kGroup3, kEndpointId0), CHIP_NO_ERROR);
+    EXPECT_EQ(provider->AddEndpoint(kFabric2, kGroup3, kEndpointId1), CHIP_NO_ERROR);
+    EXPECT_EQ(provider->AddEndpoint(kFabric2, kGroup3, kEndpointId2), CHIP_NO_ERROR);
+    EXPECT_EQ(provider->AddEndpoint(kFabric2, kGroup3, kEndpointId3), CHIP_NO_ERROR);
+    EXPECT_EQ(provider->AddEndpoint(kFabric2, kGroup3, kEndpointId4), CHIP_NO_ERROR);
 
     // Iterate fabric 1
 
@@ -523,20 +575,17 @@
 
     auto it      = provider->IterateEndpoints(kFabric1);
     size_t count = 0;
-    NL_TEST_ASSERT(apSuite, it);
-    if (it)
+    ASSERT_TRUE(it);
+    GroupEndpoint output;
+    EXPECT_EQ(expected_f1.size(), it->Count());
+    while (it->Next(output) && count < expected_f1.size())
     {
-        GroupEndpoint output;
-        NL_TEST_ASSERT(apSuite, expected_f1.size() == it->Count());
-        while (it->Next(output) && count < expected_f1.size())
-        {
-            std::pair<chip::GroupId, chip::EndpointId> mapping(output.group_id, output.endpoint_id);
-            NL_TEST_ASSERT(apSuite, expected_f1.count(mapping) > 0);
-            count++;
-        }
-        NL_TEST_ASSERT(apSuite, count == it->Count());
-        it->Release();
+        std::pair<chip::GroupId, chip::EndpointId> mapping(output.group_id, output.endpoint_id);
+        EXPECT_GT(expected_f1.count(mapping), 0u);
+        count++;
     }
+    EXPECT_EQ(count, it->Count());
+    it->Release();
 
     // Iterate fabric 2
 
@@ -546,27 +595,23 @@
     };
 
     it = provider->IterateEndpoints(kFabric2);
-    NL_TEST_ASSERT(apSuite, it);
-    if (it)
+    ASSERT_TRUE(it);
+    count = 0;
+    EXPECT_EQ(expected_f2.size(), it->Count());
+    while (it->Next(output) && count < expected_f2.size())
     {
-        count = 0;
-        GroupEndpoint output;
-        NL_TEST_ASSERT(apSuite, expected_f2.size() == it->Count());
-        while (it->Next(output) && count < expected_f2.size())
-        {
-            std::pair<chip::GroupId, chip::EndpointId> mapping(output.group_id, output.endpoint_id);
-            NL_TEST_ASSERT(apSuite, expected_f2.count(mapping) > 0);
-            count++;
-        }
-        NL_TEST_ASSERT(apSuite, count == it->Count());
-        it->Release();
+        std::pair<chip::GroupId, chip::EndpointId> mapping(output.group_id, output.endpoint_id);
+        EXPECT_GT(expected_f2.count(mapping), 0u);
+        count++;
     }
+    EXPECT_EQ(count, it->Count());
+    it->Release();
 }
 
-void TestGroupKeys(nlTestSuite * apSuite, void * apContext)
+TEST_F(TestGroupDataProvider, TestGroupKeys)
 {
     GroupDataProvider * provider = GetGroupDataProvider();
-    NL_TEST_ASSERT(apSuite, provider);
+    EXPECT_TRUE(provider);
 
     // Reset test
     ResetProvider(provider);
@@ -576,101 +621,101 @@
     // Set Group Info
 
     // Out-of-order
-    NL_TEST_ASSERT(apSuite, CHIP_ERROR_INVALID_ARGUMENT == provider->SetGroupKeyAt(kFabric1, 2, kGroup1Keyset0));
+    EXPECT_EQ(CHIP_ERROR_INVALID_ARGUMENT, provider->SetGroupKeyAt(kFabric1, 2, kGroup1Keyset0));
 
-    NL_TEST_ASSERT(apSuite, CHIP_NO_ERROR == provider->SetGroupKeyAt(kFabric1, 0, kGroup1Keyset0));
-    NL_TEST_ASSERT(apSuite, CHIP_NO_ERROR == provider->SetGroupKeyAt(kFabric1, 1, kGroup1Keyset1));
-    NL_TEST_ASSERT(apSuite, CHIP_NO_ERROR == provider->SetGroupKeyAt(kFabric1, 2, kGroup1Keyset2));
-    NL_TEST_ASSERT(apSuite, CHIP_NO_ERROR == provider->SetGroupKeyAt(kFabric1, 3, kGroup1Keyset3));
+    EXPECT_EQ(provider->SetGroupKeyAt(kFabric1, 0, kGroup1Keyset0), CHIP_NO_ERROR);
+    EXPECT_EQ(provider->SetGroupKeyAt(kFabric1, 1, kGroup1Keyset1), CHIP_NO_ERROR);
+    EXPECT_EQ(provider->SetGroupKeyAt(kFabric1, 2, kGroup1Keyset2), CHIP_NO_ERROR);
+    EXPECT_EQ(provider->SetGroupKeyAt(kFabric1, 3, kGroup1Keyset3), CHIP_NO_ERROR);
     // Duplicated
-    NL_TEST_ASSERT(apSuite, CHIP_ERROR_DUPLICATE_KEY_ID == provider->SetGroupKeyAt(kFabric1, 4, kGroup1Keyset2));
+    EXPECT_EQ(CHIP_ERROR_DUPLICATE_KEY_ID, provider->SetGroupKeyAt(kFabric1, 4, kGroup1Keyset2));
 
-    NL_TEST_ASSERT(apSuite, CHIP_NO_ERROR == provider->SetGroupKeyAt(kFabric2, 0, kGroup2Keyset0));
-    NL_TEST_ASSERT(apSuite, CHIP_NO_ERROR == provider->SetGroupKeyAt(kFabric2, 1, kGroup2Keyset1));
-    NL_TEST_ASSERT(apSuite, CHIP_NO_ERROR == provider->SetGroupKeyAt(kFabric2, 2, kGroup2Keyset2));
-    NL_TEST_ASSERT(apSuite, CHIP_NO_ERROR == provider->SetGroupKeyAt(kFabric2, 3, kGroup2Keyset3));
+    EXPECT_EQ(provider->SetGroupKeyAt(kFabric2, 0, kGroup2Keyset0), CHIP_NO_ERROR);
+    EXPECT_EQ(provider->SetGroupKeyAt(kFabric2, 1, kGroup2Keyset1), CHIP_NO_ERROR);
+    EXPECT_EQ(provider->SetGroupKeyAt(kFabric2, 2, kGroup2Keyset2), CHIP_NO_ERROR);
+    EXPECT_EQ(provider->SetGroupKeyAt(kFabric2, 3, kGroup2Keyset3), CHIP_NO_ERROR);
     // Duplicated
-    NL_TEST_ASSERT(apSuite, CHIP_ERROR_DUPLICATE_KEY_ID == provider->SetGroupKeyAt(kFabric2, 4, kGroup2Keyset0));
+    EXPECT_EQ(CHIP_ERROR_DUPLICATE_KEY_ID, provider->SetGroupKeyAt(kFabric2, 4, kGroup2Keyset0));
 
     // Get Group Info
 
-    NL_TEST_ASSERT(apSuite, CHIP_ERROR_INVALID_FABRIC_INDEX == provider->GetGroupKeyAt(kUndefinedFabricIndex, 0, pair));
-    NL_TEST_ASSERT(apSuite, CHIP_ERROR_NOT_FOUND == provider->GetGroupKeyAt(kFabric2, 999, pair));
+    EXPECT_EQ(CHIP_ERROR_INVALID_FABRIC_INDEX, provider->GetGroupKeyAt(kUndefinedFabricIndex, 0, pair));
+    EXPECT_EQ(CHIP_ERROR_NOT_FOUND, provider->GetGroupKeyAt(kFabric2, 999, pair));
 
-    NL_TEST_ASSERT(apSuite, CHIP_NO_ERROR == provider->GetGroupKeyAt(kFabric1, 3, pair));
-    NL_TEST_ASSERT(apSuite, pair == kGroup1Keyset3);
-    NL_TEST_ASSERT(apSuite, CHIP_NO_ERROR == provider->GetGroupKeyAt(kFabric1, 2, pair));
-    NL_TEST_ASSERT(apSuite, pair == kGroup1Keyset2);
-    NL_TEST_ASSERT(apSuite, CHIP_NO_ERROR == provider->GetGroupKeyAt(kFabric1, 1, pair));
-    NL_TEST_ASSERT(apSuite, pair == kGroup1Keyset1);
-    NL_TEST_ASSERT(apSuite, CHIP_NO_ERROR == provider->GetGroupKeyAt(kFabric1, 0, pair));
-    NL_TEST_ASSERT(apSuite, pair == kGroup1Keyset0);
+    EXPECT_EQ(provider->GetGroupKeyAt(kFabric1, 3, pair), CHIP_NO_ERROR);
+    EXPECT_EQ(pair, kGroup1Keyset3);
+    EXPECT_EQ(provider->GetGroupKeyAt(kFabric1, 2, pair), CHIP_NO_ERROR);
+    EXPECT_EQ(pair, kGroup1Keyset2);
+    EXPECT_EQ(provider->GetGroupKeyAt(kFabric1, 1, pair), CHIP_NO_ERROR);
+    EXPECT_EQ(pair, kGroup1Keyset1);
+    EXPECT_EQ(provider->GetGroupKeyAt(kFabric1, 0, pair), CHIP_NO_ERROR);
+    EXPECT_EQ(pair, kGroup1Keyset0);
 
-    NL_TEST_ASSERT(apSuite, CHIP_NO_ERROR == provider->GetGroupKeyAt(kFabric2, 3, pair));
-    NL_TEST_ASSERT(apSuite, pair == kGroup2Keyset3);
-    NL_TEST_ASSERT(apSuite, CHIP_NO_ERROR == provider->GetGroupKeyAt(kFabric2, 2, pair));
-    NL_TEST_ASSERT(apSuite, pair == kGroup2Keyset2);
-    NL_TEST_ASSERT(apSuite, CHIP_NO_ERROR == provider->GetGroupKeyAt(kFabric2, 1, pair));
-    NL_TEST_ASSERT(apSuite, pair == kGroup2Keyset1);
-    NL_TEST_ASSERT(apSuite, CHIP_NO_ERROR == provider->GetGroupKeyAt(kFabric2, 0, pair));
-    NL_TEST_ASSERT(apSuite, pair == kGroup2Keyset0);
+    EXPECT_EQ(provider->GetGroupKeyAt(kFabric2, 3, pair), CHIP_NO_ERROR);
+    EXPECT_EQ(pair, kGroup2Keyset3);
+    EXPECT_EQ(provider->GetGroupKeyAt(kFabric2, 2, pair), CHIP_NO_ERROR);
+    EXPECT_EQ(pair, kGroup2Keyset2);
+    EXPECT_EQ(provider->GetGroupKeyAt(kFabric2, 1, pair), CHIP_NO_ERROR);
+    EXPECT_EQ(pair, kGroup2Keyset1);
+    EXPECT_EQ(provider->GetGroupKeyAt(kFabric2, 0, pair), CHIP_NO_ERROR);
+    EXPECT_EQ(pair, kGroup2Keyset0);
 
     // Remove Groups (remaining entries shift up)
 
-    NL_TEST_ASSERT(apSuite, CHIP_NO_ERROR == provider->RemoveGroupKeyAt(kFabric1, 2));
-    NL_TEST_ASSERT(apSuite, CHIP_NO_ERROR == provider->RemoveGroupKeyAt(kFabric2, 0));
+    EXPECT_EQ(provider->RemoveGroupKeyAt(kFabric1, 2), CHIP_NO_ERROR);
+    EXPECT_EQ(provider->RemoveGroupKeyAt(kFabric2, 0), CHIP_NO_ERROR);
 
-    NL_TEST_ASSERT(apSuite, CHIP_ERROR_NOT_FOUND == provider->GetGroupKeyAt(kFabric1, 3, pair));
-    NL_TEST_ASSERT(apSuite, CHIP_NO_ERROR == provider->GetGroupKeyAt(kFabric1, 2, pair));
-    NL_TEST_ASSERT(apSuite, pair == kGroup1Keyset3);
-    NL_TEST_ASSERT(apSuite, CHIP_NO_ERROR == provider->GetGroupKeyAt(kFabric1, 1, pair));
-    NL_TEST_ASSERT(apSuite, pair == kGroup1Keyset1);
-    NL_TEST_ASSERT(apSuite, CHIP_NO_ERROR == provider->GetGroupKeyAt(kFabric1, 0, pair));
-    NL_TEST_ASSERT(apSuite, pair == kGroup1Keyset0);
+    EXPECT_EQ(CHIP_ERROR_NOT_FOUND, provider->GetGroupKeyAt(kFabric1, 3, pair));
+    EXPECT_EQ(provider->GetGroupKeyAt(kFabric1, 2, pair), CHIP_NO_ERROR);
+    EXPECT_EQ(pair, kGroup1Keyset3);
+    EXPECT_EQ(provider->GetGroupKeyAt(kFabric1, 1, pair), CHIP_NO_ERROR);
+    EXPECT_EQ(pair, kGroup1Keyset1);
+    EXPECT_EQ(provider->GetGroupKeyAt(kFabric1, 0, pair), CHIP_NO_ERROR);
+    EXPECT_EQ(pair, kGroup1Keyset0);
 
-    NL_TEST_ASSERT(apSuite, CHIP_ERROR_NOT_FOUND == provider->GetGroupKeyAt(kFabric2, 3, pair));
-    NL_TEST_ASSERT(apSuite, CHIP_NO_ERROR == provider->GetGroupKeyAt(kFabric2, 2, pair));
-    NL_TEST_ASSERT(apSuite, pair == kGroup2Keyset3);
-    NL_TEST_ASSERT(apSuite, CHIP_NO_ERROR == provider->GetGroupKeyAt(kFabric2, 1, pair));
-    NL_TEST_ASSERT(apSuite, pair == kGroup2Keyset2);
-    NL_TEST_ASSERT(apSuite, CHIP_NO_ERROR == provider->GetGroupKeyAt(kFabric2, 0, pair));
-    NL_TEST_ASSERT(apSuite, pair == kGroup2Keyset1);
+    EXPECT_EQ(CHIP_ERROR_NOT_FOUND, provider->GetGroupKeyAt(kFabric2, 3, pair));
+    EXPECT_EQ(provider->GetGroupKeyAt(kFabric2, 2, pair), CHIP_NO_ERROR);
+    EXPECT_EQ(pair, kGroup2Keyset3);
+    EXPECT_EQ(provider->GetGroupKeyAt(kFabric2, 1, pair), CHIP_NO_ERROR);
+    EXPECT_EQ(pair, kGroup2Keyset2);
+    EXPECT_EQ(provider->GetGroupKeyAt(kFabric2, 0, pair), CHIP_NO_ERROR);
+    EXPECT_EQ(pair, kGroup2Keyset1);
 
     // Overwrite, (group_id, keyset_id) must be unique
 
-    NL_TEST_ASSERT(apSuite, CHIP_ERROR_DUPLICATE_KEY_ID == provider->SetGroupKeyAt(kFabric1, 2, kGroup1Keyset0));
-    NL_TEST_ASSERT(apSuite, CHIP_NO_ERROR == provider->SetGroupKeyAt(kFabric1, 2, kGroup3Keyset0));
-    NL_TEST_ASSERT(apSuite, CHIP_ERROR_DUPLICATE_KEY_ID == provider->SetGroupKeyAt(kFabric2, 0, kGroup2Keyset2));
-    NL_TEST_ASSERT(apSuite, CHIP_NO_ERROR == provider->SetGroupKeyAt(kFabric2, 0, kGroup3Keyset1));
+    EXPECT_EQ(CHIP_ERROR_DUPLICATE_KEY_ID, provider->SetGroupKeyAt(kFabric1, 2, kGroup1Keyset0));
+    EXPECT_EQ(provider->SetGroupKeyAt(kFabric1, 2, kGroup3Keyset0), CHIP_NO_ERROR);
+    EXPECT_EQ(CHIP_ERROR_DUPLICATE_KEY_ID, provider->SetGroupKeyAt(kFabric2, 0, kGroup2Keyset2));
+    EXPECT_EQ(provider->SetGroupKeyAt(kFabric2, 0, kGroup3Keyset1), CHIP_NO_ERROR);
 
-    NL_TEST_ASSERT(apSuite, CHIP_NO_ERROR == provider->GetGroupKeyAt(kFabric1, 2, pair));
-    NL_TEST_ASSERT(apSuite, pair == kGroup3Keyset0);
+    EXPECT_EQ(provider->GetGroupKeyAt(kFabric1, 2, pair), CHIP_NO_ERROR);
+    EXPECT_EQ(pair, kGroup3Keyset0);
 
-    NL_TEST_ASSERT(apSuite, CHIP_NO_ERROR == provider->GetGroupKeyAt(kFabric2, 0, pair));
-    NL_TEST_ASSERT(apSuite, pair == kGroup3Keyset1);
+    EXPECT_EQ(provider->GetGroupKeyAt(kFabric2, 0, pair), CHIP_NO_ERROR);
+    EXPECT_EQ(pair, kGroup3Keyset1);
 
     // Remove all
 
-    NL_TEST_ASSERT(apSuite, CHIP_NO_ERROR == provider->RemoveGroupKeys(kFabric1));
+    EXPECT_EQ(provider->RemoveGroupKeys(kFabric1), CHIP_NO_ERROR);
 
-    NL_TEST_ASSERT(apSuite, CHIP_ERROR_NOT_FOUND == provider->GetGroupKeyAt(kFabric1, 3, pair));
-    NL_TEST_ASSERT(apSuite, CHIP_ERROR_NOT_FOUND == provider->GetGroupKeyAt(kFabric1, 2, pair));
-    NL_TEST_ASSERT(apSuite, CHIP_ERROR_NOT_FOUND == provider->GetGroupKeyAt(kFabric1, 1, pair));
-    NL_TEST_ASSERT(apSuite, CHIP_ERROR_NOT_FOUND == provider->GetGroupKeyAt(kFabric1, 0, pair));
+    EXPECT_EQ(CHIP_ERROR_NOT_FOUND, provider->GetGroupKeyAt(kFabric1, 3, pair));
+    EXPECT_EQ(CHIP_ERROR_NOT_FOUND, provider->GetGroupKeyAt(kFabric1, 2, pair));
+    EXPECT_EQ(CHIP_ERROR_NOT_FOUND, provider->GetGroupKeyAt(kFabric1, 1, pair));
+    EXPECT_EQ(CHIP_ERROR_NOT_FOUND, provider->GetGroupKeyAt(kFabric1, 0, pair));
 
-    NL_TEST_ASSERT(apSuite, CHIP_ERROR_NOT_FOUND == provider->GetGroupKeyAt(kFabric2, 3, pair));
-    NL_TEST_ASSERT(apSuite, CHIP_NO_ERROR == provider->GetGroupKeyAt(kFabric2, 2, pair));
-    NL_TEST_ASSERT(apSuite, pair == kGroup2Keyset3);
-    NL_TEST_ASSERT(apSuite, CHIP_NO_ERROR == provider->GetGroupKeyAt(kFabric2, 1, pair));
-    NL_TEST_ASSERT(apSuite, pair == kGroup2Keyset2);
-    NL_TEST_ASSERT(apSuite, CHIP_NO_ERROR == provider->GetGroupKeyAt(kFabric2, 0, pair));
-    NL_TEST_ASSERT(apSuite, pair == kGroup3Keyset1);
+    EXPECT_EQ(CHIP_ERROR_NOT_FOUND, provider->GetGroupKeyAt(kFabric2, 3, pair));
+    EXPECT_EQ(provider->GetGroupKeyAt(kFabric2, 2, pair), CHIP_NO_ERROR);
+    EXPECT_EQ(pair, kGroup2Keyset3);
+    EXPECT_EQ(provider->GetGroupKeyAt(kFabric2, 1, pair), CHIP_NO_ERROR);
+    EXPECT_EQ(pair, kGroup2Keyset2);
+    EXPECT_EQ(provider->GetGroupKeyAt(kFabric2, 0, pair), CHIP_NO_ERROR);
+    EXPECT_EQ(pair, kGroup3Keyset1);
 }
 
-void TestGroupKeyIterator(nlTestSuite * apSuite, void * apContext)
+TEST_F(TestGroupDataProvider, TestGroupKeyIterator)
 {
     GroupDataProvider * provider = GetGroupDataProvider();
-    NL_TEST_ASSERT(apSuite, provider);
+    EXPECT_TRUE(provider);
 
     // Reset test
     ResetProvider(provider);
@@ -679,17 +724,17 @@
 
     // Set Group Info
 
-    NL_TEST_ASSERT(apSuite, CHIP_NO_ERROR == provider->SetGroupKeyAt(kFabric1, 0, kGroup3Keyset0));
-    NL_TEST_ASSERT(apSuite, CHIP_NO_ERROR == provider->SetGroupKeyAt(kFabric1, 1, kGroup3Keyset1));
-    NL_TEST_ASSERT(apSuite, CHIP_NO_ERROR == provider->SetGroupKeyAt(kFabric1, 2, kGroup3Keyset2));
-    NL_TEST_ASSERT(apSuite, CHIP_NO_ERROR == provider->SetGroupKeyAt(kFabric1, 3, kGroup3Keyset3));
-    NL_TEST_ASSERT(apSuite, CHIP_NO_ERROR == provider->SetGroupKeyAt(kFabric1, 4, kGroup1Keyset0));
-    NL_TEST_ASSERT(apSuite, CHIP_NO_ERROR != provider->SetGroupKeyAt(kFabric1, 5, kGroup1Keyset1));
+    EXPECT_EQ(provider->SetGroupKeyAt(kFabric1, 0, kGroup3Keyset0), CHIP_NO_ERROR);
+    EXPECT_EQ(provider->SetGroupKeyAt(kFabric1, 1, kGroup3Keyset1), CHIP_NO_ERROR);
+    EXPECT_EQ(provider->SetGroupKeyAt(kFabric1, 2, kGroup3Keyset2), CHIP_NO_ERROR);
+    EXPECT_EQ(provider->SetGroupKeyAt(kFabric1, 3, kGroup3Keyset3), CHIP_NO_ERROR);
+    EXPECT_EQ(provider->SetGroupKeyAt(kFabric1, 4, kGroup1Keyset0), CHIP_NO_ERROR);
+    EXPECT_NE(CHIP_NO_ERROR, provider->SetGroupKeyAt(kFabric1, 5, kGroup1Keyset1));
 
-    NL_TEST_ASSERT(apSuite, CHIP_NO_ERROR == provider->SetGroupKeyAt(kFabric2, 0, kGroup2Keyset0));
-    NL_TEST_ASSERT(apSuite, CHIP_NO_ERROR == provider->SetGroupKeyAt(kFabric2, 1, kGroup2Keyset1));
-    NL_TEST_ASSERT(apSuite, CHIP_NO_ERROR == provider->SetGroupKeyAt(kFabric2, 2, kGroup2Keyset2));
-    NL_TEST_ASSERT(apSuite, CHIP_NO_ERROR == provider->SetGroupKeyAt(kFabric2, 3, kGroup2Keyset3));
+    EXPECT_EQ(provider->SetGroupKeyAt(kFabric2, 0, kGroup2Keyset0), CHIP_NO_ERROR);
+    EXPECT_EQ(provider->SetGroupKeyAt(kFabric2, 1, kGroup2Keyset1), CHIP_NO_ERROR);
+    EXPECT_EQ(provider->SetGroupKeyAt(kFabric2, 2, kGroup2Keyset2), CHIP_NO_ERROR);
+    EXPECT_EQ(provider->SetGroupKeyAt(kFabric2, 3, kGroup2Keyset3), CHIP_NO_ERROR);
 
     // Iterate fabric 1
 
@@ -698,17 +743,14 @@
 
     auto it      = provider->IterateGroupKeys(kFabric1);
     size_t count = 0;
-    NL_TEST_ASSERT(apSuite, it);
-    if (it)
+    ASSERT_TRUE(it);
+    EXPECT_EQ(expected_f1_count, it->Count());
+    while (it->Next(pair) && count < expected_f1_count)
     {
-        NL_TEST_ASSERT(apSuite, expected_f1_count == it->Count());
-        while (it->Next(pair) && count < expected_f1_count)
-        {
-            NL_TEST_ASSERT(apSuite, expected_f1[count++] == pair);
-        }
-        NL_TEST_ASSERT(apSuite, count == it->Count());
-        it->Release();
+        EXPECT_EQ(expected_f1[count++], pair);
     }
+    EXPECT_EQ(count, it->Count());
+    it->Release();
 
     // Iterate fabric 2
 
@@ -716,24 +758,21 @@
     size_t expected_f2_count = sizeof(expected_f2) / sizeof(GroupKey);
 
     it = provider->IterateGroupKeys(kFabric2);
-    NL_TEST_ASSERT(apSuite, it);
-    if (it)
+    ASSERT_TRUE(it);
+    count = 0;
+    EXPECT_EQ(expected_f2_count, it->Count());
+    while (it->Next(pair) && count < expected_f2_count)
     {
-        count = 0;
-        NL_TEST_ASSERT(apSuite, expected_f2_count == it->Count());
-        while (it->Next(pair) && count < expected_f2_count)
-        {
-            NL_TEST_ASSERT(apSuite, expected_f2[count++] == pair);
-        }
-        NL_TEST_ASSERT(apSuite, count == it->Count());
-        it->Release();
+        EXPECT_EQ(expected_f2[count++], pair);
     }
+    EXPECT_EQ(count, it->Count());
+    it->Release();
 }
 
-void TestKeySets(nlTestSuite * apSuite, void * apContext)
+TEST_F(TestGroupDataProvider, TestKeySets)
 {
     GroupDataProvider * provider = GetGroupDataProvider();
-    NL_TEST_ASSERT(apSuite, provider);
+    EXPECT_TRUE(provider);
 
     // Reset test
     ResetProvider(provider);
@@ -742,104 +781,104 @@
 
     // Add KeySets
 
-    NL_TEST_ASSERT(apSuite, CHIP_NO_ERROR == provider->SetKeySet(kFabric1, kCompressedFabricId1, kKeySet1));
-    NL_TEST_ASSERT(apSuite, CHIP_NO_ERROR == provider->SetKeySet(kFabric1, kCompressedFabricId1, kKeySet0));
-    NL_TEST_ASSERT(apSuite, CHIP_NO_ERROR == provider->SetKeySet(kFabric1, kCompressedFabricId1, kKeySet2));
-    NL_TEST_ASSERT(apSuite, CHIP_NO_ERROR == provider->SetKeySet(kFabric1, kCompressedFabricId1, kKeySet3));
-    NL_TEST_ASSERT(apSuite, CHIP_NO_ERROR != provider->SetKeySet(kFabric1, kCompressedFabricId1, kKeySet4));
-    NL_TEST_ASSERT(apSuite, CHIP_NO_ERROR == provider->SetKeySet(kFabric2, kCompressedFabricId2, kKeySet3));
-    NL_TEST_ASSERT(apSuite, CHIP_NO_ERROR == provider->SetKeySet(kFabric2, kCompressedFabricId2, kKeySet0));
-    NL_TEST_ASSERT(apSuite, CHIP_NO_ERROR == provider->SetKeySet(kFabric2, kCompressedFabricId2, kKeySet2));
-    NL_TEST_ASSERT(apSuite, CHIP_NO_ERROR == provider->SetKeySet(kFabric2, kCompressedFabricId2, kKeySet1));
+    EXPECT_EQ(provider->SetKeySet(kFabric1, kCompressedFabricId1, kKeySet1), CHIP_NO_ERROR);
+    EXPECT_EQ(provider->SetKeySet(kFabric1, kCompressedFabricId1, kKeySet0), CHIP_NO_ERROR);
+    EXPECT_EQ(provider->SetKeySet(kFabric1, kCompressedFabricId1, kKeySet2), CHIP_NO_ERROR);
+    EXPECT_EQ(provider->SetKeySet(kFabric1, kCompressedFabricId1, kKeySet3), CHIP_NO_ERROR);
+    EXPECT_NE(CHIP_NO_ERROR, provider->SetKeySet(kFabric1, kCompressedFabricId1, kKeySet4));
+    EXPECT_EQ(provider->SetKeySet(kFabric2, kCompressedFabricId2, kKeySet3), CHIP_NO_ERROR);
+    EXPECT_EQ(provider->SetKeySet(kFabric2, kCompressedFabricId2, kKeySet0), CHIP_NO_ERROR);
+    EXPECT_EQ(provider->SetKeySet(kFabric2, kCompressedFabricId2, kKeySet2), CHIP_NO_ERROR);
+    EXPECT_EQ(provider->SetKeySet(kFabric2, kCompressedFabricId2, kKeySet1), CHIP_NO_ERROR);
 
     // Get KeySets
 
-    NL_TEST_ASSERT(apSuite, CHIP_NO_ERROR == provider->GetKeySet(kFabric1, kKeysetId3, keyset));
-    NL_TEST_ASSERT(apSuite, CompareKeySets(keyset, kKeySet3));
+    EXPECT_EQ(provider->GetKeySet(kFabric1, kKeysetId3, keyset), CHIP_NO_ERROR);
+    EXPECT_TRUE(CompareKeySets(keyset, kKeySet3));
 
-    NL_TEST_ASSERT(apSuite, CHIP_NO_ERROR == provider->GetKeySet(kFabric1, kKeysetId1, keyset));
-    NL_TEST_ASSERT(apSuite, CompareKeySets(keyset, kKeySet1));
+    EXPECT_EQ(provider->GetKeySet(kFabric1, kKeysetId1, keyset), CHIP_NO_ERROR);
+    EXPECT_TRUE(CompareKeySets(keyset, kKeySet1));
 
-    NL_TEST_ASSERT(apSuite, CHIP_NO_ERROR == provider->GetKeySet(kFabric1, kKeysetId0, keyset));
-    NL_TEST_ASSERT(apSuite, CompareKeySets(keyset, kKeySet0));
+    EXPECT_EQ(provider->GetKeySet(kFabric1, kKeysetId0, keyset), CHIP_NO_ERROR);
+    EXPECT_TRUE(CompareKeySets(keyset, kKeySet0));
 
-    NL_TEST_ASSERT(apSuite, CHIP_NO_ERROR == provider->GetKeySet(kFabric1, kKeysetId2, keyset));
-    NL_TEST_ASSERT(apSuite, CompareKeySets(keyset, kKeySet2));
+    EXPECT_EQ(provider->GetKeySet(kFabric1, kKeysetId2, keyset), CHIP_NO_ERROR);
+    EXPECT_TRUE(CompareKeySets(keyset, kKeySet2));
 
-    NL_TEST_ASSERT(apSuite, CHIP_NO_ERROR == provider->GetKeySet(kFabric2, kKeysetId3, keyset));
-    NL_TEST_ASSERT(apSuite, CompareKeySets(keyset, kKeySet3));
+    EXPECT_EQ(provider->GetKeySet(kFabric2, kKeysetId3, keyset), CHIP_NO_ERROR);
+    EXPECT_TRUE(CompareKeySets(keyset, kKeySet3));
 
-    NL_TEST_ASSERT(apSuite, CHIP_NO_ERROR == provider->GetKeySet(kFabric2, kKeysetId2, keyset));
-    NL_TEST_ASSERT(apSuite, CompareKeySets(keyset, kKeySet2));
+    EXPECT_EQ(provider->GetKeySet(kFabric2, kKeysetId2, keyset), CHIP_NO_ERROR);
+    EXPECT_TRUE(CompareKeySets(keyset, kKeySet2));
 
-    NL_TEST_ASSERT(apSuite, CHIP_NO_ERROR == provider->GetKeySet(kFabric2, kKeysetId1, keyset));
-    NL_TEST_ASSERT(apSuite, CompareKeySets(keyset, kKeySet1));
+    EXPECT_EQ(provider->GetKeySet(kFabric2, kKeysetId1, keyset), CHIP_NO_ERROR);
+    EXPECT_TRUE(CompareKeySets(keyset, kKeySet1));
 
-    NL_TEST_ASSERT(apSuite, CHIP_NO_ERROR == provider->GetKeySet(kFabric2, kKeysetId0, keyset));
-    NL_TEST_ASSERT(apSuite, CompareKeySets(keyset, kKeySet0));
+    EXPECT_EQ(provider->GetKeySet(kFabric2, kKeysetId0, keyset), CHIP_NO_ERROR);
+    EXPECT_TRUE(CompareKeySets(keyset, kKeySet0));
 
     // Remove Keysets
 
-    NL_TEST_ASSERT(apSuite, CHIP_ERROR_NOT_FOUND == provider->RemoveKeySet(kFabric1, 0xffff));
+    EXPECT_EQ(CHIP_ERROR_NOT_FOUND, provider->RemoveKeySet(kFabric1, 0xffff));
 
-    NL_TEST_ASSERT(apSuite, CHIP_NO_ERROR == provider->RemoveKeySet(kFabric1, kKeysetId1)); // First
-    NL_TEST_ASSERT(apSuite, CHIP_NO_ERROR == provider->RemoveKeySet(kFabric1, kKeysetId3)); // Last
-    NL_TEST_ASSERT(apSuite, CHIP_NO_ERROR == provider->RemoveKeySet(kFabric2, kKeysetId2)); // Middle
+    EXPECT_EQ(provider->RemoveKeySet(kFabric1, kKeysetId1), CHIP_NO_ERROR); // First
+    EXPECT_EQ(provider->RemoveKeySet(kFabric1, kKeysetId3), CHIP_NO_ERROR); // Last
+    EXPECT_EQ(provider->RemoveKeySet(kFabric2, kKeysetId2), CHIP_NO_ERROR); // Middle
 
-    NL_TEST_ASSERT(apSuite, CHIP_ERROR_NOT_FOUND == provider->GetKeySet(kFabric1, kKeysetId3, keyset));
-    NL_TEST_ASSERT(apSuite, CHIP_ERROR_NOT_FOUND == provider->GetKeySet(kFabric1, kKeysetId1, keyset));
-    NL_TEST_ASSERT(apSuite, CHIP_NO_ERROR == provider->GetKeySet(kFabric1, kKeysetId0, keyset));
-    NL_TEST_ASSERT(apSuite, CompareKeySets(keyset, kKeySet0));
+    EXPECT_EQ(CHIP_ERROR_NOT_FOUND, provider->GetKeySet(kFabric1, kKeysetId3, keyset));
+    EXPECT_EQ(CHIP_ERROR_NOT_FOUND, provider->GetKeySet(kFabric1, kKeysetId1, keyset));
+    EXPECT_EQ(provider->GetKeySet(kFabric1, kKeysetId0, keyset), CHIP_NO_ERROR);
+    EXPECT_TRUE(CompareKeySets(keyset, kKeySet0));
 
-    NL_TEST_ASSERT(apSuite, CHIP_NO_ERROR == provider->GetKeySet(kFabric1, kKeysetId2, keyset));
-    NL_TEST_ASSERT(apSuite, CompareKeySets(keyset, kKeySet2));
+    EXPECT_EQ(provider->GetKeySet(kFabric1, kKeysetId2, keyset), CHIP_NO_ERROR);
+    EXPECT_TRUE(CompareKeySets(keyset, kKeySet2));
 
-    NL_TEST_ASSERT(apSuite, CHIP_NO_ERROR == provider->GetKeySet(kFabric2, kKeysetId3, keyset));
-    NL_TEST_ASSERT(apSuite, CompareKeySets(keyset, kKeySet3));
+    EXPECT_EQ(provider->GetKeySet(kFabric2, kKeysetId3, keyset), CHIP_NO_ERROR);
+    EXPECT_TRUE(CompareKeySets(keyset, kKeySet3));
 
-    NL_TEST_ASSERT(apSuite, CHIP_ERROR_NOT_FOUND == provider->GetKeySet(kFabric2, kKeysetId2, keyset));
-    NL_TEST_ASSERT(apSuite, CHIP_NO_ERROR == provider->GetKeySet(kFabric2, kKeysetId1, keyset));
-    NL_TEST_ASSERT(apSuite, CompareKeySets(keyset, kKeySet1));
+    EXPECT_EQ(CHIP_ERROR_NOT_FOUND, provider->GetKeySet(kFabric2, kKeysetId2, keyset));
+    EXPECT_EQ(provider->GetKeySet(kFabric2, kKeysetId1, keyset), CHIP_NO_ERROR);
+    EXPECT_TRUE(CompareKeySets(keyset, kKeySet1));
 
-    NL_TEST_ASSERT(apSuite, CHIP_NO_ERROR == provider->GetKeySet(kFabric2, kKeysetId0, keyset));
-    NL_TEST_ASSERT(apSuite, CompareKeySets(keyset, kKeySet0));
+    EXPECT_EQ(provider->GetKeySet(kFabric2, kKeysetId0, keyset), CHIP_NO_ERROR);
+    EXPECT_TRUE(CompareKeySets(keyset, kKeySet0));
 
     // Remove all
 
-    NL_TEST_ASSERT(apSuite, CHIP_ERROR_NOT_FOUND == provider->RemoveKeySet(kFabric1, kKeysetId3));
-    NL_TEST_ASSERT(apSuite, CHIP_ERROR_NOT_FOUND == provider->RemoveKeySet(kFabric1, kKeysetId1));
-    NL_TEST_ASSERT(apSuite, CHIP_NO_ERROR == provider->RemoveKeySet(kFabric1, kKeysetId0));
-    NL_TEST_ASSERT(apSuite, CHIP_NO_ERROR == provider->RemoveKeySet(kFabric1, kKeysetId2));
-    NL_TEST_ASSERT(apSuite, CHIP_NO_ERROR == provider->RemoveKeySet(kFabric2, kKeysetId3));
-    NL_TEST_ASSERT(apSuite, CHIP_ERROR_NOT_FOUND == provider->RemoveKeySet(kFabric2, kKeysetId2));
-    NL_TEST_ASSERT(apSuite, CHIP_NO_ERROR == provider->RemoveKeySet(kFabric2, kKeysetId1));
-    NL_TEST_ASSERT(apSuite, CHIP_NO_ERROR == provider->RemoveKeySet(kFabric2, kKeysetId0));
+    EXPECT_EQ(CHIP_ERROR_NOT_FOUND, provider->RemoveKeySet(kFabric1, kKeysetId3));
+    EXPECT_EQ(CHIP_ERROR_NOT_FOUND, provider->RemoveKeySet(kFabric1, kKeysetId1));
+    EXPECT_EQ(provider->RemoveKeySet(kFabric1, kKeysetId0), CHIP_NO_ERROR);
+    EXPECT_EQ(provider->RemoveKeySet(kFabric1, kKeysetId2), CHIP_NO_ERROR);
+    EXPECT_EQ(provider->RemoveKeySet(kFabric2, kKeysetId3), CHIP_NO_ERROR);
+    EXPECT_EQ(CHIP_ERROR_NOT_FOUND, provider->RemoveKeySet(kFabric2, kKeysetId2));
+    EXPECT_EQ(provider->RemoveKeySet(kFabric2, kKeysetId1), CHIP_NO_ERROR);
+    EXPECT_EQ(provider->RemoveKeySet(kFabric2, kKeysetId0), CHIP_NO_ERROR);
 
-    NL_TEST_ASSERT(apSuite, CHIP_ERROR_NOT_FOUND == provider->GetKeySet(kFabric1, kKeysetId3, keyset));
-    NL_TEST_ASSERT(apSuite, CHIP_ERROR_NOT_FOUND == provider->GetKeySet(kFabric1, kKeysetId1, keyset));
-    NL_TEST_ASSERT(apSuite, CHIP_ERROR_NOT_FOUND == provider->GetKeySet(kFabric1, kKeysetId0, keyset));
-    NL_TEST_ASSERT(apSuite, CHIP_ERROR_NOT_FOUND == provider->GetKeySet(kFabric1, kKeysetId2, keyset));
-    NL_TEST_ASSERT(apSuite, CHIP_ERROR_NOT_FOUND == provider->GetKeySet(kFabric2, kKeysetId3, keyset));
-    NL_TEST_ASSERT(apSuite, CHIP_ERROR_NOT_FOUND == provider->GetKeySet(kFabric2, kKeysetId2, keyset));
-    NL_TEST_ASSERT(apSuite, CHIP_ERROR_NOT_FOUND == provider->GetKeySet(kFabric2, kKeysetId1, keyset));
-    NL_TEST_ASSERT(apSuite, CHIP_ERROR_NOT_FOUND == provider->GetKeySet(kFabric2, kKeysetId0, keyset));
+    EXPECT_EQ(CHIP_ERROR_NOT_FOUND, provider->GetKeySet(kFabric1, kKeysetId3, keyset));
+    EXPECT_EQ(CHIP_ERROR_NOT_FOUND, provider->GetKeySet(kFabric1, kKeysetId1, keyset));
+    EXPECT_EQ(CHIP_ERROR_NOT_FOUND, provider->GetKeySet(kFabric1, kKeysetId0, keyset));
+    EXPECT_EQ(CHIP_ERROR_NOT_FOUND, provider->GetKeySet(kFabric1, kKeysetId2, keyset));
+    EXPECT_EQ(CHIP_ERROR_NOT_FOUND, provider->GetKeySet(kFabric2, kKeysetId3, keyset));
+    EXPECT_EQ(CHIP_ERROR_NOT_FOUND, provider->GetKeySet(kFabric2, kKeysetId2, keyset));
+    EXPECT_EQ(CHIP_ERROR_NOT_FOUND, provider->GetKeySet(kFabric2, kKeysetId1, keyset));
+    EXPECT_EQ(CHIP_ERROR_NOT_FOUND, provider->GetKeySet(kFabric2, kKeysetId0, keyset));
 }
 
-void TestIpk(nlTestSuite * apSuite, void * apContext)
+TEST_F(TestGroupDataProvider, TestIpk)
 {
     GroupDataProvider * provider = GetGroupDataProvider();
-    NL_TEST_ASSERT(apSuite, provider);
+    EXPECT_TRUE(provider);
 
     // Reset test
     ResetProvider(provider);
 
     // Make sure IPK set is not found on a fresh provider
     KeySet ipkOperationalKeySet;
-    NL_TEST_ASSERT(apSuite, CHIP_ERROR_NOT_FOUND == provider->GetIpkKeySet(kFabric1, ipkOperationalKeySet));
+    EXPECT_EQ(CHIP_ERROR_NOT_FOUND, provider->GetIpkKeySet(kFabric1, ipkOperationalKeySet));
 
     // Add a non-IPK key, make sure the IPK set is not found
-    NL_TEST_ASSERT(apSuite, CHIP_NO_ERROR == provider->SetKeySet(kFabric1, kCompressedFabricId1, kKeySet3));
-    NL_TEST_ASSERT(apSuite, CHIP_ERROR_NOT_FOUND == provider->GetIpkKeySet(kFabric1, ipkOperationalKeySet));
+    EXPECT_EQ(provider->SetKeySet(kFabric1, kCompressedFabricId1, kKeySet3), CHIP_NO_ERROR);
+    EXPECT_EQ(CHIP_ERROR_NOT_FOUND, provider->GetIpkKeySet(kFabric1, ipkOperationalKeySet));
 
     const uint8_t kIpkEpochKeyFromSpec[] = { 0x23, 0x5b, 0xf7, 0xe6, 0x28, 0x23, 0xd3, 0x58,
                                              0xdc, 0xa4, 0xba, 0x50, 0xb1, 0x53, 0x5f, 0x4b };
@@ -849,55 +888,51 @@
     memcpy(&fabric1KeySet0.epoch_keys[0].key, &kIpkEpochKeyFromSpec[0], sizeof(kIpkEpochKeyFromSpec));
 
     // Set a single IPK, validate key derivation follows spec
-    NL_TEST_ASSERT(apSuite, CHIP_NO_ERROR == provider->SetKeySet(kFabric1, kCompressedFabricId1, fabric1KeySet0));
-    NL_TEST_ASSERT(apSuite, CHIP_NO_ERROR == provider->GetIpkKeySet(kFabric1, ipkOperationalKeySet));
+    EXPECT_EQ(provider->SetKeySet(kFabric1, kCompressedFabricId1, fabric1KeySet0), CHIP_NO_ERROR);
+    EXPECT_EQ(provider->GetIpkKeySet(kFabric1, ipkOperationalKeySet), CHIP_NO_ERROR);
 
     // Make sure the derived key matches spec test vector
     const uint8_t kExpectedIpkFromSpec[] = { 0xa6, 0xf5, 0x30, 0x6b, 0xaf, 0x6d, 0x05, 0x0a,
                                              0xf2, 0x3b, 0xa4, 0xbd, 0x6b, 0x9d, 0xd9, 0x60 };
 
-    NL_TEST_ASSERT(apSuite, 0 == ipkOperationalKeySet.keyset_id);
-    NL_TEST_ASSERT(apSuite, 1 == ipkOperationalKeySet.num_keys_used);
-    NL_TEST_ASSERT(apSuite, SecurityPolicy::kTrustFirst == ipkOperationalKeySet.policy);
-    NL_TEST_ASSERT(apSuite, 1234 == ipkOperationalKeySet.epoch_keys[0].start_time);
-    NL_TEST_ASSERT(apSuite,
-                   0 == memcmp(ipkOperationalKeySet.epoch_keys[0].key, kExpectedIpkFromSpec, sizeof(kExpectedIpkFromSpec)));
+    EXPECT_EQ(ipkOperationalKeySet.keyset_id, 0u);
+    EXPECT_EQ(ipkOperationalKeySet.num_keys_used, 1u);
+    EXPECT_EQ(SecurityPolicy::kTrustFirst, ipkOperationalKeySet.policy);
+    EXPECT_EQ(ipkOperationalKeySet.epoch_keys[0].start_time, 1234u);
+    EXPECT_EQ(memcmp(ipkOperationalKeySet.epoch_keys[0].key, kExpectedIpkFromSpec, sizeof(kExpectedIpkFromSpec)), 0);
 
     // Remove IPK, verify removal
-    NL_TEST_ASSERT(apSuite, CHIP_NO_ERROR == provider->RemoveKeySet(kFabric1, kKeysetId0));
-    NL_TEST_ASSERT(apSuite, CHIP_ERROR_NOT_FOUND == provider->GetIpkKeySet(kFabric1, ipkOperationalKeySet));
+    EXPECT_EQ(provider->RemoveKeySet(kFabric1, kKeysetId0), CHIP_NO_ERROR);
+    EXPECT_EQ(CHIP_ERROR_NOT_FOUND, provider->GetIpkKeySet(kFabric1, ipkOperationalKeySet));
 
     // Set a single IPK with the SetSingleIpkEpochKey helper, validate key derivation follows spec
-    NL_TEST_ASSERT(
-        apSuite,
-        CHIP_NO_ERROR ==
-            chip::Credentials::SetSingleIpkEpochKey(provider, kFabric1, ByteSpan(kIpkEpochKeyFromSpec), kCompressedFabricId1));
-    NL_TEST_ASSERT(apSuite, CHIP_NO_ERROR == provider->GetIpkKeySet(kFabric1, ipkOperationalKeySet));
+    EXPECT_EQ(chip::Credentials::SetSingleIpkEpochKey(provider, kFabric1, ByteSpan(kIpkEpochKeyFromSpec), kCompressedFabricId1),
+              CHIP_NO_ERROR);
+    EXPECT_EQ(provider->GetIpkKeySet(kFabric1, ipkOperationalKeySet), CHIP_NO_ERROR);
 
-    NL_TEST_ASSERT(apSuite, 0 == ipkOperationalKeySet.keyset_id);
-    NL_TEST_ASSERT(apSuite, 1 == ipkOperationalKeySet.num_keys_used);
-    NL_TEST_ASSERT(apSuite, SecurityPolicy::kTrustFirst == ipkOperationalKeySet.policy);
-    NL_TEST_ASSERT(apSuite, 0 == ipkOperationalKeySet.epoch_keys[0].start_time); // default time is zero for SetSingleIpkEpochKey
-    NL_TEST_ASSERT(apSuite,
-                   0 == memcmp(ipkOperationalKeySet.epoch_keys[0].key, kExpectedIpkFromSpec, sizeof(kExpectedIpkFromSpec)));
+    EXPECT_EQ(ipkOperationalKeySet.keyset_id, 0u);
+    EXPECT_EQ(ipkOperationalKeySet.num_keys_used, 1u);
+    EXPECT_EQ(SecurityPolicy::kTrustFirst, ipkOperationalKeySet.policy);
+    EXPECT_EQ(ipkOperationalKeySet.epoch_keys[0].start_time, 0u); // default time is zero for SetSingleIpkEpochKey
+    EXPECT_EQ(memcmp(ipkOperationalKeySet.epoch_keys[0].key, kExpectedIpkFromSpec, sizeof(kExpectedIpkFromSpec)), 0);
 }
 
-void TestKeySetIterator(nlTestSuite * apSuite, void * apContext)
+TEST_F(TestGroupDataProvider, TestKeySetIterator)
 {
     GroupDataProvider * provider = GetGroupDataProvider();
-    NL_TEST_ASSERT(apSuite, provider);
+    EXPECT_TRUE(provider);
 
     // Reset test
     ResetProvider(provider);
 
     // Add data to iterate
-    NL_TEST_ASSERT(apSuite, CHIP_NO_ERROR == provider->SetKeySet(kFabric1, kCompressedFabricId1, kKeySet1));
-    NL_TEST_ASSERT(apSuite, CHIP_NO_ERROR == provider->SetKeySet(kFabric1, kCompressedFabricId1, kKeySet0));
-    NL_TEST_ASSERT(apSuite, CHIP_NO_ERROR == provider->SetKeySet(kFabric1, kCompressedFabricId1, kKeySet2));
-    NL_TEST_ASSERT(apSuite, CHIP_NO_ERROR == provider->SetKeySet(kFabric1, kCompressedFabricId1, kKeySet3));
-    NL_TEST_ASSERT(apSuite, CHIP_NO_ERROR == provider->SetKeySet(kFabric2, kCompressedFabricId2, kKeySet3));
-    NL_TEST_ASSERT(apSuite, CHIP_NO_ERROR == provider->SetKeySet(kFabric2, kCompressedFabricId2, kKeySet2));
-    NL_TEST_ASSERT(apSuite, CHIP_NO_ERROR == provider->SetKeySet(kFabric2, kCompressedFabricId2, kKeySet1));
+    EXPECT_EQ(provider->SetKeySet(kFabric1, kCompressedFabricId1, kKeySet1), CHIP_NO_ERROR);
+    EXPECT_EQ(provider->SetKeySet(kFabric1, kCompressedFabricId1, kKeySet0), CHIP_NO_ERROR);
+    EXPECT_EQ(provider->SetKeySet(kFabric1, kCompressedFabricId1, kKeySet2), CHIP_NO_ERROR);
+    EXPECT_EQ(provider->SetKeySet(kFabric1, kCompressedFabricId1, kKeySet3), CHIP_NO_ERROR);
+    EXPECT_EQ(provider->SetKeySet(kFabric2, kCompressedFabricId2, kKeySet3), CHIP_NO_ERROR);
+    EXPECT_EQ(provider->SetKeySet(kFabric2, kCompressedFabricId2, kKeySet2), CHIP_NO_ERROR);
+    EXPECT_EQ(provider->SetKeySet(kFabric2, kCompressedFabricId2, kKeySet1), CHIP_NO_ERROR);
 
     // Iterate Fabric 1
 
@@ -908,48 +943,42 @@
     };
 
     auto it = provider->IterateKeySets(kFabric1);
-    NL_TEST_ASSERT(apSuite, it);
-    if (it)
-    {
-        size_t count = 0;
-        NL_TEST_ASSERT(apSuite, expected_f1.size() == it->Count());
+    ASSERT_TRUE(it);
+    size_t count = 0;
+    EXPECT_EQ(expected_f1.size(), it->Count());
 
-        while (it->Next(keyset) && count < expected_f1.size())
-        {
-            NL_TEST_ASSERT(apSuite, expected_f1.count(keyset.keyset_id) > 0);
-            NL_TEST_ASSERT(apSuite, CompareKeySets(keyset, expected_f1[keyset.keyset_id]));
-            count++;
-        }
-        NL_TEST_ASSERT(apSuite, count == expected_f1.size());
-        it->Release();
+    while (it->Next(keyset) && count < expected_f1.size())
+    {
+        EXPECT_GT(expected_f1.count(keyset.keyset_id), 0u);
+        EXPECT_TRUE(CompareKeySets(keyset, expected_f1[keyset.keyset_id]));
+        count++;
     }
+    EXPECT_EQ(count, expected_f1.size());
+    it->Release();
 
     // Iterate Fabric 2
 
     std::map<uint16_t, const KeySet> expected_f2{ { kKeysetId1, kKeySet1 }, { kKeysetId2, kKeySet2 }, { kKeysetId3, kKeySet3 } };
 
     it = provider->IterateKeySets(kFabric2);
-    NL_TEST_ASSERT(apSuite, it);
-    if (it)
-    {
-        size_t count = 0;
-        NL_TEST_ASSERT(apSuite, expected_f2.size() == it->Count());
+    ASSERT_TRUE(it);
+    count = 0;
+    EXPECT_EQ(expected_f2.size(), it->Count());
 
-        while (it->Next(keyset) && count < expected_f2.size())
-        {
-            NL_TEST_ASSERT(apSuite, expected_f2.count(keyset.keyset_id) > 0);
-            NL_TEST_ASSERT(apSuite, CompareKeySets(keyset, expected_f2[keyset.keyset_id]));
-            count++;
-        }
-        NL_TEST_ASSERT(apSuite, count == expected_f2.size());
-        it->Release();
+    while (it->Next(keyset) && count < expected_f2.size())
+    {
+        EXPECT_GT(expected_f2.count(keyset.keyset_id), 0u);
+        EXPECT_TRUE(CompareKeySets(keyset, expected_f2[keyset.keyset_id]));
+        count++;
     }
+    EXPECT_EQ(count, expected_f2.size());
+    it->Release();
 }
 
-void TestPerFabricData(nlTestSuite * apSuite, void * apContext)
+TEST_F(TestGroupDataProvider, TestPerFabricData)
 {
     GroupDataProvider * provider = GetGroupDataProvider();
-    NL_TEST_ASSERT(apSuite, provider);
+    EXPECT_TRUE(provider);
 
     // Reset test
     ResetProvider(provider);
@@ -957,163 +986,163 @@
     // Group Info
     GroupInfo group;
 
-    NL_TEST_ASSERT(apSuite, CHIP_NO_ERROR == provider->SetGroupInfoAt(kFabric1, 0, kGroupInfo1_3));
-    NL_TEST_ASSERT(apSuite, CHIP_NO_ERROR == provider->SetGroupInfoAt(kFabric1, 1, kGroupInfo1_2));
-    NL_TEST_ASSERT(apSuite, CHIP_NO_ERROR == provider->SetGroupInfoAt(kFabric1, 2, kGroupInfo1_1));
-    NL_TEST_ASSERT(apSuite, CHIP_NO_ERROR == provider->SetGroupInfoAt(kFabric2, 0, kGroupInfo2_1));
-    NL_TEST_ASSERT(apSuite, CHIP_NO_ERROR == provider->SetGroupInfoAt(kFabric2, 1, kGroupInfo2_3));
-    NL_TEST_ASSERT(apSuite, CHIP_NO_ERROR == provider->SetGroupInfoAt(kFabric2, 2, kGroupInfo2_2));
+    EXPECT_EQ(provider->SetGroupInfoAt(kFabric1, 0, kGroupInfo1_3), CHIP_NO_ERROR);
+    EXPECT_EQ(provider->SetGroupInfoAt(kFabric1, 1, kGroupInfo1_2), CHIP_NO_ERROR);
+    EXPECT_EQ(provider->SetGroupInfoAt(kFabric1, 2, kGroupInfo1_1), CHIP_NO_ERROR);
+    EXPECT_EQ(provider->SetGroupInfoAt(kFabric2, 0, kGroupInfo2_1), CHIP_NO_ERROR);
+    EXPECT_EQ(provider->SetGroupInfoAt(kFabric2, 1, kGroupInfo2_3), CHIP_NO_ERROR);
+    EXPECT_EQ(provider->SetGroupInfoAt(kFabric2, 2, kGroupInfo2_2), CHIP_NO_ERROR);
 
-    NL_TEST_ASSERT(apSuite, CHIP_NO_ERROR == provider->GetGroupInfoAt(kFabric1, 0, group));
-    NL_TEST_ASSERT(apSuite, group == kGroupInfo1_3);
-    NL_TEST_ASSERT(apSuite, CHIP_NO_ERROR == provider->GetGroupInfoAt(kFabric1, 1, group));
-    NL_TEST_ASSERT(apSuite, group == kGroupInfo1_2);
-    NL_TEST_ASSERT(apSuite, CHIP_NO_ERROR == provider->GetGroupInfoAt(kFabric1, 2, group));
-    NL_TEST_ASSERT(apSuite, group == kGroupInfo1_1);
-    NL_TEST_ASSERT(apSuite, CHIP_NO_ERROR == provider->GetGroupInfoAt(kFabric2, 0, group));
-    NL_TEST_ASSERT(apSuite, group == kGroupInfo2_1);
-    NL_TEST_ASSERT(apSuite, CHIP_NO_ERROR == provider->GetGroupInfoAt(kFabric2, 1, group));
-    NL_TEST_ASSERT(apSuite, group == kGroupInfo2_3);
-    NL_TEST_ASSERT(apSuite, CHIP_NO_ERROR == provider->GetGroupInfoAt(kFabric2, 2, group));
-    NL_TEST_ASSERT(apSuite, group == kGroupInfo2_2);
+    EXPECT_EQ(provider->GetGroupInfoAt(kFabric1, 0, group), CHIP_NO_ERROR);
+    EXPECT_EQ(group, kGroupInfo1_3);
+    EXPECT_EQ(provider->GetGroupInfoAt(kFabric1, 1, group), CHIP_NO_ERROR);
+    EXPECT_EQ(group, kGroupInfo1_2);
+    EXPECT_EQ(provider->GetGroupInfoAt(kFabric1, 2, group), CHIP_NO_ERROR);
+    EXPECT_EQ(group, kGroupInfo1_1);
+    EXPECT_EQ(provider->GetGroupInfoAt(kFabric2, 0, group), CHIP_NO_ERROR);
+    EXPECT_EQ(group, kGroupInfo2_1);
+    EXPECT_EQ(provider->GetGroupInfoAt(kFabric2, 1, group), CHIP_NO_ERROR);
+    EXPECT_EQ(group, kGroupInfo2_3);
+    EXPECT_EQ(provider->GetGroupInfoAt(kFabric2, 2, group), CHIP_NO_ERROR);
+    EXPECT_EQ(group, kGroupInfo2_2);
 
     // Endpoints
 
-    NL_TEST_ASSERT(apSuite, CHIP_NO_ERROR == provider->AddEndpoint(kFabric1, kGroup1, kEndpointId0));
-    NL_TEST_ASSERT(apSuite, CHIP_NO_ERROR == provider->AddEndpoint(kFabric1, kGroup1, kEndpointId1));
-    NL_TEST_ASSERT(apSuite, CHIP_NO_ERROR == provider->AddEndpoint(kFabric1, kGroup1, kEndpointId2));
-    NL_TEST_ASSERT(apSuite, CHIP_NO_ERROR == provider->AddEndpoint(kFabric1, kGroup2, kEndpointId1));
-    NL_TEST_ASSERT(apSuite, CHIP_NO_ERROR == provider->AddEndpoint(kFabric1, kGroup2, kEndpointId2));
-    NL_TEST_ASSERT(apSuite, CHIP_NO_ERROR == provider->AddEndpoint(kFabric1, kGroup2, kEndpointId3));
-    NL_TEST_ASSERT(apSuite, CHIP_NO_ERROR == provider->AddEndpoint(kFabric2, kGroup3, kEndpointId0));
-    NL_TEST_ASSERT(apSuite, CHIP_NO_ERROR == provider->AddEndpoint(kFabric2, kGroup3, kEndpointId1));
-    NL_TEST_ASSERT(apSuite, CHIP_NO_ERROR == provider->AddEndpoint(kFabric2, kGroup3, kEndpointId2));
-    NL_TEST_ASSERT(apSuite, CHIP_NO_ERROR == provider->AddEndpoint(kFabric2, kGroup3, kEndpointId3));
-    NL_TEST_ASSERT(apSuite, CHIP_NO_ERROR == provider->AddEndpoint(kFabric2, kGroup3, kEndpointId4));
+    EXPECT_EQ(provider->AddEndpoint(kFabric1, kGroup1, kEndpointId0), CHIP_NO_ERROR);
+    EXPECT_EQ(provider->AddEndpoint(kFabric1, kGroup1, kEndpointId1), CHIP_NO_ERROR);
+    EXPECT_EQ(provider->AddEndpoint(kFabric1, kGroup1, kEndpointId2), CHIP_NO_ERROR);
+    EXPECT_EQ(provider->AddEndpoint(kFabric1, kGroup2, kEndpointId1), CHIP_NO_ERROR);
+    EXPECT_EQ(provider->AddEndpoint(kFabric1, kGroup2, kEndpointId2), CHIP_NO_ERROR);
+    EXPECT_EQ(provider->AddEndpoint(kFabric1, kGroup2, kEndpointId3), CHIP_NO_ERROR);
+    EXPECT_EQ(provider->AddEndpoint(kFabric2, kGroup3, kEndpointId0), CHIP_NO_ERROR);
+    EXPECT_EQ(provider->AddEndpoint(kFabric2, kGroup3, kEndpointId1), CHIP_NO_ERROR);
+    EXPECT_EQ(provider->AddEndpoint(kFabric2, kGroup3, kEndpointId2), CHIP_NO_ERROR);
+    EXPECT_EQ(provider->AddEndpoint(kFabric2, kGroup3, kEndpointId3), CHIP_NO_ERROR);
+    EXPECT_EQ(provider->AddEndpoint(kFabric2, kGroup3, kEndpointId4), CHIP_NO_ERROR);
 
-    NL_TEST_ASSERT(apSuite, provider->HasEndpoint(kFabric1, kGroup1, kEndpointId0));
-    NL_TEST_ASSERT(apSuite, provider->HasEndpoint(kFabric1, kGroup1, kEndpointId1));
-    NL_TEST_ASSERT(apSuite, provider->HasEndpoint(kFabric1, kGroup1, kEndpointId2));
-    NL_TEST_ASSERT(apSuite, provider->HasEndpoint(kFabric1, kGroup2, kEndpointId1));
-    NL_TEST_ASSERT(apSuite, provider->HasEndpoint(kFabric1, kGroup2, kEndpointId2));
-    NL_TEST_ASSERT(apSuite, provider->HasEndpoint(kFabric1, kGroup2, kEndpointId3));
-    NL_TEST_ASSERT(apSuite, provider->HasEndpoint(kFabric2, kGroup3, kEndpointId0));
-    NL_TEST_ASSERT(apSuite, provider->HasEndpoint(kFabric2, kGroup3, kEndpointId1));
-    NL_TEST_ASSERT(apSuite, provider->HasEndpoint(kFabric2, kGroup3, kEndpointId2));
-    NL_TEST_ASSERT(apSuite, provider->HasEndpoint(kFabric2, kGroup3, kEndpointId3));
-    NL_TEST_ASSERT(apSuite, provider->HasEndpoint(kFabric2, kGroup3, kEndpointId4));
+    EXPECT_TRUE(provider->HasEndpoint(kFabric1, kGroup1, kEndpointId0));
+    EXPECT_TRUE(provider->HasEndpoint(kFabric1, kGroup1, kEndpointId1));
+    EXPECT_TRUE(provider->HasEndpoint(kFabric1, kGroup1, kEndpointId2));
+    EXPECT_TRUE(provider->HasEndpoint(kFabric1, kGroup2, kEndpointId1));
+    EXPECT_TRUE(provider->HasEndpoint(kFabric1, kGroup2, kEndpointId2));
+    EXPECT_TRUE(provider->HasEndpoint(kFabric1, kGroup2, kEndpointId3));
+    EXPECT_TRUE(provider->HasEndpoint(kFabric2, kGroup3, kEndpointId0));
+    EXPECT_TRUE(provider->HasEndpoint(kFabric2, kGroup3, kEndpointId1));
+    EXPECT_TRUE(provider->HasEndpoint(kFabric2, kGroup3, kEndpointId2));
+    EXPECT_TRUE(provider->HasEndpoint(kFabric2, kGroup3, kEndpointId3));
+    EXPECT_TRUE(provider->HasEndpoint(kFabric2, kGroup3, kEndpointId4));
 
     // Keys
 
     KeySet keyset;
 
-    NL_TEST_ASSERT(apSuite, CHIP_NO_ERROR == provider->SetKeySet(kFabric2, kCompressedFabricId2, kKeySet0));
-    NL_TEST_ASSERT(apSuite, CHIP_NO_ERROR == provider->SetKeySet(kFabric1, kCompressedFabricId1, kKeySet2));
-    NL_TEST_ASSERT(apSuite, CHIP_NO_ERROR == provider->SetKeySet(kFabric2, kCompressedFabricId2, kKeySet1));
-    NL_TEST_ASSERT(apSuite, CHIP_NO_ERROR == provider->SetKeySet(kFabric1, kCompressedFabricId1, kKeySet1));
-    NL_TEST_ASSERT(apSuite, CHIP_NO_ERROR == provider->SetKeySet(kFabric2, kCompressedFabricId2, kKeySet2));
-    NL_TEST_ASSERT(apSuite, CHIP_NO_ERROR == provider->SetKeySet(kFabric1, kCompressedFabricId1, kKeySet0));
+    EXPECT_EQ(provider->SetKeySet(kFabric2, kCompressedFabricId2, kKeySet0), CHIP_NO_ERROR);
+    EXPECT_EQ(provider->SetKeySet(kFabric1, kCompressedFabricId1, kKeySet2), CHIP_NO_ERROR);
+    EXPECT_EQ(provider->SetKeySet(kFabric2, kCompressedFabricId2, kKeySet1), CHIP_NO_ERROR);
+    EXPECT_EQ(provider->SetKeySet(kFabric1, kCompressedFabricId1, kKeySet1), CHIP_NO_ERROR);
+    EXPECT_EQ(provider->SetKeySet(kFabric2, kCompressedFabricId2, kKeySet2), CHIP_NO_ERROR);
+    EXPECT_EQ(provider->SetKeySet(kFabric1, kCompressedFabricId1, kKeySet0), CHIP_NO_ERROR);
 
-    NL_TEST_ASSERT(apSuite, CHIP_NO_ERROR == provider->GetKeySet(kFabric2, kKeysetId0, keyset));
-    NL_TEST_ASSERT(apSuite, CompareKeySets(keyset, kKeySet0));
+    EXPECT_EQ(provider->GetKeySet(kFabric2, kKeysetId0, keyset), CHIP_NO_ERROR);
+    EXPECT_TRUE(CompareKeySets(keyset, kKeySet0));
 
-    NL_TEST_ASSERT(apSuite, CHIP_NO_ERROR == provider->GetKeySet(kFabric2, kKeysetId1, keyset));
-    NL_TEST_ASSERT(apSuite, CompareKeySets(keyset, kKeySet1));
+    EXPECT_EQ(provider->GetKeySet(kFabric2, kKeysetId1, keyset), CHIP_NO_ERROR);
+    EXPECT_TRUE(CompareKeySets(keyset, kKeySet1));
 
-    NL_TEST_ASSERT(apSuite, CHIP_NO_ERROR == provider->GetKeySet(kFabric2, kKeysetId2, keyset));
-    NL_TEST_ASSERT(apSuite, CompareKeySets(keyset, kKeySet2));
+    EXPECT_EQ(provider->GetKeySet(kFabric2, kKeysetId2, keyset), CHIP_NO_ERROR);
+    EXPECT_TRUE(CompareKeySets(keyset, kKeySet2));
 
-    NL_TEST_ASSERT(apSuite, CHIP_NO_ERROR == provider->GetKeySet(kFabric1, kKeysetId2, keyset));
-    NL_TEST_ASSERT(apSuite, CompareKeySets(keyset, kKeySet2));
+    EXPECT_EQ(provider->GetKeySet(kFabric1, kKeysetId2, keyset), CHIP_NO_ERROR);
+    EXPECT_TRUE(CompareKeySets(keyset, kKeySet2));
 
-    NL_TEST_ASSERT(apSuite, CHIP_NO_ERROR == provider->GetKeySet(kFabric1, kKeysetId1, keyset));
-    NL_TEST_ASSERT(apSuite, CompareKeySets(keyset, kKeySet1));
+    EXPECT_EQ(provider->GetKeySet(kFabric1, kKeysetId1, keyset), CHIP_NO_ERROR);
+    EXPECT_TRUE(CompareKeySets(keyset, kKeySet1));
 
-    NL_TEST_ASSERT(apSuite, CHIP_NO_ERROR == provider->GetKeySet(kFabric1, kKeysetId0, keyset));
-    NL_TEST_ASSERT(apSuite, CompareKeySets(keyset, kKeySet0));
+    EXPECT_EQ(provider->GetKeySet(kFabric1, kKeysetId0, keyset), CHIP_NO_ERROR);
+    EXPECT_TRUE(CompareKeySets(keyset, kKeySet0));
 
     //
     // Remove Fabric
     //
 
-    NL_TEST_ASSERT(apSuite, CHIP_NO_ERROR == provider->RemoveFabric(kFabric1));
+    EXPECT_EQ(provider->RemoveFabric(kFabric1), CHIP_NO_ERROR);
 
     // Endpoints
 
-    NL_TEST_ASSERT(apSuite, !provider->HasEndpoint(kFabric1, kGroup1, kEndpointId0));
-    NL_TEST_ASSERT(apSuite, !provider->HasEndpoint(kFabric1, kGroup1, kEndpointId1));
-    NL_TEST_ASSERT(apSuite, !provider->HasEndpoint(kFabric1, kGroup1, kEndpointId2));
-    NL_TEST_ASSERT(apSuite, !provider->HasEndpoint(kFabric1, kGroup2, kEndpointId1));
-    NL_TEST_ASSERT(apSuite, !provider->HasEndpoint(kFabric1, kGroup2, kEndpointId2));
-    NL_TEST_ASSERT(apSuite, !provider->HasEndpoint(kFabric1, kGroup2, kEndpointId3));
-    NL_TEST_ASSERT(apSuite, provider->HasEndpoint(kFabric2, kGroup3, kEndpointId0));
-    NL_TEST_ASSERT(apSuite, provider->HasEndpoint(kFabric2, kGroup3, kEndpointId1));
-    NL_TEST_ASSERT(apSuite, provider->HasEndpoint(kFabric2, kGroup3, kEndpointId2));
-    NL_TEST_ASSERT(apSuite, provider->HasEndpoint(kFabric2, kGroup3, kEndpointId3));
-    NL_TEST_ASSERT(apSuite, provider->HasEndpoint(kFabric2, kGroup3, kEndpointId4));
+    EXPECT_FALSE(provider->HasEndpoint(kFabric1, kGroup1, kEndpointId0));
+    EXPECT_FALSE(provider->HasEndpoint(kFabric1, kGroup1, kEndpointId1));
+    EXPECT_FALSE(provider->HasEndpoint(kFabric1, kGroup1, kEndpointId2));
+    EXPECT_FALSE(provider->HasEndpoint(kFabric1, kGroup2, kEndpointId1));
+    EXPECT_FALSE(provider->HasEndpoint(kFabric1, kGroup2, kEndpointId2));
+    EXPECT_FALSE(provider->HasEndpoint(kFabric1, kGroup2, kEndpointId3));
+    EXPECT_TRUE(provider->HasEndpoint(kFabric2, kGroup3, kEndpointId0));
+    EXPECT_TRUE(provider->HasEndpoint(kFabric2, kGroup3, kEndpointId1));
+    EXPECT_TRUE(provider->HasEndpoint(kFabric2, kGroup3, kEndpointId2));
+    EXPECT_TRUE(provider->HasEndpoint(kFabric2, kGroup3, kEndpointId3));
+    EXPECT_TRUE(provider->HasEndpoint(kFabric2, kGroup3, kEndpointId4));
 
     // Group Info
 
-    NL_TEST_ASSERT(apSuite, CHIP_ERROR_NOT_FOUND == provider->GetGroupInfoAt(kFabric1, 0, group));
-    NL_TEST_ASSERT(apSuite, CHIP_ERROR_NOT_FOUND == provider->GetGroupInfoAt(kFabric1, 1, group));
-    NL_TEST_ASSERT(apSuite, CHIP_ERROR_NOT_FOUND == provider->GetGroupInfoAt(kFabric1, 2, group));
-    NL_TEST_ASSERT(apSuite, CHIP_NO_ERROR == provider->GetGroupInfoAt(kFabric2, 0, group));
-    NL_TEST_ASSERT(apSuite, CHIP_NO_ERROR == provider->GetGroupInfoAt(kFabric2, 1, group));
-    NL_TEST_ASSERT(apSuite, CHIP_NO_ERROR == provider->GetGroupInfoAt(kFabric2, 2, group));
+    EXPECT_EQ(CHIP_ERROR_NOT_FOUND, provider->GetGroupInfoAt(kFabric1, 0, group));
+    EXPECT_EQ(CHIP_ERROR_NOT_FOUND, provider->GetGroupInfoAt(kFabric1, 1, group));
+    EXPECT_EQ(CHIP_ERROR_NOT_FOUND, provider->GetGroupInfoAt(kFabric1, 2, group));
+    EXPECT_EQ(provider->GetGroupInfoAt(kFabric2, 0, group), CHIP_NO_ERROR);
+    EXPECT_EQ(provider->GetGroupInfoAt(kFabric2, 1, group), CHIP_NO_ERROR);
+    EXPECT_EQ(provider->GetGroupInfoAt(kFabric2, 2, group), CHIP_NO_ERROR);
 
     // Keys
 
-    NL_TEST_ASSERT(apSuite, CHIP_NO_ERROR == provider->GetKeySet(kFabric2, kKeysetId1, keyset));
-    NL_TEST_ASSERT(apSuite, CompareKeySets(keyset, kKeySet1));
+    EXPECT_EQ(provider->GetKeySet(kFabric2, kKeysetId1, keyset), CHIP_NO_ERROR);
+    EXPECT_TRUE(CompareKeySets(keyset, kKeySet1));
 
-    NL_TEST_ASSERT(apSuite, CHIP_NO_ERROR == provider->GetKeySet(kFabric2, kKeysetId0, keyset));
-    NL_TEST_ASSERT(apSuite, CompareKeySets(keyset, kKeySet0));
+    EXPECT_EQ(provider->GetKeySet(kFabric2, kKeysetId0, keyset), CHIP_NO_ERROR);
+    EXPECT_TRUE(CompareKeySets(keyset, kKeySet0));
 
-    NL_TEST_ASSERT(apSuite, CHIP_ERROR_NOT_FOUND == provider->GetKeySet(kFabric1, 202, keyset));
-    NL_TEST_ASSERT(apSuite, CHIP_ERROR_NOT_FOUND == provider->GetKeySet(kFabric1, 404, keyset));
-    NL_TEST_ASSERT(apSuite, CHIP_ERROR_NOT_FOUND == provider->GetKeySet(kFabric1, 606, keyset));
+    EXPECT_EQ(CHIP_ERROR_NOT_FOUND, provider->GetKeySet(kFabric1, 202, keyset));
+    EXPECT_EQ(CHIP_ERROR_NOT_FOUND, provider->GetKeySet(kFabric1, 404, keyset));
+    EXPECT_EQ(CHIP_ERROR_NOT_FOUND, provider->GetKeySet(kFabric1, 606, keyset));
 }
 
-void TestGroupDecryption(nlTestSuite * apSuite, void * apContext)
+TEST_F(TestGroupDataProvider, TestGroupDecryption)
 {
     GroupDataProvider * provider = GetGroupDataProvider();
-    NL_TEST_ASSERT(apSuite, provider);
+    EXPECT_TRUE(provider);
 
     // Reset test
     ResetProvider(provider);
 
-    NL_TEST_ASSERT(apSuite, CHIP_NO_ERROR == provider->SetGroupInfoAt(kFabric1, 0, kGroupInfo1_3));
-    NL_TEST_ASSERT(apSuite, CHIP_NO_ERROR == provider->SetGroupInfoAt(kFabric1, 1, kGroupInfo1_2));
-    NL_TEST_ASSERT(apSuite, CHIP_NO_ERROR == provider->SetGroupInfoAt(kFabric1, 2, kGroupInfo1_1));
-    NL_TEST_ASSERT(apSuite, CHIP_NO_ERROR == provider->SetGroupInfoAt(kFabric2, 0, kGroupInfo2_1));
-    NL_TEST_ASSERT(apSuite, CHIP_NO_ERROR == provider->SetGroupInfoAt(kFabric2, 1, kGroupInfo2_3));
-    NL_TEST_ASSERT(apSuite, CHIP_NO_ERROR == provider->SetGroupInfoAt(kFabric2, 2, kGroupInfo2_2));
+    EXPECT_EQ(provider->SetGroupInfoAt(kFabric1, 0, kGroupInfo1_3), CHIP_NO_ERROR);
+    EXPECT_EQ(provider->SetGroupInfoAt(kFabric1, 1, kGroupInfo1_2), CHIP_NO_ERROR);
+    EXPECT_EQ(provider->SetGroupInfoAt(kFabric1, 2, kGroupInfo1_1), CHIP_NO_ERROR);
+    EXPECT_EQ(provider->SetGroupInfoAt(kFabric2, 0, kGroupInfo2_1), CHIP_NO_ERROR);
+    EXPECT_EQ(provider->SetGroupInfoAt(kFabric2, 1, kGroupInfo2_3), CHIP_NO_ERROR);
+    EXPECT_EQ(provider->SetGroupInfoAt(kFabric2, 2, kGroupInfo2_2), CHIP_NO_ERROR);
 
-    NL_TEST_ASSERT(apSuite, CHIP_NO_ERROR == provider->AddEndpoint(kFabric1, kGroup1, kEndpointId0));
-    NL_TEST_ASSERT(apSuite, CHIP_NO_ERROR == provider->AddEndpoint(kFabric1, kGroup1, kEndpointId2));
-    NL_TEST_ASSERT(apSuite, CHIP_NO_ERROR == provider->AddEndpoint(kFabric1, kGroup1, kEndpointId4));
-    NL_TEST_ASSERT(apSuite, CHIP_NO_ERROR == provider->AddEndpoint(kFabric1, kGroup2, kEndpointId1));
-    NL_TEST_ASSERT(apSuite, CHIP_NO_ERROR == provider->AddEndpoint(kFabric1, kGroup2, kEndpointId2));
-    NL_TEST_ASSERT(apSuite, CHIP_NO_ERROR == provider->AddEndpoint(kFabric1, kGroup2, kEndpointId3));
+    EXPECT_EQ(provider->AddEndpoint(kFabric1, kGroup1, kEndpointId0), CHIP_NO_ERROR);
+    EXPECT_EQ(provider->AddEndpoint(kFabric1, kGroup1, kEndpointId2), CHIP_NO_ERROR);
+    EXPECT_EQ(provider->AddEndpoint(kFabric1, kGroup1, kEndpointId4), CHIP_NO_ERROR);
+    EXPECT_EQ(provider->AddEndpoint(kFabric1, kGroup2, kEndpointId1), CHIP_NO_ERROR);
+    EXPECT_EQ(provider->AddEndpoint(kFabric1, kGroup2, kEndpointId2), CHIP_NO_ERROR);
+    EXPECT_EQ(provider->AddEndpoint(kFabric1, kGroup2, kEndpointId3), CHIP_NO_ERROR);
 
-    NL_TEST_ASSERT(apSuite, CHIP_NO_ERROR == provider->AddEndpoint(kFabric2, kGroup3, kEndpointId0));
-    NL_TEST_ASSERT(apSuite, CHIP_NO_ERROR == provider->AddEndpoint(kFabric2, kGroup3, kEndpointId1));
-    NL_TEST_ASSERT(apSuite, CHIP_NO_ERROR == provider->AddEndpoint(kFabric2, kGroup3, kEndpointId2));
-    NL_TEST_ASSERT(apSuite, CHIP_NO_ERROR == provider->AddEndpoint(kFabric2, kGroup3, kEndpointId3));
-    NL_TEST_ASSERT(apSuite, CHIP_NO_ERROR == provider->AddEndpoint(kFabric2, kGroup3, kEndpointId4));
+    EXPECT_EQ(provider->AddEndpoint(kFabric2, kGroup3, kEndpointId0), CHIP_NO_ERROR);
+    EXPECT_EQ(provider->AddEndpoint(kFabric2, kGroup3, kEndpointId1), CHIP_NO_ERROR);
+    EXPECT_EQ(provider->AddEndpoint(kFabric2, kGroup3, kEndpointId2), CHIP_NO_ERROR);
+    EXPECT_EQ(provider->AddEndpoint(kFabric2, kGroup3, kEndpointId3), CHIP_NO_ERROR);
+    EXPECT_EQ(provider->AddEndpoint(kFabric2, kGroup3, kEndpointId4), CHIP_NO_ERROR);
 
-    NL_TEST_ASSERT(apSuite, CHIP_NO_ERROR == provider->SetKeySet(kFabric1, kCompressedFabricId1, kKeySet0));
-    NL_TEST_ASSERT(apSuite, CHIP_NO_ERROR == provider->SetKeySet(kFabric1, kCompressedFabricId1, kKeySet2));
-    NL_TEST_ASSERT(apSuite, CHIP_NO_ERROR == provider->SetKeySet(kFabric2, kCompressedFabricId2, kKeySet1));
-    NL_TEST_ASSERT(apSuite, CHIP_NO_ERROR == provider->SetKeySet(kFabric2, kCompressedFabricId2, kKeySet3));
+    EXPECT_EQ(provider->SetKeySet(kFabric1, kCompressedFabricId1, kKeySet0), CHIP_NO_ERROR);
+    EXPECT_EQ(provider->SetKeySet(kFabric1, kCompressedFabricId1, kKeySet2), CHIP_NO_ERROR);
+    EXPECT_EQ(provider->SetKeySet(kFabric2, kCompressedFabricId2, kKeySet1), CHIP_NO_ERROR);
+    EXPECT_EQ(provider->SetKeySet(kFabric2, kCompressedFabricId2, kKeySet3), CHIP_NO_ERROR);
 
-    NL_TEST_ASSERT(apSuite, CHIP_NO_ERROR == provider->SetGroupKeyAt(kFabric1, 0, kGroup1Keyset0));
-    NL_TEST_ASSERT(apSuite, CHIP_NO_ERROR == provider->SetGroupKeyAt(kFabric1, 1, kGroup1Keyset2));
-    NL_TEST_ASSERT(apSuite, CHIP_NO_ERROR == provider->SetGroupKeyAt(kFabric1, 2, kGroup3Keyset0));
-    NL_TEST_ASSERT(apSuite, CHIP_NO_ERROR == provider->SetGroupKeyAt(kFabric1, 3, kGroup3Keyset2));
+    EXPECT_EQ(provider->SetGroupKeyAt(kFabric1, 0, kGroup1Keyset0), CHIP_NO_ERROR);
+    EXPECT_EQ(provider->SetGroupKeyAt(kFabric1, 1, kGroup1Keyset2), CHIP_NO_ERROR);
+    EXPECT_EQ(provider->SetGroupKeyAt(kFabric1, 2, kGroup3Keyset0), CHIP_NO_ERROR);
+    EXPECT_EQ(provider->SetGroupKeyAt(kFabric1, 3, kGroup3Keyset2), CHIP_NO_ERROR);
 
-    NL_TEST_ASSERT(apSuite, CHIP_NO_ERROR == provider->SetGroupKeyAt(kFabric2, 0, kGroup2Keyset1));
-    NL_TEST_ASSERT(apSuite, CHIP_NO_ERROR == provider->SetGroupKeyAt(kFabric2, 1, kGroup2Keyset3));
+    EXPECT_EQ(provider->SetGroupKeyAt(kFabric2, 0, kGroup2Keyset1), CHIP_NO_ERROR);
+    EXPECT_EQ(provider->SetGroupKeyAt(kFabric2, 1, kGroup2Keyset3), CHIP_NO_ERROR);
 
     const size_t kMessageLength            = 10;
     const uint8_t kMessage[kMessageLength] = { 0xa0, 0xa1, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7, 0xa8, 0xa9 };
@@ -1140,17 +1169,15 @@
 
     // Get the key context
     Crypto::SymmetricKeyContext * key_context = provider->GetKeyContext(kFabric2, kGroup2);
-    NL_TEST_ASSERT(apSuite, nullptr != key_context);
+    ASSERT_NE(nullptr, key_context);
     uint16_t session_id = key_context->GetKeyHash();
 
     // Encrypt the message
-    NL_TEST_ASSERT(
-        apSuite,
-        CHIP_NO_ERROR ==
-            key_context->MessageEncrypt(plaintext, ByteSpan(aad, sizeof(aad)), ByteSpan(nonce, sizeof(nonce)), tag, ciphertext));
+    EXPECT_EQ(key_context->MessageEncrypt(plaintext, ByteSpan(aad, sizeof(aad)), ByteSpan(nonce, sizeof(nonce)), tag, ciphertext),
+              CHIP_NO_ERROR);
 
     // The ciphertext must be different to the original message
-    NL_TEST_ASSERT(apSuite, memcmp(ciphertext.data(), kMessage, sizeof(kMessage)));
+    EXPECT_TRUE(memcmp(ciphertext.data(), kMessage, sizeof(kMessage)));
     key_context->Release();
 
     //
@@ -1164,126 +1191,36 @@
     auto it      = provider->IterateGroupSessions(session_id);
     size_t count = 0, total = 0;
 
-    NL_TEST_ASSERT(apSuite, it);
-    if (it)
+    ASSERT_TRUE(it);
+    total = it->Count();
+    EXPECT_EQ(expected.size(), total);
+    while (it->Next(session))
     {
-        total = it->Count();
-        NL_TEST_ASSERT(apSuite, expected.size() == total);
-        while (it->Next(session))
+        std::pair<FabricIndex, GroupId> found(session.fabric_index, session.group_id);
+        EXPECT_GT(expected.count(found), 0u);
+        ASSERT_NE(session.keyContext, nullptr);
+        // Assert aboves doesn't actually exit, we call continue so that we can call it->Release() outside of
+        // loop.
+        if (session.keyContext == nullptr)
         {
-            std::pair<FabricIndex, GroupId> found(session.fabric_index, session.group_id);
-            NL_TEST_ASSERT(apSuite, expected.count(found) > 0);
-            NL_TEST_ASSERT(apSuite, session.keyContext != nullptr);
-            // Assert aboves doesn't actually exit, we call continue so that we can call it->Release() outside of
-            // loop.
-            if (session.keyContext == nullptr)
-            {
-                continue;
-            }
-
-            // Decrypt the ciphertext
-            NL_TEST_ASSERT(apSuite,
-                           CHIP_NO_ERROR ==
-                               session.keyContext->MessageDecrypt(ciphertext, ByteSpan(aad, sizeof(aad)),
-                                                                  ByteSpan(nonce, sizeof(nonce)), tag, plaintext));
-
-            // The new plaintext must match the original message
-            NL_TEST_ASSERT(apSuite, 0 == memcmp(plaintext.data(), kMessage, sizeof(kMessage)));
-            count++;
+            continue;
         }
-        NL_TEST_ASSERT(apSuite, count == total);
-        it->Release();
+
+        // Decrypt the ciphertext
+        EXPECT_EQ(session.keyContext->MessageDecrypt(ciphertext, ByteSpan(aad, sizeof(aad)), ByteSpan(nonce, sizeof(nonce)), tag,
+                                                     plaintext),
+                  CHIP_NO_ERROR);
+
+        // The new plaintext must match the original message
+        EXPECT_EQ(memcmp(plaintext.data(), kMessage, sizeof(kMessage)), 0);
+        count++;
     }
+    EXPECT_EQ(count, total);
+    it->Release();
 }
 
 } // namespace TestGroups
 } // namespace app
 } // namespace chip
 
-namespace {
-
-static chip::TestPersistentStorageDelegate sDelegate;
-static chip::Crypto::DefaultSessionKeystore sSessionKeystore;
-static GroupDataProviderImpl sProvider(chip::app::TestGroups::kMaxGroupsPerFabric, chip::app::TestGroups::kMaxGroupKeysPerFabric);
-
-static EpochKey kEpochKeys0[] = {
-    { 0x0000000000000000, { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 } },
-    { 0x1111111111111111, { 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f } },
-    { 0x2222222222222222, { 0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f } }
-};
-static EpochKey kEpochKeys1[] = {
-    { 0x3333333333333333, { 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f } },
-    { 0x4444444444444444, { 0x40, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f } },
-    { 0x5555555555555555, { 0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x5b, 0x5c, 0x5d, 0x5e, 0x5f } },
-};
-static EpochKey kEpochKeys2[] = {
-    { 0xaaaaaaaaaaaaaaaa, { 0xa0, 0xa1, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7, 0xa8, 0xa9, 0xaa, 0xab, 0xac, 0xad, 0xae, 0xaf } },
-    { 0xbbbbbbbbbbbbbbbb, { 0xb0, 0xb1, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6, 0xb7, 0xb8, 0xb9, 0xba, 0xbb, 0xbc, 0xbd, 0xbe, 0xbf } },
-    { 0xcccccccccccccccc, { 0xc0, 0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xcb, 0xcc, 0xcd, 0xce, 0xcf } },
-};
-static EpochKey kEpochKeys3[] = {
-    { 0xdddddddddddddddd, { 0xd0, 0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8, 0xd9, 0xda, 0xdb, 0xdc, 0xdd, 0xde, 0xdf } },
-    { 0xeeeeeeeeeeeeeeee, { 0xe0, 0xe1, 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0xea, 0xeb, 0xec, 0xed, 0xee, 0xef } },
-    { 0xffffffffffffffff, { 0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff } },
-};
-
-/**
- *  Set up the test suite.
- */
-int Test_Setup(void * inContext)
-{
-    VerifyOrReturnError(CHIP_NO_ERROR == chip::Platform::MemoryInit(), FAILURE);
-
-    // Initialize Group Data Provider
-    sProvider.SetStorageDelegate(&sDelegate);
-    sProvider.SetSessionKeystore(&sSessionKeystore);
-    sProvider.SetListener(&chip::app::TestGroups::sListener);
-    VerifyOrReturnError(CHIP_NO_ERROR == sProvider.Init(), FAILURE);
-    SetGroupDataProvider(&sProvider);
-
-    memcpy(chip::app::TestGroups::kKeySet0.epoch_keys, kEpochKeys0, sizeof(kEpochKeys0));
-    memcpy(chip::app::TestGroups::kKeySet1.epoch_keys, kEpochKeys1, sizeof(kEpochKeys1));
-    memcpy(chip::app::TestGroups::kKeySet2.epoch_keys, kEpochKeys2, sizeof(kEpochKeys2));
-    memcpy(chip::app::TestGroups::kKeySet3.epoch_keys, kEpochKeys3, sizeof(kEpochKeys3));
-
-    return SUCCESS;
-}
-
-/**
- *  Tear down the test suite.
- */
-int Test_Teardown(void * inContext)
-{
-    GroupDataProvider * provider = GetGroupDataProvider();
-    if (nullptr != provider)
-    {
-        provider->Finish();
-    }
-    chip::Platform::MemoryShutdown();
-    return SUCCESS;
-}
-
-const nlTest sTests[] = { NL_TEST_DEF("TestStorageDelegate", chip::app::TestGroups::TestStorageDelegate),
-                          NL_TEST_DEF("TestGroupInfo", chip::app::TestGroups::TestGroupInfo),
-                          NL_TEST_DEF("TestGroupInfoIterator", chip::app::TestGroups::TestGroupInfoIterator),
-                          NL_TEST_DEF("TestEndpoints", chip::app::TestGroups::TestEndpoints),
-                          NL_TEST_DEF("TestEndpointIterator", chip::app::TestGroups::TestEndpointIterator),
-                          NL_TEST_DEF("TestGroupKeys", chip::app::TestGroups::TestGroupKeys),
-                          NL_TEST_DEF("TestGroupKeyIterator", chip::app::TestGroups::TestGroupKeyIterator),
-                          NL_TEST_DEF("TestKeySets", chip::app::TestGroups::TestKeySets),
-                          NL_TEST_DEF("TestKeySetIterator", chip::app::TestGroups::TestKeySetIterator),
-                          NL_TEST_DEF("TestIpk", chip::app::TestGroups::TestIpk),
-                          NL_TEST_DEF("TestPerFabricData", chip::app::TestGroups::TestPerFabricData),
-                          NL_TEST_DEF("TestGroupDecryption", chip::app::TestGroups::TestGroupDecryption),
-                          NL_TEST_SENTINEL() };
-} // namespace
-
-int TestGroups()
-{
-    nlTestSuite theSuite = { "GroupDataProvider", &sTests[0], &Test_Setup, &Test_Teardown };
-
-    nlTestRunner(&theSuite, nullptr);
-    return (nlTestRunnerStats(&theSuite));
-}
-
-CHIP_REGISTER_TEST_SUITE(TestGroups)
+namespace {} // namespace
diff --git a/src/credentials/tests/TestPersistentStorageOpCertStore.cpp b/src/credentials/tests/TestPersistentStorageOpCertStore.cpp
index 12d4ac8..c1a57e0 100644
--- a/src/credentials/tests/TestPersistentStorageOpCertStore.cpp
+++ b/src/credentials/tests/TestPersistentStorageOpCertStore.cpp
@@ -19,13 +19,12 @@
 #include <inttypes.h>
 
 #include <credentials/PersistentStorageOpCertStore.h>
+#include <gtest/gtest.h>
 #include <lib/support/CHIPMem.h>
 #include <lib/support/CodeUtils.h>
 #include <lib/support/DefaultStorageKeyAllocator.h>
 #include <lib/support/Span.h>
 #include <lib/support/TestPersistentStorageDelegate.h>
-#include <lib/support/UnitTestRegistration.h>
-#include <nlunit-test.h>
 
 using namespace chip;
 using namespace chip::Credentials;
@@ -47,19 +46,25 @@
 const uint8_t kTestNocBuf[] = { 'n', 'o', 'c' };
 const ByteSpan kTestNocSpan{ kTestNocBuf };
 
-void TestAddNocFlow(nlTestSuite * inSuite, void * inContext)
+struct TestPersistentStorageOpCertStore : public ::testing::Test
+{
+    static void SetUpTestSuite() { ASSERT_EQ(chip::Platform::MemoryInit(), CHIP_NO_ERROR); }
+    static void TearDownTestSuite() { chip::Platform::MemoryShutdown(); }
+};
+
+TEST_F(TestPersistentStorageOpCertStore, TestAddNocFlow)
 {
     TestPersistentStorageDelegate storageDelegate;
     PersistentStorageOpCertStore opCertStore;
 
     // Failure before Init
     CHIP_ERROR err = opCertStore.AddNewTrustedRootCertForFabric(kFabricIndex1, kTestRcacSpan);
-    NL_TEST_ASSERT(inSuite, err == CHIP_ERROR_INCORRECT_STATE);
-    NL_TEST_ASSERT(inSuite, storageDelegate.GetNumKeys() == 0);
+    EXPECT_EQ(err, CHIP_ERROR_INCORRECT_STATE);
+    EXPECT_EQ(storageDelegate.GetNumKeys(), 0u);
 
     // Init succeeds
     err = opCertStore.Init(&storageDelegate);
-    NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
+    EXPECT_EQ(err, CHIP_NO_ERROR);
 
     // Manually add existing root for the FabricIndex, should fail AddNewTrustedRootCertForFabric for
     // same fabric but succeed GetCertificate.
@@ -67,53 +72,52 @@
 
     err = storageDelegate.SyncSetKeyValue(DefaultStorageKeyAllocator::FabricRCAC(kFabricIndex1).KeyName(), kTestRcacBufExists,
                                           sizeof(kTestRcacBufExists));
-    NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
-    NL_TEST_ASSERT(inSuite, storageDelegate.GetNumKeys() == 1);
-    NL_TEST_ASSERT(inSuite,
-                   opCertStore.HasCertificateForFabric(kFabricIndex1, CertChainElement::kRcac) == true); //< From manual add
+    EXPECT_EQ(err, CHIP_NO_ERROR);
+    EXPECT_EQ(storageDelegate.GetNumKeys(), 1u);
+    EXPECT_TRUE(opCertStore.HasCertificateForFabric(kFabricIndex1, CertChainElement::kRcac)); //< From manual add
 
     err = opCertStore.AddNewTrustedRootCertForFabric(kFabricIndex1, kTestRcacSpan);
-    NL_TEST_ASSERT(inSuite, err == CHIP_ERROR_INCORRECT_STATE);
+    EXPECT_EQ(err, CHIP_ERROR_INCORRECT_STATE);
 
     uint8_t largeBuf[400];
     MutableByteSpan largeSpan{ largeBuf };
 
     err = opCertStore.GetCertificate(kFabricIndex1, CertChainElement::kNoc, largeSpan);
-    NL_TEST_ASSERT(inSuite, err == CHIP_ERROR_NOT_FOUND);
+    EXPECT_EQ(err, CHIP_ERROR_NOT_FOUND);
 
     largeSpan = MutableByteSpan{ largeBuf };
 
     err = opCertStore.GetCertificate(kFabricIndex1, CertChainElement::kRcac, largeSpan);
-    NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
-    NL_TEST_ASSERT(inSuite, largeSpan.data_equal(ByteSpan{ kTestRcacBufExists }));
+    EXPECT_EQ(err, CHIP_NO_ERROR);
+    EXPECT_TRUE(largeSpan.data_equal(ByteSpan{ kTestRcacBufExists }));
 
     // Adding root for another FabricIndex should work
     err = opCertStore.AddNewTrustedRootCertForFabric(kUndefinedFabricIndex, kTestRcacSpan);
-    NL_TEST_ASSERT(inSuite, err == CHIP_ERROR_INVALID_FABRIC_INDEX);
+    EXPECT_EQ(err, CHIP_ERROR_INVALID_FABRIC_INDEX);
 
     err = opCertStore.AddNewTrustedRootCertForFabric(kFabricIndex2, kTestRcacSpan);
-    NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
-    NL_TEST_ASSERT(inSuite, storageDelegate.GetNumKeys() == 1); //< Storage count did not yet increase
-    NL_TEST_ASSERT(inSuite, !opCertStore.HasPendingNocChain());
-    NL_TEST_ASSERT(inSuite, opCertStore.HasPendingRootCert() == true);
+    EXPECT_EQ(err, CHIP_NO_ERROR);
+    EXPECT_EQ(storageDelegate.GetNumKeys(), 1u); //< Storage count did not yet increase
+    EXPECT_FALSE(opCertStore.HasPendingNocChain());
+    EXPECT_TRUE(opCertStore.HasPendingRootCert());
 
     // Should be able to read pending RCAC right away
     largeSpan = MutableByteSpan{ largeBuf };
     err       = opCertStore.GetCertificate(kFabricIndex2, CertChainElement::kRcac, largeSpan);
-    NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
-    NL_TEST_ASSERT(inSuite, largeSpan.data_equal(ByteSpan{ kTestRcacSpan }));
+    EXPECT_EQ(err, CHIP_NO_ERROR);
+    EXPECT_TRUE(largeSpan.data_equal(ByteSpan{ kTestRcacSpan }));
 
     // Trying to commit with pending RCAC but no NOC should fail but leave everything as-is
     err = opCertStore.CommitOpCertsForFabric(kFabricIndex2);
-    NL_TEST_ASSERT(inSuite, err == CHIP_ERROR_INCORRECT_STATE);
-    NL_TEST_ASSERT(inSuite, !opCertStore.HasPendingNocChain());
-    NL_TEST_ASSERT(inSuite, opCertStore.HasPendingRootCert() == true);
+    EXPECT_EQ(err, CHIP_ERROR_INCORRECT_STATE);
+    EXPECT_FALSE(opCertStore.HasPendingNocChain());
+    EXPECT_TRUE(opCertStore.HasPendingRootCert());
 
     // Trying to do AddNewOpCertsForFabric for fabric different that with pending RCAC should fail
     err = opCertStore.AddNewOpCertsForFabric(kOtherFabricIndex, kTestNocSpan, kTestIcacSpan);
-    NL_TEST_ASSERT(inSuite, err == CHIP_ERROR_INVALID_FABRIC_INDEX);
-    NL_TEST_ASSERT(inSuite, !opCertStore.HasPendingNocChain());
-    NL_TEST_ASSERT(inSuite, opCertStore.HasPendingRootCert() == true);
+    EXPECT_EQ(err, CHIP_ERROR_INVALID_FABRIC_INDEX);
+    EXPECT_FALSE(opCertStore.HasPendingNocChain());
+    EXPECT_TRUE(opCertStore.HasPendingRootCert());
 
     // Clear other bad cases from storage for now
     storageDelegate.ClearStorage();
@@ -125,128 +129,127 @@
 
     err = storageDelegate.SyncSetKeyValue(DefaultStorageKeyAllocator::FabricICAC(kFabricIndex2).KeyName(), kTestIcacBufExists,
                                           sizeof(kTestIcacBufExists));
-    NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
-    NL_TEST_ASSERT(inSuite, storageDelegate.GetNumKeys() == 1);
+    EXPECT_EQ(err, CHIP_NO_ERROR);
+    EXPECT_EQ(storageDelegate.GetNumKeys(), 1u);
 
     err = storageDelegate.SyncSetKeyValue(DefaultStorageKeyAllocator::FabricNOC(kFabricIndex2).KeyName(), kTestNocBufExists,
                                           sizeof(kTestNocBufExists));
-    NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
-    NL_TEST_ASSERT(inSuite, storageDelegate.GetNumKeys() == 2);
+    EXPECT_EQ(err, CHIP_NO_ERROR);
+    EXPECT_EQ(storageDelegate.GetNumKeys(), 2u);
 
-    NL_TEST_ASSERT(inSuite,
-                   opCertStore.HasCertificateForFabric(kFabricIndex2, CertChainElement::kIcac) == true);         //< From manual add
-    NL_TEST_ASSERT(inSuite, opCertStore.HasCertificateForFabric(kFabricIndex2, CertChainElement::kNoc) == true); //< From manual add
+    EXPECT_TRUE(opCertStore.HasCertificateForFabric(kFabricIndex2, CertChainElement::kIcac)); //< From manual add
+    EXPECT_TRUE(opCertStore.HasCertificateForFabric(kFabricIndex2, CertChainElement::kNoc));  //< From manual add
 
     err = opCertStore.AddNewOpCertsForFabric(kFabricIndex2, kTestNocSpan, kTestIcacSpan);
-    NL_TEST_ASSERT(inSuite, err == CHIP_ERROR_INCORRECT_STATE);
-    NL_TEST_ASSERT(inSuite, !opCertStore.HasPendingNocChain());
-    NL_TEST_ASSERT(inSuite, opCertStore.HasPendingRootCert() == true);
+    EXPECT_EQ(err, CHIP_ERROR_INCORRECT_STATE);
+    EXPECT_FALSE(opCertStore.HasPendingNocChain());
+    EXPECT_TRUE(opCertStore.HasPendingRootCert());
 
     storageDelegate.SyncDeleteKeyValue(DefaultStorageKeyAllocator::FabricICAC(kFabricIndex2).KeyName());
     storageDelegate.SyncDeleteKeyValue(DefaultStorageKeyAllocator::FabricNOC(kFabricIndex2).KeyName());
-    NL_TEST_ASSERT(inSuite, storageDelegate.GetNumKeys() == 0);
+    EXPECT_EQ(storageDelegate.GetNumKeys(), 0u);
 
     // Trying to do AddNewOpCertsForFabric for same fabric as that with pending RCAC should succeed
     err = opCertStore.AddNewOpCertsForFabric(kFabricIndex2, kTestNocSpan, kTestIcacSpan);
-    NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
-    NL_TEST_ASSERT(inSuite, opCertStore.HasPendingNocChain());
-    NL_TEST_ASSERT(inSuite, opCertStore.HasPendingRootCert() == true);
-    NL_TEST_ASSERT(inSuite, storageDelegate.GetNumKeys() == 0); //< Storage count did not yet increase
+    EXPECT_EQ(err, CHIP_NO_ERROR);
+    EXPECT_TRUE(opCertStore.HasPendingNocChain());
+    EXPECT_TRUE(opCertStore.HasPendingRootCert());
+    EXPECT_EQ(storageDelegate.GetNumKeys(), 0u); //< Storage count did not yet increase
 
     // Should be able to get the pending cert even if not in persisted storage
     largeSpan = MutableByteSpan{ largeBuf };
     err       = opCertStore.GetCertificate(kFabricIndex2, CertChainElement::kIcac, largeSpan);
-    NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
-    NL_TEST_ASSERT(inSuite, largeSpan.data_equal(ByteSpan{ kTestIcacSpan }));
+    EXPECT_EQ(err, CHIP_NO_ERROR);
+    EXPECT_TRUE(largeSpan.data_equal(ByteSpan{ kTestIcacSpan }));
 
     largeSpan = MutableByteSpan{ largeBuf };
     err       = opCertStore.GetCertificate(kFabricIndex2, CertChainElement::kNoc, largeSpan);
-    NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
-    NL_TEST_ASSERT(inSuite, largeSpan.data_equal(ByteSpan{ kTestNocSpan }));
+    EXPECT_EQ(err, CHIP_NO_ERROR);
+    EXPECT_TRUE(largeSpan.data_equal(ByteSpan{ kTestNocSpan }));
 
     // Trying to do AddNewOpCertsForFabric a second time after success before commit should fail,
     // but leave state as-is
     err = opCertStore.AddNewOpCertsForFabric(kFabricIndex2, kTestNocSpan, kTestIcacSpan);
-    NL_TEST_ASSERT(inSuite, err == CHIP_ERROR_INCORRECT_STATE);
-    NL_TEST_ASSERT(inSuite, opCertStore.HasPendingNocChain());
-    NL_TEST_ASSERT(inSuite, opCertStore.HasPendingRootCert() == true);
+    EXPECT_EQ(err, CHIP_ERROR_INCORRECT_STATE);
+    EXPECT_TRUE(opCertStore.HasPendingNocChain());
+    EXPECT_TRUE(opCertStore.HasPendingRootCert());
 
     // Should be able to get the pending cert even if not in persisted storage, after an API error
     largeSpan = MutableByteSpan{ largeBuf };
     err       = opCertStore.GetCertificate(kFabricIndex2, CertChainElement::kIcac, largeSpan);
-    NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
-    NL_TEST_ASSERT(inSuite, largeSpan.data_equal(ByteSpan{ kTestIcacSpan }));
+    EXPECT_EQ(err, CHIP_NO_ERROR);
+    EXPECT_TRUE(largeSpan.data_equal(ByteSpan{ kTestIcacSpan }));
 
     largeSpan = MutableByteSpan{ largeBuf };
     err       = opCertStore.GetCertificate(kFabricIndex2, CertChainElement::kNoc, largeSpan);
-    NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
-    NL_TEST_ASSERT(inSuite, largeSpan.data_equal(ByteSpan{ kTestNocSpan }));
+    EXPECT_EQ(err, CHIP_NO_ERROR);
+    EXPECT_TRUE(largeSpan.data_equal(ByteSpan{ kTestNocSpan }));
 
     // Trying to commit with wrong FabricIndex should fail
     err = opCertStore.CommitOpCertsForFabric(kOtherFabricIndex);
-    NL_TEST_ASSERT(inSuite, err == CHIP_ERROR_INVALID_FABRIC_INDEX);
-    NL_TEST_ASSERT(inSuite, opCertStore.HasPendingNocChain());
-    NL_TEST_ASSERT(inSuite, opCertStore.HasPendingRootCert() == true);
+    EXPECT_EQ(err, CHIP_ERROR_INVALID_FABRIC_INDEX);
+    EXPECT_TRUE(opCertStore.HasPendingNocChain());
+    EXPECT_TRUE(opCertStore.HasPendingRootCert());
 
     // Commiting new certs should succeed on correct fabric
     err = opCertStore.CommitOpCertsForFabric(kFabricIndex2);
-    NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
-    NL_TEST_ASSERT(inSuite, !opCertStore.HasPendingNocChain());
-    NL_TEST_ASSERT(inSuite, !opCertStore.HasPendingRootCert());
+    EXPECT_EQ(err, CHIP_NO_ERROR);
+    EXPECT_FALSE(opCertStore.HasPendingNocChain());
+    EXPECT_FALSE(opCertStore.HasPendingRootCert());
 
-    NL_TEST_ASSERT(inSuite, storageDelegate.GetNumKeys() == 3); //< All certs now committed
+    EXPECT_EQ(storageDelegate.GetNumKeys(), 3u); //< All certs now committed
 
     // Should be able to get the committed certs
     largeSpan = MutableByteSpan{ largeBuf };
     err       = opCertStore.GetCertificate(kFabricIndex2, CertChainElement::kRcac, largeSpan);
-    NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
-    NL_TEST_ASSERT(inSuite, largeSpan.data_equal(ByteSpan{ kTestRcacSpan }));
+    EXPECT_EQ(err, CHIP_NO_ERROR);
+    EXPECT_TRUE(largeSpan.data_equal(ByteSpan{ kTestRcacSpan }));
 
     largeSpan = MutableByteSpan{ largeBuf };
     err       = opCertStore.GetCertificate(kFabricIndex2, CertChainElement::kIcac, largeSpan);
-    NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
-    NL_TEST_ASSERT(inSuite, largeSpan.data_equal(ByteSpan{ kTestIcacSpan }));
+    EXPECT_EQ(err, CHIP_NO_ERROR);
+    EXPECT_TRUE(largeSpan.data_equal(ByteSpan{ kTestIcacSpan }));
 
     largeSpan = MutableByteSpan{ largeBuf };
     err       = opCertStore.GetCertificate(kFabricIndex2, CertChainElement::kNoc, largeSpan);
-    NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
-    NL_TEST_ASSERT(inSuite, largeSpan.data_equal(ByteSpan{ kTestNocSpan }));
+    EXPECT_EQ(err, CHIP_NO_ERROR);
+    EXPECT_TRUE(largeSpan.data_equal(ByteSpan{ kTestNocSpan }));
 
     opCertStore.Finish();
 }
 
-void TestUpdateNocFlow(nlTestSuite * inSuite, void * inContext)
+TEST_F(TestPersistentStorageOpCertStore, TestUpdateNocFlow)
 {
     TestPersistentStorageDelegate storageDelegate;
     PersistentStorageOpCertStore opCertStore;
 
     // Failure before Init
     CHIP_ERROR err = opCertStore.UpdateOpCertsForFabric(kFabricIndex1, kTestNocSpan, kTestIcacSpan);
-    NL_TEST_ASSERT(inSuite, err == CHIP_ERROR_INCORRECT_STATE);
-    NL_TEST_ASSERT(inSuite, storageDelegate.GetNumKeys() == 0);
+    EXPECT_EQ(err, CHIP_ERROR_INCORRECT_STATE);
+    EXPECT_EQ(storageDelegate.GetNumKeys(), 0u);
 
     // Init succeeds
     err = opCertStore.Init(&storageDelegate);
-    NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
+    EXPECT_EQ(err, CHIP_NO_ERROR);
 
     // Add a new pending trusted root to test for UpdateOpCertsForFabric failure on new root present
     err = opCertStore.AddNewTrustedRootCertForFabric(kFabricIndex1, kTestRcacSpan);
-    NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
-    NL_TEST_ASSERT(inSuite, storageDelegate.GetNumKeys() == 0); //< Storage count did not yet increase
-    NL_TEST_ASSERT(inSuite, opCertStore.HasPendingRootCert() == true);
-    NL_TEST_ASSERT(inSuite, !opCertStore.HasPendingNocChain());
+    EXPECT_EQ(err, CHIP_NO_ERROR);
+    EXPECT_EQ(storageDelegate.GetNumKeys(), 0u); //< Storage count did not yet increase
+    EXPECT_TRUE(opCertStore.HasPendingRootCert());
+    EXPECT_FALSE(opCertStore.HasPendingNocChain());
 
     // Trying to do an UpdateOpCertsForFabric with new root pending should fail
     err = opCertStore.UpdateOpCertsForFabric(kFabricIndex1, kTestNocSpan, kTestIcacSpan);
-    NL_TEST_ASSERT(inSuite, err == CHIP_ERROR_INCORRECT_STATE);
-    NL_TEST_ASSERT(inSuite, opCertStore.HasPendingRootCert() == true);
-    NL_TEST_ASSERT(inSuite, !opCertStore.HasPendingNocChain());
+    EXPECT_EQ(err, CHIP_ERROR_INCORRECT_STATE);
+    EXPECT_TRUE(opCertStore.HasPendingRootCert());
+    EXPECT_FALSE(opCertStore.HasPendingNocChain());
 
     // Revert state for next tests
     opCertStore.RevertPendingOpCerts();
-    NL_TEST_ASSERT(inSuite, !opCertStore.HasPendingNocChain());
-    NL_TEST_ASSERT(inSuite, !opCertStore.HasPendingRootCert());
-    NL_TEST_ASSERT(inSuite, storageDelegate.GetNumKeys() == 0); //< Storage count did not yet increase
+    EXPECT_FALSE(opCertStore.HasPendingNocChain());
+    EXPECT_FALSE(opCertStore.HasPendingRootCert());
+    EXPECT_EQ(storageDelegate.GetNumKeys(), 0u); //< Storage count did not yet increase
 
     // Manually add root, ICAC and NOC to validate update since existing chain required
     const uint8_t kTestRcacBufExists[] = { 'r', 'c', 'a', 'c', ' ', 'e', 'x', 'i', 's', 't', 's' };
@@ -259,385 +262,382 @@
     {
         err = storageDelegate.SyncSetKeyValue(DefaultStorageKeyAllocator::FabricRCAC(kFabricIndex1).KeyName(), kTestRcacBufExists,
                                               sizeof(kTestRcacBufExists));
-        NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
-        NL_TEST_ASSERT(inSuite, storageDelegate.GetNumKeys() == 1);
-        NL_TEST_ASSERT(inSuite,
-                       opCertStore.HasCertificateForFabric(kFabricIndex1, CertChainElement::kRcac) == true); //< From manual add
+        EXPECT_EQ(err, CHIP_NO_ERROR);
+        EXPECT_EQ(storageDelegate.GetNumKeys(), 1u);
+        EXPECT_TRUE(opCertStore.HasCertificateForFabric(kFabricIndex1, CertChainElement::kRcac)); //< From manual add
 
         err = storageDelegate.SyncSetKeyValue(DefaultStorageKeyAllocator::FabricICAC(kFabricIndex1).KeyName(), kTestIcacBufExists,
                                               sizeof(kTestIcacBufExists));
-        NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
-        NL_TEST_ASSERT(inSuite, storageDelegate.GetNumKeys() == 2);
-        NL_TEST_ASSERT(inSuite,
-                       opCertStore.HasCertificateForFabric(kFabricIndex1, CertChainElement::kIcac) == true); //< From manual add
+        EXPECT_EQ(err, CHIP_NO_ERROR);
+        EXPECT_EQ(storageDelegate.GetNumKeys(), 2u);
+        EXPECT_TRUE(opCertStore.HasCertificateForFabric(kFabricIndex1, CertChainElement::kIcac)); //< From manual add
 
         err = storageDelegate.SyncSetKeyValue(DefaultStorageKeyAllocator::FabricNOC(kFabricIndex1).KeyName(), kTestNocBufExists,
                                               sizeof(kTestNocBufExists));
-        NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
-        NL_TEST_ASSERT(inSuite, storageDelegate.GetNumKeys() == 3);
-        NL_TEST_ASSERT(inSuite,
-                       opCertStore.HasCertificateForFabric(kFabricIndex1, CertChainElement::kNoc) == true); //< From manual add
+        EXPECT_EQ(err, CHIP_NO_ERROR);
+        EXPECT_EQ(storageDelegate.GetNumKeys(), 3u);
+        EXPECT_TRUE(opCertStore.HasCertificateForFabric(kFabricIndex1, CertChainElement::kNoc)); //< From manual add
 
         // Test that we can manually stored certs
         largeSpan = MutableByteSpan{ largeBuf };
         err       = opCertStore.GetCertificate(kFabricIndex1, CertChainElement::kRcac, largeSpan);
-        NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
-        NL_TEST_ASSERT(inSuite, largeSpan.data_equal(ByteSpan{ kTestRcacBufExists }));
+        EXPECT_EQ(err, CHIP_NO_ERROR);
+        EXPECT_TRUE(largeSpan.data_equal(ByteSpan{ kTestRcacBufExists }));
 
         largeSpan = MutableByteSpan{ largeBuf };
         err       = opCertStore.GetCertificate(kFabricIndex1, CertChainElement::kIcac, largeSpan);
-        NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
-        NL_TEST_ASSERT(inSuite, largeSpan.data_equal(ByteSpan{ kTestIcacBufExists }));
+        EXPECT_EQ(err, CHIP_NO_ERROR);
+        EXPECT_TRUE(largeSpan.data_equal(ByteSpan{ kTestIcacBufExists }));
 
         largeSpan = MutableByteSpan{ largeBuf };
         err       = opCertStore.GetCertificate(kFabricIndex1, CertChainElement::kNoc, largeSpan);
-        NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
-        NL_TEST_ASSERT(inSuite, largeSpan.data_equal(ByteSpan{ kTestNocBufExists }));
+        EXPECT_EQ(err, CHIP_NO_ERROR);
+        EXPECT_TRUE(largeSpan.data_equal(ByteSpan{ kTestNocBufExists }));
     }
 
     // Update fails on fabric with wrong FabricIndex
     err = opCertStore.UpdateOpCertsForFabric(kOtherFabricIndex, kTestNocSpan, kTestIcacSpan);
-    NL_TEST_ASSERT(inSuite, err == CHIP_ERROR_INCORRECT_STATE);
-    NL_TEST_ASSERT(inSuite, !opCertStore.HasPendingRootCert());
-    NL_TEST_ASSERT(inSuite, !opCertStore.HasPendingNocChain());
+    EXPECT_EQ(err, CHIP_ERROR_INCORRECT_STATE);
+    EXPECT_FALSE(opCertStore.HasPendingRootCert());
+    EXPECT_FALSE(opCertStore.HasPendingNocChain());
 
     // Update succeeds on fabric with existing data
     err = opCertStore.UpdateOpCertsForFabric(kFabricIndex1, kTestNocSpan, kTestIcacSpan);
-    NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
-    NL_TEST_ASSERT(inSuite, !opCertStore.HasPendingRootCert());
-    NL_TEST_ASSERT(inSuite, opCertStore.HasPendingNocChain() == true);
-    NL_TEST_ASSERT(inSuite, storageDelegate.GetNumKeys() == 3);
+    EXPECT_EQ(err, CHIP_NO_ERROR);
+    EXPECT_FALSE(opCertStore.HasPendingRootCert());
+    EXPECT_TRUE(opCertStore.HasPendingNocChain());
+    EXPECT_EQ(storageDelegate.GetNumKeys(), 3u);
 
     // Can read back existing root unchanged
     largeSpan = MutableByteSpan{ largeBuf };
     err       = opCertStore.GetCertificate(kFabricIndex1, CertChainElement::kRcac, largeSpan);
-    NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
-    NL_TEST_ASSERT(inSuite, largeSpan.data_equal(ByteSpan{ kTestRcacBufExists }));
+    EXPECT_EQ(err, CHIP_NO_ERROR);
+    EXPECT_TRUE(largeSpan.data_equal(ByteSpan{ kTestRcacBufExists }));
 
     // NOC chain elements see the pending updated certs
     largeSpan = MutableByteSpan{ largeBuf };
     err       = opCertStore.GetCertificate(kFabricIndex1, CertChainElement::kIcac, largeSpan);
-    NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
-    NL_TEST_ASSERT(inSuite, largeSpan.data_equal(ByteSpan{ kTestIcacBuf }));
+    EXPECT_EQ(err, CHIP_NO_ERROR);
+    EXPECT_TRUE(largeSpan.data_equal(ByteSpan{ kTestIcacBuf }));
 
     largeSpan = MutableByteSpan{ largeBuf };
     err       = opCertStore.GetCertificate(kFabricIndex1, CertChainElement::kNoc, largeSpan);
-    NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
-    NL_TEST_ASSERT(inSuite, largeSpan.data_equal(ByteSpan{ kTestNocBuf }));
+    EXPECT_EQ(err, CHIP_NO_ERROR);
+    EXPECT_TRUE(largeSpan.data_equal(ByteSpan{ kTestNocBuf }));
 
     // Trying update again fails
     err = opCertStore.UpdateOpCertsForFabric(kFabricIndex1, kTestNocSpan, kTestIcacSpan);
-    NL_TEST_ASSERT(inSuite, err == CHIP_ERROR_INCORRECT_STATE);
-    NL_TEST_ASSERT(inSuite, !opCertStore.HasPendingRootCert());
-    NL_TEST_ASSERT(inSuite, opCertStore.HasPendingNocChain() == true);
-    NL_TEST_ASSERT(inSuite, storageDelegate.GetNumKeys() == 3);
+    EXPECT_EQ(err, CHIP_ERROR_INCORRECT_STATE);
+    EXPECT_FALSE(opCertStore.HasPendingRootCert());
+    EXPECT_TRUE(opCertStore.HasPendingNocChain());
+    EXPECT_EQ(storageDelegate.GetNumKeys(), 3u);
 
     // Trying to add a new root after update, before commit/revert fails
     err = opCertStore.AddNewTrustedRootCertForFabric(kFabricIndex1, kTestRcacSpan);
-    NL_TEST_ASSERT(inSuite, err == CHIP_ERROR_INCORRECT_STATE);
-    NL_TEST_ASSERT(inSuite, !opCertStore.HasPendingRootCert());
-    NL_TEST_ASSERT(inSuite, opCertStore.HasPendingNocChain() == true);
-    NL_TEST_ASSERT(inSuite, storageDelegate.GetNumKeys() == 3);
+    EXPECT_EQ(err, CHIP_ERROR_INCORRECT_STATE);
+    EXPECT_FALSE(opCertStore.HasPendingRootCert());
+    EXPECT_TRUE(opCertStore.HasPendingNocChain());
+    EXPECT_EQ(storageDelegate.GetNumKeys(), 3u);
 
     // Trying to add new opcerts for any fabric after update, before commit/revert fails
     err = opCertStore.AddNewOpCertsForFabric(kFabricIndex1, kTestNocSpan, kTestIcacSpan);
-    NL_TEST_ASSERT(inSuite, err == CHIP_ERROR_INCORRECT_STATE);
+    EXPECT_EQ(err, CHIP_ERROR_INCORRECT_STATE);
 
     err = opCertStore.AddNewOpCertsForFabric(kFabricIndex2, kTestNocSpan, kTestIcacSpan);
-    NL_TEST_ASSERT(inSuite, err == CHIP_ERROR_INCORRECT_STATE);
+    EXPECT_EQ(err, CHIP_ERROR_INCORRECT_STATE);
 
     // Committing writes the new values (we even "background-remove" the old ICAC/NOC before commit)
     storageDelegate.SyncDeleteKeyValue(DefaultStorageKeyAllocator::FabricICAC(kFabricIndex1).KeyName());
     storageDelegate.SyncDeleteKeyValue(DefaultStorageKeyAllocator::FabricNOC(kFabricIndex1).KeyName());
-    NL_TEST_ASSERT(inSuite, storageDelegate.GetNumKeys() == 1); //< Root remains
+    EXPECT_EQ(storageDelegate.GetNumKeys(), 1u); //< Root remains
 
     err = opCertStore.CommitOpCertsForFabric(kFabricIndex1);
-    NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
-    NL_TEST_ASSERT(inSuite, !opCertStore.HasPendingNocChain());
-    NL_TEST_ASSERT(inSuite, !opCertStore.HasPendingRootCert());
-    NL_TEST_ASSERT(inSuite, storageDelegate.GetNumKeys() == 3); //< All certs now committed
+    EXPECT_EQ(err, CHIP_NO_ERROR);
+    EXPECT_FALSE(opCertStore.HasPendingNocChain());
+    EXPECT_FALSE(opCertStore.HasPendingRootCert());
+    EXPECT_EQ(storageDelegate.GetNumKeys(), 3u); //< All certs now committed
 
     // Should be able to get the committed cert even if not in persisted storage, after an API error
     largeSpan = MutableByteSpan{ largeBuf };
     err       = opCertStore.GetCertificate(kFabricIndex1, CertChainElement::kRcac, largeSpan);
-    NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
-    NL_TEST_ASSERT(inSuite, largeSpan.data_equal(ByteSpan{ kTestRcacBufExists }));
+    EXPECT_EQ(err, CHIP_NO_ERROR);
+    EXPECT_TRUE(largeSpan.data_equal(ByteSpan{ kTestRcacBufExists }));
 
     largeSpan = MutableByteSpan{ largeBuf };
     err       = opCertStore.GetCertificate(kFabricIndex1, CertChainElement::kIcac, largeSpan);
-    NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
-    NL_TEST_ASSERT(inSuite, largeSpan.data_equal(ByteSpan{ kTestIcacSpan }));
+    EXPECT_EQ(err, CHIP_NO_ERROR);
+    EXPECT_TRUE(largeSpan.data_equal(ByteSpan{ kTestIcacSpan }));
 
     largeSpan = MutableByteSpan{ largeBuf };
     err       = opCertStore.GetCertificate(kFabricIndex1, CertChainElement::kNoc, largeSpan);
-    NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
-    NL_TEST_ASSERT(inSuite, largeSpan.data_equal(ByteSpan{ kTestNocSpan }));
+    EXPECT_EQ(err, CHIP_NO_ERROR);
+    EXPECT_TRUE(largeSpan.data_equal(ByteSpan{ kTestNocSpan }));
 
     // Calling revert doesn't undo the work we just did
     opCertStore.RevertPendingOpCerts();
-    NL_TEST_ASSERT(inSuite, storageDelegate.GetNumKeys() == 3); //< All certs now committed
+    EXPECT_EQ(storageDelegate.GetNumKeys(), 3u); //< All certs now committed
 
     // Verify the revert after commit left all data alone
     largeSpan = MutableByteSpan{ largeBuf };
     err       = opCertStore.GetCertificate(kFabricIndex1, CertChainElement::kRcac, largeSpan);
-    NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
-    NL_TEST_ASSERT(inSuite, largeSpan.data_equal(ByteSpan{ kTestRcacBufExists }));
+    EXPECT_EQ(err, CHIP_NO_ERROR);
+    EXPECT_TRUE(largeSpan.data_equal(ByteSpan{ kTestRcacBufExists }));
 
     largeSpan = MutableByteSpan{ largeBuf };
     err       = opCertStore.GetCertificate(kFabricIndex1, CertChainElement::kIcac, largeSpan);
-    NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
-    NL_TEST_ASSERT(inSuite, largeSpan.data_equal(ByteSpan{ kTestIcacSpan }));
+    EXPECT_EQ(err, CHIP_NO_ERROR);
+    EXPECT_TRUE(largeSpan.data_equal(ByteSpan{ kTestIcacSpan }));
 
     largeSpan = MutableByteSpan{ largeBuf };
     err       = opCertStore.GetCertificate(kFabricIndex1, CertChainElement::kNoc, largeSpan);
-    NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
-    NL_TEST_ASSERT(inSuite, largeSpan.data_equal(ByteSpan{ kTestNocSpan }));
+    EXPECT_EQ(err, CHIP_NO_ERROR);
+    EXPECT_TRUE(largeSpan.data_equal(ByteSpan{ kTestNocSpan }));
 
     // Verify that RemoveOpCertsForFabric fails on fabric with no data
     err = opCertStore.RemoveOpCertsForFabric(kFabricIndex2);
-    NL_TEST_ASSERT(inSuite, err == CHIP_ERROR_INVALID_FABRIC_INDEX);
-    NL_TEST_ASSERT(inSuite, storageDelegate.GetNumKeys() == 3);
+    EXPECT_EQ(err, CHIP_ERROR_INVALID_FABRIC_INDEX);
+    EXPECT_EQ(storageDelegate.GetNumKeys(), 3u);
 
     // Verify that RemoveOpCertsForFabric works for fabric we just updated
     err = opCertStore.RemoveOpCertsForFabric(kFabricIndex1);
-    NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
-    NL_TEST_ASSERT(inSuite, storageDelegate.GetNumKeys() == 0); // All keys gone
+    EXPECT_EQ(err, CHIP_NO_ERROR);
+    EXPECT_EQ(storageDelegate.GetNumKeys(), 0u); // All keys gone
 
     opCertStore.Finish();
 }
 
-void TestReverts(nlTestSuite * inSuite, void * inContext)
+TEST_F(TestPersistentStorageOpCertStore, TestReverts)
 {
     TestPersistentStorageDelegate storageDelegate;
     PersistentStorageOpCertStore opCertStore;
 
     // Failure before Init
     CHIP_ERROR err = opCertStore.RemoveOpCertsForFabric(kFabricIndex1);
-    NL_TEST_ASSERT(inSuite, err == CHIP_ERROR_INCORRECT_STATE);
-    NL_TEST_ASSERT(inSuite, storageDelegate.GetNumKeys() == 0);
+    EXPECT_EQ(err, CHIP_ERROR_INCORRECT_STATE);
+    EXPECT_EQ(storageDelegate.GetNumKeys(), 0u);
 
     // Init succeeds
     err = opCertStore.Init(&storageDelegate);
-    NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
+    EXPECT_EQ(err, CHIP_NO_ERROR);
 
     // Add a new pending trusted root
     uint8_t largeBuf[400];
     MutableByteSpan largeSpan{ largeBuf };
 
     err = opCertStore.AddNewTrustedRootCertForFabric(kFabricIndex1, kTestRcacSpan);
-    NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
-    NL_TEST_ASSERT(inSuite, storageDelegate.GetNumKeys() == 0); //< Storage count did not yet increase
-    NL_TEST_ASSERT(inSuite, opCertStore.HasPendingRootCert() == true);
-    NL_TEST_ASSERT(inSuite, !opCertStore.HasPendingNocChain());
+    EXPECT_EQ(err, CHIP_NO_ERROR);
+    EXPECT_EQ(storageDelegate.GetNumKeys(), 0u); //< Storage count did not yet increase
+    EXPECT_TRUE(opCertStore.HasPendingRootCert());
+    EXPECT_FALSE(opCertStore.HasPendingNocChain());
 
     // Verify we can see the new trusted root
     largeSpan = MutableByteSpan{ largeBuf };
     err       = opCertStore.GetCertificate(kFabricIndex1, CertChainElement::kRcac, largeSpan);
-    NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
-    NL_TEST_ASSERT(inSuite, largeSpan.data_equal(kTestRcacSpan));
+    EXPECT_EQ(err, CHIP_NO_ERROR);
+    EXPECT_TRUE(largeSpan.data_equal(kTestRcacSpan));
 
     // Verify that after revert, we can't see the root anymore
     opCertStore.RevertPendingOpCerts();
-    NL_TEST_ASSERT(inSuite, !opCertStore.HasPendingRootCert());
-    NL_TEST_ASSERT(inSuite, storageDelegate.GetNumKeys() == 0); //< Storage count did not yet increase
+    EXPECT_FALSE(opCertStore.HasPendingRootCert());
+    EXPECT_EQ(storageDelegate.GetNumKeys(), 0u); //< Storage count did not yet increase
 
     largeSpan = MutableByteSpan{ largeBuf };
     err       = opCertStore.GetCertificate(kFabricIndex1, CertChainElement::kRcac, largeSpan);
-    NL_TEST_ASSERT(inSuite, err == CHIP_ERROR_NOT_FOUND);
+    EXPECT_EQ(err, CHIP_ERROR_NOT_FOUND);
 
     {
         // Add new root again, to then test review of AddNewTrustedCertificates
         err = opCertStore.AddNewTrustedRootCertForFabric(kFabricIndex1, kTestRcacSpan);
-        NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
-        NL_TEST_ASSERT(inSuite, storageDelegate.GetNumKeys() == 0); //< Storage count did not yet increase
-        NL_TEST_ASSERT(inSuite, opCertStore.HasPendingRootCert() == true);
-        NL_TEST_ASSERT(inSuite, !opCertStore.HasPendingNocChain());
+        EXPECT_EQ(err, CHIP_NO_ERROR);
+        EXPECT_EQ(storageDelegate.GetNumKeys(), 0u); //< Storage count did not yet increase
+        EXPECT_TRUE(opCertStore.HasPendingRootCert());
+        EXPECT_FALSE(opCertStore.HasPendingNocChain());
 
         // Add NOC chain
         err = opCertStore.AddNewOpCertsForFabric(kFabricIndex1, kTestNocSpan, kTestIcacSpan);
-        NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
-        NL_TEST_ASSERT(inSuite, opCertStore.HasPendingNocChain());
-        NL_TEST_ASSERT(inSuite, opCertStore.HasPendingRootCert() == true);
-        NL_TEST_ASSERT(inSuite, storageDelegate.GetNumKeys() == 0); //< Storage count did not yet increase
+        EXPECT_EQ(err, CHIP_NO_ERROR);
+        EXPECT_TRUE(opCertStore.HasPendingNocChain());
+        EXPECT_TRUE(opCertStore.HasPendingRootCert());
+        EXPECT_EQ(storageDelegate.GetNumKeys(), 0u); //< Storage count did not yet increase
     }
 
     // Make sure we can see all pending certs before revert
     {
         largeSpan = MutableByteSpan{ largeBuf };
         err       = opCertStore.GetCertificate(kFabricIndex1, CertChainElement::kRcac, largeSpan);
-        NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
-        NL_TEST_ASSERT(inSuite, largeSpan.data_equal(kTestRcacSpan));
+        EXPECT_EQ(err, CHIP_NO_ERROR);
+        EXPECT_TRUE(largeSpan.data_equal(kTestRcacSpan));
 
         largeSpan = MutableByteSpan{ largeBuf };
         err       = opCertStore.GetCertificate(kFabricIndex1, CertChainElement::kIcac, largeSpan);
-        NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
-        NL_TEST_ASSERT(inSuite, largeSpan.data_equal(kTestIcacSpan));
+        EXPECT_EQ(err, CHIP_NO_ERROR);
+        EXPECT_TRUE(largeSpan.data_equal(kTestIcacSpan));
 
         largeSpan = MutableByteSpan{ largeBuf };
         err       = opCertStore.GetCertificate(kFabricIndex1, CertChainElement::kNoc, largeSpan);
-        NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
-        NL_TEST_ASSERT(inSuite, largeSpan.data_equal(kTestNocSpan));
+        EXPECT_EQ(err, CHIP_NO_ERROR);
+        EXPECT_TRUE(largeSpan.data_equal(kTestNocSpan));
     }
 
     // Revert
     opCertStore.RevertPendingOpCerts();
-    NL_TEST_ASSERT(inSuite, !opCertStore.HasPendingRootCert());
-    NL_TEST_ASSERT(inSuite, !opCertStore.HasPendingNocChain());
-    NL_TEST_ASSERT(inSuite, storageDelegate.GetNumKeys() == 0); //< Storage count did not yet increase
+    EXPECT_FALSE(opCertStore.HasPendingRootCert());
+    EXPECT_FALSE(opCertStore.HasPendingNocChain());
+    EXPECT_EQ(storageDelegate.GetNumKeys(), 0u); //< Storage count did not yet increase
 
     // Verify that after revert, we can't see the root or chain anymore
     {
         largeSpan = MutableByteSpan{ largeBuf };
         err       = opCertStore.GetCertificate(kFabricIndex1, CertChainElement::kRcac, largeSpan);
-        NL_TEST_ASSERT(inSuite, err == CHIP_ERROR_NOT_FOUND);
+        EXPECT_EQ(err, CHIP_ERROR_NOT_FOUND);
 
         largeSpan = MutableByteSpan{ largeBuf };
         err       = opCertStore.GetCertificate(kFabricIndex1, CertChainElement::kIcac, largeSpan);
-        NL_TEST_ASSERT(inSuite, err == CHIP_ERROR_NOT_FOUND);
+        EXPECT_EQ(err, CHIP_ERROR_NOT_FOUND);
 
         largeSpan = MutableByteSpan{ largeBuf };
         err       = opCertStore.GetCertificate(kFabricIndex1, CertChainElement::kNoc, largeSpan);
-        NL_TEST_ASSERT(inSuite, err == CHIP_ERROR_NOT_FOUND);
+        EXPECT_EQ(err, CHIP_ERROR_NOT_FOUND);
     }
 
     // Start again to add a new set, but then let's commit
     {
         // Add new root again, to then test review of AddNewTrustedCertificates
         err = opCertStore.AddNewTrustedRootCertForFabric(kFabricIndex1, kTestRcacSpan);
-        NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
-        NL_TEST_ASSERT(inSuite, storageDelegate.GetNumKeys() == 0); //< Storage count did not yet increase
-        NL_TEST_ASSERT(inSuite, opCertStore.HasPendingRootCert() == true);
-        NL_TEST_ASSERT(inSuite, !opCertStore.HasPendingNocChain());
+        EXPECT_EQ(err, CHIP_NO_ERROR);
+        EXPECT_EQ(storageDelegate.GetNumKeys(), 0u); //< Storage count did not yet increase
+        EXPECT_TRUE(opCertStore.HasPendingRootCert());
+        EXPECT_FALSE(opCertStore.HasPendingNocChain());
 
         // Add NOC chain
         err = opCertStore.AddNewOpCertsForFabric(kFabricIndex1, kTestNocSpan, kTestIcacSpan);
-        NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
-        NL_TEST_ASSERT(inSuite, opCertStore.HasPendingNocChain());
-        NL_TEST_ASSERT(inSuite, opCertStore.HasPendingRootCert() == true);
-        NL_TEST_ASSERT(inSuite, storageDelegate.GetNumKeys() == 0); //< Storage count did not yet increase
+        EXPECT_EQ(err, CHIP_NO_ERROR);
+        EXPECT_TRUE(opCertStore.HasPendingNocChain());
+        EXPECT_TRUE(opCertStore.HasPendingRootCert());
+        EXPECT_EQ(storageDelegate.GetNumKeys(), 0u); //< Storage count did not yet increase
     }
 
     // Commiting new certs should succeed on correct fabric
     err = opCertStore.CommitOpCertsForFabric(kFabricIndex1);
-    NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
-    NL_TEST_ASSERT(inSuite, !opCertStore.HasPendingNocChain());
-    NL_TEST_ASSERT(inSuite, !opCertStore.HasPendingRootCert());
+    EXPECT_EQ(err, CHIP_NO_ERROR);
+    EXPECT_FALSE(opCertStore.HasPendingNocChain());
+    EXPECT_FALSE(opCertStore.HasPendingRootCert());
 
-    NL_TEST_ASSERT(inSuite, storageDelegate.GetNumKeys() == 3); //< All certs now committed
+    EXPECT_EQ(storageDelegate.GetNumKeys(), 3u); //< All certs now committed
 
     // Should be able to get the committed certs
     {
         largeSpan = MutableByteSpan{ largeBuf };
         err       = opCertStore.GetCertificate(kFabricIndex1, CertChainElement::kRcac, largeSpan);
-        NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
-        NL_TEST_ASSERT(inSuite, largeSpan.data_equal(ByteSpan{ kTestRcacSpan }));
+        EXPECT_EQ(err, CHIP_NO_ERROR);
+        EXPECT_TRUE(largeSpan.data_equal(ByteSpan{ kTestRcacSpan }));
 
         largeSpan = MutableByteSpan{ largeBuf };
         err       = opCertStore.GetCertificate(kFabricIndex1, CertChainElement::kIcac, largeSpan);
-        NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
-        NL_TEST_ASSERT(inSuite, largeSpan.data_equal(ByteSpan{ kTestIcacSpan }));
+        EXPECT_EQ(err, CHIP_NO_ERROR);
+        EXPECT_TRUE(largeSpan.data_equal(ByteSpan{ kTestIcacSpan }));
 
         largeSpan = MutableByteSpan{ largeBuf };
         err       = opCertStore.GetCertificate(kFabricIndex1, CertChainElement::kNoc, largeSpan);
-        NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
-        NL_TEST_ASSERT(inSuite, largeSpan.data_equal(ByteSpan{ kTestNocSpan }));
+        EXPECT_EQ(err, CHIP_NO_ERROR);
+        EXPECT_TRUE(largeSpan.data_equal(ByteSpan{ kTestNocSpan }));
     }
 
     const uint8_t kNewNoc[] = { 'n', 'o', 'c', ' ', 'n', 'e', 'w' };
 
     // Updating certs should work (NO ICAC)
     err = opCertStore.UpdateOpCertsForFabric(kFabricIndex1, ByteSpan{ kNewNoc }, ByteSpan{});
-    NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
-    NL_TEST_ASSERT(inSuite, !opCertStore.HasPendingRootCert());
-    NL_TEST_ASSERT(inSuite, opCertStore.HasPendingNocChain());
-    NL_TEST_ASSERT(inSuite, storageDelegate.GetNumKeys() == 3); //< No change to keys
+    EXPECT_EQ(err, CHIP_NO_ERROR);
+    EXPECT_FALSE(opCertStore.HasPendingRootCert());
+    EXPECT_TRUE(opCertStore.HasPendingNocChain());
+    EXPECT_EQ(storageDelegate.GetNumKeys(), 3u); //< No change to keys
 
     // Should see committed root, pending NOC, absent ICAC
     {
         largeSpan = MutableByteSpan{ largeBuf };
         err       = opCertStore.GetCertificate(kFabricIndex1, CertChainElement::kRcac, largeSpan);
-        NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
-        NL_TEST_ASSERT(inSuite, largeSpan.data_equal(ByteSpan{ kTestRcacSpan }));
+        EXPECT_EQ(err, CHIP_NO_ERROR);
+        EXPECT_TRUE(largeSpan.data_equal(ByteSpan{ kTestRcacSpan }));
 
         largeSpan = MutableByteSpan{ largeBuf };
         err       = opCertStore.GetCertificate(kFabricIndex1, CertChainElement::kIcac, largeSpan);
-        NL_TEST_ASSERT(inSuite, err == CHIP_ERROR_NOT_FOUND);
-        NL_TEST_ASSERT(inSuite, !opCertStore.HasCertificateForFabric(kFabricIndex1, CertChainElement::kIcac));
+        EXPECT_EQ(err, CHIP_ERROR_NOT_FOUND);
+        EXPECT_FALSE(opCertStore.HasCertificateForFabric(kFabricIndex1, CertChainElement::kIcac));
 
         largeSpan = MutableByteSpan{ largeBuf };
         err       = opCertStore.GetCertificate(kFabricIndex1, CertChainElement::kNoc, largeSpan);
-        NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
-        NL_TEST_ASSERT(inSuite, largeSpan.data_equal(ByteSpan{ kNewNoc }));
+        EXPECT_EQ(err, CHIP_NO_ERROR);
+        EXPECT_TRUE(largeSpan.data_equal(ByteSpan{ kNewNoc }));
     }
 
     // Revert, should be back at previous state
     opCertStore.RevertPendingOpCerts();
-    NL_TEST_ASSERT(inSuite, !opCertStore.HasPendingRootCert());
-    NL_TEST_ASSERT(inSuite, !opCertStore.HasPendingNocChain());
-    NL_TEST_ASSERT(inSuite, storageDelegate.GetNumKeys() == 3); //< Storage count did not yet change
+    EXPECT_FALSE(opCertStore.HasPendingRootCert());
+    EXPECT_FALSE(opCertStore.HasPendingNocChain());
+    EXPECT_EQ(storageDelegate.GetNumKeys(), 3u); //< Storage count did not yet change
 
     // Should be able to get the previously committed certs
     {
         largeSpan = MutableByteSpan{ largeBuf };
         err       = opCertStore.GetCertificate(kFabricIndex1, CertChainElement::kRcac, largeSpan);
-        NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
-        NL_TEST_ASSERT(inSuite, largeSpan.data_equal(ByteSpan{ kTestRcacSpan }));
+        EXPECT_EQ(err, CHIP_NO_ERROR);
+        EXPECT_TRUE(largeSpan.data_equal(ByteSpan{ kTestRcacSpan }));
 
         largeSpan = MutableByteSpan{ largeBuf };
         err       = opCertStore.GetCertificate(kFabricIndex1, CertChainElement::kIcac, largeSpan);
-        NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
-        NL_TEST_ASSERT(inSuite, largeSpan.data_equal(ByteSpan{ kTestIcacSpan }));
+        EXPECT_EQ(err, CHIP_NO_ERROR);
+        EXPECT_TRUE(largeSpan.data_equal(ByteSpan{ kTestIcacSpan }));
 
         largeSpan = MutableByteSpan{ largeBuf };
         err       = opCertStore.GetCertificate(kFabricIndex1, CertChainElement::kNoc, largeSpan);
-        NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
-        NL_TEST_ASSERT(inSuite, largeSpan.data_equal(ByteSpan{ kTestNocSpan }));
+        EXPECT_EQ(err, CHIP_NO_ERROR);
+        EXPECT_TRUE(largeSpan.data_equal(ByteSpan{ kTestNocSpan }));
     }
 
     // Try again to update with missing ICAC and commit
     err = opCertStore.UpdateOpCertsForFabric(kFabricIndex1, ByteSpan{ kNewNoc }, ByteSpan{});
-    NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
-    NL_TEST_ASSERT(inSuite, !opCertStore.HasPendingRootCert());
-    NL_TEST_ASSERT(inSuite, opCertStore.HasPendingNocChain());
-    NL_TEST_ASSERT(inSuite, storageDelegate.GetNumKeys() == 3); //< No change to keys
+    EXPECT_EQ(err, CHIP_NO_ERROR);
+    EXPECT_FALSE(opCertStore.HasPendingRootCert());
+    EXPECT_TRUE(opCertStore.HasPendingNocChain());
+    EXPECT_EQ(storageDelegate.GetNumKeys(), 3u); //< No change to keys
 
     err = opCertStore.CommitOpCertsForFabric(kFabricIndex1);
-    NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
-    NL_TEST_ASSERT(inSuite, !opCertStore.HasPendingRootCert());
-    NL_TEST_ASSERT(inSuite, !opCertStore.HasPendingNocChain());
-    NL_TEST_ASSERT(inSuite, storageDelegate.GetNumKeys() == 2); //< ICAC cert should be gone
+    EXPECT_EQ(err, CHIP_NO_ERROR);
+    EXPECT_FALSE(opCertStore.HasPendingRootCert());
+    EXPECT_FALSE(opCertStore.HasPendingNocChain());
+    EXPECT_EQ(storageDelegate.GetNumKeys(), 2u); //< ICAC cert should be gone
 
     // Should see committed root, new NOC, absent ICAC
     {
         largeSpan = MutableByteSpan{ largeBuf };
         err       = opCertStore.GetCertificate(kFabricIndex1, CertChainElement::kRcac, largeSpan);
-        NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
-        NL_TEST_ASSERT(inSuite, largeSpan.data_equal(ByteSpan{ kTestRcacSpan }));
-        NL_TEST_ASSERT(inSuite, opCertStore.HasCertificateForFabric(kFabricIndex1, CertChainElement::kRcac));
+        EXPECT_EQ(err, CHIP_NO_ERROR);
+        EXPECT_TRUE(largeSpan.data_equal(ByteSpan{ kTestRcacSpan }));
+        EXPECT_TRUE(opCertStore.HasCertificateForFabric(kFabricIndex1, CertChainElement::kRcac));
 
         largeSpan = MutableByteSpan{ largeBuf };
         err       = opCertStore.GetCertificate(kFabricIndex1, CertChainElement::kIcac, largeSpan);
-        NL_TEST_ASSERT(inSuite, err == CHIP_ERROR_NOT_FOUND);
-        NL_TEST_ASSERT(inSuite, !opCertStore.HasCertificateForFabric(kFabricIndex1, CertChainElement::kIcac));
+        EXPECT_EQ(err, CHIP_ERROR_NOT_FOUND);
+        EXPECT_FALSE(opCertStore.HasCertificateForFabric(kFabricIndex1, CertChainElement::kIcac));
 
         largeSpan = MutableByteSpan{ largeBuf };
         err       = opCertStore.GetCertificate(kFabricIndex1, CertChainElement::kNoc, largeSpan);
-        NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
-        NL_TEST_ASSERT(inSuite, largeSpan.data_equal(ByteSpan{ kNewNoc }));
-        NL_TEST_ASSERT(inSuite, opCertStore.HasCertificateForFabric(kFabricIndex1, CertChainElement::kNoc));
+        EXPECT_EQ(err, CHIP_NO_ERROR);
+        EXPECT_TRUE(largeSpan.data_equal(ByteSpan{ kNewNoc }));
+        EXPECT_TRUE(opCertStore.HasCertificateForFabric(kFabricIndex1, CertChainElement::kNoc));
     }
 
     opCertStore.Finish();
 }
 
-void TestRevertAddNoc(nlTestSuite * inSuite, void * inContext)
+TEST_F(TestPersistentStorageOpCertStore, TestRevertAddNoc)
 {
     TestPersistentStorageDelegate storageDelegate;
     PersistentStorageOpCertStore opCertStore;
 
     // Init succeeds
     CHIP_ERROR err = opCertStore.Init(&storageDelegate);
-    NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
+    EXPECT_EQ(err, CHIP_NO_ERROR);
 
     // Add a new pending trusted root
     uint8_t largeBuf[400];
@@ -646,63 +646,63 @@
     {
         // Add new root
         err = opCertStore.AddNewTrustedRootCertForFabric(kFabricIndex1, kTestRcacSpan);
-        NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
-        NL_TEST_ASSERT(inSuite, storageDelegate.GetNumKeys() == 0); //< Storage count did not yet increase
-        NL_TEST_ASSERT(inSuite, opCertStore.HasPendingRootCert() == true);
-        NL_TEST_ASSERT(inSuite, !opCertStore.HasPendingNocChain());
+        EXPECT_EQ(err, CHIP_NO_ERROR);
+        EXPECT_EQ(storageDelegate.GetNumKeys(), 0u); //< Storage count did not yet increase
+        EXPECT_TRUE(opCertStore.HasPendingRootCert());
+        EXPECT_FALSE(opCertStore.HasPendingNocChain());
 
         // Add NOC chain, with NO ICAC
         err = opCertStore.AddNewOpCertsForFabric(kFabricIndex1, kTestNocSpan, ByteSpan{});
-        NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
-        NL_TEST_ASSERT(inSuite, opCertStore.HasPendingNocChain());
-        NL_TEST_ASSERT(inSuite, opCertStore.HasPendingRootCert() == true);
-        NL_TEST_ASSERT(inSuite, storageDelegate.GetNumKeys() == 0); //< Storage count did not yet increase
+        EXPECT_EQ(err, CHIP_NO_ERROR);
+        EXPECT_TRUE(opCertStore.HasPendingNocChain());
+        EXPECT_TRUE(opCertStore.HasPendingRootCert());
+        EXPECT_EQ(storageDelegate.GetNumKeys(), 0u); //< Storage count did not yet increase
     }
 
     // Make sure we get expected pending state before revert
     {
         largeSpan = MutableByteSpan{ largeBuf };
         err       = opCertStore.GetCertificate(kFabricIndex1, CertChainElement::kRcac, largeSpan);
-        NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
-        NL_TEST_ASSERT(inSuite, largeSpan.data_equal(kTestRcacSpan));
+        EXPECT_EQ(err, CHIP_NO_ERROR);
+        EXPECT_TRUE(largeSpan.data_equal(kTestRcacSpan));
 
         largeSpan = MutableByteSpan{ largeBuf };
         err       = opCertStore.GetCertificate(kFabricIndex1, CertChainElement::kIcac, largeSpan);
-        NL_TEST_ASSERT(inSuite, err == CHIP_ERROR_NOT_FOUND);
+        EXPECT_EQ(err, CHIP_ERROR_NOT_FOUND);
 
         largeSpan = MutableByteSpan{ largeBuf };
         err       = opCertStore.GetCertificate(kFabricIndex1, CertChainElement::kNoc, largeSpan);
-        NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
-        NL_TEST_ASSERT(inSuite, largeSpan.data_equal(kTestNocSpan));
+        EXPECT_EQ(err, CHIP_NO_ERROR);
+        EXPECT_TRUE(largeSpan.data_equal(kTestNocSpan));
     }
 
     // Revert using RemoveOpCertsForFabric
     err = opCertStore.RemoveOpCertsForFabric(kFabricIndex1);
-    NL_TEST_ASSERT(inSuite, !opCertStore.HasPendingRootCert());
-    NL_TEST_ASSERT(inSuite, !opCertStore.HasPendingNocChain());
-    NL_TEST_ASSERT(inSuite, storageDelegate.GetNumKeys() == 0); //< Storage count did not yet increase
+    EXPECT_FALSE(opCertStore.HasPendingRootCert());
+    EXPECT_FALSE(opCertStore.HasPendingNocChain());
+    EXPECT_EQ(storageDelegate.GetNumKeys(), 0u); //< Storage count did not yet increase
 
     // Add again, and commit
     {
         // Add new root
         err = opCertStore.AddNewTrustedRootCertForFabric(kFabricIndex1, kTestRcacSpan);
-        NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
-        NL_TEST_ASSERT(inSuite, storageDelegate.GetNumKeys() == 0); //< Storage count did not yet increase
-        NL_TEST_ASSERT(inSuite, opCertStore.HasPendingRootCert() == true);
-        NL_TEST_ASSERT(inSuite, !opCertStore.HasPendingNocChain());
+        EXPECT_EQ(err, CHIP_NO_ERROR);
+        EXPECT_EQ(storageDelegate.GetNumKeys(), 0u); //< Storage count did not yet increase
+        EXPECT_TRUE(opCertStore.HasPendingRootCert());
+        EXPECT_FALSE(opCertStore.HasPendingNocChain());
 
         // Add NOC chain, with NO ICAC
         err = opCertStore.AddNewOpCertsForFabric(kFabricIndex1, kTestNocSpan, ByteSpan{});
-        NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
-        NL_TEST_ASSERT(inSuite, opCertStore.HasPendingNocChain());
-        NL_TEST_ASSERT(inSuite, opCertStore.HasPendingRootCert() == true);
-        NL_TEST_ASSERT(inSuite, storageDelegate.GetNumKeys() == 0); //< Storage count did not yet increase
+        EXPECT_EQ(err, CHIP_NO_ERROR);
+        EXPECT_TRUE(opCertStore.HasPendingNocChain());
+        EXPECT_TRUE(opCertStore.HasPendingRootCert());
+        EXPECT_EQ(storageDelegate.GetNumKeys(), 0u); //< Storage count did not yet increase
 
         err = opCertStore.CommitOpCertsForFabric(kFabricIndex1);
-        NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
-        NL_TEST_ASSERT(inSuite, !opCertStore.HasPendingRootCert());
-        NL_TEST_ASSERT(inSuite, !opCertStore.HasPendingNocChain());
-        NL_TEST_ASSERT(inSuite, storageDelegate.GetNumKeys() == 2); //< We have RCAC, NOC, no ICAC
+        EXPECT_EQ(err, CHIP_NO_ERROR);
+        EXPECT_FALSE(opCertStore.HasPendingRootCert());
+        EXPECT_FALSE(opCertStore.HasPendingNocChain());
+        EXPECT_EQ(storageDelegate.GetNumKeys(), 2u); //< We have RCAC, NOC, no ICAC
     }
 
     // Update to add an ICAC
@@ -711,65 +711,65 @@
 
     // Updating certs should work (NO ICAC)
     err = opCertStore.UpdateOpCertsForFabric(kFabricIndex1, ByteSpan{ kNewNoc }, ByteSpan{ kNewIcac });
-    NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
-    NL_TEST_ASSERT(inSuite, !opCertStore.HasPendingRootCert());
-    NL_TEST_ASSERT(inSuite, opCertStore.HasPendingNocChain());
-    NL_TEST_ASSERT(inSuite, storageDelegate.GetNumKeys() == 2); //< No change to keys
+    EXPECT_EQ(err, CHIP_NO_ERROR);
+    EXPECT_FALSE(opCertStore.HasPendingRootCert());
+    EXPECT_TRUE(opCertStore.HasPendingNocChain());
+    EXPECT_EQ(storageDelegate.GetNumKeys(), 2u); //< No change to keys
 
     // Should see committed root, pending NOC, pending ICAC
     {
         largeSpan = MutableByteSpan{ largeBuf };
         err       = opCertStore.GetCertificate(kFabricIndex1, CertChainElement::kRcac, largeSpan);
-        NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
-        NL_TEST_ASSERT(inSuite, largeSpan.data_equal(ByteSpan{ kTestRcacSpan }));
+        EXPECT_EQ(err, CHIP_NO_ERROR);
+        EXPECT_TRUE(largeSpan.data_equal(ByteSpan{ kTestRcacSpan }));
 
         largeSpan = MutableByteSpan{ largeBuf };
         err       = opCertStore.GetCertificate(kFabricIndex1, CertChainElement::kIcac, largeSpan);
-        NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
-        NL_TEST_ASSERT(inSuite, largeSpan.data_equal(ByteSpan{ kNewIcac }));
+        EXPECT_EQ(err, CHIP_NO_ERROR);
+        EXPECT_TRUE(largeSpan.data_equal(ByteSpan{ kNewIcac }));
 
         largeSpan = MutableByteSpan{ largeBuf };
         err       = opCertStore.GetCertificate(kFabricIndex1, CertChainElement::kNoc, largeSpan);
-        NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
-        NL_TEST_ASSERT(inSuite, largeSpan.data_equal(ByteSpan{ kNewNoc }));
+        EXPECT_EQ(err, CHIP_NO_ERROR);
+        EXPECT_TRUE(largeSpan.data_equal(ByteSpan{ kNewNoc }));
     }
 
     // Commit, should see the new ICAC appear.
     err = opCertStore.CommitOpCertsForFabric(kFabricIndex1);
-    NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
-    NL_TEST_ASSERT(inSuite, !opCertStore.HasPendingRootCert());
-    NL_TEST_ASSERT(inSuite, !opCertStore.HasPendingNocChain());
-    NL_TEST_ASSERT(inSuite, storageDelegate.GetNumKeys() == 3); //< We have RCAC, NOC, ICAC
+    EXPECT_EQ(err, CHIP_NO_ERROR);
+    EXPECT_FALSE(opCertStore.HasPendingRootCert());
+    EXPECT_FALSE(opCertStore.HasPendingNocChain());
+    EXPECT_EQ(storageDelegate.GetNumKeys(), 3u); //< We have RCAC, NOC, ICAC
 
     // Should see committed root, new NOC, new ICAC
     {
         largeSpan = MutableByteSpan{ largeBuf };
         err       = opCertStore.GetCertificate(kFabricIndex1, CertChainElement::kRcac, largeSpan);
-        NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
-        NL_TEST_ASSERT(inSuite, largeSpan.data_equal(ByteSpan{ kTestRcacSpan }));
+        EXPECT_EQ(err, CHIP_NO_ERROR);
+        EXPECT_TRUE(largeSpan.data_equal(ByteSpan{ kTestRcacSpan }));
 
         largeSpan = MutableByteSpan{ largeBuf };
         err       = opCertStore.GetCertificate(kFabricIndex1, CertChainElement::kIcac, largeSpan);
-        NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
-        NL_TEST_ASSERT(inSuite, largeSpan.data_equal(ByteSpan{ kNewIcac }));
+        EXPECT_EQ(err, CHIP_NO_ERROR);
+        EXPECT_TRUE(largeSpan.data_equal(ByteSpan{ kNewIcac }));
 
         largeSpan = MutableByteSpan{ largeBuf };
         err       = opCertStore.GetCertificate(kFabricIndex1, CertChainElement::kNoc, largeSpan);
-        NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
-        NL_TEST_ASSERT(inSuite, largeSpan.data_equal(ByteSpan{ kNewNoc }));
+        EXPECT_EQ(err, CHIP_NO_ERROR);
+        EXPECT_TRUE(largeSpan.data_equal(ByteSpan{ kNewNoc }));
     }
 
     opCertStore.Finish();
 }
 
-void TestRevertPendingOpCertsExceptRoot(nlTestSuite * inSuite, void * inContext)
+TEST_F(TestPersistentStorageOpCertStore, TestRevertPendingOpCertsExceptRoot)
 {
     TestPersistentStorageDelegate storageDelegate;
     PersistentStorageOpCertStore opCertStore;
 
     // Init succeeds
     CHIP_ERROR err = opCertStore.Init(&storageDelegate);
-    NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
+    EXPECT_EQ(err, CHIP_NO_ERROR);
 
     // Add a new pending trusted root
     uint8_t largeBuf[400];
@@ -778,111 +778,66 @@
     {
         // Add new root
         err = opCertStore.AddNewTrustedRootCertForFabric(kFabricIndex1, kTestRcacSpan);
-        NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
-        NL_TEST_ASSERT(inSuite, storageDelegate.GetNumKeys() == 0); //< Storage count did not yet increase
-        NL_TEST_ASSERT(inSuite, opCertStore.HasPendingRootCert() == true);
-        NL_TEST_ASSERT(inSuite, !opCertStore.HasPendingNocChain());
+        EXPECT_EQ(err, CHIP_NO_ERROR);
+        EXPECT_EQ(storageDelegate.GetNumKeys(), 0u); //< Storage count did not yet increase
+        EXPECT_TRUE(opCertStore.HasPendingRootCert());
+        EXPECT_FALSE(opCertStore.HasPendingNocChain());
 
         // Add NOC chain, with NO ICAC
         err = opCertStore.AddNewOpCertsForFabric(kFabricIndex1, kTestNocSpan, ByteSpan{});
-        NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
-        NL_TEST_ASSERT(inSuite, opCertStore.HasPendingNocChain());
-        NL_TEST_ASSERT(inSuite, opCertStore.HasPendingRootCert() == true);
-        NL_TEST_ASSERT(inSuite, storageDelegate.GetNumKeys() == 0); //< Storage count did not yet increase
+        EXPECT_EQ(err, CHIP_NO_ERROR);
+        EXPECT_TRUE(opCertStore.HasPendingNocChain());
+        EXPECT_TRUE(opCertStore.HasPendingRootCert());
+        EXPECT_EQ(storageDelegate.GetNumKeys(), 0u); //< Storage count did not yet increase
     }
 
     // Make sure we get expected pending state before revert
     {
         largeSpan = MutableByteSpan{ largeBuf };
         err       = opCertStore.GetCertificate(kFabricIndex1, CertChainElement::kRcac, largeSpan);
-        NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
-        NL_TEST_ASSERT(inSuite, largeSpan.data_equal(kTestRcacSpan));
+        EXPECT_EQ(err, CHIP_NO_ERROR);
+        EXPECT_TRUE(largeSpan.data_equal(kTestRcacSpan));
 
         largeSpan = MutableByteSpan{ largeBuf };
         err       = opCertStore.GetCertificate(kFabricIndex1, CertChainElement::kIcac, largeSpan);
-        NL_TEST_ASSERT(inSuite, err == CHIP_ERROR_NOT_FOUND);
+        EXPECT_EQ(err, CHIP_ERROR_NOT_FOUND);
 
         largeSpan = MutableByteSpan{ largeBuf };
         err       = opCertStore.GetCertificate(kFabricIndex1, CertChainElement::kNoc, largeSpan);
-        NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
-        NL_TEST_ASSERT(inSuite, largeSpan.data_equal(kTestNocSpan));
+        EXPECT_EQ(err, CHIP_NO_ERROR);
+        EXPECT_TRUE(largeSpan.data_equal(kTestNocSpan));
     }
 
     // Revert using RevertPendingOpCertsExceptRoot
     opCertStore.RevertPendingOpCertsExceptRoot();
-    NL_TEST_ASSERT(inSuite, opCertStore.HasPendingRootCert() == true);
-    NL_TEST_ASSERT(inSuite, !opCertStore.HasPendingNocChain());
-    NL_TEST_ASSERT(inSuite, storageDelegate.GetNumKeys() == 0); //< Storage count did not yet increase
+    EXPECT_TRUE(opCertStore.HasPendingRootCert());
+    EXPECT_FALSE(opCertStore.HasPendingNocChain());
+    EXPECT_EQ(storageDelegate.GetNumKeys(), 0u); //< Storage count did not yet increase
 
     // Add again, and commit
     {
         // Add new root: should fail, since it should still be pending
         err = opCertStore.AddNewTrustedRootCertForFabric(kFabricIndex1, kTestRcacSpan);
-        NL_TEST_ASSERT(inSuite, err == CHIP_ERROR_INCORRECT_STATE);
-        NL_TEST_ASSERT(inSuite, storageDelegate.GetNumKeys() == 0); //< Storage count did not yet increase
-        NL_TEST_ASSERT(inSuite, opCertStore.HasPendingRootCert() == true);
-        NL_TEST_ASSERT(inSuite, !opCertStore.HasPendingNocChain());
+        EXPECT_EQ(err, CHIP_ERROR_INCORRECT_STATE);
+        EXPECT_EQ(storageDelegate.GetNumKeys(), 0u); //< Storage count did not yet increase
+        EXPECT_TRUE(opCertStore.HasPendingRootCert());
+        EXPECT_FALSE(opCertStore.HasPendingNocChain());
 
         // Add NOC chain, with NO ICAC
         err = opCertStore.AddNewOpCertsForFabric(kFabricIndex1, kTestNocSpan, ByteSpan{});
-        NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
-        NL_TEST_ASSERT(inSuite, opCertStore.HasPendingNocChain());
-        NL_TEST_ASSERT(inSuite, opCertStore.HasPendingRootCert() == true);
-        NL_TEST_ASSERT(inSuite, storageDelegate.GetNumKeys() == 0); //< Storage count did not yet increase
+        EXPECT_EQ(err, CHIP_NO_ERROR);
+        EXPECT_TRUE(opCertStore.HasPendingNocChain());
+        EXPECT_TRUE(opCertStore.HasPendingRootCert());
+        EXPECT_EQ(storageDelegate.GetNumKeys(), 0u); //< Storage count did not yet increase
 
         err = opCertStore.CommitOpCertsForFabric(kFabricIndex1);
-        NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR);
-        NL_TEST_ASSERT(inSuite, !opCertStore.HasPendingRootCert());
-        NL_TEST_ASSERT(inSuite, !opCertStore.HasPendingNocChain());
-        NL_TEST_ASSERT(inSuite, storageDelegate.GetNumKeys() == 2); //< We have RCAC, NOC, no ICAC
+        EXPECT_EQ(err, CHIP_NO_ERROR);
+        EXPECT_FALSE(opCertStore.HasPendingRootCert());
+        EXPECT_FALSE(opCertStore.HasPendingNocChain());
+        EXPECT_EQ(storageDelegate.GetNumKeys(), 2u); //< We have RCAC, NOC, no ICAC
     }
 
     opCertStore.Finish();
 }
 
-/**
- *   Test Suite. It lists all the test functions.
- */
-static const nlTest sTests[] = {
-    NL_TEST_DEF("Test AddNOC-like flows PersistentStorageOpCertStore", TestAddNocFlow),
-    NL_TEST_DEF("Test UpdateNOC-like flows PersistentStorageOpCertStore", TestUpdateNocFlow),
-    NL_TEST_DEF("Test revert operations of PersistentStorageOpCertStore", TestReverts),
-    NL_TEST_DEF("Test revert operations with AddNOC of PersistentStorageOpCertStore", TestRevertAddNoc),
-    NL_TEST_DEF("Test revert operations using RevertPendingOpCertsExceptRoot", TestRevertPendingOpCertsExceptRoot),
-    NL_TEST_SENTINEL()
-};
-
-/**
- *  Set up the test suite.
- */
-int Test_Setup(void * inContext)
-{
-    CHIP_ERROR error = chip::Platform::MemoryInit();
-    VerifyOrReturnError(error == CHIP_NO_ERROR, FAILURE);
-    return SUCCESS;
-}
-
-/**
- *  Tear down the test suite.
- */
-int Test_Teardown(void * inContext)
-{
-    chip::Platform::MemoryShutdown();
-    return SUCCESS;
-}
-
 } // namespace
-
-/**
- *  Main
- */
-int TestPersistentStorageOpCertStore()
-{
-    nlTestSuite theSuite = { "PersistentStorageOpCertStore tests", &sTests[0], Test_Setup, Test_Teardown };
-
-    // Run test suite against one context.
-    nlTestRunner(&theSuite, nullptr);
-    return nlTestRunnerStats(&theSuite);
-}
-
-CHIP_REGISTER_TEST_SUITE(TestPersistentStorageOpCertStore)
diff --git a/src/test_driver/openiotsdk/unit-tests/test_components.txt b/src/test_driver/openiotsdk/unit-tests/test_components.txt
index 83dfc0d..0471f70 100644
--- a/src/test_driver/openiotsdk/unit-tests/test_components.txt
+++ b/src/test_driver/openiotsdk/unit-tests/test_components.txt
@@ -7,7 +7,8 @@
 MinimalMdnsRespondersTests
 CoreTests
 MdnsTests
+CredentialsTest
 PlatformTests
 TestShell
 SetupPayloadTests
-SupportTests
\ No newline at end of file
+SupportTests
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 50b0fed..d9801e9 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
 BDXTests
-CredentialsTest
 DataModelTests
 InetLayerTests
 MessagingLayerTests