diff --git a/src/lib/support/tests/BUILD.gn b/src/lib/support/tests/BUILD.gn index 2a9c1ac81fe6a8..585233b1e6667d 100644 --- a/src/lib/support/tests/BUILD.gn +++ b/src/lib/support/tests/BUILD.gn @@ -25,11 +25,18 @@ chip_test_suite("tests") { test_sources = [ "TestBitMask.cpp", "TestBufferReader.cpp", + "TestBytesToHex.cpp", "TestDefer.cpp", "TestFixedBufferAllocator.cpp", "TestFold.cpp", "TestIniEscaping.cpp", "TestSafeInt.cpp", + "TestSafeString.cpp", + "TestScoped.cpp", + "TestSpan.cpp", + "TestStaticSupportSmartPtr.cpp", + "TestTestPersistentStorageDelegate.cpp", + "TestUtf8.cpp", ] sources = [] @@ -59,7 +66,6 @@ chip_test_suite_using_nltest("tests_nltest") { test_sources = [ "TestBufferWriter.cpp", "TestBytesCircularBuffer.cpp", - "TestBytesToHex.cpp", "TestCHIPCounter.cpp", "TestCHIPMem.cpp", "TestCHIPMemString.cpp", @@ -70,21 +76,15 @@ chip_test_suite_using_nltest("tests_nltest") { "TestPersistedCounter.cpp", "TestPool.cpp", "TestPrivateHeap.cpp", - "TestSafeString.cpp", - "TestScoped.cpp", "TestScopedBuffer.cpp", "TestSorting.cpp", - "TestSpan.cpp", "TestStateMachine.cpp", - "TestStaticSupportSmartPtr.cpp", "TestStringBuilder.cpp", "TestStringSplitter.cpp", - "TestTestPersistentStorageDelegate.cpp", "TestThreadOperationalDataset.cpp", "TestTimeUtils.cpp", "TestTlvJson.cpp", "TestTlvToJson.cpp", - "TestUtf8.cpp", "TestVariant.cpp", "TestZclString.cpp", ] diff --git a/src/lib/support/tests/TestBytesToHex.cpp b/src/lib/support/tests/TestBytesToHex.cpp index f5ac6eff27feb1..1e304811b5e42b 100644 --- a/src/lib/support/tests/TestBytesToHex.cpp +++ b/src/lib/support/tests/TestBytesToHex.cpp @@ -20,15 +20,13 @@ #include #include +#include + #include #include #include #include -#include #include - -#include - namespace { using namespace chip; @@ -37,7 +35,7 @@ using namespace chip::Encoding; // To accumulate redirected logs for some tests std::vector gRedirectedLogLines; -void TestBytesToHexNotNullTerminated(nlTestSuite * inSuite, void * inContext) +TEST(TestBytesToHex, TestBytesToHexNotNullTerminated) { // Uppercase { @@ -45,12 +43,11 @@ void TestBytesToHexNotNullTerminated(nlTestSuite * inSuite, void * inContext) char dest[18] = { '?', '?', '?', '?', '?', '?', '?', '?', '?', '?', '?', '?', '?', '?', '?', '?', '!', '@' }; char dest2[18] = { '?', '?', '?', '?', '?', '?', '?', '?', '?', '?', '?', '?', '?', '?', '?', '?', '!', '@' }; char expected[18] = { 'F', 'E', 'D', 'C', 'B', 'A', '9', '8', '7', '6', '5', '4', '3', '2', '1', '0', '!', '@' }; - NL_TEST_ASSERT(inSuite, - BytesToHex(&src[0], sizeof(src), &dest[0], sizeof(src) * 2u, HexFlags::kUppercase) == CHIP_NO_ERROR); - NL_TEST_ASSERT(inSuite, memcmp(&dest[0], &expected[0], sizeof(expected)) == 0); + EXPECT_EQ(BytesToHex(&src[0], sizeof(src), &dest[0], sizeof(src) * 2u, HexFlags::kUppercase), CHIP_NO_ERROR); + EXPECT_EQ(memcmp(&dest[0], &expected[0], sizeof(expected)), 0); - NL_TEST_ASSERT(inSuite, BytesToUppercaseHexBuffer(&src[0], sizeof(src), &dest2[0], sizeof(src) * 2u) == CHIP_NO_ERROR); - NL_TEST_ASSERT(inSuite, memcmp(&dest2[0], &expected[0], sizeof(expected)) == 0); + EXPECT_EQ(BytesToUppercaseHexBuffer(&src[0], sizeof(src), &dest2[0], sizeof(src) * 2u), CHIP_NO_ERROR); + EXPECT_EQ(memcmp(&dest2[0], &expected[0], sizeof(expected)), 0); } // Lowercase @@ -59,12 +56,12 @@ void TestBytesToHexNotNullTerminated(nlTestSuite * inSuite, void * inContext) char dest[18] = { '?', '?', '?', '?', '?', '?', '?', '?', '?', '?', '?', '?', '?', '?', '?', '?', '!', '@' }; char dest2[18] = { '?', '?', '?', '?', '?', '?', '?', '?', '?', '?', '?', '?', '?', '?', '?', '?', '!', '@' }; char expected[18] = { 'f', 'e', 'd', 'c', 'b', 'a', '9', '8', '7', '6', '5', '4', '3', '2', '1', '0', '!', '@' }; - NL_TEST_ASSERT(inSuite, BytesToHex(&src[0], sizeof(src), &dest[0], sizeof(src) * 2u, HexFlags::kNone) == CHIP_NO_ERROR); - NL_TEST_ASSERT(inSuite, memcmp(&dest[0], &expected[0], sizeof(expected)) == 0); + EXPECT_EQ(BytesToHex(&src[0], sizeof(src), &dest[0], sizeof(src) * 2u, HexFlags::kNone), CHIP_NO_ERROR); + EXPECT_EQ(memcmp(&dest[0], &expected[0], sizeof(expected)), 0); // Test Alias - NL_TEST_ASSERT(inSuite, BytesToLowercaseHexBuffer(&src[0], sizeof(src), &dest2[0], sizeof(src) * 2u) == CHIP_NO_ERROR); - NL_TEST_ASSERT(inSuite, memcmp(&dest2[0], &expected[0], sizeof(expected)) == 0); + EXPECT_EQ(BytesToLowercaseHexBuffer(&src[0], sizeof(src), &dest2[0], sizeof(src) * 2u), CHIP_NO_ERROR); + EXPECT_EQ(memcmp(&dest2[0], &expected[0], sizeof(expected)), 0); } // Trivial: Zero size input @@ -72,28 +69,28 @@ void TestBytesToHexNotNullTerminated(nlTestSuite * inSuite, void * inContext) uint8_t src[] = { 0x00 }; char dest[2] = { '!', '@' }; char expected[2] = { '!', '@' }; - NL_TEST_ASSERT(inSuite, BytesToHex(&src[0], 0, &dest[0], sizeof(src) * 2u, HexFlags::kNone) == CHIP_NO_ERROR); + EXPECT_EQ(BytesToHex(&src[0], 0, &dest[0], sizeof(src) * 2u, HexFlags::kNone), CHIP_NO_ERROR); // Nothing should have been touched. - NL_TEST_ASSERT(inSuite, memcmp(&dest[0], &expected[0], sizeof(expected)) == 0); + EXPECT_EQ(memcmp(&dest[0], &expected[0], sizeof(expected)), 0); } // Trivial: Zero size input with null buffer { char dest[2] = { '!', '@' }; char expected[2] = { '!', '@' }; - NL_TEST_ASSERT(inSuite, BytesToHex(nullptr, 0, &dest[0], sizeof(dest), HexFlags::kNone) == CHIP_NO_ERROR); + EXPECT_EQ(BytesToHex(nullptr, 0, &dest[0], sizeof(dest), HexFlags::kNone), CHIP_NO_ERROR); // Nothing should have been touched. - NL_TEST_ASSERT(inSuite, memcmp(&dest[0], &expected[0], sizeof(expected)) == 0); + EXPECT_EQ(memcmp(&dest[0], &expected[0], sizeof(expected)), 0); - NL_TEST_ASSERT(inSuite, BytesToHex(nullptr, 0, nullptr, 0, HexFlags::kNone) == CHIP_NO_ERROR); + EXPECT_EQ(BytesToHex(nullptr, 0, nullptr, 0, HexFlags::kNone), CHIP_NO_ERROR); // Nothing should have been touched. - NL_TEST_ASSERT(inSuite, memcmp(&dest[0], &expected[0], sizeof(expected)) == 0); + EXPECT_EQ(memcmp(&dest[0], &expected[0], sizeof(expected)), 0); - NL_TEST_ASSERT(inSuite, BytesToHex(nullptr, 0, nullptr, 1, HexFlags::kNone) == CHIP_ERROR_INVALID_ARGUMENT); + EXPECT_EQ(BytesToHex(nullptr, 0, nullptr, 1, HexFlags::kNone), CHIP_ERROR_INVALID_ARGUMENT); } } -void TestBytesToHexNullTerminated(nlTestSuite * inSuite, void * inContext) +TEST(TestBytesToHex, TestBytesToHexNullTerminated) { // Uppercase { @@ -101,17 +98,16 @@ void TestBytesToHexNullTerminated(nlTestSuite * inSuite, void * inContext) char dest[18] = { '?', '?', '?', '?', '?', '?', '?', '?', '?', '?', '?', '?', '?', '?', '?', '?', '!', '@' }; char dest2[18] = { '?', '?', '?', '?', '?', '?', '?', '?', '?', '?', '?', '?', '?', '?', '?', '?', '!', '@' }; char expected[18] = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F', '\0', '@' }; - NL_TEST_ASSERT(inSuite, ((sizeof(src) * 2u) + 1u) <= sizeof(dest)); - NL_TEST_ASSERT(inSuite, - BytesToHex(&src[0], sizeof(src), &dest[0], (sizeof(src) * 2u) + 1, HexFlags::kUppercaseAndNullTerminate) == - CHIP_NO_ERROR); - NL_TEST_ASSERT(inSuite, memcmp(&dest[0], &expected[0], sizeof(expected)) == 0); + EXPECT_LE(((sizeof(src) * 2u) + 1u), sizeof(dest)); + EXPECT_EQ(BytesToHex(&src[0], sizeof(src), &dest[0], (sizeof(src) * 2u) + 1, HexFlags::kUppercaseAndNullTerminate), + CHIP_NO_ERROR); + EXPECT_EQ(memcmp(&dest[0], &expected[0], sizeof(expected)), 0); // Test Alias CHIP_ERROR retval = BytesToUppercaseHexString(&src[0], sizeof(src), &dest2[0], sizeof(dest2)); printf("retval=%" CHIP_ERROR_FORMAT "\n", retval.Format()); - NL_TEST_ASSERT(inSuite, retval == CHIP_NO_ERROR); - NL_TEST_ASSERT(inSuite, memcmp(&dest2[0], &expected[0], sizeof(expected)) == 0); + EXPECT_EQ(retval, CHIP_NO_ERROR); + EXPECT_EQ(memcmp(&dest2[0], &expected[0], sizeof(expected)), 0); } // Lowercase @@ -120,15 +116,14 @@ void TestBytesToHexNullTerminated(nlTestSuite * inSuite, void * inContext) char dest[18] = { '?', '?', '?', '?', '?', '?', '?', '?', '?', '?', '?', '?', '?', '?', '?', '?', '!', '@' }; char dest2[18] = { '?', '?', '?', '?', '?', '?', '?', '?', '?', '?', '?', '?', '?', '?', '?', '?', '!', '@' }; char expected[18] = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f', '\0', '@' }; - NL_TEST_ASSERT(inSuite, ((sizeof(src) * 2u) + 1u) <= sizeof(dest)); - NL_TEST_ASSERT( - inSuite, BytesToHex(&src[0], sizeof(src), &dest[0], (sizeof(src) * 2u) + 1, HexFlags::kNullTerminate) == CHIP_NO_ERROR); - NL_TEST_ASSERT(inSuite, memcmp(&dest[0], &expected[0], sizeof(expected)) == 0); + EXPECT_LE(((sizeof(src) * 2u) + 1u), sizeof(dest)); + EXPECT_EQ(BytesToHex(&src[0], sizeof(src), &dest[0], (sizeof(src) * 2u) + 1, HexFlags::kNullTerminate), CHIP_NO_ERROR); + EXPECT_EQ(memcmp(&dest[0], &expected[0], sizeof(expected)), 0); // Test Alias - NL_TEST_ASSERT(inSuite, BytesToLowercaseHexString(&src[0], sizeof(src), &dest2[0], sizeof(dest2)) == CHIP_NO_ERROR); + EXPECT_EQ(BytesToLowercaseHexString(&src[0], sizeof(src), &dest2[0], sizeof(dest2)), CHIP_NO_ERROR); printf("->%s\n", dest2); - NL_TEST_ASSERT(inSuite, memcmp(&dest2[0], &expected[0], sizeof(expected)) == 0); + EXPECT_EQ(memcmp(&dest2[0], &expected[0], sizeof(expected)), 0); } // Trivial: Zero size input @@ -136,36 +131,36 @@ void TestBytesToHexNullTerminated(nlTestSuite * inSuite, void * inContext) uint8_t src[] = { 0x00 }; char dest[2] = { '!', '@' }; char expected[2] = { '\0', '@' }; - NL_TEST_ASSERT(inSuite, BytesToHex(&src[0], 0, &dest[0], sizeof(dest), HexFlags::kNullTerminate) == CHIP_NO_ERROR); + EXPECT_EQ(BytesToHex(&src[0], 0, &dest[0], sizeof(dest), HexFlags::kNullTerminate), CHIP_NO_ERROR); // Expect nul termination - NL_TEST_ASSERT(inSuite, memcmp(&dest[0], &expected[0], sizeof(expected)) == 0); + EXPECT_EQ(memcmp(&dest[0], &expected[0], sizeof(expected)), 0); } // Trivial: Zero size input with null buffer { char dest[2] = { '!', '@' }; char expected[2] = { '\0', '@' }; - NL_TEST_ASSERT(inSuite, BytesToHex(nullptr, 0, &dest[0], sizeof(dest), HexFlags::kNullTerminate) == CHIP_NO_ERROR); + EXPECT_EQ(BytesToHex(nullptr, 0, &dest[0], sizeof(dest), HexFlags::kNullTerminate), CHIP_NO_ERROR); // Nothing should have been touched. - NL_TEST_ASSERT(inSuite, memcmp(&dest[0], &expected[0], sizeof(expected)) == 0); + EXPECT_EQ(memcmp(&dest[0], &expected[0], sizeof(expected)), 0); - NL_TEST_ASSERT(inSuite, BytesToHex(nullptr, 0, nullptr, 0, HexFlags::kNullTerminate) == CHIP_ERROR_BUFFER_TOO_SMALL); + EXPECT_EQ(BytesToHex(nullptr, 0, nullptr, 0, HexFlags::kNullTerminate), CHIP_ERROR_BUFFER_TOO_SMALL); - NL_TEST_ASSERT(inSuite, BytesToHex(nullptr, 0, &dest[0], 1, HexFlags::kNullTerminate) == CHIP_NO_ERROR); + EXPECT_EQ(BytesToHex(nullptr, 0, &dest[0], 1, HexFlags::kNullTerminate), CHIP_NO_ERROR); // Nothing should have been touched. - NL_TEST_ASSERT(inSuite, memcmp(&dest[0], &expected[0], sizeof(expected)) == 0); + EXPECT_EQ(memcmp(&dest[0], &expected[0], sizeof(expected)), 0); - NL_TEST_ASSERT(inSuite, BytesToHex(nullptr, 0, nullptr, 1, HexFlags::kNullTerminate) == CHIP_ERROR_INVALID_ARGUMENT); + EXPECT_EQ(BytesToHex(nullptr, 0, nullptr, 1, HexFlags::kNullTerminate), CHIP_ERROR_INVALID_ARGUMENT); } } -void TestBytesToHexErrors(nlTestSuite * inSuite, void * inContext) +TEST(TestBytesToHex, TestBytesToHexErrors) { // NULL destination { uint8_t src[] = { 0x01, 0x23, 0x45, 0x67, 0x89, 0xAB, 0xCD, 0xEF }; char * dest = nullptr; - NL_TEST_ASSERT(inSuite, BytesToHex(&src[0], 0, dest, sizeof(src) * 2u, HexFlags::kNone) == CHIP_ERROR_INVALID_ARGUMENT); + EXPECT_EQ(BytesToHex(&src[0], 0, dest, sizeof(src) * 2u, HexFlags::kNone), CHIP_ERROR_INVALID_ARGUMENT); } // Destination buffer too small for non-null-terminated @@ -173,12 +168,10 @@ void TestBytesToHexErrors(nlTestSuite * inSuite, void * inContext) uint8_t src[] = { 0x01, 0x23, 0x45, 0x67, 0x89, 0xAB, 0xCD, 0xEF }; char dest[18] = { '?', '?', '?', '?', '?', '?', '?', '?', '?', '?', '?', '?', '?', '?', '?', '?', '!', '@' }; char expected[18] = { '?', '?', '?', '?', '?', '?', '?', '?', '?', '?', '?', '?', '?', '?', '?', '?', '!', '@' }; - NL_TEST_ASSERT(inSuite, ((sizeof(src) * 2u) + 1u) <= sizeof(dest)); - NL_TEST_ASSERT(inSuite, - BytesToHex(&src[0], sizeof(src), &dest[0], (sizeof(src) * 2u) - 1, HexFlags::kNone) == - CHIP_ERROR_BUFFER_TOO_SMALL); + EXPECT_LE(((sizeof(src) * 2u) + 1u), sizeof(dest)); + EXPECT_EQ(BytesToHex(&src[0], sizeof(src), &dest[0], (sizeof(src) * 2u) - 1, HexFlags::kNone), CHIP_ERROR_BUFFER_TOO_SMALL); // Ensure output not touched - NL_TEST_ASSERT(inSuite, memcmp(&dest[0], &expected[0], sizeof(expected)) == 0); + EXPECT_EQ(memcmp(&dest[0], &expected[0], sizeof(expected)), 0); } // Destination buffer too small for null-terminated @@ -186,12 +179,11 @@ void TestBytesToHexErrors(nlTestSuite * inSuite, void * inContext) uint8_t src[] = { 0x01, 0x23, 0x45, 0x67, 0x89, 0xAB, 0xCD, 0xEF }; char dest[18] = { '?', '?', '?', '?', '?', '?', '?', '?', '?', '?', '?', '?', '?', '?', '?', '?', '!', '@' }; char expected[18] = { '?', '?', '?', '?', '?', '?', '?', '?', '?', '?', '?', '?', '?', '?', '?', '?', '!', '@' }; - NL_TEST_ASSERT(inSuite, ((sizeof(src) * 2u) + 1u) <= sizeof(dest)); - NL_TEST_ASSERT(inSuite, - BytesToHex(&src[0], sizeof(src), &dest[0], (sizeof(src) * 2u), HexFlags::kNullTerminate) == - CHIP_ERROR_BUFFER_TOO_SMALL); + EXPECT_LE(((sizeof(src) * 2u) + 1u), sizeof(dest)); + EXPECT_EQ(BytesToHex(&src[0], sizeof(src), &dest[0], (sizeof(src) * 2u), HexFlags::kNullTerminate), + CHIP_ERROR_BUFFER_TOO_SMALL); // Ensure output not touched - NL_TEST_ASSERT(inSuite, memcmp(&dest[0], &expected[0], sizeof(expected)) == 0); + EXPECT_EQ(memcmp(&dest[0], &expected[0], sizeof(expected)), 0); } // Writing in a larger buffer is fine, bytes past the nul terminator (when requested) are untouched. @@ -199,10 +191,9 @@ void TestBytesToHexErrors(nlTestSuite * inSuite, void * inContext) uint8_t src[] = { 0x01, 0x23, 0x45, 0x67, 0x89, 0xAB, 0xCD, 0xEF }; char dest[18] = { '?', '?', '?', '?', '?', '?', '?', '?', '?', '?', '?', '?', '?', '?', '?', '?', '!', '@' }; char expected[18] = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f', '\0', '@' }; - NL_TEST_ASSERT(inSuite, ((sizeof(src) * 2u) + 1u) < sizeof(dest)); - NL_TEST_ASSERT(inSuite, - BytesToHex(&src[0], sizeof(src), &dest[0], sizeof(dest), HexFlags::kNullTerminate) == CHIP_NO_ERROR); - NL_TEST_ASSERT(inSuite, memcmp(&dest[0], &expected[0], sizeof(expected)) == 0); + EXPECT_LT(((sizeof(src) * 2u) + 1u), sizeof(dest)); + EXPECT_EQ(BytesToHex(&src[0], sizeof(src), &dest[0], sizeof(dest), HexFlags::kNullTerminate), CHIP_NO_ERROR); + EXPECT_EQ(memcmp(&dest[0], &expected[0], sizeof(expected)), 0); } // Source size that would not fit in any output using size_t @@ -210,18 +201,16 @@ void TestBytesToHexErrors(nlTestSuite * inSuite, void * inContext) uint8_t src[] = { 0x01, 0x23, 0x45, 0x67, 0x89, 0xAB, 0xCD, 0xEF }; char dest[18] = { '?', '?', '?', '?', '?', '?', '?', '?', '?', '?', '?', '?', '?', '?', '?', '?', '!', '@' }; char expected[18] = { '?', '?', '?', '?', '?', '?', '?', '?', '?', '?', '?', '?', '?', '?', '?', '?', '!', '@' }; - NL_TEST_ASSERT(inSuite, - BytesToHex(&src[0], SIZE_MAX / 2u, &dest[0], sizeof(dest), HexFlags::kNullTerminate) == - CHIP_ERROR_BUFFER_TOO_SMALL); - NL_TEST_ASSERT(inSuite, memcmp(&dest[0], &expected[0], sizeof(expected)) == 0); - - NL_TEST_ASSERT(inSuite, - BytesToHex(&src[0], SIZE_MAX / 2u, &dest[0], sizeof(dest), HexFlags::kNone) == CHIP_ERROR_BUFFER_TOO_SMALL); - NL_TEST_ASSERT(inSuite, memcmp(&dest[0], &expected[0], sizeof(expected)) == 0); + EXPECT_EQ(BytesToHex(&src[0], SIZE_MAX / 2u, &dest[0], sizeof(dest), HexFlags::kNullTerminate), + CHIP_ERROR_BUFFER_TOO_SMALL); + EXPECT_EQ(memcmp(&dest[0], &expected[0], sizeof(expected)), 0); + + EXPECT_EQ(BytesToHex(&src[0], SIZE_MAX / 2u, &dest[0], sizeof(dest), HexFlags::kNone), CHIP_ERROR_BUFFER_TOO_SMALL); + EXPECT_EQ(memcmp(&dest[0], &expected[0], sizeof(expected)), 0); } } -void TestBytesToHexUint64(nlTestSuite * inSuite, void * inContext) +TEST(TestBytesToHex, TestBytesToHexUint64) { // Different values in each byte and each nibble should let us know if the conversion is correct. uint64_t test = 0x0123456789ABCDEF; @@ -237,62 +226,54 @@ void TestBytesToHexUint64(nlTestSuite * inSuite, void * inContext) // Lower case - uint64_t. memset(buf, 1, sizeof(buf)); - NL_TEST_ASSERT(inSuite, Uint64ToHex(test, buf, sizeof(buf), HexFlags::kNone) == CHIP_NO_ERROR); - NL_TEST_ASSERT(inSuite, memcmp(buf, lowerExpected, strlen(lowerExpected)) == 0); + EXPECT_EQ(Uint64ToHex(test, buf, sizeof(buf), HexFlags::kNone), CHIP_NO_ERROR); + EXPECT_EQ(memcmp(buf, lowerExpected, strlen(lowerExpected)), 0); // No null termination. - NL_TEST_ASSERT(inSuite, buf[16] == 1); + EXPECT_EQ(buf[16], 1); // Lower case - uint32_t. memset(buf, 1, sizeof(buf)); - NL_TEST_ASSERT(inSuite, Uint32ToHex(test32_0, buf, sizeof(uint32_t) * 2, HexFlags::kNone) == CHIP_NO_ERROR); - NL_TEST_ASSERT(inSuite, - Uint32ToHex(test32_1, &buf[sizeof(uint32_t) * 2], sizeof(uint32_t) * 2, HexFlags::kNone) == CHIP_NO_ERROR); - NL_TEST_ASSERT(inSuite, memcmp(buf, lowerExpected, strlen(lowerExpected)) == 0); + EXPECT_EQ(Uint32ToHex(test32_0, buf, sizeof(uint32_t) * 2, HexFlags::kNone), CHIP_NO_ERROR); + EXPECT_EQ(Uint32ToHex(test32_1, &buf[sizeof(uint32_t) * 2], sizeof(uint32_t) * 2, HexFlags::kNone), CHIP_NO_ERROR); + EXPECT_EQ(memcmp(buf, lowerExpected, strlen(lowerExpected)), 0); // No null termination. - NL_TEST_ASSERT(inSuite, buf[16] == 1); + EXPECT_EQ(buf[16], 1); // Upper case - uint64_t. memset(buf, 1, sizeof(buf)); - NL_TEST_ASSERT(inSuite, Uint64ToHex(test, buf, sizeof(buf), HexFlags::kUppercase) == CHIP_NO_ERROR); - NL_TEST_ASSERT(inSuite, memcmp(buf, upperExpected, strlen(upperExpected)) == 0); + EXPECT_EQ(Uint64ToHex(test, buf, sizeof(buf), HexFlags::kUppercase), CHIP_NO_ERROR); + EXPECT_EQ(memcmp(buf, upperExpected, strlen(upperExpected)), 0); // No null termination. - NL_TEST_ASSERT(inSuite, buf[16] == 1); + EXPECT_EQ(buf[16], 1); // Upper case - uint16_t. memset(buf, 1, sizeof(buf)); - NL_TEST_ASSERT(inSuite, Uint16ToHex(test16_0, buf, sizeof(uint16_t) * 2, HexFlags::kUppercase) == CHIP_NO_ERROR); - NL_TEST_ASSERT(inSuite, - Uint16ToHex(test16_1, &buf[sizeof(uint16_t) * 2 * 1], sizeof(uint16_t) * 2, HexFlags::kUppercase) == - CHIP_NO_ERROR); - NL_TEST_ASSERT(inSuite, - Uint16ToHex(test16_2, &buf[sizeof(uint16_t) * 2 * 2], sizeof(uint16_t) * 2, HexFlags::kUppercase) == - CHIP_NO_ERROR); - NL_TEST_ASSERT(inSuite, - Uint16ToHex(test16_3, &buf[sizeof(uint16_t) * 2 * 3], sizeof(uint16_t) * 2, HexFlags::kUppercase) == - CHIP_NO_ERROR); - NL_TEST_ASSERT(inSuite, memcmp(buf, upperExpected, strlen(upperExpected)) == 0); + EXPECT_EQ(Uint16ToHex(test16_0, buf, sizeof(uint16_t) * 2, HexFlags::kUppercase), CHIP_NO_ERROR); + EXPECT_EQ(Uint16ToHex(test16_1, &buf[sizeof(uint16_t) * 2 * 1], sizeof(uint16_t) * 2, HexFlags::kUppercase), CHIP_NO_ERROR); + EXPECT_EQ(Uint16ToHex(test16_2, &buf[sizeof(uint16_t) * 2 * 2], sizeof(uint16_t) * 2, HexFlags::kUppercase), CHIP_NO_ERROR); + EXPECT_EQ(Uint16ToHex(test16_3, &buf[sizeof(uint16_t) * 2 * 3], sizeof(uint16_t) * 2, HexFlags::kUppercase), CHIP_NO_ERROR); + EXPECT_EQ(memcmp(buf, upperExpected, strlen(upperExpected)), 0); // No null termination. - NL_TEST_ASSERT(inSuite, buf[16] == 1); + EXPECT_EQ(buf[16], 1); // Lower case with null termination. memset(buf, 1, sizeof(buf)); - NL_TEST_ASSERT(inSuite, Uint64ToHex(test, buf, sizeof(buf), HexFlags::kNullTerminate) == CHIP_NO_ERROR); - NL_TEST_ASSERT(inSuite, memcmp(buf, lowerExpected, sizeof(lowerExpected)) == 0); + EXPECT_EQ(Uint64ToHex(test, buf, sizeof(buf), HexFlags::kNullTerminate), CHIP_NO_ERROR); + EXPECT_EQ(memcmp(buf, lowerExpected, sizeof(lowerExpected)), 0); // Upper case with null termination. memset(buf, 1, sizeof(buf)); - NL_TEST_ASSERT(inSuite, Uint64ToHex(test, buf, sizeof(buf), HexFlags::kUppercaseAndNullTerminate) == CHIP_NO_ERROR); - NL_TEST_ASSERT(inSuite, memcmp(buf, upperExpected, sizeof(upperExpected)) == 0); + EXPECT_EQ(Uint64ToHex(test, buf, sizeof(buf), HexFlags::kUppercaseAndNullTerminate), CHIP_NO_ERROR); + EXPECT_EQ(memcmp(buf, upperExpected, sizeof(upperExpected)), 0); // Too small buffer - NL_TEST_ASSERT(inSuite, Uint64ToHex(test, buf, sizeof(buf) - 2, HexFlags::kNone) == CHIP_ERROR_BUFFER_TOO_SMALL); - NL_TEST_ASSERT(inSuite, Uint64ToHex(test, buf, sizeof(buf) - 2, HexFlags::kUppercase) == CHIP_ERROR_BUFFER_TOO_SMALL); - NL_TEST_ASSERT(inSuite, Uint64ToHex(test, buf, sizeof(buf) - 1, HexFlags::kNullTerminate) == CHIP_ERROR_BUFFER_TOO_SMALL); - NL_TEST_ASSERT(inSuite, - Uint64ToHex(test, buf, sizeof(buf) - 1, HexFlags::kUppercaseAndNullTerminate) == CHIP_ERROR_BUFFER_TOO_SMALL); + EXPECT_EQ(Uint64ToHex(test, buf, sizeof(buf) - 2, HexFlags::kNone), CHIP_ERROR_BUFFER_TOO_SMALL); + EXPECT_EQ(Uint64ToHex(test, buf, sizeof(buf) - 2, HexFlags::kUppercase), CHIP_ERROR_BUFFER_TOO_SMALL); + EXPECT_EQ(Uint64ToHex(test, buf, sizeof(buf) - 1, HexFlags::kNullTerminate), CHIP_ERROR_BUFFER_TOO_SMALL); + EXPECT_EQ(Uint64ToHex(test, buf, sizeof(buf) - 1, HexFlags::kUppercaseAndNullTerminate), CHIP_ERROR_BUFFER_TOO_SMALL); } -void TestHexToBytesAndUint(nlTestSuite * inSuite, void * inContext) +TEST(TestBytesToHex, TestHexToBytesAndUint) { // Different values in each byte and each nibble should let us know if the conversion is correct. char hexInLowercase[] = "0123456789abcdef"; @@ -310,32 +291,32 @@ void TestHexToBytesAndUint(nlTestSuite * inSuite, void * inContext) // Lower case - bytes. memset(buf, 0, sizeof(buf)); - NL_TEST_ASSERT(inSuite, HexToBytes(hexInLowercase, strlen(hexInLowercase), buf, sizeof(buf)) == sizeof(buf)); - NL_TEST_ASSERT(inSuite, memcmp(buf, bytesOutExpected, sizeof(buf)) == 0); + EXPECT_EQ(HexToBytes(hexInLowercase, strlen(hexInLowercase), buf, sizeof(buf)), sizeof(buf)); + EXPECT_EQ(memcmp(buf, bytesOutExpected, sizeof(buf)), 0); // Upper case - bytes. memset(buf, 0, sizeof(buf)); - NL_TEST_ASSERT(inSuite, HexToBytes(hexInUppercase, strlen(hexInUppercase), buf, sizeof(buf)) == sizeof(buf)); - NL_TEST_ASSERT(inSuite, memcmp(buf, bytesOutExpected, sizeof(buf)) == 0); + EXPECT_EQ(HexToBytes(hexInUppercase, strlen(hexInUppercase), buf, sizeof(buf)), sizeof(buf)); + EXPECT_EQ(memcmp(buf, bytesOutExpected, sizeof(buf)), 0); // Lower case - uint64_t. test64Out = 0; - NL_TEST_ASSERT(inSuite, UppercaseHexToUint64(hexInLowercase, strlen(hexInLowercase), test64Out) == 0); + EXPECT_EQ(UppercaseHexToUint64(hexInLowercase, strlen(hexInLowercase), test64Out), 0u); // Upper case - uint64_t. test64Out = 0; - NL_TEST_ASSERT(inSuite, UppercaseHexToUint64(hexInUppercase, strlen(hexInUppercase), test64Out) == sizeof(uint64_t)); - NL_TEST_ASSERT(inSuite, test64Out == test64OutExpected); + EXPECT_EQ(UppercaseHexToUint64(hexInUppercase, strlen(hexInUppercase), test64Out), sizeof(uint64_t)); + EXPECT_EQ(test64Out, test64OutExpected); // Upper case - uint32_t. test32Out = 0; - NL_TEST_ASSERT(inSuite, UppercaseHexToUint32(hexInUppercase32, strlen(hexInUppercase32), test32Out) == sizeof(uint32_t)); - NL_TEST_ASSERT(inSuite, test32Out == test32OutExpected); + EXPECT_EQ(UppercaseHexToUint32(hexInUppercase32, strlen(hexInUppercase32), test32Out), sizeof(uint32_t)); + EXPECT_EQ(test32Out, test32OutExpected); // Upper case - uint16_t. test16Out = 0; - NL_TEST_ASSERT(inSuite, UppercaseHexToUint16(hexInUppercase16, strlen(hexInUppercase16), test16Out) == sizeof(uint16_t)); - NL_TEST_ASSERT(inSuite, test16Out == test16OutExpected); + EXPECT_EQ(UppercaseHexToUint16(hexInUppercase16, strlen(hexInUppercase16), test16Out), sizeof(uint16_t)); + EXPECT_EQ(test16Out, test16OutExpected); } #if CHIP_PROGRESS_LOGGING @@ -351,9 +332,9 @@ ENFORCE_FORMAT(3, 0) void AccumulateLogLineCallback(const char * module, uint8_t gRedirectedLogLines.push_back(std::string(line)); } -void ValidateTextMatches(nlTestSuite * inSuite, const char ** expected, size_t numLines, const std::vector & candidate) +void ValidateTextMatches(const char ** expected, size_t numLines, const std::vector & candidate) { - NL_TEST_ASSERT(inSuite, candidate.size() == numLines); + EXPECT_EQ(candidate.size(), numLines); if (candidate.size() != numLines) { return; @@ -361,7 +342,7 @@ void ValidateTextMatches(nlTestSuite * inSuite, const char ** expected, size_t n for (size_t idx = 0; idx < numLines; idx++) { printf("Checking '%s' against '%s'\n", candidate.at(idx).c_str(), expected[idx]); - NL_TEST_ASSERT(inSuite, candidate.at(idx) == expected[idx]); + EXPECT_EQ(candidate.at(idx), expected[idx]); if (candidate.at(idx) != expected[idx]) { return; @@ -369,7 +350,7 @@ void ValidateTextMatches(nlTestSuite * inSuite, const char ** expected, size_t n } } -void TestLogBufferAsHex(nlTestSuite * inSuite, void * inContext) +TEST(TestBytesToHex, TestLogBufferAsHex) { const char * kExpectedText1[] = { ">>>A54A39294B28886E8BFC15B44105A3FD22745225983A753E6BB82DA7C62493BF", @@ -425,31 +406,9 @@ void TestLogBufferAsHex(nlTestSuite * inSuite, void * inContext) LogBufferAsHex(testCase.label, testCase.buffer); } chip::Logging::SetLogRedirectCallback(nullptr); - ValidateTextMatches(inSuite, testCase.expectedText, testCase.numLines, gRedirectedLogLines); + ValidateTextMatches(testCase.expectedText, testCase.numLines, gRedirectedLogLines); } } #endif - -const nlTest sTests[] = { - NL_TEST_DEF("TestBytesToHexNotNullTerminated", TestBytesToHexNotNullTerminated), // - NL_TEST_DEF("TestBytesToHexNullTerminated", TestBytesToHexNullTerminated), // - NL_TEST_DEF("TestBytesToHexErrors", TestBytesToHexErrors), // - NL_TEST_DEF("TestBytesToHexUint64", TestBytesToHexUint64), // - NL_TEST_DEF("TestHexToBytesAndUint", TestHexToBytesAndUint), // -#if CHIP_PROGRESS_LOGGING - NL_TEST_DEF("TestLogBufferAsHex", TestLogBufferAsHex), // -#endif - NL_TEST_SENTINEL() // -}; - } // namespace - -int TestBytesToHex() -{ - nlTestSuite theSuite = { "BytesToHex", sTests, nullptr, nullptr }; - nlTestRunner(&theSuite, nullptr); - return nlTestRunnerStats(&theSuite); -} - -CHIP_REGISTER_TEST_SUITE(TestBytesToHex) diff --git a/src/lib/support/tests/TestSafeString.cpp b/src/lib/support/tests/TestSafeString.cpp index 2dc52d38a6754e..09e7d89e4054f7 100644 --- a/src/lib/support/tests/TestSafeString.cpp +++ b/src/lib/support/tests/TestSafeString.cpp @@ -22,45 +22,27 @@ * */ -#include -#include +#include -#include +#include using namespace chip; -static void TestMaxStringLength(nlTestSuite * inSuite, void * inContext) +TEST(TestSafeString, TestMaxStringLength) { constexpr size_t len = MaxStringLength("a", "bc", "def"); - NL_TEST_ASSERT(inSuite, len == 3); + EXPECT_EQ(len, 3u); - NL_TEST_ASSERT(inSuite, MaxStringLength("bc") == 2); + EXPECT_EQ(MaxStringLength("bc"), 2u); - NL_TEST_ASSERT(inSuite, MaxStringLength("def", "bc", "a") == 3); + EXPECT_EQ(MaxStringLength("def", "bc", "a"), 3u); - NL_TEST_ASSERT(inSuite, MaxStringLength("") == 0); -} - -static void TestTotalStringLength(nlTestSuite * inSuite, void * inContext) -{ - NL_TEST_ASSERT(inSuite, TotalStringLength("") == 0); - NL_TEST_ASSERT(inSuite, TotalStringLength("a") == 1); - NL_TEST_ASSERT(inSuite, TotalStringLength("def", "bc", "a") == 6); + EXPECT_EQ(MaxStringLength(""), 0u); } -#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(TestMaxStringLength), NL_TEST_DEF_FN(TestTotalStringLength), NL_TEST_SENTINEL() }; - -int TestSafeString() +TEST(TestSafeString, TestTotalStringLength) { - nlTestSuite theSuite = { "CHIP SafeString tests", &sTests[0], nullptr, nullptr }; - - // Run test suite against one context. - nlTestRunner(&theSuite, nullptr); - return nlTestRunnerStats(&theSuite); + EXPECT_EQ(TotalStringLength(""), 0u); + EXPECT_EQ(TotalStringLength("a"), 1u); + EXPECT_EQ(TotalStringLength("def", "bc", "a"), 6u); } - -CHIP_REGISTER_TEST_SUITE(TestSafeString) diff --git a/src/lib/support/tests/TestScoped.cpp b/src/lib/support/tests/TestScoped.cpp index 90cdd62b0acf4a..fef70a443dcfb1 100644 --- a/src/lib/support/tests/TestScoped.cpp +++ b/src/lib/support/tests/TestScoped.cpp @@ -16,87 +16,66 @@ * limitations under the License. */ -#include -#include - -#include #include +#include + +#include + namespace { using namespace chip; -void TestScopedVariableChange(nlTestSuite * inSuite, void * inContext) +TEST(TestScoped, TestScopedVariableChange) { int x = 123; { ScopedChange change1(x, 10); - NL_TEST_ASSERT(inSuite, x == 10); + EXPECT_EQ(x, 10); x = 15; { ScopedChange change2(x, 20); - NL_TEST_ASSERT(inSuite, x == 20); + EXPECT_EQ(x, 20); } - NL_TEST_ASSERT(inSuite, x == 15); + EXPECT_EQ(x, 15); } - NL_TEST_ASSERT(inSuite, x == 123); + EXPECT_EQ(x, 123); } -void TestScopedChangeOnly(nlTestSuite * inSuite, void * inContext) +TEST(TestScoped, TestScopedChangeOnly) { ScopedChangeOnly intValue(123); ScopedChangeOnly strValue("abc"); - NL_TEST_ASSERT(inSuite, intValue == 123); - NL_TEST_ASSERT(inSuite, strcmp(strValue, "abc") == 0); + EXPECT_EQ(intValue, 123); + EXPECT_STREQ(strValue, "abc"); { ScopedChange change1(intValue, 234); - NL_TEST_ASSERT(inSuite, intValue == 234); - NL_TEST_ASSERT(inSuite, strcmp(strValue, "abc") == 0); + EXPECT_EQ(intValue, 234); + EXPECT_STREQ(strValue, "abc"); ScopedChange change2(strValue, "xyz"); - NL_TEST_ASSERT(inSuite, intValue == 234); - NL_TEST_ASSERT(inSuite, strcmp(strValue, "xyz") == 0); + EXPECT_EQ(intValue, 234); + EXPECT_STREQ(strValue, "xyz"); { ScopedChange change3(intValue, 10); ScopedChange change4(strValue, "test"); - NL_TEST_ASSERT(inSuite, intValue == 10); - NL_TEST_ASSERT(inSuite, strcmp(strValue, "test") == 0); + EXPECT_EQ(intValue, 10); + EXPECT_STREQ(strValue, "test"); } - NL_TEST_ASSERT(inSuite, intValue == 234); - NL_TEST_ASSERT(inSuite, strcmp(strValue, "xyz") == 0); + EXPECT_EQ(intValue, 234); + EXPECT_STREQ(strValue, "xyz"); } - NL_TEST_ASSERT(inSuite, intValue == 123); - NL_TEST_ASSERT(inSuite, strcmp(strValue, "abc") == 0); + EXPECT_EQ(intValue, 123); + EXPECT_STREQ(strValue, "abc"); } } // namespace - -#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(TestScopedVariableChange), // - NL_TEST_DEF_FN(TestScopedChangeOnly), // - NL_TEST_SENTINEL() // -}; - -int TestScoped() -{ - nlTestSuite theSuite = { "CHIP Scoped tests", &sTests[0], nullptr, nullptr }; - - // Run test suite against one context. - nlTestRunner(&theSuite, nullptr); - return nlTestRunnerStats(&theSuite); -} - -CHIP_REGISTER_TEST_SUITE(TestScoped) diff --git a/src/lib/support/tests/TestSpan.cpp b/src/lib/support/tests/TestSpan.cpp index 87f52ae9bec4d2..6849138861065c 100644 --- a/src/lib/support/tests/TestSpan.cpp +++ b/src/lib/support/tests/TestSpan.cpp @@ -22,256 +22,255 @@ * */ -#include -#include +#include -#include +#include -#include +#include using namespace chip; -static void TestByteSpan(nlTestSuite * inSuite, void * inContext) +TEST(TestSpan, TestByteSpan) { uint8_t arr[] = { 1, 2, 3 }; ByteSpan s0 = ByteSpan(); - NL_TEST_ASSERT(inSuite, s0.size() == 0); - NL_TEST_ASSERT(inSuite, s0.empty()); - NL_TEST_ASSERT(inSuite, s0.data_equal(s0)); + EXPECT_EQ(s0.size(), 0u); + EXPECT_TRUE(s0.empty()); + EXPECT_TRUE(s0.data_equal(s0)); ByteSpan s1(arr, 2); - NL_TEST_ASSERT(inSuite, s1.data() == arr); - NL_TEST_ASSERT(inSuite, s1.size() == 2); - NL_TEST_ASSERT(inSuite, !s1.empty()); - NL_TEST_ASSERT(inSuite, s1.data_equal(s1)); - NL_TEST_ASSERT(inSuite, !s1.data_equal(s0)); + EXPECT_EQ(s1.data(), arr); + EXPECT_EQ(s1.size(), 2u); + EXPECT_FALSE(s1.empty()); + EXPECT_TRUE(s1.data_equal(s1)); + EXPECT_FALSE(s1.data_equal(s0)); ByteSpan s2(arr); - NL_TEST_ASSERT(inSuite, s2.data() == arr); - NL_TEST_ASSERT(inSuite, s2.size() == 3); - NL_TEST_ASSERT(inSuite, s2.data()[2] == 3); - NL_TEST_ASSERT(inSuite, !s2.empty()); - NL_TEST_ASSERT(inSuite, s2.data_equal(s2)); - NL_TEST_ASSERT(inSuite, !s2.data_equal(s1)); - NL_TEST_ASSERT(inSuite, s2.front() == 1); - NL_TEST_ASSERT(inSuite, s2.back() == 3); - NL_TEST_ASSERT(inSuite, s2[0] == 1); - NL_TEST_ASSERT(inSuite, s2[1] == 2); - NL_TEST_ASSERT(inSuite, s2[2] == 3); + EXPECT_EQ(s2.data(), arr); + EXPECT_EQ(s2.size(), 3u); + EXPECT_EQ(s2.data()[2], 3u); + EXPECT_FALSE(s2.empty()); + EXPECT_TRUE(s2.data_equal(s2)); + EXPECT_FALSE(s2.data_equal(s1)); + EXPECT_EQ(s2.front(), 1u); + EXPECT_EQ(s2.back(), 3u); + EXPECT_EQ(s2[0], 1u); + EXPECT_EQ(s2[1], 2u); + EXPECT_EQ(s2[2], 3u); ByteSpan s3 = s2; - NL_TEST_ASSERT(inSuite, s3.data() == arr); - NL_TEST_ASSERT(inSuite, s3.size() == 3); - NL_TEST_ASSERT(inSuite, s3.data()[2] == 3); - NL_TEST_ASSERT(inSuite, !s3.empty()); - NL_TEST_ASSERT(inSuite, s3.data_equal(s2)); + EXPECT_EQ(s3.data(), arr); + EXPECT_EQ(s3.size(), 3u); + EXPECT_EQ(s3.data()[2], 3u); + EXPECT_FALSE(s3.empty()); + EXPECT_TRUE(s3.data_equal(s2)); uint8_t arr2[] = { 3, 2, 1 }; ByteSpan s4(arr2); - NL_TEST_ASSERT(inSuite, !s4.data_equal(s2)); + EXPECT_FALSE(s4.data_equal(s2)); ByteSpan s5(arr2, 0); - NL_TEST_ASSERT(inSuite, s5.data() != nullptr); - NL_TEST_ASSERT(inSuite, !s5.data_equal(s4)); - NL_TEST_ASSERT(inSuite, s5.data_equal(s0)); - NL_TEST_ASSERT(inSuite, s0.data_equal(s5)); + EXPECT_NE(s5.data(), nullptr); + EXPECT_FALSE(s5.data_equal(s4)); + EXPECT_TRUE(s5.data_equal(s0)); + EXPECT_TRUE(s0.data_equal(s5)); ByteSpan s6(arr2); s6.reduce_size(2); - NL_TEST_ASSERT(inSuite, s6.size() == 2); + EXPECT_EQ(s6.size(), 2u); ByteSpan s7(arr2, 2); - NL_TEST_ASSERT(inSuite, s6.data_equal(s7)); - NL_TEST_ASSERT(inSuite, s7.data_equal(s6)); + EXPECT_TRUE(s6.data_equal(s7)); + EXPECT_TRUE(s7.data_equal(s6)); } -static void TestMutableByteSpan(nlTestSuite * inSuite, void * inContext) +TEST(TestSpan, TestMutableByteSpan) { uint8_t arr[] = { 1, 2, 3 }; MutableByteSpan s0 = MutableByteSpan(); - NL_TEST_ASSERT(inSuite, s0.size() == 0); - NL_TEST_ASSERT(inSuite, s0.empty()); - NL_TEST_ASSERT(inSuite, s0.data_equal(s0)); + EXPECT_EQ(s0.size(), 0u); + EXPECT_TRUE(s0.empty()); + EXPECT_TRUE(s0.data_equal(s0)); MutableByteSpan s1(arr, 2); - NL_TEST_ASSERT(inSuite, s1.data() == arr); - NL_TEST_ASSERT(inSuite, s1.size() == 2); - NL_TEST_ASSERT(inSuite, !s1.empty()); - NL_TEST_ASSERT(inSuite, s1.data_equal(s1)); - NL_TEST_ASSERT(inSuite, !s1.data_equal(s0)); + EXPECT_EQ(s1.data(), arr); + EXPECT_EQ(s1.size(), 2u); + EXPECT_FALSE(s1.empty()); + EXPECT_TRUE(s1.data_equal(s1)); + EXPECT_FALSE(s1.data_equal(s0)); MutableByteSpan s2(arr); - NL_TEST_ASSERT(inSuite, s2.data() == arr); - NL_TEST_ASSERT(inSuite, s2.size() == 3); - NL_TEST_ASSERT(inSuite, s2.data()[2] == 3); - NL_TEST_ASSERT(inSuite, !s2.empty()); - NL_TEST_ASSERT(inSuite, s2.data_equal(s2)); - NL_TEST_ASSERT(inSuite, !s2.data_equal(s1)); + EXPECT_EQ(s2.data(), arr); + EXPECT_EQ(s2.size(), 3u); + EXPECT_EQ(s2.data()[2], 3u); + EXPECT_FALSE(s2.empty()); + EXPECT_TRUE(s2.data_equal(s2)); + EXPECT_FALSE(s2.data_equal(s1)); MutableByteSpan s3 = s2; - NL_TEST_ASSERT(inSuite, s3.data() == arr); - NL_TEST_ASSERT(inSuite, s3.size() == 3); - NL_TEST_ASSERT(inSuite, s3.data()[2] == 3); - NL_TEST_ASSERT(inSuite, !s3.empty()); - NL_TEST_ASSERT(inSuite, s3.data_equal(s2)); + EXPECT_EQ(s3.data(), arr); + EXPECT_EQ(s3.size(), 3u); + EXPECT_EQ(s3.data()[2], 3u); + EXPECT_FALSE(s3.empty()); + EXPECT_TRUE(s3.data_equal(s2)); uint8_t arr2[] = { 3, 2, 1 }; MutableByteSpan s4(arr2); - NL_TEST_ASSERT(inSuite, !s4.data_equal(s2)); + EXPECT_FALSE(s4.data_equal(s2)); MutableByteSpan s5(arr2, 0); - NL_TEST_ASSERT(inSuite, s5.data() != nullptr); - NL_TEST_ASSERT(inSuite, !s5.data_equal(s4)); - NL_TEST_ASSERT(inSuite, s5.data_equal(s0)); - NL_TEST_ASSERT(inSuite, s0.data_equal(s5)); + EXPECT_NE(s5.data(), nullptr); + EXPECT_FALSE(s5.data_equal(s4)); + EXPECT_TRUE(s5.data_equal(s0)); + EXPECT_TRUE(s0.data_equal(s5)); MutableByteSpan s6(arr2); s6.reduce_size(2); - NL_TEST_ASSERT(inSuite, s6.size() == 2); + EXPECT_EQ(s6.size(), 2u); MutableByteSpan s7(arr2, 2); - NL_TEST_ASSERT(inSuite, s6.data_equal(s7)); - NL_TEST_ASSERT(inSuite, s7.data_equal(s6)); + EXPECT_TRUE(s6.data_equal(s7)); + EXPECT_TRUE(s7.data_equal(s6)); uint8_t arr3[] = { 1, 2, 3 }; MutableByteSpan s8(arr3); - NL_TEST_ASSERT(inSuite, arr3[1] == 2); + EXPECT_EQ(arr3[1], 2u); s8.data()[1] = 3; - NL_TEST_ASSERT(inSuite, arr3[1] == 3); + EXPECT_EQ(arr3[1], 3u); // Not mutable span on purpose, to test conversion. ByteSpan s9 = s8; - NL_TEST_ASSERT(inSuite, s9.data_equal(s8)); - NL_TEST_ASSERT(inSuite, s8.data_equal(s9)); + EXPECT_TRUE(s9.data_equal(s8)); + EXPECT_TRUE(s8.data_equal(s9)); // Not mutable span on purpose. ByteSpan s10(s8); - NL_TEST_ASSERT(inSuite, s10.data_equal(s8)); - NL_TEST_ASSERT(inSuite, s8.data_equal(s10)); + EXPECT_TRUE(s10.data_equal(s8)); + EXPECT_TRUE(s8.data_equal(s10)); } -static void TestFixedByteSpan(nlTestSuite * inSuite, void * inContext) +TEST(TestSpan, TestFixedByteSpan) { uint8_t arr[] = { 1, 2, 3 }; FixedByteSpan<3> s0 = FixedByteSpan<3>(); - NL_TEST_ASSERT(inSuite, s0.data() != nullptr); - NL_TEST_ASSERT(inSuite, s0.size() == 3); - NL_TEST_ASSERT(inSuite, s0.data_equal(s0)); - NL_TEST_ASSERT(inSuite, s0[0] == 0); - NL_TEST_ASSERT(inSuite, s0[1] == 0); - NL_TEST_ASSERT(inSuite, s0[2] == 0); + EXPECT_NE(s0.data(), nullptr); + EXPECT_EQ(s0.size(), 3u); + EXPECT_TRUE(s0.data_equal(s0)); + EXPECT_EQ(s0[0], 0u); + EXPECT_EQ(s0[1], 0u); + EXPECT_EQ(s0[2], 0u); FixedByteSpan<2> s1(arr); - NL_TEST_ASSERT(inSuite, s1.data() == arr); - NL_TEST_ASSERT(inSuite, s1.size() == 2); - NL_TEST_ASSERT(inSuite, s1.data_equal(s1)); + EXPECT_EQ(s1.data(), arr); + EXPECT_EQ(s1.size(), 2u); + EXPECT_TRUE(s1.data_equal(s1)); FixedByteSpan<3> s2(arr); - NL_TEST_ASSERT(inSuite, s2.data() == arr); - NL_TEST_ASSERT(inSuite, s2.size() == 3); - NL_TEST_ASSERT(inSuite, s2.data()[2] == 3); - NL_TEST_ASSERT(inSuite, s2.data_equal(s2)); - NL_TEST_ASSERT(inSuite, s2.front() == 1); - NL_TEST_ASSERT(inSuite, s2.back() == 3); - NL_TEST_ASSERT(inSuite, s2[0] == 1); - NL_TEST_ASSERT(inSuite, s2[1] == 2); - NL_TEST_ASSERT(inSuite, s2[2] == 3); + EXPECT_EQ(s2.data(), arr); + EXPECT_EQ(s2.size(), 3u); + EXPECT_EQ(s2.data()[2], 3u); + EXPECT_TRUE(s2.data_equal(s2)); + EXPECT_EQ(s2.front(), 1u); + EXPECT_EQ(s2.back(), 3u); + EXPECT_EQ(s2[0], 1u); + EXPECT_EQ(s2[1], 2u); + EXPECT_EQ(s2[2], 3u); FixedByteSpan<3> s3 = s2; - NL_TEST_ASSERT(inSuite, s3.data() == arr); - NL_TEST_ASSERT(inSuite, s3.size() == 3); - NL_TEST_ASSERT(inSuite, s3.data()[2] == 3); - NL_TEST_ASSERT(inSuite, s3.data_equal(s2)); + EXPECT_EQ(s3.data(), arr); + EXPECT_EQ(s3.size(), 3u); + EXPECT_EQ(s3.data()[2], 3u); + EXPECT_TRUE(s3.data_equal(s2)); uint8_t arr2[] = { 3, 2, 1 }; FixedSpan s4(arr2); - NL_TEST_ASSERT(inSuite, !s4.data_equal(s2)); + EXPECT_FALSE(s4.data_equal(s2)); size_t idx = 0; for (auto & entry : s4) { - NL_TEST_ASSERT(inSuite, entry == arr2[idx++]); + EXPECT_EQ(entry, arr2[idx++]); } - NL_TEST_ASSERT(inSuite, idx == 3); + EXPECT_EQ(idx, 3u); FixedByteSpan<3> s5(arr2); - NL_TEST_ASSERT(inSuite, s5.data_equal(s4)); - NL_TEST_ASSERT(inSuite, s4.data_equal(s5)); + EXPECT_TRUE(s5.data_equal(s4)); + EXPECT_TRUE(s4.data_equal(s5)); FixedByteSpan<2> s6(s4); idx = 0; for (auto & entry : s6) { - NL_TEST_ASSERT(inSuite, entry == arr2[idx++]); + EXPECT_EQ(entry, arr2[idx++]); } - NL_TEST_ASSERT(inSuite, idx == 2); + EXPECT_EQ(idx, 2u); // Not fixed, to test conversion. ByteSpan s7(s4); - NL_TEST_ASSERT(inSuite, s7.data_equal(s4)); - NL_TEST_ASSERT(inSuite, s4.data_equal(s7)); + EXPECT_TRUE(s7.data_equal(s4)); + EXPECT_TRUE(s4.data_equal(s7)); MutableByteSpan s8(s4); - NL_TEST_ASSERT(inSuite, s8.data_equal(s4)); - NL_TEST_ASSERT(inSuite, s4.data_equal(s8)); + EXPECT_TRUE(s8.data_equal(s4)); + EXPECT_TRUE(s4.data_equal(s8)); } -static void TestSpanOfPointers(nlTestSuite * inSuite, void * inContext) +TEST(TestSpan, TestSpanOfPointers) { uint8_t x = 5; uint8_t * ptrs[] = { &x, &x }; Span s1(ptrs); Span s2(s1); - NL_TEST_ASSERT(inSuite, s1.data_equal(s2)); - NL_TEST_ASSERT(inSuite, s2.data_equal(s1)); + EXPECT_TRUE(s1.data_equal(s2)); + EXPECT_TRUE(s2.data_equal(s1)); FixedSpan s3(ptrs); FixedSpan s4(s3); - NL_TEST_ASSERT(inSuite, s1.data_equal(s3)); - NL_TEST_ASSERT(inSuite, s3.data_equal(s1)); + EXPECT_TRUE(s1.data_equal(s3)); + EXPECT_TRUE(s3.data_equal(s1)); - NL_TEST_ASSERT(inSuite, s2.data_equal(s3)); - NL_TEST_ASSERT(inSuite, s3.data_equal(s2)); + EXPECT_TRUE(s2.data_equal(s3)); + EXPECT_TRUE(s3.data_equal(s2)); - NL_TEST_ASSERT(inSuite, s1.data_equal(s4)); - NL_TEST_ASSERT(inSuite, s4.data_equal(s1)); + EXPECT_TRUE(s1.data_equal(s4)); + EXPECT_TRUE(s4.data_equal(s1)); - NL_TEST_ASSERT(inSuite, s2.data_equal(s4)); - NL_TEST_ASSERT(inSuite, s4.data_equal(s2)); + EXPECT_TRUE(s2.data_equal(s4)); + EXPECT_TRUE(s4.data_equal(s2)); - NL_TEST_ASSERT(inSuite, s3.data_equal(s4)); - NL_TEST_ASSERT(inSuite, s4.data_equal(s3)); + EXPECT_TRUE(s3.data_equal(s4)); + EXPECT_TRUE(s4.data_equal(s3)); Span s5(s3); - NL_TEST_ASSERT(inSuite, s5.data_equal(s3)); - NL_TEST_ASSERT(inSuite, s3.data_equal(s5)); + EXPECT_TRUE(s5.data_equal(s3)); + EXPECT_TRUE(s3.data_equal(s5)); } -static void TestSubSpan(nlTestSuite * inSuite, void * inContext) +TEST(TestSpan, TestSubSpan) { uint8_t array[16]; ByteSpan span(array); - NL_TEST_ASSERT(inSuite, span.data() == &array[0]); - NL_TEST_ASSERT(inSuite, span.size() == 16); + EXPECT_EQ(span.data(), &array[0]); + EXPECT_EQ(span.size(), 16u); ByteSpan subspan = span.SubSpan(1, 14); - NL_TEST_ASSERT(inSuite, subspan.data() == &array[1]); - NL_TEST_ASSERT(inSuite, subspan.size() == 14); + EXPECT_EQ(subspan.data(), &array[1]); + EXPECT_EQ(subspan.size(), 14u); subspan = span.SubSpan(1, 0); - NL_TEST_ASSERT(inSuite, subspan.size() == 0); + EXPECT_EQ(subspan.size(), 0u); subspan = span.SubSpan(10); - NL_TEST_ASSERT(inSuite, subspan.data() == &array[10]); - NL_TEST_ASSERT(inSuite, subspan.size() == 6); + EXPECT_EQ(subspan.data(), &array[10]); + EXPECT_EQ(subspan.size(), 6u); subspan = span.SubSpan(16); - NL_TEST_ASSERT(inSuite, subspan.size() == 0); + EXPECT_EQ(subspan.size(), 0u); } -static void TestFromZclString(nlTestSuite * inSuite, void * inContext) +TEST(TestSpan, TestFromZclString) { // Purposefully larger size than data. constexpr uint8_t array[16] = { 3, 0x41, 0x63, 0x45 }; @@ -279,26 +278,26 @@ static void TestFromZclString(nlTestSuite * inSuite, void * inContext) static constexpr char str[] = "AcE"; ByteSpan s1 = ByteSpan::fromZclString(array); - NL_TEST_ASSERT(inSuite, s1.data_equal(ByteSpan(&array[1], 3))); + EXPECT_TRUE(s1.data_equal(ByteSpan(&array[1], 3u))); CharSpan s2 = CharSpan::fromZclString(array); - NL_TEST_ASSERT(inSuite, s2.data_equal(CharSpan(str, 3))); + EXPECT_TRUE(s2.data_equal(CharSpan(str, 3))); } -static void TestFromCharString(nlTestSuite * inSuite, void * inContext) +TEST(TestSpan, TestFromCharString) { static constexpr char str[] = "AcE"; CharSpan s1 = CharSpan::fromCharString(str); - NL_TEST_ASSERT(inSuite, s1.data_equal(CharSpan(str, 3))); + EXPECT_TRUE(s1.data_equal(CharSpan(str, 3))); } -static void TestLiteral(nlTestSuite * inSuite, void * inContext) +TEST(TestSpan, TestLiteral) { constexpr CharSpan literal = "HI!"_span; - NL_TEST_ASSERT(inSuite, literal.size() == 3); - NL_TEST_ASSERT(inSuite, literal.data_equal(CharSpan::fromCharString("HI!"))); - NL_TEST_ASSERT(inSuite, ""_span.size() == 0); + EXPECT_EQ(literal.size(), 3u); + EXPECT_TRUE(literal.data_equal(CharSpan::fromCharString("HI!"))); + EXPECT_EQ(""_span.size(), 0u); // These should be compile errors -- if they were allowed they would produce // a CharSpan that includes the trailing '\0' byte in the value. @@ -306,7 +305,7 @@ static void TestLiteral(nlTestSuite * inSuite, void * inContext) // constexpr CharSpan disallowed2{ "abcd" }; } -static void TestConversionConstructors(nlTestSuite * inSuite, void * inContext) +TEST(TestSpan, TestConversionConstructors) { struct Foo { @@ -345,43 +344,15 @@ static void TestConversionConstructors(nlTestSuite * inSuite, void * inContext) ([](FixedSpan f) {})(constArray); ([](Span f) {})(constArray); - NL_TEST_ASSERT(inSuite, span10.data_equal(span10)); - NL_TEST_ASSERT(inSuite, span10.data_equal(span9)); - NL_TEST_ASSERT(inSuite, span10.data_equal(array)); - NL_TEST_ASSERT(inSuite, span10.data_equal(constArray)); - NL_TEST_ASSERT(inSuite, span9.data_equal(span9)); - NL_TEST_ASSERT(inSuite, span9.data_equal(span10)); - NL_TEST_ASSERT(inSuite, span9.data_equal(array)); - NL_TEST_ASSERT(inSuite, span9.data_equal(constArray)); + EXPECT_TRUE(span10.data_equal(span10)); + EXPECT_TRUE(span10.data_equal(span9)); + EXPECT_TRUE(span10.data_equal(array)); + EXPECT_TRUE(span10.data_equal(constArray)); + EXPECT_TRUE(span9.data_equal(span9)); + EXPECT_TRUE(span9.data_equal(span10)); + EXPECT_TRUE(span9.data_equal(array)); + EXPECT_TRUE(span9.data_equal(constArray)); // The following should not compile // Span error1 = std::array(); // Span would point into a temporary value } - -#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(TestByteSpan), - NL_TEST_DEF_FN(TestMutableByteSpan), - NL_TEST_DEF_FN(TestFixedByteSpan), - NL_TEST_DEF_FN(TestSpanOfPointers), - NL_TEST_DEF_FN(TestSubSpan), - NL_TEST_DEF_FN(TestFromZclString), - NL_TEST_DEF_FN(TestFromCharString), - NL_TEST_DEF_FN(TestLiteral), - NL_TEST_DEF_FN(TestConversionConstructors), - NL_TEST_SENTINEL(), -}; - -int TestSpan() -{ - nlTestSuite theSuite = { "CHIP Span tests", &sTests[0], nullptr, nullptr }; - - // Run test suite against one context. - nlTestRunner(&theSuite, nullptr); - return nlTestRunnerStats(&theSuite); -} - -CHIP_REGISTER_TEST_SUITE(TestSpan) diff --git a/src/lib/support/tests/TestStaticSupportSmartPtr.cpp b/src/lib/support/tests/TestStaticSupportSmartPtr.cpp index 809c2e4887969c..b51afc15729ad8 100644 --- a/src/lib/support/tests/TestStaticSupportSmartPtr.cpp +++ b/src/lib/support/tests/TestStaticSupportSmartPtr.cpp @@ -15,14 +15,13 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -#include - -#include -#include #include -#include +#include + +#include +#include using namespace chip; namespace { @@ -50,42 +49,42 @@ TestClass * GlobalInstanceProvider::InstancePointer() namespace { -void TestCheckedGlobalInstanceReference(nlTestSuite * inSuite, void * inContext) +TEST(TestStaticSupportSmartPtr, TestCheckedGlobalInstanceReference) { CheckedGlobalInstanceReference ref(&gTestClass); // We expect that sizes of global references is minimal - NL_TEST_ASSERT(inSuite, sizeof(ref) == 1); + EXPECT_EQ(sizeof(ref), 1u); - NL_TEST_ASSERT(inSuite, ref->num == 123); - NL_TEST_ASSERT(inSuite, strcmp(ref->str, "abc") == 0); + EXPECT_EQ(ref->num, 123); + EXPECT_STREQ(ref->str, "abc"); { ScopedChange change1(gTestClass.num, 100); ScopedChange change2(ref->str, "xyz"); - NL_TEST_ASSERT(inSuite, ref->num == 100); - NL_TEST_ASSERT(inSuite, strcmp(gTestClass.str, "xyz") == 0); + EXPECT_EQ(ref->num, 100); + EXPECT_STREQ(gTestClass.str, "xyz"); } CheckedGlobalInstanceReference ref2(&gTestClass); - NL_TEST_ASSERT(inSuite, ref->num == ref2->num); - NL_TEST_ASSERT(inSuite, strcmp(ref->str, ref2->str) == 0); + EXPECT_EQ(ref->num, ref2->num); + EXPECT_STREQ(ref->str, ref2->str); { ScopedChange change1(gTestClass.num, 321); ScopedChange change2(ref->str, "test"); - NL_TEST_ASSERT(inSuite, ref->num == ref2->num); - NL_TEST_ASSERT(inSuite, strcmp(ref->str, ref2->str) == 0); + EXPECT_EQ(ref->num, ref2->num); + EXPECT_STREQ(ref->str, ref2->str); - NL_TEST_ASSERT(inSuite, ref2->num == 321); - NL_TEST_ASSERT(inSuite, strcmp(ref2->str, "test") == 0); + EXPECT_EQ(ref2->num, 321); + EXPECT_STREQ(ref2->str, "test"); } } -void TestSimpleInstanceReference(nlTestSuite * inSuite, void * inContext) +TEST(TestStaticSupportSmartPtr, TestSimpleInstanceReference) { TestClass a("abc", 123); TestClass b("xyz", 100); @@ -94,34 +93,16 @@ void TestSimpleInstanceReference(nlTestSuite * inSuite, void * inContext) SimpleInstanceReference ref_b(&b); // overhead of simple references should be a simple pointer - NL_TEST_ASSERT(inSuite, sizeof(ref_a) <= sizeof(void *)); + EXPECT_LE(sizeof(ref_a), sizeof(void *)); - NL_TEST_ASSERT(inSuite, ref_a->num == 123); - NL_TEST_ASSERT(inSuite, ref_b->num == 100); + EXPECT_EQ(ref_a->num, 123); + EXPECT_EQ(ref_b->num, 100); ref_a->num = 99; b.num = 30; - NL_TEST_ASSERT(inSuite, a.num == 99); - NL_TEST_ASSERT(inSuite, ref_b->num == 30); + EXPECT_EQ(a.num, 99); + EXPECT_EQ(ref_b->num, 30); } -#define NL_TEST_DEF_FN(fn) NL_TEST_DEF("Test " #fn, fn) -const nlTest sTests[] = { - NL_TEST_DEF_FN(TestCheckedGlobalInstanceReference), - NL_TEST_DEF_FN(TestSimpleInstanceReference), - NL_TEST_SENTINEL(), -}; - } // namespace - -int TestStaticSupportSmartPtr() -{ - nlTestSuite theSuite = { "CHIP Static support smart pointers", &sTests[0], nullptr, nullptr }; - - // Run test suite against one context. - nlTestRunner(&theSuite, nullptr); - return nlTestRunnerStats(&theSuite); -} - -CHIP_REGISTER_TEST_SUITE(TestStaticSupportSmartPtr) diff --git a/src/lib/support/tests/TestTestPersistentStorageDelegate.cpp b/src/lib/support/tests/TestTestPersistentStorageDelegate.cpp index 05ef383f248b14..a53f43c0febaaa 100644 --- a/src/lib/support/tests/TestTestPersistentStorageDelegate.cpp +++ b/src/lib/support/tests/TestTestPersistentStorageDelegate.cpp @@ -18,14 +18,13 @@ #include #include -#include #include #include #include #include -#include +#include using namespace chip; @@ -50,7 +49,7 @@ bool SetMatches(const std::set & set, const std::array expectedContents return true; } -void TestBasicApi(nlTestSuite * inSuite, void * inContext) +TEST(TestTestPersistentStorageDelegate, TestBasicApi) { TestPersistentStorageDelegate storage; @@ -63,49 +62,49 @@ void TestBasicApi(nlTestSuite * inSuite, void * inContext) memset(&buf[0], 0, sizeof(buf)); size = actualSizeOfBuf; err = storage.SyncGetKeyValue("roboto", &buf[0], size); - NL_TEST_ASSERT(inSuite, err == CHIP_ERROR_PERSISTED_STORAGE_VALUE_NOT_FOUND); - NL_TEST_ASSERT(inSuite, size == actualSizeOfBuf); + EXPECT_EQ(err, CHIP_ERROR_PERSISTED_STORAGE_VALUE_NOT_FOUND); + EXPECT_EQ(size, actualSizeOfBuf); - NL_TEST_ASSERT(inSuite, storage.GetNumKeys() == 0); + EXPECT_EQ(storage.GetNumKeys(), 0u); err = storage.SyncDeleteKeyValue("roboto"); - NL_TEST_ASSERT(inSuite, err == CHIP_ERROR_PERSISTED_STORAGE_VALUE_NOT_FOUND); + EXPECT_EQ(err, CHIP_ERROR_PERSISTED_STORAGE_VALUE_NOT_FOUND); // Add basic key, read it back, erase it static const char kStringValue1[] = "abcd"; err = storage.SyncSetKeyValue("roboto", kStringValue1, static_cast(strlen(kStringValue1))); - NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR); + EXPECT_EQ(err, CHIP_NO_ERROR); memset(&buf[0], 0, sizeof(buf)); size = actualSizeOfBuf; err = storage.SyncGetKeyValue("roboto", &buf[0], size); - NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR); - NL_TEST_ASSERT(inSuite, size == strlen(kStringValue1)); - NL_TEST_ASSERT(inSuite, 0 == memcmp(&buf[0], kStringValue1, strlen(kStringValue1))); + EXPECT_EQ(err, CHIP_NO_ERROR); + EXPECT_EQ(size, strlen(kStringValue1)); + EXPECT_EQ(0, memcmp(&buf[0], kStringValue1, strlen(kStringValue1))); err = storage.SyncDeleteKeyValue("roboto"); - NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR); + EXPECT_EQ(err, CHIP_NO_ERROR); memset(&buf[0], 0, sizeof(buf)); size = actualSizeOfBuf; err = storage.SyncGetKeyValue("roboto", &buf[0], size); - NL_TEST_ASSERT(inSuite, err == CHIP_ERROR_PERSISTED_STORAGE_VALUE_NOT_FOUND); - NL_TEST_ASSERT(inSuite, size == actualSizeOfBuf); + EXPECT_EQ(err, CHIP_ERROR_PERSISTED_STORAGE_VALUE_NOT_FOUND); + EXPECT_EQ(size, actualSizeOfBuf); // Validate adding 2 different keys static const char kStringValue2[] = "0123abcd"; static const char kStringValue3[] = "cdef89"; err = storage.SyncSetKeyValue("key2", kStringValue2, static_cast(strlen(kStringValue2))); - NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR); + EXPECT_EQ(err, CHIP_NO_ERROR); err = storage.SyncSetKeyValue("key3", kStringValue3, static_cast(strlen(kStringValue3))); - NL_TEST_ASSERT(inSuite, storage.SyncDoesKeyExist("key3")); - NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR); + EXPECT_TRUE(storage.SyncDoesKeyExist("key3")); + EXPECT_EQ(err, CHIP_NO_ERROR); - NL_TEST_ASSERT(inSuite, storage.GetNumKeys() == 2); + EXPECT_EQ(storage.GetNumKeys(), 2u); auto keys = storage.GetKeys(); std::array kExpectedKeys{ "key2", "key3" }; - NL_TEST_ASSERT(inSuite, SetMatches(keys, kExpectedKeys) == true); + EXPECT_EQ(SetMatches(keys, kExpectedKeys), true); // Read them back @@ -115,164 +114,164 @@ void TestBasicApi(nlTestSuite * inSuite, void * inContext) memset(&buf[0], 0, sizeof(buf)); size = actualSizeOfBuf; err = storage.SyncGetKeyValue("key2", &buf[0], size); - NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR); - NL_TEST_ASSERT(inSuite, size == strlen(kStringValue2)); - NL_TEST_ASSERT(inSuite, 0 == memcmp(&buf[0], kStringValue2, strlen(kStringValue2))); + EXPECT_EQ(err, CHIP_NO_ERROR); + EXPECT_EQ(size, strlen(kStringValue2)); + EXPECT_EQ(0, memcmp(&buf[0], kStringValue2, strlen(kStringValue2))); // Make sure that there was no buffer overflow during SyncGetKeyValue - NL_TEST_ASSERT(inSuite, 0 == memcmp(&buf[size], &all_zeroes[0], sizeof(buf) - size)); + EXPECT_EQ(0, memcmp(&buf[size], &all_zeroes[0], sizeof(buf) - size)); memset(&buf[0], 0, sizeof(buf)); size = actualSizeOfBuf; err = storage.SyncGetKeyValue("key3", &buf[0], size); - NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR); - NL_TEST_ASSERT(inSuite, size == strlen(kStringValue3)); - NL_TEST_ASSERT(inSuite, 0 == memcmp(&buf[0], kStringValue3, strlen(kStringValue3))); + EXPECT_EQ(err, CHIP_NO_ERROR); + EXPECT_EQ(size, strlen(kStringValue3)); + EXPECT_EQ(0, memcmp(&buf[0], kStringValue3, strlen(kStringValue3))); // Make sure that there was no buffer overflow during SyncGetKeyValue - NL_TEST_ASSERT(inSuite, 0 == memcmp(&buf[size], &all_zeroes[0], sizeof(buf) - size)); + EXPECT_EQ(0, memcmp(&buf[size], &all_zeroes[0], sizeof(buf) - size)); // Read providing too small a buffer. Data read up to `size` and nothing more. memset(&buf[0], 0, sizeof(buf)); size = static_cast(strlen(kStringValue2) - 1); uint16_t sizeBeforeGetKeyValueCall = size; err = storage.SyncGetKeyValue("key2", &buf[0], size); - NL_TEST_ASSERT(inSuite, err == CHIP_ERROR_BUFFER_TOO_SMALL); - NL_TEST_ASSERT(inSuite, size == sizeBeforeGetKeyValueCall); - NL_TEST_ASSERT(inSuite, 0 == memcmp(&buf[0], kStringValue2, size)); + EXPECT_EQ(err, CHIP_ERROR_BUFFER_TOO_SMALL); + EXPECT_EQ(size, sizeBeforeGetKeyValueCall); + EXPECT_EQ(0, memcmp(&buf[0], kStringValue2, size)); // Make sure that there was no buffer overflow during SyncGetKeyValue - NL_TEST_ASSERT(inSuite, 0 == memcmp(&buf[size], &all_zeroes[0], sizeof(buf) - size)); + EXPECT_EQ(0, memcmp(&buf[size], &all_zeroes[0], sizeof(buf) - size)); // Read in too small a buffer, which is nullptr and size == 0: check CHIP_ERROR_BUFFER_TOO_SMALL is given. memset(&buf[0], 0, sizeof(buf)); size = 0; sizeBeforeGetKeyValueCall = size; err = storage.SyncGetKeyValue("key2", nullptr, size); - NL_TEST_ASSERT(inSuite, err == CHIP_ERROR_BUFFER_TOO_SMALL); - NL_TEST_ASSERT(inSuite, size != strlen(kStringValue2)); - NL_TEST_ASSERT(inSuite, size == sizeBeforeGetKeyValueCall); + EXPECT_EQ(err, CHIP_ERROR_BUFFER_TOO_SMALL); + EXPECT_NE(size, strlen(kStringValue2)); + EXPECT_EQ(size, sizeBeforeGetKeyValueCall); // Just making sure that implementation doesn't hold onto reference of previous destination buffer when // nullptr is provided. - NL_TEST_ASSERT(inSuite, 0 == memcmp(&buf[0], &all_zeroes[0], sizeof(buf))); + EXPECT_EQ(0, memcmp(&buf[0], &all_zeroes[0], sizeof(buf))); // Read in too small a buffer, which is nullptr and size != 0: error size = static_cast(strlen(kStringValue2) - 1); sizeBeforeGetKeyValueCall = size; err = storage.SyncGetKeyValue("key2", nullptr, size); - NL_TEST_ASSERT(inSuite, err == CHIP_ERROR_INVALID_ARGUMENT); - NL_TEST_ASSERT(inSuite, size == sizeBeforeGetKeyValueCall); + EXPECT_EQ(err, CHIP_ERROR_INVALID_ARGUMENT); + EXPECT_EQ(size, sizeBeforeGetKeyValueCall); // Just making sure that implementation doesn't hold onto reference of previous destination buffer when // nullptr is provided. - NL_TEST_ASSERT(inSuite, 0 == memcmp(&buf[0], &all_zeroes[0], sizeof(buf))); + EXPECT_EQ(0, memcmp(&buf[0], &all_zeroes[0], sizeof(buf))); // When key not found, size is not touched. size = actualSizeOfBuf; err = storage.SyncGetKeyValue("keyDOES_NOT_EXIST", &buf[0], size); - NL_TEST_ASSERT(inSuite, err == CHIP_ERROR_PERSISTED_STORAGE_VALUE_NOT_FOUND); - NL_TEST_ASSERT(inSuite, actualSizeOfBuf == size); - NL_TEST_ASSERT(inSuite, 0 == memcmp(&buf[0], &all_zeroes[0], sizeof(buf))); + EXPECT_EQ(err, CHIP_ERROR_PERSISTED_STORAGE_VALUE_NOT_FOUND); + EXPECT_EQ(actualSizeOfBuf, size); + EXPECT_EQ(0, memcmp(&buf[0], &all_zeroes[0], sizeof(buf))); size = 0; err = storage.SyncGetKeyValue("keyDOES_NOT_EXIST", nullptr, size); - NL_TEST_ASSERT(inSuite, err == CHIP_ERROR_PERSISTED_STORAGE_VALUE_NOT_FOUND); - NL_TEST_ASSERT(inSuite, 0 == size); - NL_TEST_ASSERT(inSuite, 0 == memcmp(&buf[0], &all_zeroes[0], sizeof(buf))); + EXPECT_EQ(err, CHIP_ERROR_PERSISTED_STORAGE_VALUE_NOT_FOUND); + EXPECT_EQ(0, size); + EXPECT_EQ(0, memcmp(&buf[0], &all_zeroes[0], sizeof(buf))); // Even when key not found, cannot pass nullptr with size != 0. size = actualSizeOfBuf; err = storage.SyncGetKeyValue("keyDOES_NOT_EXIST", nullptr, size); - NL_TEST_ASSERT(inSuite, err == CHIP_ERROR_INVALID_ARGUMENT); - NL_TEST_ASSERT(inSuite, actualSizeOfBuf == size); - NL_TEST_ASSERT(inSuite, 0 == memcmp(&buf[0], &all_zeroes[0], size)); + EXPECT_EQ(err, CHIP_ERROR_INVALID_ARGUMENT); + EXPECT_EQ(actualSizeOfBuf, size); + EXPECT_EQ(0, memcmp(&buf[0], &all_zeroes[0], size)); // Attempt an empty key write with either nullptr or zero size works err = storage.SyncSetKeyValue("key2", kStringValue2, 0); - NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR); - NL_TEST_ASSERT(inSuite, storage.SyncDoesKeyExist("key2")); + EXPECT_EQ(err, CHIP_NO_ERROR); + EXPECT_TRUE(storage.SyncDoesKeyExist("key2")); size = 0; err = storage.SyncGetKeyValue("key2", &buf[0], size); - NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR); - NL_TEST_ASSERT(inSuite, size == 0); + EXPECT_EQ(err, CHIP_NO_ERROR); + EXPECT_EQ(size, 0u); size = 0; err = storage.SyncGetKeyValue("key2", nullptr, size); - NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR); - NL_TEST_ASSERT(inSuite, size == 0); + EXPECT_EQ(err, CHIP_NO_ERROR); + EXPECT_EQ(size, 0u); size = actualSizeOfBuf; err = storage.SyncGetKeyValue("key2", &buf[0], size); - NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR); - NL_TEST_ASSERT(inSuite, size == 0); + EXPECT_EQ(err, CHIP_NO_ERROR); + EXPECT_EQ(size, 0u); err = storage.SyncSetKeyValue("key2", nullptr, 0); - NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR); - NL_TEST_ASSERT(inSuite, storage.SyncDoesKeyExist("key2")); + EXPECT_EQ(err, CHIP_NO_ERROR); + EXPECT_TRUE(storage.SyncDoesKeyExist("key2")); size = 0; err = storage.SyncGetKeyValue("key2", &buf[0], size); - NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR); - NL_TEST_ASSERT(inSuite, size == 0); + EXPECT_EQ(err, CHIP_NO_ERROR); + EXPECT_EQ(size, 0u); // Failure to set key if buffer is nullptr and size != 0 size = 10; err = storage.SyncSetKeyValue("key4", nullptr, size); - NL_TEST_ASSERT(inSuite, err == CHIP_ERROR_INVALID_ARGUMENT); - NL_TEST_ASSERT(inSuite, !storage.SyncDoesKeyExist("key4")); + EXPECT_EQ(err, CHIP_ERROR_INVALID_ARGUMENT); + EXPECT_FALSE(storage.SyncDoesKeyExist("key4")); // Can delete empty key err = storage.SyncDeleteKeyValue("key2"); - NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR); + EXPECT_EQ(err, CHIP_NO_ERROR); - NL_TEST_ASSERT(inSuite, !storage.SyncDoesKeyExist("key2")); + EXPECT_FALSE(storage.SyncDoesKeyExist("key2")); size = actualSizeOfBuf; err = storage.SyncGetKeyValue("key2", &buf[0], size); - NL_TEST_ASSERT(inSuite, err == CHIP_ERROR_PERSISTED_STORAGE_VALUE_NOT_FOUND); - NL_TEST_ASSERT(inSuite, size == actualSizeOfBuf); - NL_TEST_ASSERT(inSuite, 0 == memcmp(&buf[0], &all_zeroes[0], size)); + EXPECT_EQ(err, CHIP_ERROR_PERSISTED_STORAGE_VALUE_NOT_FOUND); + EXPECT_EQ(size, actualSizeOfBuf); + EXPECT_EQ(0, memcmp(&buf[0], &all_zeroes[0], size)); // Using key and value with base64 symbols static const char kBase64SymbolsKey[] = "key+/="; static const char kBase64SymbolValues[] = "value+/="; err = storage.SyncSetKeyValue(kBase64SymbolsKey, kBase64SymbolValues, static_cast(strlen(kBase64SymbolValues))); - NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR); + EXPECT_EQ(err, CHIP_NO_ERROR); memset(&buf[0], 0, sizeof(buf)); size = actualSizeOfBuf; err = storage.SyncGetKeyValue(kBase64SymbolsKey, &buf[0], size); - NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR); - NL_TEST_ASSERT(inSuite, size == strlen(kBase64SymbolValues)); - NL_TEST_ASSERT(inSuite, 0 == memcmp(&buf[0], kBase64SymbolValues, strlen(kBase64SymbolValues))); + EXPECT_EQ(err, CHIP_NO_ERROR); + EXPECT_EQ(size, strlen(kBase64SymbolValues)); + EXPECT_EQ(0, memcmp(&buf[0], kBase64SymbolValues, strlen(kBase64SymbolValues))); // Make sure that there was no buffer overflow during SyncGetKeyValue - NL_TEST_ASSERT(inSuite, 0 == memcmp(&buf[size], &all_zeroes[0], sizeof(buf) - size)); + EXPECT_EQ(0, memcmp(&buf[size], &all_zeroes[0], sizeof(buf) - size)); err = storage.SyncDeleteKeyValue(kBase64SymbolsKey); - NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR); - NL_TEST_ASSERT(inSuite, !storage.SyncDoesKeyExist(kBase64SymbolsKey)); + EXPECT_EQ(err, CHIP_NO_ERROR); + EXPECT_FALSE(storage.SyncDoesKeyExist(kBase64SymbolsKey)); // Try using key that is a size that equals PersistentStorageDelegate::kKeyLengthMax char longKeyString[PersistentStorageDelegate::kKeyLengthMax + 1]; memset(&longKeyString, 'X', PersistentStorageDelegate::kKeyLengthMax); longKeyString[sizeof(longKeyString) - 1] = '\0'; // strlen() is not compile time so we just have this runtime assert that should aways pass as a sanity check. - NL_TEST_ASSERT(inSuite, strlen(longKeyString) == PersistentStorageDelegate::kKeyLengthMax); + EXPECT_EQ(strlen(longKeyString), PersistentStorageDelegate::kKeyLengthMax); err = storage.SyncSetKeyValue(longKeyString, kStringValue2, static_cast(strlen(kStringValue2))); - NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR); + EXPECT_EQ(err, CHIP_NO_ERROR); memset(&buf[0], 0, sizeof(buf)); size = actualSizeOfBuf; err = storage.SyncGetKeyValue(longKeyString, &buf[0], size); - NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR); - NL_TEST_ASSERT(inSuite, size == strlen(kStringValue2)); - NL_TEST_ASSERT(inSuite, 0 == memcmp(&buf[0], kStringValue2, strlen(kStringValue2))); + EXPECT_EQ(err, CHIP_NO_ERROR); + EXPECT_EQ(size, strlen(kStringValue2)); + EXPECT_EQ(0, memcmp(&buf[0], kStringValue2, strlen(kStringValue2))); // Make sure that there was no buffer overflow during SyncGetKeyValue - NL_TEST_ASSERT(inSuite, 0 == memcmp(&buf[size], &all_zeroes[0], sizeof(buf) - size)); + EXPECT_EQ(0, memcmp(&buf[size], &all_zeroes[0], sizeof(buf) - size)); - NL_TEST_ASSERT(inSuite, storage.SyncDoesKeyExist(longKeyString)); + EXPECT_TRUE(storage.SyncDoesKeyExist(longKeyString)); err = storage.SyncDeleteKeyValue(longKeyString); - NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR); - NL_TEST_ASSERT(inSuite, !storage.SyncDoesKeyExist(longKeyString)); + EXPECT_EQ(err, CHIP_NO_ERROR); + EXPECT_FALSE(storage.SyncDoesKeyExist(longKeyString)); constexpr size_t kMaxCHIPCertLength = 400; // From credentials/CHIPCert.h and spec uint8_t largeBuffer[kMaxCHIPCertLength]; @@ -281,26 +280,26 @@ void TestBasicApi(nlTestSuite * inSuite, void * inContext) memcpy(largeBufferForCheck, largeBuffer, sizeof(largeBuffer)); err = storage.SyncSetKeyValue(longKeyString, largeBuffer, static_cast(sizeof(largeBuffer))); - NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR); + EXPECT_EQ(err, CHIP_NO_ERROR); memset(&largeBuffer, 0, sizeof(largeBuffer)); size = static_cast(sizeof(largeBuffer)); err = storage.SyncGetKeyValue(longKeyString, &largeBuffer[0], size); - NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR); - NL_TEST_ASSERT(inSuite, size == static_cast(sizeof(largeBuffer))); - NL_TEST_ASSERT(inSuite, 0 == memcmp(&largeBuffer, largeBufferForCheck, sizeof(largeBuffer))); + EXPECT_EQ(err, CHIP_NO_ERROR); + EXPECT_EQ(size, static_cast(sizeof(largeBuffer))); + EXPECT_EQ(0, memcmp(&largeBuffer, largeBufferForCheck, sizeof(largeBuffer))); err = storage.SyncDeleteKeyValue(longKeyString); - NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR); + EXPECT_EQ(err, CHIP_NO_ERROR); // Cleaning up err = storage.SyncDeleteKeyValue("key3"); - NL_TEST_ASSERT(inSuite, storage.GetNumKeys() == 0); + EXPECT_EQ(storage.GetNumKeys(), 0u); } // ClearStorage is not a PersistentStorageDelegate base class method, it only // appears in the TestPersistentStorageDelegate. -void TestClearStorage(nlTestSuite * inSuite, void * inContext) +TEST(TestTestPersistentStorageDelegate, TestClearStorage) { TestPersistentStorageDelegate storage; @@ -308,51 +307,37 @@ void TestClearStorage(nlTestSuite * inSuite, void * inContext) uint16_t size = sizeof(buf); // Key not there - NL_TEST_ASSERT(inSuite, storage.GetNumKeys() == 0); + EXPECT_EQ(storage.GetNumKeys(), 0u); CHIP_ERROR err; memset(&buf[0], 0, sizeof(buf)); size = sizeof(buf); err = storage.SyncGetKeyValue("roboto", &buf[0], size); - NL_TEST_ASSERT(inSuite, err == CHIP_ERROR_PERSISTED_STORAGE_VALUE_NOT_FOUND); - NL_TEST_ASSERT(inSuite, size == sizeof(buf)); + EXPECT_EQ(err, CHIP_ERROR_PERSISTED_STORAGE_VALUE_NOT_FOUND); + EXPECT_EQ(size, sizeof(buf)); // Add basic key, read it back static const char kStringValue1[] = "abcd"; err = storage.SyncSetKeyValue("roboto", kStringValue1, static_cast(strlen(kStringValue1))); - NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR); - NL_TEST_ASSERT(inSuite, storage.GetNumKeys() == 1); + EXPECT_EQ(err, CHIP_NO_ERROR); + EXPECT_EQ(storage.GetNumKeys(), 1u); memset(&buf[0], 0, sizeof(buf)); size = sizeof(buf); err = storage.SyncGetKeyValue("roboto", &buf[0], size); - NL_TEST_ASSERT(inSuite, err == CHIP_NO_ERROR); - NL_TEST_ASSERT(inSuite, size == strlen(kStringValue1)); - NL_TEST_ASSERT(inSuite, 0 == memcmp(&buf[0], kStringValue1, strlen(kStringValue1))); + EXPECT_EQ(err, CHIP_NO_ERROR); + EXPECT_EQ(size, strlen(kStringValue1)); + EXPECT_EQ(0, memcmp(&buf[0], kStringValue1, strlen(kStringValue1))); // Clear storage, make sure it's gone storage.ClearStorage(); - NL_TEST_ASSERT(inSuite, storage.GetNumKeys() == 0); + EXPECT_EQ(storage.GetNumKeys(), 0u); memset(&buf[0], 0, sizeof(buf)); size = sizeof(buf); err = storage.SyncGetKeyValue("roboto", &buf[0], size); - NL_TEST_ASSERT(inSuite, err == CHIP_ERROR_PERSISTED_STORAGE_VALUE_NOT_FOUND); - NL_TEST_ASSERT(inSuite, size == sizeof(buf)); + EXPECT_EQ(err, CHIP_ERROR_PERSISTED_STORAGE_VALUE_NOT_FOUND); + EXPECT_EQ(size, sizeof(buf)); } -const nlTest sTests[] = { NL_TEST_DEF("Test basic API", TestBasicApi), - NL_TEST_DEF("Test ClearStorage method of TestPersistentStorageDelegate", TestClearStorage), - NL_TEST_SENTINEL() }; - } // namespace - -int TestTestPersistentStorageDelegate() -{ - nlTestSuite theSuite = { "TestPersistentStorageDelegate tests", &sTests[0], nullptr, nullptr }; - - nlTestRunner(&theSuite, nullptr); - return nlTestRunnerStats(&theSuite); -} - -CHIP_REGISTER_TEST_SUITE(TestTestPersistentStorageDelegate); diff --git a/src/lib/support/tests/TestUtf8.cpp b/src/lib/support/tests/TestUtf8.cpp index a18ed74f65c8ae..dd078804c1ed5d 100644 --- a/src/lib/support/tests/TestUtf8.cpp +++ b/src/lib/support/tests/TestUtf8.cpp @@ -17,12 +17,10 @@ * limitations under the License. */ -#include - -#include #include -#include +#include +#include namespace { @@ -33,7 +31,7 @@ using namespace chip; { \ uint8_t _buff[] = { __VA_ARGS__ }; \ CharSpan _span(reinterpret_cast(_buff), sizeof(_buff)); \ - NL_TEST_ASSERT(inSuite, Utf8::IsValid(_span)); \ + EXPECT_TRUE(Utf8::IsValid(_span)); \ } while (0) #define TEST_INVALID_BYTES(...) \ @@ -41,42 +39,42 @@ using namespace chip; { \ uint8_t _buff[] = { __VA_ARGS__ }; \ CharSpan _span(reinterpret_cast(_buff), sizeof(_buff)); \ - NL_TEST_ASSERT(inSuite, !Utf8::IsValid(_span)); \ + EXPECT_FALSE(Utf8::IsValid(_span)); \ } while (0) -void TestValidStrings(nlTestSuite * inSuite, void * inContext) +TEST(TestUtf8, TestValidStrings) { - NL_TEST_ASSERT(inSuite, Utf8::IsValid(CharSpan())); // empty span ok + EXPECT_TRUE(Utf8::IsValid(CharSpan())); // empty span ok - NL_TEST_ASSERT(inSuite, Utf8::IsValid(CharSpan::fromCharString(""))); - NL_TEST_ASSERT(inSuite, Utf8::IsValid(CharSpan::fromCharString("abc"))); + EXPECT_TRUE(Utf8::IsValid(CharSpan::fromCharString(""))); + EXPECT_TRUE(Utf8::IsValid(CharSpan::fromCharString("abc"))); // Various tests from https://www.w3.org/2001/06/utf-8-wrong/UTF-8-test.html // Generic UTF8 - NL_TEST_ASSERT(inSuite, Utf8::IsValid(CharSpan::fromCharString("κόσμε"))); + EXPECT_TRUE(Utf8::IsValid(CharSpan::fromCharString("κόσμε"))); // First possible sequence of a certain length - NL_TEST_ASSERT(inSuite, Utf8::IsValid(CharSpan::fromCharString("€"))); - NL_TEST_ASSERT(inSuite, Utf8::IsValid(CharSpan::fromCharString("ࠀ"))); - NL_TEST_ASSERT(inSuite, Utf8::IsValid(CharSpan::fromCharString("𐀀"))); - NL_TEST_ASSERT(inSuite, Utf8::IsValid(CharSpan::fromCharString("�����"))); - NL_TEST_ASSERT(inSuite, Utf8::IsValid(CharSpan::fromCharString("������"))); + EXPECT_TRUE(Utf8::IsValid(CharSpan::fromCharString("€"))); + EXPECT_TRUE(Utf8::IsValid(CharSpan::fromCharString("ࠀ"))); + EXPECT_TRUE(Utf8::IsValid(CharSpan::fromCharString("𐀀"))); + EXPECT_TRUE(Utf8::IsValid(CharSpan::fromCharString("�����"))); + EXPECT_TRUE(Utf8::IsValid(CharSpan::fromCharString("������"))); // Last possible sequence of a certain length - NL_TEST_ASSERT(inSuite, Utf8::IsValid(CharSpan::fromCharString(""))); - NL_TEST_ASSERT(inSuite, Utf8::IsValid(CharSpan::fromCharString("߿"))); - NL_TEST_ASSERT(inSuite, Utf8::IsValid(CharSpan::fromCharString("￿"))); - NL_TEST_ASSERT(inSuite, Utf8::IsValid(CharSpan::fromCharString("����"))); - NL_TEST_ASSERT(inSuite, Utf8::IsValid(CharSpan::fromCharString("�����"))); - NL_TEST_ASSERT(inSuite, Utf8::IsValid(CharSpan::fromCharString("������"))); + EXPECT_TRUE(Utf8::IsValid(CharSpan::fromCharString(""))); + EXPECT_TRUE(Utf8::IsValid(CharSpan::fromCharString("߿"))); + EXPECT_TRUE(Utf8::IsValid(CharSpan::fromCharString("￿"))); + EXPECT_TRUE(Utf8::IsValid(CharSpan::fromCharString("����"))); + EXPECT_TRUE(Utf8::IsValid(CharSpan::fromCharString("�����"))); + EXPECT_TRUE(Utf8::IsValid(CharSpan::fromCharString("������"))); // Other boundary conditions - NL_TEST_ASSERT(inSuite, Utf8::IsValid(CharSpan::fromCharString("퟿"))); - NL_TEST_ASSERT(inSuite, Utf8::IsValid(CharSpan::fromCharString(""))); - NL_TEST_ASSERT(inSuite, Utf8::IsValid(CharSpan::fromCharString("�"))); - NL_TEST_ASSERT(inSuite, Utf8::IsValid(CharSpan::fromCharString("􏿿"))); - NL_TEST_ASSERT(inSuite, Utf8::IsValid(CharSpan::fromCharString("����"))); + EXPECT_TRUE(Utf8::IsValid(CharSpan::fromCharString("퟿"))); + EXPECT_TRUE(Utf8::IsValid(CharSpan::fromCharString(""))); + EXPECT_TRUE(Utf8::IsValid(CharSpan::fromCharString("�"))); + EXPECT_TRUE(Utf8::IsValid(CharSpan::fromCharString("􏿿"))); + EXPECT_TRUE(Utf8::IsValid(CharSpan::fromCharString("����"))); // NOTE: UTF8 allows embeded NULLs // even though strings like that are probably not ideal for handling @@ -84,17 +82,17 @@ void TestValidStrings(nlTestSuite * inSuite, void * inContext) // completely if the spec is updated as such { char zero[16] = { 0 }; - NL_TEST_ASSERT(inSuite, Utf8::IsValid(CharSpan(zero, 0))); - NL_TEST_ASSERT(inSuite, Utf8::IsValid(CharSpan(zero, 1))); - NL_TEST_ASSERT(inSuite, Utf8::IsValid(CharSpan(zero, 2))); - NL_TEST_ASSERT(inSuite, Utf8::IsValid(CharSpan(zero, 3))); - NL_TEST_ASSERT(inSuite, Utf8::IsValid(CharSpan(zero, 4))); - NL_TEST_ASSERT(inSuite, Utf8::IsValid(CharSpan(zero, 16))); + EXPECT_TRUE(Utf8::IsValid(CharSpan(zero, 0))); + EXPECT_TRUE(Utf8::IsValid(CharSpan(zero, 1))); + EXPECT_TRUE(Utf8::IsValid(CharSpan(zero, 2))); + EXPECT_TRUE(Utf8::IsValid(CharSpan(zero, 3))); + EXPECT_TRUE(Utf8::IsValid(CharSpan(zero, 4))); + EXPECT_TRUE(Utf8::IsValid(CharSpan(zero, 16))); } { char insideZero[] = "test\0zero"; - NL_TEST_ASSERT(inSuite, Utf8::IsValid(CharSpan(insideZero))); + EXPECT_TRUE(Utf8::IsValid(CharSpan(insideZero))); } // Test around forbidden 0xD800..0xDFFF UTF-16 surrogate pairs. @@ -102,7 +100,7 @@ void TestValidStrings(nlTestSuite * inSuite, void * inContext) TEST_VALID_BYTES(0b1110'1110, 0b10'000000, 0b10'000000); } -void TestInvalidStrings(nlTestSuite * inSuite, void * inContext) +TEST(TestUtf8, TestInvalidStrings) { // Overly long sequences TEST_INVALID_BYTES(0xc0, 0b10'111111); @@ -169,22 +167,3 @@ void TestInvalidStrings(nlTestSuite * inSuite, void * inContext) } } // namespace - -// clang-format off -const nlTest sTests[] = -{ - NL_TEST_DEF("TestValidStrings", TestValidStrings), - NL_TEST_DEF("TestInvalidStrings", TestInvalidStrings), - NL_TEST_SENTINEL() -}; -// clang-format on - -int TestUtf8() -{ - nlTestSuite theSuite = { "UTF8 validator tests", &sTests[0], nullptr, nullptr }; - - nlTestRunner(&theSuite, nullptr); - return nlTestRunnerStats(&theSuite); -} - -CHIP_REGISTER_TEST_SUITE(TestUtf8);