@nxtedition/rocksdb 15.4.0 → 15.5.0

package/deps/rocksdb/rocksdb/utilities/blob_db/blob_db_test.cc

@@ -84,6 +84,7 @@ class BlobDBTest : public testing::Test {
       options.stats_dump_period_sec = 0;
       options.stats_persist_period_sec = 0;
     }
+    bdb_options_ = bdb_options;
     return BlobDB::Open(options, bdb_options, dbname_, &blob_db_);
   }
 
@@ -109,17 +110,16 @@ class BlobDBTest : public testing::Test {
   void Destroy() {
     if (blob_db_) {
       Options options = blob_db_->GetOptions();
-      BlobDBOptions bdb_options = blob_db_->GetBlobDBOptions();
       delete blob_db_;
       blob_db_ = nullptr;
-      ASSERT_OK(DestroyBlobDB(dbname_, options, bdb_options));
+      ASSERT_OK(DestroyBlobDB(dbname_, options, bdb_options_));
     }
   }
 
-  BlobDBImpl *blob_db_impl() { return static_cast<BlobDBImpl *>(blob_db_); }
+  BlobDBImpl* blob_db_impl() { return static_cast<BlobDBImpl*>(blob_db_); }
 
-  Status Put(const Slice &key, const Slice &value,
-             std::map<std::string, std::string> *data = nullptr) {
+  Status Put(const Slice& key, const Slice& value,
+             std::map<std::string, std::string>* data = nullptr) {
     Status s = blob_db_->Put(WriteOptions(), key, value);
     if (data != nullptr) {
       (*data)[key.ToString()] = value.ToString();
@@ -127,16 +127,16 @@ class BlobDBTest : public testing::Test {
     return s;
   }
 
-  void Delete(const std::string &key,
-              std::map<std::string, std::string> *data = nullptr) {
+  void Delete(const std::string& key,
+              std::map<std::string, std::string>* data = nullptr) {
     ASSERT_OK(blob_db_->Delete(WriteOptions(), key));
     if (data != nullptr) {
       data->erase(key);
     }
   }
 
-  Status PutWithTTL(const Slice &key, const Slice &value, uint64_t ttl,
-                    std::map<std::string, std::string> *data = nullptr) {
+  Status PutWithTTL(const Slice& key, const Slice& value, uint64_t ttl,
+                    std::map<std::string, std::string>* data = nullptr) {
     Status s = blob_db_->PutWithTTL(WriteOptions(), key, value, ttl);
     if (data != nullptr) {
       (*data)[key.ToString()] = value.ToString();
@@ -144,12 +144,8 @@ class BlobDBTest : public testing::Test {
     return s;
   }
 
-  Status PutUntil(const Slice &key, const Slice &value, uint64_t expiration) {
-    return blob_db_->PutUntil(WriteOptions(), key, value, expiration);
-  }
-
-  void PutRandomWithTTL(const std::string &key, uint64_t ttl, Random *rnd,
-                        std::map<std::string, std::string> *data = nullptr) {
+  void PutRandomWithTTL(const std::string& key, uint64_t ttl, Random* rnd,
+                        std::map<std::string, std::string>* data = nullptr) {
     int len = rnd->Next() % kMaxBlobSize + 1;
     std::string value = rnd->HumanReadableString(len);
     ASSERT_OK(
@@ -159,24 +155,13 @@ class BlobDBTest : public testing::Test {
     }
   }
 
-  void PutRandomUntil(const std::string &key, uint64_t expiration, Random *rnd,
-                      std::map<std::string, std::string> *data = nullptr) {
-    int len = rnd->Next() % kMaxBlobSize + 1;
-    std::string value = rnd->HumanReadableString(len);
-    ASSERT_OK(blob_db_->PutUntil(WriteOptions(), Slice(key), Slice(value),
-                                 expiration));
-    if (data != nullptr) {
-      (*data)[key] = value;
-    }
-  }
-
-  void PutRandom(const std::string &key, Random *rnd,
-                 std::map<std::string, std::string> *data = nullptr) {
+  void PutRandom(const std::string& key, Random* rnd,
+                 std::map<std::string, std::string>* data = nullptr) {
     PutRandom(blob_db_, key, rnd, data);
   }
 
-  void PutRandom(DB *db, const std::string &key, Random *rnd,
-                 std::map<std::string, std::string> *data = nullptr) {
+  void PutRandom(DB* db, const std::string& key, Random* rnd,
+                 std::map<std::string, std::string>* data = nullptr) {
     int len = rnd->Next() % kMaxBlobSize + 1;
     std::string value = rnd->HumanReadableString(len);
     ASSERT_OK(db->Put(WriteOptions(), Slice(key), Slice(value)));
@@ -186,8 +171,8 @@ class BlobDBTest : public testing::Test {
   }
 
   void PutRandomToWriteBatch(
-      const std::string &key, Random *rnd, WriteBatch *batch,
-      std::map<std::string, std::string> *data = nullptr) {
+      const std::string& key, Random* rnd, WriteBatch* batch,
+      std::map<std::string, std::string>* data = nullptr) {
     int len = rnd->Next() % kMaxBlobSize + 1;
     std::string value = rnd->HumanReadableString(len);
     ASSERT_OK(batch->Put(key, value));
@@ -197,14 +182,14 @@ class BlobDBTest : public testing::Test {
   }
 
   // Verify blob db contain expected data and nothing more.
-  void VerifyDB(const std::map<std::string, std::string> &data) {
+  void VerifyDB(const std::map<std::string, std::string>& data) {
     VerifyDB(blob_db_, data);
   }
 
-  void VerifyDB(DB *db, const std::map<std::string, std::string> &data) {
+  void VerifyDB(DB* db, const std::map<std::string, std::string>& data) {
     // Verify normal Get
-    auto *cfh = db->DefaultColumnFamily();
-    for (auto &p : data) {
+    auto* cfh = db->DefaultColumnFamily();
+    for (auto& p : data) {
       PinnableSlice value_slice;
       ASSERT_OK(db->Get(ReadOptions(), cfh, p.first, &value_slice));
       ASSERT_EQ(p.second, value_slice.ToString());
@@ -214,9 +199,9 @@ class BlobDBTest : public testing::Test {
     }
 
     // Verify iterators
-    Iterator *iter = db->NewIterator(ReadOptions());
+    Iterator* iter = db->NewIterator(ReadOptions());
     iter->SeekToFirst();
-    for (auto &p : data) {
+    for (auto& p : data) {
       ASSERT_TRUE(iter->Valid());
       ASSERT_EQ(p.first, iter->key().ToString());
       ASSERT_EQ(p.second, iter->value().ToString());
@@ -228,16 +213,16 @@ class BlobDBTest : public testing::Test {
   }
 
   void VerifyBaseDB(
-      const std::map<std::string, KeyVersion> &expected_versions) {
-    auto *bdb_impl = static_cast<BlobDBImpl *>(blob_db_);
-    DB *db = blob_db_->GetRootDB();
+      const std::map<std::string, KeyVersion>& expected_versions) {
+    auto* bdb_impl = static_cast<BlobDBImpl*>(blob_db_);
+    DB* db = blob_db_->GetRootDB();
     const size_t kMaxKeys = 10000;
     std::vector<KeyVersion> versions;
     ASSERT_OK(GetAllKeyVersions(db, {}, {}, kMaxKeys, &versions));
     ASSERT_EQ(expected_versions.size(), versions.size());
     size_t i = 0;
-    for (auto &key_version : expected_versions) {
-      const KeyVersion &expected_version = key_version.second;
+    for (auto& key_version : expected_versions) {
+      const KeyVersion& expected_version = key_version.second;
       ASSERT_EQ(expected_version.user_key, versions[i].user_key);
       ASSERT_EQ(expected_version.sequence, versions[i].sequence);
       ASSERT_EQ(expected_version.type, versions[i].type);
@@ -255,7 +240,7 @@ class BlobDBTest : public testing::Test {
   }
 
   void VerifyBaseDBBlobIndex(
-      const std::map<std::string, BlobIndexVersion> &expected_versions) {
+      const std::map<std::string, BlobIndexVersion>& expected_versions) {
     const size_t kMaxKeys = 10000;
     std::vector<KeyVersion> versions;
     ASSERT_OK(
@@ -263,8 +248,8 @@ class BlobDBTest : public testing::Test {
     ASSERT_EQ(versions.size(), expected_versions.size());
 
     size_t i = 0;
-    for (const auto &expected_pair : expected_versions) {
-      const BlobIndexVersion &expected_version = expected_pair.second;
+    for (const auto& expected_pair : expected_versions) {
+      const BlobIndexVersion& expected_version = expected_pair.second;
 
       ASSERT_EQ(versions[i].user_key, expected_version.user_key);
       ASSERT_EQ(versions[i].sequence, expected_version.sequence);
@@ -280,10 +265,7 @@ class BlobDBTest : public testing::Test {
       BlobIndex blob_index;
       ASSERT_OK(blob_index.DecodeFrom(versions[i].value));
 
-      const uint64_t file_number = !blob_index.IsInlined()
-                                       ? blob_index.file_number()
-                                       : kInvalidBlobFileNumber;
-      ASSERT_EQ(file_number, expected_version.file_number);
+      ASSERT_EQ(blob_index.file_number(), expected_version.file_number);
 
       const uint64_t expiration =
           blob_index.HasTTL() ? blob_index.expiration() : kNoExpiration;
@@ -312,13 +294,13 @@ class BlobDBTest : public testing::Test {
   std::shared_ptr<MockSystemClock> mock_clock_;
   std::unique_ptr<Env> mock_env_;
   std::unique_ptr<FaultInjectionTestEnv> fault_injection_env_;
-  BlobDB *blob_db_;
+  BlobDB* blob_db_;
+  BlobDBOptions bdb_options_;
 };  // class BlobDBTest
 
 TEST_F(BlobDBTest, Put) {
   Random rnd(301);
   BlobDBOptions bdb_options;
-  bdb_options.min_blob_size = 0;
   bdb_options.disable_background_tasks = true;
   Open(bdb_options);
   std::map<std::string, std::string> data;
@@ -334,8 +316,6 @@ TEST_F(BlobDBTest, PutWithTTL) {
   options.env = mock_env_.get();
   BlobDBOptions bdb_options;
   bdb_options.ttl_range_secs = 1000;
-  bdb_options.min_blob_size = 0;
-  bdb_options.blob_file_size = 256 * 1000 * 1000;
   bdb_options.disable_background_tasks = true;
   Open(bdb_options, options);
   std::map<std::string, std::string> data;
@@ -346,33 +326,7 @@ TEST_F(BlobDBTest, PutWithTTL) {
                      (ttl <= 50 ? nullptr : &data));
   }
   mock_clock_->SetCurrentTime(100);
-  auto *bdb_impl = static_cast<BlobDBImpl *>(blob_db_);
-  auto blob_files = bdb_impl->TEST_GetBlobFiles();
-  ASSERT_EQ(1, blob_files.size());
-  ASSERT_TRUE(blob_files[0]->HasTTL());
-  ASSERT_OK(bdb_impl->TEST_CloseBlobFile(blob_files[0]));
-  VerifyDB(data);
-}
-
-TEST_F(BlobDBTest, PutUntil) {
-  Random rnd(301);
-  Options options;
-  options.env = mock_env_.get();
-  BlobDBOptions bdb_options;
-  bdb_options.ttl_range_secs = 1000;
-  bdb_options.min_blob_size = 0;
-  bdb_options.blob_file_size = 256 * 1000 * 1000;
-  bdb_options.disable_background_tasks = true;
-  Open(bdb_options, options);
-  std::map<std::string, std::string> data;
-  mock_clock_->SetCurrentTime(50);
-  for (size_t i = 0; i < 100; i++) {
-    uint64_t expiration = rnd.Next() % 100 + 50;
-    PutRandomUntil("key" + std::to_string(i), expiration, &rnd,
-                   (expiration <= 100 ? nullptr : &data));
-  }
-  mock_clock_->SetCurrentTime(100);
-  auto *bdb_impl = static_cast<BlobDBImpl *>(blob_db_);
+  auto* bdb_impl = static_cast<BlobDBImpl*>(blob_db_);
   auto blob_files = bdb_impl->TEST_GetBlobFiles();
   ASSERT_EQ(1, blob_files.size());
   ASSERT_TRUE(blob_files[0]->HasTTL());
@@ -383,7 +337,6 @@ TEST_F(BlobDBTest, PutUntil) {
 TEST_F(BlobDBTest, StackableDBGet) {
   Random rnd(301);
   BlobDBOptions bdb_options;
-  bdb_options.min_blob_size = 0;
   bdb_options.disable_background_tasks = true;
   Open(bdb_options);
   std::map<std::string, std::string> data;
@@ -391,8 +344,8 @@ TEST_F(BlobDBTest, StackableDBGet) {
     PutRandom("key" + std::to_string(i), &rnd, &data);
   }
   for (size_t i = 0; i < 100; i++) {
-    StackableDB *db = blob_db_;
-    ColumnFamilyHandle *column_family = db->DefaultColumnFamily();
+    StackableDB* db = blob_db_;
+    ColumnFamilyHandle* column_family = db->DefaultColumnFamily();
     std::string key = "key" + std::to_string(i);
     PinnableSlice pinnable_value;
     ASSERT_OK(db->Get(ReadOptions(), column_family, key, &pinnable_value));
@@ -426,10 +379,9 @@ TEST_F(BlobDBTest, GetIOError) {
   Options options;
   options.env = fault_injection_env_.get();
   BlobDBOptions bdb_options;
-  bdb_options.min_blob_size = 0;  // Make sure value write to blob file
   bdb_options.disable_background_tasks = true;
   Open(bdb_options, options);
-  ColumnFamilyHandle *column_family = blob_db_->DefaultColumnFamily();
+  ColumnFamilyHandle* column_family = blob_db_->DefaultColumnFamily();
   PinnableSlice value;
   ASSERT_OK(Put("foo", "bar"));
   fault_injection_env_->SetFilesystemActive(false, Status::IOError());
@@ -443,7 +395,6 @@ TEST_F(BlobDBTest, PutIOError) {
   Options options;
   options.env = fault_injection_env_.get();
   BlobDBOptions bdb_options;
-  bdb_options.min_blob_size = 0;  // Make sure value write to blob file
   bdb_options.disable_background_tasks = true;
   Open(bdb_options, options);
   fault_injection_env_->SetFilesystemActive(false, Status::IOError());
@@ -455,7 +406,6 @@ TEST_F(BlobDBTest, PutIOError) {
 TEST_F(BlobDBTest, WriteBatch) {
   Random rnd(301);
   BlobDBOptions bdb_options;
-  bdb_options.min_blob_size = 0;
   bdb_options.disable_background_tasks = true;
   Open(bdb_options);
   std::map<std::string, std::string> data;
@@ -474,7 +424,6 @@ TEST_F(BlobDBTest, WriteBatch) {
 TEST_F(BlobDBTest, Delete) {
   Random rnd(301);
   BlobDBOptions bdb_options;
-  bdb_options.min_blob_size = 0;
   bdb_options.disable_background_tasks = true;
   Open(bdb_options);
   std::map<std::string, std::string> data;
@@ -490,7 +439,6 @@ TEST_F(BlobDBTest, Delete) {
 TEST_F(BlobDBTest, DeleteBatch) {
   Random rnd(301);
   BlobDBOptions bdb_options;
-  bdb_options.min_blob_size = 0;
   bdb_options.disable_background_tasks = true;
   Open(bdb_options);
   for (size_t i = 0; i < 100; i++) {
@@ -508,7 +456,6 @@ TEST_F(BlobDBTest, DeleteBatch) {
 TEST_F(BlobDBTest, Override) {
   Random rnd(301);
   BlobDBOptions bdb_options;
-  bdb_options.min_blob_size = 0;
   bdb_options.disable_background_tasks = true;
   Open(bdb_options);
   std::map<std::string, std::string> data;
@@ -522,208 +469,6 @@ TEST_F(BlobDBTest, Override) {
   VerifyDB(data);
 }
 
-#ifdef SNAPPY
-TEST_F(BlobDBTest, Compression) {
-  Random rnd(301);
-  BlobDBOptions bdb_options;
-  bdb_options.min_blob_size = 0;
-  bdb_options.disable_background_tasks = true;
-  bdb_options.compression = CompressionType::kSnappyCompression;
-  Open(bdb_options);
-  std::map<std::string, std::string> data;
-  for (size_t i = 0; i < 100; i++) {
-    PutRandom("put-key" + std::to_string(i), &rnd, &data);
-  }
-  for (int i = 0; i < 100; i++) {
-    WriteBatch batch;
-    for (size_t j = 0; j < 10; j++) {
-      PutRandomToWriteBatch("write-batch-key" + std::to_string(j * 100 + i),
-                            &rnd, &batch, &data);
-    }
-    ASSERT_OK(blob_db_->Write(WriteOptions(), &batch));
-  }
-  VerifyDB(data);
-}
-
-TEST_F(BlobDBTest, DecompressAfterReopen) {
-  Random rnd(301);
-  BlobDBOptions bdb_options;
-  bdb_options.min_blob_size = 0;
-  bdb_options.disable_background_tasks = true;
-  bdb_options.compression = CompressionType::kSnappyCompression;
-  Open(bdb_options);
-  std::map<std::string, std::string> data;
-  for (size_t i = 0; i < 100; i++) {
-    PutRandom("put-key" + std::to_string(i), &rnd, &data);
-  }
-  VerifyDB(data);
-  bdb_options.compression = CompressionType::kNoCompression;
-  Reopen(bdb_options);
-  VerifyDB(data);
-}
-
-TEST_F(BlobDBTest, EnableDisableCompressionGC) {
-  Random rnd(301);
-  BlobDBOptions bdb_options;
-  bdb_options.min_blob_size = 0;
-  bdb_options.garbage_collection_cutoff = 1.0;
-  bdb_options.disable_background_tasks = true;
-  bdb_options.compression = kSnappyCompression;
-  Open(bdb_options);
-  std::map<std::string, std::string> data;
-  size_t data_idx = 0;
-  for (; data_idx < 100; data_idx++) {
-    PutRandom("put-key" + std::to_string(data_idx), &rnd, &data);
-  }
-  VerifyDB(data);
-  auto blob_files = blob_db_impl()->TEST_GetBlobFiles();
-  ASSERT_EQ(1, blob_files.size());
-  ASSERT_EQ(kSnappyCompression, blob_files[0]->GetCompressionType());
-
-  // disable compression
-  bdb_options.compression = kNoCompression;
-  Reopen(bdb_options);
-
-  // Add more data with new compression type
-  for (; data_idx < 200; data_idx++) {
-    PutRandom("put-key" + std::to_string(data_idx), &rnd, &data);
-  }
-  VerifyDB(data);
-
-  blob_files = blob_db_impl()->TEST_GetBlobFiles();
-  ASSERT_EQ(2, blob_files.size());
-  ASSERT_EQ(kNoCompression, blob_files[1]->GetCompressionType());
-
-  // Enable GC. If we do it earlier the snapshot release triggered compaction
-  // may compact files and trigger GC before we can verify there are two files.
-  bdb_options.enable_garbage_collection = true;
-  Reopen(bdb_options);
-
-  // Trigger compaction
-  ASSERT_OK(blob_db_->CompactRange(CompactRangeOptions(), nullptr, nullptr));
-  blob_db_impl()->TEST_DeleteObsoleteFiles();
-  VerifyDB(data);
-
-  blob_files = blob_db_impl()->TEST_GetBlobFiles();
-  for (const auto &bfile : blob_files) {
-    ASSERT_EQ(kNoCompression, bfile->GetCompressionType());
-  }
-
-  // enabling the compression again
-  bdb_options.compression = kSnappyCompression;
-  Reopen(bdb_options);
-
-  // Add more data with new compression type
-  for (; data_idx < 300; data_idx++) {
-    PutRandom("put-key" + std::to_string(data_idx), &rnd, &data);
-  }
-  VerifyDB(data);
-
-  // Trigger compaction
-  ASSERT_OK(blob_db_->CompactRange(CompactRangeOptions(), nullptr, nullptr));
-  blob_db_impl()->TEST_DeleteObsoleteFiles();
-  VerifyDB(data);
-
-  blob_files = blob_db_impl()->TEST_GetBlobFiles();
-  for (const auto &bfile : blob_files) {
-    ASSERT_EQ(kSnappyCompression, bfile->GetCompressionType());
-  }
-}
-
-#ifdef LZ4
-// Test switch compression types and run GC, it needs both Snappy and LZ4
-// support.
-TEST_F(BlobDBTest, ChangeCompressionGC) {
-  Random rnd(301);
-  BlobDBOptions bdb_options;
-  bdb_options.min_blob_size = 0;
-  bdb_options.garbage_collection_cutoff = 1.0;
-  bdb_options.disable_background_tasks = true;
-  bdb_options.compression = kLZ4Compression;
-  Open(bdb_options);
-  std::map<std::string, std::string> data;
-  size_t data_idx = 0;
-  for (; data_idx < 100; data_idx++) {
-    PutRandom("put-key" + std::to_string(data_idx), &rnd, &data);
-  }
-  VerifyDB(data);
-  auto blob_files = blob_db_impl()->TEST_GetBlobFiles();
-  ASSERT_EQ(1, blob_files.size());
-  ASSERT_EQ(kLZ4Compression, blob_files[0]->GetCompressionType());
-
-  // Change compression type
-  bdb_options.compression = kSnappyCompression;
-  Reopen(bdb_options);
-
-  // Add more data with Snappy compression type
-  for (; data_idx < 200; data_idx++) {
-    PutRandom("put-key" + std::to_string(data_idx), &rnd, &data);
-  }
-  VerifyDB(data);
-
-  // Verify blob file compression type
-  blob_files = blob_db_impl()->TEST_GetBlobFiles();
-  ASSERT_EQ(2, blob_files.size());
-  ASSERT_EQ(kSnappyCompression, blob_files[1]->GetCompressionType());
-
-  // Enable GC. If we do it earlier the snapshot release triggered compaction
-  // may compact files and trigger GC before we can verify there are two files.
-  bdb_options.enable_garbage_collection = true;
-  Reopen(bdb_options);
-
-  ASSERT_OK(blob_db_->CompactRange(CompactRangeOptions(), nullptr, nullptr));
-  VerifyDB(data);
-
-  blob_db_impl()->TEST_DeleteObsoleteFiles();
-  blob_files = blob_db_impl()->TEST_GetBlobFiles();
-  for (const auto &bfile : blob_files) {
-    ASSERT_EQ(kSnappyCompression, bfile->GetCompressionType());
-  }
-
-  // Disable compression
-  bdb_options.compression = kNoCompression;
-  Reopen(bdb_options);
-  for (; data_idx < 300; data_idx++) {
-    PutRandom("put-key" + std::to_string(data_idx), &rnd, &data);
-  }
-  VerifyDB(data);
-
-  ASSERT_OK(blob_db_->CompactRange(CompactRangeOptions(), nullptr, nullptr));
-  VerifyDB(data);
-
-  blob_db_impl()->TEST_DeleteObsoleteFiles();
-  blob_files = blob_db_impl()->TEST_GetBlobFiles();
-  for (const auto &bfile : blob_files) {
-    ASSERT_EQ(kNoCompression, bfile->GetCompressionType());
-  }
-
-  // switching different compression types to generate mixed compression types
-  bdb_options.compression = kSnappyCompression;
-  Reopen(bdb_options);
-  for (; data_idx < 400; data_idx++) {
-    PutRandom("put-key" + std::to_string(data_idx), &rnd, &data);
-  }
-  VerifyDB(data);
-
-  bdb_options.compression = kLZ4Compression;
-  Reopen(bdb_options);
-  for (; data_idx < 500; data_idx++) {
-    PutRandom("put-key" + std::to_string(data_idx), &rnd, &data);
-  }
-  VerifyDB(data);
-
-  ASSERT_OK(blob_db_->CompactRange(CompactRangeOptions(), nullptr, nullptr));
-  VerifyDB(data);
-
-  blob_db_impl()->TEST_DeleteObsoleteFiles();
-  blob_files = blob_db_impl()->TEST_GetBlobFiles();
-  for (const auto &bfile : blob_files) {
-    ASSERT_EQ(kLZ4Compression, bfile->GetCompressionType());
-  }
-}
-#endif  // LZ4
-#endif  // SNAPPY
-
 TEST_F(BlobDBTest, MultipleWriters) {
   Open(BlobDBOptions());
 
@@ -760,21 +505,19 @@ TEST_F(BlobDBTest, SstFileManager) {
   std::shared_ptr<SstFileManager> sst_file_manager(
       NewSstFileManager(mock_env_.get()));
   sst_file_manager->SetDeleteRateBytesPerSecond(1024 * 1024);
-  SstFileManagerImpl *sfm =
-      static_cast<SstFileManagerImpl *>(sst_file_manager.get());
+  SstFileManagerImpl* sfm =
+      static_cast<SstFileManagerImpl*>(sst_file_manager.get());
 
   BlobDBOptions bdb_options;
-  bdb_options.min_blob_size = 0;
   bdb_options.enable_garbage_collection = true;
-  bdb_options.garbage_collection_cutoff = 1.0;
   Options db_options;
 
   int files_scheduled_to_delete = 0;
   ROCKSDB_NAMESPACE::SyncPoint::GetInstance()->SetCallBack(
-      "SstFileManagerImpl::ScheduleFileDeletion", [&](void *arg) {
+      "SstFileManagerImpl::ScheduleFileDeletion", [&](void* arg) {
         assert(arg);
-        const std::string *const file_path =
-            static_cast<const std::string *>(arg);
+        const std::string* const file_path =
+            static_cast<const std::string*>(arg);
         if (file_path->find(".blob") != std::string::npos) {
           ++files_scheduled_to_delete;
         }
@@ -784,12 +527,22 @@ TEST_F(BlobDBTest, SstFileManager) {
 
   Open(bdb_options, db_options);
 
-  // Create one obselete file and clean it.
+  // Create 4 blob files. With GC cutoff of 0.25, the oldest file (file 1)
+  // will be in the GC zone: floor(0.25 * 4) = 1.
   ASSERT_OK(blob_db_->Put(WriteOptions(), "foo", "bar"));
   auto blob_files = blob_db_impl()->TEST_GetBlobFiles();
   ASSERT_EQ(1, blob_files.size());
   std::shared_ptr<BlobFile> bfile = blob_files[0];
   ASSERT_OK(blob_db_impl()->TEST_CloseBlobFile(bfile));
+
+  // Create 3 more blob files (files 2-4, outside GC zone).
+  for (int i = 1; i < 4; i++) {
+    ASSERT_OK(blob_db_->Put(WriteOptions(), "key" + std::to_string(i), "val"));
+    blob_files = blob_db_impl()->TEST_GetBlobFiles();
+    ASSERT_EQ(static_cast<size_t>(i + 1), blob_files.size());
+    ASSERT_OK(blob_db_impl()->TEST_CloseBlobFile(blob_files[i]));
+  }
+
   ASSERT_OK(blob_db_->CompactRange(CompactRangeOptions(), nullptr, nullptr));
   blob_db_impl()->TEST_DeleteObsoleteFiles();
 
@@ -797,7 +550,8 @@ TEST_F(BlobDBTest, SstFileManager) {
   ASSERT_EQ(1, files_scheduled_to_delete);
   Destroy();
   // Make sure that DestroyBlobDB() also goes through delete scheduler.
-  ASSERT_EQ(2, files_scheduled_to_delete);
+  // Remaining files: 3 original (files 2-4) + 1 GC output file = 4 files.
+  ASSERT_EQ(5, files_scheduled_to_delete);
   SyncPoint::GetInstance()->DisableProcessing();
   sfm->WaitForEmptyTrash();
 }
@@ -805,10 +559,10 @@ TEST_F(BlobDBTest, SstFileManager) {
 TEST_F(BlobDBTest, SstFileManagerRestart) {
   int files_scheduled_to_delete = 0;
   ROCKSDB_NAMESPACE::SyncPoint::GetInstance()->SetCallBack(
-      "SstFileManagerImpl::ScheduleFileDeletion", [&](void *arg) {
+      "SstFileManagerImpl::ScheduleFileDeletion", [&](void* arg) {
         assert(arg);
-        const std::string *const file_path =
-            static_cast<const std::string *>(arg);
+        const std::string* const file_path =
+            static_cast<const std::string*>(arg);
         if (file_path->find(".blob") != std::string::npos) {
           ++files_scheduled_to_delete;
         }
@@ -818,11 +572,10 @@ TEST_F(BlobDBTest, SstFileManagerRestart) {
   std::shared_ptr<SstFileManager> sst_file_manager(
       NewSstFileManager(mock_env_.get()));
   sst_file_manager->SetDeleteRateBytesPerSecond(1024 * 1024);
-  SstFileManagerImpl *sfm =
-      static_cast<SstFileManagerImpl *>(sst_file_manager.get());
+  SstFileManagerImpl* sfm =
+      static_cast<SstFileManagerImpl*>(sst_file_manager.get());
 
   BlobDBOptions bdb_options;
-  bdb_options.min_blob_size = 0;
   Options db_options;
 
   SyncPoint::GetInstance()->EnableProcessing();
@@ -834,7 +587,7 @@ TEST_F(BlobDBTest, SstFileManagerRestart) {
   Close();
 
   // Create 3 dummy trash files under the blob_dir
-  const auto &fs = db_options.env->GetFileSystem();
+  const auto& fs = db_options.env->GetFileSystem();
   ASSERT_OK(CreateFile(fs, blob_dir + "/000666.blob.trash", "", false));
   ASSERT_OK(CreateFile(fs, blob_dir + "/000888.blob.trash", "", true));
   ASSERT_OK(CreateFile(fs, blob_dir + "/something_not_match.trash", "", false));
@@ -849,7 +602,7 @@ TEST_F(BlobDBTest, SstFileManagerRestart) {
   std::vector<std::string> all_files;
   ASSERT_OK(db_options.env->GetChildren(blob_dir, &all_files));
   int nfiles = 0;
-  for (const auto &f : all_files) {
+  for (const auto& f : all_files) {
     assert(!f.empty());
     if (f[0] == '.') {
       continue;
@@ -863,22 +616,28 @@ TEST_F(BlobDBTest, SstFileManagerRestart) {
 
 TEST_F(BlobDBTest, SnapshotAndGarbageCollection) {
   BlobDBOptions bdb_options;
-  bdb_options.min_blob_size = 0;
   bdb_options.enable_garbage_collection = true;
-  bdb_options.garbage_collection_cutoff = 1.0;
   bdb_options.disable_background_tasks = true;
 
   Options options;
   options.disable_auto_compactions = true;
 
-  // i = when to take snapshot
+  // This test verifies that snapshots protect blob files from deletion during
+  // garbage collection. With fixed GC cutoff of 0.25 and 8 immutable files,
+  // floor(0.25 * 8) = 2 files are in the GC zone (files 1 and 2).
+  //
+  // We run 4 iterations with different snapshot timing:
+  //   i=0: snapshot after key1 (before key2) - protects file 1
+  //   i=1: snapshot after key2 (before key3) - protects files 1 and 2
+  //   i=2: snapshot after key9 (after all keys) - no protection needed
+  //   i=3: snapshot after Delete(key2) - no protection needed
   for (int i = 0; i < 4; i++) {
     Destroy();
     Open(bdb_options, options);
 
-    const Snapshot *snapshot = nullptr;
+    const Snapshot* snapshot = nullptr;
 
-    // First file
+    // Create first blob file (will be in GC zone).
     ASSERT_OK(Put("key1", "value"));
     if (i == 0) {
       snapshot = blob_db_->GetSnapshot();
@@ -888,7 +647,8 @@ TEST_F(BlobDBTest, SnapshotAndGarbageCollection) {
     ASSERT_EQ(1, blob_files.size());
     ASSERT_OK(blob_db_impl()->TEST_CloseBlobFile(blob_files[0]));
 
-    // Second file
+    // Create second blob file (will be in GC zone). We track this file
+    // to verify it becomes obsolete after GC relocates its blob.
     ASSERT_OK(Put("key2", "value"));
     if (i == 1) {
       snapshot = blob_db_->GetSnapshot();
@@ -896,39 +656,66 @@ TEST_F(BlobDBTest, SnapshotAndGarbageCollection) {
 
     blob_files = blob_db_impl()->TEST_GetBlobFiles();
     ASSERT_EQ(2, blob_files.size());
-    auto bfile = blob_files[1];
-    ASSERT_FALSE(bfile->Immutable());
-    ASSERT_OK(blob_db_impl()->TEST_CloseBlobFile(bfile));
+    auto gc_target_file = blob_files[1];
+    ASSERT_FALSE(gc_target_file->Immutable());
+    ASSERT_OK(blob_db_impl()->TEST_CloseBlobFile(gc_target_file));
+
+    // Create files 3-8, all closed (these are outside GC zone).
+    for (int j = 3; j <= 8; j++) {
+      ASSERT_OK(Put("key" + std::to_string(j), "value"));
+      blob_files = blob_db_impl()->TEST_GetBlobFiles();
+      ASSERT_EQ(static_cast<size_t>(j), blob_files.size());
+      ASSERT_OK(blob_db_impl()->TEST_CloseBlobFile(blob_files[j - 1]));
+    }
 
-    // Third file
-    ASSERT_OK(Put("key3", "value"));
+    // Create file 9 but leave it open (mutable). Only immutable files are
+    // counted for GC cutoff calculation.
+    ASSERT_OK(Put("key9", "value"));
     if (i == 2) {
       snapshot = blob_db_->GetSnapshot();
     }
 
+    // Verify we have 9 total files (8 immutable + 1 mutable).
+    blob_files = blob_db_impl()->TEST_GetBlobFiles();
+    ASSERT_EQ(9, blob_files.size());
+
+    // Trigger GC via compaction. Blobs in files 1 and 2 will be relocated
+    // to a new GC output file.
     ASSERT_OK(blob_db_->CompactRange(CompactRangeOptions(), nullptr, nullptr));
-    ASSERT_TRUE(bfile->Obsolete());
+
+    // Verify gc_target_file (file 2) is now obsolete.
+    ASSERT_TRUE(gc_target_file->Obsolete());
+    // Verify the obsolete sequence matches the latest sequence number.
     ASSERT_EQ(blob_db_->GetLatestSequenceNumber(),
-              bfile->GetObsoleteSequence());
+              gc_target_file->GetObsoleteSequence());
 
     Delete("key2");
     if (i == 3) {
       snapshot = blob_db_->GetSnapshot();
     }
 
-    ASSERT_EQ(4, blob_db_impl()->TEST_GetBlobFiles().size());
+    // Verify we now have 10 files (9 original + 1 GC output file).
+    // Files 1 and 2 are obsolete but not yet deleted.
+    ASSERT_EQ(10, blob_db_impl()->TEST_GetBlobFiles().size());
     blob_db_impl()->TEST_DeleteObsoleteFiles();
 
     if (i >= 2) {
-      // The snapshot shouldn't see data in bfile
-      ASSERT_EQ(2, blob_db_impl()->TEST_GetBlobFiles().size());
+      // Snapshot was taken after all keys were written, so it sees the
+      // post-compaction state where blob indexes point to the GC output file.
+      // Obsolete files 1 and 2 can be deleted immediately.
+      // Verify 8 files remain (10 - 2 obsolete files deleted).
+      ASSERT_EQ(8, blob_db_impl()->TEST_GetBlobFiles().size());
       blob_db_->ReleaseSnapshot(snapshot);
     } else {
-      // The snapshot will see data in bfile, so the file shouldn't be deleted
-      ASSERT_EQ(4, blob_db_impl()->TEST_GetBlobFiles().size());
+      // Snapshot was taken before compaction completed, so it may still
+      // reference blobs in the obsolete files. Files cannot be deleted.
+      // Verify all 10 files still exist.
+      ASSERT_EQ(10, blob_db_impl()->TEST_GetBlobFiles().size());
       blob_db_->ReleaseSnapshot(snapshot);
       blob_db_impl()->TEST_DeleteObsoleteFiles();
-      ASSERT_EQ(2, blob_db_impl()->TEST_GetBlobFiles().size());
+      // After releasing the snapshot, obsolete files can be deleted.
+      // Verify 8 files remain.
+      ASSERT_EQ(8, blob_db_impl()->TEST_GetBlobFiles().size());
     }
   }
 }
@@ -938,8 +725,8 @@ TEST_F(BlobDBTest, ColumnFamilyNotSupported) {
   options.env = mock_env_.get();
   mock_clock_->SetCurrentTime(0);
   Open(BlobDBOptions(), options);
-  ColumnFamilyHandle *default_handle = blob_db_->DefaultColumnFamily();
-  ColumnFamilyHandle *handle = nullptr;
+  ColumnFamilyHandle* default_handle = blob_db_->DefaultColumnFamily();
+  ColumnFamilyHandle* handle = nullptr;
   std::string value;
   std::vector<std::string> values;
   // The call simply pass through to base db. It should succeed.
@@ -948,8 +735,6 @@ TEST_F(BlobDBTest, ColumnFamilyNotSupported) {
   ASSERT_TRUE(blob_db_->Put(WriteOptions(), handle, "k", "v").IsNotSupported());
   ASSERT_TRUE(blob_db_->PutWithTTL(WriteOptions(), handle, "k", "v", 60)
                   .IsNotSupported());
-  ASSERT_TRUE(blob_db_->PutUntil(WriteOptions(), handle, "k", "v", 100)
-                  .IsNotSupported());
   WriteBatch batch;
   ASSERT_OK(batch.Put("k1", "v1"));
   ASSERT_OK(batch.Put(handle, "k2", "v2"));
@@ -970,10 +755,7 @@ TEST_F(BlobDBTest, GetLiveFilesMetaData) {
   Random rnd(301);
 
   BlobDBOptions bdb_options;
-  bdb_options.blob_dir = "blob_dir";
-  bdb_options.path_relative = true;
   bdb_options.ttl_range_secs = 10;
-  bdb_options.min_blob_size = 0;
   bdb_options.disable_background_tasks = true;
 
   Options options;
@@ -986,8 +768,9 @@ TEST_F(BlobDBTest, GetLiveFilesMetaData) {
     PutRandom("key" + std::to_string(i), &rnd, &data);
   }
 
-  constexpr uint64_t expiration = 1000ULL;
-  PutRandomUntil("key100", expiration, &rnd, &data);
+  // At time 0, the stored expiration equals TTL
+  constexpr uint64_t ttl = 1000ULL;
+  PutRandomWithTTL("key100", ttl, &rnd, &data);
 
   std::vector<LiveFileMetaData> metadata;
   blob_db_->GetLiveFilesMetaData(&metadata);
@@ -1003,7 +786,7 @@ TEST_F(BlobDBTest, GetLiveFilesMetaData) {
   const std::string filename2("/blob_dir/000002.blob");
   ASSERT_EQ(filename2, metadata[1].name);
   ASSERT_EQ(2, metadata[1].file_number);
-  ASSERT_EQ(expiration, metadata[1].oldest_ancester_time);
+  ASSERT_EQ(ttl, metadata[1].oldest_ancester_time);
   ASSERT_EQ(kDefaultColumnFamilyName, metadata[1].column_family_name);
 
   std::vector<std::string> livefile;
@@ -1046,16 +829,15 @@ TEST_F(BlobDBTest, MigrateFromPlainRocksDB) {
   // Write to plain rocksdb.
   Options options;
   options.create_if_missing = true;
-  DB *db = nullptr;
+  std::unique_ptr<DB> db;
   ASSERT_OK(DB::Open(options, dbname_, &db));
   for (size_t i = 0; i < kNumIteration; i++) {
     auto key_index = rnd.Next() % kNumKey;
     std::string key = "key" + std::to_string(key_index);
-    PutRandom(db, key, &rnd, &data);
+    PutRandom(db.get(), key, &rnd, &data);
   }
-  VerifyDB(db, data);
-  delete db;
-  db = nullptr;
+  VerifyDB(db.get(), data);
+  db.reset();
 
   // Open as blob db. Verify it can read existing data.
   Open();
@@ -1085,7 +867,6 @@ TEST_F(BlobDBTest, MigrateFromPlainRocksDB) {
       ASSERT_EQ(data[key], value);
     }
   }
-  delete db;
 }
 
 // Test to verify that a NoSpace IOError Status is returned on reaching
@@ -1096,7 +877,6 @@ TEST_F(BlobDBTest, OutOfSpace) {
   options.env = mock_env_.get();
   BlobDBOptions bdb_options;
   bdb_options.max_db_size = 200;
-  bdb_options.is_fifo = false;
   bdb_options.disable_background_tasks = true;
   Open(bdb_options);
 
@@ -1112,256 +892,13 @@ TEST_F(BlobDBTest, OutOfSpace) {
   ASSERT_TRUE(s.IsNoSpace());
 }
 
-TEST_F(BlobDBTest, FIFOEviction) {
-  BlobDBOptions bdb_options;
-  bdb_options.max_db_size = 200;
-  bdb_options.blob_file_size = 100;
-  bdb_options.is_fifo = true;
-  bdb_options.disable_background_tasks = true;
-  Open(bdb_options);
-
-  std::atomic<int> evict_count{0};
-  SyncPoint::GetInstance()->SetCallBack(
-      "BlobDBImpl::EvictOldestBlobFile:Evicted",
-      [&](void *) { evict_count++; });
-  SyncPoint::GetInstance()->EnableProcessing();
-
-  // Each stored blob has an overhead of 32 bytes currently.
-  // So a 100 byte blob should take up 132 bytes.
-  std::string value(100, 'v');
-  ASSERT_OK(blob_db_->PutWithTTL(WriteOptions(), "key1", value, 10));
-  VerifyDB({{"key1", value}});
-
-  ASSERT_EQ(1, blob_db_impl()->TEST_GetBlobFiles().size());
-
-  // Adding another 100 bytes blob would take the total size to 264 bytes
-  // (2*132). max_db_size will be exceeded
-  // than max_db_size and trigger FIFO eviction.
-  ASSERT_OK(blob_db_->PutWithTTL(WriteOptions(), "key2", value, 60));
-  ASSERT_EQ(1, evict_count);
-  // key1 will exist until corresponding file be deleted.
-  VerifyDB({{"key1", value}, {"key2", value}});
-
-  // Adding another 100 bytes blob without TTL.
-  ASSERT_OK(blob_db_->Put(WriteOptions(), "key3", value));
-  ASSERT_EQ(2, evict_count);
-  // key1 and key2 will exist until corresponding file be deleted.
-  VerifyDB({{"key1", value}, {"key2", value}, {"key3", value}});
-
-  // The fourth blob file, without TTL.
-  ASSERT_OK(blob_db_->Put(WriteOptions(), "key4", value));
-  ASSERT_EQ(3, evict_count);
-  VerifyDB(
-      {{"key1", value}, {"key2", value}, {"key3", value}, {"key4", value}});
-
-  auto blob_files = blob_db_impl()->TEST_GetBlobFiles();
-  ASSERT_EQ(4, blob_files.size());
-  ASSERT_TRUE(blob_files[0]->Obsolete());
-  ASSERT_TRUE(blob_files[1]->Obsolete());
-  ASSERT_TRUE(blob_files[2]->Obsolete());
-  ASSERT_FALSE(blob_files[3]->Obsolete());
-  auto obsolete_files = blob_db_impl()->TEST_GetObsoleteFiles();
-  ASSERT_EQ(3, obsolete_files.size());
-  ASSERT_EQ(blob_files[0], obsolete_files[0]);
-  ASSERT_EQ(blob_files[1], obsolete_files[1]);
-  ASSERT_EQ(blob_files[2], obsolete_files[2]);
-
-  blob_db_impl()->TEST_DeleteObsoleteFiles();
-  obsolete_files = blob_db_impl()->TEST_GetObsoleteFiles();
-  ASSERT_TRUE(obsolete_files.empty());
-  VerifyDB({{"key4", value}});
-}
-
-TEST_F(BlobDBTest, FIFOEviction_NoOldestFileToEvict) {
-  Options options;
-  BlobDBOptions bdb_options;
-  bdb_options.max_db_size = 1000;
-  bdb_options.blob_file_size = 5000;
-  bdb_options.is_fifo = true;
-  bdb_options.disable_background_tasks = true;
-  Open(bdb_options);
-
-  std::atomic<int> evict_count{0};
-  SyncPoint::GetInstance()->SetCallBack(
-      "BlobDBImpl::EvictOldestBlobFile:Evicted",
-      [&](void *) { evict_count++; });
-  SyncPoint::GetInstance()->EnableProcessing();
-
-  std::string value(2000, 'v');
-  ASSERT_TRUE(Put("foo", std::string(2000, 'v')).IsNoSpace());
-  ASSERT_EQ(0, evict_count);
-}
-
-TEST_F(BlobDBTest, FIFOEviction_NoEnoughBlobFilesToEvict) {
-  BlobDBOptions bdb_options;
-  bdb_options.is_fifo = true;
-  bdb_options.min_blob_size = 100;
-  bdb_options.disable_background_tasks = true;
-  Options options;
-  // Use mock env to stop wall clock.
-  options.env = mock_env_.get();
-  options.disable_auto_compactions = true;
-  auto statistics = CreateDBStatistics();
-  options.statistics = statistics;
-  Open(bdb_options, options);
-
-  SyncPoint::GetInstance()->LoadDependency(
-      {{"DBImpl::NotifyOnFlushCompleted::PostAllOnFlushCompleted",
-        "BlobDBTest.FIFOEviction_NoEnoughBlobFilesToEvict:AfterFlush"}});
-
-  SyncPoint::GetInstance()->EnableProcessing();
-
-  ASSERT_EQ(0, blob_db_impl()->TEST_live_sst_size());
-  std::string small_value(50, 'v');
-  std::map<std::string, std::string> data;
-  // Insert some data into LSM tree to make sure FIFO eviction take SST
-  // file size into account.
-  for (int i = 0; i < 1000; i++) {
-    ASSERT_OK(Put("key" + std::to_string(i), small_value, &data));
-  }
-  ASSERT_OK(blob_db_->Flush(FlushOptions()));
-
-  uint64_t live_sst_size = 0;
-  ASSERT_TRUE(blob_db_->GetIntProperty(DB::Properties::kTotalSstFilesSize,
-                                       &live_sst_size));
-  ASSERT_TRUE(live_sst_size > 0);
-
-  TEST_SYNC_POINT(
-      "BlobDBTest.FIFOEviction_NoEnoughBlobFilesToEvict:AfterFlush");
-
-  ASSERT_EQ(live_sst_size, blob_db_impl()->TEST_live_sst_size());
-
-  bdb_options.max_db_size = live_sst_size + 2000;
-  Reopen(bdb_options, options);
-  ASSERT_EQ(live_sst_size, blob_db_impl()->TEST_live_sst_size());
-
-  std::string value_1k(1000, 'v');
-  ASSERT_OK(PutWithTTL("large_key1", value_1k, 60, &data));
-  ASSERT_EQ(0, statistics->getTickerCount(BLOB_DB_FIFO_NUM_FILES_EVICTED));
-  VerifyDB(data);
-  // large_key2 evicts large_key1
-  ASSERT_OK(PutWithTTL("large_key2", value_1k, 60, &data));
-  ASSERT_EQ(1, statistics->getTickerCount(BLOB_DB_FIFO_NUM_FILES_EVICTED));
-  blob_db_impl()->TEST_DeleteObsoleteFiles();
-  data.erase("large_key1");
-  VerifyDB(data);
-  // large_key3 get no enough space even after evicting large_key2, so it
-  // instead return no space error.
-  std::string value_2k(2000, 'v');
-  ASSERT_TRUE(PutWithTTL("large_key3", value_2k, 60).IsNoSpace());
-  ASSERT_EQ(1, statistics->getTickerCount(BLOB_DB_FIFO_NUM_FILES_EVICTED));
-  // Verify large_key2 still exists.
-  VerifyDB(data);
-
-  SyncPoint::GetInstance()->DisableProcessing();
-}
-
-// Test flush or compaction will trigger FIFO eviction since they update
-// total SST file size.
-TEST_F(BlobDBTest, FIFOEviction_TriggerOnSSTSizeChange) {
-  BlobDBOptions bdb_options;
-  bdb_options.max_db_size = 1000;
-  bdb_options.is_fifo = true;
-  bdb_options.min_blob_size = 100;
-  bdb_options.disable_background_tasks = true;
-  Options options;
-  // Use mock env to stop wall clock.
-  options.env = mock_env_.get();
-  auto statistics = CreateDBStatistics();
-  options.statistics = statistics;
-  options.compression = kNoCompression;
-  Open(bdb_options, options);
-
-  SyncPoint::GetInstance()->LoadDependency(
-      {{"DBImpl::NotifyOnFlushCompleted::PostAllOnFlushCompleted",
-        "BlobDBTest.FIFOEviction_TriggerOnSSTSizeChange:AfterFlush"}});
-
-  SyncPoint::GetInstance()->EnableProcessing();
-
-  std::string value(800, 'v');
-  ASSERT_OK(PutWithTTL("large_key", value, 60));
-  ASSERT_EQ(1, blob_db_impl()->TEST_GetBlobFiles().size());
-  ASSERT_EQ(0, statistics->getTickerCount(BLOB_DB_FIFO_NUM_FILES_EVICTED));
-  VerifyDB({{"large_key", value}});
-
-  // Insert some small keys and flush to bring DB out of space.
-  std::map<std::string, std::string> data;
-  for (int i = 0; i < 10; i++) {
-    ASSERT_OK(Put("key" + std::to_string(i), "v", &data));
-  }
-  ASSERT_OK(blob_db_->Flush(FlushOptions()));
-
-  TEST_SYNC_POINT("BlobDBTest.FIFOEviction_TriggerOnSSTSizeChange:AfterFlush");
-
-  // Verify large_key is deleted by FIFO eviction.
-  blob_db_impl()->TEST_DeleteObsoleteFiles();
-  ASSERT_EQ(0, blob_db_impl()->TEST_GetBlobFiles().size());
-  ASSERT_EQ(1, statistics->getTickerCount(BLOB_DB_FIFO_NUM_FILES_EVICTED));
-  VerifyDB(data);
-
-  SyncPoint::GetInstance()->DisableProcessing();
-}
-
-TEST_F(BlobDBTest, InlineSmallValues) {
-  constexpr uint64_t kMaxExpiration = 1000;
-  Random rnd(301);
-  BlobDBOptions bdb_options;
-  bdb_options.ttl_range_secs = kMaxExpiration;
-  bdb_options.min_blob_size = 100;
-  bdb_options.blob_file_size = 256 * 1000 * 1000;
-  bdb_options.disable_background_tasks = true;
-  Options options;
-  options.env = mock_env_.get();
-  mock_clock_->SetCurrentTime(0);
-  Open(bdb_options, options);
-  std::map<std::string, std::string> data;
-  std::map<std::string, KeyVersion> versions;
-  for (size_t i = 0; i < 1000; i++) {
-    bool is_small_value = rnd.Next() % 2;
-    bool has_ttl = rnd.Next() % 2;
-    uint64_t expiration = rnd.Next() % kMaxExpiration;
-    int len = is_small_value ? 50 : 200;
-    std::string key = "key" + std::to_string(i);
-    std::string value = rnd.HumanReadableString(len);
-    std::string blob_index;
-    data[key] = value;
-    SequenceNumber sequence = blob_db_->GetLatestSequenceNumber() + 1;
-    if (!has_ttl) {
-      ASSERT_OK(blob_db_->Put(WriteOptions(), key, value));
-    } else {
-      ASSERT_OK(blob_db_->PutUntil(WriteOptions(), key, value, expiration));
-    }
-    ASSERT_EQ(blob_db_->GetLatestSequenceNumber(), sequence);
-    versions[key] =
-        KeyVersion(key, value, sequence,
-                   (is_small_value && !has_ttl) ? kTypeValue : kTypeBlobIndex);
-  }
-  VerifyDB(data);
-  VerifyBaseDB(versions);
-  auto *bdb_impl = static_cast<BlobDBImpl *>(blob_db_);
-  auto blob_files = bdb_impl->TEST_GetBlobFiles();
-  ASSERT_EQ(2, blob_files.size());
-  std::shared_ptr<BlobFile> non_ttl_file;
-  std::shared_ptr<BlobFile> ttl_file;
-  if (blob_files[0]->HasTTL()) {
-    ttl_file = blob_files[0];
-    non_ttl_file = blob_files[1];
-  } else {
-    non_ttl_file = blob_files[0];
-    ttl_file = blob_files[1];
-  }
-  ASSERT_FALSE(non_ttl_file->HasTTL());
-  ASSERT_TRUE(ttl_file->HasTTL());
-}
-
 TEST_F(BlobDBTest, UserCompactionFilter) {
   class CustomerFilter : public CompactionFilter {
    public:
-    bool Filter(int /*level*/, const Slice & /*key*/, const Slice &value,
-                std::string *new_value, bool *value_changed) const override {
+    bool Filter(int /*level*/, const Slice& /*key*/, const Slice& value,
+                std::string* new_value, bool* value_changed) const override {
       *value_changed = false;
-      // changing value size to test value transitions between inlined data
-      // and stored-in-blob data
+      // Test compaction filter modifying blob values
       if (value.size() % 4 == 1) {
         *new_value = value.ToString();
         // double size by duplicating value
@@ -1380,31 +917,23 @@ TEST_F(BlobDBTest, UserCompactionFilter) {
       return false;
     }
     bool IgnoreSnapshots() const override { return true; }
-    const char *Name() const override { return "CustomerFilter"; }
+    const char* Name() const override { return "CustomerFilter"; }
   };
   class CustomerFilterFactory : public CompactionFilterFactory {
-    const char *Name() const override { return "CustomerFilterFactory"; }
+    const char* Name() const override { return "CustomerFilterFactory"; }
     std::unique_ptr<CompactionFilter> CreateCompactionFilter(
-        const CompactionFilter::Context & /*context*/) override {
+        const CompactionFilter::Context& /*context*/) override {
       return std::unique_ptr<CompactionFilter>(new CustomerFilter());
     }
   };
 
   constexpr size_t kNumPuts = 1 << 10;
-  // Generate both inlined and blob value
   constexpr uint64_t kMinValueSize = 1 << 6;
   constexpr uint64_t kMaxValueSize = 1 << 8;
-  constexpr uint64_t kMinBlobSize = 1 << 7;
-  static_assert(kMinValueSize < kMinBlobSize);
-  static_assert(kMaxValueSize > kMinBlobSize);
 
   BlobDBOptions bdb_options;
-  bdb_options.min_blob_size = kMinBlobSize;
   bdb_options.blob_file_size = kMaxValueSize * 10;
   bdb_options.disable_background_tasks = true;
-  if (Snappy_Supported()) {
-    bdb_options.compression = CompressionType::kSnappyCompression;
-  }
   // case_num == 0: Test user defined compaction filter
   // case_num == 1: Test user defined compaction filter factory
   for (int case_num = 0; case_num < 2; case_num++) {
@@ -1467,24 +996,22 @@ TEST_F(BlobDBTest, UserCompactionFilter) {
 TEST_F(BlobDBTest, UserCompactionFilter_BlobIOError) {
   class CustomerFilter : public CompactionFilter {
    public:
-    bool Filter(int /*level*/, const Slice & /*key*/, const Slice &value,
-                std::string *new_value, bool *value_changed) const override {
+    bool Filter(int /*level*/, const Slice& /*key*/, const Slice& value,
+                std::string* new_value, bool* value_changed) const override {
       *new_value = value.ToString() + "_new";
       *value_changed = true;
       return false;
     }
     bool IgnoreSnapshots() const override { return true; }
-    const char *Name() const override { return "CustomerFilter"; }
+    const char* Name() const override { return "CustomerFilter"; }
   };
 
   constexpr size_t kNumPuts = 100;
   constexpr int kValueSize = 100;
 
   BlobDBOptions bdb_options;
-  bdb_options.min_blob_size = 0;
   bdb_options.blob_file_size = kValueSize * 10;
   bdb_options.disable_background_tasks = true;
-  bdb_options.compression = CompressionType::kNoCompression;
 
   std::vector<std::string> io_failure_cases = {
       "BlobDBImpl::CreateBlobFileAndWriter",
@@ -1518,7 +1045,7 @@ TEST_F(BlobDBTest, UserCompactionFilter_BlobIOError) {
     VerifyDB(data);
 
     SyncPoint::GetInstance()->SetCallBack(
-        io_failure_cases[case_num], [&](void * /*arg*/) {
+        io_failure_cases[case_num], [&](void* /*arg*/) {
           fault_injection_env_->SetFilesystemActive(false, Status::IOError());
         });
     SyncPoint::GetInstance()->EnableProcessing();
@@ -1542,13 +1069,11 @@ TEST_F(BlobDBTest, UserCompactionFilter_BlobIOError) {
 TEST_F(BlobDBTest, FilterExpiredBlobIndex) {
   constexpr size_t kNumKeys = 100;
   constexpr size_t kNumPuts = 1000;
-  constexpr uint64_t kMaxExpiration = 1000;
+  constexpr uint64_t kMaxTTL = 1000;
   constexpr uint64_t kCompactTime = 500;
-  constexpr uint64_t kMinBlobSize = 100;
   Random rnd(301);
   mock_clock_->SetCurrentTime(0);
   BlobDBOptions bdb_options;
-  bdb_options.min_blob_size = kMinBlobSize;
   bdb_options.disable_background_tasks = true;
   Options options;
   options.env = mock_env_.get();
@@ -1557,25 +1082,18 @@ TEST_F(BlobDBTest, FilterExpiredBlobIndex) {
   std::map<std::string, std::string> data;
   std::map<std::string, std::string> data_after_compact;
   for (size_t i = 0; i < kNumPuts; i++) {
-    bool is_small_value = rnd.Next() % 2;
     bool has_ttl = rnd.Next() % 2;
-    uint64_t expiration = rnd.Next() % kMaxExpiration;
-    int len = is_small_value ? 10 : 200;
+    // At time 0, stored expiration equals TTL
+    uint64_t ttl = rnd.Next() % kMaxTTL;
+    int len = rnd.Next() % 200 + 10;
     std::string key = "key" + std::to_string(rnd.Next() % kNumKeys);
     std::string value = rnd.HumanReadableString(len);
     if (!has_ttl) {
-      if (is_small_value) {
-        std::string blob_entry;
-        BlobIndex::EncodeInlinedTTL(&blob_entry, expiration, value);
-        // Fake blob index with TTL. See what it will do.
-        ASSERT_GT(kMinBlobSize, blob_entry.size());
-        value = blob_entry;
-      }
       ASSERT_OK(Put(key, value));
       data_after_compact[key] = value;
     } else {
-      ASSERT_OK(PutUntil(key, value, expiration));
-      if (expiration <= kCompactTime) {
+      ASSERT_OK(blob_db_->PutWithTTL(WriteOptions(), key, value, ttl));
+      if (ttl <= kCompactTime) {
         data_after_compact.erase(key);
       } else {
         data_after_compact[key] = value;
@@ -1588,7 +1106,7 @@ TEST_F(BlobDBTest, FilterExpiredBlobIndex) {
   mock_clock_->SetCurrentTime(kCompactTime);
   // Take a snapshot before compaction. Make sure expired blob indexes is
   // filtered regardless of snapshot.
-  const Snapshot *snapshot = blob_db_->GetSnapshot();
+  const Snapshot* snapshot = blob_db_->GetSnapshot();
   // Issue manual compaction to trigger compaction filter.
   ASSERT_OK(blob_db_->CompactRange(CompactRangeOptions(), nullptr, nullptr));
   blob_db_->ReleaseSnapshot(snapshot);
@@ -1597,7 +1115,7 @@ TEST_F(BlobDBTest, FilterExpiredBlobIndex) {
   const size_t kMaxKeys = 10000;
   ASSERT_OK(GetAllKeyVersions(blob_db_, {}, {}, kMaxKeys, &versions));
   ASSERT_EQ(data_after_compact.size(), versions.size());
-  for (auto &version : versions) {
+  for (auto& version : versions) {
     ASSERT_TRUE(data_after_compact.count(version.user_key) > 0);
   }
   VerifyDB(data_after_compact);
@@ -1607,7 +1125,6 @@ TEST_F(BlobDBTest, FilterExpiredBlobIndex) {
 // blob file has been removed.
 TEST_F(BlobDBTest, FilterFileNotAvailable) {
   BlobDBOptions bdb_options;
-  bdb_options.min_blob_size = 0;
   bdb_options.disable_background_tasks = true;
   Options options;
   options.disable_auto_compactions = true;
@@ -1627,7 +1144,7 @@ TEST_F(BlobDBTest, FilterFileNotAvailable) {
 
   const size_t kMaxKeys = 10000;
 
-  DB *base_db = blob_db_->GetRootDB();
+  DB* base_db = blob_db_->GetRootDB();
   std::vector<KeyVersion> versions;
   ASSERT_OK(GetAllKeyVersions(base_db, {}, {}, kMaxKeys, &versions));
   ASSERT_EQ(2, versions.size());
@@ -1660,127 +1177,25 @@ TEST_F(BlobDBTest, FilterFileNotAvailable) {
   VerifyDB({});
 }
 
-// Test compaction filter should filter any inlined TTL keys that would have
-// been dropped by last FIFO eviction if they are store out-of-line.
-TEST_F(BlobDBTest, FilterForFIFOEviction) {
-  Random rnd(215);
-  BlobDBOptions bdb_options;
-  bdb_options.min_blob_size = 100;
-  bdb_options.ttl_range_secs = 60;
-  bdb_options.max_db_size = 0;
-  bdb_options.disable_background_tasks = true;
-  Options options;
-  // Use mock env to stop wall clock.
-  mock_clock_->SetCurrentTime(0);
-  options.env = mock_env_.get();
-  auto statistics = CreateDBStatistics();
-  options.statistics = statistics;
-  options.disable_auto_compactions = true;
-  Open(bdb_options, options);
-
-  SyncPoint::GetInstance()->LoadDependency(
-      {{"DBImpl::NotifyOnFlushCompleted::PostAllOnFlushCompleted",
-        "BlobDBTest.FilterForFIFOEviction:AfterFlush"}});
-
-  SyncPoint::GetInstance()->EnableProcessing();
-
-  std::map<std::string, std::string> data;
-  std::map<std::string, std::string> data_after_compact;
-  // Insert some small values that will be inlined.
-  for (int i = 0; i < 1000; i++) {
-    std::string key = "key" + std::to_string(i);
-    std::string value = rnd.HumanReadableString(50);
-    uint64_t ttl = rnd.Next() % 120 + 1;
-    ASSERT_OK(PutWithTTL(key, value, ttl, &data));
-    if (ttl >= 60) {
-      data_after_compact[key] = value;
-    }
-  }
-  uint64_t num_keys_to_evict = data.size() - data_after_compact.size();
-  ASSERT_OK(blob_db_->Flush(FlushOptions()));
-
-  TEST_SYNC_POINT("BlobDBTest.FilterForFIFOEviction:AfterFlush");
-
-  uint64_t live_sst_size = blob_db_impl()->TEST_live_sst_size();
-  ASSERT_GT(live_sst_size, 0);
-  VerifyDB(data);
-
-  bdb_options.max_db_size = live_sst_size + 30000;
-  bdb_options.is_fifo = true;
-  Reopen(bdb_options, options);
-  VerifyDB(data);
-
-  // Put two large values, each on a different blob file.
-  std::string large_value(10000, 'v');
-  ASSERT_OK(PutWithTTL("large_key1", large_value, 90));
-  ASSERT_OK(PutWithTTL("large_key2", large_value, 150));
-  ASSERT_EQ(2, blob_db_impl()->TEST_GetBlobFiles().size());
-  ASSERT_EQ(0, statistics->getTickerCount(BLOB_DB_FIFO_NUM_FILES_EVICTED));
-  data["large_key1"] = large_value;
-  data["large_key2"] = large_value;
-  VerifyDB(data);
-
-  // Put a third large value which will bring the DB out of space.
-  // FIFO eviction will evict the file of large_key1.
-  ASSERT_OK(PutWithTTL("large_key3", large_value, 150));
-  ASSERT_EQ(1, statistics->getTickerCount(BLOB_DB_FIFO_NUM_FILES_EVICTED));
-  ASSERT_EQ(2, blob_db_impl()->TEST_GetBlobFiles().size());
-  blob_db_impl()->TEST_DeleteObsoleteFiles();
-  ASSERT_EQ(1, blob_db_impl()->TEST_GetBlobFiles().size());
-  data.erase("large_key1");
-  data["large_key3"] = large_value;
-  VerifyDB(data);
-
-  // Putting some more small values. These values shouldn't be evicted by
-  // compaction filter since they are inserted after FIFO eviction.
-  ASSERT_OK(PutWithTTL("foo", "v", 30, &data_after_compact));
-  ASSERT_OK(PutWithTTL("bar", "v", 30, &data_after_compact));
-
-  // FIFO eviction doesn't trigger again since there enough room for the flush.
-  ASSERT_OK(blob_db_->Flush(FlushOptions()));
-  ASSERT_EQ(1, statistics->getTickerCount(BLOB_DB_FIFO_NUM_FILES_EVICTED));
-
-  // Manual compact and check if compaction filter evict those keys with
-  // expiration < 60.
-  ASSERT_OK(blob_db_->CompactRange(CompactRangeOptions(), nullptr, nullptr));
-  // All keys with expiration < 60, plus large_key1 is filtered by
-  // compaction filter.
-  ASSERT_EQ(num_keys_to_evict + 1,
-            statistics->getTickerCount(BLOB_DB_BLOB_INDEX_EVICTED_COUNT));
-  ASSERT_EQ(1, statistics->getTickerCount(BLOB_DB_FIFO_NUM_FILES_EVICTED));
-  ASSERT_EQ(1, blob_db_impl()->TEST_GetBlobFiles().size());
-  data_after_compact["large_key2"] = large_value;
-  data_after_compact["large_key3"] = large_value;
-  VerifyDB(data_after_compact);
-
-  SyncPoint::GetInstance()->DisableProcessing();
-}
-
 TEST_F(BlobDBTest, GarbageCollection) {
   constexpr size_t kNumPuts = 1 << 10;
 
-  constexpr uint64_t kExpiration = 1000;
+  // At time 0, stored expiration equals TTL
+  constexpr uint64_t kTTL = 1000;
   constexpr uint64_t kCompactTime = 500;
 
   constexpr uint64_t kKeySize = 7;  // "key" + 4 digits
-
-  constexpr uint64_t kSmallValueSize = 1 << 6;
-  constexpr uint64_t kLargeValueSize = 1 << 8;
-  constexpr uint64_t kMinBlobSize = 1 << 7;
-  static_assert(kSmallValueSize < kMinBlobSize);
-  static_assert(kLargeValueSize > kMinBlobSize);
+  constexpr uint64_t kValueSize = 1 << 8;
 
   constexpr size_t kBlobsPerFile = 8;
   constexpr size_t kNumBlobFiles = kNumPuts / kBlobsPerFile;
   constexpr uint64_t kBlobFileSize =
       BlobLogHeader::kSize +
-      (BlobLogRecord::kHeaderSize + kKeySize + kLargeValueSize) * kBlobsPerFile;
+      (BlobLogRecord::kHeaderSize + kKeySize + kValueSize) * kBlobsPerFile;
 
   BlobDBOptions bdb_options;
-  bdb_options.min_blob_size = kMinBlobSize;
   bdb_options.blob_file_size = kBlobFileSize;
   bdb_options.enable_garbage_collection = true;
-  bdb_options.garbage_collection_cutoff = 0.25;
   bdb_options.disable_background_tasks = true;
 
   Options options;
@@ -1795,14 +1210,14 @@ TEST_F(BlobDBTest, GarbageCollection) {
 
   Random rnd(301);
 
-  // Add a bunch of large non-TTL values. These will be written to non-TTL
+  // Add a bunch of non-TTL values. These will be written to non-TTL
   // blob files and will be subject to GC.
   for (size_t i = 0; i < kNumPuts; ++i) {
     std::ostringstream oss;
     oss << "key" << std::setw(4) << std::setfill('0') << i;
 
     const std::string key(oss.str());
-    const std::string value = rnd.HumanReadableString(kLargeValueSize);
+    const std::string value = rnd.HumanReadableString(kValueSize);
     const SequenceNumber sequence = blob_db_->GetLatestSequenceNumber() + 1;
 
     ASSERT_OK(Put(key, value));
@@ -1815,54 +1230,23 @@ TEST_F(BlobDBTest, GarbageCollection) {
                          sequence, kTypeBlobIndex);
   }
 
-  // Add some small and/or TTL values that will be ignored during GC.
-  // First, add a large TTL value will be written to its own TTL blob file.
+  // Add a TTL value that will be written to its own TTL blob file (ignored
+  // during GC).
   {
     const std::string key("key2000");
-    const std::string value = rnd.HumanReadableString(kLargeValueSize);
+    const std::string value = rnd.HumanReadableString(kValueSize);
     const SequenceNumber sequence = blob_db_->GetLatestSequenceNumber() + 1;
 
-    ASSERT_OK(PutUntil(key, value, kExpiration));
+    ASSERT_OK(blob_db_->PutWithTTL(WriteOptions(), key, value, kTTL));
     ASSERT_EQ(blob_db_->GetLatestSequenceNumber(), sequence);
 
     data[key] = value;
     blob_value_versions[key] = KeyVersion(key, value, sequence, kTypeBlobIndex);
     blob_index_versions[key] =
-        BlobIndexVersion(key, /* file_number */ kNumBlobFiles + 1, kExpiration,
+        BlobIndexVersion(key, /* file_number */ kNumBlobFiles + 1, kTTL,
                          sequence, kTypeBlobIndex);
   }
 
-  // Now add a small TTL value (which will be inlined).
-  {
-    const std::string key("key3000");
-    const std::string value = rnd.HumanReadableString(kSmallValueSize);
-    const SequenceNumber sequence = blob_db_->GetLatestSequenceNumber() + 1;
-
-    ASSERT_OK(PutUntil(key, value, kExpiration));
-    ASSERT_EQ(blob_db_->GetLatestSequenceNumber(), sequence);
-
-    data[key] = value;
-    blob_value_versions[key] = KeyVersion(key, value, sequence, kTypeBlobIndex);
-    blob_index_versions[key] = BlobIndexVersion(
-        key, kInvalidBlobFileNumber, kExpiration, sequence, kTypeBlobIndex);
-  }
-
-  // Finally, add a small non-TTL value (which will be stored as a regular
-  // value).
-  {
-    const std::string key("key4000");
-    const std::string value = rnd.HumanReadableString(kSmallValueSize);
-    const SequenceNumber sequence = blob_db_->GetLatestSequenceNumber() + 1;
-
-    ASSERT_OK(Put(key, value));
-    ASSERT_EQ(blob_db_->GetLatestSequenceNumber(), sequence);
-
-    data[key] = value;
-    blob_value_versions[key] = KeyVersion(key, value, sequence, kTypeValue);
-    blob_index_versions[key] = BlobIndexVersion(
-        key, kInvalidBlobFileNumber, kNoExpiration, sequence, kTypeValue);
-  }
-
   VerifyDB(data);
   VerifyBaseDB(blob_value_versions);
   VerifyBaseDBBlobIndex(blob_index_versions);
@@ -1888,17 +1272,18 @@ TEST_F(BlobDBTest, GarbageCollection) {
   // compaction.
   VerifyDB(data);
 
-  for (auto &pair : blob_value_versions) {
-    KeyVersion &version = pair.second;
+  for (auto& pair : blob_value_versions) {
+    KeyVersion& version = pair.second;
     version.sequence = 0;
   }
 
   VerifyBaseDB(blob_value_versions);
 
-  const uint64_t cutoff = static_cast<uint64_t>(
-      bdb_options.garbage_collection_cutoff * kNumBlobFiles);
-  for (auto &pair : blob_index_versions) {
-    BlobIndexVersion &version = pair.second;
+  // GC cutoff is fixed at 0.25
+  constexpr double kGCCutoff = 0.25;
+  const uint64_t cutoff = static_cast<uint64_t>(kGCCutoff * kNumBlobFiles);
+  for (auto& pair : blob_index_versions) {
+    BlobIndexVersion& version = pair.second;
 
     version.sequence = 0;
 
@@ -1915,7 +1300,7 @@ TEST_F(BlobDBTest, GarbageCollection) {
 
   VerifyBaseDBBlobIndex(blob_index_versions);
 
-  const Statistics *const statistics = options.statistics.get();
+  const Statistics* const statistics = options.statistics.get();
   assert(statistics);
 
   ASSERT_EQ(statistics->getTickerCount(BLOB_DB_GC_NUM_FILES), cutoff);
@@ -1924,7 +1309,7 @@ TEST_F(BlobDBTest, GarbageCollection) {
   ASSERT_EQ(statistics->getTickerCount(BLOB_DB_GC_NUM_KEYS_RELOCATED),
             cutoff * kBlobsPerFile);
   ASSERT_EQ(statistics->getTickerCount(BLOB_DB_GC_BYTES_RELOCATED),
-            cutoff * kBlobsPerFile * kLargeValueSize);
+            cutoff * kBlobsPerFile * kValueSize);
 
   // At this point, we should have 128 immutable non-TTL files with file numbers
   // 33..128 and 130..161. (129 was taken by the TTL blob file.)
@@ -1946,9 +1331,7 @@ TEST_F(BlobDBTest, GarbageCollection) {
 
 TEST_F(BlobDBTest, GarbageCollectionFailure) {
   BlobDBOptions bdb_options;
-  bdb_options.min_blob_size = 0;
   bdb_options.enable_garbage_collection = true;
-  bdb_options.garbage_collection_cutoff = 1.0;
   bdb_options.disable_background_tasks = true;
 
   Options db_options;
@@ -1956,14 +1339,31 @@ TEST_F(BlobDBTest, GarbageCollectionFailure) {
 
   Open(bdb_options, db_options);
 
-  // Write a couple of valid blobs.
+  // Create 4 blob files. With fixed GC cutoff of 0.25, the oldest file
+  // (floor(0.25 * 4) = 1) will be in the GC zone.
+  // The first file contains valid blobs for "foo" and "dead".
   ASSERT_OK(Put("foo", "bar"));
   ASSERT_OK(Put("dead", "beef"));
 
-  // Write a fake blob reference into the base DB that points to a non-existing
-  // blob file.
+  auto blob_files = blob_db_impl()->TEST_GetBlobFiles();
+  ASSERT_EQ(blob_files.size(), 1);
+  auto first_file = blob_files[0];
+  uint64_t first_file_number = first_file->BlobFileNumber();
+  ASSERT_OK(blob_db_impl()->TEST_CloseBlobFile(first_file));
+
+  // Create 3 more blob files (files 2-4, outside GC zone).
+  for (int i = 1; i < 4; i++) {
+    ASSERT_OK(Put("key" + std::to_string(i), "value"));
+    blob_files = blob_db_impl()->TEST_GetBlobFiles();
+    ASSERT_EQ(static_cast<size_t>(i + 1), blob_files.size());
+    ASSERT_OK(blob_db_impl()->TEST_CloseBlobFile(blob_files[i]));
+  }
+
+  // Write a fake blob index that points to the first file (in GC zone)
+  // but with an invalid offset beyond the file size. This will cause
+  // GC to fail when it tries to read this blob.
   std::string blob_index;
-  BlobIndex::EncodeBlob(&blob_index, /* file_number */ 1000, /* offset */ 1234,
+  BlobIndex::EncodeBlob(&blob_index, first_file_number, /* offset */ 999999,
                         /* size */ 5678, kNoCompression);
 
   WriteBatch batch;
@@ -1971,17 +1371,17 @@ TEST_F(BlobDBTest, GarbageCollectionFailure) {
       &batch, blob_db_->DefaultColumnFamily()->GetID(), "key", blob_index));
   ASSERT_OK(blob_db_->GetRootDB()->Write(WriteOptions(), &batch));
 
-  auto blob_files = blob_db_impl()->TEST_GetBlobFiles();
-  ASSERT_EQ(blob_files.size(), 1);
-  auto blob_file = blob_files[0];
-  ASSERT_OK(blob_db_impl()->TEST_CloseBlobFile(blob_file));
-
+  // Verify compaction fails with IO error due to invalid blob offset.
   ASSERT_TRUE(blob_db_->CompactRange(CompactRangeOptions(), nullptr, nullptr)
                   .IsIOError());
 
-  const Statistics *const statistics = db_options.statistics.get();
+  const Statistics* const statistics = db_options.statistics.get();
   assert(statistics);
 
+  // Verify GC statistics:
+  // - Relocated 2 keys ("foo" and "dead") with 7 bytes ("bar" + "beef")
+  // - Failed on "key" which has invalid blob offset
+  // - Created 1 new GC output file before failing
   ASSERT_EQ(statistics->getTickerCount(BLOB_DB_GC_NUM_FILES), 0);
   ASSERT_EQ(statistics->getTickerCount(BLOB_DB_GC_NUM_NEW_FILES), 1);
   ASSERT_EQ(statistics->getTickerCount(BLOB_DB_GC_FAILURES), 1);
@@ -1993,7 +1393,6 @@ TEST_F(BlobDBTest, GarbageCollectionFailure) {
 TEST_F(BlobDBTest, EvictExpiredFile) {
   BlobDBOptions bdb_options;
   bdb_options.ttl_range_secs = 100;
-  bdb_options.min_blob_size = 0;
   bdb_options.disable_background_tasks = true;
   Options options;
   options.env = mock_env_.get();
@@ -2116,7 +1515,7 @@ TEST_F(BlobDBTest, MaintainBlobFileToSstMapping) {
     const std::vector<bool> expected_obsolete{false, false, false, false,
                                               false};
     for (size_t i = 0; i < 5; ++i) {
-      const auto &blob_file = blob_files[i];
+      const auto& blob_file = blob_files[i];
       ASSERT_EQ(blob_file->GetLinkedSstFiles(), expected_sst_files[i]);
       ASSERT_EQ(blob_file->Obsolete(), expected_obsolete[i]);
     }
@@ -2144,7 +1543,7 @@ TEST_F(BlobDBTest, MaintainBlobFileToSstMapping) {
     const std::vector<bool> expected_obsolete{false, false, false, false,
                                               false};
     for (size_t i = 0; i < 5; ++i) {
-      const auto &blob_file = blob_files[i];
+      const auto& blob_file = blob_files[i];
       ASSERT_EQ(blob_file->GetLinkedSstFiles(), expected_sst_files[i]);
       ASSERT_EQ(blob_file->Obsolete(), expected_obsolete[i]);
     }
@@ -2173,7 +1572,7 @@ TEST_F(BlobDBTest, MaintainBlobFileToSstMapping) {
     const std::vector<bool> expected_obsolete{false, false, false, false,
                                               false};
     for (size_t i = 0; i < 5; ++i) {
-      const auto &blob_file = blob_files[i];
+      const auto& blob_file = blob_files[i];
       ASSERT_EQ(blob_file->GetLinkedSstFiles(), expected_sst_files[i]);
       ASSERT_EQ(blob_file->Obsolete(), expected_obsolete[i]);
     }
@@ -2211,7 +1610,7 @@ TEST_F(BlobDBTest, MaintainBlobFileToSstMapping) {
         {}, {7}, {3, 8, 23}, {4, 9}, {5, 10, 22}};
     const std::vector<bool> expected_obsolete{true, false, false, false, false};
     for (size_t i = 0; i < 5; ++i) {
-      const auto &blob_file = blob_files[i];
+      const auto& blob_file = blob_files[i];
       ASSERT_EQ(blob_file->GetLinkedSstFiles(), expected_sst_files[i]);
       ASSERT_EQ(blob_file->Obsolete(), expected_obsolete[i]);
     }
@@ -2241,7 +1640,7 @@ TEST_F(BlobDBTest, MaintainBlobFileToSstMapping) {
         {}, {7}, {3, 8, 23}, {4, 9}, {5, 10, 22}};
     const std::vector<bool> expected_obsolete{true, false, false, false, false};
     for (size_t i = 0; i < 5; ++i) {
-      const auto &blob_file = blob_files[i];
+      const auto& blob_file = blob_files[i];
       ASSERT_EQ(blob_file->GetLinkedSstFiles(), expected_sst_files[i]);
       ASSERT_EQ(blob_file->Obsolete(), expected_obsolete[i]);
     }
@@ -2272,7 +1671,7 @@ TEST_F(BlobDBTest, MaintainBlobFileToSstMapping) {
         {}, {}, {3, 8, 23, 25}, {4, 9}, {5, 10}};
     const std::vector<bool> expected_obsolete{true, false, false, false, false};
     for (size_t i = 0; i < 5; ++i) {
-      const auto &blob_file = blob_files[i];
+      const auto& blob_file = blob_files[i];
       ASSERT_EQ(blob_file->GetLinkedSstFiles(), expected_sst_files[i]);
       ASSERT_EQ(blob_file->Obsolete(), expected_obsolete[i]);
     }
@@ -2302,7 +1701,7 @@ TEST_F(BlobDBTest, MaintainBlobFileToSstMapping) {
         {}, {}, {3, 8, 23, 25}, {4, 9}, {5, 10}};
     const std::vector<bool> expected_obsolete{true, true, false, false, false};
     for (size_t i = 0; i < 5; ++i) {
-      const auto &blob_file = blob_files[i];
+      const auto& blob_file = blob_files[i];
       ASSERT_EQ(blob_file->GetLinkedSstFiles(), expected_sst_files[i]);
       ASSERT_EQ(blob_file->Obsolete(), expected_obsolete[i]);
     }
@@ -2323,7 +1722,6 @@ TEST_F(BlobDBTest, MaintainBlobFileToSstMapping) {
 TEST_F(BlobDBTest, ShutdownWait) {
   BlobDBOptions bdb_options;
   bdb_options.ttl_range_secs = 100;
-  bdb_options.min_blob_size = 0;
   bdb_options.disable_background_tasks = false;
   Options options;
   options.env = mock_env_.get();
@@ -2336,15 +1734,15 @@ TEST_F(BlobDBTest, ShutdownWait) {
   });
   // Force all tasks to be scheduled immediately.
   SyncPoint::GetInstance()->SetCallBack(
-      "TimeQueue::Add:item.end", [&](void *arg) {
-        std::chrono::steady_clock::time_point *tp =
-            static_cast<std::chrono::steady_clock::time_point *>(arg);
+      "TimeQueue::Add:item.end", [&](void* arg) {
+        std::chrono::steady_clock::time_point* tp =
+            static_cast<std::chrono::steady_clock::time_point*>(arg);
         *tp =
             std::chrono::steady_clock::now() - std::chrono::milliseconds(10000);
       });
 
   SyncPoint::GetInstance()->SetCallBack(
-      "BlobDBImpl::EvictExpiredFiles:cb", [&](void * /*arg*/) {
+      "BlobDBImpl::EvictExpiredFiles:cb", [&](void* /*arg*/) {
         // Sleep 3 ms to increase the chance of data race.
         // We've synced up the code so that EvictExpiredFiles()
         // is called concurrently with ~BlobDBImpl().
@@ -2387,8 +1785,6 @@ TEST_F(BlobDBTest, SyncBlobFileBeforeClose) {
   options.statistics = CreateDBStatistics();
 
   BlobDBOptions blob_options;
-  blob_options.min_blob_size = 0;
-  blob_options.bytes_per_sync = 1 << 20;
   blob_options.disable_background_tasks = true;
 
   Open(blob_options, options);
@@ -2407,8 +1803,6 @@ TEST_F(BlobDBTest, SyncBlobFileBeforeCloseIOError) {
   options.env = fault_injection_env_.get();
 
   BlobDBOptions blob_options;
-  blob_options.min_blob_size = 0;
-  blob_options.bytes_per_sync = 1 << 20;
   blob_options.disable_background_tasks = true;
 
   Open(blob_options, options);
@@ -2419,7 +1813,7 @@ TEST_F(BlobDBTest, SyncBlobFileBeforeCloseIOError) {
   ASSERT_EQ(blob_files.size(), 1);
 
   SyncPoint::GetInstance()->SetCallBack(
-      "BlobLogWriter::Sync", [this](void * /* arg */) {
+      "BlobLogWriter::Sync", [this](void* /* arg */) {
         fault_injection_env_->SetFilesystemActive(false, Status::IOError());
       });
   SyncPoint::GetInstance()->EnableProcessing();
@@ -2436,7 +1830,7 @@ TEST_F(BlobDBTest, SyncBlobFileBeforeCloseIOError) {
 }  // namespace ROCKSDB_NAMESPACE::blob_db
 
 // A black-box test for the ttl wrapper around rocksdb
-int main(int argc, char **argv) {
+int main(int argc, char** argv) {
   ROCKSDB_NAMESPACE::port::InstallStackTraceHandler();
   ::testing::InitGoogleTest(&argc, argv);
   return RUN_ALL_TESTS();