@nxtedition/rocksdb 8.1.2 → 8.1.4

package/deps/rocksdb/rocksdb/db/db_compaction_test.cc

@@ -9,10 +9,8 @@
 
 #include <tuple>
 
-#include "compaction/compaction_picker_universal.h"
 #include "db/blob/blob_index.h"
 #include "db/db_test_util.h"
-#include "db/dbformat.h"
 #include "env/mock_env.h"
 #include "port/port.h"
 #include "port/stack_trace.h"
@@ -1026,70 +1024,6 @@ TEST_F(DBCompactionTest, CompactionSstPartitioner) {
   ASSERT_EQ("B", Get("bbbb1"));
 }
 
-TEST_F(DBCompactionTest, CompactionSstPartitionWithManualCompaction) {
-  Options options = CurrentOptions();
-  options.compaction_style = kCompactionStyleLevel;
-  options.level0_file_num_compaction_trigger = 3;
-
-  DestroyAndReopen(options);
-
-  // create first file and flush to l0
-  ASSERT_OK(Put("000015", "A"));
-  ASSERT_OK(Put("000025", "B"));
-  ASSERT_OK(Flush());
-  ASSERT_OK(dbfull()->TEST_WaitForFlushMemTable());
-
-  // create second file and flush to l0
-  ASSERT_OK(Put("000015", "A2"));
-  ASSERT_OK(Put("000025", "B2"));
-  ASSERT_OK(Flush());
-  ASSERT_OK(dbfull()->TEST_WaitForFlushMemTable());
-
-  // CONTROL 1: compact without partitioner
-  CompactRangeOptions compact_options;
-  compact_options.bottommost_level_compaction =
-      BottommostLevelCompaction::kForceOptimized;
-  ASSERT_OK(dbfull()->CompactRange(CompactRangeOptions(), nullptr, nullptr));
-
-  // Check (compacted but no partitioning yet)
-  std::vector<LiveFileMetaData> files;
-  dbfull()->GetLiveFilesMetaData(&files);
-  ASSERT_EQ(1, files.size());
-
-  // Install partitioner
-  std::shared_ptr<SstPartitionerFactory> factory(
-      NewSstPartitionerFixedPrefixFactory(5));
-  options.sst_partitioner_factory = factory;
-  Reopen(options);
-
-  // CONTROL 2: request compaction on range with no partition boundary and no
-  // overlap with actual entries
-  Slice from("000017");
-  Slice to("000019");
-  ASSERT_OK(dbfull()->CompactRange(compact_options, &from, &to));
-
-  // Check (no partitioning yet)
-  files.clear();
-  dbfull()->GetLiveFilesMetaData(&files);
-  ASSERT_EQ(1, files.size());
-  ASSERT_EQ("A2", Get("000015"));
-  ASSERT_EQ("B2", Get("000025"));
-
-  // TEST: request compaction overlapping with partition boundary but no
-  // actual entries
-  // NOTE: `to` is INCLUSIVE
-  from = Slice("000019");
-  to = Slice("000020");
-  ASSERT_OK(dbfull()->CompactRange(compact_options, &from, &to));
-
-  // Check (must be partitioned)
-  files.clear();
-  dbfull()->GetLiveFilesMetaData(&files);
-  ASSERT_EQ(2, files.size());
-  ASSERT_EQ("A2", Get("000015"));
-  ASSERT_EQ("B2", Get("000025"));
-}
-
 TEST_F(DBCompactionTest, CompactionSstPartitionerNonTrivial) {
   Options options = CurrentOptions();
   options.compaction_style = kCompactionStyleLevel;
@@ -6245,231 +6179,6 @@ TEST_P(DBCompactionTestWithParam, FixFileIngestionCompactionDeadlock) {
   Close();
 }
 
-class DBCompactionTestWithOngoingFileIngestionParam
-    : public DBCompactionTest,
-      public testing::WithParamInterface<std::string> {
- public:
-  DBCompactionTestWithOngoingFileIngestionParam() : DBCompactionTest() {
-    compaction_path_to_test_ = GetParam();
-  }
-  void SetupOptions() {
-    options_ = CurrentOptions();
-    options_.create_if_missing = true;
-
-    if (compaction_path_to_test_ == "RefitLevelCompactRange") {
-      options_.num_levels = 7;
-    } else {
-      options_.num_levels = 3;
-    }
-    options_.compaction_style = CompactionStyle::kCompactionStyleLevel;
-    if (compaction_path_to_test_ == "AutoCompaction") {
-      options_.disable_auto_compactions = false;
-      options_.level0_file_num_compaction_trigger = 1;
-    } else {
-      options_.disable_auto_compactions = true;
-    }
-  }
-
-  void PauseCompactionThread() {
-    sleeping_task_.reset(new test::SleepingBackgroundTask());
-    env_->SetBackgroundThreads(1, Env::LOW);
-    env_->Schedule(&test::SleepingBackgroundTask::DoSleepTask,
-                   sleeping_task_.get(), Env::Priority::LOW);
-    sleeping_task_->WaitUntilSleeping();
-  }
-
-  void ResumeCompactionThread() {
-    if (sleeping_task_) {
-      sleeping_task_->WakeUp();
-      sleeping_task_->WaitUntilDone();
-    }
-  }
-
-  void SetupFilesToForceFutureFilesIngestedToCertainLevel() {
-    SstFileWriter sst_file_writer(EnvOptions(), options_);
-    std::string dummy = dbname_ + "/dummy.sst";
-    ASSERT_OK(sst_file_writer.Open(dummy));
-    ASSERT_OK(sst_file_writer.Put("k2", "dummy"));
-    ASSERT_OK(sst_file_writer.Finish());
-    ASSERT_OK(db_->IngestExternalFile({dummy}, IngestExternalFileOptions()));
-    // L2 is made to contain a file overlapped with files to be ingested in
-    // later steps on key "k2". This will force future files ingested to L1 or
-    // above.
-    ASSERT_EQ("0,0,1", FilesPerLevel(0));
-  }
-
-  void SetupSyncPoints() {
-    if (compaction_path_to_test_ == "AutoCompaction") {
-      SyncPoint::GetInstance()->SetCallBack(
-          "ExternalSstFileIngestionJob::Run", [&](void*) {
-            SyncPoint::GetInstance()->LoadDependency(
-                {{"DBImpl::BackgroundCompaction():AfterPickCompaction",
-                  "VersionSet::LogAndApply:WriteManifest"}});
-          });
-    } else if (compaction_path_to_test_ == "NonRefitLevelCompactRange") {
-      SyncPoint::GetInstance()->SetCallBack(
-          "ExternalSstFileIngestionJob::Run", [&](void*) {
-            SyncPoint::GetInstance()->LoadDependency(
-                {{"ColumnFamilyData::CompactRange:Return",
-                  "VersionSet::LogAndApply:WriteManifest"}});
-          });
-    } else if (compaction_path_to_test_ == "RefitLevelCompactRange") {
-      SyncPoint::GetInstance()->SetCallBack(
-          "ExternalSstFileIngestionJob::Run", [&](void*) {
-            SyncPoint::GetInstance()->LoadDependency(
-                {{"DBImpl::CompactRange:PostRefitLevel",
-                  "VersionSet::LogAndApply:WriteManifest"}});
-          });
-    } else if (compaction_path_to_test_ == "CompactFiles") {
-      SyncPoint::GetInstance()->SetCallBack(
-          "ExternalSstFileIngestionJob::Run", [&](void*) {
-            SyncPoint::GetInstance()->LoadDependency(
-                {{"DBImpl::CompactFilesImpl::PostSanitizeCompactionInputFiles",
-                  "VersionSet::LogAndApply:WriteManifest"}});
-          });
-    } else {
-      assert(false);
-    }
-    SyncPoint::GetInstance()->LoadDependency(
-        {{"ExternalSstFileIngestionJob::Run", "PreCompaction"}});
-    SyncPoint::GetInstance()->EnableProcessing();
-  }
-
-  void RunCompactionOverlappedWithFileIngestion() {
-    if (compaction_path_to_test_ == "AutoCompaction") {
-      TEST_SYNC_POINT("PreCompaction");
-      ResumeCompactionThread();
-      // Without proper range conflict check,
-      // this would have been `Status::Corruption` about overlapping ranges
-      Status s = dbfull()->TEST_WaitForCompact();
-      EXPECT_OK(s);
-    } else if (compaction_path_to_test_ == "NonRefitLevelCompactRange") {
-      CompactRangeOptions cro;
-      cro.change_level = false;
-      std::string start_key = "k1";
-      Slice start(start_key);
-      std::string end_key = "k4";
-      Slice end(end_key);
-      TEST_SYNC_POINT("PreCompaction");
-      // Without proper range conflict check,
-      // this would have been `Status::Corruption` about overlapping ranges
-      Status s = dbfull()->CompactRange(cro, &start, &end);
-      EXPECT_OK(s);
-    } else if (compaction_path_to_test_ == "RefitLevelCompactRange") {
-      CompactRangeOptions cro;
-      cro.change_level = true;
-      cro.target_level = 5;
-      std::string start_key = "k1";
-      Slice start(start_key);
-      std::string end_key = "k4";
-      Slice end(end_key);
-      TEST_SYNC_POINT("PreCompaction");
-      Status s = dbfull()->CompactRange(cro, &start, &end);
-      // Without proper range conflict check,
-      // this would have been `Status::Corruption` about overlapping ranges
-      // To see this, remove the fix AND replace
-      // `DBImpl::CompactRange:PostRefitLevel` in sync point dependency with
-      // `DBImpl::ReFitLevel:PostRegisterCompaction`
-      EXPECT_TRUE(s.IsNotSupported());
-      EXPECT_TRUE(s.ToString().find("some ongoing compaction's output") !=
-                  std::string::npos);
-    } else if (compaction_path_to_test_ == "CompactFiles") {
-      ColumnFamilyMetaData cf_meta_data;
-      db_->GetColumnFamilyMetaData(&cf_meta_data);
-      ASSERT_EQ(cf_meta_data.levels[0].files.size(), 1);
-      std::vector<std::string> input_files;
-      for (const auto& file : cf_meta_data.levels[0].files) {
-        input_files.push_back(file.name);
-      }
-      TEST_SYNC_POINT("PreCompaction");
-      Status s = db_->CompactFiles(CompactionOptions(), input_files, 1);
-      // Without proper range conflict check,
-      // this would have been `Status::Corruption` about overlapping ranges
-      EXPECT_TRUE(s.IsAborted());
-      EXPECT_TRUE(
-          s.ToString().find(
-              "A running compaction is writing to the same output level") !=
-          std::string::npos);
-    } else {
-      assert(false);
-    }
-  }
-
-  void DisableSyncPoints() {
-    ROCKSDB_NAMESPACE::SyncPoint::GetInstance()->ClearAllCallBacks();
-    ROCKSDB_NAMESPACE::SyncPoint::GetInstance()->DisableProcessing();
-  }
-
- protected:
-  std::string compaction_path_to_test_;
-  Options options_;
-  std::shared_ptr<test::SleepingBackgroundTask> sleeping_task_;
-};
-
-INSTANTIATE_TEST_CASE_P(DBCompactionTestWithOngoingFileIngestionParam,
-                        DBCompactionTestWithOngoingFileIngestionParam,
-                        ::testing::Values("AutoCompaction",
-                                          "NonRefitLevelCompactRange",
-                                          "RefitLevelCompactRange",
-                                          "CompactFiles"));
-
-TEST_P(DBCompactionTestWithOngoingFileIngestionParam, RangeConflictCheck) {
-  SetupOptions();
-  DestroyAndReopen(options_);
-
-  if (compaction_path_to_test_ == "AutoCompaction") {
-    PauseCompactionThread();
-  }
-
-  if (compaction_path_to_test_ != "RefitLevelCompactRange") {
-    SetupFilesToForceFutureFilesIngestedToCertainLevel();
-  }
-
-  // Create s1
-  ASSERT_OK(Put("k1", "v"));
-  ASSERT_OK(Put("k4", "v"));
-  ASSERT_OK(Flush());
-  if (compaction_path_to_test_ == "RefitLevelCompactRange") {
-    MoveFilesToLevel(6 /* level */);
-    ASSERT_EQ("0,0,0,0,0,0,1", FilesPerLevel(0));
-  } else {
-    ASSERT_EQ("1,0,1", FilesPerLevel(0));
-  }
-
-  // To coerce following sequence of events
-  // Timeline   Thread 1 (Ingest s2)          Thread 2 (Compact s1)
-  // t0   |     Decide to output to Lk
-  // t1   |     Release lock in LogAndApply()
-  // t2   |                                    Acquire lock
-  // t3   |                                    Decides to compact to Lk
-  //      |                                    Expected to fail due to range
-  //      |                                    conflict check with file
-  //      |                                    ingestion
-  // t4   |                                    Release lock in LogAndApply()
-  // t5   |    Acquire lock again and finish
-  // t6   |                                    Acquire lock again and finish
-  SetupSyncPoints();
-
-  // Ingest s2
-  port::Thread thread1([&] {
-    SstFileWriter sst_file_writer(EnvOptions(), options_);
-    std::string s2 = dbname_ + "/ingested_s2.sst";
-    ASSERT_OK(sst_file_writer.Open(s2));
-    ASSERT_OK(sst_file_writer.Put("k2", "v2"));
-    ASSERT_OK(sst_file_writer.Put("k3", "v2"));
-    ASSERT_OK(sst_file_writer.Finish());
-    ASSERT_OK(db_->IngestExternalFile({s2}, IngestExternalFileOptions()));
-  });
-
-  // Compact s1. Without proper range conflict check,
-  // this will encounter overlapping file corruption.
-  port::Thread thread2([&] { RunCompactionOverlappedWithFileIngestion(); });
-
-  thread1.join();
-  thread2.join();
-  DisableSyncPoints();
-}
-
 TEST_F(DBCompactionTest, ConsistencyFailTest) {
   Options options = CurrentOptions();
   options.force_consistency_checks = true;
@@ -6562,655 +6271,172 @@ void IngestOneKeyValue(DBImpl* db, const std::string& key,
   ASSERT_OK(db->IngestExternalFile({info.file_path}, ingest_opt));
 }
 
-class DBCompactionTestL0FilesMisorderCorruption : public DBCompactionTest {
- public:
-  DBCompactionTestL0FilesMisorderCorruption() : DBCompactionTest() {}
-  void SetupOptions(const CompactionStyle compaciton_style,
-                    const std::string& compaction_path_to_test = "") {
-    options_ = CurrentOptions();
-    options_.create_if_missing = true;
-    options_.compression = kNoCompression;
-
-    options_.force_consistency_checks = true;
-    options_.compaction_style = compaciton_style;
-
-    if (compaciton_style == CompactionStyle::kCompactionStyleLevel) {
-      options_.num_levels = 7;
-      // Level compaction's PickIntraL0Compaction() impl detail requires
-      // `options.level0_file_num_compaction_trigger` to be
-      // at least 2 files less than the actual number of level 0 files
-      // (i.e, 7 by design in this test)
-      options_.level0_file_num_compaction_trigger = 5;
-      options_.max_background_compactions = 2;
-      options_.write_buffer_size = 2 << 20;
-      options_.max_write_buffer_number = 6;
-    } else if (compaciton_style == CompactionStyle::kCompactionStyleUniversal) {
-      // TODO: expand test coverage to num_lvels > 1 for universal compacion,
-      // which requires careful unit test design to compact to level 0 despite
-      // num_levels > 1
-      options_.num_levels = 1;
-      options_.level0_file_num_compaction_trigger = 5;
-
-      CompactionOptionsUniversal universal_options;
-      if (compaction_path_to_test == "PickCompactionToReduceSizeAmp") {
-        universal_options.max_size_amplification_percent = 50;
-      } else if (compaction_path_to_test ==
-                 "PickCompactionToReduceSortedRuns") {
-        universal_options.max_size_amplification_percent = 400;
-      } else if (compaction_path_to_test == "PickDeleteTriggeredCompaction") {
-        universal_options.max_size_amplification_percent = 400;
-        universal_options.min_merge_width = 6;
-      }
-      options_.compaction_options_universal = universal_options;
-    } else if (compaciton_style == CompactionStyle::kCompactionStyleFIFO) {
-      options_.max_open_files = -1;
-      options_.num_levels = 1;
-      options_.level0_file_num_compaction_trigger = 3;
-
-      CompactionOptionsFIFO fifo_options;
-      if (compaction_path_to_test == "FindIntraL0Compaction" ||
-          compaction_path_to_test == "CompactRange") {
-        fifo_options.allow_compaction = true;
-        fifo_options.age_for_warm = 0;
-      } else if (compaction_path_to_test == "CompactFile") {
-        fifo_options.allow_compaction = false;
-        fifo_options.age_for_warm = 0;
-      }
-      options_.compaction_options_fifo = fifo_options;
-    }
-
-    if (compaction_path_to_test == "CompactFile" ||
-        compaction_path_to_test == "CompactRange") {
-      options_.disable_auto_compactions = true;
-    } else {
-      options_.disable_auto_compactions = false;
-    }
-  }
-
-  void Destroy(const Options& options) {
-    if (snapshot_) {
-      assert(db_);
-      db_->ReleaseSnapshot(snapshot_);
-      snapshot_ = nullptr;
-    }
-    DBTestBase::Destroy(options);
-  }
-
-  void Reopen(const Options& options) {
-    DBTestBase::Reopen(options);
-    if (options.compaction_style != CompactionStyle::kCompactionStyleLevel) {
-      // To force assigning the global seqno to ingested file
-      // for our test purpose.
-      assert(snapshot_ == nullptr);
-      snapshot_ = db_->GetSnapshot();
-    }
-  }
-
-  void DestroyAndReopen(Options& options) {
-    Destroy(options);
-    Reopen(options);
-  }
-
-  void PauseCompactionThread() {
-    sleeping_task_.reset(new test::SleepingBackgroundTask());
-    env_->SetBackgroundThreads(1, Env::LOW);
-    env_->Schedule(&test::SleepingBackgroundTask::DoSleepTask,
-                   sleeping_task_.get(), Env::Priority::LOW);
-    sleeping_task_->WaitUntilSleeping();
-  }
-
-  void ResumeCompactionThread() {
-    if (sleeping_task_) {
-      sleeping_task_->WakeUp();
-      sleeping_task_->WaitUntilDone();
-    }
-  }
+TEST_P(DBCompactionTestWithParam,
+       FlushAfterIntraL0CompactionCheckConsistencyFail) {
+  Options options = CurrentOptions();
+  options.force_consistency_checks = true;
+  options.compression = kNoCompression;
+  options.level0_file_num_compaction_trigger = 5;
+  options.max_background_compactions = 2;
+  options.max_subcompactions = max_subcompactions_;
+  DestroyAndReopen(options);
 
-  void AddFilesMarkedForPeriodicCompaction(const size_t num_files) {
-    assert(options_.compaction_style ==
-           CompactionStyle::kCompactionStyleUniversal);
-    VersionSet* const versions = dbfull()->GetVersionSet();
-    assert(versions);
-    ColumnFamilyData* const cfd = versions->GetColumnFamilySet()->GetDefault();
-    assert(cfd);
-    Version* const current = cfd->current();
-    assert(current);
+  const size_t kValueSize = 1 << 20;
+  Random rnd(301);
+  std::atomic<int> pick_intra_l0_count(0);
+  std::string value(rnd.RandomString(kValueSize));
 
-    VersionStorageInfo* const storage_info = current->storage_info();
-    assert(storage_info);
+  // The L0->L1 must be picked before we begin ingesting files to trigger
+  // intra-L0 compaction, and must not finish until after an intra-L0
+  // compaction has been picked.
+  ROCKSDB_NAMESPACE::SyncPoint::GetInstance()->LoadDependency(
+      {{"LevelCompactionPicker::PickCompaction:Return",
+        "DBCompactionTestWithParam::"
+        "FlushAfterIntraL0CompactionCheckConsistencyFail:L0ToL1Ready"},
+       {"LevelCompactionPicker::PickCompactionBySize:0",
+        "CompactionJob::Run():Start"}});
+  ROCKSDB_NAMESPACE::SyncPoint::GetInstance()->SetCallBack(
+      "FindIntraL0Compaction",
+      [&](void* /*arg*/) { pick_intra_l0_count.fetch_add(1); });
 
-    const std::vector<FileMetaData*> level0_files = storage_info->LevelFiles(0);
-    assert(level0_files.size() == num_files);
+  ROCKSDB_NAMESPACE::SyncPoint::GetInstance()->EnableProcessing();
 
-    for (FileMetaData* f : level0_files) {
-      storage_info->TEST_AddFileMarkedForPeriodicCompaction(0, f);
-    }
+  // prevents trivial move
+  for (int i = 0; i < 10; ++i) {
+    ASSERT_OK(Put(Key(i), ""));  // prevents trivial move
   }
+  ASSERT_OK(Flush());
+  Compact("", Key(99));
+  ASSERT_EQ(0, NumTableFilesAtLevel(0));
 
-  void AddFilesMarkedForCompaction(const size_t num_files) {
-    assert(options_.compaction_style ==
-           CompactionStyle::kCompactionStyleUniversal);
-    VersionSet* const versions = dbfull()->GetVersionSet();
-    assert(versions);
-    ColumnFamilyData* const cfd = versions->GetColumnFamilySet()->GetDefault();
-    assert(cfd);
-    Version* const current = cfd->current();
-    assert(current);
-
-    VersionStorageInfo* const storage_info = current->storage_info();
-    assert(storage_info);
-
-    const std::vector<FileMetaData*> level0_files = storage_info->LevelFiles(0);
-    assert(level0_files.size() == num_files);
-
-    for (FileMetaData* f : level0_files) {
-      storage_info->TEST_AddFileMarkedForCompaction(0, f);
-    }
+  // Flush 5 L0 sst.
+  for (int i = 0; i < 5; ++i) {
+    ASSERT_OK(Put(Key(i + 1), value));
+    ASSERT_OK(Flush());
   }
+  ASSERT_EQ(5, NumTableFilesAtLevel(0));
 
-  void SetupSyncPoints(const std::string& compaction_path_to_test) {
-    compaction_path_sync_point_called_.store(false);
-    if (compaction_path_to_test == "FindIntraL0Compaction" &&
-        options_.compaction_style == CompactionStyle::kCompactionStyleLevel) {
-      ROCKSDB_NAMESPACE::SyncPoint::GetInstance()->SetCallBack(
-          "PostPickFileToCompact", [&](void* arg) {
-            bool* picked_file_to_compact = (bool*)arg;
-            // To trigger intra-L0 compaction specifically,
-            // we mock PickFileToCompact()'s result to be false
-            *picked_file_to_compact = false;
-          });
-      ROCKSDB_NAMESPACE::SyncPoint::GetInstance()->SetCallBack(
-          "FindIntraL0Compaction", [&](void* /*arg*/) {
-            compaction_path_sync_point_called_.store(true);
-          });
-
-    } else if (compaction_path_to_test == "PickPeriodicCompaction") {
-      assert(options_.compaction_style ==
-             CompactionStyle::kCompactionStyleUniversal);
-      ROCKSDB_NAMESPACE::SyncPoint::GetInstance()->SetCallBack(
-          "PostPickPeriodicCompaction", [&](void* compaction_arg) {
-            Compaction* compaction = (Compaction*)compaction_arg;
-            if (compaction != nullptr) {
-              compaction_path_sync_point_called_.store(true);
-            }
-          });
-    } else if (compaction_path_to_test == "PickCompactionToReduceSizeAmp") {
-      assert(options_.compaction_style ==
-             CompactionStyle::kCompactionStyleUniversal);
-      ROCKSDB_NAMESPACE::SyncPoint::GetInstance()->SetCallBack(
-          "PickCompactionToReduceSizeAmpReturnNonnullptr", [&](void* /*arg*/) {
-            compaction_path_sync_point_called_.store(true);
-          });
-    } else if (compaction_path_to_test == "PickCompactionToReduceSortedRuns") {
-      assert(options_.compaction_style ==
-             CompactionStyle::kCompactionStyleUniversal);
-      ROCKSDB_NAMESPACE::SyncPoint::GetInstance()->SetCallBack(
-          "PickCompactionToReduceSortedRunsReturnNonnullptr",
-          [&](void* /*arg*/) {
-            compaction_path_sync_point_called_.store(true);
-          });
-    } else if (compaction_path_to_test == "PickDeleteTriggeredCompaction") {
-      assert(options_.compaction_style ==
-             CompactionStyle::kCompactionStyleUniversal);
-      ROCKSDB_NAMESPACE::SyncPoint::GetInstance()->SetCallBack(
-          "PickDeleteTriggeredCompactionReturnNonnullptr", [&](void* /*arg*/) {
-            compaction_path_sync_point_called_.store(true);
-          });
-    } else if ((compaction_path_to_test == "FindIntraL0Compaction" ||
-                compaction_path_to_test == "CompactRange") &&
-               options_.compaction_style ==
-                   CompactionStyle::kCompactionStyleFIFO) {
-      ROCKSDB_NAMESPACE::SyncPoint::GetInstance()->SetCallBack(
-          "FindIntraL0Compaction", [&](void* /*arg*/) {
-            compaction_path_sync_point_called_.store(true);
-          });
-    }
-
-    ROCKSDB_NAMESPACE::SyncPoint::GetInstance()->EnableProcessing();
-  }
+  // Put one key, to make smallest log sequence number in this memtable is less
+  // than sst which would be ingested in next step.
+  ASSERT_OK(Put(Key(0), "a"));
 
-  bool SyncPointsCalled() { return compaction_path_sync_point_called_.load(); }
+  ASSERT_EQ(5, NumTableFilesAtLevel(0));
+  TEST_SYNC_POINT(
+      "DBCompactionTestWithParam::"
+      "FlushAfterIntraL0CompactionCheckConsistencyFail:L0ToL1Ready");
 
-  void DisableSyncPoints() {
-    ROCKSDB_NAMESPACE::SyncPoint::GetInstance()->ClearAllCallBacks();
-    ROCKSDB_NAMESPACE::SyncPoint::GetInstance()->DisableProcessing();
+  // Ingest 5 L0 sst. And this files would trigger PickIntraL0Compaction.
+  for (int i = 5; i < 10; i++) {
+    ASSERT_EQ(i, NumTableFilesAtLevel(0));
+    IngestOneKeyValue(dbfull(), Key(i), value, options);
   }
 
-  // Return the largest seqno of the latest L0 file based on file number
-  SequenceNumber GetLatestL0FileLargestSeqnoHelper() {
-    VersionSet* const versions = dbfull()->GetVersionSet();
-    assert(versions);
-    ColumnFamilyData* const cfd = versions->GetColumnFamilySet()->GetDefault();
-    assert(cfd);
-    Version* const current = cfd->current();
-    assert(current);
-    VersionStorageInfo* const storage_info = current->storage_info();
-    assert(storage_info);
-    const std::vector<FileMetaData*> level0_files = storage_info->LevelFiles(0);
-    assert(level0_files.size() >= 1);
-
-    uint64_t latest_file_num = 0;
-    uint64_t latest_file_largest_seqno = 0;
-    for (FileMetaData* f : level0_files) {
-      if (f->fd.GetNumber() > latest_file_num) {
-        latest_file_num = f->fd.GetNumber();
-        latest_file_largest_seqno = f->fd.largest_seqno;
-      }
-    }
+  // Put one key, to make biggest log sequence number in this memtable is bigger
+  // than sst which would be ingested in next step.
+  ASSERT_OK(Put(Key(2), "b"));
+  ASSERT_OK(dbfull()->TEST_WaitForCompact());
+  ROCKSDB_NAMESPACE::SyncPoint::GetInstance()->DisableProcessing();
+  std::vector<std::vector<FileMetaData>> level_to_files;
+  dbfull()->TEST_GetFilesMetaData(dbfull()->DefaultColumnFamily(),
+                                  &level_to_files);
+  ASSERT_GT(level_to_files[0].size(), 0);
+  ASSERT_GT(pick_intra_l0_count.load(), 0);
 
-    return latest_file_largest_seqno;
-  }
+  ASSERT_OK(Flush());
+}
 
- protected:
-  Options options_;
+TEST_P(DBCompactionTestWithParam,
+       IntraL0CompactionAfterFlushCheckConsistencyFail) {
+  Options options = CurrentOptions();
+  options.force_consistency_checks = true;
+  options.compression = kNoCompression;
+  options.level0_file_num_compaction_trigger = 5;
+  options.max_background_compactions = 2;
+  options.max_subcompactions = max_subcompactions_;
+  options.write_buffer_size = 2 << 20;
+  options.max_write_buffer_number = 6;
+  DestroyAndReopen(options);
 
- private:
-  const Snapshot* snapshot_ = nullptr;
-  std::atomic<bool> compaction_path_sync_point_called_;
-  std::shared_ptr<test::SleepingBackgroundTask> sleeping_task_;
-};
+  const size_t kValueSize = 1 << 20;
+  Random rnd(301);
+  std::string value(rnd.RandomString(kValueSize));
+  std::string value2(rnd.RandomString(kValueSize));
+  std::string bigvalue = value + value;
 
-TEST_F(DBCompactionTestL0FilesMisorderCorruption,
-       FlushAfterIntraL0LevelCompactionWithIngestedFile) {
-  SetupOptions(CompactionStyle::kCompactionStyleLevel, "");
-  DestroyAndReopen(options_);
-  // Prevents trivial move
+  // prevents trivial move
   for (int i = 0; i < 10; ++i) {
-    ASSERT_OK(Put(Key(i), ""));  // Prevents trivial move
+    ASSERT_OK(Put(Key(i), ""));  // prevents trivial move
   }
   ASSERT_OK(Flush());
   Compact("", Key(99));
   ASSERT_EQ(0, NumTableFilesAtLevel(0));
 
-  // To get accurate NumTableFilesAtLevel(0) when the number reaches
-  // options_.level0_file_num_compaction_trigger
-  PauseCompactionThread();
-
-  // To create below LSM tree
-  // (key:value@n indicates key-value pair has seqno "n", L0 is sorted):
-  //
-  // memtable: m1[              5:new@12 ..      1:new@8,    0:new@7]
-  //       L0: s6[6:new@13], s5[5:old@6] ...  s1[1:old@2],s0[0:old@1]
-  //
-  // (1) Make 6 L0 sst (i.e, s0 - s5)
+  std::atomic<int> pick_intra_l0_count(0);
+  // The L0->L1 must be picked before we begin ingesting files to trigger
+  // intra-L0 compaction, and must not finish until after an intra-L0
+  // compaction has been picked.
+  ROCKSDB_NAMESPACE::SyncPoint::GetInstance()->LoadDependency(
+      {{"LevelCompactionPicker::PickCompaction:Return",
+        "DBCompactionTestWithParam::"
+        "IntraL0CompactionAfterFlushCheckConsistencyFail:L0ToL1Ready"},
+       {"LevelCompactionPicker::PickCompactionBySize:0",
+        "CompactionJob::Run():Start"}});
+  ROCKSDB_NAMESPACE::SyncPoint::GetInstance()->SetCallBack(
+      "FindIntraL0Compaction",
+      [&](void* /*arg*/) { pick_intra_l0_count.fetch_add(1); });
+  ROCKSDB_NAMESPACE::SyncPoint::GetInstance()->EnableProcessing();
+  // Make 6 L0 sst.
   for (int i = 0; i < 6; ++i) {
     if (i % 2 == 0) {
-      IngestOneKeyValue(dbfull(), Key(i), "old", options_);
+      IngestOneKeyValue(dbfull(), Key(i), value, options);
     } else {
-      ASSERT_OK(Put(Key(i), "old"));
+      ASSERT_OK(Put(Key(i), value));
       ASSERT_OK(Flush());
     }
   }
+
   ASSERT_EQ(6, NumTableFilesAtLevel(0));
 
-  // (2) Create m1
+  // Stop run flush job
+  env_->SetBackgroundThreads(1, Env::HIGH);
+  test::SleepingBackgroundTask sleeping_tasks;
+  env_->Schedule(&test::SleepingBackgroundTask::DoSleepTask, &sleeping_tasks,
+                 Env::Priority::HIGH);
+  sleeping_tasks.WaitUntilSleeping();
+
+  // Put many keys to make memtable request to flush
   for (int i = 0; i < 6; ++i) {
-    ASSERT_OK(Put(Key(i), "new"));
+    ASSERT_OK(Put(Key(i), bigvalue));
   }
-  ASSERT_EQ(6, NumTableFilesAtLevel(0));
 
-  // (3) Ingest file (i.e, s6) to trigger IntraL0Compaction()
-  for (int i = 6; i < 7; ++i) {
+  ASSERT_EQ(6, NumTableFilesAtLevel(0));
+  TEST_SYNC_POINT(
+      "DBCompactionTestWithParam::"
+      "IntraL0CompactionAfterFlushCheckConsistencyFail:L0ToL1Ready");
+  // ingest file to trigger IntraL0Compaction
+  for (int i = 6; i < 10; ++i) {
     ASSERT_EQ(i, NumTableFilesAtLevel(0));
-    IngestOneKeyValue(dbfull(), Key(i), "new", options_);
+    IngestOneKeyValue(dbfull(), Key(i), value2, options);
   }
 
-  SetupSyncPoints("FindIntraL0Compaction");
-  ResumeCompactionThread();
-
+  // Wake up flush job
+  sleeping_tasks.WakeUp();
+  sleeping_tasks.WaitUntilDone();
   ASSERT_OK(dbfull()->TEST_WaitForCompact());
+  ROCKSDB_NAMESPACE::SyncPoint::GetInstance()->DisableProcessing();
 
-  ASSERT_TRUE(SyncPointsCalled());
-  DisableSyncPoints();
-
-  // After compaction, we have LSM tree:
-  //
-  // memtable: m1[          5:new@12 ..     1:new@8,  0:new@7]
-  //       L0: s7[6:new@13, 5:old@6 ..                0:old@1]
-  ASSERT_EQ(1, NumTableFilesAtLevel(0));
-  SequenceNumber compact_output_file_largest_seqno =
-      GetLatestL0FileLargestSeqnoHelper();
-
-  ASSERT_OK(Flush());
-  // After flush, we have LSM tree:
-  //
-  // L0: s8[5:new@12 .. 0:new@7],s7[6:new@13, 5:old@5 .. 0:old@1]
-  ASSERT_EQ(2, NumTableFilesAtLevel(0));
-  SequenceNumber flushed_file_largest_seqno =
-      GetLatestL0FileLargestSeqnoHelper();
-
-  // To verify there isn't any file misorder leading to returning a old value
-  // of Key(0) - Key(5) , which is caused by flushed table s8 has a
-  // smaller largest seqno than the compaction output file s7's largest seqno
-  // while the flushed table has the newer version of the values than the
-  // compaction output file's.
-  ASSERT_TRUE(flushed_file_largest_seqno < compact_output_file_largest_seqno);
+  uint64_t error_count = 0;
+  db_->GetIntProperty("rocksdb.background-errors", &error_count);
+  ASSERT_EQ(error_count, 0);
+  ASSERT_GT(pick_intra_l0_count.load(), 0);
   for (int i = 0; i < 6; ++i) {
-    ASSERT_EQ("new", Get(Key(i)));
+    ASSERT_EQ(bigvalue, Get(Key(i)));
   }
-  for (int i = 6; i < 7; ++i) {
-    ASSERT_EQ("new", Get(Key(i)));
+  for (int i = 6; i < 10; ++i) {
+    ASSERT_EQ(value2, Get(Key(i)));
   }
 }
 
-TEST_F(DBCompactionTestL0FilesMisorderCorruption,
-       FlushAfterIntraL0UniversalCompactionWithIngestedFile) {
-  for (const std::string compaction_path_to_test :
-       {"PickPeriodicCompaction", "PickCompactionToReduceSizeAmp",
-        "PickCompactionToReduceSortedRuns", "PickDeleteTriggeredCompaction"}) {
-    SetupOptions(CompactionStyle::kCompactionStyleUniversal,
-                 compaction_path_to_test);
-    DestroyAndReopen(options_);
-
-    // To get accurate NumTableFilesAtLevel(0) when the number reaches
-    // options_.level0_file_num_compaction_trigger
-    PauseCompactionThread();
-
-    // To create below LSM tree
-    // (key:value@n indicates key-value pair has seqno "n", L0 is sorted):
-    //
-    // memtable: m1 [                  k2:new@8, k1:new@7]
-    // L0: s4[k9:dummy@10], s3[k8:dummy@9],
-    //     s2[k7:old@6, k6:old@5].. s0[k3:old@2, k1:old@1]
-    //
-    // (1) Create 3 existing SST file (i.e, s0 - s2)
-    ASSERT_OK(Put("k1", "old"));
-    ASSERT_OK(Put("k3", "old"));
-    ASSERT_OK(Flush());
-    ASSERT_EQ(1, NumTableFilesAtLevel(0));
-    ASSERT_OK(Put("k4", "old"));
-    ASSERT_OK(Put("k5", "old"));
-    ASSERT_OK(Flush());
-    ASSERT_EQ(2, NumTableFilesAtLevel(0));
-    ASSERT_OK(Put("k6", "old"));
-    ASSERT_OK(Put("k7", "old"));
-    ASSERT_OK(Flush());
-    ASSERT_EQ(3, NumTableFilesAtLevel(0));
-
-    // (2) Create m1. Noted that it contains a overlaped key with s0
-    ASSERT_OK(Put("k1", "new"));  // overlapped key
-    ASSERT_OK(Put("k2", "new"));
-
-    // (3) Ingest two SST files s3, s4
-    IngestOneKeyValue(dbfull(), "k8", "dummy", options_);
-    IngestOneKeyValue(dbfull(), "k9", "dummy", options_);
-    // Up to now, L0 contains s0 - s4
-    ASSERT_EQ(5, NumTableFilesAtLevel(0));
-
-    if (compaction_path_to_test == "PickPeriodicCompaction") {
-      AddFilesMarkedForPeriodicCompaction(5);
-    } else if (compaction_path_to_test == "PickDeleteTriggeredCompaction") {
-      AddFilesMarkedForCompaction(5);
-    }
-
-    SetupSyncPoints(compaction_path_to_test);
-    ResumeCompactionThread();
-
-    ASSERT_OK(dbfull()->TEST_WaitForCompact());
-
-    ASSERT_TRUE(SyncPointsCalled())
-        << "failed for compaction path to test: " << compaction_path_to_test;
-    DisableSyncPoints();
-
-    // After compaction, we have LSM tree:
-    //
-    // memtable: m1[                                     k2:new@8, k1:new@7]
-    //       L0: s5[k9:dummy@10, k8@dummy@9, k7:old@6 .. k3:old@2, k1:old@1]
-    ASSERT_EQ(1, NumTableFilesAtLevel(0))
-        << "failed for compaction path to test: " << compaction_path_to_test;
-    SequenceNumber compact_output_file_largest_seqno =
-        GetLatestL0FileLargestSeqnoHelper();
-
-    ASSERT_OK(Flush()) << "failed for compaction path to test: "
-                       << compaction_path_to_test;
-    // After flush, we have LSM tree:
-    //
-    // L0: s6[k2:new@8, k1:new@7],
-    //     s5[k9:dummy@10, k8@dummy@9, k7:old@6 .. k3:old@2, k1:old@1]
-    ASSERT_EQ(2, NumTableFilesAtLevel(0))
-        << "failed for compaction path to test: " << compaction_path_to_test;
-    SequenceNumber flushed_file_largest_seqno =
-        GetLatestL0FileLargestSeqnoHelper();
-
-    // To verify there isn't any file misorder leading to returning a old
-    // value of "k1" , which is caused by flushed table s6 has a
-    // smaller largest seqno than the compaction output file s5's largest seqno
-    // while the flushed table has the newer version of the value
-    // than the compaction output file's.
-    ASSERT_TRUE(flushed_file_largest_seqno < compact_output_file_largest_seqno)
-        << "failed for compaction path to test: " << compaction_path_to_test;
-    EXPECT_EQ(Get("k1"), "new")
-        << "failed for compaction path to test: " << compaction_path_to_test;
-  }
-
-  Destroy(options_);
-}
-
-TEST_F(DBCompactionTestL0FilesMisorderCorruption,
-       FlushAfterIntraL0FIFOCompactionWithIngestedFile) {
-  for (const std::string compaction_path_to_test : {"FindIntraL0Compaction"}) {
-    SetupOptions(CompactionStyle::kCompactionStyleFIFO,
-                 compaction_path_to_test);
-    DestroyAndReopen(options_);
-
-    // To create below LSM tree
-    // (key:value@n indicates key-value pair has seqno "n", L0 is sorted):
-    //
-    // memtable: m1 [                         k2:new@4, k1:new@3]
-    // L0: s2[k5:dummy@6], s1[k4:dummy@5], s0[k3:old@2, k1:old@1]
-    //
-    // (1) Create an existing SST file s0
-    ASSERT_OK(Put("k1", "old"));
-    ASSERT_OK(Put("k3", "old"));
-    ASSERT_OK(Flush());
-    ASSERT_EQ(1, NumTableFilesAtLevel(0));
-
-    // (2) Create memtable m1. Noted that it contains a overlaped key with s0
-    ASSERT_OK(Put("k1", "new"));  // overlapped key
-    ASSERT_OK(Put("k2", "new"));
-
-    // To get accurate NumTableFilesAtLevel(0) when the number reaches
-    // options_.level0_file_num_compaction_trigger
-    PauseCompactionThread();
-
-    // (3) Ingest two SST files s1, s2
-    IngestOneKeyValue(dbfull(), "k4", "dummy", options_);
-    IngestOneKeyValue(dbfull(), "k5", "dummy", options_);
-    // Up to now, L0 contains s0, s1, s2
-    ASSERT_EQ(3, NumTableFilesAtLevel(0));
-
-    SetupSyncPoints(compaction_path_to_test);
-    ResumeCompactionThread();
-
-    ASSERT_OK(dbfull()->TEST_WaitForCompact());
-
-    ASSERT_TRUE(SyncPointsCalled())
-        << "failed for compaction path to test: " << compaction_path_to_test;
-    DisableSyncPoints();
-    // After compaction, we have LSM tree:
-    //
-    // memtable: m1 [                 k2:new@4, k1:new@3]
-    // L0: s3[k5:dummy@6, k4:dummy@5, k3:old@2, k1:old@1]
-    ASSERT_EQ(1, NumTableFilesAtLevel(0))
-        << "failed for compaction path to test: " << compaction_path_to_test;
-    SequenceNumber compact_output_file_largest_seqno =
-        GetLatestL0FileLargestSeqnoHelper();
-
-    ASSERT_OK(Flush()) << "failed for compaction path to test: "
-                       << compaction_path_to_test;
-    // After flush, we have LSM tree:
-    //
-    // L0: s4[k2:new@4, k1:new@3], s3[k5:dummy@6, k4:dummy@5, k3:old@2,
-    // k1:old@1]
-    ASSERT_EQ(2, NumTableFilesAtLevel(0))
-        << "failed for compaction path to test: " << compaction_path_to_test;
-    SequenceNumber flushed_file_largest_seqno =
-        GetLatestL0FileLargestSeqnoHelper();
-
-    // To verify there isn't any file misorder leading to returning a old
-    // value of "k1" , which is caused by flushed table s4 has a
-    // smaller largest seqno than the compaction output file s3's largest seqno
-    // while the flushed table has the newer version of the value
-    // than the compaction output file's.
-    ASSERT_TRUE(flushed_file_largest_seqno < compact_output_file_largest_seqno)
-        << "failed for compaction path to test: " << compaction_path_to_test;
-    EXPECT_EQ(Get("k1"), "new")
-        << "failed for compaction path to test: " << compaction_path_to_test;
-  }
-
-  Destroy(options_);
-}
-
-class DBCompactionTestL0FilesMisorderCorruptionWithParam
-    : public DBCompactionTestL0FilesMisorderCorruption,
-      public testing::WithParamInterface<CompactionStyle> {
- public:
-  DBCompactionTestL0FilesMisorderCorruptionWithParam()
-      : DBCompactionTestL0FilesMisorderCorruption() {}
-};
-
-// TODO: add `CompactionStyle::kCompactionStyleLevel` to testing parameter,
-// which requires careful unit test
-// design for ingesting file to L0 and CompactRange()/CompactFile() to L0
-INSTANTIATE_TEST_CASE_P(
-    DBCompactionTestL0FilesMisorderCorruptionWithParam,
-    DBCompactionTestL0FilesMisorderCorruptionWithParam,
-    ::testing::Values(CompactionStyle::kCompactionStyleUniversal,
-                      CompactionStyle::kCompactionStyleFIFO));
-
-TEST_P(DBCompactionTestL0FilesMisorderCorruptionWithParam,
-       FlushAfterIntraL0CompactFileWithIngestedFile) {
-  SetupOptions(GetParam(), "CompactFile");
-  DestroyAndReopen(options_);
-
-  // To create below LSM tree
-  // (key:value@n indicates key-value pair has seqno "n", L0 is sorted):
-  //
-  // memtable: m1 [                         k2:new@4, k1:new@3]
-  // L0: s2[k5:dummy@6], s1[k4:dummy@5], s0[k3:old@2, k1:old@1]
-  //
-  // (1) Create an existing SST file s0
-  ASSERT_OK(Put("k1", "old"));
-  ASSERT_OK(Put("k3", "old"));
-  ASSERT_OK(Flush());
-  ASSERT_EQ(1, NumTableFilesAtLevel(0));
-
-  // (2) Create memtable m1. Noted that it contains a overlaped key with s0
-  ASSERT_OK(Put("k1", "new"));  // overlapped key
-  ASSERT_OK(Put("k2", "new"));
-
-  // (3) Ingest two SST files s1, s2
-  IngestOneKeyValue(dbfull(), "k4", "dummy", options_);
-  IngestOneKeyValue(dbfull(), "k5", "dummy", options_);
-  // Up to now, L0 contains s0, s1, s2
-  ASSERT_EQ(3, NumTableFilesAtLevel(0));
-
-  ColumnFamilyMetaData cf_meta_data;
-  db_->GetColumnFamilyMetaData(&cf_meta_data);
-  ASSERT_EQ(cf_meta_data.levels[0].files.size(), 3);
-  std::vector<std::string> input_files;
-  for (const auto& file : cf_meta_data.levels[0].files) {
-    input_files.push_back(file.name);
-  }
-  ASSERT_EQ(input_files.size(), 3);
-
-  Status s = db_->CompactFiles(CompactionOptions(), input_files, 0);
-  // After compaction, we have LSM tree:
-  //
-  // memtable: m1 [                 k2:new@4, k1:new@3]
-  // L0: s3[k5:dummy@6, k4:dummy@5, k3:old@2, k1:old@1]
-  ASSERT_OK(s);
-  ASSERT_EQ(1, NumTableFilesAtLevel(0));
-  SequenceNumber compact_output_file_largest_seqno =
-      GetLatestL0FileLargestSeqnoHelper();
-
-  ASSERT_OK(Flush());
-  // After flush, we have LSM tree:
-  //
-  // L0: s4[k2:new@4, k1:new@3], s3[k5:dummy@6, k4:dummy@5, k3:old@2,
-  // k1:old@1]
-  ASSERT_EQ(2, NumTableFilesAtLevel(0));
-  SequenceNumber flushed_file_largest_seqno =
-      GetLatestL0FileLargestSeqnoHelper();
-
-  // To verify there isn't any file misorder leading to returning a old value
-  // of "1" , which is caused by flushed table s4 has a smaller
-  // largest seqno than the compaction output file s3's largest seqno while the
-  // flushed table has the newer version of the value than the
-  // compaction output file's.
-  ASSERT_TRUE(flushed_file_largest_seqno < compact_output_file_largest_seqno);
-  EXPECT_EQ(Get("k1"), "new");
-
-  Destroy(options_);
-}
-
-TEST_P(DBCompactionTestL0FilesMisorderCorruptionWithParam,
-       FlushAfterIntraL0CompactRangeWithIngestedFile) {
-  SetupOptions(GetParam(), "CompactRange");
-  DestroyAndReopen(options_);
-
-  // To create below LSM tree
-  // (key:value@n indicates key-value pair has seqno "n", L0 is sorted):
-  //
-  // memtable: m1 [                         k2:new@4, k1:new@3]
-  // L0: s2[k5:dummy@6], s1[k4:dummy@5], s0[k3:old@2, k1:old@1]
-  //
-  // (1) Create an existing SST file s0
-  ASSERT_OK(Put("k1", "old"));
-  ASSERT_OK(Put("k3", "old"));
-  ASSERT_OK(Flush());
-  ASSERT_EQ(1, NumTableFilesAtLevel(0));
-
-  // (2) Create memtable m1. Noted that it contains a overlaped key with s0
-  ASSERT_OK(Put("k1", "new"));  // overlapped key
-  ASSERT_OK(Put("k2", "new"));
-
-  // (3) Ingest two SST files s1, s2
-  IngestOneKeyValue(dbfull(), "k4", "dummy", options_);
-  IngestOneKeyValue(dbfull(), "k5", "dummy", options_);
-  // Up to now, L0 contains s0, s1, s2
-  ASSERT_EQ(3, NumTableFilesAtLevel(0));
-
-  if (options_.compaction_style == CompactionStyle::kCompactionStyleFIFO) {
-    SetupSyncPoints("CompactRange");
-  }
-  // `start` and `end` is carefully chosen so that compact range:
-  // (1) doesn't overlap with memtable therefore the memtable won't be flushed
-  // (2) should target at compacting s0 with s1 and s2
-  Slice start("k3"), end("k5");
-  ASSERT_OK(db_->CompactRange(CompactRangeOptions(), &start, &end));
-  // After compaction, we have LSM tree:
-  //
-  // memtable: m1 [                 k2:new@4, k1:new@3]
-  // L0: s3[k5:dummy@6, k4:dummy@5, k3:old@2, k1:old@1]
-  if (options_.compaction_style == CompactionStyle::kCompactionStyleFIFO) {
-    ASSERT_TRUE(SyncPointsCalled());
-    DisableSyncPoints();
-  }
-  ASSERT_EQ(1, NumTableFilesAtLevel(0));
-  SequenceNumber compact_output_file_largest_seqno =
-      GetLatestL0FileLargestSeqnoHelper();
-
-  ASSERT_OK(Flush());
-  // After flush, we have LSM tree:
-  //
-  // L0: s4[k2:new@4, k1:new@3], s3[k5:dummy@6, k4:dummy@5, k3:old@2,
-  // k1:old@1]
-  ASSERT_EQ(2, NumTableFilesAtLevel(0));
-  SequenceNumber flushed_file_largest_seqno =
-      GetLatestL0FileLargestSeqnoHelper();
-
-  // To verify there isn't any file misorder leading to returning a old value
-  // of "k1" , which is caused by flushed table s4 has a smaller
-  // largest seqno than the compaction output file s3's largest seqno while the
-  // flushed table has the newer version of the value than the
-  // compaction output file's.
-  ASSERT_TRUE(flushed_file_largest_seqno < compact_output_file_largest_seqno);
-  EXPECT_EQ(Get("k1"), "new");
-
-  Destroy(options_);
-}
-
 TEST_P(DBCompactionTestWithBottommostParam, SequenceKeysManualCompaction) {
   constexpr int kSstNum = 10;
   Options options = CurrentOptions();