@nxtedition/rocksdb 14.0.0 → 15.1.0

package/deps/rocksdb/rocksdb/table/block_based/block_based_table_reader_test.cc

@@ -246,6 +246,70 @@ class BlockBasedTableReaderBaseTest : public testing::Test {
   }
 };
 
+struct BlockBasedTableReaderTestParam {
+  BlockBasedTableReaderTestParam(
+      CompressionType _compression_type, bool _use_direct_reads,
+      BlockBasedTableOptions::IndexType _index_type, bool _no_block_cache,
+      test::UserDefinedTimestampTestMode _udt_test_mode,
+      uint32_t _compression_parallel_threads, uint32_t _compression_dict_bytes,
+      bool _same_key_diff_ts, const Comparator* _comparator, bool _fill_cache,
+      bool _use_async_io, bool _block_align, size_t _super_block_alignment_size,
+      size_t _super_block_alignment_space_overhead_ratio)
+      : compression_type(_compression_type),
+        use_direct_reads(_use_direct_reads),
+        index_type(_index_type),
+        no_block_cache(_no_block_cache),
+        udt_test_mode(_udt_test_mode),
+        compression_parallel_threads(_compression_parallel_threads),
+        compression_dict_bytes(_compression_dict_bytes),
+        same_key_diff_ts(_same_key_diff_ts),
+        comparator(_comparator),
+        fill_cache(_fill_cache),
+        use_async_io(_use_async_io),
+        block_align(_block_align),
+        super_block_alignment_size(_super_block_alignment_size),
+        super_block_alignment_space_overhead_ratio(
+            _super_block_alignment_space_overhead_ratio) {}
+
+  CompressionType compression_type;
+  bool use_direct_reads;
+  BlockBasedTableOptions::IndexType index_type;
+  bool no_block_cache;
+  test::UserDefinedTimestampTestMode udt_test_mode;
+  uint32_t compression_parallel_threads;
+  uint32_t compression_dict_bytes;
+  bool same_key_diff_ts;
+  const Comparator* comparator;
+  bool fill_cache;
+  bool use_async_io;
+  bool block_align;
+  size_t super_block_alignment_size;
+  size_t super_block_alignment_space_overhead_ratio;
+};
+
+// Define operator<< for SpotLockManagerTestParam to stop valgrind from
+// complaining uinitialized value when printing SpotLockManagerTestParam.
+std::ostream& operator<<(std::ostream& os,
+                         const BlockBasedTableReaderTestParam& param) {
+  os << "compression_type: " << CompressionTypeToString(param.compression_type)
+     << " use_direct_reads: " << param.use_direct_reads
+     << " index_type: " << static_cast<int>(param.index_type)
+     << " no_block_cache: " << param.no_block_cache
+     << " udt_test_mode: " << static_cast<int>(param.udt_test_mode)
+     << " compression_parallel_threads: " << param.compression_parallel_threads
+     << " compression_dict_bytes: " << param.compression_dict_bytes
+     << " same_key_diff_ts: " << param.same_key_diff_ts
+     << " comparator: " << param.comparator->Name()
+     << " fill_cache: " << param.fill_cache
+     << " use_async_io: " << param.use_async_io
+     << " block_align: " << param.block_align
+     << " super_block_alignment_size: " << param.super_block_alignment_size
+     << " super_block_alignment_space_overhead_ratio: "
+     << param.super_block_alignment_space_overhead_ratio;
+
+  return os;
+}
+
 // Param 1: compression type
 // Param 2: whether to use direct reads
 // Param 3: Block Based Table Index type
@@ -265,28 +329,30 @@ class BlockBasedTableReaderBaseTest : public testing::Test {
 // Param 9: test both the default comparator and a reverse comparator.
 class BlockBasedTableReaderTest
     : public BlockBasedTableReaderBaseTest,
-      public testing::WithParamInterface<
-          std::tuple<CompressionType, bool, BlockBasedTableOptions::IndexType,
-                     bool, test::UserDefinedTimestampTestMode, uint32_t,
-                     uint32_t, bool, const Comparator*>> {
+      public testing::WithParamInterface<BlockBasedTableReaderTestParam> {
  protected:
   void SetUp() override {
-    compression_type_ = std::get<0>(GetParam());
-    use_direct_reads_ = std::get<1>(GetParam());
-    test::UserDefinedTimestampTestMode udt_test_mode = std::get<4>(GetParam());
+    auto param = GetParam();
+    compression_type_ = param.compression_type;
+    use_direct_reads_ = param.use_direct_reads;
+    test::UserDefinedTimestampTestMode udt_test_mode = param.udt_test_mode;
     udt_enabled_ = test::IsUDTEnabled(udt_test_mode);
     persist_udt_ = test::ShouldPersistUDT(udt_test_mode);
-    compression_parallel_threads_ = std::get<5>(GetParam());
-    compression_dict_bytes_ = std::get<6>(GetParam());
-    same_key_diff_ts_ = std::get<7>(GetParam());
-    comparator_ = std::get<8>(GetParam());
+    compression_parallel_threads_ = param.compression_parallel_threads;
+    compression_dict_bytes_ = param.compression_dict_bytes;
+    same_key_diff_ts_ = param.same_key_diff_ts;
+    comparator_ = param.comparator;
     BlockBasedTableReaderBaseTest::SetUp();
   }
 
   void ConfigureTableFactory() override {
     BlockBasedTableOptions opts;
-    opts.index_type = std::get<2>(GetParam());
-    opts.no_block_cache = std::get<3>(GetParam());
+    auto param = GetParam();
+    opts.index_type = param.index_type;
+    opts.no_block_cache = param.no_block_cache;
+    opts.super_block_alignment_size = param.super_block_alignment_size;
+    opts.super_block_alignment_space_overhead_ratio =
+        param.super_block_alignment_space_overhead_ratio;
     opts.filter_policy.reset(NewBloomFilterPolicy(10, false));
     opts.partition_filters =
         opts.index_type ==
@@ -1009,184 +1075,287 @@ TEST_P(BlockBasedTableReaderTestVerifyChecksum, ChecksumMismatch) {
   ASSERT_EQ(s.code(), Status::kCorruption);
 }
 
+class BlockBasedTableReaderMultiScanTest : public BlockBasedTableReaderTest {
+ public:
+  void SetUp() override {
+    BlockBasedTableReaderTest::SetUp();
+    options_.comparator = comparator_;
+  }
+};
+
+class BlockBasedTableReaderMultiScanAsyncIOTest
+    : public BlockBasedTableReaderMultiScanTest {};
+
 // TODO: test no block cache case
-TEST_P(BlockBasedTableReaderTest, MultiScanPrepare) {
-  std::ostringstream param_trace;
-  param_trace << "[MultiScanPrepare] Test params: " << "CompressionType="
-              << CompressionTypeToString(compression_type_)
-              << ", UseDirectReads=" << (use_direct_reads_ ? "true" : "false")
-              << ", UDTEnabled=" << (udt_enabled_ ? "true" : "false")
-              << ", PersistUDT=" << (persist_udt_ ? "true" : "false")
-              << ", CompressionParallelThreads="
-              << compression_parallel_threads_
-              << ", CompressionDictBytes=" << compression_dict_bytes_
-              << ", SameKeyDiffTs=" << (same_key_diff_ts_ ? "true" : "false");
-  SCOPED_TRACE(param_trace.str());
-
-  for (bool fill_cache : {false, true}) {
-    SCOPED_TRACE(std::string("fill_cache=") + std::to_string(fill_cache));
-    for (bool use_async_io : {false,
-#ifdef ROCKSDB_IOURING_PRESENT
-                              true
-#endif
-         }) {
-      SCOPED_TRACE(std::string("use_async_io=") + std::to_string(use_async_io));
-      Options options;
-      options.statistics = CreateDBStatistics();
-      options.comparator = comparator_;
-      std::shared_ptr<FileSystem> fs = options.env->GetFileSystem();
-      ReadOptions read_opts;
-      read_opts.fill_cache = fill_cache;
-      size_t ts_sz = options.comparator->timestamp_size();
-      std::vector<std::pair<std::string, std::string>> kv =
-          BlockBasedTableReaderBaseTest::GenerateKVMap(
-              100 /* num_block */,
-              true /* mixed_with_human_readable_string_value */, ts_sz,
-              same_key_diff_ts_, comparator_);
-      std::string table_name = "BlockBasedTableReaderTest_NewIterator" +
-                               CompressionTypeToString(compression_type_) +
-                               "_async" + std::to_string(use_async_io);
-      ImmutableOptions ioptions(options);
-      CreateTable(table_name, ioptions, compression_type_, kv,
-                  compression_parallel_threads_, compression_dict_bytes_);
-
-      std::unique_ptr<BlockBasedTable> table;
-      FileOptions foptions;
-      foptions.use_direct_reads = use_direct_reads_;
-      InternalKeyComparator comparator(options.comparator);
-      NewBlockBasedTableReader(
-          foptions, ioptions, comparator, table_name, &table,
-          true /* bool prefetch_index_and_filter_in_cache */,
-          nullptr /* status */, persist_udt_);
-
-      // 1. Should coalesce into a single I/O
-      std::unique_ptr<InternalIterator> iter;
-      iter.reset(table->NewIterator(
-          read_opts, options_.prefix_extractor.get(), /*arena=*/nullptr,
-          /*skip_filters=*/false, TableReaderCaller::kUncategorized));
-
-      MultiScanArgs scan_options(comparator_);
-      scan_options.use_async_io = use_async_io;
-      scan_options.insert(ExtractUserKey(kv[0].first),
-                          ExtractUserKey(kv[kEntriesPerBlock].first));
-      scan_options.insert(ExtractUserKey(kv[2 * kEntriesPerBlock].first),
-                          ExtractUserKey(kv[3 * kEntriesPerBlock].first));
-      auto read_count_before =
-          options.statistics->getTickerCount(NON_LAST_LEVEL_READ_COUNT);
-
-      iter->Prepare(&scan_options);
-      iter->Seek(kv[0].first);
-      for (size_t i = 0; i < kEntriesPerBlock + 1; ++i) {
-        ASSERT_TRUE(iter->status().ok()) << iter->status().ToString();
-        ASSERT_TRUE(iter->Valid()) << i;
-        ASSERT_EQ(iter->key().ToString(), kv[i].first);
-        iter->Next();
-      }
-      // Iter may still be valid after scan range. Upper layer (DBIter) handles
-      // exact upper bound checking. So we don't check !iter->Valid() here.
-      ASSERT_OK(iter->status());
-      iter->Seek(kv[2 * kEntriesPerBlock].first);
-      for (size_t i = 2 * kEntriesPerBlock; i < 3 * kEntriesPerBlock; ++i) {
-        ASSERT_TRUE(iter->Valid());
-        ASSERT_EQ(iter->key().ToString(), kv[i].first);
-        iter->Next();
-      }
-      ASSERT_OK(iter->status());
-      auto read_count_after =
-          options.statistics->getTickerCount(NON_LAST_LEVEL_READ_COUNT);
-      ASSERT_EQ(read_count_before + 1, read_count_after);
+TEST_P(BlockBasedTableReaderMultiScanAsyncIOTest, MultiScanPrepare) {
+  auto param = GetParam();
+  auto fill_cache = param.fill_cache;
+  auto use_async_io = param.use_async_io;
 
-      // 2. No IO coalesce, should do MultiRead/ReadAsync with 2 read requests.
-      iter.reset(table->NewIterator(
-          read_opts, options_.prefix_extractor.get(), /*arena=*/nullptr,
-          /*skip_filters=*/false, TableReaderCaller::kUncategorized));
-      scan_options = MultiScanArgs(comparator_);
-      scan_options.insert(ExtractUserKey(kv[70 * kEntriesPerBlock].first),
-                          ExtractUserKey(kv[75 * kEntriesPerBlock].first));
-      scan_options.insert(ExtractUserKey(kv[90 * kEntriesPerBlock].first),
-                          ExtractUserKey(kv[95 * kEntriesPerBlock].first));
-
-      read_count_before =
-          options.statistics->getTickerCount(NON_LAST_LEVEL_READ_COUNT);
-      iter->Prepare(&scan_options);
-
-      iter->Seek(kv[70 * kEntriesPerBlock].first);
-      for (size_t i = 70 * kEntriesPerBlock; i < 75 * kEntriesPerBlock; ++i) {
-        ASSERT_TRUE(iter->Valid());
-        ASSERT_EQ(iter->key().ToString(), kv[i].first);
-        iter->Next();
-      }
-      ASSERT_OK(iter->status());
-      iter->Seek(kv[90 * kEntriesPerBlock].first);
-      for (size_t i = 90 * kEntriesPerBlock; i < 95 * kEntriesPerBlock; ++i) {
-        ASSERT_TRUE(iter->Valid());
-        ASSERT_EQ(iter->key().ToString(), kv[i].first);
-        iter->Next();
-      }
-      ASSERT_OK(iter->status());
+  options_.statistics = CreateDBStatistics();
+  std::shared_ptr<FileSystem> fs = options_.env->GetFileSystem();
+  ReadOptions read_opts;
+  read_opts.fill_cache = fill_cache;
+  size_t ts_sz = options_.comparator->timestamp_size();
+  std::vector<std::pair<std::string, std::string>> kv =
+      BlockBasedTableReaderBaseTest::GenerateKVMap(
+          100 /* num_block */,
+          true /* mixed_with_human_readable_string_value */, ts_sz,
+          same_key_diff_ts_, comparator_);
+  std::string table_name = "BlockBasedTableReaderTest_NewIterator" +
+                           CompressionTypeToString(compression_type_) +
+                           "_async" + std::to_string(use_async_io);
+  ImmutableOptions ioptions(options_);
+  // Only insert 60 out of 100 blocks
+  CreateTable(table_name, ioptions, compression_type_,
+              std::vector<std::pair<std::string, std::string>>{
+                  kv.begin() + 20 * kEntriesPerBlock,
+                  kv.begin() + 80 * kEntriesPerBlock},
+              compression_parallel_threads_, compression_dict_bytes_);
+
+  std::unique_ptr<BlockBasedTable> table;
+  FileOptions foptions;
+  foptions.use_direct_reads = use_direct_reads_;
+  InternalKeyComparator comparator(options_.comparator);
+  NewBlockBasedTableReader(foptions, ioptions, comparator, table_name, &table,
+                           true /* bool prefetch_index_and_filter_in_cache */,
+                           nullptr /* status */, persist_udt_);
+
+  // 1. Should coalesce into a single I/O
+  std::unique_ptr<InternalIterator> iter;
+  iter.reset(table->NewIterator(
+      read_opts, options_.prefix_extractor.get(), /*arena=*/nullptr,
+      /*skip_filters=*/false, TableReaderCaller::kUncategorized));
+
+  MultiScanArgs scan_options(comparator_);
+  scan_options.use_async_io = use_async_io;
+  scan_options.insert(ExtractUserKey(kv[30 * kEntriesPerBlock].first),
+                      ExtractUserKey(kv[31 * kEntriesPerBlock].first));
+  scan_options.insert(ExtractUserKey(kv[32 * kEntriesPerBlock].first),
+                      ExtractUserKey(kv[33 * kEntriesPerBlock].first));
+  auto read_count_before =
+      options_.statistics->getTickerCount(NON_LAST_LEVEL_READ_COUNT);
+
+  iter->Prepare(&scan_options);
+  iter->Seek(kv[30 * kEntriesPerBlock].first);
+  for (size_t i = 30 * kEntriesPerBlock; i <= 31 * kEntriesPerBlock; ++i) {
+    ASSERT_TRUE(iter->status().ok()) << iter->status().ToString();
+    ASSERT_TRUE(iter->Valid()) << i;
+    ASSERT_EQ(iter->key().ToString(), kv[i].first);
+    iter->Next();
+  }
+  // Iter may still be valid after scan range. Upper layer (DBIter) handles
+  // exact upper bound checking. So we don't check !iter->Valid() here.
+  ASSERT_OK(iter->status());
+  iter->Seek(kv[32 * kEntriesPerBlock].first);
+  for (size_t i = 32 * kEntriesPerBlock; i < 33 * kEntriesPerBlock; ++i) {
+    ASSERT_TRUE(iter->Valid());
+    ASSERT_EQ(iter->key().ToString(), kv[i].first);
+    iter->Next();
+  }
+  ASSERT_OK(iter->status());
+  auto read_count_after =
+      options_.statistics->getTickerCount(NON_LAST_LEVEL_READ_COUNT);
+  ASSERT_EQ(read_count_before + 1, read_count_after);
 
-      read_count_after =
-          options.statistics->getTickerCount(NON_LAST_LEVEL_READ_COUNT);
+  // 2. No IO coalesce, should do MultiRead/ReadAsync with 2 read requests.
+  iter.reset(table->NewIterator(
+      read_opts, options_.prefix_extractor.get(), /*arena=*/nullptr,
+      /*skip_filters=*/false, TableReaderCaller::kUncategorized));
+  scan_options = MultiScanArgs(comparator_);
+  scan_options.insert(ExtractUserKey(kv[40 * kEntriesPerBlock].first),
+                      ExtractUserKey(kv[45 * kEntriesPerBlock].first));
+  scan_options.insert(ExtractUserKey(kv[70 * kEntriesPerBlock].first),
+                      ExtractUserKey(kv[75 * kEntriesPerBlock].first));
+
+  read_count_before =
+      options_.statistics->getTickerCount(NON_LAST_LEVEL_READ_COUNT);
+  iter->Prepare(&scan_options);
+
+  iter->Seek(kv[40 * kEntriesPerBlock].first);
+  for (size_t i = 40 * kEntriesPerBlock; i < 45 * kEntriesPerBlock; ++i) {
+    ASSERT_TRUE(iter->Valid());
+    ASSERT_EQ(iter->key().ToString(), kv[i].first);
+    iter->Next();
+  }
+  ASSERT_OK(iter->status());
+  iter->Seek(kv[70 * kEntriesPerBlock].first);
+  for (size_t i = 70 * kEntriesPerBlock; i < 75 * kEntriesPerBlock; ++i) {
+    ASSERT_TRUE(iter->Valid());
+    ASSERT_EQ(iter->key().ToString(), kv[i].first);
+    iter->Next();
+  }
+  ASSERT_OK(iter->status());
+
+  read_count_after =
+      options_.statistics->getTickerCount(NON_LAST_LEVEL_READ_COUNT);
+  ASSERT_EQ(read_count_before + 2, read_count_after);
+
+  iter.reset(table->NewIterator(
+      read_opts, options_.prefix_extractor.get(), /*arena=*/nullptr,
+      /*skip_filters=*/false, TableReaderCaller::kUncategorized));
+
+  // 3. Tests I/O excludes blocks already in cache.
+  // Reading blocks from 40-79
+  // From reads above, blocks 40-44 and 70-74 already in cache
+  // So we should read 45-69, 75-79 in two I/Os.
+  // If fill_cache is false, then we'll do one giant I/O.
+  scan_options = MultiScanArgs(comparator_);
+  scan_options.use_async_io = use_async_io;
+  scan_options.insert(ExtractUserKey(kv[40 * kEntriesPerBlock].first),
+                      ExtractUserKey(kv[80 * kEntriesPerBlock].first));
+  read_count_before =
+      options_.statistics->getTickerCount(NON_LAST_LEVEL_READ_COUNT);
+  iter->Prepare(&scan_options);
+  read_count_after =
+      options_.statistics->getTickerCount(NON_LAST_LEVEL_READ_COUNT);
+  if (!use_async_io) {
+    if (!fill_cache) {
+      ASSERT_EQ(read_count_before + 1, read_count_after);
+    } else {
       ASSERT_EQ(read_count_before + 2, read_count_after);
+    }
+  } else {
+    // stat is recorded in async callback which happens in Poll(), and
+    // Poll() happens during scanning.
+    ASSERT_EQ(read_count_before, read_count_after);
+  }
 
-      iter.reset(table->NewIterator(
-          read_opts, options_.prefix_extractor.get(), /*arena=*/nullptr,
-          /*skip_filters=*/false, TableReaderCaller::kUncategorized));
-
-      // 3. Tests I/O excludes blocks already in cache.
-      // Reading blocks from 50-99
-      // From reads above, blocks 70-75 and 90-95 already in cache
-      // So we should read 50-70 76-89 96-99 in three I/Os.
-      // If fill_cache is false, then we'll do one giant I/O.
-      scan_options = MultiScanArgs(comparator_);
-      scan_options.use_async_io = use_async_io;
-      scan_options.insert(ExtractUserKey(kv[50 * kEntriesPerBlock].first));
-      read_count_before =
-          options.statistics->getTickerCount(NON_LAST_LEVEL_READ_COUNT);
-      iter->Prepare(&scan_options);
-      read_count_after =
-          options.statistics->getTickerCount(NON_LAST_LEVEL_READ_COUNT);
-      if (!use_async_io) {
-        if (!fill_cache) {
-          ASSERT_EQ(read_count_before + 1, read_count_after);
-        } else {
-          ASSERT_EQ(read_count_before + 3, read_count_after);
-        }
-      } else {
-        // stat is recorded in async callback which happens in Poll(), and
-        // Poll() happens during scanning.
-        ASSERT_EQ(read_count_before, read_count_after);
-      }
+  iter->Seek(kv[40 * kEntriesPerBlock].first);
+  for (size_t i = 40 * kEntriesPerBlock; i < 80 * kEntriesPerBlock; ++i) {
+    ASSERT_TRUE(iter->Valid());
+    ASSERT_EQ(iter->key().ToString(), kv[i].first);
+    iter->Next();
+  }
+  ASSERT_FALSE(iter->Valid());
+  ASSERT_OK(iter->status());
+  read_count_after =
+      options_.statistics->getTickerCount(NON_LAST_LEVEL_READ_COUNT);
+  if (!fill_cache) {
+    ASSERT_EQ(read_count_before + 1, read_count_after);
+  } else {
+    ASSERT_EQ(read_count_before + 2, read_count_after);
+  }
+
+  // 4. Check cases when Seek key does not match start key in ScanOptions
+  iter.reset(table->NewIterator(
+      read_opts, options_.prefix_extractor.get(), /*arena=*/nullptr,
+      /*skip_filters=*/false, TableReaderCaller::kUncategorized));
+  scan_options = MultiScanArgs(comparator_);
+  scan_options.use_async_io = use_async_io;
+  scan_options.insert(ExtractUserKey(kv[30 * kEntriesPerBlock].first),
+                      ExtractUserKey(kv[40 * kEntriesPerBlock].first));
+  scan_options.insert(ExtractUserKey(kv[50 * kEntriesPerBlock].first),
+                      ExtractUserKey(kv[60 * kEntriesPerBlock].first));
+  iter->Prepare(&scan_options);
+  // Match start key
+  iter->Seek(kv[30 * kEntriesPerBlock].first);
+  for (size_t i = 30 * kEntriesPerBlock; i < 40 * kEntriesPerBlock; ++i) {
+    ASSERT_TRUE(iter->Valid());
+    ASSERT_EQ(iter->key().ToString(), kv[i].first);
+    iter->Next();
+  }
+  ASSERT_OK(iter->status());
+
+  // Seek a key that is larger than next start key is allowed, as long as it is
+  // larger than the previous key
+  iter->Seek(kv[50 * kEntriesPerBlock + 1].first);
+  ASSERT_OK(iter->status());
 
-      iter->Seek(kv[50 * kEntriesPerBlock].first);
-      for (size_t i = 50 * kEntriesPerBlock; i < 100 * kEntriesPerBlock; ++i) {
-        ASSERT_TRUE(iter->Valid());
-        ASSERT_EQ(iter->key().ToString(), kv[i].first);
+  // Check seek key going backward
+  iter.reset(table->NewIterator(
+      read_opts, options_.prefix_extractor.get(), /*arena=*/nullptr,
+      /*skip_filters=*/false, TableReaderCaller::kUncategorized));
+  scan_options = MultiScanArgs(comparator_);
+  scan_options.use_async_io = use_async_io;
+  scan_options.insert(ExtractUserKey(kv[30 * kEntriesPerBlock].first),
+                      ExtractUserKey(kv[31 * kEntriesPerBlock].first));
+  scan_options.insert(ExtractUserKey(kv[32 * kEntriesPerBlock].first),
+                      ExtractUserKey(kv[33 * kEntriesPerBlock].first));
+  iter->Prepare(&scan_options);
+  iter->Seek(kv[32 * kEntriesPerBlock].first);
+  ASSERT_OK(iter->status());
+  iter->Seek(kv[34 * kEntriesPerBlock].first);
+  ASSERT_OK(iter->status());
+  // Seek key could not going backward
+  iter->Seek(kv[30 * kEntriesPerBlock].first);
+  ASSERT_EQ(iter->status(),
+            Status::InvalidArgument("Unexpected seek key moving backward"));
+
+  // Test prefetch limit reached.
+  iter.reset(table->NewIterator(
+      read_opts, options_.prefix_extractor.get(), /*arena=*/nullptr,
+      /*skip_filters=*/false, TableReaderCaller::kUncategorized));
+  scan_options = MultiScanArgs(comparator_);
+  scan_options.use_async_io = use_async_io;
+  scan_options.max_prefetch_size = 1024;  // less than block size
+  scan_options.insert(ExtractUserKey(kv[30 * kEntriesPerBlock].first),
+                      ExtractUserKey(kv[40 * kEntriesPerBlock].first));
+  iter->Prepare(&scan_options);
+  iter->Seek(kv[31 * kEntriesPerBlock].first);
+  ASSERT_TRUE(iter->status().IsIncomplete());
+
+  // Randomly seek keys on the file, as long as the key is moving forward, it
+  // is allowed
+
+  if (use_async_io) {
+    // Skip following test when async io is enabled. There is some issue with
+    // IO_uring that I am still trying to root cause.
+    // TODO : enable the test again with async IO
+    return;
+  }
+  for (int i = 0; i < 100; i++) {
+    iter.reset(table->NewIterator(
+        read_opts, options_.prefix_extractor.get(), /*arena=*/nullptr,
+        /*skip_filters=*/false, TableReaderCaller::kUncategorized));
+    scan_options = MultiScanArgs(comparator_);
+    scan_options.use_async_io = use_async_io;
+    scan_options.insert(ExtractUserKey(kv[5 * kEntriesPerBlock].first),
+                        ExtractUserKey(kv[10 * kEntriesPerBlock].first));
+    scan_options.insert(ExtractUserKey(kv[25 * kEntriesPerBlock].first),
+                        ExtractUserKey(kv[35 * kEntriesPerBlock].first));
+    scan_options.insert(ExtractUserKey(kv[35 * kEntriesPerBlock].first),
+                        ExtractUserKey(kv[40 * kEntriesPerBlock].first));
+    scan_options.insert(ExtractUserKey(kv[45 * kEntriesPerBlock].first),
+                        ExtractUserKey(kv[50 * kEntriesPerBlock].first));
+    scan_options.insert(ExtractUserKey(kv[75 * kEntriesPerBlock].first),
+                        ExtractUserKey(kv[85 * kEntriesPerBlock].first));
+    scan_options.insert(ExtractUserKey(kv[85 * kEntriesPerBlock].first),
+                        ExtractUserKey(kv[95 * kEntriesPerBlock].first));
+
+    iter->Prepare(&scan_options);
+
+    auto random_seed = static_cast<uint32_t>(
+        std::chrono::duration_cast<std::chrono::nanoseconds>(
+            std::chrono::system_clock::now().time_since_epoch())
+            .count());
+    Random rnd(random_seed);
+    std::cout << random_seed << std::endl;
+    SCOPED_TRACE("Random seed " + std::to_string(random_seed));
+
+    int last_read_key_index = rnd.Uniform(100);
+    while (last_read_key_index < 100) {
+      iter->Seek(kv[last_read_key_index * kEntriesPerBlock].first);
+      EXPECT_OK(iter->status());
+      // iterate for a few keys
+      while (iter->Valid()) {
         iter->Next();
+        last_read_key_index++;
+        EXPECT_OK(iter->status());
       }
-      ASSERT_FALSE(iter->Valid());
-      ASSERT_OK(iter->status());
-      read_count_after =
-          options.statistics->getTickerCount(NON_LAST_LEVEL_READ_COUNT);
-      if (!fill_cache) {
-        ASSERT_EQ(read_count_before + 1, read_count_after);
-      } else {
-        ASSERT_EQ(read_count_before + 3, read_count_after);
-      }
+      last_read_key_index += rnd.Uniform(100);
     }
   }
 }
 
-TEST_P(BlockBasedTableReaderTest, MultiScanPrefetchSizeLimit) {
+TEST_P(BlockBasedTableReaderMultiScanTest, MultiScanPrefetchSizeLimit) {
   if (compression_type_ != kNoCompression) {
     // This test relies on block sizes to be close to what's set in option.
     ROCKSDB_GTEST_BYPASS("This test assumes no compression.");
     return;
   }
-  Options options;
-  options.comparator = comparator_;
   ReadOptions read_opts;
-  size_t ts_sz = options.comparator->timestamp_size();
+  size_t ts_sz = options_.comparator->timestamp_size();
 
   // Generate data that spans multiple blocks
   std::vector<std::pair<std::string, std::string>> kv =
@@ -1197,14 +1366,14 @@ TEST_P(BlockBasedTableReaderTest, MultiScanPrefetchSizeLimit) {
   std::string table_name = "BlockBasedTableReaderTest_PrefetchSizeLimit" +
                            CompressionTypeToString(compression_type_);
 
-  ImmutableOptions ioptions(options);
+  ImmutableOptions ioptions(options_);
   CreateTable(table_name, ioptions, compression_type_, kv,
               compression_parallel_threads_, compression_dict_bytes_);
 
   std::unique_ptr<BlockBasedTable> table;
   FileOptions foptions;
   foptions.use_direct_reads = use_direct_reads_;
-  InternalKeyComparator comparator(options.comparator);
+  InternalKeyComparator comparator(options_.comparator);
   NewBlockBasedTableReader(foptions, ioptions, comparator, table_name, &table,
                            true /* bool prefetch_index_and_filter_in_cache */,
                            nullptr /* status */, persist_udt_);
@@ -1377,11 +1546,11 @@ TEST_P(BlockBasedTableReaderTest, MultiScanPrefetchSizeLimit) {
   }
 }
 
-TEST_P(BlockBasedTableReaderTest, MultiScanUnpinPreviousBlocks) {
+TEST_P(BlockBasedTableReaderMultiScanTest, MultiScanUnpinPreviousBlocks) {
   std::vector<std::pair<std::string, std::string>> kv =
       BlockBasedTableReaderBaseTest::GenerateKVMap(
-          30 /* num_block */,
-          true /* mixed_with_human_readable_string_value */);
+          30 /* num_block */, true /* mixed_with_human_readable_string_value */,
+          comparator_->timestamp_size(), same_key_diff_ts_, comparator_);
   std::string table_name = "BlockBasedTableReaderTest_UnpinPreviousBlocks" +
                            CompressionTypeToString(compression_type_);
   ImmutableOptions ioptions(options_);
@@ -1454,53 +1623,375 @@ TEST_P(BlockBasedTableReaderTest, MultiScanUnpinPreviousBlocks) {
   }
 }
 
+// Test that fs_prefetch_support flag is correctly initialized during table
+// construction based on filesystem capabilities
+TEST_P(BlockBasedTableReaderTest, FSPrefetchSupportInitializedCorrectly) {
+  class ConfigurablePrefetchFS : public FileSystemWrapper {
+   public:
+    ConfigurablePrefetchFS(const std::shared_ptr<FileSystem>& target,
+                           bool support_prefetch)
+        : FileSystemWrapper(target), support_prefetch_(support_prefetch) {}
+
+    static const char* kClassName() { return "ConfigurablePrefetchFS"; }
+    const char* Name() const override { return kClassName(); }
+
+    void SupportedOps(int64_t& supported_ops) override {
+      target()->SupportedOps(supported_ops);
+      if (!support_prefetch_) {  // Disable prefetch support if requested
+        supported_ops &= ~(1 << FSSupportedOps::kFSPrefetch);
+      }
+    }
+
+   private:
+    bool support_prefetch_;
+  };
+
+  // Prepare test table
+  Options options;
+  options.persist_user_defined_timestamps = persist_udt_;
+  if (udt_enabled_) {
+    options.comparator = test::BytewiseComparatorWithU64TsWrapper();
+  }
+  size_t ts_sz = options.comparator->timestamp_size();
+  auto kv = BlockBasedTableReaderBaseTest::GenerateKVMap(5, true, ts_sz);
+  std::string table_name = "BlockBasedTableReaderTest_BlockPrefetcherTest" +
+                           CompressionTypeToString(compression_type_);
+  ImmutableOptions ioptions(options);
+  CreateTable(table_name, ioptions, compression_type_, kv,
+              compression_parallel_threads_, compression_dict_bytes_);
+
+  // Test Case 1: Filesystem supports prefetch, fs_prefetch_support should be
+  // true
+  {
+    auto fs_with_prefetch = std::make_shared<ConfigurablePrefetchFS>(
+        env_->GetFileSystem(), true /* support_prefetch */);
+    std::unique_ptr<Env> env_wrapper(
+        new CompositeEnvWrapper(env_, fs_with_prefetch));
+    options.env = env_wrapper.get();
+
+    FileOptions fopts;
+    fopts.use_direct_reads = use_direct_reads_;
+    InternalKeyComparator cmp(options.comparator);
+    ImmutableOptions iopts(options);
+
+    std::unique_ptr<BlockBasedTable> table;
+    NewBlockBasedTableReader(fopts, iopts, cmp, table_name, &table,
+                             false /* prefetch_index_and_filter_in_cache */,
+                             nullptr, persist_udt_);
+
+    ASSERT_TRUE(table->get_rep()->fs_prefetch_support);
+    ASSERT_TRUE(CheckFSFeatureSupport(fs_with_prefetch.get(),
+                                      FSSupportedOps::kFSPrefetch));
+  }
+
+  // Test Case 2: Filesystem doesn't support prefetch, fs_prefetch_support
+  // should be false
+  {
+    auto fs_without_prefetch = std::make_shared<ConfigurablePrefetchFS>(
+        env_->GetFileSystem(), false /* support_prefetch */);
+    std::unique_ptr<Env> env_wrapper(
+        new CompositeEnvWrapper(env_, fs_without_prefetch));
+    options.env = env_wrapper.get();
+
+    FileOptions fopts;
+    fopts.use_direct_reads = use_direct_reads_;
+    InternalKeyComparator cmp(options.comparator);
+    ImmutableOptions iopts(options);
+
+    std::unique_ptr<BlockBasedTable> table;
+    NewBlockBasedTableReader(fopts, iopts, cmp, table_name, &table,
+                             false /* prefetch_index_and_filter_in_cache */,
+                             nullptr, persist_udt_);
+
+    ASSERT_FALSE(table->get_rep()->fs_prefetch_support);
+    ASSERT_FALSE(CheckFSFeatureSupport(fs_without_prefetch.get(),
+                                       FSSupportedOps::kFSPrefetch));
+  }
+}
+std::vector<BlockBasedTableReaderTestParam> GenerateCombinedParameters(
+    const std::vector<CompressionType>& compression_types,
+    const std::vector<bool>& use_direct_read_flags,
+    const std::vector<BlockBasedTableOptions::IndexType>& index_types,
+    const std::vector<bool>& no_block_cache_flags,
+    const std::vector<test::UserDefinedTimestampTestMode>& udt_test_modes,
+    const std::vector<int>& parallel_compression_thread_counts,
+    const std::vector<uint32_t>& compression_dict_byte_counts,
+    const std::vector<bool>& same_key_diff_ts_flags,
+    const std::vector<const Comparator*>& comparators,
+    const std::vector<bool>& fill_cache_flags,
+    const std::vector<bool>& use_async_io_flags,
+    const std::vector<bool>& block_align_flags,
+    const std::vector<size_t>& super_block_alignment_sizes,
+    const std::vector<size_t>& super_block_alignment_space_overhead_ratios) {
+  std::vector<BlockBasedTableReaderTestParam> params;
+  for (const auto& compression_type : compression_types) {
+    for (auto use_direct_read : use_direct_read_flags) {
+      for (const auto& index_type : index_types) {
+        for (auto no_block_cache : no_block_cache_flags) {
+          for (const auto& udt_test_mode : udt_test_modes) {
+            for (auto parallel_compression_thread_count :
+                 parallel_compression_thread_counts) {
+              for (auto compression_dict_byte_count :
+                   compression_dict_byte_counts) {
+                for (auto same_key_diff_ts_flag : same_key_diff_ts_flags) {
+                  for (const auto& comparator : comparators) {
+                    for (auto fill_cache : fill_cache_flags) {
+                      for (auto use_async_io : use_async_io_flags) {
+                        for (auto block_align : block_align_flags) {
+                          for (auto super_block_alignment_size :
+                               super_block_alignment_sizes) {
+                            for (
+                                auto
+                                    super_block_alignment_space_overhead_ratio :
+                                super_block_alignment_space_overhead_ratios) {
+                              if (super_block_alignment_size == 0) {
+                                // Override padding size to 0 if alignment size
+                                // is 0, which means no super block alignment
+                                super_block_alignment_space_overhead_ratio = 0;
+                              }
+                              params.emplace_back(
+                                  compression_type, use_direct_read, index_type,
+                                  no_block_cache, udt_test_mode,
+                                  parallel_compression_thread_count,
+                                  compression_dict_byte_count,
+                                  same_key_diff_ts_flag, comparator, fill_cache,
+                                  use_async_io, block_align,
+                                  super_block_alignment_size,
+                                  super_block_alignment_space_overhead_ratio);
+                            }
+                          }
+                        }
+                      }
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+  return params;
+}
+
+std::vector<bool> Bool() { return {true, false}; }
+
+struct BlockBasedTableReaderTestParamBuilder {
+  BlockBasedTableReaderTestParamBuilder() {
+    // Default values
+    compression_types = GetSupportedCompressions();
+    use_direct_read_flags = Bool();
+    index_types = {
+        BlockBasedTableOptions::IndexType::kBinarySearch,
+        BlockBasedTableOptions::IndexType::kHashSearch,
+        BlockBasedTableOptions::IndexType::kTwoLevelIndexSearch,
+        BlockBasedTableOptions::IndexType::kBinarySearchWithFirstKey};
+    no_block_cache_flags = {false};
+    udt_test_modes = {
+        test::UserDefinedTimestampTestMode::kStripUserDefinedTimestamp};
+    parallel_compression_thread_counts = {1, 2};
+    compression_dict_byte_counts = {0, 4096};
+    same_key_diff_ts_flags = {false};
+    comparators = {BytewiseComparator()};
+    fill_cache_flags = {true};
+    use_async_io_flags = {false};
+    block_align_flags = {false};
+    super_block_alignment_sizes = {0};
+    super_block_alignment_space_overhead_ratios = {128};
+  }
+
+  // builder methods for each member
+  BlockBasedTableReaderTestParamBuilder& WithCompressionTypes(
+      const std::vector<CompressionType>& _compression_types) {
+    compression_types = _compression_types;
+    return *this;
+  }
+
+  BlockBasedTableReaderTestParamBuilder& WithUseDirectReadFlags(
+      const std::vector<bool>& _use_direct_read_flags) {
+    use_direct_read_flags = _use_direct_read_flags;
+    return *this;
+  }
+
+  BlockBasedTableReaderTestParamBuilder& WithIndexTypes(
+      const std::vector<BlockBasedTableOptions::IndexType>& _index_types) {
+    index_types = _index_types;
+    return *this;
+  }
+
+  BlockBasedTableReaderTestParamBuilder& WithNoBlockCacheFlags(
+      const std::vector<bool>& _no_block_cache_flags) {
+    no_block_cache_flags = _no_block_cache_flags;
+    return *this;
+  }
+
+  BlockBasedTableReaderTestParamBuilder& WithUDTTestModes(
+      const std::vector<test::UserDefinedTimestampTestMode>& _udt_test_modes) {
+    udt_test_modes = _udt_test_modes;
+    return *this;
+  }
+
+  BlockBasedTableReaderTestParamBuilder& WithParallelCompressionThreadCounts(
+      const std::vector<int>& _parallel_compression_thread_counts) {
+    parallel_compression_thread_counts = _parallel_compression_thread_counts;
+    return *this;
+  }
+
+  BlockBasedTableReaderTestParamBuilder& WithCompressionDictByteCounts(
+      const std::vector<uint32_t>& _compression_dict_byte_counts) {
+    compression_dict_byte_counts = _compression_dict_byte_counts;
+    return *this;
+  }
+
+  BlockBasedTableReaderTestParamBuilder& WithSameKeyDiffTsFlags(
+      const std::vector<bool>& _same_key_diff_ts_flags) {
+    same_key_diff_ts_flags = _same_key_diff_ts_flags;
+    return *this;
+  }
+
+  BlockBasedTableReaderTestParamBuilder& WithComparators(
+      const std::vector<const Comparator*>& _comparators) {
+    comparators = _comparators;
+    return *this;
+  }
+
+  BlockBasedTableReaderTestParamBuilder& WithFillCacheFlags(
+      const std::vector<bool>& _fill_cache_flags) {
+    fill_cache_flags = _fill_cache_flags;
+    return *this;
+  }
+
+  BlockBasedTableReaderTestParamBuilder& WithUseAsyncIoFlags(
+      const std::vector<bool>& _use_async_io_flags) {
+    use_async_io_flags = _use_async_io_flags;
+    return *this;
+  }
+
+  BlockBasedTableReaderTestParamBuilder& WithBlockAlignFlags(
+      const std::vector<bool>& _block_align_flags) {
+    block_align_flags = _block_align_flags;
+    return *this;
+  }
+
+  BlockBasedTableReaderTestParamBuilder& WithSuperBlockAlignmentSizes(
+      const std::vector<size_t>& _super_block_alignment_sizes) {
+    super_block_alignment_sizes = _super_block_alignment_sizes;
+    return *this;
+  }
+
+  BlockBasedTableReaderTestParamBuilder&
+  WithSuperBlockAlignmentSpaceOverheadRatios(
+      const std::vector<size_t>& _super_block_alignment_space_overhead_ratios) {
+    super_block_alignment_space_overhead_ratios =
+        _super_block_alignment_space_overhead_ratios;
+    return *this;
+  }
+
+  std::vector<BlockBasedTableReaderTestParam> build() {
+    return GenerateCombinedParameters(
+        compression_types, use_direct_read_flags, index_types,
+        no_block_cache_flags, udt_test_modes,
+        parallel_compression_thread_counts, compression_dict_byte_counts,
+        same_key_diff_ts_flags, comparators, fill_cache_flags,
+        use_async_io_flags, block_align_flags, super_block_alignment_sizes,
+        super_block_alignment_space_overhead_ratios);
+  }
+
+  std::vector<CompressionType> compression_types;
+  std::vector<bool> use_direct_read_flags;
+  std::vector<BlockBasedTableOptions::IndexType> index_types;
+  std::vector<bool> no_block_cache_flags;
+  std::vector<test::UserDefinedTimestampTestMode> udt_test_modes;
+  std::vector<int> parallel_compression_thread_counts;
+  std::vector<uint32_t> compression_dict_byte_counts;
+  std::vector<bool> same_key_diff_ts_flags;
+  std::vector<const Comparator*> comparators;
+  std::vector<bool> fill_cache_flags;
+  std::vector<bool> use_async_io_flags;
+  std::vector<bool> block_align_flags;
+  std::vector<size_t> super_block_alignment_sizes;
+  std::vector<size_t> super_block_alignment_space_overhead_ratios;
+};
+
+std::vector<bool> IOUringFlags() {
+#ifdef ROCKSDB_IOURING_PRESENT
+  return {false, true};
+#else
+  return {false};
+#endif
+}
+
 INSTANTIATE_TEST_CASE_P(
     BlockBasedTableReaderTest, BlockBasedTableReaderTest,
-    ::testing::Combine(
-        ::testing::ValuesIn(GetSupportedCompressions()), ::testing::Bool(),
-        ::testing::Values(
-            BlockBasedTableOptions::IndexType::kBinarySearch,
-            BlockBasedTableOptions::IndexType::kHashSearch,
-            BlockBasedTableOptions::IndexType::kTwoLevelIndexSearch,
-            BlockBasedTableOptions::IndexType::kBinarySearchWithFirstKey),
-        ::testing::Values(false), ::testing::ValuesIn(test::GetUDTTestModes()),
-        ::testing::Values(1, 2), ::testing::Values(0, 4096),
-        ::testing::Values(false),
-        ::testing::Values(BytewiseComparator(), ReverseBytewiseComparator())));
+    ::testing::ValuesIn(BlockBasedTableReaderTestParamBuilder()
+                            .WithUDTTestModes(test::GetUDTTestModes())
+                            .build()));
+
+INSTANTIATE_TEST_CASE_P(
+    BlockBasedTableReaderMultiScanAsyncIOTest,
+    BlockBasedTableReaderMultiScanAsyncIOTest,
+    ::testing::ValuesIn(BlockBasedTableReaderTestParamBuilder()
+                            .WithComparators({BytewiseComparator(),
+                                              ReverseBytewiseComparator()})
+                            .WithFillCacheFlags(Bool())
+                            .WithUseAsyncIoFlags(IOUringFlags())
+                            .build()));
+
+INSTANTIATE_TEST_CASE_P(
+    BlockBasedTableReaderMultiScanTest, BlockBasedTableReaderMultiScanTest,
+    ::testing::ValuesIn(BlockBasedTableReaderTestParamBuilder()
+                            .WithComparators({BytewiseComparator(),
+                                              ReverseBytewiseComparator()})
+                            .build()));
+
 INSTANTIATE_TEST_CASE_P(
     BlockBasedTableReaderGetTest, BlockBasedTableReaderGetTest,
-    ::testing::Combine(
-        ::testing::ValuesIn(GetSupportedCompressions()), ::testing::Bool(),
-        ::testing::Values(
-            BlockBasedTableOptions::IndexType::kBinarySearch,
-            BlockBasedTableOptions::IndexType::kHashSearch,
-            BlockBasedTableOptions::IndexType::kTwoLevelIndexSearch,
-            BlockBasedTableOptions::IndexType::kBinarySearchWithFirstKey),
-        ::testing::Values(false), ::testing::ValuesIn(test::GetUDTTestModes()),
-        ::testing::Values(1, 2), ::testing::Values(0, 4096),
-        ::testing::Values(false, true),
-        ::testing::Values(BytewiseComparator(), ReverseBytewiseComparator())));
+    ::testing::ValuesIn(BlockBasedTableReaderTestParamBuilder()
+                            .WithUDTTestModes(test::GetUDTTestModes())
+                            .WithSameKeyDiffTsFlags(Bool())
+                            .WithComparators({BytewiseComparator(),
+                                              ReverseBytewiseComparator()})
+                            .WithFillCacheFlags({false})
+                            .build()));
+
+INSTANTIATE_TEST_CASE_P(
+    BlockBasedTableReaderSuperBlockAlignTest, BlockBasedTableReaderGetTest,
+    ::testing::ValuesIn(
+        BlockBasedTableReaderTestParamBuilder()
+            .WithIndexTypes(
+                {BlockBasedTableOptions::IndexType::kBinarySearch,
+                 BlockBasedTableOptions::IndexType::kTwoLevelIndexSearch})
+            .WithFillCacheFlags({false})
+            .WithBlockAlignFlags(Bool())
+            .WithSuperBlockAlignmentSizes({0, 32 * 1024, 16 * 1024})
+            .WithSuperBlockAlignmentSpaceOverheadRatios({0, 4, 256})
+            .build()));
+
 INSTANTIATE_TEST_CASE_P(
     StrictCapacityLimitReaderTest, StrictCapacityLimitReaderTest,
-    ::testing::Combine(
-        ::testing::ValuesIn(GetSupportedCompressions()), ::testing::Bool(),
-        ::testing::Values(
-            BlockBasedTableOptions::IndexType::kTwoLevelIndexSearch),
-        ::testing::Values(false), ::testing::ValuesIn(test::GetUDTTestModes()),
-        ::testing::Values(1, 2), ::testing::Values(0),
-        ::testing::Values(false, true),
-        ::testing::Values(BytewiseComparator(), ReverseBytewiseComparator())));
+    ::testing::ValuesIn(
+        BlockBasedTableReaderTestParamBuilder()
+            .WithIndexTypes(
+                {BlockBasedTableOptions::IndexType::kTwoLevelIndexSearch})
+            .WithUDTTestModes(test::GetUDTTestModes())
+            .WithCompressionDictByteCounts({0})
+            .WithSameKeyDiffTsFlags(Bool())
+            .WithFillCacheFlags({false})
+            .build()));
+
 INSTANTIATE_TEST_CASE_P(
     VerifyChecksum, BlockBasedTableReaderTestVerifyChecksum,
-    ::testing::Combine(
-        ::testing::ValuesIn(GetSupportedCompressions()),
-        ::testing::Values(false),
-        ::testing::Values(
-            BlockBasedTableOptions::IndexType::kTwoLevelIndexSearch),
-        ::testing::Values(true), ::testing::ValuesIn(test::GetUDTTestModes()),
-        ::testing::Values(1, 2), ::testing::Values(0), ::testing::Values(false),
-        ::testing::Values(BytewiseComparator(), ReverseBytewiseComparator())));
-
+    ::testing::ValuesIn(
+        BlockBasedTableReaderTestParamBuilder()
+            .WithUseDirectReadFlags({false})
+            .WithIndexTypes(
+                {BlockBasedTableOptions::IndexType::kTwoLevelIndexSearch})
+            .WithNoBlockCacheFlags({true})
+            .WithUDTTestModes(test::GetUDTTestModes())
+            .WithCompressionDictByteCounts({0})
+            .WithFillCacheFlags({false})
+            .build()));
 }  // namespace ROCKSDB_NAMESPACE
 
 int main(int argc, char** argv) {