[scudo] Restore zxtest compatibility

[cryptoad]

I manually patched that in, it compiles, but now I am hitting an early page fault so something else (not related to this) is likely wrong.
Investigating.

[vitalybuka]

In D100426#2687449, @cryptoad wrote:

I manually patched that in, it compiles, but now I am hitting an early page fault so something else (not related to this) is likely wrong.
Investigating.

I assume D99766 should not be relevant because DefaultConfig is not tested on SCUDO_FUCHSIA ?

[cryptoad]

In D100426#2689545, @vitalybuka wrote:

I assume D99766 should not be relevant because DefaultConfig is not tested on SCUDO_FUCHSIA ?

The roll hasn't happened in a while so I had to bisect the CLs.
I tracked it down to https://reviews.llvm.org/D96435, specifically the increase in the size class map of the default num cached from 8 to 10 (eg: the CL works with 8, but not with 10).
This boggles me a bit because I thought I tested that back then, and also I don't see immediately why the increase here ends up triggering an access violation on Fuchsia.
Still trying to debug it.

[cryptoad]

As far as I can tell this works.
With a few extra fixes:

[==========] 183 tests from 87 test cases ran (10944 ms total).
[  PASSED  ] 183 tests

This helped unearthed a few things that I have to address in a separate CL.

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

TestAllocator() {
     this->initThreadMaybe();
     if (scudo::archSupportsMemoryTagging() &&
         !scudo::systemDetectsMemoryTagFaultsTestOnly())
       this->disableMemoryTagging();
   }
   ~TestAllocator() { this->unmapTestOnly(); }
 };
 
-SCUDO_DEFINE_GTEST_TYPE_NAME(scudo::AndroidSvelteConfig)
-#if SCUDO_FUCHSIA
-SCUDO_DEFINE_GTEST_TYPE_NAME(scudo::FuchsiaConfig)
-#else
-SCUDO_DEFINE_GTEST_TYPE_NAME(scudo::DefaultConfig)
-SCUDO_DEFINE_GTEST_TYPE_NAME(scudo::AndroidConfig)
-#endif
-
-template <class Config> struct ScudoCombinedTest : public ::testing::Test {
+template <class TypeParam> struct ScudoCombinedTest : public Test {
   ScudoCombinedTest() {
-    UseQuarantine = std::is_same<Config, scudo::AndroidConfig>::value;
+    UseQuarantine = std::is_same<TypeParam, scudo::AndroidConfig>::value;
     Allocator = std::make_unique<AllocatorT>();
   }
   ~ScudoCombinedTest() {
     Allocator->releaseToOS();
     UseQuarantine = true;
   }
 
+  void RunTest();
+
   void BasicTest(scudo::uptr SizeLogMin, scudo::uptr SizeLogMax);
 
-  using AllocatorT = TestAllocator<Config>;
+  using AllocatorT = TestAllocator<TypeParam>;
   std::unique_ptr<AllocatorT> Allocator;
 };
 
-using ScudoCombinedTestTypes = testing::Types<scudo::AndroidSvelteConfig,
 #if SCUDO_FUCHSIA
-                                              scudo::FuchsiaConfig,
+#define SCUDO_TYPED_TEST_ALL_TYPES(FIXTURE, NAME)                              \
+  SCUDO_TYPED_TEST_TYPE(FIXTURE, NAME, AndroidSvelteConfig)                    \
+  SCUDO_TYPED_TEST_TYPE(FIXTURE, NAME, FuchsiaConfig)
 #else
-                                              scudo::DefaultConfig,
-                                              scudo::AndroidConfig
+#define SCUDO_TYPED_TEST_ALL_TYPES(FIXTURE, NAME)                              \
+  SCUDO_TYPED_TEST_TYPE(FIXTURE, NAME, AndroidSvelteConfig)                    \
+  SCUDO_TYPED_TEST_TYPE(FIXTURE, NAME, DefaultConfig)                          \
+  SCUDO_TYPED_TEST_TYPE(FIXTURE, NAME, AndroidConfig)
 #endif
-                                              >;
-TYPED_TEST_CASE(ScudoCombinedTest, ScudoCombinedTestTypes);
 
-TYPED_TEST(ScudoCombinedTest, IsOwned) {
+#define SCUDO_TYPED_TEST_TYPE(FIXTURE, NAME, TYPE)                             \
+  using FIXTURE##NAME##_##TYPE = FIXTURE##NAME<scudo::TYPE>;                   \
+  TEST_F(FIXTURE##NAME##_##TYPE, NAME) { Run(); }
+
+#define SCUDO_TYPED_TEST(FIXTURE, NAME)                                        \
+  template <class TypeParam>                                                   \
+  struct FIXTURE##NAME : public FIXTURE<TypeParam> {                           \
+    void Run();                                                                \
+  };                                                                           \
+  SCUDO_TYPED_TEST_ALL_TYPES(FIXTURE, NAME)                                    \
+  template <class TypeParam> void FIXTURE##NAME<TypeParam>::Run()
+
+SCUDO_TYPED_TEST(ScudoCombinedTest, IsOwned) {
   auto *Allocator = this->Allocator.get();
   static scudo::u8 StaticBuffer[scudo::Chunk::getHeaderSize() + 1];
   EXPECT_FALSE(
       Allocator->isOwned(&StaticBuffer[scudo::Chunk::getHeaderSize()]));
 
   scudo::u8 StackBuffer[scudo::Chunk::getHeaderSize() + 1];
   for (scudo::uptr I = 0; I < sizeof(StackBuffer); I++)
     StackBuffer[I] = 0x42U;
for (scudo::uptr AlignLog = MinAlignLog; AlignLog <= 16U; AlignLog++) {
         memset(P, 0xaa, Size);
         checkMemoryTaggingMaybe(Allocator, P, Size, Align);
         Allocator->deallocate(P, Origin, Size);
       }
     }
   }
 }
 
-TYPED_TEST(ScudoCombinedTest, BasicCombined0) { this->BasicTest(0, 16); }
-TYPED_TEST(ScudoCombinedTest, BasicCombined1) { this->BasicTest(17, 18); }
-TYPED_TEST(ScudoCombinedTest, BasicCombined2) { this->BasicTest(19, 19); }
-TYPED_TEST(ScudoCombinedTest, BasicCombined3) { this->BasicTest(20, 20); }
+SCUDO_TYPED_TEST(ScudoCombinedTest, BasicCombined0) { this->BasicTest(0, 16); }
+SCUDO_TYPED_TEST(ScudoCombinedTest, BasicCombined1) { this->BasicTest(17, 18); }
+SCUDO_TYPED_TEST(ScudoCombinedTest, BasicCombined2) { this->BasicTest(19, 19); }
+SCUDO_TYPED_TEST(ScudoCombinedTest, BasicCombined3) { this->BasicTest(20, 20); }
 
-TYPED_TEST(ScudoCombinedTest, ZeroContents) {
+SCUDO_TYPED_TEST(ScudoCombinedTest, ZeroContents) {
   auto *Allocator = this->Allocator.get();
 
   // Ensure that specifying ZeroContents returns a zero'd out block.
   for (scudo::uptr SizeLog = 0U; SizeLog <= 20U; SizeLog++) {
     for (scudo::uptr Delta = 0U; Delta <= 4U; Delta++) {
       const scudo::uptr Size = (1U << SizeLog) + Delta * 128U;
       void *P = Allocator->allocate(Size, Origin, 1U << MinAlignLog, true);
       EXPECT_NE(P, nullptr);
       for (scudo::uptr I = 0; I < Size; I++)
         ASSERT_EQ((reinterpret_cast<char *>(P))[I], 0);
       memset(P, 0xaa, Size);
       Allocator->deallocate(P, Origin, Size);
     }
   }
 }
 
-TYPED_TEST(ScudoCombinedTest, ZeroFill) {
+SCUDO_TYPED_TEST(ScudoCombinedTest, ZeroFill) {
   auto *Allocator = this->Allocator.get();
 
   // Ensure that specifying ZeroContents returns a zero'd out block.
   Allocator->setFillContents(scudo::ZeroFill);
   for (scudo::uptr SizeLog = 0U; SizeLog <= 20U; SizeLog++) {
     for (scudo::uptr Delta = 0U; Delta <= 4U; Delta++) {
       const scudo::uptr Size = (1U << SizeLog) + Delta * 128U;
       void *P = Allocator->allocate(Size, Origin, 1U << MinAlignLog, false);
       EXPECT_NE(P, nullptr);
       for (scudo::uptr I = 0; I < Size; I++)
         ASSERT_EQ((reinterpret_cast<char *>(P))[I], 0);
       memset(P, 0xaa, Size);
       Allocator->deallocate(P, Origin, Size);
     }
   }
 }
 
-TYPED_TEST(ScudoCombinedTest, PatternOrZeroFill) {
+SCUDO_TYPED_TEST(ScudoCombinedTest, PatternOrZeroFill) {
   auto *Allocator = this->Allocator.get();
 
   // Ensure that specifying PatternOrZeroFill returns a pattern or zero filled
   // block. The primary allocator only produces pattern filled blocks if MTE
   // is disabled, so we only require pattern filled blocks in that case.
   Allocator->setFillContents(scudo::PatternOrZeroFill);
   for (scudo::uptr SizeLog = 0U; SizeLog <= 20U; SizeLog++) {
     for (scudo::uptr Delta = 0U; Delta <= 4U; Delta++) {
for (scudo::uptr Delta = 0U; Delta <= 4U; Delta++) {
           ASSERT_TRUE(V == scudo::PatternFillByte || V == 0);
       }
       memset(P, 0xaa, Size);
       Allocator->deallocate(P, Origin, Size);
     }
   }
 }
 
-TYPED_TEST(ScudoCombinedTest, BlockReuse) {
+SCUDO_TYPED_TEST(ScudoCombinedTest, BlockReuse) {
   auto *Allocator = this->Allocator.get();
 
   // Verify that a chunk will end up being reused, at some point.
   const scudo::uptr NeedleSize = 1024U;
   void *NeedleP = Allocator->allocate(NeedleSize, Origin);
   Allocator->deallocate(NeedleP, Origin);
   bool Found = false;
   for (scudo::uptr I = 0; I < 1024U && !Found; I++) {
     void *P = Allocator->allocate(NeedleSize, Origin);
     if (Allocator->getHeaderTaggedPointer(P) ==
         Allocator->getHeaderTaggedPointer(NeedleP))
       Found = true;
     Allocator->deallocate(P, Origin);
   }
   EXPECT_TRUE(Found);
 }
 
-TYPED_TEST(ScudoCombinedTest, ReallocateLarge) {
+SCUDO_TYPED_TEST(ScudoCombinedTest, ReallocateLarge) {
   auto *Allocator = this->Allocator.get();
 
   // Reallocate a large chunk all the way down to a byte, verifying that we
   // preserve the data in the process.
   scudo::uptr Size = TypeParam::Primary::SizeClassMap::MaxSize * 2;
   const scudo::uptr DataSize = 2048U;
   void *P = Allocator->allocate(Size, Origin);
   const char Marker = 0xab;
   memset(P, Marker, scudo::Min(Size, DataSize));
   while (Size > 1U) {
     Size /= 2U;
     void *NewP = Allocator->reallocate(P, Size);
     EXPECT_NE(NewP, nullptr);
     for (scudo::uptr J = 0; J < scudo::Min(Size, DataSize); J++)
       EXPECT_EQ((reinterpret_cast<char *>(NewP))[J], Marker);
     P = NewP;
   }
   Allocator->deallocate(P, Origin);
 }
 
-TYPED_TEST(ScudoCombinedTest, ReallocateSame) {
+SCUDO_TYPED_TEST(ScudoCombinedTest, ReallocateSame) {
   auto *Allocator = this->Allocator.get();
 
   // Check that reallocating a chunk to a slightly smaller or larger size
   // returns the same chunk. This requires that all the sizes we iterate on use
   // the same block size, but that should be the case for MaxSize - 64 with our
   // default class size maps.
   constexpr scudo::uptr ReallocSize =
       TypeParam::Primary::SizeClassMap::MaxSize - 64;
   void *P = Allocator->allocate(ReallocSize, Origin);
   const char Marker = 0xab;
   memset(P, Marker, ReallocSize);
   for (scudo::sptr Delta = -32; Delta < 32; Delta += 8) {
     const scudo::uptr NewSize = ReallocSize + Delta;
     void *NewP = Allocator->reallocate(P, NewSize);
     EXPECT_EQ(NewP, P);
     for (scudo::uptr I = 0; I < ReallocSize - 32; I++)
       EXPECT_EQ((reinterpret_cast<char *>(NewP))[I], Marker);
     checkMemoryTaggingMaybe(Allocator, NewP, NewSize, 0);
   }
   Allocator->deallocate(P, Origin);
 }
 
-TYPED_TEST(ScudoCombinedTest, IterateOverChunks) {
+SCUDO_TYPED_TEST(ScudoCombinedTest, IterateOverChunks) {
   auto *Allocator = this->Allocator.get();
   // Allocates a bunch of chunks, then iterate over all the chunks, ensuring
   // they are the ones we allocated. This requires the allocator to not have any
   // other allocated chunk at this point (eg: won't work with the Quarantine).
   // FIXME: Make it work with UseQuarantine and tagging enabled. Internals of
   // iterateOverChunks reads header by tagged and non-tagger pointers so one of
   // them will fail.
   if (!UseQuarantine) {
Allocator->iterateOverChunks(
         },
         reinterpret_cast<void *>(&V));
     Allocator->enable();
     for (auto P : V)
       Allocator->deallocate(P, Origin);
   }
 }
 
-TYPED_TEST(ScudoCombinedTest, UseAfterFree) {
+SCUDO_TYPED_TEST(ScudoCombinedTest, UseAfterFree) {
   auto *Allocator = this->Allocator.get();
 
   // Check that use-after-free is detected.
   for (scudo::uptr SizeLog = 0U; SizeLog <= 20U; SizeLog++) {
     const scudo::uptr Size = 1U << SizeLog;
     if (!Allocator->useMemoryTaggingTestOnly())
       continue;
     EXPECT_DEATH(
EXPECT_DEATH(
           void *P = Allocator->allocate(Size, Origin);
           Allocator->deallocate(P, Origin);
           reinterpret_cast<char *>(P)[Size - 1] = 0xaa;
         },
         "");
   }
 }
 
-TYPED_TEST(ScudoCombinedTest, DisableMemoryTagging) {
+SCUDO_TYPED_TEST(ScudoCombinedTest, DisableMemoryTagging) {
   auto *Allocator = this->Allocator.get();
 
   if (Allocator->useMemoryTaggingTestOnly()) {
     // Check that disabling memory tagging works correctly.
     void *P = Allocator->allocate(2048, Origin);
     EXPECT_DEATH(reinterpret_cast<char *>(P)[2048] = 0xaa, "");
     scudo::disableMemoryTagChecksTestOnly();
     Allocator->disableMemoryTagging();
     reinterpret_cast<char *>(P)[2048] = 0xaa;
     Allocator->deallocate(P, Origin);
 
     P = Allocator->allocate(2048, Origin);
     EXPECT_EQ(scudo::untagPointer(P), P);
     reinterpret_cast<char *>(P)[2048] = 0xaa;
     Allocator->deallocate(P, Origin);
 
     Allocator->releaseToOS();
 
     // Disabling memory tag checks may interfere with subsequent tests.
     // Re-enable them now.
     scudo::enableMemoryTagChecksTestOnly();
   }
 }
 
-TYPED_TEST(ScudoCombinedTest, Stats) {
+SCUDO_TYPED_TEST(ScudoCombinedTest, Stats) {
   auto *Allocator = this->Allocator.get();
 
   scudo::uptr BufferSize = 8192;
   std::vector<char> Buffer(BufferSize);
   scudo::uptr ActualSize = Allocator->getStats(Buffer.data(), BufferSize);
   while (ActualSize > BufferSize) {
     BufferSize = ActualSize + 1024;
     Buffer.resize(BufferSize);
     ActualSize = Allocator->getStats(Buffer.data(), BufferSize);
   }
   std::string Stats(Buffer.begin(), Buffer.end());
   // 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);
 }
 
-TYPED_TEST(ScudoCombinedTest, CacheDrain) {
+SCUDO_TYPED_TEST(ScudoCombinedTest, CacheDrain) {
   auto *Allocator = this->Allocator.get();
 
   std::vector<void *> V;
   for (scudo::uptr I = 0; I < 64U; I++)
     V.push_back(Allocator->allocate(
         rand() % (TypeParam::Primary::SizeClassMap::MaxSize / 2U), Origin));
   for (auto P : V)
     Allocator->deallocate(P, Origin);
 
   bool UnlockRequired;
   auto *TSD = Allocator->getTSDRegistry()->getTSDAndLock(&UnlockRequired);
   EXPECT_TRUE(!TSD->Cache.isEmpty());
   TSD->Cache.drain();
   EXPECT_TRUE(TSD->Cache.isEmpty());
   if (UnlockRequired)
     TSD->unlock();
 }
 
-TYPED_TEST(ScudoCombinedTest, ThreadedCombined) {
+SCUDO_TYPED_TEST(ScudoCombinedTest, ThreadedCombined) {
   std::mutex Mutex;
   std::condition_variable Cv;
   bool Ready = false;
   auto *Allocator = this->Allocator.get();
   std::thread Threads[32];
   for (scudo::uptr I = 0; I < ARRAY_SIZE(Threads); I++)
     Threads[I] = std::thread([&]() {
       {

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

 struct SizeClassAllocator<TestConfig1, SizeClassMapT>
     : public scudo::SizeClassAllocator32<Config<TestConfig1, SizeClassMapT>> {};
 
 template <typename BaseConfig, typename SizeClassMapT>
 struct TestAllocator : public SizeClassAllocator<BaseConfig, SizeClassMapT> {
   ~TestAllocator() { this->unmapTestOnly(); }
 };
 
-SCUDO_DEFINE_GTEST_TYPE_NAME(TestConfig1)
-SCUDO_DEFINE_GTEST_TYPE_NAME(TestConfig2)
-SCUDO_DEFINE_GTEST_TYPE_NAME(TestConfig3)
-
-template <class BaseConfig> struct ScudoPrimaryTest : public ::testing::Test {};
-
-using ScudoPrimaryTestTypes = testing::Types<
-#if !SCUDO_FUCHSIA
-    TestConfig1,
+template <class BaseConfig> struct ScudoPrimaryTest : public Test {};
+
+#if SCUDO_FUCHSIA
+#define SCUDO_TYPED_TEST_ALL_TYPES(FIXTURE, NAME)                              \
+  SCUDO_TYPED_TEST_TYPE(FIXTURE, NAME, TestConfig2)                            \
+  SCUDO_TYPED_TEST_TYPE(FIXTURE, NAME, TestConfig3)
+#else
+#define SCUDO_TYPED_TEST_ALL_TYPES(FIXTURE, NAME)                              \
+  SCUDO_TYPED_TEST_TYPE(FIXTURE, NAME, TestConfig1)                            \
+  SCUDO_TYPED_TEST_TYPE(FIXTURE, NAME, TestConfig2)                            \
+  SCUDO_TYPED_TEST_TYPE(FIXTURE, NAME, TestConfig3)
 #endif
-    TestConfig2, TestConfig3>;
-TYPED_TEST_CASE(ScudoPrimaryTest, ScudoPrimaryTestTypes);
 
-TYPED_TEST(ScudoPrimaryTest, BasicPrimary) {
+#define SCUDO_TYPED_TEST_TYPE(FIXTURE, NAME, TYPE)                             \
+  using FIXTURE##NAME##_##TYPE = FIXTURE##NAME<TYPE>;                          \
+  TEST_F(FIXTURE##NAME##_##TYPE, NAME) { Run(); }
+
+#define SCUDO_TYPED_TEST(FIXTURE, NAME)                                        \
+  template <class TypeParam>                                                   \
+  struct FIXTURE##NAME : public FIXTURE<TypeParam> {                           \
+    void Run();                                                                \
+  };                                                                           \
+  SCUDO_TYPED_TEST_ALL_TYPES(FIXTURE, NAME)                                    \
+  template <class TypeParam> void FIXTURE##NAME<TypeParam>::Run()
+
+SCUDO_TYPED_TEST(ScudoPrimaryTest, BasicPrimary) {
   using Primary = TestAllocator<TypeParam, scudo::DefaultSizeClassMap>;
   std::unique_ptr<Primary> Allocator(new Primary);
   Allocator->init(/*ReleaseToOsInterval=*/-1);
   typename Primary::CacheT Cache;
   Cache.init(nullptr, Allocator.get());
   const scudo::uptr NumberOfAllocations = 32U;
   for (scudo::uptr I = 0; I <= 16U; I++) {
     const scudo::uptr Size = 1UL << I;
TEST(ScudoPrimaryTest, Primary64OOM) {
   Allocator.releaseToOS();
   scudo::ScopedString Str(1024);
   Allocator.getStats(&Str);
   Str.output();
   EXPECT_EQ(AllocationFailed, true);
   Allocator.unmapTestOnly();
 }
 
-TYPED_TEST(ScudoPrimaryTest, PrimaryIterate) {
+SCUDO_TYPED_TEST(ScudoPrimaryTest, PrimaryIterate) {
   using Primary = TestAllocator<TypeParam, scudo::DefaultSizeClassMap>;
   std::unique_ptr<Primary> Allocator(new Primary);
   Allocator->init(/*ReleaseToOsInterval=*/-1);
   typename Primary::CacheT Cache;
   Cache.init(nullptr, Allocator.get());
   std::vector<std::pair<scudo::uptr, void *>> V;
   for (scudo::uptr I = 0; I < 64U; I++) {
     const scudo::uptr Size = std::rand() % Primary::SizeClassMap::MaxSize;
SCUDO_TYPED_TEST(ScudoPrimaryTest, PrimaryIterate) {
   }
   Cache.destroy(nullptr);
   Allocator->releaseToOS();
   scudo::ScopedString Str(1024);
   Allocator->getStats(&Str);
   Str.output();
 }
 
-TYPED_TEST(ScudoPrimaryTest, PrimaryThreaded) {
+SCUDO_TYPED_TEST(ScudoPrimaryTest, PrimaryThreaded) {
   using Primary = TestAllocator<TypeParam, scudo::SvelteSizeClassMap>;
   std::unique_ptr<Primary> Allocator(new Primary);
   Allocator->init(/*ReleaseToOsInterval=*/-1);
   std::mutex Mutex;
   std::condition_variable Cv;
   bool Ready = false;
   std::thread Threads[32];
   for (scudo::uptr I = 0; I < ARRAY_SIZE(Threads); I++)
SCUDO_TYPED_TEST(ScudoPrimaryTest, PrimaryThreaded) {
   scudo::ScopedString Str(1024);
   Allocator->getStats(&Str);
   Str.output();
 }
 
 // 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.
-TYPED_TEST(ScudoPrimaryTest, ReleaseToOS) {
+SCUDO_TYPED_TEST(ScudoPrimaryTest, ReleaseToOS) {
   using Primary = TestAllocator<TypeParam, scudo::DefaultSizeClassMap>;
   std::unique_ptr<Primary> Allocator(new Primary);
   Allocator->init(/*ReleaseToOsInterval=*/-1);
   typename Primary::CacheT Cache;
   Cache.init(nullptr, Allocator.get());
   const scudo::uptr Size = scudo::getPageSizeCached() * 2;
   EXPECT_TRUE(Primary::canAllocate(Size));
   const scudo::uptr ClassId = Primary::SizeClassMap::getClassIdBySize(Size);
   void *P = Cache.allocate(ClassId);
   EXPECT_NE(P, nullptr);
   Cache.deallocate(ClassId, P);
   Cache.destroy(nullptr);
   EXPECT_GT(Allocator->releaseToOS(), 0U);
 }

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>
+using Test = ::zxtest::Test;
 #else
 #include "gtest/gtest.h"
+using Test = ::testing::Test;
 #endif
 
 // If EXPECT_DEATH isn't defined, make it a no-op.
 #ifndef EXPECT_DEATH
 // If ASSERT_DEATH is defined, make EXPECT_DEATH a wrapper to it.
 #ifdef ASSERT_DEATH
 #define EXPECT_DEATH(X, Y) ASSERT_DEATH(([&] { X; }), "")
 #else
 #define EXPECT_DEATH(X, Y)                                                     \
   do {                                                                         \
   } while (0)
 #endif // ASSERT_DEATH
 #endif // EXPECT_DEATH
 
 // 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;
-
-#define SCUDO_DEFINE_GTEST_TYPE_NAME(TYPE)                                     \
-  template <> std::string testing::internal::GetTypeName<TYPE>() {             \
-    return #TYPE;                                                              \
-  }