Refactor Partition Alloc unit tests.

base/allocator/partition_allocator/partition_alloc_unittest.cc

 // Copyright (c) 2013 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "base/allocator/partition_allocator/partition_alloc.h"
 
 #include <stdlib.h>
 #include <string.h>
 
 #include <memory>
 #include <vector>
 
 #include "base/bits.h"
 #include "base/sys_info.h"
 #include "build/build_config.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 #if defined(OS_POSIX)
 #include <sys/mman.h>
 #include <sys/resource.h>
 #include <sys/time.h>
 
-#ifndef MAP_ANONYMOUS
-#define MAP_ANONYMOUS MAP_ANON
-#endif
 #endif  // defined(OS_POSIX)
 
+#if !defined(MEMORY_TOOL_REPLACES_ALLOCATOR)
+
 namespace {
+
 template <typename T>
 std::unique_ptr<T[]> WrapArrayUnique(T* ptr) {
   return std::unique_ptr<T[]>(ptr);
 }
-}  // namespace
-
-#if !defined(MEMORY_TOOL_REPLACES_ALLOCATOR)
-
-namespace base {
-
-namespace {
 
 const size_t kTestMaxAllocation = 4096;
-SizeSpecificPartitionAllocator<kTestMaxAllocation> allocator;
-PartitionAllocatorGeneric generic_allocator;
 
-const size_t kTestAllocSize = 16;
-#if !DCHECK_IS_ON()
-const size_t kPointerOffset = 0;
-const size_t kExtraAllocSize = 0;
-#else
-const size_t kPointerOffset = kCookieSize;
-const size_t kExtraAllocSize = kCookieSize * 2;
-#endif
-const size_t kRealAllocSize = kTestAllocSize + kExtraAllocSize;
-const size_t kTestBucketIndex = kRealAllocSize >> kBucketShift;
-
-const char* type_name = nullptr;
-
-void TestSetup() {
-  // Zero the allocator structs to clear out traces
-  // from previous test.
-  memset(&allocator, 0, sizeof(allocator));
-  memset(&generic_allocator, 0, sizeof(generic_allocator));
-
-  allocator.init();
-  generic_allocator.init();
+bool IsLargeMemoryDevice() {
+  return base::SysInfo::AmountOfPhysicalMemory() >= 2LL * 1024 * 1024 * 1024;
 }
 
-#if !defined(ARCH_CPU_64_BITS) || defined(OS_POSIX)
 bool SetAddressSpaceLimit() {
-#if !defined(ARCH_CPU_64_BITS)
+#if !defined(ARCH_CPU_64_BITS) || !defined(OS_POSIX)
   // 32 bits => address space is limited already.
   return true;
 #elif defined(OS_POSIX) && !defined(OS_MACOSX)
-  // Mac will accept RLIMIT_AS changes but it is not enforced.
-  // See https://crbug.com/435269 and rdar://17576114.
-  // Note: this number must be not less than 6 GB, because with
-  // sanitizer_coverage_flags=edge, it reserves > 5 GB of address
-  // space, see https://crbug.com/674665.
+  // macOS will accept, but not enforce, |RLIMIT_AS| changes. See
+  // https://crbug.com/435269 and rdar://17576114.
+  //
+  // Note: This number must be not less than 6 GB, because with
+  // sanitizer_coverage_flags=edge, it reserves > 5 GB of address space. See
+  // https://crbug.com/674665.
   const size_t kAddressSpaceLimit = static_cast<size_t>(6144) * 1024 * 1024;
   struct rlimit limit;
   if (getrlimit(RLIMIT_AS, &limit) != 0)
     return false;
   if (limit.rlim_cur == RLIM_INFINITY || limit.rlim_cur > kAddressSpaceLimit) {
     limit.rlim_cur = kAddressSpaceLimit;
     if (setrlimit(RLIMIT_AS, &limit) != 0)
       return false;
   }
   return true;
 #else
   return false;
 #endif
 }
 
 bool ClearAddressSpaceLimit() {
-#if !defined(ARCH_CPU_64_BITS)
+#if !defined(ARCH_CPU_64_BITS) || !defined(OS_POSIX)
   return true;
 #elif defined(OS_POSIX)
   struct rlimit limit;
   if (getrlimit(RLIMIT_AS, &limit) != 0)
     return false;
   limit.rlim_cur = limit.rlim_max;
   if (setrlimit(RLIMIT_AS, &limit) != 0)
     return false;
   return true;
 #else
   return false;
 #endif
 }
+
+}  // namespace
+
+namespace base {
+
+const size_t kTestAllocSize = 16;
+#if !DCHECK_IS_ON()
+const size_t kPointerOffset = 0;
+const size_t kExtraAllocSize = 0;
+#else
+const size_t kPointerOffset = kCookieSize;
+const size_t kExtraAllocSize = kCookieSize * 2;
 #endif
+const size_t kRealAllocSize = kTestAllocSize + kExtraAllocSize;
+const size_t kTestBucketIndex = kRealAllocSize >> kBucketShift;
 
-PartitionPage* GetFullPage(size_t size) {
-  size_t real_size = size + kExtraAllocSize;
-  size_t bucket_index = real_size >> kBucketShift;
-  PartitionBucket* bucket = &allocator.root()->buckets()[bucket_index];
-  size_t num_slots =
-      (bucket->num_system_pages_per_slot_span * kSystemPageSize) / real_size;
-  void* first = 0;
-  void* last = 0;
-  size_t i;
-  for (i = 0; i < num_slots; ++i) {
-    void* ptr = PartitionAlloc(allocator.root(), size, type_name);
-    EXPECT_TRUE(ptr);
-    if (!i)
-      first = PartitionCookieFreePointerAdjust(ptr);
-    else if (i == num_slots - 1)
-      last = PartitionCookieFreePointerAdjust(ptr);
+const char* type_name = nullptr;
+
+class PartitionAllocTest : public testing::Test {
+ protected:
+  PartitionAllocTest() {}
+
+  ~PartitionAllocTest() override {}
+
+  void SetUp() override {
+    // TODO(crbug.com/722911): These calls to |memset| should perhaps not be
+    // necessary.
+    memset(&allocator, 0, sizeof(allocator));
+    memset(&generic_allocator, 0, sizeof(generic_allocator));
+    allocator.init();
+    generic_allocator.init();
   }
-  EXPECT_EQ(PartitionPointerToPage(first), PartitionPointerToPage(last));
-  if (bucket->num_system_pages_per_slot_span == kNumSystemPagesPerPartitionPage)
-    EXPECT_EQ(reinterpret_cast<size_t>(first) & kPartitionPageBaseMask,
-              reinterpret_cast<size_t>(last) & kPartitionPageBaseMask);
-  EXPECT_EQ(num_slots, static_cast<size_t>(
-                           bucket->active_pages_head->num_allocated_slots));
-  EXPECT_EQ(0, bucket->active_pages_head->freelist_head);
-  EXPECT_TRUE(bucket->active_pages_head);
-  EXPECT_TRUE(bucket->active_pages_head != &PartitionRootGeneric::gSeedPage);
-  return bucket->active_pages_head;
-}
+
+  PartitionPage* GetFullPage(size_t size) {
+    size_t real_size = size + kExtraAllocSize;
+    size_t bucket_index = real_size >> kBucketShift;
+    PartitionBucket* bucket = &allocator.root()->buckets()[bucket_index];
+    size_t num_slots =
+        (bucket->num_system_pages_per_slot_span * kSystemPageSize) / real_size;
+    void* first = 0;
+    void* last = 0;
+    size_t i;
+    for (i = 0; i < num_slots; ++i) {
+      void* ptr = PartitionAlloc(allocator.root(), size, type_name);
+      EXPECT_TRUE(ptr);
+      if (!i)
+        first = PartitionCookieFreePointerAdjust(ptr);
+      else if (i == num_slots - 1)
+        last = PartitionCookieFreePointerAdjust(ptr);
+    }
+    EXPECT_EQ(PartitionPointerToPage(first), PartitionPointerToPage(last));
+    if (bucket->num_system_pages_per_slot_span ==
+        kNumSystemPagesPerPartitionPage)
+      EXPECT_EQ(reinterpret_cast<size_t>(first) & kPartitionPageBaseMask,
+                reinterpret_cast<size_t>(last) & kPartitionPageBaseMask);
+    EXPECT_EQ(num_slots, static_cast<size_t>(
+                             bucket->active_pages_head->num_allocated_slots));
+    EXPECT_EQ(0, bucket->active_pages_head->freelist_head);
+    EXPECT_TRUE(bucket->active_pages_head);
+    EXPECT_TRUE(bucket->active_pages_head != &PartitionRootGeneric::gSeedPage);
+    return bucket->active_pages_head;
+  }
+
+  void CycleFreeCache(size_t size) {
+    size_t real_size = size + kExtraAllocSize;
+    size_t bucket_index = real_size >> kBucketShift;
+    PartitionBucket* bucket = &allocator.root()->buckets()[bucket_index];
+    DCHECK(!bucket->active_pages_head->num_allocated_slots);
+
+    for (size_t i = 0; i < kMaxFreeableSpans; ++i) {
+      void* ptr = PartitionAlloc(allocator.root(), size, type_name);
+      EXPECT_EQ(1, bucket->active_pages_head->num_allocated_slots);
+      PartitionFree(ptr);
+      EXPECT_EQ(0, bucket->active_pages_head->num_allocated_slots);
+      EXPECT_NE(-1, bucket->active_pages_head->empty_cache_index);
+    }
+  }
+
+  void CycleGenericFreeCache(size_t size) {
+    for (size_t i = 0; i < kMaxFreeableSpans; ++i) {
+      void* ptr =
+          PartitionAllocGeneric(generic_allocator.root(), size, type_name);
+      PartitionPage* page =
+          PartitionPointerToPage(PartitionCookieFreePointerAdjust(ptr));
+      PartitionBucket* bucket = page->bucket;
+      EXPECT_EQ(1, bucket->active_pages_head->num_allocated_slots);
+      PartitionFreeGeneric(generic_allocator.root(), ptr);
+      EXPECT_EQ(0, bucket->active_pages_head->num_allocated_slots);
+      EXPECT_NE(-1, bucket->active_pages_head->empty_cache_index);
+    }
+  }
+
+  void DoReturnNullTest(size_t allocSize) {
+    // TODO(crbug.com/678782): Where necessary and possible, disable the
+    // platform's OOM-killing behavior. OOM-killing makes this test flaky on
+    // low-memory devices.
+    if (!IsLargeMemoryDevice()) {
+      LOG(WARNING)
+          << "Skipping test on this device because of crbug.com/678782";
+      return;
+    }
+
+    EXPECT_TRUE(SetAddressSpaceLimit());
+
+    // Work out the number of allocations for 6 GB of memory.
+    const int numAllocations = (6 * 1024 * 1024) / (allocSize / 1024);
+
+    void** ptrs = reinterpret_cast<void**>(PartitionAllocGeneric(
+        generic_allocator.root(), numAllocations * sizeof(void*), type_name));
+    int i;
+
+    for (i = 0; i < numAllocations; ++i) {
+      ptrs[i] = PartitionAllocGenericFlags(generic_allocator.root(),
+                                           PartitionAllocReturnNull, allocSize,
+                                           type_name);
+      if (!i)
+        EXPECT_TRUE(ptrs[0]);
+      if (!ptrs[i]) {
+        ptrs[i] = PartitionAllocGenericFlags(generic_allocator.root(),
+                                             PartitionAllocReturnNull,
+                                             allocSize, type_name);
+        EXPECT_FALSE(ptrs[i]);
+        break;
+      }
+    }
+
+    // We shouldn't succeed in allocating all 6 GB of memory. If we do, then
+    // we're not actually testing anything here.
+    EXPECT_LT(i, numAllocations);
+
+    // Free, reallocate and free again each block we allocated. We do this to
+    // check that freeing memory also works correctly after a failed allocation.
+    for (--i; i >= 0; --i) {
+      PartitionFreeGeneric(generic_allocator.root(), ptrs[i]);
+      ptrs[i] = PartitionAllocGenericFlags(generic_allocator.root(),
+                                           PartitionAllocReturnNull, allocSize,
+                                           type_name);
+      EXPECT_TRUE(ptrs[i]);
+      PartitionFreeGeneric(generic_allocator.root(), ptrs[i]);
+    }
+
+    PartitionFreeGeneric(generic_allocator.root(), ptrs);
+
+    EXPECT_TRUE(ClearAddressSpaceLimit());
+  }
+
+  SizeSpecificPartitionAllocator<kTestMaxAllocation> allocator;
+  PartitionAllocatorGeneric generic_allocator;
+};
+
+class PartitionAllocDeathTest : public PartitionAllocTest {};
+
+namespace {
 
 void FreeFullPage(PartitionPage* page) {
   size_t size = page->bucket->slot_size;
   size_t num_slots =
       (page->bucket->num_system_pages_per_slot_span * kSystemPageSize) / size;
   EXPECT_EQ(num_slots, static_cast<size_t>(abs(page->num_allocated_slots)));
   char* ptr = reinterpret_cast<char*>(PartitionPageToPointer(page));
   size_t i;
   for (i = 0; i < num_slots; ++i) {
     PartitionFree(ptr + kPointerOffset);
     ptr += size;
   }
 }
 
-void CycleFreeCache(size_t size) {
-  size_t real_size = size + kExtraAllocSize;
-  size_t bucket_index = real_size >> kBucketShift;
-  PartitionBucket* bucket = &allocator.root()->buckets()[bucket_index];
-  DCHECK(!bucket->active_pages_head->num_allocated_slots);
-
-  for (size_t i = 0; i < kMaxFreeableSpans; ++i) {
-    void* ptr = PartitionAlloc(allocator.root(), size, type_name);
-    EXPECT_EQ(1, bucket->active_pages_head->num_allocated_slots);
-    PartitionFree(ptr);
-    EXPECT_EQ(0, bucket->active_pages_head->num_allocated_slots);
-    EXPECT_NE(-1, bucket->active_pages_head->empty_cache_index);
-  }
-}
-
-void CycleGenericFreeCache(size_t size) {
-  for (size_t i = 0; i < kMaxFreeableSpans; ++i) {
-    void* ptr =
-        PartitionAllocGeneric(generic_allocator.root(), size, type_name);
-    PartitionPage* page =
-        PartitionPointerToPage(PartitionCookieFreePointerAdjust(ptr));
-    PartitionBucket* bucket = page->bucket;
-    EXPECT_EQ(1, bucket->active_pages_head->num_allocated_slots);
-    PartitionFreeGeneric(generic_allocator.root(), ptr);
-    EXPECT_EQ(0, bucket->active_pages_head->num_allocated_slots);
-    EXPECT_NE(-1, bucket->active_pages_head->empty_cache_index);
-  }
-}
-
 void CheckPageInCore(void* ptr, bool inCore) {
 #if defined(OS_LINUX)
   unsigned char ret;
   EXPECT_EQ(0, mincore(ptr, kSystemPageSize, &ret));
   EXPECT_EQ(inCore, ret);
 #endif
 }
 
-bool IsLargeMemoryDevice() {
-  return base::SysInfo::AmountOfPhysicalMemory() >= 2LL * 1024 * 1024 * 1024;
-}
-
 class MockPartitionStatsDumper : public PartitionStatsDumper {
  public:
   MockPartitionStatsDumper()
       : total_resident_bytes(0),
         total_active_bytes(0),
         total_decommittable_bytes(0),
         total_discardable_bytes(0) {}
 
   void PartitionDumpTotals(const char* partition_name,
                            const PartitionMemoryStats* stats) override {
@@ skipping 34 matching lines @@
   size_t total_active_bytes;
   size_t total_decommittable_bytes;
   size_t total_discardable_bytes;
 
   std::vector<PartitionBucketMemoryStats> bucket_stats;
 };
 
 }  // anonymous namespace
 
 // Check that the most basic of allocate / free pairs work.
-TEST(PartitionAllocTest, Basic) {
-  TestSetup();
+TEST_F(PartitionAllocTest, Basic) {
   PartitionBucket* bucket = &allocator.root()->buckets()[kTestBucketIndex];
   PartitionPage* seedPage = &PartitionRootGeneric::gSeedPage;
 
   EXPECT_FALSE(bucket->empty_pages_head);
   EXPECT_FALSE(bucket->decommitted_pages_head);
   EXPECT_EQ(seedPage, bucket->active_pages_head);
   EXPECT_EQ(0, bucket->active_pages_head->next_page);
 
   void* ptr = PartitionAlloc(allocator.root(), kTestAllocSize, type_name);
   EXPECT_TRUE(ptr);
   EXPECT_EQ(kPointerOffset,
             reinterpret_cast<size_t>(ptr) & kPartitionPageOffsetMask);
   // Check that the offset appears to include a guard page.
   EXPECT_EQ(kPartitionPageSize + kPointerOffset,
             reinterpret_cast<size_t>(ptr) & kSuperPageOffsetMask);
 
   PartitionFree(ptr);
   // Expect that the last active page gets noticed as empty but doesn't get
   // decommitted.
   EXPECT_TRUE(bucket->empty_pages_head);
   EXPECT_FALSE(bucket->decommitted_pages_head);
 }
 
 // Test multiple allocations, and freelist handling.
-TEST(PartitionAllocTest, MultiAlloc) {
-  TestSetup();
-
+TEST_F(PartitionAllocTest, MultiAlloc) {
   char* ptr1 = reinterpret_cast<char*>(
       PartitionAlloc(allocator.root(), kTestAllocSize, type_name));
   char* ptr2 = reinterpret_cast<char*>(
       PartitionAlloc(allocator.root(), kTestAllocSize, type_name));
   EXPECT_TRUE(ptr1);
   EXPECT_TRUE(ptr2);
   ptrdiff_t diff = ptr2 - ptr1;
   EXPECT_EQ(static_cast<ptrdiff_t>(kRealAllocSize), diff);
 
   // Check that we re-use the just-freed slot.
@@ skipping 15 matching lines @@
   EXPECT_TRUE(ptr3);
   diff = ptr3 - ptr1;
   EXPECT_EQ(static_cast<ptrdiff_t>(kRealAllocSize * 2), diff);
 
   PartitionFree(ptr1);
   PartitionFree(ptr2);
   PartitionFree(ptr3);
 }
 
 // Test a bucket with multiple pages.
-TEST(PartitionAllocTest, MultiPages) {
-  TestSetup();
+TEST_F(PartitionAllocTest, MultiPages) {
   PartitionBucket* bucket = &allocator.root()->buckets()[kTestBucketIndex];
 
   PartitionPage* page = GetFullPage(kTestAllocSize);
   FreeFullPage(page);
   EXPECT_TRUE(bucket->empty_pages_head);
   EXPECT_EQ(&PartitionRootGeneric::gSeedPage, bucket->active_pages_head);
   EXPECT_EQ(0, page->next_page);
   EXPECT_EQ(0, page->num_allocated_slots);
 
   page = GetFullPage(kTestAllocSize);
@@ skipping 20 matching lines @@
 
   FreeFullPage(page);
   FreeFullPage(page2);
   EXPECT_EQ(0, page->num_allocated_slots);
   EXPECT_EQ(0, page2->num_allocated_slots);
   EXPECT_EQ(0, page2->num_unprovisioned_slots);
   EXPECT_NE(-1, page2->empty_cache_index);
 }
 
 // Test some finer aspects of internal page transitions.
-TEST(PartitionAllocTest, PageTransitions) {
-  TestSetup();
+TEST_F(PartitionAllocTest, PageTransitions) {
   PartitionBucket* bucket = &allocator.root()->buckets()[kTestBucketIndex];
 
   PartitionPage* page1 = GetFullPage(kTestAllocSize);
   EXPECT_EQ(page1, bucket->active_pages_head);
   EXPECT_EQ(0, page1->next_page);
   PartitionPage* page2 = GetFullPage(kTestAllocSize);
   EXPECT_EQ(page2, bucket->active_pages_head);
   EXPECT_EQ(0, page2->next_page);
 
   // Bounce page1 back into the non-full list then fill it up again.
@@ skipping 39 matching lines @@
   FreeFullPage(page1);
 
   // Allocating whilst in this state exposed a bug, so keep the test.
   ptr = reinterpret_cast<char*>(
       PartitionAlloc(allocator.root(), kTestAllocSize, type_name));
   PartitionFree(ptr);
 }
 
 // Test some corner cases relating to page transitions in the internal
 // free page list metadata bucket.
-TEST(PartitionAllocTest, FreePageListPageTransitions) {
-  TestSetup();
+TEST_F(PartitionAllocTest, FreePageListPageTransitions) {
   PartitionBucket* bucket = &allocator.root()->buckets()[kTestBucketIndex];
 
   size_t numToFillFreeListPage =
       kPartitionPageSize / (sizeof(PartitionPage) + kExtraAllocSize);
   // The +1 is because we need to account for the fact that the current page
   // never gets thrown on the freelist.
   ++numToFillFreeListPage;
   std::unique_ptr<PartitionPage* []> pages =
       WrapArrayUnique(new PartitionPage*[numToFillFreeListPage]);
 
@@ skipping 21 matching lines @@
   EXPECT_EQ(pages[numToFillFreeListPage - 1], bucket->active_pages_head);
 
   for (i = 0; i < numToFillFreeListPage; ++i)
     FreeFullPage(pages[i]);
   EXPECT_EQ(&PartitionRootGeneric::gSeedPage, bucket->active_pages_head);
   EXPECT_TRUE(bucket->empty_pages_head);
 }
 
 // Test a large series of allocations that cross more than one underlying
 // 64KB super page allocation.
-TEST(PartitionAllocTest, MultiPageAllocs) {
-  TestSetup();
+TEST_F(PartitionAllocTest, MultiPageAllocs) {
   // This is guaranteed to cross a super page boundary because the first
   // partition page "slot" will be taken up by a guard page.
   size_t numPagesNeeded = kNumPartitionPagesPerSuperPage;
   // The super page should begin and end in a guard so we one less page in
   // order to allocate a single page in the new super page.
   --numPagesNeeded;
 
   EXPECT_GT(numPagesNeeded, 1u);
   std::unique_ptr<PartitionPage* []> pages;
   pages = WrapArrayUnique(new PartitionPage*[numPagesNeeded]);
@@ skipping 14 matching lines @@
       // Check that we allocated a guard page for the second page.
       EXPECT_EQ(kPartitionPageSize, secondSuperPageOffset);
     }
   }
   for (i = 0; i < numPagesNeeded; ++i)
     FreeFullPage(pages[i]);
 }
 
 // Test the generic allocation functions that can handle arbitrary sizes and
 // reallocing etc.
-TEST(PartitionAllocTest, GenericAlloc) {
-  TestSetup();
-
+TEST_F(PartitionAllocTest, GenericAlloc) {
   void* ptr = PartitionAllocGeneric(generic_allocator.root(), 1, type_name);
   EXPECT_TRUE(ptr);
   PartitionFreeGeneric(generic_allocator.root(), ptr);
   ptr = PartitionAllocGeneric(generic_allocator.root(), kGenericMaxBucketed + 1,
                               type_name);
   EXPECT_TRUE(ptr);
   PartitionFreeGeneric(generic_allocator.root(), ptr);
 
   ptr = PartitionAllocGeneric(generic_allocator.root(), 1, type_name);
   EXPECT_TRUE(ptr);
@@ skipping 71 matching lines @@
   EXPECT_NE(newPtr, ptr);
   EXPECT_EQ(newPtr, origPtr);
   newCharPtr = static_cast<char*>(newPtr);
   EXPECT_EQ(*newCharPtr, 'F');
 
   PartitionFreeGeneric(generic_allocator.root(), newPtr);
 }
 
 // Test the generic allocation functions can handle some specific sizes of
 // interest.
-TEST(PartitionAllocTest, GenericAllocSizes) {
-  TestSetup();
-
+TEST_F(PartitionAllocTest, GenericAllocSizes) {
   void* ptr = PartitionAllocGeneric(generic_allocator.root(), 0, type_name);
   EXPECT_TRUE(ptr);
   PartitionFreeGeneric(generic_allocator.root(), ptr);
 
   // kPartitionPageSize is interesting because it results in just one
   // allocation per page, which tripped up some corner cases.
   size_t size = kPartitionPageSize - kExtraAllocSize;
   ptr = PartitionAllocGeneric(generic_allocator.root(), size, type_name);
   EXPECT_TRUE(ptr);
   void* ptr2 = PartitionAllocGeneric(generic_allocator.root(), size, type_name);
@@ skipping 73 matching lines @@
   // Can we free null?
   PartitionFreeGeneric(generic_allocator.root(), 0);
 
   // Do we correctly get a null for a failed allocation?
   EXPECT_EQ(0, PartitionAllocGenericFlags(generic_allocator.root(),
                                           PartitionAllocReturnNull,
                                           3u * 1024 * 1024 * 1024, type_name));
 }
 
 // Test that we can fetch the real allocated size after an allocation.
-TEST(PartitionAllocTest, GenericAllocGetSize) {
-  TestSetup();
-
+TEST_F(PartitionAllocTest, GenericAllocGetSize) {
   void* ptr;
   size_t requestedSize, actualSize, predictedSize;
 
   EXPECT_TRUE(PartitionAllocSupportsGetSize());
 
   // Allocate something small.
   requestedSize = 511 - kExtraAllocSize;
   predictedSize =
       PartitionAllocActualSize(generic_allocator.root(), requestedSize);
   ptr =
@@ skipping 48 matching lines @@
   }
 
   // Too large allocation.
   requestedSize = INT_MAX;
   predictedSize =
       PartitionAllocActualSize(generic_allocator.root(), requestedSize);
   EXPECT_EQ(requestedSize, predictedSize);
 }
 
 // Test the realloc() contract.
-TEST(PartitionAllocTest, Realloc) {
-  TestSetup();
-
+TEST_F(PartitionAllocTest, Realloc) {
   // realloc(0, size) should be equivalent to malloc().
   void* ptr = PartitionReallocGeneric(generic_allocator.root(), 0,
                                       kTestAllocSize, type_name);
   memset(ptr, 'A', kTestAllocSize);
   PartitionPage* page =
       PartitionPointerToPage(PartitionCookieFreePointerAdjust(ptr));
   // realloc(ptr, 0) should be equivalent to free().
   void* ptr2 =
       PartitionReallocGeneric(generic_allocator.root(), ptr, 0, type_name);
   EXPECT_EQ(0, ptr2);
@@ skipping 49 matching lines @@
   // Test that a direct mapped allocation is performed not in-place when the
   // new size is small enough.
   ptr2 = PartitionReallocGeneric(generic_allocator.root(), ptr, kSystemPageSize,
                                  type_name);
   EXPECT_NE(ptr, ptr2);
 
   PartitionFreeGeneric(generic_allocator.root(), ptr2);
 }
 
 // Tests the handing out of freelists for partial pages.
-TEST(PartitionAllocTest, PartialPageFreelists) {
-  TestSetup();
-
+TEST_F(PartitionAllocTest, PartialPageFreelists) {
   size_t big_size = allocator.root()->max_allocation - kExtraAllocSize;
   EXPECT_EQ(kSystemPageSize - kAllocationGranularity,
             big_size + kExtraAllocSize);
   size_t bucket_index = (big_size + kExtraAllocSize) >> kBucketShift;
   PartitionBucket* bucket = &allocator.root()->buckets()[bucket_index];
   EXPECT_EQ(0, bucket->empty_pages_head);
 
   void* ptr = PartitionAlloc(allocator.root(), big_size, type_name);
   EXPECT_TRUE(ptr);
 
@@ skipping 133 matching lines @@
   EXPECT_EQ(1, page->num_allocated_slots);
   EXPECT_FALSE(page->freelist_head);
   totalSlots =
       (page->bucket->num_system_pages_per_slot_span * kSystemPageSize) /
       (pageSize + kExtraAllocSize);
   EXPECT_EQ(totalSlots - 1, page->num_unprovisioned_slots);
   PartitionFreeGeneric(generic_allocator.root(), ptr);
 }
 
 // Test some of the fragmentation-resistant properties of the allocator.
-TEST(PartitionAllocTest, PageRefilling) {
-  TestSetup();
+TEST_F(PartitionAllocTest, PageRefilling) {
   PartitionBucket* bucket = &allocator.root()->buckets()[kTestBucketIndex];
 
   // Grab two full pages and a non-full page.
   PartitionPage* page1 = GetFullPage(kTestAllocSize);
   PartitionPage* page2 = GetFullPage(kTestAllocSize);
   void* ptr = PartitionAlloc(allocator.root(), kTestAllocSize, type_name);
   EXPECT_TRUE(ptr);
   EXPECT_NE(page1, bucket->active_pages_head);
   EXPECT_NE(page2, bucket->active_pages_head);
   PartitionPage* page =
@@ skipping 13 matching lines @@
   (void)PartitionAlloc(allocator.root(), kTestAllocSize, type_name);
   (void)PartitionAlloc(allocator.root(), kTestAllocSize, type_name);
   EXPECT_EQ(1, page->num_allocated_slots);
 
   FreeFullPage(page2);
   FreeFullPage(page1);
   PartitionFree(ptr);
 }
 
 // Basic tests to ensure that allocations work for partial page buckets.
-TEST(PartitionAllocTest, PartialPages) {
-  TestSetup();
-
+TEST_F(PartitionAllocTest, PartialPages) {
   // Find a size that is backed by a partial partition page.
   size_t size = sizeof(void*);
   PartitionBucket* bucket = 0;
   while (size < kTestMaxAllocation) {
     bucket = &allocator.root()->buckets()[size >> kBucketShift];
     if (bucket->num_system_pages_per_slot_span %
         kNumSystemPagesPerPartitionPage)
       break;
     size += sizeof(void*);
   }
   EXPECT_LT(size, kTestMaxAllocation);
 
   PartitionPage* page1 = GetFullPage(size);
   PartitionPage* page2 = GetFullPage(size);
   FreeFullPage(page2);
   FreeFullPage(page1);
 }
 
 // Test correct handling if our mapping collides with another.
-TEST(PartitionAllocTest, MappingCollision) {
-  TestSetup();
+TEST_F(PartitionAllocTest, MappingCollision) {
   // The -2 is because the first and last partition pages in a super page are
   // guard pages.
   size_t numPartitionPagesNeeded = kNumPartitionPagesPerSuperPage - 2;
   std::unique_ptr<PartitionPage* []> firstSuperPagePages =
       WrapArrayUnique(new PartitionPage*[numPartitionPagesNeeded]);
   std::unique_ptr<PartitionPage* []> secondSuperPagePages =
       WrapArrayUnique(new PartitionPage*[numPartitionPagesNeeded]);
 
   size_t i;
   for (i = 0; i < numPartitionPagesNeeded; ++i)
@@ skipping 60 matching lines @@
                 kSuperPageBaseMask);
 
   FreeFullPage(pageInThirdSuperPage);
   for (i = 0; i < numPartitionPagesNeeded; ++i) {
     FreeFullPage(firstSuperPagePages[i]);
     FreeFullPage(secondSuperPagePages[i]);
   }
 }
 
 // Tests that pages in the free page cache do get freed as appropriate.
-TEST(PartitionAllocTest, FreeCache) {
-  TestSetup();
-
+TEST_F(PartitionAllocTest, FreeCache) {
   EXPECT_EQ(0U, allocator.root()->total_size_of_committed_pages);
 
   size_t big_size = allocator.root()->max_allocation - kExtraAllocSize;
   size_t bucket_index = (big_size + kExtraAllocSize) >> kBucketShift;
   PartitionBucket* bucket = &allocator.root()->buckets()[bucket_index];
 
   void* ptr = PartitionAlloc(allocator.root(), big_size, type_name);
   EXPECT_TRUE(ptr);
   PartitionPage* page =
       PartitionPointerToPage(PartitionCookieFreePointerAdjust(ptr));
@@ skipping 30 matching lines @@
     ptr = PartitionAlloc(allocator.root(), big_size, type_name);
     EXPECT_TRUE(page->freelist_head);
     PartitionFree(ptr);
     EXPECT_TRUE(page->freelist_head);
   }
   EXPECT_EQ(kPartitionPageSize,
             allocator.root()->total_size_of_committed_pages);
 }
 
 // Tests for a bug we had with losing references to free pages.
-TEST(PartitionAllocTest, LostFreePagesBug) {
-  TestSetup();
-
+TEST_F(PartitionAllocTest, LostFreePagesBug) {
   size_t size = kPartitionPageSize - kExtraAllocSize;
 
   void* ptr = PartitionAllocGeneric(generic_allocator.root(), size, type_name);
   EXPECT_TRUE(ptr);
   void* ptr2 = PartitionAllocGeneric(generic_allocator.root(), size, type_name);
   EXPECT_TRUE(ptr2);
 
   PartitionPage* page =
       PartitionPointerToPage(PartitionCookieFreePointerAdjust(ptr));
   PartitionPage* page2 =
@@ skipping 41 matching lines @@
   EXPECT_TRUE(ptr);
   PartitionFreeGeneric(generic_allocator.root(), ptr);
 
   EXPECT_TRUE(bucket->active_pages_head);
   EXPECT_TRUE(bucket->empty_pages_head);
   EXPECT_TRUE(bucket->decommitted_pages_head);
 }
 
 #if !defined(ARCH_CPU_64_BITS) || defined(OS_POSIX)
 
-static void DoReturnNullTest(size_t allocSize) {
-  // TODO(crbug.com/678782): Where necessary and possible, disable the
-  // platform's OOM-killing behavior. OOM-killing makes this test flaky on
-  // low-memory devices.
-  if (!IsLargeMemoryDevice()) {
-    LOG(WARNING) << "Skipping test on this device because of crbug.com/678782";
-    return;
-  }
-
-  TestSetup();
-
-  EXPECT_TRUE(SetAddressSpaceLimit());
-
-  // Work out the number of allocations for 6 GB of memory.
-  const int numAllocations = (6 * 1024 * 1024) / (allocSize / 1024);
-
-  void** ptrs = reinterpret_cast<void**>(PartitionAllocGeneric(
-      generic_allocator.root(), numAllocations * sizeof(void*), type_name));
-  int i;
-
-  for (i = 0; i < numAllocations; ++i) {
-    ptrs[i] = PartitionAllocGenericFlags(generic_allocator.root(),
-                                         PartitionAllocReturnNull, allocSize,
-                                         type_name);
-    if (!i)
-      EXPECT_TRUE(ptrs[0]);
-    if (!ptrs[i]) {
-      ptrs[i] = PartitionAllocGenericFlags(generic_allocator.root(),
-                                           PartitionAllocReturnNull, allocSize,
-                                           type_name);
-      EXPECT_FALSE(ptrs[i]);
-      break;
-    }
-  }
-
-  // We shouldn't succeed in allocating all 6 GB of memory. If we do, then
-  // we're not actually testing anything here.
-  EXPECT_LT(i, numAllocations);
-
-  // Free, reallocate and free again each block we allocated. We do this to
-  // check that freeing memory also works correctly after a failed allocation.
-  for (--i; i >= 0; --i) {
-    PartitionFreeGeneric(generic_allocator.root(), ptrs[i]);
-    ptrs[i] = PartitionAllocGenericFlags(generic_allocator.root(),
-                                         PartitionAllocReturnNull, allocSize,
-                                         type_name);
-    EXPECT_TRUE(ptrs[i]);
-    PartitionFreeGeneric(generic_allocator.root(), ptrs[i]);
-  }
-
-  PartitionFreeGeneric(generic_allocator.root(), ptrs);
-
-  EXPECT_TRUE(ClearAddressSpaceLimit());
-}
 
 // Unit tests that check if an allocation fails in "return null" mode,
 // repeating it doesn't crash, and still returns null. The tests need to
 // stress memory subsystem limits to do so, hence they try to allocate
 // 6 GB of memory, each with a different per-allocation block sizes.
 //
 // On 64-bit POSIX systems, the address space is limited to 6 GB using
 // setrlimit() first.
 
 // Test "return null" for larger, direct-mapped allocations first. As a
 // direct-mapped allocation's pages are unmapped and freed on release, this
 // test is performd first for these "return null" tests in order to leave
 // sufficient unreserved virtual memory around for the later one(s).
 
 // Disable this test on Android because, due to its allocation-heavy behavior,
 // it tends to get OOM-killed rather than pass.
 #if defined(OS_MACOSX) || defined(OS_ANDROID)
 #define MAYBE_RepeatedReturnNullDirect DISABLED_RepeatedReturnNullDirect
 #else
 #define MAYBE_RepeatedReturnNullDirect RepeatedReturnNullDirect
 #endif
-TEST(PartitionAllocTest, MAYBE_RepeatedReturnNullDirect) {
+TEST_F(PartitionAllocTest, MAYBE_RepeatedReturnNullDirect) {
   // A direct-mapped allocation size.
   DoReturnNullTest(32 * 1024 * 1024);
 }
 
 // Test "return null" with a 512 kB block size.
 
 // Disable this test on Android because, due to its allocation-heavy behavior,
 // it tends to get OOM-killed rather than pass.
 #if defined(OS_MACOSX) || defined(OS_ANDROID)
 #define MAYBE_RepeatedReturnNull DISABLED_RepeatedReturnNull
 #else
 #define MAYBE_RepeatedReturnNull RepeatedReturnNull
 #endif
-TEST(PartitionAllocTest, MAYBE_RepeatedReturnNull) {
+TEST_F(PartitionAllocTest, MAYBE_RepeatedReturnNull) {
   // A single-slot but non-direct-mapped allocation size.
   DoReturnNullTest(512 * 1024);
 }
 
 #endif  // !defined(ARCH_CPU_64_BITS) || defined(OS_POSIX)
 
 // Death tests misbehave on Android, http://crbug.com/643760.
 #if defined(GTEST_HAS_DEATH_TEST) && !defined(OS_ANDROID)
 
 // Make sure that malloc(-1) dies.
 // In the past, we had an integer overflow that would alias malloc(-1) to
 // malloc(0), which is not good.
-TEST(PartitionAllocDeathTest, LargeAllocs) {
-  TestSetup();
+TEST_F(PartitionAllocDeathTest, LargeAllocs) {
   // Largest alloc.
   EXPECT_DEATH(PartitionAllocGeneric(generic_allocator.root(),
                                      static_cast<size_t>(-1), type_name),
                "");
   // And the smallest allocation we expect to die.
   EXPECT_DEATH(
       PartitionAllocGeneric(generic_allocator.root(),
                             static_cast<size_t>(INT_MAX) + 1, type_name),
       "");
 }
 
 // Check that our immediate double-free detection works.
-TEST(PartitionAllocDeathTest, ImmediateDoubleFree) {
-  TestSetup();
-
+TEST_F(PartitionAllocDeathTest, ImmediateDoubleFree) {
   void* ptr = PartitionAllocGeneric(generic_allocator.root(), kTestAllocSize,
                                     type_name);
   EXPECT_TRUE(ptr);
   PartitionFreeGeneric(generic_allocator.root(), ptr);
 
   EXPECT_DEATH(PartitionFreeGeneric(generic_allocator.root(), ptr), "");
 }
 
 // Check that our refcount-based double-free detection works.
-TEST(PartitionAllocDeathTest, RefcountDoubleFree) {
-  TestSetup();
-
+TEST_F(PartitionAllocDeathTest, RefcountDoubleFree) {
   void* ptr = PartitionAllocGeneric(generic_allocator.root(), kTestAllocSize,
                                     type_name);
   EXPECT_TRUE(ptr);
   void* ptr2 = PartitionAllocGeneric(generic_allocator.root(), kTestAllocSize,
                                      type_name);
   EXPECT_TRUE(ptr2);
   PartitionFreeGeneric(generic_allocator.root(), ptr);
   PartitionFreeGeneric(generic_allocator.root(), ptr2);
   // This is not an immediate double-free so our immediate detection won't
   // fire. However, it does take the "refcount" of the partition page to -1,
   // which is illegal and should be trapped.
   EXPECT_DEATH(PartitionFreeGeneric(generic_allocator.root(), ptr), "");
 }
 
 // Check that guard pages are present where expected.
-TEST(PartitionAllocDeathTest, GuardPages) {
-  TestSetup();
-
+TEST_F(PartitionAllocDeathTest, GuardPages) {
 // PartitionAlloc adds kPartitionPageSize to the requested size
 // (for metadata), and then rounds that size to kPageAllocationGranularity.
 // To be able to reliably write one past a direct allocation, choose a size
 // that's
 // a) larger than kGenericMaxBucketed (to make the allocation direct)
 // b) aligned at kPageAllocationGranularity boundaries after
 //    kPartitionPageSize has been added to it.
 // (On 32-bit, PartitionAlloc adds another kSystemPageSize to the
 // allocation size before rounding, but there it marks the memory right
 // after size as inaccessible, so it's fine to write 1 past the size we
@@ skipping 13 matching lines @@
   char* charPtr = reinterpret_cast<char*>(ptr) - kPointerOffset;
 
   EXPECT_DEATH(*(charPtr - 1) = 'A', "");
   EXPECT_DEATH(*(charPtr + size + kExtraAllocSize) = 'A', "");
 
   PartitionFreeGeneric(generic_allocator.root(), ptr);
 }
 
 // Check that a bad free() is caught where the free() refers to an unused
 // partition page of a large allocation.
-TEST(PartitionAllocDeathTest, FreeWrongPartitionPage) {
-  TestSetup();
-
+TEST_F(PartitionAllocDeathTest, FreeWrongPartitionPage) {
   // This large size will result in a direct mapped allocation with guard
   // pages at either end.
   void* ptr = PartitionAllocGeneric(generic_allocator.root(),
                                     kPartitionPageSize * 2, type_name);
   EXPECT_TRUE(ptr);
   char* badPtr = reinterpret_cast<char*>(ptr) + kPartitionPageSize;
 
   EXPECT_DEATH(PartitionFreeGeneric(generic_allocator.root(), badPtr), "");
 
   PartitionFreeGeneric(generic_allocator.root(), ptr);
 }
 
 #endif  // !defined(OS_ANDROID) && !defined(OS_IOS)
 
-// Tests that PartitionDumpStatsGeneric and PartitionDumpStats runs without
-// crashing and returns non zero values when memory is allocated.
-TEST(PartitionAllocTest, DumpMemoryStats) {
-  TestSetup();
+// Tests that |PartitionDumpStatsGeneric| and |PartitionDumpStats| run without
+// crashing and return non-zero values when memory is allocated.
+TEST_F(PartitionAllocTest, DumpMemoryStats) {
   {
     void* ptr = PartitionAlloc(allocator.root(), kTestAllocSize, type_name);
     MockPartitionStatsDumper mockStatsDumper;
     PartitionDumpStats(allocator.root(), "mock_allocator",
                        false /* detailed dump */, &mockStatsDumper);
     EXPECT_TRUE(mockStatsDumper.IsMemoryAllocationRecorded());
-
     PartitionFree(ptr);
   }
 
   // This series of tests checks the active -> empty -> decommitted states.
   {
-    void* genericPtr = PartitionAllocGeneric(generic_allocator.root(),
-                                             2048 - kExtraAllocSize, type_name);
     {
+      void* ptr = PartitionAllocGeneric(generic_allocator.root(),
+                                        2048 - kExtraAllocSize, type_name);
       MockPartitionStatsDumper dumper;
       PartitionDumpStatsGeneric(generic_allocator.root(),
                                 "mock_generic_allocator",
                                 false /* detailed dump */, &dumper);
       EXPECT_TRUE(dumper.IsMemoryAllocationRecorded());
 
       const PartitionBucketMemoryStats* stats = dumper.GetBucketStats(2048);
       EXPECT_TRUE(stats);
       EXPECT_TRUE(stats->is_valid);
       EXPECT_EQ(2048u, stats->bucket_slot_size);
       EXPECT_EQ(2048u, stats->active_bytes);
       EXPECT_EQ(kSystemPageSize, stats->resident_bytes);
       EXPECT_EQ(0u, stats->decommittable_bytes);
       EXPECT_EQ(0u, stats->discardable_bytes);
       EXPECT_EQ(0u, stats->num_full_pages);
       EXPECT_EQ(1u, stats->num_active_pages);
       EXPECT_EQ(0u, stats->num_empty_pages);
       EXPECT_EQ(0u, stats->num_decommitted_pages);
+      PartitionFreeGeneric(generic_allocator.root(), ptr);
     }
 
-    PartitionFreeGeneric(generic_allocator.root(), genericPtr);
-
     {
       MockPartitionStatsDumper dumper;
       PartitionDumpStatsGeneric(generic_allocator.root(),
                                 "mock_generic_allocator",
                                 false /* detailed dump */, &dumper);
       EXPECT_FALSE(dumper.IsMemoryAllocationRecorded());
 
       const PartitionBucketMemoryStats* stats = dumper.GetBucketStats(2048);
       EXPECT_TRUE(stats);
       EXPECT_TRUE(stats->is_valid);
       EXPECT_EQ(2048u, stats->bucket_slot_size);
       EXPECT_EQ(0u, stats->active_bytes);
       EXPECT_EQ(kSystemPageSize, stats->resident_bytes);
       EXPECT_EQ(kSystemPageSize, stats->decommittable_bytes);
       EXPECT_EQ(0u, stats->discardable_bytes);
       EXPECT_EQ(0u, stats->num_full_pages);
       EXPECT_EQ(0u, stats->num_active_pages);
       EXPECT_EQ(1u, stats->num_empty_pages);
       EXPECT_EQ(0u, stats->num_decommitted_pages);
     }
 
+    // TODO(crbug.com/722911): Commenting this out causes this test to fail when
+    // run singly (--gtest_filter=PartitionAllocTest.DumpMemoryStats), but not
+    // when run with the others (--gtest_filter=PartitionAllocTest.*).
     CycleGenericFreeCache(kTestAllocSize);
 
     {
       MockPartitionStatsDumper dumper;
       PartitionDumpStatsGeneric(generic_allocator.root(),
                                 "mock_generic_allocator",
                                 false /* detailed dump */, &dumper);
       EXPECT_FALSE(dumper.IsMemoryAllocationRecorded());
 
       const PartitionBucketMemoryStats* stats = dumper.GetBucketStats(2048);
@@ skipping 95 matching lines @@
       EXPECT_EQ(0u, stats->discardable_bytes);
       EXPECT_EQ(1u, stats->num_full_pages);
       EXPECT_EQ(0u, stats->num_active_pages);
       EXPECT_EQ(0u, stats->num_empty_pages);
       EXPECT_EQ(0u, stats->num_decommitted_pages);
     }
 
     PartitionFreeGeneric(generic_allocator.root(), ptr2);
     PartitionFreeGeneric(generic_allocator.root(), ptr);
 
-    // Whilst we're here, allocate again and free with different ordering
-    // to give a workout to our linked list code.
+    // Whilst we're here, allocate again and free with different ordering to
+    // give a workout to our linked list code.
     ptr = PartitionAllocGeneric(generic_allocator.root(), size_smaller,
                                 type_name);
     ptr2 =
         PartitionAllocGeneric(generic_allocator.root(), size_bigger, type_name);
     PartitionFreeGeneric(generic_allocator.root(), ptr);
     PartitionFreeGeneric(generic_allocator.root(), ptr2);
   }
 
   // This test checks large-but-not-quite-direct allocations.
   {
@@ skipping 76 matching lines @@
       EXPECT_EQ(0u, stats->num_active_pages);
       EXPECT_EQ(0u, stats->num_empty_pages);
       EXPECT_EQ(0u, stats->num_decommitted_pages);
     }
 
     PartitionFreeGeneric(generic_allocator.root(), ptr2);
   }
 }
 
 // Tests the API to purge freeable memory.
-TEST(PartitionAllocTest, Purge) {
-  TestSetup();
-
+TEST_F(PartitionAllocTest, Purge) {
   char* ptr = reinterpret_cast<char*>(PartitionAllocGeneric(
       generic_allocator.root(), 2048 - kExtraAllocSize, type_name));
   PartitionFreeGeneric(generic_allocator.root(), ptr);
   {
     MockPartitionStatsDumper dumper;
     PartitionDumpStatsGeneric(generic_allocator.root(),
                               "mock_generic_allocator",
                               false /* detailed dump */, &dumper);
     EXPECT_FALSE(dumper.IsMemoryAllocationRecorded());
 
@@ skipping 29 matching lines @@
   PartitionPurgeMemoryGeneric(generic_allocator.root(),
                               PartitionPurgeDecommitEmptyPages);
 
   CheckPageInCore(ptr - kPointerOffset, false);
   CheckPageInCore(bigPtr - kPointerOffset, false);
 }
 
 // Tests that we prefer to allocate into a non-empty partition page over an
 // empty one. This is an important aspect of minimizing memory usage for some
 // allocation sizes, particularly larger ones.
-TEST(PartitionAllocTest, PreferActiveOverEmpty) {
-  TestSetup();
-
+TEST_F(PartitionAllocTest, PreferActiveOverEmpty) {
   size_t size = (kSystemPageSize * 2) - kExtraAllocSize;
   // Allocate 3 full slot spans worth of 8192-byte allocations.
   // Each slot span for this size is 16384 bytes, or 1 partition page and 2
   // slots.
   void* ptr1 = PartitionAllocGeneric(generic_allocator.root(), size, type_name);
   void* ptr2 = PartitionAllocGeneric(generic_allocator.root(), size, type_name);
   void* ptr3 = PartitionAllocGeneric(generic_allocator.root(), size, type_name);
   void* ptr4 = PartitionAllocGeneric(generic_allocator.root(), size, type_name);
   void* ptr5 = PartitionAllocGeneric(generic_allocator.root(), size, type_name);
   void* ptr6 = PartitionAllocGeneric(generic_allocator.root(), size, type_name);
@@ skipping 28 matching lines @@
   // empty. We used to fail that.
   void* ptr7 = PartitionAllocGeneric(generic_allocator.root(), size, type_name);
   EXPECT_EQ(ptr6, ptr7);
   EXPECT_EQ(page3, bucket->active_pages_head);
 
   PartitionFreeGeneric(generic_allocator.root(), ptr5);
   PartitionFreeGeneric(generic_allocator.root(), ptr7);
 }
 
 // Tests the API to purge discardable memory.
-TEST(PartitionAllocTest, PurgeDiscardable) {
-  TestSetup();
-
+TEST_F(PartitionAllocTest, PurgeDiscardable) {
   // Free the second of two 4096 byte allocations and then purge.
   {
     void* ptr1 = PartitionAllocGeneric(
         generic_allocator.root(), kSystemPageSize - kExtraAllocSize, type_name);
     char* ptr2 = reinterpret_cast<char*>(
         PartitionAllocGeneric(generic_allocator.root(),
                               kSystemPageSize - kExtraAllocSize, type_name));
     PartitionFreeGeneric(generic_allocator.root(), ptr2);
     PartitionPage* page =
         PartitionPointerToPage(PartitionCookieFreePointerAdjust(ptr1));
@@ skipping 252 matching lines @@
     CheckPageInCore(ptr1 - kPointerOffset + (kSystemPageSize * 2), false);
     CheckPageInCore(ptr1 - kPointerOffset + (kSystemPageSize * 3), false);
 
     EXPECT_FALSE(page->freelist_head);
 
     PartitionFreeGeneric(generic_allocator.root(), ptr1);
     PartitionFreeGeneric(generic_allocator.root(), ptr2);
   }
 }
 
-TEST(PartitionAllocTest, ReallocMovesCookies) {
-  TestSetup();
-
+TEST_F(PartitionAllocTest, ReallocMovesCookies) {
   // Resize so as to be sure to hit a "resize in place" case, and ensure that
   // use of the entire result is compatible with the debug mode's cookies, even
   // when the bucket size is large enough to span more than one partition page
   // and we can track the "raw" size. See https://crbug.com/709271
   const size_t kSize = base::kMaxSystemPagesPerSlotSpan * base::kSystemPageSize;
   void* ptr =
       PartitionAllocGeneric(generic_allocator.root(), kSize + 1, type_name);
   EXPECT_TRUE(ptr);
 
   memset(ptr, 0xbd, kSize + 1);
   ptr = PartitionReallocGeneric(generic_allocator.root(), ptr, kSize + 2,
                                 type_name);
   EXPECT_TRUE(ptr);
 
   memset(ptr, 0xbd, kSize + 2);
   PartitionFreeGeneric(generic_allocator.root(), ptr);
 }
 
 }  // namespace base
 
 #endif  // !defined(MEMORY_TOOL_REPLACES_ALLOCATOR)