[scudo][standalone] Make tests work on Fuchsia

[cryptoad]

Summary

This CL makes unit tests compatible with Fuchsia's zxtest. This
required a few changes here and there, but also unearthed some
incompatibilities that had to be addressed.

A header is introduced to allow to account for the zxtest/gtest
differences, some #if SCUDO_FUCHSIA are used to disable incompatible
code (the 32-bit primary, or the exclusive TSD).

It also brought to my attention that I was using
__scudo_default_options in different tests, which ended up in a
single binary, and I am not sure how that ever worked. So move
this to the main cpp.

Additionally fully disable the secondary freelist on Fuchsia as we do
not track VMOs for secondary allocations, so no release possible.

With some modifications to Scudo's BUILD.gn in Fuchsia:

[==========] 79 tests from 23 test cases ran (10280 ms total).
[  PASSED  ] 79 tests

[cryptoad]

Adding allocator_config.h to the diff.

[cryptoad]

Adding the LLVM header to scudo_unit_test.h.

[hctim]

compiler-rt/lib/scudo/standalone/secondary.h

122

I worry about adding ifdefs in core implementation files. Is it possibly a better idea to abstract the freelist away into a platform-specific implementation file? If so, you could also make this configurable at runtime...

[cryptoad]

compiler-rt/lib/scudo/standalone/secondary.h

122

So MaxFreeListSize is set to 0U in the Fuchsia config, which will make this go away, so the SCUDO_FUCHSIA is not needed.
I can change that to a COMPILER_CHECK.

[hctim]

compiler-rt/lib/scudo/standalone/secondary.h

122

SGTM!

[cryptoad]

Remove the SCUDO_FUCHSIA conditionals from the code of the
Secondary and prefer a COMPILER_CHECK instead to ensure that
the freelist is disabled on Fuchsia.

[hctim]

compiler-rt/lib/scudo/standalone/secondary.h

51

Can we remove this ternary-guided default? Looks like it's being manually initialised everywhere.

compiler-rt/lib/scudo/standalone/tests/combined_test.cpp

165

Can we now roll this up?

#if SCUDO_FUCHSIA
  testAllocator<scudo::FuchsiaConfig>();
#else
  testAllocator<scudo::DefaultConfig>();
#endif

219

Same as here

[cryptoad]

compiler-rt/lib/scudo/standalone/secondary.h

51

Stuff like ScudoSecondaryTest, SecondaryBasic use an default templated allocator.
I am open to gating those or leaving the ternary, as you think is better.

compiler-rt/lib/scudo/standalone/tests/combined_test.cpp

165

Ack

219

Ack

[hctim]

compiler-rt/lib/scudo/standalone/secondary.h

51

Personally, I am in favour of the gating of the tests rather than the ternary default.

[cryptoad]

Addressing Mitch's review comments, wrapping things better in #if
and removing the ternary in the default secondary template parameter.

compiler-rt/lib/scudo/standalone/allocator_config.h

#endif
   typedef MapAllocator<0U> Secondary;
   template <class A>
   using TSDRegistryT = TSDRegistrySharedT<A, 1U>; // Shared, only 1 TSD.
 };
 
 struct FuchsiaConfig {
   // 1GB Regions
   typedef SizeClassAllocator64<DefaultSizeClassMap, 30U> Primary;
-  typedef MapAllocator<> Secondary;
+  typedef MapAllocator<0U> Secondary;
   template <class A>
   using TSDRegistryT = TSDRegistrySharedT<A, 8U>; // Shared, max 8 TSDs.
 };
 
 #if SCUDO_ANDROID
 typedef AndroidConfig Config;
 #elif SCUDO_FUCHSIA
 typedef FuchsiaConfig Config;
 #else
 typedef DefaultConfig Config;
 #endif
 
 } // namespace scudo
 
 #endif // SCUDO_ALLOCATOR_CONFIG_H_

compiler-rt/lib/scudo/standalone/secondary.h

 }
 
 static Header *getHeader(const void *Ptr) {
   return getHeader(reinterpret_cast<uptr>(Ptr));
 }
 
 } // namespace LargeBlock
 
 template <uptr MaxFreeListSize = 32U> class MapAllocator {
 public:
   void initLinkerInitialized(GlobalStats *S) {
     Stats.initLinkerInitialized();
     if (LIKELY(S))
       S->link(&Stats);
   }
   void init(GlobalStats *S) {
     memset(this, 0, sizeof(*this));

 void *MapAllocator<MaxFreeListSize>::allocate(uptr Size, uptr AlignmentHint,
                                               uptr *BlockEnd,
                                               bool ZeroContents) {
   DCHECK_GE(Size, AlignmentHint);
   const uptr PageSize = getPageSizeCached();
   const uptr RoundedSize =
       roundUpTo(Size + LargeBlock::getHeaderSize(), PageSize);
 
-  if (MaxFreeListSize && AlignmentHint < PageSize) {
+  if (!SCUDO_FUCHSIA && MaxFreeListSize && AlignmentHint < PageSize) {
     ScopedLock L(Mutex);
     for (auto &H : FreeBlocks) {
       const uptr FreeBlockSize = H.BlockEnd - reinterpret_cast<uptr>(&H);
       if (FreeBlockSize < RoundedSize)
         continue;
       // Candidate free block should only be at most 4 pages larger.
       if (FreeBlockSize > RoundedSize + 4 * PageSize)
         break;
void *MapAllocator<MaxFreeListSize>::allocate(uptr Size, uptr AlignmentHint,
   if (BlockEnd)
     *BlockEnd = CommitBase + CommitSize;
   return reinterpret_cast<void *>(Ptr + LargeBlock::getHeaderSize());
 }
 
 template <uptr MaxFreeListSize>
 void MapAllocator<MaxFreeListSize>::deallocate(void *Ptr) {
   LargeBlock::Header *H = LargeBlock::getHeader(Ptr);
+  const uptr Block = reinterpret_cast<uptr>(H);
   {
     ScopedLock L(Mutex);
     InUseBlocks.remove(H);
-    const uptr CommitSize = H->BlockEnd - reinterpret_cast<uptr>(H);
+    const uptr CommitSize = H->BlockEnd - Block;
     FreedBytes += CommitSize;
     NumberOfFrees++;
     Stats.sub(StatAllocated, CommitSize);
-    if (MaxFreeListSize && FreeBlocks.size() < MaxFreeListSize) {
+    if (!SCUDO_FUCHSIA && MaxFreeListSize &&
+        FreeBlocks.size() < MaxFreeListSize) {
       bool Inserted = false;
       for (auto &F : FreeBlocks) {
         const uptr FreeBlockSize = F.BlockEnd - reinterpret_cast<uptr>(&F);
         if (FreeBlockSize >= CommitSize) {
           FreeBlocks.insert(H, &F);
           Inserted = true;
           break;
         }
       }
       if (!Inserted)
         FreeBlocks.push_back(H);
       const uptr RoundedAllocationStart =
-          roundUpTo(reinterpret_cast<uptr>(H) + LargeBlock::getHeaderSize(),
-                    getPageSizeCached());
+          roundUpTo(Block + LargeBlock::getHeaderSize(), getPageSizeCached());
       MapPlatformData Data = H->Data;
       // TODO(kostyak): use release_to_os_interval_ms
-      releasePagesToOS(H->MapBase, RoundedAllocationStart - H->MapBase,
+      releasePagesToOS(Block, RoundedAllocationStart - Block,
                        H->BlockEnd - RoundedAllocationStart, &Data);
       return;
     }
     Stats.sub(StatMapped, H->MapSize);
   }
   void *Addr = reinterpret_cast<void *>(H->MapBase);
   const uptr Size = H->MapSize;
   MapPlatformData Data = H->Data;

compiler-rt/lib/scudo/standalone/tests/atomic_test.cpp

 //===-- atomic_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 "scudo/standalone/atomic_helpers.h"
-#include "gtest/gtest.h"
+#include "tests/scudo_unit_test.h"
+
+#include "atomic_helpers.h"
 
 namespace scudo {
 
 template <typename T> struct ValAndMagic {
   typename T::Type Magic0;
   T A;
   typename T::Type Magic1;
 

compiler-rt/lib/scudo/standalone/tests/bytemap_test.cpp

 //===-- bytemap_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 "bytemap.h"
+#include "tests/scudo_unit_test.h"
 
-#include "gtest/gtest.h"
+#include "bytemap.h"
 
+#include <pthread.h>
 #include <string.h>
 
 template <typename T> void testMap(T &Map, scudo::uptr Size) {
   Map.init();
   for (scudo::uptr I = 0; I < Size; I += 7)
     Map.set(I, (I % 100) + 1);
   for (scudo::uptr J = 0; J < Size; J++) {
     if (J % 7)

compiler-rt/lib/scudo/standalone/tests/checksum_test.cpp

 //===-- checksum_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 "checksum.h"
+#include "tests/scudo_unit_test.h"
 
-#include "gtest/gtest.h"
+#include "checksum.h"
 
 #include <string.h>
 
 scudo::u16 computeSoftwareChecksum(scudo::u32 Seed, scudo::uptr *Array,
                                    scudo::uptr ArraySize) {
   scudo::u16 Checksum = static_cast<scudo::u16>(Seed & 0xffff);
   for (scudo::uptr I = 0; I < ArraySize; I++)
     Checksum = scudo::computeBSDChecksum(Checksum, Array[I]);

compiler-rt/lib/scudo/standalone/tests/chunk_test.cpp

 //===-- chunk_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 "chunk.h"
+#include "tests/scudo_unit_test.h"
 
-#include "gtest/gtest.h"
+#include "chunk.h"
 
 #include <stdlib.h>
 
 static constexpr scudo::uptr HeaderSize = scudo::Chunk::getHeaderSize();
 static constexpr scudo::u32 Cookie = 0x41424344U;
 static constexpr scudo::u32 InvalidCookie = 0x11223344U;
 
 static void initChecksum(void) {

compiler-rt/lib/scudo/standalone/tests/combined_test.cpp

 //===-- combined_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 "tests/scudo_unit_test.h"
+
 #include "allocator_config.h"
 #include "combined.h"
 
-#include "gtest/gtest.h"
-
 #include <condition_variable>
 #include <mutex>
 #include <thread>
+#include <vector>
 
 static std::mutex Mutex;
 static std::condition_variable Cv;
 static bool Ready = false;
 
 static constexpr scudo::Chunk::Origin Origin = scudo::Chunk::Origin::Malloc;
 
-// This allows us to turn on the Quarantine for specific tests. The Quarantine
-// parameters are on the low end, to avoid having to loop excessively in some
-// tests.
-static bool UseQuarantine = false;
-extern "C" const char *__scudo_default_options() {
-  if (!UseQuarantine)
-    return "";
-  return "quarantine_size_kb=256:thread_local_quarantine_size_kb=128:"
-         "quarantine_max_chunk_size=1024";
-}
-
 template <class Config> static void testAllocator() {
   using AllocatorT = scudo::Allocator<Config>;
   auto Deleter = [](AllocatorT *A) {
     A->unmapTestOnly();
     delete A;
   };
   std::unique_ptr<AllocatorT, decltype(Deleter)> Allocator(new AllocatorT,
                                                            Deleter);
template <class Config> static void testAllocator() {
   // Basic checks on the contents of the statistics output, which also allows us
   // to verify that we got it all.
   EXPECT_NE(Stats.find("Stats: SizeClassAllocator"), std::string::npos);
   EXPECT_NE(Stats.find("Stats: MapAllocator"), std::string::npos);
   EXPECT_NE(Stats.find("Stats: Quarantine"), std::string::npos);
 }
 
 TEST(ScudoCombinedTest, BasicCombined) {
+  UseQuarantine = false;
+#if !SCUDO_FUCHSIA
   testAllocator<scudo::DefaultConfig>();
+#endif
 #if SCUDO_WORDSIZE == 64U
   testAllocator<scudo::FuchsiaConfig>();
 #endif
   // The following configs should work on all platforms.
+  testAllocator<scudo::AndroidSvelteConfig>();
   UseQuarantine = true;
   testAllocator<scudo::AndroidConfig>();
-  UseQuarantine = false;
-  testAllocator<scudo::AndroidSvelteConfig>();
 }
 
 template <typename AllocatorT> static void stressAllocator(AllocatorT *A) {
   {
     std::unique_lock<std::mutex> Lock(Mutex);
     while (!Ready)
       Cv.wait(Lock);
   }
for (scudo::uptr I = 0; I < ARRAY_SIZE(Threads); I++)
     Cv.notify_all();
   }
   for (auto &T : Threads)
     T.join();
   Allocator->releaseToOS();
 }
 
 TEST(ScudoCombinedTest, ThreadedCombined) {
+  UseQuarantine = false;
+#if !SCUDO_FUCHSIA
   testAllocatorThreaded<scudo::DefaultConfig>();
+#endif
 #if SCUDO_WORDSIZE == 64U
   testAllocatorThreaded<scudo::FuchsiaConfig>();
 #endif
+  testAllocatorThreaded<scudo::AndroidSvelteConfig>();
   UseQuarantine = true;
   testAllocatorThreaded<scudo::AndroidConfig>();
-  UseQuarantine = false;
-  testAllocatorThreaded<scudo::AndroidSvelteConfig>();
 }
 
 struct DeathConfig {
   // Tiny allocator, its Primary only serves chunks of 1024 bytes.
   using DeathSizeClassMap = scudo::SizeClassMap<1U, 10U, 10U, 10U, 1U, 10U>;
-  typedef scudo::SizeClassAllocator32<DeathSizeClassMap, 18U> Primary;
+  typedef scudo::SizeClassAllocator64<DeathSizeClassMap, 20U> Primary;
   typedef scudo::MapAllocator<0U> Secondary;
   template <class A> using TSDRegistryT = scudo::TSDRegistrySharedT<A, 1U>;
 };
 
 TEST(ScudoCombinedTest, DeathCombined) {
   using AllocatorT = scudo::Allocator<DeathConfig>;
   auto Deleter = [](AllocatorT *A) {
     A->unmapTestOnly();
     delete A;
   };
   std::unique_ptr<AllocatorT, decltype(Deleter)> Allocator(new AllocatorT,
                                                            Deleter);
   Allocator->reset();
 
   const scudo::uptr Size = 1000U;
   void *P = Allocator->allocate(Size, Origin);
   EXPECT_NE(P, nullptr);
 
   // Invalid sized deallocation.
   EXPECT_DEATH(Allocator->deallocate(P, Origin, Size + 8U), "");
 
-  // Misaligned pointer.
-  void *MisalignedP =
+  // Misaligned pointer. Potentially unused if EXPECT_DEATH isn't available.
+  UNUSED void *MisalignedP =
       reinterpret_cast<void *>(reinterpret_cast<scudo::uptr>(P) | 1U);
   EXPECT_DEATH(Allocator->deallocate(MisalignedP, Origin, Size), "");
   EXPECT_DEATH(Allocator->reallocate(MisalignedP, Size * 2U), "");
 
   // Header corruption.
   scudo::u64 *H =
       reinterpret_cast<scudo::u64 *>(scudo::Chunk::getAtomicHeader(P));
   *H ^= 0x42U;

compiler-rt/lib/scudo/standalone/tests/flags_test.cpp

 //===-- flags_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 "tests/scudo_unit_test.h"
+
 #include "flags.h"
 #include "flags_parser.h"
 
-#include "gtest/gtest.h"
-
 #include <string.h>
 
 static const char FlagName[] = "flag_name";
 static const char FlagDesc[] = "flag description";
 
 template <typename T>
 static void testFlag(scudo::FlagType Type, T StartValue, const char *Env,
                      T FinalValue) {

compiler-rt/lib/scudo/standalone/tests/list_test.cpp

 //===-- list_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 "scudo/standalone/list.h"
-#include "gtest/gtest.h"
+#include "tests/scudo_unit_test.h"
+
+#include "list.h"
 
 struct ListItem {
   ListItem *Next;
   ListItem *Prev;
 };
 
 static ListItem Items[6];
 static ListItem *X = &Items[0];

compiler-rt/lib/scudo/standalone/tests/map_test.cpp

 //===-- map_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 "common.h"
+#include "tests/scudo_unit_test.h"
 
-#include "gtest/gtest.h"
+#include "common.h"
 
 #include <string.h>
 #include <unistd.h>
 
 static const char *MappingName = "scudo:test";
 
 TEST(ScudoMapTest, PageSize) {
   EXPECT_EQ(scudo::getPageSizeCached(),
             static_cast<scudo::uptr>(getpagesize()));
 }
 
 TEST(ScudoMapTest, MapNoAccessUnmap) {
   const scudo::uptr Size = 4 * scudo::getPageSizeCached();
   scudo::MapPlatformData Data = {};
   void *P = scudo::map(nullptr, Size, MappingName, MAP_NOACCESS, &Data);
   EXPECT_NE(P, nullptr);
   EXPECT_DEATH(memset(P, 0xaa, Size), "");
   scudo::unmap(P, Size, UNMAP_ALL, &Data);
 }
 
 TEST(ScudoMapTest, MapUnmap) {
   const scudo::uptr Size = 4 * scudo::getPageSizeCached();
-  scudo::MapPlatformData Data = {};
-  void *P = scudo::map(nullptr, Size, MappingName, 0, &Data);
+  void *P = scudo::map(nullptr, Size, MappingName, 0, nullptr);
   EXPECT_NE(P, nullptr);
   memset(P, 0xaa, Size);
-  scudo::unmap(P, Size, 0, &Data);
+  scudo::unmap(P, Size, 0, nullptr);
   EXPECT_DEATH(memset(P, 0xbb, Size), "");
 }
 
 TEST(ScudoMapTest, MapWithGuardUnmap) {
   const scudo::uptr PageSize = scudo::getPageSizeCached();
   const scudo::uptr Size = 4 * PageSize;
   scudo::MapPlatformData Data = {};
   void *P = scudo::map(nullptr, Size + 2 * PageSize, MappingName, MAP_NOACCESS,

compiler-rt/lib/scudo/standalone/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 "mutex.h"
+#include "tests/scudo_unit_test.h"
 
-#include "gtest/gtest.h"
+#include "mutex.h"
 
+#include <pthread.h>
 #include <string.h>
 
 class TestData {
 public:
   explicit TestData(scudo::HybridMutex &M) : Mutex(M) {
     for (scudo::u32 I = 0; I < Size; I++)
       Data[I] = 0;
   }

compiler-rt/lib/scudo/standalone/tests/primary_test.cpp

 //===-- primary_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 "tests/scudo_unit_test.h"
+
 #include "primary32.h"
 #include "primary64.h"
 #include "size_class_map.h"
 
-#include "gtest/gtest.h"
-
 #include <condition_variable>
 #include <mutex>
 #include <thread>
+#include <vector>
 
 // Note that with small enough regions, the SizeClassAllocator64 also works on
 // 32-bit architectures. It's not something we want to encourage, but we still
 // should ensure the tests pass.
 
 template <typename Primary> static void testPrimary() {
   const scudo::uptr NumberOfAllocations = 32U;
   auto Deleter = [](Primary *P) {
template <typename Primary> static void testPrimary() {
   Allocator->releaseToOS();
   scudo::ScopedString Str(1024);
   Allocator->getStats(&Str);
   Str.output();
 }
 
 TEST(ScudoPrimaryTest, BasicPrimary) {
   using SizeClassMap = scudo::DefaultSizeClassMap;
+#if !SCUDO_FUCHSIA
   testPrimary<scudo::SizeClassAllocator32<SizeClassMap, 18U>>();
+#endif
   testPrimary<scudo::SizeClassAllocator64<SizeClassMap, 24U>>();
 }
 
 // The 64-bit SizeClassAllocator can be easily OOM'd with small region sizes.
 // For the 32-bit one, it requires actually exhausting memory, so we skip it.
 TEST(ScudoPrimaryTest, Primary64OOM) {
   using Primary = scudo::SizeClassAllocator64<scudo::DefaultSizeClassMap, 20U>;
   using TransferBatch = Primary::CacheT::TransferBatch;
   Primary Allocator;
   Allocator.init(/*ReleaseToOsInterval=*/-1);
   typename Primary::CacheT Cache;
   scudo::GlobalStats Stats;
   Stats.init();
   Cache.init(&Stats, &Allocator);
   bool AllocationFailed = false;
   std::vector<TransferBatch *> Batches;
   const scudo::uptr ClassId = Primary::SizeClassMap::LargestClassId;
   const scudo::uptr Size = Primary::getSizeByClassId(ClassId);
   for (scudo::uptr I = 0; I < 10000U; I++) {
     TransferBatch *B = Allocator.popBatch(&Cache, ClassId);
     if (!B) {
       AllocationFailed = true;
       break;
     }
-    for (scudo::uptr J = 0; J < B->getCount(); J++)
+    for (scudo::u32 J = 0; J < B->getCount(); J++)
       memset(B->get(J), 'B', Size);
     Batches.push_back(B);
   }
   while (!Batches.empty()) {
     Allocator.pushBatch(ClassId, Batches.back());
     Batches.pop_back();
   }
   Cache.destroy(nullptr);
template <typename Primary> static void testIteratePrimary() {
   Allocator->releaseToOS();
   scudo::ScopedString Str(1024);
   Allocator->getStats(&Str);
   Str.output();
 }
 
 TEST(ScudoPrimaryTest, PrimaryIterate) {
   using SizeClassMap = scudo::DefaultSizeClassMap;
+#if !SCUDO_FUCHSIA
   testIteratePrimary<scudo::SizeClassAllocator32<SizeClassMap, 18U>>();
+#endif
   testIteratePrimary<scudo::SizeClassAllocator64<SizeClassMap, 24U>>();
 }
 
 static std::mutex Mutex;
 static std::condition_variable Cv;
 static bool Ready = false;
 
 template <typename Primary> static void performAllocations(Primary *Allocator) {
template <typename Primary> static void testPrimaryThreaded() {
   Allocator->releaseToOS();
   scudo::ScopedString Str(1024);
   Allocator->getStats(&Str);
   Str.output();
 }
 
 TEST(ScudoPrimaryTest, PrimaryThreaded) {
   using SizeClassMap = scudo::SvelteSizeClassMap;
+#if !SCUDO_FUCHSIA
   testPrimaryThreaded<scudo::SizeClassAllocator32<SizeClassMap, 18U>>();
+#endif
   testPrimaryThreaded<scudo::SizeClassAllocator64<SizeClassMap, 24U>>();
 }
 
 // Through a simple allocation that spans two pages, verify that releaseToOS
 // actually releases some bytes (at least one page worth). This is a regression
 // test for an error in how the release criteria were computed.
 template <typename Primary> static void testReleaseToOS() {
   auto Deleter = [](Primary *P) {
template <typename Primary> static void testReleaseToOS() {
   EXPECT_NE(P, nullptr);
   Cache.deallocate(ClassId, P);
   Cache.destroy(nullptr);
   EXPECT_GT(Allocator->releaseToOS(), 0U);
 }
 
 TEST(ScudoPrimaryTest, ReleaseToOS) {
   using SizeClassMap = scudo::DefaultSizeClassMap;
+#if !SCUDO_FUCHSIA
   testReleaseToOS<scudo::SizeClassAllocator32<SizeClassMap, 18U>>();
+#endif
   testReleaseToOS<scudo::SizeClassAllocator64<SizeClassMap, 24U>>();
 }

compiler-rt/lib/scudo/standalone/tests/quarantine_test.cpp

 //===-- quarantine_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 "quarantine.h"
+#include "tests/scudo_unit_test.h"
 
-#include "gtest/gtest.h"
+#include "quarantine.h"
 
+#include <pthread.h>
 #include <stdlib.h>
 
 static void *FakePtr = reinterpret_cast<void *>(0xFA83FA83);
 static const scudo::uptr BlockSize = 8UL;
 static const scudo::uptr LargeBlockSize = 16384UL;
 
 struct QuarantineCallback {
   void recycle(void *P) { EXPECT_EQ(P, FakePtr); }

compiler-rt/lib/scudo/standalone/tests/release_test.cpp

 //===-- release_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 "tests/scudo_unit_test.h"
+
 #include "list.h"
 #include "release.h"
 #include "size_class_map.h"
 
-#include "gtest/gtest.h"
-
 #include <string.h>
 
 #include <algorithm>
 #include <random>
+#include <set>
 
 TEST(ScudoReleaseTest, PackedCounterArray) {
   for (scudo::uptr I = 0; I < SCUDO_WORDSIZE; I++) {
     // Various valid counter's max values packed into one word.
     scudo::PackedCounterArray Counters2N(1, 1UL << I);
     EXPECT_EQ(sizeof(scudo::uptr), Counters2N.getBufferSize());
     // Check the "all bit set" values too.
     scudo::PackedCounterArray Counters2N1_1(1, ~0UL >> I);

compiler-rt/lib/scudo/standalone/tests/report_test.cpp

 //===-- report_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 "scudo/standalone/report.h"
-#include "gtest/gtest.h"
+#include "tests/scudo_unit_test.h"
+
+#include "report.h"
 
 TEST(ScudoReportTest, Generic) {
-  void *P = reinterpret_cast<void *>(0x42424242U);
+  // Potentially unused if EXPECT_DEATH isn't defined.
+  UNUSED void *P = reinterpret_cast<void *>(0x42424242U);
   EXPECT_DEATH(scudo::reportError("TEST123"), "Scudo ERROR.*TEST123");
   EXPECT_DEATH(scudo::reportInvalidFlag("ABC", "DEF"), "Scudo ERROR.*ABC.*DEF");
   EXPECT_DEATH(scudo::reportHeaderCorruption(P), "Scudo ERROR.*42424242");
   EXPECT_DEATH(scudo::reportHeaderRace(P), "Scudo ERROR.*42424242");
   EXPECT_DEATH(scudo::reportSanityCheckError("XYZ"), "Scudo ERROR.*XYZ");
   EXPECT_DEATH(scudo::reportAlignmentTooBig(123, 456), "Scudo ERROR.*123.*456");
   EXPECT_DEATH(scudo::reportAllocationSizeTooBig(123, 456, 789),
                "Scudo ERROR.*123.*456.*789");

compiler-rt/lib/scudo/standalone/tests/scudo_unit_test.h

+//===-- scudo_unit_test.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
+//
+//===----------------------------------------------------------------------===//
+
+#include "platform.h"
+
+#if SCUDO_FUCHSIA
+#include <zxtest/zxtest.h>
+#else
+#include "gtest/gtest.h"
+#endif
+
+// If EXPECT_DEATH isn't defined, make it a no-op.
+#ifndef EXPECT_DEATH
+#define EXPECT_DEATH(X, Y)                                                     \
+  do {                                                                         \
+  } while (0)
+#endif
+
+// If EXPECT_STREQ isn't defined, define our own simple one.
+#ifndef EXPECT_STREQ
+#define EXPECT_STREQ(X, Y) EXPECT_EQ(strcmp(X, Y), 0)
+#endif
+
+extern bool UseQuarantine;

compiler-rt/lib/scudo/standalone/tests/scudo_unit_test_main.cpp

 //===-- scudo_unit_test_main.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 "tests/scudo_unit_test.h"
+
+// This allows us to turn on/off a Quarantine for specific tests. The Quarantine
+// parameters are on the low end, to avoid having to loop excessively in some
+// tests.
+bool UseQuarantine = true;
+extern "C" __attribute__((visibility("default"))) const char *
+__scudo_default_options() {
+  if (!UseQuarantine)
+    return "dealloc_type_mismatch=true";
+  return "quarantine_size_kb=256:thread_local_quarantine_size_kb=128:"
+         "quarantine_max_chunk_size=512:dealloc_type_mismatch=true";
+}
 
 int main(int argc, char **argv) {
+#if !SCUDO_FUCHSIA
   testing::InitGoogleTest(&argc, argv);
   return RUN_ALL_TESTS();
+#else
+  return RUN_ALL_TESTS(argc, argv);
+#endif
 }

compiler-rt/lib/scudo/standalone/tests/secondary_test.cpp

 //===-- secondary_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 "secondary.h"
+#include "tests/scudo_unit_test.h"
 
-#include "gtest/gtest.h"
+#include "secondary.h"
 
 #include <stdio.h>
 
 #include <condition_variable>
 #include <mutex>
 #include <random>
 #include <thread>
+#include <vector>
 
 template <class SecondaryT> static void testSecondaryBasic(void) {
   scudo::GlobalStats S;
   S.init();
   SecondaryT *L = new SecondaryT;
   L->init(&S);
   const scudo::uptr Size = 1U << 16;
   void *P = L->allocate(Size);

compiler-rt/lib/scudo/standalone/tests/size_class_map_test.cpp

 //===-- size_class_map_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 "scudo/standalone/size_class_map.h"
-#include "gtest/gtest.h"
+#include "tests/scudo_unit_test.h"
+
+#include "size_class_map.h"
 
 template <class SizeClassMap> void testSizeClassMap() {
   typedef SizeClassMap SCMap;
   SCMap::print();
   SCMap::validate();
 }
 
 TEST(ScudoSizeClassMapTest, DefaultSizeClassMap) {

compiler-rt/lib/scudo/standalone/tests/stats_test.cpp

 //===-- stats_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 "scudo/standalone/stats.h"
-#include "gtest/gtest.h"
+#include "tests/scudo_unit_test.h"
+
+#include "stats.h"
 
 TEST(ScudoStatsTest, LocalStats) {
   scudo::LocalStats LStats;
   LStats.init();
   for (scudo::uptr I = 0; I < scudo::StatCount; I++)
     EXPECT_EQ(LStats.get(static_cast<scudo::StatType>(I)), 0U);
   LStats.add(scudo::StatAllocated, 4096U);
   EXPECT_EQ(LStats.get(scudo::StatAllocated), 4096U);

compiler-rt/lib/scudo/standalone/tests/strings_test.cpp

 //===-- strings_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 "scudo/standalone/string_utils.h"
-#include "gtest/gtest.h"
+#include "tests/scudo_unit_test.h"
+
+#include "string_utils.h"
 
 #include <limits.h>
 
 TEST(ScudoStringsTest, Basic) {
   scudo::ScopedString Str(128);
   Str.append("a%db%zdc%ue%zuf%xh%zxq%pe%sr", static_cast<int>(-1),
              static_cast<scudo::uptr>(-2), static_cast<unsigned>(-4),
              static_cast<scudo::uptr>(5), static_cast<unsigned>(10),

compiler-rt/lib/scudo/standalone/tests/tsd_test.cpp

 //===-- tsd_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 "tests/scudo_unit_test.h"
+
 #include "tsd_exclusive.h"
 #include "tsd_shared.h"
 
-#include "gtest/gtest.h"
-
 #include <condition_variable>
 #include <mutex>
 #include <thread>
 
 // We mock out an allocator with a TSD registry, mostly using empty stubs. The
 // cache contains a single volatile uptr, to be able to test that several
 // concurrent threads will not access or modify the same cache at the same time.
 template <class Config> class MockAllocator {
template <class AllocatorT> static void testRegistry() {
   memset(&TSD->Cache, 0x42, sizeof(TSD->Cache));
   if (UnlockRequired)
     TSD->unlock();
 }
 
 TEST(ScudoTSDTest, TSDRegistryBasic) {
   testRegistry<MockAllocator<OneCache>>();
   testRegistry<MockAllocator<SharedCaches>>();
+#if !SCUDO_FUCHSIA
   testRegistry<MockAllocator<ExclusiveCaches>>();
+#endif
 }
 
 static std::mutex Mutex;
 static std::condition_variable Cv;
 static bool Ready = false;
 
 template <typename AllocatorT> static void stressCache(AllocatorT *Allocator) {
   auto Registry = Allocator->getTSDRegistry();
template <class AllocatorT> static void testRegistryThreaded() {
   }
   for (auto &T : Threads)
     T.join();
 }
 
 TEST(ScudoTSDTest, TSDRegistryThreaded) {
   testRegistryThreaded<MockAllocator<OneCache>>();
   testRegistryThreaded<MockAllocator<SharedCaches>>();
+#if !SCUDO_FUCHSIA
   testRegistryThreaded<MockAllocator<ExclusiveCaches>>();
+#endif
 }

compiler-rt/lib/scudo/standalone/tests/vector_test.cpp

 //===-- vector_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 "vector.h"
+#include "tests/scudo_unit_test.h"
 
-#include "gtest/gtest.h"
+#include "vector.h"
 
 TEST(ScudoVectorTest, Basic) {
   scudo::Vector<int> V;
   EXPECT_EQ(V.size(), 0U);
   V.push_back(42);
   EXPECT_EQ(V.size(), 1U);
   EXPECT_EQ(V[0], 42);
   V.push_back(43);

compiler-rt/lib/scudo/standalone/tests/wrappers_c_test.cpp

 //===-- wrappers_c_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 "platform.h"
-
-#include "gtest/gtest.h"
+#include "tests/scudo_unit_test.h"
 
+#include <errno.h>
 #include <limits.h>
 #include <malloc.h>
 #include <stdlib.h>
 #include <unistd.h>
 
 extern "C" {
 void malloc_enable(void);
 void malloc_disable(void);
 int malloc_iterate(uintptr_t base, size_t size,
                    void (*callback)(uintptr_t base, size_t size, void *arg),
                    void *arg);
 }
 
 // Note that every C allocation function in the test binary will be fulfilled
 // by Scudo (this includes the gtest APIs, etc.), which is a test by itself.
 // But this might also lead to unexpected side-effects, since the allocation and
 // deallocation operations in the TEST functions will coexist with others (see
 // the EXPECT_DEATH comment below).
 
 // We have to use a small quarantine to make sure that our double-free tests
 // trigger. Otherwise EXPECT_DEATH ends up reallocating the chunk that was just
 // freed (this depends on the size obviously) and the following free succeeds.
-extern "C" __attribute__((visibility("default"))) const char *
-__scudo_default_options() {
-  return "quarantine_size_kb=256:thread_local_quarantine_size_kb=128:"
-         "quarantine_max_chunk_size=512";
-}
 
 static const size_t Size = 100U;
 
 TEST(ScudoWrappersCTest, Malloc) {
   void *P = malloc(Size);
   EXPECT_NE(P, nullptr);
   EXPECT_LE(Size, malloc_usable_size(P));
   EXPECT_EQ(reinterpret_cast<uintptr_t>(P) % FIRST_32_SECOND_64(8U, 16U), 0U);

 #ifndef M_DECAY_TIME
 #define M_DECAY_TIME -100
 #endif
 
 #ifndef M_PURGE
 #define M_PURGE -101
 #endif
 
+#if !SCUDO_FUCHSIA
 TEST(ScudoWrappersCTest, MallOpt) {
   errno = 0;
   EXPECT_EQ(mallopt(-1000, 1), 0);
   // mallopt doesn't set errno.
   EXPECT_EQ(errno, 0);
 
   EXPECT_EQ(mallopt(M_PURGE, 0), 1);
 
   EXPECT_EQ(mallopt(M_DECAY_TIME, 1), 1);
   EXPECT_EQ(mallopt(M_DECAY_TIME, 0), 1);
   EXPECT_EQ(mallopt(M_DECAY_TIME, 1), 1);
   EXPECT_EQ(mallopt(M_DECAY_TIME, 0), 1);
 }
+#endif
 
 TEST(ScudoWrappersCTest, OtherAlloc) {
+#if !SCUDO_FUCHSIA
   const size_t PageSize = sysconf(_SC_PAGESIZE);
 
   void *P = pvalloc(Size);
   EXPECT_NE(P, nullptr);
   EXPECT_EQ(reinterpret_cast<uintptr_t>(P) & (PageSize - 1), 0U);
   EXPECT_LE(PageSize, malloc_usable_size(P));
   free(P);
 
   EXPECT_EQ(pvalloc(SIZE_MAX), nullptr);
 
   P = pvalloc(Size);
   EXPECT_NE(P, nullptr);
   EXPECT_EQ(reinterpret_cast<uintptr_t>(P) & (PageSize - 1), 0U);
   free(P);
+#endif
 
   EXPECT_EQ(valloc(SIZE_MAX), nullptr);
 }
 
+#if !SCUDO_FUCHSIA
 TEST(ScudoWrappersCTest, MallInfo) {
   const size_t BypassQuarantineSize = 1024U;
 
   struct mallinfo MI = mallinfo();
   size_t Allocated = MI.uordblks;
   void *P = malloc(BypassQuarantineSize);
   EXPECT_NE(P, nullptr);
   MI = mallinfo();
   EXPECT_GE(static_cast<size_t>(MI.uordblks), Allocated + BypassQuarantineSize);
   EXPECT_GT(static_cast<size_t>(MI.hblkhd), 0U);
   size_t Free = MI.fordblks;
   free(P);
   MI = mallinfo();
   EXPECT_GE(static_cast<size_t>(MI.fordblks), Free + BypassQuarantineSize);
 }
+#endif
 
 static uintptr_t BoundaryP;
 static size_t Count;
 
 static void callback(uintptr_t Base, size_t Size, void *Arg) {
   if (Base == BoundaryP)
     Count++;
 }
TEST(ScudoWrappersCTest, MallocIterateBoundary) {
   malloc_iterate(Block - PageSize, PageSize, callback, nullptr);
   malloc_iterate(Block, PageSize, callback, nullptr);
   malloc_enable();
   EXPECT_EQ(Count, 1U);
 
   free(P);
 }
 
+#if !SCUDO_FUCHSIA
 TEST(ScudoWrappersCTest, MallocInfo) {
   char Buffer[64];
   FILE *F = fmemopen(Buffer, sizeof(Buffer), "w+");
   EXPECT_NE(F, nullptr);
   errno = 0;
   EXPECT_EQ(malloc_info(0, F), 0);
   EXPECT_EQ(errno, 0);
   fclose(F);
   EXPECT_EQ(strncmp(Buffer, "<malloc version=\"scudo-", 23), 0);
 }
+#endif

compiler-rt/lib/scudo/standalone/tests/wrappers_cpp_test.cpp

 //===-- wrappers_cpp_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 "gtest/gtest.h"
+#include "tests/scudo_unit_test.h"
 
 #include <condition_variable>
 #include <mutex>
 #include <thread>
+#include <vector>
 
 void operator delete(void *, size_t) noexcept;
 void operator delete[](void *, size_t) noexcept;
 
 // Note that every Cxx allocation function in the test binary will be fulfilled
 // by Scudo. See the comment in the C counterpart of this file.
 
-extern "C" __attribute__((visibility("default"))) const char *
-__scudo_default_options() {
-  return "quarantine_size_kb=256:thread_local_quarantine_size_kb=128:"
-         "quarantine_max_chunk_size=512:dealloc_type_mismatch=true";
-}
-
 template <typename T> static void testCxxNew() {
   T *P = new T;
   EXPECT_NE(P, nullptr);
   memset(P, 0x42, sizeof(T));
   EXPECT_DEATH(delete[] P, "");
   delete P;
   EXPECT_DEATH(delete P, "");