rocksdb-native 2.6.2 → 2.6.4

package/vendor/librocksdb/vendor/rocksdb/table/unique_id.cc

@@ -1,223 +0,0 @@
-//  Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
-//  This source code is licensed under both the GPLv2 (found in the
-//  COPYING file in the root directory) and Apache 2.0 License
-//  (found in the LICENSE.Apache file in the root directory).
-
-#include <cstdint>
-
-#include "table/unique_id_impl.h"
-#include "util/coding_lean.h"
-#include "util/hash.h"
-#include "util/string_util.h"
-
-namespace ROCKSDB_NAMESPACE {
-
-std::string EncodeSessionId(uint64_t upper, uint64_t lower) {
-  std::string db_session_id(20U, '\0');
-  char *buf = db_session_id.data();
-  // Preserving `lower` is slightly tricky. 36^12 is slightly more than
-  // 62 bits, so we use 12 chars plus the bottom two bits of one more.
-  // (A tiny fraction of 20 digit strings go unused.)
-  uint64_t a = (upper << 2) | (lower >> 62);
-  uint64_t b = lower & (UINT64_MAX >> 2);
-  PutBaseChars<36>(&buf, 8, a, /*uppercase*/ true);
-  PutBaseChars<36>(&buf, 12, b, /*uppercase*/ true);
-  assert(buf == &db_session_id.back() + 1);
-  return db_session_id;
-}
-
-Status DecodeSessionId(const std::string &db_session_id, uint64_t *upper,
-                       uint64_t *lower) {
-  const size_t len = db_session_id.size();
-  if (len == 0) {
-    return Status::NotSupported("Missing db_session_id");
-  }
-  // Anything from 13 to 24 chars is reasonable. We don't have to limit to
-  // exactly 20.
-  if (len < 13) {
-    return Status::NotSupported("Too short db_session_id");
-  }
-  if (len > 24) {
-    return Status::NotSupported("Too long db_session_id");
-  }
-  uint64_t a = 0, b = 0;
-  const char *buf = &db_session_id.front();
-  bool success = ParseBaseChars<36>(&buf, len - 12U, &a);
-  if (!success) {
-    return Status::NotSupported("Bad digit in db_session_id");
-  }
-  success = ParseBaseChars<36>(&buf, 12U, &b);
-  if (!success) {
-    return Status::NotSupported("Bad digit in db_session_id");
-  }
-  assert(buf == &db_session_id.back() + 1);
-  *upper = a >> 2;
-  *lower = (b & (UINT64_MAX >> 2)) | (a << 62);
-  return Status::OK();
-}
-
-Status GetSstInternalUniqueId(const std::string &db_id,
-                              const std::string &db_session_id,
-                              uint64_t file_number, UniqueIdPtr out,
-                              bool force) {
-  if (!force) {
-    if (db_id.empty()) {
-      return Status::NotSupported("Missing db_id");
-    }
-    if (file_number == 0) {
-      return Status::NotSupported("Missing or bad file number");
-    }
-    if (db_session_id.empty()) {
-      return Status::NotSupported("Missing db_session_id");
-    }
-  }
-  uint64_t session_upper = 0;  // Assignment to appease clang-analyze
-  uint64_t session_lower = 0;  // Assignment to appease clang-analyze
-  {
-    Status s = DecodeSessionId(db_session_id, &session_upper, &session_lower);
-    if (!s.ok()) {
-      if (!force) {
-        return s;
-      } else {
-        // A reasonable fallback in case malformed
-        Hash2x64(db_session_id.data(), db_session_id.size(), &session_upper,
-                 &session_lower);
-        if (session_lower == 0) {
-          session_lower = session_upper | 1;
-        }
-      }
-    }
-  }
-
-  // Exactly preserve session lower to ensure that session ids generated
-  // during the same process lifetime are guaranteed unique.
-  // DBImpl also guarantees (in recent versions) that this is not zero,
-  // so that we can guarantee unique ID is never all zeros. (Can't assert
-  // that here because of testing and old versions.)
-  // We put this first in anticipation of matching a small-ish set of cache
-  // key prefixes to cover entries relevant to any DB.
-  out.ptr[0] = session_lower;
-
-  // Hash the session upper (~39 bits entropy) and DB id (120+ bits entropy)
-  // for very high global uniqueness entropy.
-  // (It is possible that many DBs descended from one common DB id are copied
-  // around and proliferate, in which case session id is critical, but it is
-  // more common for different DBs to have different DB ids.)
-  uint64_t db_a, db_b;
-  Hash2x64(db_id.data(), db_id.size(), session_upper, &db_a, &db_b);
-
-  // Xor in file number for guaranteed uniqueness by file number for a given
-  // session and DB id. (Xor slightly better than + here. See
-  // https://github.com/pdillinger/unique_id )
-  out.ptr[1] = db_a ^ file_number;
-
-  // Extra (optional) global uniqueness
-  if (out.extended) {
-    out.ptr[2] = db_b;
-  }
-
-  return Status::OK();
-}
-
-namespace {
-// For InternalUniqueIdToExternal / ExternalUniqueIdToInternal we want all
-// zeros in first 128 bits to map to itself, so that excluding zero in
-// internal IDs (session_lower != 0 above) does the same for external IDs.
-// These values are meaningless except for making that work.
-constexpr uint64_t kHiOffsetForZero = 17391078804906429400U;
-constexpr uint64_t kLoOffsetForZero = 6417269962128484497U;
-}  // namespace
-
-void InternalUniqueIdToExternal(UniqueIdPtr in_out) {
-  uint64_t hi, lo;
-  BijectiveHash2x64(in_out.ptr[1] + kHiOffsetForZero,
-                    in_out.ptr[0] + kLoOffsetForZero, &hi, &lo);
-  in_out.ptr[0] = lo;
-  in_out.ptr[1] = hi;
-  if (in_out.extended) {
-    in_out.ptr[2] += lo + hi;
-  }
-}
-
-void ExternalUniqueIdToInternal(UniqueIdPtr in_out) {
-  uint64_t lo = in_out.ptr[0];
-  uint64_t hi = in_out.ptr[1];
-  if (in_out.extended) {
-    in_out.ptr[2] -= lo + hi;
-  }
-  BijectiveUnhash2x64(hi, lo, &hi, &lo);
-  in_out.ptr[0] = lo - kLoOffsetForZero;
-  in_out.ptr[1] = hi - kHiOffsetForZero;
-}
-
-std::string EncodeUniqueIdBytes(UniqueIdPtr in) {
-  std::string ret(in.extended ? 24U : 16U, '\0');
-  EncodeFixed64(ret.data(), in.ptr[0]);
-  EncodeFixed64(&ret[8], in.ptr[1]);
-  if (in.extended) {
-    EncodeFixed64(&ret[16], in.ptr[2]);
-  }
-  return ret;
-}
-
-Status DecodeUniqueIdBytes(const std::string &unique_id, UniqueIdPtr out) {
-  if (unique_id.size() != (out.extended ? 24 : 16)) {
-    return Status::NotSupported("Not a valid unique_id");
-  }
-  const char *buf = &unique_id.front();
-  out.ptr[0] = DecodeFixed64(&buf[0]);
-  out.ptr[1] = DecodeFixed64(&buf[8]);
-  if (out.extended) {
-    out.ptr[2] = DecodeFixed64(&buf[16]);
-  }
-  return Status::OK();
-}
-
-template <typename ID>
-Status GetUniqueIdFromTablePropertiesHelper(const TableProperties &props,
-                                            std::string *out_id) {
-  ID tmp{};
-  Status s = GetSstInternalUniqueId(props.db_id, props.db_session_id,
-                                    props.orig_file_number, &tmp);
-  if (s.ok()) {
-    InternalUniqueIdToExternal(&tmp);
-    *out_id = EncodeUniqueIdBytes(&tmp);
-  } else {
-    out_id->clear();
-  }
-  return s;
-}
-
-Status GetExtendedUniqueIdFromTableProperties(const TableProperties &props,
-                                              std::string *out_id) {
-  return GetUniqueIdFromTablePropertiesHelper<UniqueId64x3>(props, out_id);
-}
-
-Status GetUniqueIdFromTableProperties(const TableProperties &props,
-                                      std::string *out_id) {
-  return GetUniqueIdFromTablePropertiesHelper<UniqueId64x2>(props, out_id);
-}
-
-std::string UniqueIdToHumanString(const std::string &id) {
-  // Not so efficient, but that's OK
-  std::string str = Slice(id).ToString(/*hex*/ true);
-  for (size_t i = 16; i < str.size(); i += 17) {
-    str.insert(i, "-");
-  }
-  return str;
-}
-
-std::string InternalUniqueIdToHumanString(UniqueIdPtr in) {
-  std::string str = "{";
-  str += std::to_string(in.ptr[0]);
-  str += ",";
-  str += std::to_string(in.ptr[1]);
-  if (in.extended) {
-    str += ",";
-    str += std::to_string(in.ptr[2]);
-  }
-  str += "}";
-  return str;
-}
-
-}  // namespace ROCKSDB_NAMESPACE

package/vendor/librocksdb/vendor/rocksdb/table/unique_id_impl.h

@@ -1,93 +0,0 @@
-//  Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
-//  This source code is licensed under both the GPLv2 (found in the
-//  COPYING file in the root directory) and Apache 2.0 License
-//  (found in the LICENSE.Apache file in the root directory).
-
-#pragma once
-
-#include <array>
-
-#include "rocksdb/unique_id.h"
-
-namespace ROCKSDB_NAMESPACE {
-
-// Standard size unique ID, good enough for almost all practical purposes
-using UniqueId64x2 = std::array<uint64_t, 2>;
-
-// Value never used as an actual unique ID so can be used for "null"
-constexpr UniqueId64x2 kNullUniqueId64x2 = {};
-
-// Extended size unique ID, for extra certainty of uniqueness among SST files
-// spanning many hosts over a long time (rarely if ever needed)
-using UniqueId64x3 = std::array<uint64_t, 3>;
-
-// Value never used as an actual unique ID so can be used for "null"
-constexpr UniqueId64x3 kNullUniqueId64x3 = {};
-
-// Dynamic pointer wrapper for one of the two above
-struct UniqueIdPtr {
-  uint64_t *ptr = nullptr;
-  bool extended = false;
-
-  /*implicit*/ UniqueIdPtr(UniqueId64x2 *id) {
-    ptr = (*id).data();
-    extended = false;
-  }
-  /*implicit*/ UniqueIdPtr(UniqueId64x3 *id) {
-    ptr = (*id).data();
-    extended = true;
-  }
-};
-
-// Helper for GetUniqueIdFromTableProperties. This function can also be used
-// for temporary ids for files without sufficient information in table
-// properties. The internal unique id is more structured than the public
-// unique id, so can be manipulated in more ways but very carefully.
-// These must be long term stable to ensure GetUniqueIdFromTableProperties
-// is long term stable.
-Status GetSstInternalUniqueId(const std::string &db_id,
-                              const std::string &db_session_id,
-                              uint64_t file_number, UniqueIdPtr out,
-                              bool force = false);
-
-// Helper for GetUniqueIdFromTableProperties. External unique ids go through
-// this extra hashing layer so that prefixes of the unique id have predictable
-// "full" entropy. This hashing layer is 1-to-1 on the first 128 bits and on
-// the full 192 bits.
-// This transformation must be long term stable to ensure
-// GetUniqueIdFromTableProperties is long term stable.
-void InternalUniqueIdToExternal(UniqueIdPtr in_out);
-
-// Reverse of InternalUniqueIdToExternal mostly for testing purposes
-// (demonstrably 1-to-1 on the first 128 bits and on the full 192 bits).
-void ExternalUniqueIdToInternal(UniqueIdPtr in_out);
-
-// Convert numerical format to byte format for public API
-std::string EncodeUniqueIdBytes(UniqueIdPtr in);
-
-// Reverse of EncodeUniqueIdBytes.
-Status DecodeUniqueIdBytes(const std::string &unique_id, UniqueIdPtr out);
-
-// For presenting internal IDs for debugging purposes. Visually distinct from
-// UniqueIdToHumanString for external IDs.
-std::string InternalUniqueIdToHumanString(UniqueIdPtr in);
-
-// Reformat a random value down to our "DB session id" format,
-// which is intended to be compact and friendly for use in file names.
-// `lower` is fully preserved and data is lost from `upper`.
-//
-// Detail: Encoded into 20 chars in base-36 ([0-9A-Z]), which is ~103 bits of
-// entropy, which is enough to expect no collisions across a billion servers
-// each opening DBs a million times (~2^50). Benefits vs. RFC-4122 unique id:
-// * Save ~ dozen bytes per SST file
-// * Shorter shared backup file names (some platforms have low limits)
-// * Visually distinct from DB id format (usually RFC-4122)
-std::string EncodeSessionId(uint64_t upper, uint64_t lower);
-
-// Reverse of EncodeSessionId. Returns NotSupported on error rather than
-// Corruption because non-standard session IDs should be allowed with degraded
-// functionality.
-Status DecodeSessionId(const std::string &db_session_id, uint64_t *upper,
-                       uint64_t *lower);
-
-}  // namespace ROCKSDB_NAMESPACE

package/vendor/librocksdb/vendor/rocksdb/test_util/mock_time_env.cc

@@ -1,38 +0,0 @@
-// Copyright (c) 2011-present, Facebook, Inc.  All rights reserved.
-//  This source code is licensed under both the GPLv2 (found in the
-//  COPYING file in the root directory) and Apache 2.0 License
-//  (found in the LICENSE.Apache file in the root directory).
-
-#include "test_util/mock_time_env.h"
-
-#include "test_util/sync_point.h"
-
-namespace ROCKSDB_NAMESPACE {
-
-// TODO: this is a workaround for the different behavior on different platform
-// for timedwait timeout. Ideally timedwait API should be moved to env.
-// details: PR #7101.
-void MockSystemClock::InstallTimedWaitFixCallback() {
-#ifndef NDEBUG
-  SyncPoint::GetInstance()->DisableProcessing();
-  SyncPoint::GetInstance()->ClearAllCallBacks();
-#ifdef OS_MACOSX
-  // This is an alternate way (vs. SpecialEnv) of dealing with the fact
-  // that on some platforms, pthread_cond_timedwait does not appear to
-  // release the lock for other threads to operate if the deadline time
-  // is already passed. (TimedWait calls are currently a bad abstraction
-  // because the deadline parameter is usually computed from Env time,
-  // but is interpreted in real clock time.)
-  SyncPoint::GetInstance()->SetCallBack(
-      "InstrumentedCondVar::TimedWaitInternal", [&](void* arg) {
-        uint64_t time_us = *static_cast<uint64_t*>(arg);
-        if (time_us < this->RealNowMicros()) {
-          *static_cast<uint64_t*>(arg) = this->RealNowMicros() + 1000;
-        }
-      });
-#endif  // OS_MACOSX
-  SyncPoint::GetInstance()->EnableProcessing();
-#endif  // !NDEBUG
-}
-
-}  // namespace ROCKSDB_NAMESPACE

package/vendor/librocksdb/vendor/rocksdb/test_util/mock_time_env.h

@@ -1,109 +0,0 @@
-// Copyright (c) 2011-present, Facebook, Inc.  All rights reserved.
-//  This source code is licensed under both the GPLv2 (found in the
-//  COPYING file in the root directory) and Apache 2.0 License
-//  (found in the LICENSE.Apache file in the root directory).
-
-#pragma once
-
-#include <atomic>
-#include <limits>
-
-#include "port/port.h"
-#include "rocksdb/system_clock.h"
-#include "test_util/mock_time_env.h"
-#include "test_util/sync_point.h"
-#include "util/random.h"
-
-namespace ROCKSDB_NAMESPACE {
-
-// NOTE: SpecialEnv offers most of this functionality, along with hooks
-// for safe DB behavior under a mock time environment, so should be used
-// instead of MockSystemClock for DB tests.
-class MockSystemClock : public SystemClockWrapper {
- public:
-  explicit MockSystemClock(const std::shared_ptr<SystemClock>& base)
-      : SystemClockWrapper(base) {}
-
-  static const char* kClassName() { return "MockSystemClock"; }
-  const char* Name() const override { return kClassName(); }
-  Status GetCurrentTime(int64_t* time_sec) override {
-    assert(time_sec != nullptr);
-    *time_sec = static_cast<int64_t>(current_time_us_ / kMicrosInSecond);
-    return Status::OK();
-  }
-
-  virtual uint64_t NowSeconds() { return current_time_us_ / kMicrosInSecond; }
-
-  uint64_t NowMicros() override { return current_time_us_; }
-
-  uint64_t NowNanos() override {
-    assert(current_time_us_ <= std::numeric_limits<uint64_t>::max() / 1000);
-    return current_time_us_ * 1000;
-  }
-
-  uint64_t RealNowMicros() { return target_->NowMicros(); }
-
-  void SetCurrentTime(uint64_t time_sec) {
-    assert(time_sec < std::numeric_limits<uint64_t>::max() / kMicrosInSecond);
-    assert(time_sec * kMicrosInSecond >= current_time_us_);
-    current_time_us_ = time_sec * kMicrosInSecond;
-  }
-
-  // It's a fake sleep that just updates the Env current time, which is similar
-  // to `NoSleepEnv.SleepForMicroseconds()` and
-  // `SpecialEnv.MockSleepForMicroseconds()`.
-  // It's also similar to `set_current_time()`, which takes an absolute time in
-  // seconds, vs. this one takes the sleep in microseconds.
-  // Note: Not thread safe.
-  void SleepForMicroseconds(int micros) override {
-    assert(micros >= 0);
-    assert(current_time_us_ + static_cast<uint64_t>(micros) >=
-           current_time_us_);
-    current_time_us_.fetch_add(micros);
-  }
-
-  void MockSleepForSeconds(int seconds) {
-    assert(seconds >= 0);
-    uint64_t micros = static_cast<uint64_t>(seconds) * kMicrosInSecond;
-    assert(current_time_us_ + micros >= current_time_us_);
-    current_time_us_.fetch_add(micros);
-  }
-
-  bool TimedWait(port::CondVar* cv,
-                 std::chrono::microseconds deadline) override {
-    uint64_t now_micros = NowMicros();
-    uint64_t deadline_micros = static_cast<uint64_t>(deadline.count());
-    uint64_t delay_micros;
-    if (deadline_micros > now_micros) {
-      delay_micros = deadline_micros - now_micros;
-    } else {
-      delay_micros = 0;
-    }
-    // To prevent slowdown, this `TimedWait()` is completely synthetic. First,
-    // it yields to coerce other threads to run while the lock is released.
-    // Second, it randomly selects between mocking an immediate wakeup and a
-    // timeout.
-    cv->GetMutex()->Unlock();
-    std::this_thread::yield();
-    bool mock_timeout = Random::GetTLSInstance()->OneIn(2);
-    if (mock_timeout) {
-      TEST_SYNC_POINT("MockSystemClock::TimedWait:UnlockedPreSleep");
-      current_time_us_.fetch_add(delay_micros);
-      TEST_SYNC_POINT("MockSystemClock::TimedWait:UnlockedPostSleep1");
-      TEST_SYNC_POINT("MockSystemClock::TimedWait:UnlockedPostSleep2");
-    }
-    cv->GetMutex()->Lock();
-    return mock_timeout;
-  }
-
-  // TODO: this is a workaround for the different behavior on different platform
-  // for timedwait timeout. Ideally timedwait API should be moved to env.
-  // details: PR #7101.
-  void InstallTimedWaitFixCallback();
-
- private:
-  std::atomic<uint64_t> current_time_us_{0};
-  static constexpr uint64_t kMicrosInSecond = 1000U * 1000U;
-};
-
-}  // namespace ROCKSDB_NAMESPACE

package/vendor/librocksdb/vendor/rocksdb/test_util/secondary_cache_test_util.cc

@@ -1,93 +0,0 @@
-//  Copyright (c) Meta Platforms, Inc. and affiliates.
-//  This source code is licensed under both the GPLv2 (found in the
-//  COPYING file in the root directory) and Apache 2.0 License
-//  (found in the LICENSE.Apache file in the root directory).
-
-#include "test_util/secondary_cache_test_util.h"
-
-#include <array>
-
-namespace ROCKSDB_NAMESPACE::secondary_cache_test_util {
-
-namespace {
-using TestItem = WithCacheType::TestItem;
-
-size_t SizeCallback(Cache::ObjectPtr obj) {
-  return static_cast<TestItem*>(obj)->Size();
-}
-
-Status SaveToCallback(Cache::ObjectPtr from_obj, size_t from_offset,
-                      size_t length, char* out) {
-  auto item = static_cast<TestItem*>(from_obj);
-  const char* buf = item->Buf();
-  EXPECT_EQ(length, item->Size());
-  EXPECT_EQ(from_offset, 0);
-  memcpy(out, buf, length);
-  return Status::OK();
-}
-
-void DeletionCallback(Cache::ObjectPtr obj, MemoryAllocator* /*alloc*/) {
-  delete static_cast<TestItem*>(obj);
-}
-
-Status SaveToCallbackFail(Cache::ObjectPtr /*obj*/, size_t /*offset*/,
-                          size_t /*size*/, char* /*out*/) {
-  return Status::NotSupported();
-}
-
-Status CreateCallback(const Slice& data, CompressionType /*type*/,
-                      CacheTier /*source*/, Cache::CreateContext* context,
-                      MemoryAllocator* /*allocator*/, Cache::ObjectPtr* out_obj,
-                      size_t* out_charge) {
-  auto t = static_cast<TestCreateContext*>(context);
-  if (t->fail_create_) {
-    return Status::NotSupported();
-  }
-  *out_obj = new TestItem(data.data(), data.size());
-  *out_charge = data.size();
-  return Status::OK();
-}
-
-// If helpers without_secondary are provided, returns helpers with secondary
-// support. If not provided, returns helpers without secondary support.
-auto GenerateHelpersByRole(
-    const std::array<Cache::CacheItemHelper, kNumCacheEntryRoles>*
-        without_secondary,
-    bool fail) {
-  std::array<Cache::CacheItemHelper, kNumCacheEntryRoles> a;
-  for (uint32_t i = 0; i < kNumCacheEntryRoles; ++i) {
-    if (without_secondary) {
-      a[i] =
-          Cache::CacheItemHelper{static_cast<CacheEntryRole>(i),
-                                 &DeletionCallback,
-                                 &SizeCallback,
-                                 fail ? &SaveToCallbackFail : &SaveToCallback,
-                                 &CreateCallback,
-                                 &(*without_secondary)[i]};
-    } else {
-      a[i] = Cache::CacheItemHelper{static_cast<CacheEntryRole>(i),
-                                    &DeletionCallback};
-    }
-  }
-  return a;
-}
-}  // namespace
-
-const Cache::CacheItemHelper* WithCacheType::GetHelper(
-    CacheEntryRole r, bool secondary_compatible, bool fail) {
-  static const std::array<Cache::CacheItemHelper, kNumCacheEntryRoles>
-      without_secondary = GenerateHelpersByRole(nullptr, false);
-  static const std::array<Cache::CacheItemHelper, kNumCacheEntryRoles>
-      with_secondary = GenerateHelpersByRole(&without_secondary, false);
-  static const std::array<Cache::CacheItemHelper, kNumCacheEntryRoles>
-      with_secondary_fail = GenerateHelpersByRole(&without_secondary, true);
-  return &(fail                   ? with_secondary_fail
-           : secondary_compatible ? with_secondary
-                                  : without_secondary)[static_cast<int>(r)];
-}
-
-const Cache::CacheItemHelper* WithCacheType::GetHelperFail(CacheEntryRole r) {
-  return GetHelper(r, true, true);
-}
-
-}  // namespace ROCKSDB_NAMESPACE::secondary_cache_test_util

package/vendor/librocksdb/vendor/rocksdb/test_util/secondary_cache_test_util.h

@@ -1,131 +0,0 @@
-//  Copyright (c) Meta Platforms, Inc. and affiliates.
-//  This source code is licensed under both the GPLv2 (found in the
-//  COPYING file in the root directory) and Apache 2.0 License
-//  (found in the LICENSE.Apache file in the root directory).
-
-#pragma once
-
-#include <gtest/gtest.h>
-
-#include <functional>
-
-#include "rocksdb/advanced_cache.h"
-
-namespace ROCKSDB_NAMESPACE {
-namespace secondary_cache_test_util {
-
-struct TestCreateContext : public Cache::CreateContext {
-  void SetFailCreate(bool fail) { fail_create_ = fail; }
-
-  bool fail_create_ = false;
-};
-
-class WithCacheType : public TestCreateContext {
- public:
-  WithCacheType() {}
-  virtual ~WithCacheType() {}
-
-  class TestItem {
-   public:
-    TestItem(const char* buf, size_t size) : buf_(new char[size]), size_(size) {
-      memcpy(buf_.get(), buf, size);
-    }
-    ~TestItem() = default;
-
-    char* Buf() { return buf_.get(); }
-    [[nodiscard]] size_t Size() const { return size_; }
-    std::string ToString() { return std::string(Buf(), Size()); }
-
-   private:
-    std::unique_ptr<char[]> buf_;
-    size_t size_;
-  };
-
-  static constexpr auto kLRU = "lru";
-  static constexpr auto kFixedHyperClock = "fixed_hyper_clock";
-  static constexpr auto kAutoHyperClock = "auto_hyper_clock";
-
-  // For options other than capacity
-  size_t estimated_value_size_ = 1;
-
-  virtual const std::string& Type() const = 0;
-
-  static bool IsHyperClock(const std::string& type) {
-    return type == kFixedHyperClock || type == kAutoHyperClock;
-  }
-
-  bool IsHyperClock() const { return IsHyperClock(Type()); }
-
-  std::shared_ptr<Cache> NewCache(
-      size_t capacity,
-      std::function<void(ShardedCacheOptions&)> modify_opts_fn = {}) {
-    const auto& type = Type();
-    if (type == kLRU) {
-      LRUCacheOptions lru_opts;
-      lru_opts.capacity = capacity;
-      lru_opts.hash_seed = 0;  // deterministic tests
-      if (modify_opts_fn) {
-        modify_opts_fn(lru_opts);
-      }
-      return lru_opts.MakeSharedCache();
-    }
-    if (IsHyperClock(type)) {
-      HyperClockCacheOptions hc_opts{
-          capacity, type == kFixedHyperClock ? estimated_value_size_ : 0};
-      hc_opts.min_avg_entry_charge =
-          std::max(size_t{1}, estimated_value_size_ / 2);
-      hc_opts.hash_seed = 0;  // deterministic tests
-      if (modify_opts_fn) {
-        modify_opts_fn(hc_opts);
-      }
-      return hc_opts.MakeSharedCache();
-    }
-    assert(false);
-    return nullptr;
-  }
-
-  std::shared_ptr<Cache> NewCache(
-      size_t capacity, int num_shard_bits, bool strict_capacity_limit,
-      CacheMetadataChargePolicy charge_policy = kDontChargeCacheMetadata) {
-    return NewCache(capacity, [=](ShardedCacheOptions& opts) {
-      opts.num_shard_bits = num_shard_bits;
-      opts.strict_capacity_limit = strict_capacity_limit;
-      opts.metadata_charge_policy = charge_policy;
-    });
-  }
-
-  std::shared_ptr<Cache> NewCache(
-      size_t capacity, int num_shard_bits, bool strict_capacity_limit,
-      std::shared_ptr<SecondaryCache> secondary_cache) {
-    return NewCache(capacity, [=](ShardedCacheOptions& opts) {
-      opts.num_shard_bits = num_shard_bits;
-      opts.strict_capacity_limit = strict_capacity_limit;
-      opts.metadata_charge_policy = kDontChargeCacheMetadata;
-      opts.secondary_cache = secondary_cache;
-    });
-  }
-
-  static const Cache::CacheItemHelper* GetHelper(
-      CacheEntryRole r = CacheEntryRole::kDataBlock,
-      bool secondary_compatible = true, bool fail = false);
-
-  static const Cache::CacheItemHelper* GetHelperFail(
-      CacheEntryRole r = CacheEntryRole::kDataBlock);
-};
-
-class WithCacheTypeParam : public WithCacheType,
-                           public testing::WithParamInterface<std::string> {
-  const std::string& Type() const override { return GetParam(); }
-};
-
-constexpr auto kLRU = WithCacheType::kLRU;
-constexpr auto kFixedHyperClock = WithCacheType::kFixedHyperClock;
-constexpr auto kAutoHyperClock = WithCacheType::kAutoHyperClock;
-
-inline auto GetTestingCacheTypes() {
-  return testing::Values(std::string(kLRU), std::string(kFixedHyperClock),
-                         std::string(kAutoHyperClock));
-}
-
-}  // namespace secondary_cache_test_util
-}  // namespace ROCKSDB_NAMESPACE