Parameterize DBTest.Randomized

Summary: Break down DBTest.Randomized to multiple gtest tests based on config type

Test Plan: Run the test and all tests. Make sure configurations are correctly set

Reviewers: yhchiang, IslamAbdelRahman, rven, kradhakrishnan, andrewkr, anthony

Reviewed By: anthony

Subscribers: leveldb, dhruba

Differential Revision: https://reviews.facebook.net/D53247

db/db_test.cc

@@ -5097,12 +5097,37 @@ static bool CompareIterators(int step,
   return ok;
 }
 
-TEST_F(DBTest, Randomized) {
+class DBTestRandomized : public DBTest,
+                         public ::testing::WithParamInterface<int> {
+ public:
+  virtual void SetUp() override { option_config_ = GetParam(); }
+
+  static std::vector<int> GenerateOptionConfigs() {
+    std::vector<int> option_configs;
+    // skip cuckoo hash as it does not support snapshot.
+    for (int option_config = kDefault; option_config < kEnd; ++option_config) {
+      if (!ShouldSkipOptions(option_config, kSkipDeletesFilterFirst |
+                                                kSkipNoSeekToLast |
+                                                kSkipHashCuckoo)) {
+        option_configs.push_back(option_config);
+      }
+    }
+    return option_configs;
+  }
+};
+
+INSTANTIATE_TEST_CASE_P(
+    DBTestRandomized, DBTestRandomized,
+    ::testing::ValuesIn(DBTestRandomized::GenerateOptionConfigs()));
+
+TEST_P(DBTestRandomized, Randomized) {
   anon::OptionsOverride options_override;
   options_override.skip_policy = kSkipNoSnapshot;
-  Random rnd(test::RandomSeed());
+  Options options = CurrentOptions(options_override);
-  do {
+  DestroyAndReopen(options);
-    ModelDB model(CurrentOptions(options_override));
+
+  Random rnd(test::RandomSeed() + GetParam());
+  ModelDB model(options);
     const int N = 10000;
     const Snapshot* model_snap = nullptr;
     const Snapshot* db_snap = nullptr;
@@ -5127,13 +5152,10 @@ TEST_F(DBTest, Randomized) {
                          : rnd.Uniform(8));
         ASSERT_OK(model.Put(WriteOptions(), k, v));
         ASSERT_OK(db_->Put(WriteOptions(), k, v));
-
       } else if (p < 90) {                        // Delete
         k = RandomKey(&rnd, minimum);
         ASSERT_OK(model.Delete(WriteOptions(), k));
         ASSERT_OK(db_->Delete(WriteOptions(), k));
-
-
       } else {                                    // Multi-element batch
         WriteBatch b;
         const int num = rnd.Uniform(8);
@@ -5171,26 +5193,15 @@ TEST_F(DBTest, Randomized) {
         if (model_snap != nullptr) model.ReleaseSnapshot(model_snap);
         if (db_snap != nullptr) db_->ReleaseSnapshot(db_snap);
 
-
-        auto options = CurrentOptions(options_override);
         Reopen(options);
         ASSERT_TRUE(CompareIterators(step, &model, db_, nullptr, nullptr));
 
         model_snap = model.GetSnapshot();
         db_snap = db_->GetSnapshot();
       }
-
-      if ((step % 2000) == 0) {
-        fprintf(stderr,
-                "DBTest.Randomized, option ID: %d, step: %d out of %d\n",
-                option_config_, step, N);
-      }
     }
     if (model_snap != nullptr) model.ReleaseSnapshot(model_snap);
     if (db_snap != nullptr) db_->ReleaseSnapshot(db_snap);
-    // skip cuckoo hash as it does not support snapshot.
-  } while (ChangeOptions(kSkipDeletesFilterFirst | kSkipNoSeekToLast |
-                         kSkipHashCuckoo));
 }
 
 TEST_F(DBTest, MultiGetSimple) {

db/db_test_util.cc

@@ -73,63 +73,68 @@ DBTestBase::~DBTestBase() {
   delete env_;
 }
 
-// Switch to a fresh database with the next option configuration to
+bool DBTestBase::ShouldSkipOptions(int option_config, int skip_mask) {
-// test.  Return false if there are no more configurations to test.
-bool DBTestBase::ChangeOptions(int skip_mask) {
-  for (option_config_++; option_config_ < kEnd; option_config_++) {
 #ifdef ROCKSDB_LITE
     // These options are not supported in ROCKSDB_LITE
-    if (option_config_ == kHashSkipList ||
+  if (option_config == kHashSkipList ||
-        option_config_ == kPlainTableFirstBytePrefix ||
+      option_config == kPlainTableFirstBytePrefix ||
-        option_config_ == kPlainTableCappedPrefix ||
+      option_config == kPlainTableCappedPrefix ||
-        option_config_ == kPlainTableCappedPrefixNonMmap ||
+      option_config == kPlainTableCappedPrefixNonMmap ||
-        option_config_ == kPlainTableAllBytesPrefix ||
+      option_config == kPlainTableAllBytesPrefix ||
-        option_config_ == kVectorRep || option_config_ == kHashLinkList ||
+      option_config == kVectorRep || option_config == kHashLinkList ||
-        option_config_ == kHashCuckoo ||
+      option_config == kHashCuckoo || option_config == kUniversalCompaction ||
-        option_config_ == kUniversalCompaction ||
+      option_config == kUniversalCompactionMultiLevel ||
-        option_config_ == kUniversalCompactionMultiLevel ||
+      option_config == kUniversalSubcompactions ||
-        option_config_ == kUniversalSubcompactions ||
+      option_config == kFIFOCompaction) {
-        option_config_ == kFIFOCompaction) {
+    return true;
-      continue;
     }
 #endif
 
     if ((skip_mask & kSkipDeletesFilterFirst) &&
-        option_config_ == kDeletesFilterFirst) {
+        option_config == kDeletesFilterFirst) {
-      continue;
+      return true;
     }
     if ((skip_mask & kSkipUniversalCompaction) &&
-        (option_config_ == kUniversalCompaction ||
+        (option_config == kUniversalCompaction ||
-         option_config_ == kUniversalCompactionMultiLevel)) {
+         option_config == kUniversalCompactionMultiLevel)) {
-      continue;
+      return true;
     }
-    if ((skip_mask & kSkipMergePut) && option_config_ == kMergePut) {
+    if ((skip_mask & kSkipMergePut) && option_config == kMergePut) {
-      continue;
+      return true;
     }
     if ((skip_mask & kSkipNoSeekToLast) &&
-        (option_config_ == kHashLinkList || option_config_ == kHashSkipList)) {
+        (option_config == kHashLinkList || option_config == kHashSkipList)) {
-      continue;
+      return true;
     }
     if ((skip_mask & kSkipPlainTable) &&
-        (option_config_ == kPlainTableAllBytesPrefix ||
+        (option_config == kPlainTableAllBytesPrefix ||
-         option_config_ == kPlainTableFirstBytePrefix ||
+         option_config == kPlainTableFirstBytePrefix ||
-         option_config_ == kPlainTableCappedPrefix ||
+         option_config == kPlainTableCappedPrefix ||
-         option_config_ == kPlainTableCappedPrefixNonMmap)) {
+         option_config == kPlainTableCappedPrefixNonMmap)) {
-      continue;
+      return true;
     }
     if ((skip_mask & kSkipHashIndex) &&
-        (option_config_ == kBlockBasedTableWithPrefixHashIndex ||
+        (option_config == kBlockBasedTableWithPrefixHashIndex ||
-         option_config_ == kBlockBasedTableWithWholeKeyHashIndex)) {
+         option_config == kBlockBasedTableWithWholeKeyHashIndex)) {
-      continue;
+      return true;
     }
-    if ((skip_mask & kSkipHashCuckoo) && (option_config_ == kHashCuckoo)) {
+    if ((skip_mask & kSkipHashCuckoo) && (option_config == kHashCuckoo)) {
-      continue;
+      return true;
     }
-    if ((skip_mask & kSkipFIFOCompaction) &&
+    if ((skip_mask & kSkipFIFOCompaction) && option_config == kFIFOCompaction) {
-        option_config_ == kFIFOCompaction) {
+      return true;
-      continue;
     }
-    if ((skip_mask & kSkipMmapReads) && option_config_ == kWalDirAndMmapReads) {
+    if ((skip_mask & kSkipMmapReads) && option_config == kWalDirAndMmapReads) {
+      return true;
+    }
+    return false;
+}
+
+// Switch to a fresh database with the next option configuration to
+// test.  Return false if there are no more configurations to test.
+bool DBTestBase::ChangeOptions(int skip_mask) {
+  for (option_config_++; option_config_ < kEnd; option_config_++) {
+    if (ShouldSkipOptions(option_config_, skip_mask)) {
       continue;
     }
     break;

db/db_test_util.h

@@ -572,6 +572,8 @@ class DBTestBase : public testing::Test {
     return std::string(buf);
   }
 
+  static bool ShouldSkipOptions(int option_config, int skip_mask = kNoSkip);
+
   // Switch to a fresh database with the next option configuration to
   // test.  Return false if there are no more configurations to test.
   bool ChangeOptions(int skip_mask = kNoSkip);