Name all DEATH tests using 'DeathTest' suffix.

[hctim]

Summary

gtest highly recommends this prefix, and runs death tests first
(https://github.com/google/googletest/blob/master/docs/advanced.md#death-test-naming).
This may help with some spurious bot failures like
https://lab.llvm.org/buildbot/#/builders/169/builds/1290/steps/25/logs/stdio.

[vitalybuka]

LGTM, but I suspect it's not going to help. lit runs one test case per process anyway.

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

 __attribute((optnone)) void
 DeallocateMemory2(gwp_asan::GuardedPoolAllocator &GPA, void *Ptr) {
   GPA.deallocate(Ptr);
 }
 __attribute__((optnone)) void TouchMemory(void *Ptr) {
   *(reinterpret_cast<volatile char *>(Ptr)) = 7;
 }
 
-TEST_F(BacktraceGuardedPoolAllocator, DoubleFree) {
+TEST_F(BacktraceGuardedPoolAllocatorDeathTest, DoubleFree) {
   void *Ptr = AllocateMemory(GPA);
   DeallocateMemory(GPA, Ptr);
 
   std::string DeathRegex = "Double Free.*";
   DeathRegex.append("DeallocateMemory2.*");
 
   DeathRegex.append("was deallocated.*");
   DeathRegex.append("DeallocateMemory.*");
 
   DeathRegex.append("was allocated.*");
   DeathRegex.append("AllocateMemory.*");
   ASSERT_DEATH(DeallocateMemory2(GPA, Ptr), DeathRegex);
 }
 
-TEST_F(BacktraceGuardedPoolAllocator, UseAfterFree) {
+TEST_F(BacktraceGuardedPoolAllocatorDeathTest, UseAfterFree) {
   void *Ptr = AllocateMemory(GPA);
   DeallocateMemory(GPA, Ptr);
 
   std::string DeathRegex = "Use After Free.*";
   DeathRegex.append("TouchMemory.*");
 
   DeathRegex.append("was deallocated.*");
   DeathRegex.append("DeallocateMemory.*");

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

 //===-- enable_disable.cpp --------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "gwp_asan/tests/harness.h"
 
 constexpr size_t Size = 100;
 
-TEST_F(DefaultGuardedPoolAllocator, Fork) {
+TEST_F(DefaultGuardedPoolAllocatorDeathTest, Fork) {
   void *P;
   pid_t Pid = fork();
   EXPECT_GE(Pid, 0);
   if (Pid == 0) {
     P = GPA.allocate(Size);
     EXPECT_NE(P, nullptr);
     memset(P, 0x42, Size);
     GPA.deallocate(P);

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

void TearDown() override {
     GPA.uninitTestOnly();
     gwp_asan::segv_handler::uninstallSignalHandlers();
   }
 
 protected:
   gwp_asan::GuardedPoolAllocator GPA;
 };
 
+// https://github.com/google/googletest/blob/master/docs/advanced.md#death-tests-and-threads
+using DefaultGuardedPoolAllocatorDeathTest = DefaultGuardedPoolAllocator;
+using CustomGuardedPoolAllocatorDeathTest = CustomGuardedPoolAllocator;
+using BacktraceGuardedPoolAllocatorDeathTest = BacktraceGuardedPoolAllocator;
+
 #endif // GWP_ASAN_TESTS_HARNESS_H_

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

 static constexpr scudo::u32 Cookie = 0x41424344U;
 static constexpr scudo::u32 InvalidCookie = 0x11223344U;
 
 static void initChecksum(void) {
   if (&scudo::computeHardwareCRC32 && scudo::hasHardwareCRC32())
     scudo::HashAlgorithm = scudo::Checksum::HardwareCRC32;
 }
 
-TEST(ScudoChunkTest, ChunkBasic) {
+TEST(ScudoChunkDeathTest, ChunkBasic) {
   initChecksum();
   const scudo::uptr Size = 0x100U;
   scudo::Chunk::UnpackedHeader Header = {};
   void *Block = malloc(HeaderSize + Size);
   void *P = reinterpret_cast<void *>(reinterpret_cast<scudo::uptr>(Block) +
                                      HeaderSize);
   scudo::Chunk::storeHeader(Cookie, P, &Header);
   memset(P, 'A', Size);
TEST(ScudoChunkTest, ChunkCmpXchg) {
   scudo::Chunk::compareExchangeHeader(Cookie, P, &NewHeader, &OldHeader);
   NewHeader = {};
   EXPECT_TRUE(scudo::Chunk::isValid(Cookie, P, &NewHeader));
   EXPECT_EQ(NewHeader.State, scudo::Chunk::State::Quarantined);
   EXPECT_FALSE(scudo::Chunk::isValid(InvalidCookie, P, &NewHeader));
   free(Block);
 }
 
-TEST(ScudoChunkTest, CorruptHeader) {
+TEST(ScudoChunkDeathTest, CorruptHeader) {
   initChecksum();
   const scudo::uptr Size = 0x100U;
   scudo::Chunk::UnpackedHeader Header = {};
   void *Block = malloc(HeaderSize + Size);
   void *P = reinterpret_cast<void *>(reinterpret_cast<scudo::uptr>(Block) +
                                      HeaderSize);
   scudo::Chunk::storeHeader(Cookie, P, &Header);
   memset(P, 'A', Size);

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

template <class TypeParam> struct ScudoCombinedTest : public Test {
   void RunTest();
 
   void BasicTest(scudo::uptr SizeLog);
 
   using AllocatorT = TestAllocator<TypeParam>;
   std::unique_ptr<AllocatorT> Allocator;
 };
 
+template <typename T> using ScudoCombinedDeathTest = ScudoCombinedTest<T>;
+
 #if SCUDO_FUCHSIA
 #define SCUDO_TYPED_TEST_ALL_TYPES(FIXTURE, NAME)                              \
   SCUDO_TYPED_TEST_TYPE(FIXTURE, NAME, AndroidSvelteConfig)                    \
   SCUDO_TYPED_TEST_TYPE(FIXTURE, NAME, FuchsiaConfig)
 #else
 #define SCUDO_TYPED_TEST_ALL_TYPES(FIXTURE, NAME)                              \
   SCUDO_TYPED_TEST_TYPE(FIXTURE, NAME, AndroidSvelteConfig)                    \
   SCUDO_TYPED_TEST_TYPE(FIXTURE, NAME, DefaultConfig)                          \
for (scudo::sptr Delta = -32; Delta <= 32; Delta++) {
       memset(P, 0xaa, Size);
       checkMemoryTaggingMaybe(Allocator, P, Size, Align);
       Allocator->deallocate(P, Origin, Size);
     }
   }
 }
 
 #define SCUDO_MAKE_BASIC_TEST(SizeLog)                                         \
-  SCUDO_TYPED_TEST(ScudoCombinedTest, BasicCombined##SizeLog) {                \
+  SCUDO_TYPED_TEST(ScudoCombinedDeathTest, BasicCombined##SizeLog) {           \
     this->BasicTest(SizeLog);                                                  \
   }
 
 SCUDO_MAKE_BASIC_TEST(0)
 SCUDO_MAKE_BASIC_TEST(1)
 SCUDO_MAKE_BASIC_TEST(2)
 SCUDO_MAKE_BASIC_TEST(3)
 SCUDO_MAKE_BASIC_TEST(4)
while (Size > 1U) {
     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);
 }
 
-SCUDO_TYPED_TEST(ScudoCombinedTest, ReallocateSame) {
+SCUDO_TYPED_TEST(ScudoCombinedDeathTest, 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;
Allocator->iterateOverChunks(
         },
         reinterpret_cast<void *>(&V));
     Allocator->enable();
     for (auto P : V)
       Allocator->deallocate(P, Origin);
   }
 }
 
-SCUDO_TYPED_TEST(ScudoCombinedTest, UseAfterFree) {
+SCUDO_TYPED_TEST(ScudoCombinedDeathTest, 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;
         },
         "");
   }
 }
 
-SCUDO_TYPED_TEST(ScudoCombinedTest, DisableMemoryTagging) {
+SCUDO_TYPED_TEST(ScudoCombinedDeathTest, 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::ScopedDisableMemoryTagChecks NoTagChecks;
     Allocator->disableMemoryTagging();
SCUDO_TYPED_TEST(ScudoCombinedTest, ThreadedCombined) {
   }
   for (auto &T : Threads)
     T.join();
   Allocator->releaseToOS();
 }
 
 // Test that multiple instantiations of the allocator have not messed up the
 // process's signal handlers (GWP-ASan used to do this).
-TEST(ScudoCombinedTest, SKIP_ON_FUCHSIA(testSEGV)) {
+TEST(ScudoCombinedDeathTest, SKIP_ON_FUCHSIA(testSEGV)) {
   const scudo::uptr Size = 4 * scudo::getPageSizeCached();
   scudo::MapPlatformData Data = {};
   void *P = scudo::map(nullptr, Size, "testSEGV", MAP_NOACCESS, &Data);
   EXPECT_NE(P, nullptr);
   EXPECT_DEATH(memset(P, 0xaa, Size), "");
   scudo::unmap(P, Size, UNMAP_ALL, &Data);
 }
 
struct DeathConfig {
   static const scudo::uptr PrimaryCompactPtrScale = 0;
   static const bool PrimaryEnableRandomOffset = true;
   static const scudo::uptr PrimaryMapSizeIncrement = 1UL << 18;
 
   typedef scudo::MapAllocatorNoCache SecondaryCache;
   template <class A> using TSDRegistryT = scudo::TSDRegistrySharedT<A, 1U, 1U>;
 };
 
-TEST(ScudoCombinedTest, DeathCombined) {
+TEST(ScudoCombinedDeathTest, DeathCombined) {
   using AllocatorT = TestAllocator<DeathConfig>;
   auto Allocator = std::unique_ptr<AllocatorT>(new AllocatorT());
 
   const scudo::uptr Size = 1000U;
   void *P = Allocator->allocate(Size, Origin);
   EXPECT_NE(P, nullptr);
 
   // Invalid sized deallocation.

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

 
 static const char *MappingName = "scudo:test";
 
 TEST(ScudoMapTest, PageSize) {
   EXPECT_EQ(scudo::getPageSizeCached(),
             static_cast<scudo::uptr>(getpagesize()));
 }
 
-TEST(ScudoMapTest, MapNoAccessUnmap) {
+TEST(ScudoMapDeathTest, 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) {
+TEST(ScudoMapDeathTest, MapUnmap) {
   const scudo::uptr Size = 4 * scudo::getPageSizeCached();
   EXPECT_DEATH(
       {
         // Repeat few time to avoid missing crash if it's mmaped by unrelated
         // code.
         for (int i = 0; i < 10; ++i) {
           void *P = scudo::map(nullptr, Size, MappingName, 0, nullptr);
           if (!P)
             continue;
           scudo::unmap(P, Size, 0, nullptr);
           memset(P, 0xbb, Size);
         }
       },
       "");
 }
 
-TEST(ScudoMapTest, MapWithGuardUnmap) {
+TEST(ScudoMapDeathTest, 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,
                        &Data);
   EXPECT_NE(P, nullptr);
   void *Q =
       reinterpret_cast<void *>(reinterpret_cast<scudo::uptr>(P) + PageSize);

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

 //===-- memtag_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 "memtag.h"
 #include "platform.h"
 #include "tests/scudo_unit_test.h"
 
 #if SCUDO_LINUX
 namespace scudo {
 
-TEST(MemtagBasicTest, Unsupported) {
+TEST(MemtagBasicDeathTest, Unsupported) {
   if (archSupportsMemoryTagging())
     GTEST_SKIP();
 
   EXPECT_DEATH(archMemoryTagGranuleSize(), "not supported");
   EXPECT_DEATH(untagPointer((uptr)0), "not supported");
   EXPECT_DEATH(extractTag((uptr)0), "not supported");
 
   EXPECT_DEATH(systemSupportsMemoryTagging(), "not supported");
protected:
   }
 
   uptr BufferSize = 0;
   MapPlatformData Data = {};
   u8 *Buffer = nullptr;
   uptr Addr = 0;
 };
 
+using MemtagDeathTest = MemtagTest;
+
 TEST_F(MemtagTest, ArchMemoryTagGranuleSize) {
   EXPECT_GT(archMemoryTagGranuleSize(), 1u);
   EXPECT_TRUE(isPowerOfTwo(archMemoryTagGranuleSize()));
 }
 
 TEST_F(MemtagTest, ExtractTag) {
   uptr Tags = 0;
   // Try all value for the top byte and check the tags values are in the
   // expected range.
   for (u64 Top = 0; Top < 0x100; ++Top)
     Tags = Tags | (1u << extractTag(Addr | (Top << 56)));
   EXPECT_EQ(0xffffull, Tags);
 }
 
-TEST_F(MemtagTest, AddFixedTag) {
+TEST_F(MemtagDeathTest, AddFixedTag) {
   for (uptr Tag = 0; Tag < 0x10; ++Tag)
     EXPECT_EQ(Tag, extractTag(addFixedTag(Addr, Tag)));
   if (SCUDO_DEBUG) {
     EXPECT_DEBUG_DEATH(addFixedTag(Addr, 16), "");
     EXPECT_DEBUG_DEATH(addFixedTag(~Addr, 0), "");
   }
 }
 
 TEST_F(MemtagTest, UntagPointer) {
   uptr UnTagMask = untagPointer(~uptr(0));
   for (u64 Top = 0; Top < 0x100; ++Top) {
     uptr Ptr = (Addr | (Top << 56)) & UnTagMask;
     EXPECT_EQ(addFixedTag(Ptr, 0), untagPointer(Ptr));
   }
 }
 
-TEST_F(MemtagTest, ScopedDisableMemoryTagChecks) {
+TEST_F(MemtagDeathTest, ScopedDisableMemoryTagChecks) {
   u8 *P = reinterpret_cast<u8 *>(addFixedTag(Addr, 1));
   EXPECT_NE(P, Buffer);
 
   EXPECT_DEATH(*P = 20, "");
   ScopedDisableMemoryTagChecks Disable;
   *P = 10;
 }
 

 
 TEST_F(MemtagTest, SelectRandomTagWithMask) {
   for (uptr j = 0; j < 32; ++j) {
     for (uptr i = 0; i < 1000; ++i)
       EXPECT_NE(j, extractTag(selectRandomTag(Addr, 1ull << j)));
   }
 }
 
-TEST_F(MemtagTest, SKIP_NO_DEBUG(LoadStoreTagUnaligned)) {
+TEST_F(MemtagDeathTest, SKIP_NO_DEBUG(LoadStoreTagUnaligned)) {
   for (uptr P = Addr; P < Addr + 4 * archMemoryTagGranuleSize(); ++P) {
     if (P % archMemoryTagGranuleSize() == 0)
       continue;
     EXPECT_DEBUG_DEATH(loadTag(P), "");
     EXPECT_DEBUG_DEATH(storeTag(P), "");
   }
 }
 
 TEST_F(MemtagTest, LoadStoreTag) {
   uptr Base = Addr + 0x100;
   uptr Tagged = addFixedTag(Base, 7);
   storeTag(Tagged);
 
   EXPECT_EQ(Base - archMemoryTagGranuleSize(),
             loadTag(Base - archMemoryTagGranuleSize()));
   EXPECT_EQ(Tagged, loadTag(Base));
   EXPECT_EQ(Base + archMemoryTagGranuleSize(),
             loadTag(Base + archMemoryTagGranuleSize()));
 }
 
-TEST_F(MemtagTest, SKIP_NO_DEBUG(StoreTagsUnaligned)) {
+TEST_F(MemtagDeathTest, SKIP_NO_DEBUG(StoreTagsUnaligned)) {
   for (uptr P = Addr; P < Addr + 4 * archMemoryTagGranuleSize(); ++P) {
     uptr Tagged = addFixedTag(P, 5);
     if (Tagged % archMemoryTagGranuleSize() == 0)
       continue;
     EXPECT_DEBUG_DEATH(storeTags(Tagged, Tagged), "");
   }
 }
 

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 "tests/scudo_unit_test.h"
 
 #include "report.h"
 
-TEST(ScudoReportTest, Check) {
+TEST(ScudoReportDeathTest, Check) {
   CHECK_LT(-1, 1);
   EXPECT_DEATH(CHECK_GT(-1, 1),
                "\\(-1\\) > \\(1\\) \\(\\(u64\\)op1=18446744073709551615, "
                "\\(u64\\)op2=1");
 }
 
-TEST(ScudoReportTest, Generic) {
+TEST(ScudoReportDeathTest, Generic) {
   // 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 ERROR.*deallocating.*42424242");
   EXPECT_DEATH(scudo::reportDeallocTypeMismatch(
                    scudo::AllocatorAction::Reallocating, P, 0, 1),
                "Scudo ERROR.*reallocating.*42424242");
   EXPECT_DEATH(scudo::reportDeleteSizeMismatch(P, 123, 456),
                "Scudo ERROR.*42424242.*123.*456");
 }
 
-TEST(ScudoReportTest, CSpecific) {
+TEST(ScudoReportDeathTest, CSpecific) {
   EXPECT_DEATH(scudo::reportAlignmentNotPowerOfTwo(123), "Scudo ERROR.*123");
   EXPECT_DEATH(scudo::reportCallocOverflow(123, 456), "Scudo ERROR.*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");
 }

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

 // 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.
 
 static const size_t Size = 100U;
 
-TEST(ScudoWrappersCTest, Malloc) {
+TEST(ScudoWrappersCDeathTest, 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);
 
   // 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.
 #if defined(__has_warning) && __has_warning("-Wfree-nonheap-object")
TEST(ScudoWrappersCTest, AlignedAlloc) {
   free(P);
 
   errno = 0;
   P = aligned_alloc(Alignment, Size);
   EXPECT_EQ(P, nullptr);
   EXPECT_EQ(errno, EINVAL);
 }
 
-TEST(ScudoWrappersCTest, Realloc) {
+TEST(ScudoWrappersCDeathTest, Realloc) {
   // realloc(nullptr, N) is malloc(N)
   void *P = realloc(nullptr, 0U);
   EXPECT_NE(P, nullptr);
   free(P);
 
   P = malloc(Size);
   EXPECT_NE(P, nullptr);
   // realloc(P, 0U) is free(P) and returns nullptr
while (P) {
     void *NextP = *reinterpret_cast<void **>(P);
     free(P);
     P = NextP;
   }
 }
 
 // Fuchsia doesn't have alarm, fork or malloc_info.
 #if !SCUDO_FUCHSIA
-TEST(ScudoWrappersCTest, MallocDisableDeadlock) {
+TEST(ScudoWrappersCDeathTest, MallocDisableDeadlock) {
   // We expect heap operations within a disable/enable scope to deadlock.
   EXPECT_DEATH(
       {
         void *P = malloc(Size);
         EXPECT_NE(P, nullptr);
         free(P);
         malloc_disable();
         alarm(1);
TEST(ScudoWrappersCTest, MallocInfo) {
   EXPECT_EQ(strncmp(Buffer, "<malloc version=\"scudo-", 23), 0);
   EXPECT_NE(nullptr, strstr(Buffer, "<alloc size=\"1234\" count=\""));
   EXPECT_NE(nullptr, strstr(Buffer, "<alloc size=\"4321\" count=\""));
 
   free(P1);
   free(P2);
 }
 
-TEST(ScudoWrappersCTest, Fork) {
+TEST(ScudoWrappersCDeathTest, Fork) {
   void *P;
   pid_t Pid = fork();
   EXPECT_GE(Pid, 0) << strerror(errno);
   if (Pid == 0) {
     P = malloc(Size);
     EXPECT_NE(P, nullptr);
     memset(P, 0x42, Size);
     free(P);

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

 class Pixel {
 public:
   enum class Color { Red, Green, Blue };
   int X = 0;
   int Y = 0;
   Color C = Color::Red;
 };
 
-TEST(ScudoWrappersCppTest, New) {
+TEST(ScudoWrappersCppDeathTest, New) {
   if (getenv("SKIP_TYPE_MISMATCH")) {
     printf("Skipped type mismatch tests.\n");
     return;
   }
   testCxxNew<bool>();
   testCxxNew<uint8_t>();
   testCxxNew<uint16_t>();
   testCxxNew<uint32_t>();