diff --git a/tests/chunk_test.cpp b/tests/chunk_test.cpp
index 1b2c1eb..ded1867 100644
--- a/tests/chunk_test.cpp
+++ b/tests/chunk_test.cpp
@@ -33,7 +33,7 @@
   scudo::Chunk::loadHeader(Cookie, P, &Header);
   EXPECT_TRUE(scudo::Chunk::isValid(Cookie, P, &Header));
   EXPECT_FALSE(scudo::Chunk::isValid(InvalidCookie, P, &Header));
-  EXPECT_DEATH(scudo::Chunk::loadHeader(InvalidCookie, P, &Header), "");
+  SCUDO_EXPECT_DEATH(scudo::Chunk::loadHeader(InvalidCookie, P, &Header), "");
   free(Block);
 }
 
@@ -50,7 +50,7 @@
   // Simulate a couple of corrupted bits per byte of header data.
   for (scudo::uptr I = 0; I < sizeof(scudo::Chunk::PackedHeader); I++) {
     *(reinterpret_cast<scudo::u8 *>(Block) + I) ^= 0x42U;
-    EXPECT_DEATH(scudo::Chunk::loadHeader(Cookie, P, &Header), "");
+    SCUDO_EXPECT_DEATH(scudo::Chunk::loadHeader(Cookie, P, &Header), "");
     *(reinterpret_cast<scudo::u8 *>(Block) + I) ^= 0x42U;
   }
   free(Block);
diff --git a/tests/combined_test.cpp b/tests/combined_test.cpp
index 528afc4..4116cf8 100644
--- a/tests/combined_test.cpp
+++ b/tests/combined_test.cpp
@@ -32,15 +32,6 @@
 static constexpr scudo::Chunk::Origin Origin = scudo::Chunk::Origin::Malloc;
 static constexpr scudo::uptr MinAlignLog = FIRST_32_SECOND_64(3U, 4U);
 
-// Fuchsia complains that the function is not used.
-UNUSED static void disableDebuggerdMaybe() {
-#if SCUDO_ANDROID
-  // Disable the debuggerd signal handler on Android, without this we can end
-  // up spending a significant amount of time creating tombstones.
-  signal(SIGSEGV, SIG_DFL);
-#endif
-}
-
 template <class AllocatorT>
 bool isPrimaryAllocation(scudo::uptr Size, scudo::uptr Alignment) {
   const scudo::uptr MinAlignment = 1UL << SCUDO_MIN_ALIGNMENT_LOG;
@@ -58,23 +49,13 @@
   const scudo::uptr MinAlignment = 1UL << SCUDO_MIN_ALIGNMENT_LOG;
   Size = scudo::roundUp(Size, MinAlignment);
   if (Allocator->useMemoryTaggingTestOnly()) {
-    EXPECT_DEATH(
-        {
-          disableDebuggerdMaybe();
-          reinterpret_cast<char *>(P)[-1] = 'A';
-        },
-        "");
+    SCUDO_EXPECT_DEATH(reinterpret_cast<char *>(P)[-1] = 'A', "");
   }
   if (isPrimaryAllocation<AllocatorT>(Size, Alignment)
           ? Allocator->useMemoryTaggingTestOnly()
           : Alignment == MinAlignment &&
                 AllocatorT::SecondaryT::getGuardPageSize() > 0) {
-    EXPECT_DEATH(
-        {
-          disableDebuggerdMaybe();
-          reinterpret_cast<char *>(P)[Size] = 'A';
-        },
-        "");
+    SCUDO_EXPECT_DEATH(reinterpret_cast<char *>(P)[Size] = 'A', "");
   }
 }
 
@@ -551,12 +532,7 @@
 
   // Check that accessing the entire allocation after new size causes a crash.
   for (size_t I = NewSize; I < Size; I++) {
-    EXPECT_DEATH(
-        {
-          disableDebuggerdMaybe();
-          reinterpret_cast<char *>(NewP)[I] = 'A';
-        },
-        "");
+    SCUDO_EXPECT_DEATH(reinterpret_cast<char *>(NewP)[I] = 'A', "");
   }
   Allocator->deallocate(P, Origin);
 }
@@ -594,17 +570,15 @@
     const scudo::uptr Size = 1U << SizeLog;
     if (!Allocator->useMemoryTaggingTestOnly())
       continue;
-    EXPECT_DEATH(
+    SCUDO_EXPECT_DEATH(
         {
-          disableDebuggerdMaybe();
           void *P = Allocator->allocate(Size, Origin);
           Allocator->deallocate(P, Origin);
           reinterpret_cast<char *>(P)[0] = 'A';
         },
         "");
-    EXPECT_DEATH(
+    SCUDO_EXPECT_DEATH(
         {
-          disableDebuggerdMaybe();
           void *P = Allocator->allocate(Size, Origin);
           Allocator->deallocate(P, Origin);
           reinterpret_cast<char *>(P)[Size - 1] = 'A';
@@ -622,7 +596,7 @@
       break;
 
     // Verify that a double free results in a chunk state error.
-    EXPECT_DEATH(
+    SCUDO_EXPECT_DEATH(
         {
           // Allocate from primary
           void *P = Allocator->allocate(Size, Origin);
@@ -640,7 +614,7 @@
   if (Allocator->useMemoryTaggingTestOnly()) {
     // Check that disabling memory tagging works correctly.
     void *P = Allocator->allocate(2048, Origin);
-    EXPECT_DEATH(reinterpret_cast<char *>(P)[2048] = 'A', "");
+    SCUDO_EXPECT_DEATH(reinterpret_cast<char *>(P)[2048] = 'A', "");
     scudo::ScopedDisableMemoryTagChecks NoTagChecks;
     Allocator->disableMemoryTagging();
     reinterpret_cast<char *>(P)[2048] = 'A';
@@ -777,7 +751,7 @@
   ASSERT_TRUE(ReservedMemory.create(/*Addr=*/0U, Size, "testSEGV"));
   void *P = reinterpret_cast<void *>(ReservedMemory.getBase());
   ASSERT_NE(P, nullptr);
-  EXPECT_DEATH(memset(P, 0xaa, Size), "");
+  SCUDO_EXPECT_DEATH(memset(P, 0xaa, Size), "");
   ReservedMemory.release();
 }
 
@@ -828,28 +802,28 @@
   EXPECT_NE(P, nullptr);
 
   // Invalid sized deallocation.
-  EXPECT_DEATH(Allocator->deallocateSized(P, Origin, Size + 8U), "");
+  SCUDO_EXPECT_DEATH(Allocator->deallocateSized(P, Origin, Size + 8U), "");
 
   // 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->deallocateSized(MisalignedP, Origin, Size), "");
-  EXPECT_DEATH(Allocator->reallocate(MisalignedP, Size * 2U), "");
+  SCUDO_EXPECT_DEATH(Allocator->deallocateSized(MisalignedP, Origin, Size), "");
+  SCUDO_EXPECT_DEATH(Allocator->reallocate(MisalignedP, Size * 2U), "");
 
   // Header corruption.
   scudo::u64 *H =
       reinterpret_cast<scudo::u64 *>(scudo::Chunk::getAtomicHeader(P));
   *H ^= 0x42U;
-  EXPECT_DEATH(Allocator->deallocateSized(P, Origin, Size), "");
+  SCUDO_EXPECT_DEATH(Allocator->deallocateSized(P, Origin, Size), "");
   *H ^= 0x420042U;
-  EXPECT_DEATH(Allocator->deallocateSized(P, Origin, Size), "");
+  SCUDO_EXPECT_DEATH(Allocator->deallocateSized(P, Origin, Size), "");
   *H ^= 0x420000U;
 
   // Invalid chunk state.
   Allocator->deallocateSized(P, Origin, Size);
-  EXPECT_DEATH(Allocator->deallocateSized(P, Origin, Size), "");
-  EXPECT_DEATH(Allocator->reallocate(P, Size * 2U), "");
-  EXPECT_DEATH(Allocator->getUsableSize(P), "");
+  SCUDO_EXPECT_DEATH(Allocator->deallocateSized(P, Origin, Size), "");
+  SCUDO_EXPECT_DEATH(Allocator->reallocate(P, Size * 2U), "");
+  SCUDO_EXPECT_DEATH(Allocator->getUsableSize(P), "");
 }
 
 // Verify that when a region gets full, the allocator will still manage to
@@ -1836,7 +1810,7 @@
   auto Allocator = std::unique_ptr<AllocatorT>(new AllocatorT());
 
   void *Ptr = Allocator->allocate(10, scudo::Chunk::Origin::Memalign, 32);
-  EXPECT_DEATH(
+  SCUDO_EXPECT_DEATH(
       Allocator->deallocateAligned(Ptr, scudo::Chunk::Origin::Memalign, 9),
       "alignment must be a power of two");
   Allocator->deallocateAligned(Ptr, scudo::Chunk::Origin::Memalign, 32);
@@ -1850,26 +1824,26 @@
 
   void *Ptr = Allocator->allocate(10, scudo::Chunk::Origin::Malloc);
   EXPECT_TRUE(Ptr != nullptr);
-  EXPECT_DEATH(Allocator->deallocate(Ptr, scudo::Chunk::Origin::New),
-               "deallocating.*\\(malloc vs new\\)");
-  EXPECT_DEATH(Allocator->deallocate(Ptr, scudo::Chunk::Origin::NewArray),
-               "deallocating.*\\(malloc vs new\\[\\]\\)");
+  SCUDO_EXPECT_DEATH(Allocator->deallocate(Ptr, scudo::Chunk::Origin::New),
+                     "deallocating.*\\(malloc vs new\\)");
+  SCUDO_EXPECT_DEATH(Allocator->deallocate(Ptr, scudo::Chunk::Origin::NewArray),
+                     "deallocating.*\\(malloc vs new\\[\\]\\)");
   Allocator->deallocate(Ptr, scudo::Chunk::Origin::Malloc);
 
   Ptr = Allocator->allocate(10, scudo::Chunk::Origin::New);
   EXPECT_TRUE(Ptr != nullptr);
-  EXPECT_DEATH(Allocator->deallocate(Ptr, scudo::Chunk::Origin::Malloc),
-               "deallocating.*\\(new vs malloc\\)");
-  EXPECT_DEATH(Allocator->deallocate(Ptr, scudo::Chunk::Origin::NewArray),
-               "deallocating.*\\(new vs new\\[\\]\\)");
+  SCUDO_EXPECT_DEATH(Allocator->deallocate(Ptr, scudo::Chunk::Origin::Malloc),
+                     "deallocating.*\\(new vs malloc\\)");
+  SCUDO_EXPECT_DEATH(Allocator->deallocate(Ptr, scudo::Chunk::Origin::NewArray),
+                     "deallocating.*\\(new vs new\\[\\]\\)");
   Allocator->deallocate(Ptr, scudo::Chunk::Origin::New);
 
   Ptr = Allocator->allocate(10, scudo::Chunk::Origin::NewArray);
   EXPECT_TRUE(Ptr != nullptr);
-  EXPECT_DEATH(Allocator->deallocate(Ptr, scudo::Chunk::Origin::Malloc),
-               "deallocating.*\\(new\\[\\] vs malloc\\)");
-  EXPECT_DEATH(Allocator->deallocate(Ptr, scudo::Chunk::Origin::New),
-               "deallocating.*\\(new\\[\\] vs new\\)");
+  SCUDO_EXPECT_DEATH(Allocator->deallocate(Ptr, scudo::Chunk::Origin::Malloc),
+                     "deallocating.*\\(new\\[\\] vs malloc\\)");
+  SCUDO_EXPECT_DEATH(Allocator->deallocate(Ptr, scudo::Chunk::Origin::New),
+                     "deallocating.*\\(new\\[\\] vs new\\)");
   Allocator->deallocate(Ptr, scudo::Chunk::Origin::NewArray);
 }
 
@@ -1881,20 +1855,20 @@
 
   void *Ptr = Allocator->allocate(10, scudo::Chunk::Origin::New);
   EXPECT_TRUE(Ptr != nullptr);
-  EXPECT_DEATH(Allocator->reallocate(Ptr, 1000000),
-               "reallocating.*\\(new vs malloc\\)");
+  SCUDO_EXPECT_DEATH(Allocator->reallocate(Ptr, 1000000),
+                     "reallocating.*\\(new vs malloc\\)");
   Allocator->deallocate(Ptr, scudo::Chunk::Origin::New);
 
   Ptr = Allocator->allocate(10, scudo::Chunk::Origin::NewArray);
   EXPECT_TRUE(Ptr != nullptr);
-  EXPECT_DEATH(Allocator->reallocate(Ptr, 1000000),
-               "reallocating.*\\(new\\[\\] vs malloc\\)");
+  SCUDO_EXPECT_DEATH(Allocator->reallocate(Ptr, 1000000),
+                     "reallocating.*\\(new\\[\\] vs malloc\\)");
   Allocator->deallocate(Ptr, scudo::Chunk::Origin::NewArray);
 
   Ptr = Allocator->allocate(10, scudo::Chunk::Origin::Memalign, 32);
   EXPECT_TRUE(Ptr != nullptr);
-  EXPECT_DEATH(Allocator->reallocate(Ptr, 1000000),
-               "reallocating.*\\(aligned malloc vs malloc\\)");
+  SCUDO_EXPECT_DEATH(Allocator->reallocate(Ptr, 1000000),
+                     "reallocating.*\\(aligned malloc vs malloc\\)");
   Allocator->deallocateAligned(Ptr, scudo::Chunk::Origin::Memalign, 32);
 }
 
@@ -1906,8 +1880,8 @@
 
   void *Ptr = Allocator->allocate(10, scudo::Chunk::Origin::Memalign, 32);
   EXPECT_TRUE(Ptr != nullptr);
-  EXPECT_DEATH(Allocator->reallocate(Ptr, 1000),
-               "reallocating.*\\(aligned malloc vs malloc\\)");
+  SCUDO_EXPECT_DEATH(Allocator->reallocate(Ptr, 1000),
+                     "reallocating.*\\(aligned malloc vs malloc\\)");
   // Aligned allocate with non-aligned deallocate is okay.
   Allocator->deallocate(Ptr, scudo::Chunk::Origin::Malloc);
 }
@@ -1937,16 +1911,17 @@
 
   void *Ptr = Allocator->allocate(10, scudo::Chunk::Origin::Malloc);
   EXPECT_TRUE(Ptr != nullptr);
-  EXPECT_DEATH(
+  SCUDO_EXPECT_DEATH(
       Allocator->deallocateSized(Ptr, scudo::Chunk::Origin::Malloc, 1000000),
       "invalid sized delete when deallocating.*\\(1000000 vs 10\\)");
   Allocator->deallocate(Ptr, scudo::Chunk::Origin::Malloc);
 
   Ptr = Allocator->allocate(10, scudo::Chunk::Origin::Memalign, 32);
   EXPECT_TRUE(Ptr != nullptr);
-  EXPECT_DEATH(Allocator->deallocateSizedAligned(
-                   Ptr, scudo::Chunk::Origin::Malloc, 1000000, 32),
-               "invalid sized delete when deallocating.*\\(1000000 vs 10\\)");
+  SCUDO_EXPECT_DEATH(
+      Allocator->deallocateSizedAligned(Ptr, scudo::Chunk::Origin::Malloc,
+                                        1000000, 32),
+      "invalid sized delete when deallocating.*\\(1000000 vs 10\\)");
   Allocator->deallocateAligned(Ptr, scudo::Chunk::Origin::Malloc, 32);
 }
 
@@ -1962,14 +1937,14 @@
 
   void *Ptr = Allocator->allocate(10, scudo::Chunk::Origin::Malloc);
   EXPECT_TRUE(Ptr != nullptr);
-  EXPECT_DEATH(
+  SCUDO_EXPECT_DEATH(
       Allocator->deallocateSized(Ptr, scudo::Chunk::Origin::Malloc, 1000000),
       "invalid sized delete when deallocating.*\\(1000000 vs 10 or .*\\)");
   Allocator->deallocateSized(Ptr, scudo::Chunk::Origin::Malloc, 10);
 
   Ptr = Allocator->allocate(10, scudo::Chunk::Origin::Memalign, 32);
   EXPECT_TRUE(Ptr != nullptr);
-  EXPECT_DEATH(
+  SCUDO_EXPECT_DEATH(
       Allocator->deallocateSizedAligned(Ptr, scudo::Chunk::Origin::Malloc,
                                         1000000, 32),
       "invalid sized delete when deallocating.*\\(1000000 vs 10 or .*\\)");
@@ -2019,12 +1994,13 @@
   }
 
   scudo::uptr Alignment = 2 * scudo::getPageSizeCached();
-  EXPECT_DEATH(Allocator->deallocateAligned(
-                   AlignedPtr, scudo::Chunk::Origin::Malloc, Alignment),
-               "invalid aligned delete when deallocating");
-  EXPECT_DEATH(Allocator->deallocateSizedAligned(
-                   AlignedPtr, scudo::Chunk::Origin::Malloc, 10, Alignment),
-               "invalid aligned delete when deallocating");
+  SCUDO_EXPECT_DEATH(Allocator->deallocateAligned(
+                         AlignedPtr, scudo::Chunk::Origin::Malloc, Alignment),
+                     "invalid aligned delete when deallocating");
+  SCUDO_EXPECT_DEATH(
+      Allocator->deallocateSizedAligned(
+          AlignedPtr, scudo::Chunk::Origin::Malloc, 10, Alignment),
+      "invalid aligned delete when deallocating");
 
   Allocator->deallocateAligned(AlignedPtr, scudo::Chunk::Origin::Malloc, 32);
 }
diff --git a/tests/flags_test.cpp b/tests/flags_test.cpp
index 591611e..1bac283 100644
--- a/tests/flags_test.cpp
+++ b/tests/flags_test.cpp
@@ -41,16 +41,21 @@
 }
 
 TEST(ScudoFlagsDeathTest, BooleanFlags) {
-  EXPECT_DEATH(testFlag(scudo::FlagType::FT_bool, false, "flag_name", true),
-               "expected '='");
-  EXPECT_DEATH(testFlag(scudo::FlagType::FT_bool, false, "flag_name=", true),
-               "invalid value for bool option: ''");
-  EXPECT_DEATH(testFlag(scudo::FlagType::FT_bool, false, "flag_name=2", true),
-               "invalid value for bool option: '2'");
-  EXPECT_DEATH(testFlag(scudo::FlagType::FT_bool, false, "flag_name=-1", true),
-               "invalid value for bool option: '-1'");
-  EXPECT_DEATH(testFlag(scudo::FlagType::FT_bool, false, "flag_name=on", true),
-               "invalid value for bool option: 'on'");
+  SCUDO_EXPECT_DEATH(
+      testFlag(scudo::FlagType::FT_bool, false, "flag_name", true),
+      "expected '='");
+  SCUDO_EXPECT_DEATH(
+      testFlag(scudo::FlagType::FT_bool, false, "flag_name=", true),
+      "invalid value for bool option: ''");
+  SCUDO_EXPECT_DEATH(
+      testFlag(scudo::FlagType::FT_bool, false, "flag_name=2", true),
+      "invalid value for bool option: '2'");
+  SCUDO_EXPECT_DEATH(
+      testFlag(scudo::FlagType::FT_bool, false, "flag_name=-1", true),
+      "invalid value for bool option: '-1'");
+  SCUDO_EXPECT_DEATH(
+      testFlag(scudo::FlagType::FT_bool, false, "flag_name=on", true),
+      "invalid value for bool option: 'on'");
 }
 
 TEST(ScudoFlagsTest, IntFlags) {
@@ -67,10 +72,10 @@
 }
 
 TEST(ScudoFlagsDeathTest, IntFlags) {
-  EXPECT_DEATH(testFlag(scudo::FlagType::FT_int, -11, "flag_name", 0),
-               "expected '='");
-  EXPECT_DEATH(testFlag(scudo::FlagType::FT_int, -11, "flag_name=42U", 0),
-               "invalid value for int option");
+  SCUDO_EXPECT_DEATH(testFlag(scudo::FlagType::FT_int, -11, "flag_name", 0),
+                     "expected '='");
+  SCUDO_EXPECT_DEATH(testFlag(scudo::FlagType::FT_int, -11, "flag_name=42U", 0),
+                     "invalid value for int option");
 }
 
 static void testTwoFlags(const char *Env, bool ExpectedFlag1,
diff --git a/tests/map_test.cpp b/tests/map_test.cpp
index 620dffc..051a466 100644
--- a/tests/map_test.cpp
+++ b/tests/map_test.cpp
@@ -129,7 +129,7 @@
 
   ASSERT_TRUE(ReservedMemory.create(/*Addr=*/0U, Size, MappingName));
   EXPECT_NE(ReservedMemory.getBase(), 0U);
-  EXPECT_DEATH(
+  SCUDO_EXPECT_DEATH(
       memset(reinterpret_cast<void *>(ReservedMemory.getBase()), 0xaa, Size),
       "");
 
@@ -138,7 +138,7 @@
 
 TEST(ScudoMapDeathTest, MapUnmap) {
   const scudo::uptr Size = 4 * scudo::getPageSizeCached();
-  EXPECT_DEATH(
+  SCUDO_EXPECT_DEATH(
       {
         // Repeat few time to avoid missing crash if it's mmaped by unrelated
         // code.
@@ -169,7 +169,7 @@
   scudo::uptr Q = MemMap.getBase() + PageSize;
   ASSERT_TRUE(MemMap.remap(Q, Size, MappingName));
   memset(reinterpret_cast<void *>(Q), 0xaa, Size);
-  EXPECT_DEATH(memset(reinterpret_cast<void *>(Q), 0xaa, Size + 1), "");
+  SCUDO_EXPECT_DEATH(memset(reinterpret_cast<void *>(Q), 0xaa, Size + 1), "");
   MemMap.unmap();
 }
 
diff --git a/tests/memtag_test.cpp b/tests/memtag_test.cpp
index d0d9331..4f971bb 100644
--- a/tests/memtag_test.cpp
+++ b/tests/memtag_test.cpp
@@ -24,23 +24,24 @@
   if (&__hwasan_init != 0)
     TEST_SKIP("Incompatible with HWASan");
 
-  EXPECT_DEATH(archMemoryTagGranuleSize(), "not supported");
-  EXPECT_DEATH(untagPointer((uptr)0), "not supported");
-  EXPECT_DEATH(extractTag((uptr)0), "not supported");
+  SCUDO_EXPECT_DEATH(archMemoryTagGranuleSize(), "not supported");
+  SCUDO_EXPECT_DEATH(untagPointer((uptr)0), "not supported");
+  SCUDO_EXPECT_DEATH(extractTag((uptr)0), "not supported");
 
-  EXPECT_DEATH(systemDetectsMemoryTagFaultsTestOnly(), "not supported");
-  EXPECT_DEATH(enableSystemMemoryTaggingTestOnly(), "not supported");
+  SCUDO_EXPECT_DEATH(systemDetectsMemoryTagFaultsTestOnly(), "not supported");
+  SCUDO_EXPECT_DEATH(enableSystemMemoryTaggingTestOnly(), "not supported");
 
-  EXPECT_DEATH(selectRandomTag((uptr)0, 0), "not supported");
-  EXPECT_DEATH(addFixedTag((uptr)0, 1), "not supported");
-  EXPECT_DEATH(storeTags((uptr)0, (uptr)0 + sizeof(0)), "not supported");
-  EXPECT_DEATH(storeTag((uptr)0), "not supported");
-  EXPECT_DEATH(loadTag((uptr)0), "not supported");
+  SCUDO_EXPECT_DEATH(selectRandomTag((uptr)0, 0), "not supported");
+  SCUDO_EXPECT_DEATH(addFixedTag((uptr)0, 1), "not supported");
+  SCUDO_EXPECT_DEATH(storeTags((uptr)0, (uptr)0 + sizeof(0)), "not supported");
+  SCUDO_EXPECT_DEATH(storeTag((uptr)0), "not supported");
+  SCUDO_EXPECT_DEATH(loadTag((uptr)0), "not supported");
 
-  EXPECT_DEATH(setRandomTag(nullptr, 64, 0, nullptr, nullptr), "not supported");
-  EXPECT_DEATH(untagPointer(nullptr), "not supported");
-  EXPECT_DEATH(loadTag(nullptr), "not supported");
-  EXPECT_DEATH(addFixedTag(nullptr, 0), "not supported");
+  SCUDO_EXPECT_DEATH(setRandomTag(nullptr, 64, 0, nullptr, nullptr),
+                     "not supported");
+  SCUDO_EXPECT_DEATH(untagPointer(nullptr), "not supported");
+  SCUDO_EXPECT_DEATH(loadTag(nullptr), "not supported");
+  SCUDO_EXPECT_DEATH(addFixedTag(nullptr, 0), "not supported");
 }
 
 class MemtagTest : public Test {
@@ -96,8 +97,8 @@
   for (uptr Tag = 0; Tag < 0x10; ++Tag)
     EXPECT_EQ(Tag, extractTag(addFixedTag(Addr, Tag)));
   if (SCUDO_DEBUG) {
-    EXPECT_DEATH(addFixedTag(Addr, 16), "");
-    EXPECT_DEATH(addFixedTag(~Addr, 0), "");
+    SCUDO_EXPECT_DEATH(addFixedTag(Addr, 16), "");
+    SCUDO_EXPECT_DEATH(addFixedTag(~Addr, 0), "");
   }
 }
 
@@ -113,7 +114,7 @@
   u8 *P = reinterpret_cast<u8 *>(addFixedTag(Addr, 1));
   EXPECT_NE(P, Buffer);
 
-  EXPECT_DEATH(*P = 20, "");
+  SCUDO_EXPECT_DEATH(*P = 20, "");
   ScopedDisableMemoryTagChecks Disable;
   *P = 10;
 }
@@ -151,8 +152,8 @@
   for (uptr P = Addr; P < Addr + 4 * archMemoryTagGranuleSize(); ++P) {
     if (P % archMemoryTagGranuleSize() == 0)
       continue;
-    EXPECT_DEATH(loadTag(P), "");
-    EXPECT_DEATH(storeTag(P), "");
+    SCUDO_EXPECT_DEATH(loadTag(P), "");
+    SCUDO_EXPECT_DEATH(storeTag(P), "");
   }
 }
 
@@ -173,7 +174,7 @@
     uptr Tagged = addFixedTag(P, 5);
     if (Tagged % archMemoryTagGranuleSize() == 0)
       continue;
-    EXPECT_DEATH(storeTags(Tagged, Tagged), "");
+    SCUDO_EXPECT_DEATH(storeTags(Tagged, Tagged), "");
   }
 }
 
diff --git a/tests/report_test.cpp b/tests/report_test.cpp
index e69f5dc..f82c708 100644
--- a/tests/report_test.cpp
+++ b/tests/report_test.cpp
@@ -13,82 +13,90 @@
 
 TEST(ScudoReportDeathTest, Check) {
   CHECK_LT(-1, 1);
-  EXPECT_DEATH(CHECK_GT(-1, 1),
-               "\\(-1\\) > \\(1\\) \\(\\(u64\\)op1=18446744073709551615, "
-               "\\(u64\\)op2=1");
+  SCUDO_EXPECT_DEATH(CHECK_GT(-1, 1),
+                     "\\(-1\\) > \\(1\\) \\(\\(u64\\)op1=18446744073709551615, "
+                     "\\(u64\\)op2=1");
 }
 
 TEST(ScudoReportDeathTest, Generic) {
   // Potentially unused if EXPECT_DEATH isn't defined.
   UNUSED void *P = reinterpret_cast<void *>(0x42424242U);
   UNUSED scudo::Chunk::PackedHeader Header = {};
-  EXPECT_DEATH(scudo::reportError("TEST123"), "Scudo ERROR.*TEST123");
-  EXPECT_DEATH(scudo::reportInvalidFlag("ABC", "DEF"), "Scudo ERROR.*ABC.*DEF");
-  EXPECT_DEATH(scudo::reportHeaderCorruption(&Header, 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");
-  EXPECT_DEATH(scudo::reportOutOfMemory(4242), "Scudo ERROR.*4242");
-  EXPECT_DEATH(
+  SCUDO_EXPECT_DEATH(scudo::reportError("TEST123"), "Scudo ERROR.*TEST123");
+  SCUDO_EXPECT_DEATH(scudo::reportInvalidFlag("ABC", "DEF"),
+                     "Scudo ERROR.*ABC.*DEF");
+  SCUDO_EXPECT_DEATH(scudo::reportHeaderCorruption(&Header, P),
+                     "Scudo ERROR.*42424242");
+  SCUDO_EXPECT_DEATH(scudo::reportSanityCheckError("XYZ"), "Scudo ERROR.*XYZ");
+  SCUDO_EXPECT_DEATH(scudo::reportAlignmentTooBig(123, 456),
+                     "Scudo ERROR.*123.*456");
+  SCUDO_EXPECT_DEATH(scudo::reportAllocationSizeTooBig(123, 456, 789),
+                     "Scudo ERROR.*123.*456.*789");
+  SCUDO_EXPECT_DEATH(scudo::reportOutOfMemory(4242), "Scudo ERROR.*4242");
+  SCUDO_EXPECT_DEATH(
       scudo::reportInvalidChunkState(scudo::AllocatorAction::Recycling, P),
       "Scudo ERROR.*recycling.*42424242");
-  EXPECT_DEATH(
+  SCUDO_EXPECT_DEATH(
       scudo::reportInvalidChunkState(scudo::AllocatorAction::Sizing, P),
       "Scudo ERROR.*sizing.*42424242");
-  EXPECT_DEATH(
+  SCUDO_EXPECT_DEATH(
       scudo::reportMisalignedPointer(scudo::AllocatorAction::Deallocating, P),
       "Scudo ERROR.*deallocating.*42424242");
-  EXPECT_DEATH(
+  SCUDO_EXPECT_DEATH(
       scudo::reportDeallocTypeMismatch(scudo::AllocatorAction::Reallocating, P,
                                        scudo::Chunk::Origin::New,
                                        scudo::Chunk::Origin::Memalign),
       "Scudo ERROR.*reallocating.*42424242.*\\(new vs aligned malloc\\)");
-  EXPECT_DEATH(scudo::reportDeallocTypeMismatch(
-                   scudo::AllocatorAction::Deallocating, P,
-                   scudo::Chunk::Origin::Memalign, scudo::Chunk::Origin::New),
-               "Scudo ERROR.*deallocating.*\\(aligned malloc vs new\\)");
-  EXPECT_DEATH(scudo::reportDeallocTypeMismatch(
-                   scudo::AllocatorAction::Deallocating, P,
-                   scudo::Chunk::Origin::Malloc | scudo::Chunk::Origin::Size,
-                   scudo::Chunk::Origin::NewArray | scudo::Chunk::Origin::Size |
-                       scudo::Chunk::Origin::Align),
-               "Scudo ERROR.*deallocating.*\\(sized malloc vs sized aligned "
-               "new\\[\\]\\)");
-  EXPECT_DEATH(scudo::reportDeleteSizeMismatch(P, 123, 456),
-               "Scudo ERROR.*42424242.*\\(123 vs 456\\)");
-  EXPECT_DEATH(scudo::reportDeleteSizeMismatch(P, 123, 456, 789),
-               "Scudo ERROR.*42424242.*\\(123 vs 456 or 789\\)");
-  EXPECT_DEATH(
+  SCUDO_EXPECT_DEATH(
+      scudo::reportDeallocTypeMismatch(scudo::AllocatorAction::Deallocating, P,
+                                       scudo::Chunk::Origin::Memalign,
+                                       scudo::Chunk::Origin::New),
+      "Scudo ERROR.*deallocating.*\\(aligned malloc vs new\\)");
+  SCUDO_EXPECT_DEATH(
+      scudo::reportDeallocTypeMismatch(
+          scudo::AllocatorAction::Deallocating, P,
+          scudo::Chunk::Origin::Malloc | scudo::Chunk::Origin::Size,
+          scudo::Chunk::Origin::NewArray | scudo::Chunk::Origin::Size |
+              scudo::Chunk::Origin::Align),
+      "Scudo ERROR.*deallocating.*\\(sized malloc vs sized aligned "
+      "new\\[\\]\\)");
+  SCUDO_EXPECT_DEATH(scudo::reportDeleteSizeMismatch(P, 123, 456),
+                     "Scudo ERROR.*42424242.*\\(123 vs 456\\)");
+  SCUDO_EXPECT_DEATH(scudo::reportDeleteSizeMismatch(P, 123, 456, 789),
+                     "Scudo ERROR.*42424242.*\\(123 vs 456 or 789\\)");
+  SCUDO_EXPECT_DEATH(
       scudo::reportDeleteAlignmentMismatch(reinterpret_cast<void *>(0x80),
                                            0x100),
       "Scudo ERROR.*invalid aligned delete.*\\(7 bit align vs 8 bit align\\)");
 }
 
 TEST(ScudoReportDeathTest, CSpecific) {
-  EXPECT_DEATH(scudo::reportAlignmentNotPowerOfTwo(123), "Scudo ERROR.*123");
-  EXPECT_DEATH(scudo::reportCallocOverflow(123, 456), "Scudo ERROR.*123.*456");
-  EXPECT_DEATH(scudo::reportReallocarrayOverflow(123, 456),
-               "Scudo ERROR.*reallocarray parameters.*123.*456");
-  EXPECT_DEATH(scudo::reportInvalidPosixMemalignAlignment(789),
-               "Scudo ERROR.*789");
-  EXPECT_DEATH(scudo::reportPvallocOverflow(123), "Scudo ERROR.*123");
-  EXPECT_DEATH(scudo::reportInvalidAlignedAllocAlignment(123, 456),
-               "Scudo ERROR.*123.*456");
+  SCUDO_EXPECT_DEATH(scudo::reportAlignmentNotPowerOfTwo(123),
+                     "Scudo ERROR.*123");
+  SCUDO_EXPECT_DEATH(scudo::reportCallocOverflow(123, 456),
+                     "Scudo ERROR.*123.*456");
+  SCUDO_EXPECT_DEATH(scudo::reportReallocarrayOverflow(123, 456),
+                     "Scudo ERROR.*reallocarray parameters.*123.*456");
+  SCUDO_EXPECT_DEATH(scudo::reportInvalidPosixMemalignAlignment(789),
+                     "Scudo ERROR.*789");
+  SCUDO_EXPECT_DEATH(scudo::reportPvallocOverflow(123), "Scudo ERROR.*123");
+  SCUDO_EXPECT_DEATH(scudo::reportInvalidAlignedAllocAlignment(123, 456),
+                     "Scudo ERROR.*123.*456");
 }
 
 TEST(ScudoReportDeathTest, HeaderCorruption) {
   UNUSED void *P = reinterpret_cast<void *>(0x42424242U);
   UNUSED scudo::Chunk::PackedHeader Header = {};
-  EXPECT_DEATH(scudo::reportHeaderCorruption(&Header, P),
-               "Scudo ERROR.*corrupted chunk header at address 0x.*42424242: "
-               "chunk header is zero and might indicate memory "
-               "corruption or a double free");
+  SCUDO_EXPECT_DEATH(
+      scudo::reportHeaderCorruption(&Header, P),
+      "Scudo ERROR.*corrupted chunk header at address 0x.*42424242: "
+      "chunk header is zero and might indicate memory "
+      "corruption or a double free");
   Header = 10U;
-  EXPECT_DEATH(scudo::reportHeaderCorruption(&Header, P),
-               "Scudo ERROR.*corrupted chunk header at address 0x.*42424242: "
-               "most likely due to memory corruption");
+  SCUDO_EXPECT_DEATH(
+      scudo::reportHeaderCorruption(&Header, P),
+      "Scudo ERROR.*corrupted chunk header at address 0x.*42424242: "
+      "most likely due to memory corruption");
 }
 
 #if SCUDO_LINUX || SCUDO_TRUSTY || SCUDO_ANDROID
@@ -99,22 +107,24 @@
 
 TEST(ScudoReportDeathTest, Linux) {
   errno = ENOMEM;
-  EXPECT_DEATH(scudo::reportMapError(),
-               "Scudo ERROR:.*internal map failure \\(error desc=.*\\)");
+  SCUDO_EXPECT_DEATH(scudo::reportMapError(),
+                     "Scudo ERROR:.*internal map failure \\(error desc=.*\\)");
   errno = ENOMEM;
-  EXPECT_DEATH(scudo::reportMapError(1024U),
-               "Scudo ERROR:.*internal map failure \\(error desc=.*\\) "
-               "requesting 1KB");
-  EXPECT_DEATH(scudo::reportMapFixedError(0x1000U, 0x2000U),
-               "Scudo ERROR:.*internal map failure using fixed address "
-               "\\(expected: 0x1000 requested: 0x2000\\)");
+  SCUDO_EXPECT_DEATH(scudo::reportMapError(1024U),
+                     "Scudo ERROR:.*internal map failure \\(error desc=.*\\) "
+                     "requesting 1KB");
+  SCUDO_EXPECT_DEATH(scudo::reportMapFixedError(0x1000U, 0x2000U),
+                     "Scudo ERROR:.*internal map failure using fixed address "
+                     "\\(expected: 0x1000 requested: 0x2000\\)");
   errno = ENOMEM;
-  EXPECT_DEATH(scudo::reportUnmapError(0x1000U, 100U),
-               "Scudo ERROR:.*internal unmap failure \\(error desc=.*\\) Addr "
-               "0x1000 Size 100");
+  SCUDO_EXPECT_DEATH(
+      scudo::reportUnmapError(0x1000U, 100U),
+      "Scudo ERROR:.*internal unmap failure \\(error desc=.*\\) Addr "
+      "0x1000 Size 100");
   errno = ENOMEM;
-  EXPECT_DEATH(scudo::reportProtectError(0x1000U, 100U, PROT_READ),
-               "Scudo ERROR:.*internal protect failure \\(error desc=.*\\) "
-               "Addr 0x1000 Size 100 Prot 1");
+  SCUDO_EXPECT_DEATH(
+      scudo::reportProtectError(0x1000U, 100U, PROT_READ),
+      "Scudo ERROR:.*internal protect failure \\(error desc=.*\\) "
+      "Addr 0x1000 Size 100 Prot 1");
 }
 #endif
diff --git a/tests/scudo_unit_test.h b/tests/scudo_unit_test.h
index 27c0e59..0bb2ac4 100644
--- a/tests/scudo_unit_test.h
+++ b/tests/scudo_unit_test.h
@@ -58,4 +58,33 @@
 #define SCUDO_NO_TEST_MAIN
 #endif
 
+#if SCUDO_ANDROID
+static void DisableDebuggerdMaybe() {
+  // Disable the debuggerd signal handler on Android, without this we can end
+  // up spending a significant amount of time creating tombstones.
+  signal(SIGSEGV, SIG_DFL);
+  signal(SIGABRT, SIG_DFL);
+}
+
+#define SCUDO_EXPECT_DEATH(X, Y)                                               \
+  EXPECT_DEATH(                                                                \
+      {                                                                        \
+        DisableDebuggerdMaybe();                                               \
+        X;                                                                     \
+      },                                                                       \
+      Y);
+#define SCUDO_ASSERT_DEATH(X, Y)                                               \
+  ASSERT_DEATH(                                                                \
+      {                                                                        \
+        DisableDebuggerdMaybe();                                               \
+        X;                                                                     \
+      },                                                                       \
+      Y);
+#else
+
+#define SCUDO_EXPECT_DEATH(X, Y) EXPECT_DEATH(X, Y);
+#define SCUDO_ASSERT_DEATH(X, Y) ASSERT_DEATH(X, Y);
+
+#endif
+
 extern bool UseQuarantine;
diff --git a/tests/secondary_test.cpp b/tests/secondary_test.cpp
index 8741c82..e6ceb2d 100644
--- a/tests/secondary_test.cpp
+++ b/tests/secondary_test.cpp
@@ -145,7 +145,7 @@
 
   // If the Secondary can't cache that pointer, it will be unmapped.
   if (!Info.Allocator->canCache(Size)) {
-    EXPECT_DEATH(
+    SCUDO_EXPECT_DEATH(
         {
           // Repeat few time to avoid missing crash if it's mmaped by unrelated
           // code.
diff --git a/tests/wrappers_c_test.cpp b/tests/wrappers_c_test.cpp
index 12aaf82..4465429 100644
--- a/tests/wrappers_c_test.cpp
+++ b/tests/wrappers_c_test.cpp
@@ -188,7 +188,7 @@
 #pragma GCC diagnostic push
 #pragma GCC diagnostic ignored "-Wfree-nonheap-object"
 #endif
-  EXPECT_DEATH(
+  SCUDO_EXPECT_DEATH(
       free(reinterpret_cast<void *>(reinterpret_cast<uintptr_t>(P) | 1U)), "");
 #if defined(__has_warning) && __has_warning("-Wfree-nonheap-object")
 #pragma GCC diagnostic pop
@@ -202,7 +202,7 @@
   // allocations before creating a new process. There is a possibility
   // that the previously freed P is reused, therefore, in the new
   // process doing free(P) is not a double free.
-  EXPECT_DEATH(
+  SCUDO_EXPECT_DEATH(
       {
         // Note: volatile here prevents the calls from being optimized out.
         void *volatile Ptr = malloc(Size);
@@ -374,7 +374,7 @@
   verifyReallocHookPtrs(OldP, P, Size / 2U);
   free(P);
 
-  EXPECT_DEATH(P = realloc(P, Size), "");
+  SCUDO_EXPECT_DEATH(P = realloc(P, Size), "");
 
   errno = 0;
   EXPECT_EQ(realloc(nullptr, SIZE_MAX), nullptr);
@@ -425,8 +425,8 @@
   verifyAllocHookSize(Size);
 
   if (VERIFY_FREE_SIZED_DEATH) {
-    EXPECT_DEATH(free_sized(P, Size - 1), "");
-    EXPECT_DEATH(free_sized(P, Size + 1), "");
+    SCUDO_EXPECT_DEATH(free_sized(P, Size - 1), "");
+    SCUDO_EXPECT_DEATH(free_sized(P, Size + 1), "");
 
     // An update to this warning in Clang now triggers in this line, but it's ok
     // because the check is expecting a bad pointer and should fail.
@@ -434,10 +434,10 @@
 #pragma GCC diagnostic push
 #pragma GCC diagnostic ignored "-Wfree-nonheap-object"
 #endif
-    EXPECT_DEATH(free_sized(reinterpret_cast<void *>(
-                                reinterpret_cast<uintptr_t>(P) | 1U),
-                            Size),
-                 "");
+    SCUDO_EXPECT_DEATH(free_sized(reinterpret_cast<void *>(
+                                      reinterpret_cast<uintptr_t>(P) | 1U),
+                                  Size),
+                       "");
 #if defined(__has_warning) && __has_warning("-Wfree-nonheap-object")
 #pragma GCC diagnostic pop
 #endif
@@ -447,7 +447,7 @@
   verifyDeallocHookPtr(P);
 
   if (VERIFY_FREE_SIZED_DEATH)
-    EXPECT_DEATH(free_sized(P, Size), "");
+    SCUDO_EXPECT_DEATH(free_sized(P, Size), "");
 }
 
 TEST_F(ScudoWrappersCTest, AlignedAllocFreeAlignedSized) {
@@ -461,9 +461,9 @@
   verifyAllocHookSize(Size);
 
   if (VERIFY_FREE_ALIGNED_SIZED_DEATH) {
-    EXPECT_DEATH(free_aligned_sized(P, Alignment, Size - 1), "");
-    EXPECT_DEATH(free_aligned_sized(P, Alignment, Size + 1), "");
-    EXPECT_DEATH(
+    SCUDO_EXPECT_DEATH(free_aligned_sized(P, Alignment, Size - 1), "");
+    SCUDO_EXPECT_DEATH(free_aligned_sized(P, Alignment, Size + 1), "");
+    SCUDO_EXPECT_DEATH(
         free_aligned_sized(P, size_t{1} << (sizeof(size_t) * 8 - 1), Size), "");
 
     // An update to this warning in Clang now triggers in this line, but it's ok
@@ -472,10 +472,11 @@
 #pragma GCC diagnostic push
 #pragma GCC diagnostic ignored "-Wfree-nonheap-object"
 #endif
-    EXPECT_DEATH(free_aligned_sized(reinterpret_cast<void *>(
-                                        reinterpret_cast<uintptr_t>(P) | 1U),
-                                    Alignment, Size),
-                 "");
+    SCUDO_EXPECT_DEATH(
+        free_aligned_sized(
+            reinterpret_cast<void *>(reinterpret_cast<uintptr_t>(P) | 1U),
+            Alignment, Size),
+        "");
 #if defined(__has_warning) && __has_warning("-Wfree-nonheap-object")
 #pragma GCC diagnostic pop
 #endif
@@ -483,7 +484,7 @@
 
   free_aligned_sized(P, Alignment, Size);
   verifyDeallocHookPtr(P);
-  EXPECT_DEATH(free_aligned_sized(P, Alignment, Size), "");
+  SCUDO_EXPECT_DEATH(free_aligned_sized(P, Alignment, Size), "");
 }
 
 TEST_F(ScudoWrappersCDeathTest, MallocFreeAlignedSized) {
@@ -495,8 +496,9 @@
   verifyAllocHookSize(Size);
 
   if (VERIFY_FREE_ALIGNED_SIZED_DEATH) {
-    EXPECT_DEATH(free_aligned_sized(P, 8, Size), "");
-    EXPECT_DEATH(free_aligned_sized(P, alignof(std::max_align_t), Size), "");
+    SCUDO_EXPECT_DEATH(free_aligned_sized(P, 8, Size), "");
+    SCUDO_EXPECT_DEATH(free_aligned_sized(P, alignof(std::max_align_t), Size),
+                       "");
   }
 
   free_sized(P, Size);
@@ -514,7 +516,7 @@
   verifyAllocHookSize(Size);
 
   if (VERIFY_FREE_SIZED_DEATH)
-    EXPECT_DEATH(free_sized(P, Size), "");
+    SCUDO_EXPECT_DEATH(free_sized(P, Size), "");
 
   free_aligned_sized(P, Alignment, Size);
   verifyDeallocHookPtr(P);
@@ -532,7 +534,7 @@
   verifyAllocHookSize(Size);
 
   if (VERIFY_FREE_SIZED_DEATH)
-    EXPECT_DEATH(free_sized(P, Size), "");
+    SCUDO_EXPECT_DEATH(free_sized(P, Size), "");
 
   free(P);
   verifyDeallocHookPtr(P);
@@ -549,7 +551,7 @@
   verifyAllocHookSize(Size);
 
   if (VERIFY_FREE_SIZED_DEATH)
-    EXPECT_DEATH(free_sized(P, Size), "");
+    SCUDO_EXPECT_DEATH(free_sized(P, Size), "");
 
   free(P);
   verifyDeallocHookPtr(P);
@@ -565,7 +567,7 @@
   verifyAllocHookSize(Size);
 
   if (VERIFY_FREE_SIZED_DEATH)
-    EXPECT_DEATH(free_sized(P, Size), "");
+    SCUDO_EXPECT_DEATH(free_sized(P, Size), "");
 
   free(P);
   verifyDeallocHookPtr(P);
@@ -582,7 +584,7 @@
   verifyAllocHookSize(Size);
 
   if (VERIFY_FREE_SIZED_DEATH)
-    EXPECT_DEATH(free_sized(P, Size), "");
+    SCUDO_EXPECT_DEATH(free_sized(P, Size), "");
 
   free(P);
   verifyDeallocHookPtr(P);
@@ -756,7 +758,7 @@
 #if !SCUDO_FUCHSIA
 TEST_F(ScudoWrappersCDeathTest, MallocDisableDeadlock) {
   // We expect heap operations within a disable/enable scope to deadlock.
-  EXPECT_DEATH(
+  SCUDO_EXPECT_DEATH(
       {
         void *P = malloc(Size);
         EXPECT_NE(P, nullptr);
@@ -812,7 +814,7 @@
   free(P);
 
   // fork should stall if the allocator has been disabled.
-  EXPECT_DEATH(
+  SCUDO_EXPECT_DEATH(
       {
         malloc_disable();
         alarm(1);
diff --git a/tests/wrappers_cpp_test.cpp b/tests/wrappers_cpp_test.cpp
index 5e56447..88ab061 100644
--- a/tests/wrappers_cpp_test.cpp
+++ b/tests/wrappers_cpp_test.cpp
@@ -84,10 +84,10 @@
     verifyAllocHookPtr(P);
     verifyAllocHookSize(sizeof(T));
     memset(P, 0x42, sizeof(T));
-    EXPECT_DEATH(delete[] P, "");
+    SCUDO_EXPECT_DEATH(delete[] P, "");
     delete P;
     verifyDeallocHookPtr(P);
-    EXPECT_DEATH(delete P, "");
+    SCUDO_EXPECT_DEATH(delete P, "");
 
     P = new T;
     EXPECT_NE(P, nullptr);
@@ -109,10 +109,10 @@
     verifyAllocHookPtr(A);
     verifyAllocHookSize(sizeof(T) * N);
     memset(A, 0x42, sizeof(T) * N);
-    EXPECT_DEATH(delete A, "");
+    SCUDO_EXPECT_DEATH(delete A, "");
     delete[] A;
     verifyDeallocHookPtr(A);
-    EXPECT_DEATH(delete[] A, "");
+    SCUDO_EXPECT_DEATH(delete[] A, "");
 
     A = new T[N];
     EXPECT_NE(A, nullptr);