@nxtedition/rocksdb 15.2.2 → 15.2.4

package/deps/abseil-cpp/absl/debugging/failure_signal_handler_test.cc

@@ -1,166 +0,0 @@
-//
-// Copyright 2018 The Abseil Authors.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//      https://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-//
-
-#include "absl/debugging/failure_signal_handler.h"
-
-#include <csignal>
-#include <cstdio>
-#include <cstdlib>
-#include <cstring>
-#include <fstream>
-
-#include "gmock/gmock.h"
-#include "gtest/gtest.h"
-#include "absl/base/internal/raw_logging.h"
-#include "absl/debugging/stacktrace.h"
-#include "absl/debugging/symbolize.h"
-#include "absl/log/check.h"
-#include "absl/strings/match.h"
-#include "absl/strings/str_cat.h"
-
-namespace {
-
-using testing::StartsWith;
-
-#if GTEST_HAS_DEATH_TEST
-
-// For the parameterized death tests. GetParam() returns the signal number.
-using FailureSignalHandlerDeathTest = ::testing::TestWithParam<int>;
-
-// This function runs in a fork()ed process on most systems.
-void InstallHandlerAndRaise(int signo) {
-  absl::InstallFailureSignalHandler(absl::FailureSignalHandlerOptions());
-  raise(signo);
-}
-
-TEST_P(FailureSignalHandlerDeathTest, AbslFailureSignal) {
-  const int signo = GetParam();
-  std::string exit_regex = absl::StrCat(
-      "\\*\\*\\* ", absl::debugging_internal::FailureSignalToString(signo),
-      " received at time=");
-#ifndef _WIN32
-  EXPECT_EXIT(InstallHandlerAndRaise(signo), testing::KilledBySignal(signo),
-              exit_regex);
-#else
-  // Windows doesn't have testing::KilledBySignal().
-  EXPECT_DEATH_IF_SUPPORTED(InstallHandlerAndRaise(signo), exit_regex);
-#endif
-}
-
-ABSL_CONST_INIT FILE* error_file = nullptr;
-
-void WriteToErrorFile(const char* msg) {
-  if (msg != nullptr) {
-    ABSL_RAW_CHECK(fwrite(msg, strlen(msg), 1, error_file) == 1,
-                   "fwrite() failed");
-  }
-  ABSL_RAW_CHECK(fflush(error_file) == 0, "fflush() failed");
-}
-
-std::string GetTmpDir() {
-  // TEST_TMPDIR is set by Bazel. Try the others when not running under Bazel.
-  static const char* const kTmpEnvVars[] = {"TEST_TMPDIR", "TMPDIR", "TEMP",
-                                            "TEMPDIR", "TMP"};
-  for (const char* const var : kTmpEnvVars) {
-    const char* tmp_dir = std::getenv(var);
-    if (tmp_dir != nullptr) {
-      return tmp_dir;
-    }
-  }
-
-  // Try something reasonable.
-  return "/tmp";
-}
-
-// This function runs in a fork()ed process on most systems.
-void InstallHandlerWithWriteToFileAndRaise(const char* file, int signo) {
-  error_file = fopen(file, "w");
-  CHECK_NE(error_file, nullptr) << "Failed create error_file";
-  absl::FailureSignalHandlerOptions options;
-  options.writerfn = WriteToErrorFile;
-  absl::InstallFailureSignalHandler(options);
-  raise(signo);
-}
-
-TEST_P(FailureSignalHandlerDeathTest, AbslFatalSignalsWithWriterFn) {
-  const int signo = GetParam();
-  std::string tmp_dir = GetTmpDir();
-  std::string file = absl::StrCat(tmp_dir, "/signo_", signo);
-
-  std::string exit_regex = absl::StrCat(
-      "\\*\\*\\* ", absl::debugging_internal::FailureSignalToString(signo),
-      " received at time=");
-#ifndef _WIN32
-  EXPECT_EXIT(InstallHandlerWithWriteToFileAndRaise(file.c_str(), signo),
-              testing::KilledBySignal(signo), exit_regex);
-#else
-  // Windows doesn't have testing::KilledBySignal().
-  EXPECT_DEATH_IF_SUPPORTED(
-      InstallHandlerWithWriteToFileAndRaise(file.c_str(), signo), exit_regex);
-#endif
-
-  // Open the file in this process and check its contents.
-  std::fstream error_output(file);
-  ASSERT_TRUE(error_output.is_open()) << file;
-  std::string error_line;
-  std::getline(error_output, error_line);
-  EXPECT_THAT(
-      error_line,
-      StartsWith(absl::StrCat(
-          "*** ", absl::debugging_internal::FailureSignalToString(signo),
-          " received at ")));
-
-  // On platforms where it is possible to get the current CPU, the
-  // CPU number is also logged. Check that it is present in output.
-#if defined(__linux__)
-  EXPECT_THAT(error_line, testing::HasSubstr(" on cpu "));
-#endif
-
-  if (absl::debugging_internal::StackTraceWorksForTest()) {
-    std::getline(error_output, error_line);
-    EXPECT_THAT(error_line, StartsWith("PC: "));
-  }
-}
-
-constexpr int kFailureSignals[] = {
-    SIGSEGV, SIGILL,  SIGFPE, SIGABRT, SIGTERM,
-#ifndef _WIN32
-    SIGBUS,  SIGTRAP,
-#endif
-};
-
-std::string SignalParamToString(const ::testing::TestParamInfo<int>& info) {
-  std::string result =
-      absl::debugging_internal::FailureSignalToString(info.param);
-  if (result.empty()) {
-    result = absl::StrCat(info.param);
-  }
-  return result;
-}
-
-INSTANTIATE_TEST_SUITE_P(AbslDeathTest, FailureSignalHandlerDeathTest,
-                         ::testing::ValuesIn(kFailureSignals),
-                         SignalParamToString);
-
-#endif  // GTEST_HAS_DEATH_TEST
-
-}  // namespace
-
-int main(int argc, char** argv) {
-  absl::InitializeSymbolizer(argv[0]);
-  testing::InitGoogleTest(&argc, argv);
-  return RUN_ALL_TESTS();
-}

package/deps/abseil-cpp/absl/debugging/internal/address_is_readable.cc

@@ -1,98 +0,0 @@
-// Copyright 2017 The Abseil Authors.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//      https://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-// base::AddressIsReadable() probes an address to see whether it is readable,
-// without faulting.
-
-#include "absl/debugging/internal/address_is_readable.h"
-
-#if !defined(__linux__) || defined(__ANDROID__)
-
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace debugging_internal {
-
-// On platforms other than Linux, just return true.
-bool AddressIsReadable(const void* /* addr */) { return true; }
-
-}  // namespace debugging_internal
-ABSL_NAMESPACE_END
-}  // namespace absl
-
-#else  // __linux__ && !__ANDROID__
-
-#include <stdint.h>
-#include <syscall.h>
-#include <unistd.h>
-
-#include "absl/base/internal/errno_saver.h"
-#include "absl/base/internal/raw_logging.h"
-
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace debugging_internal {
-
-// NOTE: be extra careful about adding any interposable function calls here
-// (such as open(), read(), etc.). These symbols may be interposed and will get
-// invoked in contexts they don't expect.
-//
-// NOTE: any new system calls here may also require sandbox reconfiguration.
-//
-bool AddressIsReadable(const void *addr) {
-  // rt_sigprocmask below checks 8 contiguous bytes. If addr resides in the
-  // last 7 bytes of a page (unaligned), rt_sigprocmask would additionally
-  // check the readability of the next page, which is not desired. Align
-  // address on 8-byte boundary to check only the current page.
-  const uintptr_t u_addr = reinterpret_cast<uintptr_t>(addr) & ~uintptr_t{7};
-  addr = reinterpret_cast<const void *>(u_addr);
-
-  // rt_sigprocmask below will succeed for this input.
-  if (addr == nullptr) return false;
-
-  absl::base_internal::ErrnoSaver errno_saver;
-
-  // Here we probe with some syscall which
-  // - accepts an 8-byte region of user memory as input
-  // - tests for EFAULT before other validation
-  // - has no problematic side-effects
-  //
-  // rt_sigprocmask(2) works for this.  It copies sizeof(kernel_sigset_t)==8
-  // bytes from the address into the kernel memory before any validation.
-  //
-  // The call can never succeed, since the `how` parameter is not one of
-  // SIG_BLOCK, SIG_UNBLOCK, SIG_SETMASK.
-  //
-  // This strategy depends on Linux implementation details,
-  // so we rely on the test to alert us if it stops working.
-  //
-  // Some discarded past approaches:
-  // - msync() doesn't reject PROT_NONE regions
-  // - write() on /dev/null doesn't return EFAULT
-  // - write() on a pipe requires creating it and draining the writes
-  // - connect() works but is problematic for sandboxes and needs a valid
-  //   file descriptor
-  //
-  // This can never succeed (invalid first argument to sigprocmask).
-  ABSL_RAW_CHECK(syscall(SYS_rt_sigprocmask, ~0, addr, nullptr,
-                         /*sizeof(kernel_sigset_t)*/ 8) == -1,
-                 "unexpected success");
-  ABSL_RAW_CHECK(errno == EFAULT || errno == EINVAL, "unexpected errno");
-  return errno != EFAULT;
-}
-
-}  // namespace debugging_internal
-ABSL_NAMESPACE_END
-}  // namespace absl
-
-#endif  // __linux__ && !__ANDROID__

package/deps/abseil-cpp/absl/debugging/internal/address_is_readable.h

@@ -1,32 +0,0 @@
-// Copyright 2017 The Abseil Authors.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//      https://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#ifndef ABSL_DEBUGGING_INTERNAL_ADDRESS_IS_READABLE_H_
-#define ABSL_DEBUGGING_INTERNAL_ADDRESS_IS_READABLE_H_
-
-#include "absl/base/config.h"
-
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace debugging_internal {
-
-// Return whether the byte at *addr is readable, without faulting.
-// Save and restores errno.
-bool AddressIsReadable(const void *addr);
-
-}  // namespace debugging_internal
-ABSL_NAMESPACE_END
-}  // namespace absl
-
-#endif  // ABSL_DEBUGGING_INTERNAL_ADDRESS_IS_READABLE_H_

package/deps/abseil-cpp/absl/debugging/internal/addresses.h

@@ -1,57 +0,0 @@
-// Copyright 2025 The Abseil Authors
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     https://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#ifndef ABSL_DEBUGGING_INTERNAL_ADDRESSES_H_
-#define ABSL_DEBUGGING_INTERNAL_ADDRESSES_H_
-
-#include <stdint.h>
-
-#include "absl/base/config.h"
-
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace debugging_internal {
-
-// Removes any metadata (tag bits) from the given pointer, converting it into a
-// user-readable address.
-inline uintptr_t StripPointerMetadata(uintptr_t ptr) {
-#if defined(__aarch64__)
-  // When PAC-RET (-mbranch-protection=pac-ret) is enabled, return addresses
-  // stored on the stack will be signed, which means that pointer bits outside
-  // of the virtual address range are potentially set. Since the stacktrace code
-  // is expected to return normal code pointers, this function clears those
-  // bits.
-  register uintptr_t x30 __asm__("x30") = ptr;
-  // The normal instruction for clearing PAC bits is XPACI, but for
-  // compatibility with ARM platforms that do not support pointer
-  // authentication, we use the hint space instruction XPACLRI instead. Hint
-  // space instructions behave as NOPs on unsupported platforms.
-#define ABSL_XPACLRI_HINT "hint #0x7;"
-  asm(ABSL_XPACLRI_HINT : "+r"(x30));  // asm("xpaclri" : "+r"(x30));
-#undef ABSL_XPACLRI_HINT
-  return x30;
-#else
-  return ptr;
-#endif
-}
-
-inline uintptr_t StripPointerMetadata(void* ptr) {
-  return StripPointerMetadata(reinterpret_cast<uintptr_t>(ptr));
-}
-
-}  // namespace debugging_internal
-ABSL_NAMESPACE_END
-}  // namespace absl
-
-#endif  // ABSL_DEBUGGING_INTERNAL_ADDRESSES_H_

package/deps/abseil-cpp/absl/debugging/internal/borrowed_fixup_buffer.cc

@@ -1,118 +0,0 @@
-// Copyright 2025 The Abseil Authors
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     https://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#include "absl/debugging/internal/borrowed_fixup_buffer.h"
-
-#include <assert.h>
-#include <limits.h>
-#include <stddef.h>
-#include <stdint.h>
-
-#include <atomic>
-#include <iterator>
-#include <utility>
-
-#include "absl/base/attributes.h"
-#include "absl/base/config.h"
-#include "absl/base/internal/low_level_alloc.h"
-#include "absl/hash/hash.h"
-
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace internal_stacktrace {
-
-// A buffer for holding fix-up information for stack traces of common sizes_.
-struct BorrowedFixupBuffer::FixupStackBuffer {
-  static constexpr size_t kMaxStackElements = 128;  // Can be reduced if needed
-  std::atomic_flag in_use{};
-  uintptr_t frames[kMaxStackElements];
-  int sizes[kMaxStackElements];
-
-  ABSL_CONST_INIT static FixupStackBuffer g_instances[kNumStaticBuffers];
-};
-
-ABSL_CONST_INIT BorrowedFixupBuffer::FixupStackBuffer
-    BorrowedFixupBuffer::FixupStackBuffer::g_instances[kNumStaticBuffers] = {};
-
-BorrowedFixupBuffer::~BorrowedFixupBuffer() {
-  if (borrowed_) {
-    std::move(*this).Unlock();
-  } else {
-    base_internal::LowLevelAlloc::Free(frames_);
-  }
-}
-
-BorrowedFixupBuffer::BorrowedFixupBuffer(size_t length)
-    : borrowed_(0 < length && length <= FixupStackBuffer::kMaxStackElements
-                    ? TryLock()
-                    : nullptr) {
-  if (borrowed_) {
-    InitViaBorrow();
-  } else {
-    InitViaAllocation(length);
-  }
-}
-
-void BorrowedFixupBuffer::InitViaBorrow() {
-  assert(borrowed_);
-  frames_ = borrowed_->frames;
-  sizes_ = borrowed_->sizes;
-}
-
-void BorrowedFixupBuffer::InitViaAllocation(size_t length) {
-  static_assert(alignof(decltype(*frames_)) >= alignof(decltype(*sizes_)),
-                "contiguous layout assumes decreasing alignment, otherwise "
-                "padding may be needed in the middle");
-  assert(!borrowed_);
-
-  base_internal::InitSigSafeArena();
-  void* buf = base_internal::LowLevelAlloc::AllocWithArena(
-      length * (sizeof(*frames_) + sizeof(*sizes_)),
-      base_internal::SigSafeArena());
-
-  if (buf == nullptr) {
-    frames_ = nullptr;
-    sizes_ = nullptr;
-    return;
-  }
-
-  frames_ = new (buf) uintptr_t[length];
-  sizes_ = new (static_cast<void*>(static_cast<unsigned char*>(buf) +
-                                   length * sizeof(*frames_))) int[length];
-}
-
-[[nodiscard]] BorrowedFixupBuffer::FixupStackBuffer*
-BorrowedFixupBuffer::TryLock() {
-  constexpr size_t kNumSlots = std::size(FixupStackBuffer::g_instances);
-  const size_t i = absl::Hash<const void*>()(this) % kNumSlots;
-  for (size_t k = 0; k < kNumSlots; ++k) {
-    auto* instance = &FixupStackBuffer::g_instances[(i + k) % kNumSlots];
-    // Use memory_order_acquire to ensure that no reads and writes on the
-    // borrowed buffer are reordered before the borrowing.
-    if (!instance->in_use.test_and_set(std::memory_order_acquire)) {
-      return instance;
-    }
-  }
-  return nullptr;
-}
-
-void BorrowedFixupBuffer::Unlock() && {
-  // Use memory_order_release to ensure that no reads and writes on the borrowed
-  // buffer are reordered after the borrowing.
-  borrowed_->in_use.clear(std::memory_order_release);
-}
-
-}  // namespace internal_stacktrace
-ABSL_NAMESPACE_END
-}  // namespace absl

package/deps/abseil-cpp/absl/debugging/internal/borrowed_fixup_buffer.h

@@ -1,71 +0,0 @@
-// Copyright 2025 The Abseil Authors
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     https://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#ifndef ABSL_DEBUGGING_INTERNAL_BORROWED_FIXUP_BUFFER_H_
-#define ABSL_DEBUGGING_INTERNAL_BORROWED_FIXUP_BUFFER_H_
-
-#include <stddef.h>
-#include <stdint.h>
-#include <stdlib.h>
-
-#include "absl/base/config.h"
-
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace internal_stacktrace {
-
-// An RAII type that temporarily acquires a buffer for stack trace fix-ups from
-// a pool of preallocated buffers, or attempts to allocate a new buffer if no
-// such buffer is available.
-// When destroyed, returns the buffer to the pool if it borrowed successfully,
-// otherwise deallocates any previously allocated buffer.
-class BorrowedFixupBuffer {
- public:
-  static constexpr size_t kNumStaticBuffers = 64;
-  ~BorrowedFixupBuffer();
-
-  // The number of frames to allocate space for. Note that allocations can fail.
-  explicit BorrowedFixupBuffer(size_t length);
-
-  uintptr_t* frames() const { return frames_; }
-  int* sizes() const { return sizes_; }
-
- private:
-  struct FixupStackBuffer;
-
-  uintptr_t* frames_;
-  int* sizes_;
-
-  // The borrowed pre-existing buffer, if any (if we haven't allocated our own)
-  FixupStackBuffer* const borrowed_;
-
-  void InitViaBorrow();
-  void InitViaAllocation(size_t length);
-
-  // Attempts to opportunistically borrow a small buffer in a thread- and
-  // signal-safe manner. Returns nullptr on failure.
-  [[nodiscard]] FixupStackBuffer* TryLock();
-
-  // Returns the borrowed buffer.
-  void Unlock() &&;
-
-  BorrowedFixupBuffer(const BorrowedFixupBuffer&) = delete;
-  BorrowedFixupBuffer& operator=(const BorrowedFixupBuffer&) = delete;
-};
-
-}  // namespace internal_stacktrace
-ABSL_NAMESPACE_END
-}  // namespace absl
-
-#endif  // ABSL_DEBUGGING_INTERNAL_BORROWED_FIXUP_BUFFER_H_

package/deps/abseil-cpp/absl/debugging/internal/borrowed_fixup_buffer_test.cc

@@ -1,97 +0,0 @@
-// Copyright 2025 The Abseil Authors
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     https://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#include "absl/debugging/internal/borrowed_fixup_buffer.h"
-
-#include <stddef.h>
-#include <stdint.h>
-
-#include <algorithm>
-#include <functional>
-#include <memory>
-
-#include "gtest/gtest.h"
-#include "absl/base/config.h"
-
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace internal_stacktrace {
-namespace {
-
-TEST(BorrowedFixupBuffer, ProperReuse) {
-  uintptr_t first_borrowed_frame = 0;
-  uintptr_t first_borrowed_size = 0;
-
-  // Ensure that we borrow the same buffer each time, indicating proper reuse.
-  // Disable loop unrolling. We need all iterations to match exactly, to coax
-  // reuse of the the same underlying buffer.
-#if defined(__GNUC__) || defined(__clang__)
-#pragma GCC unroll 1  // <= 1 disables unrolling
-#endif
-  for (int i = 0; i < 100; ++i) {
-    BorrowedFixupBuffer buf0(0);
-    EXPECT_EQ(buf0.frames(), nullptr);
-    EXPECT_EQ(buf0.sizes(), nullptr);
-
-    BorrowedFixupBuffer buf1(1);
-    EXPECT_NE(buf1.frames(), nullptr);
-    EXPECT_NE(buf1.sizes(), nullptr);
-    if (first_borrowed_frame == 0) {
-      first_borrowed_frame = reinterpret_cast<uintptr_t>(buf1.frames());
-    } else {
-      EXPECT_EQ(reinterpret_cast<uintptr_t>(buf1.frames()),
-                first_borrowed_frame);
-    }
-    if (first_borrowed_size == 0) {
-      first_borrowed_size = reinterpret_cast<uintptr_t>(buf1.sizes());
-    } else {
-      EXPECT_EQ(reinterpret_cast<uintptr_t>(buf1.sizes()), first_borrowed_size);
-    }
-
-    BorrowedFixupBuffer buf2(2);
-    EXPECT_NE(buf2.frames(), buf1.frames());
-    EXPECT_NE(buf2.sizes(), buf1.sizes());
-    EXPECT_NE(buf2.frames(), nullptr);
-    EXPECT_NE(buf2.sizes(), nullptr);
-  }
-}
-
-TEST(BorrowedFixupBuffer, NoOverlap) {
-  using BufferPtr = std::unique_ptr<BorrowedFixupBuffer>;
-  static constexpr std::less<const void*> less;
-  static constexpr size_t kBufLen = 5;
-  static constexpr size_t kNumBuffers =
-      BorrowedFixupBuffer::kNumStaticBuffers * 37 + 1;
-
-  auto bufs = std::make_unique<BufferPtr[]>(kNumBuffers);
-  for (size_t i = 0; i < kNumBuffers; ++i) {
-    bufs[i] = std::make_unique<BorrowedFixupBuffer>(kBufLen);
-  }
-
-  std::sort(bufs.get(), bufs.get() + kNumBuffers,
-            [](const BufferPtr& a, const BufferPtr& b) {
-              return less(a->frames(), b->frames());
-            });
-
-  // Verify there are no overlaps
-  for (size_t i = 1; i < kNumBuffers; ++i) {
-    EXPECT_FALSE(less(bufs[i]->frames(), bufs[i - 1]->frames() + kBufLen));
-    EXPECT_FALSE(less(bufs[i]->sizes(), bufs[i - 1]->sizes() + kBufLen));
-  }
-}
-
-}  // namespace
-}  // namespace internal_stacktrace
-ABSL_NAMESPACE_END
-}  // namespace absl