Fix tests

Author: jlatusek

src/platform/tests/TestConfigurationMgr.cpp

@@ -31,6 +31,7 @@
 #include <gtest/gtest.h>
 #include <lib/support/CHIPMem.h>
 #include <lib/support/CodeUtils.h>
+
 #include <platform/BuildTime.h>
 #include <platform/CHIPDeviceLayer.h>
 #include <platform/DeviceInstanceInfoProvider.h>
@@ -50,6 +51,7 @@ struct TestConfigurationMgr : ::testing::Test
 {
     static void SetUpTestSuite()
     {
+        // ConfigurationManager is initialized from PlatformManager indirectly
         CHIP_ERROR err = chip::Platform::MemoryInit();
         EXPECT_EQ(err, CHIP_NO_ERROR);
         err = PlatformMgr().InitChipStack();
@@ -89,7 +91,7 @@ TEST_F(TestConfigurationMgr, SerialNumber)
     EXPECT_EQ(err, CHIP_NO_ERROR);
 
     EXPECT_EQ(strlen(buf), 12u);
-    ASSERT_STREQ(buf, serialNumber);
+    EXPECT_STREQ(buf, serialNumber);
 
     err = ConfigurationMgr().StoreSerialNumber(serialNumber, 5);
     EXPECT_EQ(err, CHIP_NO_ERROR);
@@ -98,7 +100,7 @@ TEST_F(TestConfigurationMgr, SerialNumber)
     EXPECT_EQ(err, CHIP_NO_ERROR);
 
     EXPECT_EQ(strlen(buf), 5u);
-    ASSERT_STREQ(buf, "89051");
+    EXPECT_STREQ(buf, "89051");
 }
 
 TEST_F(TestConfigurationMgr, UniqueId)
@@ -115,7 +117,7 @@ TEST_F(TestConfigurationMgr, UniqueId)
     EXPECT_EQ(err, CHIP_NO_ERROR);
 
     EXPECT_EQ(strlen(buf), 14u);
-    ASSERT_STREQ(buf, uniqueId);
+    EXPECT_STREQ(buf, uniqueId);
 
     err = ConfigurationMgr().StoreUniqueId(uniqueId, 7);
     EXPECT_EQ(err, CHIP_NO_ERROR);
@@ -124,7 +126,7 @@ TEST_F(TestConfigurationMgr, UniqueId)
     EXPECT_EQ(err, CHIP_NO_ERROR);
 
     EXPECT_EQ(strlen(buf), 7u);
-    ASSERT_STREQ(buf, "67MXAZ0");
+    EXPECT_STREQ(buf, "67MXAZ0");
 }
 
 TEST_F(TestConfigurationMgr, ManufacturingDate)
@@ -265,8 +267,8 @@ TEST_F(TestConfigurationMgr, FirmwareBuildTime)
         const char * timeOfDay = CHIP_DEVICE_CONFIG_FIRMWARE_BUILD_TIME;
 
         // Check that strings look good.
-        EXPECT_TRUE(!BUILD_DATE_IS_BAD(date));
-        EXPECT_TRUE(!BUILD_TIME_IS_BAD(timeOfDay));
+        EXPECT_FALSE(BUILD_DATE_IS_BAD(date));
+        EXPECT_FALSE(BUILD_TIME_IS_BAD(timeOfDay));
         if (BUILD_DATE_IS_BAD(date) || BUILD_TIME_IS_BAD(timeOfDay))
         {
             break;
@@ -299,8 +301,8 @@ TEST_F(TestConfigurationMgr, FirmwareBuildTime)
         }
 
         // Verify match.
-        ASSERT_STREQ(date, parsedDate);
-        ASSERT_STREQ(timeOfDay, parsedTimeOfDay);
+        EXPECT_STREQ(date, parsedDate);
+        EXPECT_STREQ(timeOfDay, parsedTimeOfDay);
     } while (false);
 
     // Generate random chip epoch times and verify that our BuildTime.h parser
@@ -333,8 +335,8 @@ TEST_F(TestConfigurationMgr, FirmwareBuildTime)
         }
 
         // Check that strings look good.
-        EXPECT_TRUE(!BUILD_DATE_IS_BAD(date));
-        EXPECT_TRUE(!BUILD_TIME_IS_BAD(timeOfDay));
+        EXPECT_FALSE(BUILD_DATE_IS_BAD(date));
+        EXPECT_FALSE(BUILD_TIME_IS_BAD(timeOfDay));
         if (BUILD_DATE_IS_BAD(date) || BUILD_TIME_IS_BAD(timeOfDay))
         {
             continue;
@@ -374,7 +376,7 @@ TEST_F(TestConfigurationMgr, CountryCode)
     EXPECT_EQ(err, CHIP_NO_ERROR);
 
     EXPECT_EQ(countryCodeLen, strlen(countryCode));
-    ASSERT_STREQ(buf, countryCode);
+    EXPECT_STREQ(buf, countryCode);
 }
 
 TEST_F(TestConfigurationMgr, GetPrimaryMACAddress)
@@ -464,7 +466,3 @@ TEST_F(TestConfigurationMgr, GetProductId)
 }
 
 } // namespace
-
-/**
- *  Main
- */

src/platform/tests/TestConnectivityMgr.cpp

@@ -50,11 +50,8 @@ struct TestConnectivityMgr : public ::testing::Test
 
     static void SetUpTestSuite()
     {
-        // ConfigurationManager is initialized from PlatformManager indirectly
-        CHIP_ERROR err = PlatformMgr().InitChipStack();
+        auto err = chip::Platform::MemoryInit();
         EXPECT_EQ(err, CHIP_NO_ERROR);
-        err = chip::Platform::MemoryInit();
-        ASSERT_EQ(err, CHIP_NO_ERROR);
     }
 
     static void TearDownTestSuite()
@@ -63,6 +60,12 @@ struct TestConnectivityMgr : public ::testing::Test
         chip::DeviceLayer::PlatformMgr().Shutdown();
     }
 };
+TEST_F(TestConnectivityMgr, Init)
+{
+    // ConfigurationManager is initialized from PlatformManager indirectly
+    CHIP_ERROR err = PlatformMgr().InitChipStack();
+    EXPECT_EQ(err, CHIP_NO_ERROR);
+}
 
 TEST_F(TestConnectivityMgr, GetNetworkInterfaces)
 {
@@ -72,7 +75,7 @@ TEST_F(TestConnectivityMgr, GetNetworkInterfaces)
 
     err = GetDiagnosticDataProvider().GetNetworkInterfaces(&netifs);
     EXPECT_EQ(err, CHIP_NO_ERROR);
-    ASSERT_NE(netifs, nullptr);
+    EXPECT_NE(netifs, nullptr);
 
     GetDiagnosticDataProvider().ReleaseNetworkInterfaces(netifs);
 }

src/platform/tests/TestDnssd.cpp

@@ -41,17 +41,6 @@ using chip::Dnssd::TextEntry;
 
 namespace {
 
-struct DnssdContext
-{
-    std::atomic<bool> mTimeoutExpired{ false };
-
-    intptr_t mBrowseIdentifier = 0;
-
-    unsigned int mBrowsedServicesCount  = 0;
-    unsigned int mResolvedServicesCount = 0;
-    bool mEndOfInput                    = false;
-};
-
 class TestDnssdResolveServerDelegate : public mdns::Minimal::ServerDelegate, public mdns::Minimal::ParserDelegate
 {
 public:
@@ -96,11 +85,19 @@ class TestDnssd : public ::testing::Test
         chip::DeviceLayer::PlatformMgr().Shutdown();
         chip::Platform::MemoryShutdown();
     }
+
+    std::atomic<bool> mTimeoutExpired{ false };
+
+    intptr_t mBrowseIdentifier = 0;
+
+    unsigned int mBrowsedServicesCount  = 0;
+    unsigned int mResolvedServicesCount = 0;
+    bool mEndOfInput                    = false;
 };
 
 static void Timeout(chip::System::Layer * systemLayer, void * context)
 {
-    auto * ctx = static_cast<DnssdContext *>(context);
+    auto * ctx = static_cast<TestDnssd *>(context);
     ChipLogError(DeviceLayer, "mDNS test timeout, is avahi daemon running?");
     ctx->mTimeoutExpired = true;
     chip::DeviceLayer::PlatformMgr().StopEventLoopTask();
@@ -109,16 +106,12 @@ static void Timeout(chip::System::Layer * systemLayer, void * context)
 static void HandleResolve(void * context, DnssdService * result, const chip::Span<chip::Inet::IPAddress> & addresses,
                           CHIP_ERROR error)
 {
-    auto * ctx = static_cast<DnssdContext *>(context);
+    auto * ctx = static_cast<TestDnssd *>(context);
     char addrBuf[100];
 
-    ASSERT_NE(result, nullptr);
+    EXPECT_NE(result, nullptr);
     EXPECT_EQ(error, CHIP_NO_ERROR);
 
-    // The NL_TEST_ASSERT above will not abort the test, so we need to
-    // explicitly abort it here to avoid dereferencing a null pointer.
-    VerifyOrReturn(result != nullptr, );
-
     if (!addresses.empty())
     {
         addresses.data()[0].ToString(addrBuf, sizeof(addrBuf));
@@ -147,7 +140,7 @@ static void HandleResolve(void * context, DnssdService * result, const chip::Spa
 
 static void HandleBrowse(void * context, DnssdService * services, size_t servicesSize, bool finalBrowse, CHIP_ERROR error)
 {
-    auto * ctx   = static_cast<DnssdContext *>(context);
+    auto * ctx = static_cast<TestDnssd *>(context);
 
     // Make sure that we will not be called again after end-of-input is set
     EXPECT_EQ(ctx->mEndOfInput, false);
@@ -177,7 +170,7 @@ static void DnssdErrorCallback(void * context, CHIP_ERROR error)
 
 void TestDnssdBrowse_DnssdInitCallback(void * context, CHIP_ERROR error)
 {
-    auto * ctx = static_cast<DnssdContext *>(context);
+    auto * ctx = static_cast<TestDnssd *>(context);
     EXPECT_EQ(error, CHIP_NO_ERROR);
 
     EXPECT_EQ(ChipDnssdBrowse("_mock", DnssdServiceProtocol::kDnssdProtocolUdp, chip::Inet::IPAddressType::kAny,
@@ -194,8 +187,6 @@ void TestDnssdBrowse_DnssdInitCallback(void * context, CHIP_ERROR error)
 // services by querying for all of these records separately.
 TEST_F(TestDnssd, TestDnssdBrowse)
 {
-    DnssdContext context;
-
     mdns::Minimal::SetDefaultAddressPolicy();
 
     mdns::Minimal::Server<10> server;
@@ -236,18 +227,18 @@ TEST_F(TestDnssd, TestDnssdBrowse)
     auto endpoints = mdns::Minimal::GetAddressPolicy()->GetListenEndpoints();
     EXPECT_EQ(server.Listen(chip::DeviceLayer::UDPEndPointManager(), endpoints.get(), 5353), CHIP_NO_ERROR);
 
-    EXPECT_EQ(chip::Dnssd::ChipDnssdInit(TestDnssdBrowse_DnssdInitCallback, DnssdErrorCallback, &context), CHIP_NO_ERROR);
-    EXPECT_EQ(chip::DeviceLayer::SystemLayer().StartTimer(chip::System::Clock::Seconds32(5), Timeout, &context), CHIP_NO_ERROR);
+    EXPECT_EQ(chip::Dnssd::ChipDnssdInit(TestDnssdBrowse_DnssdInitCallback, DnssdErrorCallback, this), CHIP_NO_ERROR);
+    EXPECT_EQ(chip::DeviceLayer::SystemLayer().StartTimer(chip::System::Clock::Seconds32(5), Timeout, this), CHIP_NO_ERROR);
 
     ChipLogProgress(DeviceLayer, "Start EventLoop");
     chip::DeviceLayer::PlatformMgr().RunEventLoop();
     ChipLogProgress(DeviceLayer, "End EventLoop");
 
-    EXPECT_TRUE(context.mResolvedServicesCount > 0);
-    EXPECT_TRUE(!context.mTimeoutExpired);
+    EXPECT_GT(mResolvedServicesCount, 0);
+    EXPECT_FALSE(mTimeoutExpired);
 
     // Stop browsing so we can safely shutdown DNS-SD
-    chip::Dnssd::ChipDnssdStopBrowse(context.mBrowseIdentifier);
+    chip::Dnssd::ChipDnssdStopBrowse(mBrowseIdentifier);
 
     chip::Dnssd::ChipDnssdShutdown();
 }
@@ -259,7 +250,7 @@ static void HandlePublish(void * context, const char * type, const char * instan
 
 static void TestDnssdPublishService_DnssdInitCallback(void * context, CHIP_ERROR error)
 {
-    auto * ctx = static_cast<DnssdContext *>(context);
+    auto * ctx = static_cast<TestDnssd *>(context);
     EXPECT_EQ(error, CHIP_NO_ERROR);
 
     DnssdService service{};
@@ -277,7 +268,7 @@ static void TestDnssdPublishService_DnssdInitCallback(void * context, CHIP_ERROR
     service.mSubTypes      = nullptr;
     service.mSubTypeSize   = 0;
 
-    EXPECT_EQ(ChipDnssdPublishService(&service, HandlePublish, context), CHIP_NO_ERROR);
+    EXPECT_EQ(ChipDnssdPublishService(&service, HandlePublish, nullptr), CHIP_NO_ERROR);
 
     EXPECT_EQ(ChipDnssdBrowse("_mock", DnssdServiceProtocol::kDnssdProtocolTcp, chip::Inet::IPAddressType::kAny,
                               chip::Inet::InterfaceId::Null(), HandleBrowse, context, &ctx->mBrowseIdentifier),
@@ -291,20 +282,18 @@ static void TestDnssdPublishService_DnssdInitCallback(void * context, CHIP_ERROR
 // here we only verify that the server implementation can publish services.
 TEST_F(TestDnssd, TestDnssdPublishService)
 {
-    DnssdContext context;
-
-    EXPECT_EQ(chip::Dnssd::ChipDnssdInit(TestDnssdPublishService_DnssdInitCallback, DnssdErrorCallback, &context), CHIP_NO_ERROR);
-    EXPECT_EQ(chip::DeviceLayer::SystemLayer().StartTimer(chip::System::Clock::Seconds32(5), Timeout, &context), CHIP_NO_ERROR);
+    EXPECT_EQ(chip::Dnssd::ChipDnssdInit(TestDnssdPublishService_DnssdInitCallback, DnssdErrorCallback, this), CHIP_NO_ERROR);
+    EXPECT_EQ(chip::DeviceLayer::SystemLayer().StartTimer(chip::System::Clock::Seconds32(5), Timeout, this), CHIP_NO_ERROR);
 
     ChipLogProgress(DeviceLayer, "Start EventLoop");
     chip::DeviceLayer::PlatformMgr().RunEventLoop();
     ChipLogProgress(DeviceLayer, "End EventLoop");
 
-    EXPECT_TRUE(context.mResolvedServicesCount > 0);
-    EXPECT_TRUE(!context.mTimeoutExpired);
+    EXPECT_GT(mResolvedServicesCount, 0);
+    EXPECT_FALSE(mTimeoutExpired);
 
     // Stop browsing so we can safely shutdown DNS-SD
-    chip::Dnssd::ChipDnssdStopBrowse(context.mBrowseIdentifier);
+    chip::Dnssd::ChipDnssdStopBrowse(mBrowseIdentifier);
 
     chip::Dnssd::ChipDnssdShutdown();
 }

src/platform/tests/TestKeyValueStoreMgr.cpp

@@ -39,7 +39,7 @@ struct TestKeyValueStoreMgr : public ::testing::Test
     static void SetUpTestSuite()
     {
         CHIP_ERROR err = chip::Platform::MemoryInit();
-        ASSERT_EQ(err, CHIP_NO_ERROR);
+        EXPECT_EQ(err, CHIP_NO_ERROR);
     }
 
     static void TearDownTestSuite() { chip::Platform::MemoryShutdown(); }

src/platform/tests/TestPlatformMgr.cpp

@@ -53,20 +53,15 @@ class TestPlatformMgr : public ::testing::Test
     static void SetUpTestSuite()
     {
         CHIP_ERROR error = chip::Platform::MemoryInit();
-        if (error != CHIP_NO_ERROR)
-            FAIL() << "Failed to initialize memory";
+        EXPECT_EQ(error, CHIP_NO_ERROR);
 
         // Setup a fake commissionable data provider since required by internals of several
         // Device/SystemLayer components.
         static chip::DeviceLayer::TestOnlyCommissionableDataProvider commissionable_data_provider;
         chip::DeviceLayer::SetCommissionableDataProvider(&commissionable_data_provider);
     }
 
-    static void TearDownTestSuite()
-    {
-        chip::Platform::MemoryShutdown();
-        SUCCEED();
-    }
+    static void TearDownTestSuite() { chip::Platform::MemoryShutdown(); }
 };
 
 TEST_F(TestPlatformMgr, InitShutdown)
@@ -199,8 +194,8 @@ TEST_F(TestPlatformMgr, RunEventLoopStopBeforeSleep)
         SleepSome(arg);
     });
 
-    EXPECT_TRUE(!stopRan);
-    EXPECT_TRUE(!sleepRan);
+    EXPECT_FALSE(stopRan);
+    EXPECT_FALSE(sleepRan);
     PlatformMgr().RunEventLoop();
     EXPECT_TRUE(stopRan);
     EXPECT_TRUE(sleepRan);

src/platform/tests/TestPlatformTime.cpp

@@ -29,7 +29,6 @@
 #include <string.h>
 
 #include <lib/support/CodeUtils.h>
-
 #include <gtest/gtest.h>
 #include <lib/support/UnitTestUtils.h>
 #include <system/SystemClock.h>
@@ -76,7 +75,7 @@ TEST(TestDevice, GetMonotonicMicroseconds)
         // verify that timers don't fire early
         EXPECT_GT(Tdelta, (Tdelay - margin));
         // verify they're not too late
-        //        NL_TEST_ASSERT(inSuite, Tdelta < (Tdelay + margin));
+        //        EXPECT_LT(Tdelta, (Tdelay + margin));
         numOfTestsRan++;
     }
     EXPECT_GT(numOfTestsRan, 0);
@@ -110,12 +109,8 @@ TEST(TestDevice, GetMonotonicMilliseconds)
         // verify that timers don't fire early
         EXPECT_GT(Tdelta, (Tdelay - margin));
         // verify they're not too late
-        //        NL_TEST_ASSERT(inSuite, Tdelta < (Tdelay + margin));
+        //        EXPECT_LT(Tdelta, (Tdelay + margin));
         numOfTestsRan++;
     }
     EXPECT_GT(numOfTestsRan, 0);
 }
-
-/**
- *   Test Suite. It lists all the test functions.
- */

src/platform/tests/TestThreadStackMgr.cpp

@@ -79,5 +79,5 @@ TEST(TestThreadStackManager, TestThreadStackManager)
     chip::DeviceLayer::PlatformMgrImpl().RunEventLoop();
     chip::Platform::MemoryShutdown();
 
-    ASSERT_TRUE(eventReceived);
+    EXPECT_TRUE(eventReceived);
 }