Clean up subsumed tests in tcmalloc.

tcmalloc/BUILD

@@ -1243,7 +1243,6 @@ create_tcmalloc_testsuite(
     srcs = ["span_test.cc"],
     copts = TCMALLOC_DEFAULT_COPTS,
     deps = [
-        ":experiment",
         "//tcmalloc/internal:logging",
         "@com_github_google_benchmark//:benchmark",
         "@com_google_absl//absl/base",

tcmalloc/huge_page_aware_allocator_test.cc

@@ -321,30 +321,6 @@ struct SpanInfo {
   SpanAllocInfo span_alloc_info;
 };
 
-TEST_P(HugePageAwareAllocatorTest, Fuzz) {
-  absl::BitGen rng;
-  std::vector<SpanInfo> allocs;
-  for (int i = 0; i < 1000; ++i) {
-    auto [n, span_alloc_info] = RandomAllocSize(rng);
-    Span* s = New(n, span_alloc_info);
-    allocs.push_back(SpanInfo{s, span_alloc_info});
-  }
-  static const size_t kReps = 10 * 1000;
-  for (int i = 0; i < kReps; ++i) {
-    SCOPED_TRACE(absl::StrFormat("%d reps, %d pages", i, total_.raw_num()));
-    size_t index = absl::Uniform<int32_t>(rng, 0, allocs.size());
-    Span* old_span = allocs[index].span;
-    size_t objects_per_span = allocs[index].span_alloc_info.objects_per_span;
-    Delete(old_span, objects_per_span);
-    auto [n, span_alloc_info] = RandomAllocSize(rng);
-    allocs[index] = SpanInfo{New(n, span_alloc_info), span_alloc_info};
-  }
-
-  for (auto s : allocs) {
-    Delete(s.span, s.span_alloc_info.objects_per_span);
-  }
-}
-
 // Prevent regression of the fragmentation problem that was reported in
 // b/63301358, reproduced in CL/161345659 and (partially) fixed in CL/161305971.
 TEST_P(HugePageAwareAllocatorTest, JustUnderMultipleOfHugepages) {

tcmalloc/span_test.cc

@@ -250,73 +250,6 @@ TEST_P(SpanTest, AllocTime) {
             kSpanAllocTime & kAllocTimeMask);
 }
 
-TEST_P(SpanTest, FreelistRandomized) {
-  Span& span_ = raw_span_.span();
-
-  char* start = static_cast<char*>(span_.start_address());
-
-  // Do a bunch of random pushes/pops with random batch size.
-  absl::BitGen rng;
-  absl::flat_hash_set<void*> objects;
-  void* batch[kMaxObjectsToMove];
-  for (size_t x = 0; x < 10000; ++x) {
-    if (!objects.empty() && absl::Bernoulli(rng, 1.0 / 2)) {
-      void* p = *objects.begin();
-      bool ok;
-      if (absl::Bernoulli(rng, 0.5)) {
-        Span::ObjIdx objidx;
-        if (Span::UseBitmapForSize(size_)) {
-          objidx = span_.BitmapPtrToIdx(p, size_, reciprocal_);
-        } else {
-          objidx = span_.PtrToIdx(p, size_);
-        }
-        ok = span_.FreelistPushBatch(absl::MakeSpan(&objidx, 1), size_,
-                                     reciprocal_);
-      } else {
-        ok = span_.FreelistPushBatch(absl::MakeSpan(&p, 1), size_, reciprocal_);
-      }
-
-      if (ok) {
-        objects.erase(objects.begin());
-      } else {
-        EXPECT_EQ(objects.size(), 1);
-      }
-      EXPECT_EQ(span_.FreelistEmpty(size_, objects_per_span_),
-                objects_per_span_ == 1);
-    } else {
-      size_t want = absl::Uniform<int32_t>(rng, 0, batch_size_) + 1;
-      size_t n = span_.FreelistPopBatch(absl::MakeSpan(batch, want), size_);
-      if (n < want) {
-        EXPECT_TRUE(span_.FreelistEmpty(size_, objects_per_span_));
-      }
-      for (size_t i = 0; i < n; ++i) {
-        EXPECT_TRUE(objects.insert(batch[i]).second);
-      }
-    }
-  }
-
-  EXPECT_EQ(span_.AllocTime() & kAllocTimeMask,
-            kSpanAllocTime & kAllocTimeMask);
-  // Now pop everything what's there.
-  for (;;) {
-    size_t n =
-        span_.FreelistPopBatch(absl::MakeSpan(batch, batch_size_), size_);
-    for (size_t i = 0; i < n; ++i) {
-      EXPECT_TRUE(objects.insert(batch[i]).second);
-    }
-    if (n < batch_size_) {
-      break;
-    }
-  }
-  // Check that we have collected all objects.
-  EXPECT_EQ(objects.size(), objects_per_span_);
-  for (void* p : objects) {
-    uintptr_t off = reinterpret_cast<char*>(p) - start;
-    EXPECT_LT(off, span_.bytes_in_span());
-    EXPECT_EQ(off % size_, 0);
-  }
-}
-
 INSTANTIATE_TEST_SUITE_P(All, SpanTest, testing::Range(size_t(1), kNumClasses));
 
 TEST(SpanAllocatorTest, Alignment) {