Allow building host tests with code coverage (project-chip#33141)

arkq · web-flow · commit a28965b0d829 · 2024-04-25T20:38:43.000Z
* Fix access for == operator defined for AccessControl * Fix nested if warning * Fix access to ==operator and fix mismatched types * Allow building host tests with code coverage * Ignore virtual-device-app build directory * Fix initialization of CHIPoBLEStackMgr with google test * Fix find -exec syntax * Exclude tests from the coverage report * Revert "Ignore virtual-device-app build directory" This reverts commit 2215235.
diff --git a/scripts/build/build/target.py b/scripts/build/build/target.py
@@ -406,7 +406,7 @@ def Create(self, name: str, runner, repository_path: str, output_prefix: str,
         builder.target = self
         builder.identifier = name
         builder.output_dir = os.path.join(output_prefix, name)
-        builder.chip_dir = repository_path
+        builder.chip_dir = os.path.abspath(repository_path)
         builder.options = builder_options
 
         return builder
diff --git a/scripts/build/build/targets.py b/scripts/build/build/targets.py
@@ -177,7 +177,7 @@ def BuildHostTarget():
     target.AppendModifier("ossfuzz", fuzzing_type=HostFuzzingType.OSS_FUZZ).OnlyIfRe(
         "-clang").ExceptIfRe('-libfuzzer')
     target.AppendModifier('coverage', use_coverage=True).OnlyIfRe(
-        '-(chip-tool|all-clusters)')
+        '-(chip-tool|all-clusters|tests)')
     target.AppendModifier('dmalloc', use_dmalloc=True)
     target.AppendModifier('clang', use_clang=True)
     target.AppendModifier('test', extra_tests=True)
diff --git a/scripts/build/builders/host.py b/scripts/build/builders/host.py
@@ -512,19 +512,21 @@ def generate(self):
     def PreBuildCommand(self):
         if self.app == HostApp.TESTS and self.use_coverage:
             self._Execute(['ninja', '-C', self.output_dir, 'default'], title="Build-only")
-            self._Execute(['find', os.path.join(self.output_dir, 'obj/src/'), '-depth',
-                           '-name', 'tests', '-exec', 'rm -rf {} \\;'], title="Cleanup unit tests")
             self._Execute(['lcov', '--initial', '--capture', '--directory', os.path.join(self.output_dir, 'obj'),
+                           '--exclude', os.path.join(self.chip_dir, '**/tests/*'),
                            '--exclude', os.path.join(self.chip_dir, 'zzz_generated/*'),
                            '--exclude', os.path.join(self.chip_dir, 'third_party/*'),
+                           '--exclude', os.path.join(self.chip_dir, 'out/*'),
                            '--exclude', '/usr/include/*',
                            '--output-file', os.path.join(self.coverage_dir, 'lcov_base.info')], title="Initial coverage baseline")
 
     def PostBuildCommand(self):
         if self.app == HostApp.TESTS and self.use_coverage:
             self._Execute(['lcov', '--capture', '--directory', os.path.join(self.output_dir, 'obj'),
+                           '--exclude', os.path.join(self.chip_dir, '**/tests/*'),
                            '--exclude', os.path.join(self.chip_dir, 'zzz_generated/*'),
                            '--exclude', os.path.join(self.chip_dir, 'third_party/*'),
+                           '--exclude', os.path.join(self.chip_dir, 'out/*'),
                            '--exclude', '/usr/include/*',
                            '--output-file', os.path.join(self.coverage_dir, 'lcov_test.info')], title="Update coverage")
             self._Execute(['lcov', '--add-tracefile', os.path.join(self.coverage_dir, 'lcov_base.info'),
diff --git a/src/access/tests/TestAccessControl.cpp b/src/access/tests/TestAccessControl.cpp
@@ -23,7 +23,8 @@
 
 #include <gtest/gtest.h>
 
-namespace {
+namespace chip {
+namespace Access {
 
 using namespace chip;
 using namespace chip::Access;
@@ -2189,4 +2190,5 @@ TEST_F(TestAccessControl, TestUpdateEntry)
     }
 }
 
-} // namespace
+} // namespace Access
+} // namespace chip
diff --git a/src/lib/core/tests/TestTLV.cpp b/src/lib/core/tests/TestTLV.cpp
@@ -859,8 +859,7 @@ void WriteEncoding3(TLVWriter & writer)
         TLVWriter writer1;
 
         err = writer.OpenContainer(ProfileTag(TestProfile_1, 1), kTLVType_Structure, writer1);
-        if (err != CHIP_NO_ERROR)
-            EXPECT_EQ(err, CHIP_NO_ERROR);
+        EXPECT_EQ(err, CHIP_NO_ERROR);
 
         err = writer1.PutBoolean(ProfileTag(TestProfile_2, 2), false);
         EXPECT_EQ(err, CHIP_NO_ERROR);
diff --git a/src/platform/tests/BUILD.gn b/src/platform/tests/BUILD.gn
@@ -78,7 +78,6 @@ if (chip_device_platform != "none" && chip_device_platform != "fake") {
       #
       sources = [
         "TestCHIPoBLEStackMgr.cpp",
-        "TestCHIPoBLEStackMgr.h",
         "TestCHIPoBLEStackMgrDriver.cpp",
       ]
       tests = [ "TestCHIPoBLEStackMgr" ]
diff --git a/src/platform/tests/TestCHIPoBLEStackMgr.h b/src/platform/tests/TestCHIPoBLEStackMgr.h
diff --git a/src/platform/tests/TestCHIPoBLEStackMgrDriver.cpp b/src/platform/tests/TestCHIPoBLEStackMgrDriver.cpp
@@ -15,19 +15,16 @@
  *    limitations under the License.
  */
 
-#include "TestCHIPoBLEStackMgr.h"
 #include <gtest/gtest.h>
 #include <platform/CHIPDeviceConfig.h>
 #include <stdlib.h>
 
 int main(int argc, char * argv[])
 {
-#if CHIP_DEVICE_CONFIG_ENABLE_CHIPOBLE
+    testing::InitGoogleTest(&argc, argv);
     if (argc == 2 && atoi(argv[1]) == 1)
     {
-        testing::InitGoogleTest(nullptr, nullptr);
         return RUN_ALL_TESTS();
     }
     return 0;
-#endif // CHIP_DEVICE_CONFIG_ENABLE_CHIPOBLE
 }
diff --git a/src/system/SystemPacketBuffer.h b/src/system/SystemPacketBuffer.h
@@ -657,6 +657,8 @@ class DLL_EXPORT PacketBufferHandle
 #endif
     }
 
+    bool operator==(const PacketBufferHandle & aOther) const { return mBuffer == aOther.mBuffer; }
+
 protected:
 #if CHIP_SYSTEM_CONFIG_USE_LWIP
     // For use via LwIPPacketBufferView only.
@@ -684,8 +686,7 @@ class DLL_EXPORT PacketBufferHandle
     }
 
     PacketBuffer * Get() const { return mBuffer; }
-
-    bool operator==(const PacketBufferHandle & aOther) const { return mBuffer == aOther.mBuffer; }
+    PacketBuffer * GetNext() const { return static_cast<PacketBuffer *>(mBuffer->next); }
 
 #if CHIP_SYSTEM_PACKETBUFFER_HAS_RIGHTSIZE
     void InternalRightSize();
diff --git a/src/system/tests/TestSystemPacketBuffer.cpp b/src/system/tests/TestSystemPacketBuffer.cpp
@@ -469,13 +469,13 @@ TEST_F_FROM_FIXTURE(TestSystemPacketBuffer, CheckSetDataLength)
                     {
                         EXPECT_EQ(config_2.handle->len, (config_2.end_buffer - config_2.payload_ptr));
                         EXPECT_EQ(config_2.handle->tot_len, (config_2.end_buffer - config_2.payload_ptr));
-                        EXPECT_EQ(config_2.handle->next, nullptr);
+                        EXPECT_EQ(config_2.handle.GetNext(), nullptr);
                     }
                     else
                     {
                         EXPECT_EQ(config_2.handle->len, length);
                         EXPECT_EQ(config_2.handle->tot_len, length);
-                        EXPECT_EQ(config_2.handle->next, nullptr);
+                        EXPECT_EQ(config_2.handle.GetNext(), nullptr);
                     }
                 }
                 else
@@ -487,7 +487,7 @@ TEST_F_FROM_FIXTURE(TestSystemPacketBuffer, CheckSetDataLength)
                     {
                         EXPECT_EQ(config_2.handle->len, (config_2.end_buffer - config_2.payload_ptr));
                         EXPECT_EQ(config_2.handle->tot_len, (config_2.end_buffer - config_2.payload_ptr));
-                        EXPECT_EQ(config_2.handle->next, nullptr);
+                        EXPECT_EQ(config_2.handle.GetNext(), nullptr);
 
                         EXPECT_EQ(config_1.handle->tot_len,
                                   (config_1.init_len + static_cast<int32_t>(config_2.end_buffer - config_2.payload_ptr) -
@@ -497,7 +497,7 @@ TEST_F_FROM_FIXTURE(TestSystemPacketBuffer, CheckSetDataLength)
                     {
                         EXPECT_EQ(config_2.handle->len, length);
                         EXPECT_EQ(config_2.handle->tot_len, length);
-                        EXPECT_EQ(config_2.handle->next, nullptr);
+                        EXPECT_EQ(config_2.handle.GetNext(), nullptr);
 
                         EXPECT_EQ(config_1.handle->tot_len,
                                   (config_1.init_len + static_cast<int32_t>(length) - static_cast<int32_t>(config_2.init_len)));
@@ -632,19 +632,19 @@ TEST_F_FROM_FIXTURE(TestSystemPacketBuffer, CheckAddToEnd)
                 EXPECT_EQ(config_3.handle->ref, 1); // config_3.handle
 
                 EXPECT_EQ(config_1.handle->tot_len, (config_1.init_len + config_2.init_len));
-                EXPECT_EQ(config_1.handle->next, config_2.handle.Get());
-                EXPECT_EQ(config_2.handle->next, nullptr);
-                EXPECT_EQ(config_3.handle->next, nullptr);
+                EXPECT_EQ(config_1.handle.GetNext(), config_2.handle.Get());
+                EXPECT_EQ(config_2.handle.GetNext(), nullptr);
+                EXPECT_EQ(config_3.handle.GetNext(), nullptr);
 
                 config_1.handle->AddToEnd(config_3.handle.Retain());
                 EXPECT_EQ(config_1.handle->ref, 1); // config_1.handle
                 EXPECT_EQ(config_2.handle->ref, 2); // config_2.handle and config_1.handle->next
                 EXPECT_EQ(config_3.handle->ref, 2); // config_3.handle and config_2.handle->next
 
                 EXPECT_EQ(config_1.handle->tot_len, (config_1.init_len + config_2.init_len + config_3.init_len));
-                EXPECT_EQ(config_1.handle->next, config_2.handle.Get());
-                EXPECT_EQ(config_2.handle->next, config_3.handle.Get());
-                EXPECT_EQ(config_3.handle->next, nullptr);
+                EXPECT_EQ(config_1.handle.GetNext(), config_2.handle.Get());
+                EXPECT_EQ(config_2.handle.GetNext(), config_3.handle.Get());
+                EXPECT_EQ(config_3.handle.GetNext(), nullptr);
 
                 config_1.handle = nullptr;
                 config_2.handle = nullptr;
@@ -703,7 +703,7 @@ TEST_F_FROM_FIXTURE(TestSystemPacketBuffer, CheckPopHead)
             const PacketBufferHandle popped = config_1.handle.PopHead();
 
             EXPECT_EQ(config_1.handle, config_2.handle);
-            EXPECT_EQ(config_1.handle->next, nullptr);
+            EXPECT_EQ(config_1.handle.GetNext(), nullptr);
             EXPECT_EQ(config_1.handle->tot_len, config_1.init_len);
         }
     }
@@ -786,7 +786,7 @@ TEST_F_FROM_FIXTURE(TestSystemPacketBuffer, CheckCompactHead)
                     {
                         EXPECT_EQ(config_1.handle->len, config_1.handle->MaxDataLength());
                         EXPECT_EQ(buffer_2->len, config_1.handle->tot_len - config_1.handle->MaxDataLength());
-                        EXPECT_EQ(config_1.handle->next, buffer_2);
+                        EXPECT_EQ(config_1.handle.GetNext(), buffer_2);
                         EXPECT_EQ(config_1.handle->ref, 2);
                         EXPECT_EQ(buffer_2->ref, 1);
                     }
@@ -796,13 +796,13 @@ TEST_F_FROM_FIXTURE(TestSystemPacketBuffer, CheckCompactHead)
                         if (data_length_1 >= config_1.handle->MaxDataLength() && data_length_2 == 0)
                         {
                             /* make sure the second buffer is not freed */
-                            EXPECT_EQ(config_1.handle->next, buffer_2);
+                            EXPECT_EQ(config_1.handle.GetNext(), buffer_2);
                             EXPECT_EQ(buffer_2->ref, 1);
                         }
                         else
                         {
                             /* make sure the second buffer is freed */
-                            EXPECT_EQ(config_1.handle->next, nullptr);
+                            EXPECT_EQ(config_1.handle.GetNext(), nullptr);
                             buffer_2 = nullptr;
                         }
                     }
@@ -1263,7 +1263,7 @@ TEST_F_FROM_FIXTURE(TestSystemPacketBuffer, CheckFree)
                     // Verify that head ref count is decremented.
                     EXPECT_EQ(config_1.handle->ref, initial_refs_1 - 1);
                     // Verify that chain is maintained.
-                    EXPECT_EQ(config_1.handle->next, config_2.handle.Get());
+                    EXPECT_EQ(config_1.handle.GetNext(), config_2.handle.Get());
                     // Verify that chained buffer ref count has not changed.
                     EXPECT_EQ(config_2.handle->ref, initial_refs_2);
                 }

Original file line number	Diff line number	Diff line change
`@@ -23,7 +23,8 @@`
`23`	`23`
`24`	`24`	`#include <gtest/gtest.h>`
`25`	`25`
`26`		`-namespace {`
	`26`	`+namespace chip {`
	`27`	`+namespace Access {`
`27`	`28`
`28`	`29`	`using namespace chip;`
`29`	`30`	`using namespace chip::Access;`
`@@ -2189,4 +2190,5 @@ TEST_F(TestAccessControl, TestUpdateEntry)`
`2189`	`2190`	`}`
`2190`	`2191`	`}`
`2191`	`2192`
`2192`		`-} // namespace`
	`2193`	`+} // namespace Access`
	`2194`	`+} // namespace chip`
Original file line number	Diff line number	Diff line change
`@@ -78,7 +78,6 @@ if (chip_device_platform != "none" && chip_device_platform != "fake") {`
`78`	`78`	`#`
`79`	`79`	`sources = [`
`80`	`80`	`"TestCHIPoBLEStackMgr.cpp",`
`81`		`- "TestCHIPoBLEStackMgr.h",`
`82`	`81`	`"TestCHIPoBLEStackMgrDriver.cpp",`
`83`	`82`	`]`
`84`	`83`	`tests = [ "TestCHIPoBLEStackMgr" ]`
Original file line number	Diff line number	Diff line change
`@@ -15,19 +15,16 @@`
`15`	`15`	`* limitations under the License.`
`16`	`16`	`*/`
`17`	`17`
`18`		`-#include "TestCHIPoBLEStackMgr.h"`
`19`	`18`	`#include <gtest/gtest.h>`
`20`	`19`	`#include <platform/CHIPDeviceConfig.h>`
`21`	`20`	`#include <stdlib.h>`
`22`	`21`
`23`	`22`	`int main(int argc, char * argv[])`
`24`	`23`	`{`
`25`		`-#if CHIP_DEVICE_CONFIG_ENABLE_CHIPOBLE`
	`24`	`+ testing::InitGoogleTest(&argc, argv);`
`26`	`25`	`if (argc == 2 && atoi(argv[1]) == 1)`
`27`	`26`	`{`
`28`		`- testing::InitGoogleTest(nullptr, nullptr);`
`29`	`27`	`return RUN_ALL_TESTS();`
`30`	`28`	`}`
`31`	`29`	`return 0;`
`32`		`-#endif // CHIP_DEVICE_CONFIG_ENABLE_CHIPOBLE`
`33`	`30`	`}`
Original file line number	Diff line number	Diff line change
`@@ -469,13 +469,13 @@ TEST_F_FROM_FIXTURE(TestSystemPacketBuffer, CheckSetDataLength)`
`469`	`469`	`{`
`470`	`470`	`EXPECT_EQ(config_2.handle->len, (config_2.end_buffer - config_2.payload_ptr));`
`471`	`471`	`EXPECT_EQ(config_2.handle->tot_len, (config_2.end_buffer - config_2.payload_ptr));`
`472`		`- EXPECT_EQ(config_2.handle->next, nullptr);`
	`472`	`+ EXPECT_EQ(config_2.handle.GetNext(), nullptr);`
`473`	`473`	`}`
`474`	`474`	`else`
`475`	`475`	`{`
`476`	`476`	`EXPECT_EQ(config_2.handle->len, length);`
`477`	`477`	`EXPECT_EQ(config_2.handle->tot_len, length);`
`478`		`- EXPECT_EQ(config_2.handle->next, nullptr);`
	`478`	`+ EXPECT_EQ(config_2.handle.GetNext(), nullptr);`
`479`	`479`	`}`
`480`	`480`	`}`
`481`	`481`	`else`
`@@ -487,7 +487,7 @@ TEST_F_FROM_FIXTURE(TestSystemPacketBuffer, CheckSetDataLength)`
`487`	`487`	`{`
`488`	`488`	`EXPECT_EQ(config_2.handle->len, (config_2.end_buffer - config_2.payload_ptr));`
`489`	`489`	`EXPECT_EQ(config_2.handle->tot_len, (config_2.end_buffer - config_2.payload_ptr));`
`490`		`- EXPECT_EQ(config_2.handle->next, nullptr);`
	`490`	`+ EXPECT_EQ(config_2.handle.GetNext(), nullptr);`
`491`	`491`
`492`	`492`	`EXPECT_EQ(config_1.handle->tot_len,`
`493`	`493`	`(config_1.init_len + static_cast<int32_t>(config_2.end_buffer - config_2.payload_ptr) -`
`@@ -497,7 +497,7 @@ TEST_F_FROM_FIXTURE(TestSystemPacketBuffer, CheckSetDataLength)`
`497`	`497`	`{`
`498`	`498`	`EXPECT_EQ(config_2.handle->len, length);`
`499`	`499`	`EXPECT_EQ(config_2.handle->tot_len, length);`
`500`		`- EXPECT_EQ(config_2.handle->next, nullptr);`
	`500`	`+ EXPECT_EQ(config_2.handle.GetNext(), nullptr);`
`501`	`501`
`502`	`502`	`EXPECT_EQ(config_1.handle->tot_len,`
`503`	`503`	`(config_1.init_len + static_cast<int32_t>(length) - static_cast<int32_t>(config_2.init_len)));`
`@@ -632,19 +632,19 @@ TEST_F_FROM_FIXTURE(TestSystemPacketBuffer, CheckAddToEnd)`
`632`	`632`	`EXPECT_EQ(config_3.handle->ref, 1); // config_3.handle`
`633`	`633`
`634`	`634`	`EXPECT_EQ(config_1.handle->tot_len, (config_1.init_len + config_2.init_len));`
`635`		`- EXPECT_EQ(config_1.handle->next, config_2.handle.Get());`
`636`		`- EXPECT_EQ(config_2.handle->next, nullptr);`
`637`		`- EXPECT_EQ(config_3.handle->next, nullptr);`
	`635`	`+ EXPECT_EQ(config_1.handle.GetNext(), config_2.handle.Get());`
	`636`	`+ EXPECT_EQ(config_2.handle.GetNext(), nullptr);`
	`637`	`+ EXPECT_EQ(config_3.handle.GetNext(), nullptr);`
`638`	`638`
`639`	`639`	`config_1.handle->AddToEnd(config_3.handle.Retain());`
`640`	`640`	`EXPECT_EQ(config_1.handle->ref, 1); // config_1.handle`
`641`	`641`	`EXPECT_EQ(config_2.handle->ref, 2); // config_2.handle and config_1.handle->next`
`642`	`642`	`EXPECT_EQ(config_3.handle->ref, 2); // config_3.handle and config_2.handle->next`
`643`	`643`
`644`	`644`	`EXPECT_EQ(config_1.handle->tot_len, (config_1.init_len + config_2.init_len + config_3.init_len));`
`645`		`- EXPECT_EQ(config_1.handle->next, config_2.handle.Get());`
`646`		`- EXPECT_EQ(config_2.handle->next, config_3.handle.Get());`
`647`		`- EXPECT_EQ(config_3.handle->next, nullptr);`
	`645`	`+ EXPECT_EQ(config_1.handle.GetNext(), config_2.handle.Get());`
	`646`	`+ EXPECT_EQ(config_2.handle.GetNext(), config_3.handle.Get());`
	`647`	`+ EXPECT_EQ(config_3.handle.GetNext(), nullptr);`
`648`	`648`
`649`	`649`	`config_1.handle = nullptr;`
`650`	`650`	`config_2.handle = nullptr;`
`@@ -703,7 +703,7 @@ TEST_F_FROM_FIXTURE(TestSystemPacketBuffer, CheckPopHead)`
`703`	`703`	`const PacketBufferHandle popped = config_1.handle.PopHead();`
`704`	`704`
`705`	`705`	`EXPECT_EQ(config_1.handle, config_2.handle);`
`706`		`- EXPECT_EQ(config_1.handle->next, nullptr);`
	`706`	`+ EXPECT_EQ(config_1.handle.GetNext(), nullptr);`
`707`	`707`	`EXPECT_EQ(config_1.handle->tot_len, config_1.init_len);`
`708`	`708`	`}`
`709`	`709`	`}`
`@@ -786,7 +786,7 @@ TEST_F_FROM_FIXTURE(TestSystemPacketBuffer, CheckCompactHead)`
`786`	`786`	`{`
`787`	`787`	`EXPECT_EQ(config_1.handle->len, config_1.handle->MaxDataLength());`
`788`	`788`	`EXPECT_EQ(buffer_2->len, config_1.handle->tot_len - config_1.handle->MaxDataLength());`
`789`		`- EXPECT_EQ(config_1.handle->next, buffer_2);`
	`789`	`+ EXPECT_EQ(config_1.handle.GetNext(), buffer_2);`
`790`	`790`	`EXPECT_EQ(config_1.handle->ref, 2);`
`791`	`791`	`EXPECT_EQ(buffer_2->ref, 1);`
`792`	`792`	`}`
`@@ -796,13 +796,13 @@ TEST_F_FROM_FIXTURE(TestSystemPacketBuffer, CheckCompactHead)`
`796`	`796`	`if (data_length_1 >= config_1.handle->MaxDataLength() && data_length_2 == 0)`
`797`	`797`	`{`
`798`	`798`	`/* make sure the second buffer is not freed */`
`799`		`- EXPECT_EQ(config_1.handle->next, buffer_2);`
	`799`	`+ EXPECT_EQ(config_1.handle.GetNext(), buffer_2);`
`800`	`800`	`EXPECT_EQ(buffer_2->ref, 1);`
`801`	`801`	`}`
`802`	`802`	`else`
`803`	`803`	`{`
`804`	`804`	`/* make sure the second buffer is freed */`
`805`		`- EXPECT_EQ(config_1.handle->next, nullptr);`
	`805`	`+ EXPECT_EQ(config_1.handle.GetNext(), nullptr);`
`806`	`806`	`buffer_2 = nullptr;`
`807`	`807`	`}`
`808`	`808`	`}`
`@@ -1263,7 +1263,7 @@ TEST_F_FROM_FIXTURE(TestSystemPacketBuffer, CheckFree)`
`1263`	`1263`	`// Verify that head ref count is decremented.`
`1264`	`1264`	`EXPECT_EQ(config_1.handle->ref, initial_refs_1 - 1);`
`1265`	`1265`	`// Verify that chain is maintained.`
`1266`		`- EXPECT_EQ(config_1.handle->next, config_2.handle.Get());`
	`1266`	`+ EXPECT_EQ(config_1.handle.GetNext(), config_2.handle.Get());`
`1267`	`1267`	`// Verify that chained buffer ref count has not changed.`
`1268`	`1268`	`EXPECT_EQ(config_2.handle->ref, initial_refs_2);`
`1269`	`1269`	`}`