[GWP-ASan] Port tests to Fuchsia

[cryptoad]

Summary

This modifies the tests so that they can be run on Fuchsia:

• add the necessary includes for set/vector etc
• do the few modifications required to use zxtest instead og gtest

backtrace.cpp requires stacktrace support that Fuchsia doesn't have
yet, and enable_disable.cpp currently uses fork() which Fuchsia
doesn't support yet. I'll revisit this later.

I chose to use harness.h to hold my "platform-specific" include and
namespace, and using this header in tests rather than gtest.h,
which I am open to change if someone would rather go another direction.

[hctim]

If we need to have more platform-specific code then we'll look at adding a platform-specific subfolder to tests, but I'm okay with this as is.

[mcgrathr]

lgtm

[phosek]

compiler-rt/lib/gwp_asan/tests/harness.h

15

Not an immediate concern, but when we start running compiler-rt tests on Fuchsia, this may become an issue because we don't ship zxtest in our SDK. We might need to come up with a different solution then, for example have a dedicated define to control which test framework is being used.

compiler-rt/lib/gwp_asan/tests/alignment.cpp

 //===-- alignment.cpp -------------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "gwp_asan/tests/harness.h"
 #include "gwp_asan/utilities.h"
 
+#include <vector>
+
 TEST(AlignmentTest, PowerOfTwo) {
   std::vector<std::pair<size_t, size_t>> AskedSizeToAlignedSize = {
       {1, 1},   {2, 2},   {3, 4},       {4, 4},       {5, 8},   {7, 8},
       {8, 8},   {9, 16},  {15, 16},     {16, 16},     {17, 32}, {31, 32},
       {32, 32}, {33, 48}, {4095, 4096}, {4096, 4096},
   };
 
   for (const auto &KV : AskedSizeToAlignedSize) {

compiler-rt/lib/gwp_asan/tests/compression.cpp

 //===-- compression.cpp -----------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "gwp_asan/stack_trace_compressor.h"
-#include "gtest/gtest.h"
+#include "gwp_asan/tests/harness.h"
 
 namespace gwp_asan {
 namespace compression {
 
 TEST(GwpAsanCompressionTest, SingleByteVarInt) {
   uint8_t Compressed[1];
 
   uintptr_t Uncompressed = 0x00;

compiler-rt/lib/gwp_asan/tests/crash_handler_api.cpp

 #include "gwp_asan/stack_trace_compressor.h"
 #include "gwp_asan/tests/harness.h"
 
 using Error = gwp_asan::Error;
 using GuardedPoolAllocator = gwp_asan::GuardedPoolAllocator;
 using AllocationMetadata = gwp_asan::AllocationMetadata;
 using AllocatorState = gwp_asan::AllocatorState;
 
-class CrashHandlerAPITest : public ::testing::Test {
+class CrashHandlerAPITest : public Test {
 public:
   void SetUp() override { setupState(); }
 
 protected:
   size_t metadata(uintptr_t Addr, uintptr_t Size, bool IsDeallocated) {
     // Should only be allocating the 0x3000, 0x5000, 0x7000, 0x9000 pages.
     EXPECT_GE(Addr, 0x3000u);
     EXPECT_LT(Addr, 0xa000u);

compiler-rt/lib/gwp_asan/tests/driver.cpp

 //===-- driver.cpp ----------------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
-#include "gtest/gtest.h"
+#include "gwp_asan/tests/harness.h"
 
 int main(int argc, char **argv) {
   testing::InitGoogleTest(&argc, argv);
   return RUN_ALL_TESTS();
 }

compiler-rt/lib/gwp_asan/tests/harness.h

 //===-- harness.h -----------------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef GWP_ASAN_TESTS_HARNESS_H_
 #define GWP_ASAN_TESTS_HARNESS_H_
 
 #include <stdarg.h>
 
+#if defined(__Fuchsia__)
+#include <zxtest/zxtest.h>
+using Test = ::zxtest::Test;
+#else
 #include "gtest/gtest.h"
+using Test = ::testing::Test;
+#endif
 
 #include "gwp_asan/guarded_pool_allocator.h"
 #include "gwp_asan/optional/backtrace.h"
 #include "gwp_asan/optional/segv_handler.h"
 #include "gwp_asan/options.h"
 
 namespace gwp_asan {
 namespace test {
 // This printf-function getter allows other platforms (e.g. Android) to define
 // their own signal-safe Printf function. In LLVM, we use
 // `optional/printf_sanitizer_common.cpp` which supplies the __sanitizer::Printf
 // for this purpose.
 crash_handler::Printf_t getPrintfFunction();
 
 // First call returns true, all the following calls return false.
 bool OnlyOnce();
 
 }; // namespace test
 }; // namespace gwp_asan
 
-class DefaultGuardedPoolAllocator : public ::testing::Test {
+class DefaultGuardedPoolAllocator : public Test {
 public:
   void SetUp() override {
     gwp_asan::options::Options Opts;
     Opts.setDefaults();
     MaxSimultaneousAllocations = Opts.MaxSimultaneousAllocations;
 
     Opts.InstallForkHandlers = gwp_asan::test::OnlyOnce();
     GPA.init(Opts);
   }
 
   void TearDown() override { GPA.uninitTestOnly(); }
 
 protected:
   gwp_asan::GuardedPoolAllocator GPA;
   decltype(gwp_asan::options::Options::MaxSimultaneousAllocations)
       MaxSimultaneousAllocations;
 };
 
-class CustomGuardedPoolAllocator : public ::testing::Test {
+class CustomGuardedPoolAllocator : public Test {
 public:
   void
   InitNumSlots(decltype(gwp_asan::options::Options::MaxSimultaneousAllocations)
                    MaxSimultaneousAllocationsArg) {
     gwp_asan::options::Options Opts;
     Opts.setDefaults();
 
     Opts.MaxSimultaneousAllocations = MaxSimultaneousAllocationsArg;
     MaxSimultaneousAllocations = MaxSimultaneousAllocationsArg;
 
     Opts.InstallForkHandlers = gwp_asan::test::OnlyOnce();
     GPA.init(Opts);
   }
 
   void TearDown() override { GPA.uninitTestOnly(); }
 
 protected:
   gwp_asan::GuardedPoolAllocator GPA;
   decltype(gwp_asan::options::Options::MaxSimultaneousAllocations)
       MaxSimultaneousAllocations;
 };
 
-class BacktraceGuardedPoolAllocator : public ::testing::Test {
+class BacktraceGuardedPoolAllocator : public Test {
 public:
   void SetUp() override {
     gwp_asan::options::Options Opts;
     Opts.setDefaults();
 
     Opts.Backtrace = gwp_asan::options::getBacktraceFunction();
     Opts.InstallForkHandlers = gwp_asan::test::OnlyOnce();
     GPA.init(Opts);

compiler-rt/lib/gwp_asan/tests/harness.cpp

-#include "harness.h"
+//===-- harness.cpp ---------------------------------------------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#include "gwp_asan/tests/harness.h"
 
 namespace gwp_asan {
 namespace test {
 bool OnlyOnce() {
   static int x = 0;
   return !x++;
 }
 } // namespace test
 } // namespace gwp_asan

compiler-rt/lib/gwp_asan/tests/iterate.cpp

 //===-- iterate.cpp ---------------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "gwp_asan/tests/harness.h"
 
+#include <set>
+#include <vector>
+
 TEST_F(CustomGuardedPoolAllocator, Iterate) {
   InitNumSlots(7);
   std::vector<std::pair<void *, size_t>> Allocated;
   auto alloc = [&](size_t size) {
     Allocated.push_back({GPA.allocate(size), size});
   };
 
   void *Ptr = GPA.allocate(5);

compiler-rt/lib/gwp_asan/tests/late_init.cpp

 //===-- late_init.cpp -------------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "gwp_asan/guarded_pool_allocator.h"
 #include "gwp_asan/options.h"
-#include "gtest/gtest.h"
+#include "gwp_asan/tests/harness.h"
 
 TEST(LateInit, CheckLateInitIsOK) {
   gwp_asan::GuardedPoolAllocator GPA;
 
   for (size_t i = 0; i < 0x100; ++i)
     EXPECT_FALSE(GPA.shouldSample());
 
   gwp_asan::options::Options Opts;
   Opts.Enabled = true;
   Opts.SampleRate = 1;
 
   GPA.init(Opts);
   EXPECT_TRUE(GPA.shouldSample());
 }

compiler-rt/lib/gwp_asan/tests/mutex_test.cpp

 //===-- mutex_test.cpp ------------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "gwp_asan/mutex.h"
-#include "gtest/gtest.h"
+#include "gwp_asan/tests/harness.h"
 
 #include <atomic>
 #include <mutex>
 #include <thread>
 #include <vector>
 
 using gwp_asan::Mutex;
 using gwp_asan::ScopedLock;

compiler-rt/lib/gwp_asan/tests/slot_reuse.cpp

 //===-- slot_reuse.cpp ------------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "gwp_asan/tests/harness.h"
 
+#include <set>
+
 void singleByteGoodAllocDealloc(gwp_asan::GuardedPoolAllocator *GPA) {
   void *Ptr = GPA->allocate(1);
   EXPECT_NE(nullptr, Ptr);
   EXPECT_TRUE(GPA->pointerIsMine(Ptr));
   EXPECT_EQ(1u, GPA->getSize(Ptr));
   GPA->deallocate(Ptr);
 }