Update upstream source from tag 'upstream/6.0.0'master

Update to upstream version '6.0.0'
with Debian dir 5604a80ec1c96ca76f25f40d78e6ef855abec322

1 files changed, 45 insertions, 311 deletions

diff --git a/src/mongo/dbtests/validate_tests.cpp b/src/mongo/dbtests/validate_tests.cpp
index f85755ac87e..031057cb7cf 100644
--- a/src/mongo/dbtests/validate_tests.cpp
+++ b/src/mongo/dbtests/validate_tests.cpp
@@ -54,7 +54,7 @@ using std::unique_ptr;
 namespace {
 
 const auto kIndexVersion = IndexDescriptor::IndexVersion::kV2;
-const bool kLogDiagnostics = true;
+const bool kTurnOnExtraLoggingForTest = true;
 
 std::size_t omitTransientWarningsFromCount(const ValidateResults& results) {
     return std::count_if(
@@ -146,14 +146,8 @@ protected:
         ValidateResults results;
         BSONObjBuilder output;
 
-        ASSERT_OK(CollectionValidation::validate(&_opCtx,
-                                                 _nss,
-                                                 mode,
-                                                 repairMode,
-                                                 /*additionalOptions=*/{},
-                                                 &results,
-                                                 &output,
-                                                 kLogDiagnostics));
+        ASSERT_OK(CollectionValidation::validate(
+            &_opCtx, _nss, mode, repairMode, &results, &output, kTurnOnExtraLoggingForTest));
 
         //  Check if errors are reported if and only if valid is set to false.
         ASSERT_EQ(results.valid, results.errors.empty());
@@ -184,23 +178,6 @@ protected:
         dumpOnErrorGuard.dismiss();
     }
 
-    void ensureValidateWarned() {
-        ValidateResults results = runValidate();
-
-        ScopeGuard dumpOnErrorGuard([&] {
-            StorageDebugUtil::printValidateResults(results);
-            StorageDebugUtil::printCollectionAndIndexTableEntries(&_opCtx, _nss);
-        });
-
-        ASSERT_TRUE(results.valid) << "Validation failed when it should've worked.";
-        ASSERT_TRUE(results.errors.empty())
-            << "Validation reported errors when it should not have.";
-        ASSERT_FALSE(results.warnings.empty())
-            << "Validation did not report a warning when it should have.";
-
-        dumpOnErrorGuard.dismiss();
-    }
-
     void ensureValidateFailed() {
         ValidateResults results = runValidate();
 
@@ -1218,10 +1195,9 @@ public:
                                                _nss,
                                                CollectionValidation::ValidateMode::kForegroundFull,
                                                CollectionValidation::RepairMode::kNone,
-                                               /*additionalOptions=*/{},
                                                &results,
                                                &output,
-                                               kLogDiagnostics));
+                                               kTurnOnExtraLoggingForTest));
 
             ScopeGuard dumpOnErrorGuard([&] {
                 StorageDebugUtil::printValidateResults(results);
@@ -1337,10 +1313,9 @@ public:
                                                _nss,
                                                CollectionValidation::ValidateMode::kForegroundFull,
                                                CollectionValidation::RepairMode::kNone,
-                                               /*additionalOptions=*/{},
                                                &results,
                                                &output,
-                                               kLogDiagnostics));
+                                               kTurnOnExtraLoggingForTest));
 
             ScopeGuard dumpOnErrorGuard([&] {
                 StorageDebugUtil::printValidateResults(results);
@@ -1427,10 +1402,9 @@ public:
                                                _nss,
                                                CollectionValidation::ValidateMode::kForegroundFull,
                                                CollectionValidation::RepairMode::kNone,
-                                               /*additionalOptions=*/{},
                                                &results,
                                                &output,
-                                               kLogDiagnostics));
+                                               kTurnOnExtraLoggingForTest));
 
             ScopeGuard dumpOnErrorGuard([&] {
                 StorageDebugUtil::printValidateResults(results);
@@ -1540,10 +1514,9 @@ public:
                                                _nss,
                                                CollectionValidation::ValidateMode::kForegroundFull,
                                                CollectionValidation::RepairMode::kNone,
-                                               /*additionalOptions=*/{},
                                                &results,
                                                &output,
-                                               kLogDiagnostics));
+                                               kTurnOnExtraLoggingForTest));
 
             ScopeGuard dumpOnErrorGuard([&] {
                 StorageDebugUtil::printValidateResults(results);
@@ -1570,10 +1543,9 @@ public:
                                                _nss,
                                                CollectionValidation::ValidateMode::kForegroundFull,
                                                CollectionValidation::RepairMode::kFixErrors,
-                                               /*additionalOptions=*/{},
                                                &results,
                                                &output,
-                                               kLogDiagnostics));
+                                               kTurnOnExtraLoggingForTest));
 
             ScopeGuard dumpOnErrorGuard([&] {
                 StorageDebugUtil::printValidateResults(results);
@@ -1607,10 +1579,9 @@ public:
                                                _nss,
                                                CollectionValidation::ValidateMode::kForegroundFull,
                                                CollectionValidation::RepairMode::kFixErrors,
-                                               /*additionalOptions=*/{},
                                                &results,
                                                &output,
-                                               kLogDiagnostics));
+                                               kTurnOnExtraLoggingForTest));
 
             ScopeGuard dumpOnErrorGuard([&] {
                 StorageDebugUtil::printValidateResults(results);
@@ -1727,10 +1698,9 @@ public:
                                                _nss,
                                                CollectionValidation::ValidateMode::kForegroundFull,
                                                CollectionValidation::RepairMode::kNone,
-                                               /*additionalOptions=*/{},
                                                &results,
                                                &output,
-                                               kLogDiagnostics));
+                                               kTurnOnExtraLoggingForTest));
 
             ScopeGuard dumpOnErrorGuard([&] {
                 StorageDebugUtil::printValidateResults(results);
@@ -1759,10 +1729,9 @@ public:
                                                _nss,
                                                CollectionValidation::ValidateMode::kForegroundFull,
                                                CollectionValidation::RepairMode::kFixErrors,
-                                               /*additionalOptions=*/{},
                                                &results,
                                                &output,
-                                               kLogDiagnostics));
+                                               kTurnOnExtraLoggingForTest));
 
             ScopeGuard dumpOnErrorGuard([&] {
                 StorageDebugUtil::printValidateResults(results);
@@ -1792,10 +1761,9 @@ public:
                                                _nss,
                                                CollectionValidation::ValidateMode::kForegroundFull,
                                                CollectionValidation::RepairMode::kNone,
-                                               /*additionalOptions=*/{},
                                                &results,
                                                &output,
-                                               kLogDiagnostics));
+                                               kTurnOnExtraLoggingForTest));
 
             ScopeGuard dumpOnErrorGuard([&] {
                 StorageDebugUtil::printValidateResults(results);
@@ -1883,10 +1851,9 @@ public:
                                                _nss,
                                                CollectionValidation::ValidateMode::kForegroundFull,
                                                CollectionValidation::RepairMode::kNone,
-                                               /*additionalOptions=*/{},
                                                &results,
                                                &output,
-                                               kLogDiagnostics));
+                                               kTurnOnExtraLoggingForTest));
 
             ScopeGuard dumpOnErrorGuard([&] {
                 StorageDebugUtil::printValidateResults(results);
@@ -1915,10 +1882,9 @@ public:
                                                _nss,
                                                CollectionValidation::ValidateMode::kForegroundFull,
                                                CollectionValidation::RepairMode::kFixErrors,
-                                               /*additionalOptions=*/{},
                                                &results,
                                                &output,
-                                               kLogDiagnostics));
+                                               kTurnOnExtraLoggingForTest));
 
             ScopeGuard dumpOnErrorGuard([&] {
                 StorageDebugUtil::printValidateResults(results);
@@ -1947,10 +1913,9 @@ public:
                                                _nss,
                                                CollectionValidation::ValidateMode::kForegroundFull,
                                                CollectionValidation::RepairMode::kNone,
-                                               /*additionalOptions=*/{},
                                                &results,
                                                &output,
-                                               kLogDiagnostics));
+                                               kTurnOnExtraLoggingForTest));
 
             ScopeGuard dumpOnErrorGuard([&] {
                 StorageDebugUtil::printValidateResults(results);
@@ -2100,10 +2065,9 @@ public:
                                                _nss,
                                                CollectionValidation::ValidateMode::kForegroundFull,
                                                CollectionValidation::RepairMode::kNone,
-                                               /*additionalOptions=*/{},
                                                &results,
                                                &output,
-                                               kLogDiagnostics));
+                                               kTurnOnExtraLoggingForTest));
 
             ScopeGuard dumpOnErrorGuard([&] {
                 StorageDebugUtil::printValidateResults(results);
@@ -2131,10 +2095,9 @@ public:
                                                _nss,
                                                CollectionValidation::ValidateMode::kForegroundFull,
                                                CollectionValidation::RepairMode::kFixErrors,
-                                               /*additionalOptions=*/{},
                                                &results,
                                                &output,
-                                               kLogDiagnostics));
+                                               kTurnOnExtraLoggingForTest));
 
             ScopeGuard dumpOnErrorGuard([&] {
                 StorageDebugUtil::printValidateResults(results);
@@ -2167,10 +2130,9 @@ public:
                                                _nss,
                                                CollectionValidation::ValidateMode::kForegroundFull,
                                                CollectionValidation::RepairMode::kNone,
-                                               /*additionalOptions=*/{},
                                                &results,
                                                &output,
-                                               kLogDiagnostics));
+                                               kTurnOnExtraLoggingForTest));
 
             ScopeGuard dumpOnErrorGuard([&] {
                 StorageDebugUtil::printValidateResults(results);
@@ -2339,10 +2301,9 @@ public:
                                                _nss,
                                                CollectionValidation::ValidateMode::kForegroundFull,
                                                CollectionValidation::RepairMode::kNone,
-                                               /*additionalOptions=*/{},
                                                &results,
                                                &output,
-                                               kLogDiagnostics));
+                                               kTurnOnExtraLoggingForTest));
 
             ScopeGuard dumpOnErrorGuard([&] {
                 StorageDebugUtil::printValidateResults(results);
@@ -2370,10 +2331,9 @@ public:
                                                _nss,
                                                CollectionValidation::ValidateMode::kForegroundFull,
                                                CollectionValidation::RepairMode::kFixErrors,
-                                               /*additionalOptions=*/{},
                                                &results,
                                                &output,
-                                               kLogDiagnostics));
+                                               kTurnOnExtraLoggingForTest));
 
             ScopeGuard dumpOnErrorGuard([&] {
                 StorageDebugUtil::printValidateResults(results);
@@ -2407,10 +2367,9 @@ public:
                                                _nss,
                                                CollectionValidation::ValidateMode::kForegroundFull,
                                                CollectionValidation::RepairMode::kNone,
-                                               /*additionalOptions=*/{},
                                                &results,
                                                &output,
-                                               kLogDiagnostics));
+                                               kTurnOnExtraLoggingForTest));
 
             ScopeGuard dumpOnErrorGuard([&] {
                 StorageDebugUtil::printValidateResults(results);
@@ -2668,10 +2627,9 @@ public:
                                                _nss,
                                                CollectionValidation::ValidateMode::kForegroundFull,
                                                CollectionValidation::RepairMode::kNone,
-                                               /*additionalOptions=*/{},
                                                &results,
                                                &output,
-                                               kLogDiagnostics));
+                                               kTurnOnExtraLoggingForTest));
 
             ScopeGuard dumpOnErrorGuard([&] {
                 StorageDebugUtil::printValidateResults(results);
@@ -2702,10 +2660,9 @@ public:
                                                _nss,
                                                CollectionValidation::ValidateMode::kForegroundFull,
                                                CollectionValidation::RepairMode::kFixErrors,
-                                               /*additionalOptions=*/{},
                                                &results,
                                                &output,
-                                               kLogDiagnostics));
+                                               kTurnOnExtraLoggingForTest));
 
             ScopeGuard dumpOnErrorGuard([&] {
                 StorageDebugUtil::printValidateResults(results);
@@ -2739,10 +2696,9 @@ public:
                                                _nss,
                                                CollectionValidation::ValidateMode::kForegroundFull,
                                                CollectionValidation::RepairMode::kNone,
-                                               /*additionalOptions=*/{},
                                                &results,
                                                &output,
-                                               kLogDiagnostics));
+                                               kTurnOnExtraLoggingForTest));
 
             ScopeGuard dumpOnErrorGuard([&] {
                 StorageDebugUtil::printValidateResults(results);
@@ -2865,10 +2821,9 @@ public:
                                                _nss,
                                                CollectionValidation::ValidateMode::kForeground,
                                                CollectionValidation::RepairMode::kNone,
-                                               /*additionalOptions=*/{},
                                                &results,
                                                &output,
-                                               kLogDiagnostics));
+                                               kTurnOnExtraLoggingForTest));
 
             ScopeGuard dumpOnErrorGuard([&] {
                 StorageDebugUtil::printValidateResults(results);
@@ -2897,10 +2852,9 @@ public:
                                                _nss,
                                                CollectionValidation::ValidateMode::kForeground,
                                                CollectionValidation::RepairMode::kFixErrors,
-                                               /*additionalOptions=*/{},
                                                &results,
                                                &output,
-                                               kLogDiagnostics));
+                                               kTurnOnExtraLoggingForTest));
 
             ScopeGuard dumpOnErrorGuard([&] {
                 StorageDebugUtil::printValidateResults(results);
@@ -2930,10 +2884,9 @@ public:
                                                _nss,
                                                CollectionValidation::ValidateMode::kForeground,
                                                CollectionValidation::RepairMode::kFixErrors,
-                                               /*additionalOptions=*/{},
                                                &results,
                                                &output,
-                                               kLogDiagnostics));
+                                               kTurnOnExtraLoggingForTest));
 
             ScopeGuard dumpOnErrorGuard([&] {
                 StorageDebugUtil::printValidateResults(results);
@@ -3331,10 +3284,9 @@ public:
                                                      _nss,
                                                      mode,
                                                      CollectionValidation::RepairMode::kNone,
-                                                     /*additionalOptions=*/{},
                                                      &results,
                                                      &output,
-                                                     kLogDiagnostics));
+                                                     kTurnOnExtraLoggingForTest));
 
             ScopeGuard dumpOnErrorGuard([&] {
                 StorageDebugUtil::printValidateResults(results);
@@ -3400,10 +3352,9 @@ public:
                                                _nss,
                                                CollectionValidation::ValidateMode::kForeground,
                                                CollectionValidation::RepairMode::kNone,
-                                               /*additionalOptions=*/{},
                                                &results,
                                                &output,
-                                               kLogDiagnostics));
+                                               kTurnOnExtraLoggingForTest));
 
             ScopeGuard dumpOnErrorGuard([&] {
                 StorageDebugUtil::printValidateResults(results);
@@ -3432,10 +3383,9 @@ public:
                                                _nss,
                                                CollectionValidation::ValidateMode::kForeground,
                                                CollectionValidation::RepairMode::kFixErrors,
-                                               /*additionalOptions=*/{},
                                                &results,
                                                &output,
-                                               kLogDiagnostics));
+                                               kTurnOnExtraLoggingForTest));
 
             ScopeGuard dumpOnErrorGuard([&] {
                 StorageDebugUtil::printValidateResults(results);
@@ -3468,10 +3418,9 @@ public:
                                                _nss,
                                                CollectionValidation::ValidateMode::kForeground,
                                                CollectionValidation::RepairMode::kFixErrors,
-                                               /*additionalOptions=*/{},
                                                &results,
                                                &output,
-                                               kLogDiagnostics));
+                                               kTurnOnExtraLoggingForTest));
 
             ScopeGuard dumpOnErrorGuard([&] {
                 StorageDebugUtil::printValidateResults(results);
@@ -3500,10 +3449,9 @@ public:
                                                _nss,
                                                CollectionValidation::ValidateMode::kForeground,
                                                CollectionValidation::RepairMode::kNone,
-                                               /*additionalOptions=*/{},
                                                &results,
                                                &output,
-                                               kLogDiagnostics));
+                                               kTurnOnExtraLoggingForTest));
 
             ScopeGuard dumpOnErrorGuard([&] {
                 StorageDebugUtil::printValidateResults(results);
@@ -3667,10 +3615,9 @@ public:
                                                _nss,
                                                CollectionValidation::ValidateMode::kForeground,
                                                CollectionValidation::RepairMode::kNone,
-                                               /*additionalOptions=*/{},
                                                &results,
                                                &output,
-                                               kLogDiagnostics));
+                                               kTurnOnExtraLoggingForTest));
 
             ScopeGuard dumpOnErrorGuard([&] {
                 StorageDebugUtil::printValidateResults(results);
@@ -3697,10 +3644,9 @@ public:
                                                _nss,
                                                CollectionValidation::ValidateMode::kForeground,
                                                CollectionValidation::RepairMode::kFixErrors,
-                                               /*additionalOptions=*/{},
                                                &results,
                                                &output,
-                                               kLogDiagnostics));
+                                               kTurnOnExtraLoggingForTest));
 
             ScopeGuard dumpOnErrorGuard([&] {
                 StorageDebugUtil::printValidateResults(results);
@@ -3728,10 +3674,9 @@ public:
                                                _nss,
                                                CollectionValidation::ValidateMode::kForeground,
                                                CollectionValidation::RepairMode::kFixErrors,
-                                               /*additionalOptions=*/{},
                                                &results,
                                                &output,
-                                               kLogDiagnostics));
+                                               kTurnOnExtraLoggingForTest));
 
             ScopeGuard dumpOnErrorGuard([&] {
                 StorageDebugUtil::printValidateResults(results);
@@ -3876,10 +3821,9 @@ public:
                                                _nss,
                                                CollectionValidation::ValidateMode::kForeground,
                                                CollectionValidation::RepairMode::kNone,
-                                               /*additionalOptions=*/{},
                                                &results,
                                                &output,
-                                               kLogDiagnostics));
+                                               kTurnOnExtraLoggingForTest));
 
             ScopeGuard dumpOnErrorGuard([&] {
                 StorageDebugUtil::printValidateResults(results);
@@ -3906,10 +3850,9 @@ public:
                                                _nss,
                                                CollectionValidation::ValidateMode::kForeground,
                                                CollectionValidation::RepairMode::kFixErrors,
-                                               /*additionalOptions=*/{},
                                                &results,
                                                &output,
-                                               kLogDiagnostics));
+                                               kTurnOnExtraLoggingForTest));
 
             ScopeGuard dumpOnErrorGuard([&] {
                 StorageDebugUtil::printValidateResults(results);
@@ -3936,10 +3879,9 @@ public:
                                                _nss,
                                                CollectionValidation::ValidateMode::kForeground,
                                                CollectionValidation::RepairMode::kNone,
-                                               /*additionalOptions=*/{},
                                                &results,
                                                &output,
-                                               kLogDiagnostics));
+                                               kTurnOnExtraLoggingForTest));
 
             ScopeGuard dumpOnErrorGuard([&] {
                 StorageDebugUtil::printValidateResults(results);
@@ -4043,10 +3985,9 @@ public:
                                                _nss,
                                                CollectionValidation::ValidateMode::kForeground,
                                                CollectionValidation::RepairMode::kAdjustMultikey,
-                                               /*additionalOptions=*/{},
                                                &results,
                                                &output,
-                                               kLogDiagnostics));
+                                               kTurnOnExtraLoggingForTest));
 
             ScopeGuard dumpOnErrorGuard([&] {
                 StorageDebugUtil::printValidateResults(results);
@@ -4077,10 +4018,9 @@ public:
                                                _nss,
                                                CollectionValidation::ValidateMode::kForeground,
                                                CollectionValidation::RepairMode::kAdjustMultikey,
-                                               /*additionalOptions=*/{},
                                                &results,
                                                &output,
-                                               kLogDiagnostics));
+                                               kTurnOnExtraLoggingForTest));
 
             ScopeGuard dumpOnErrorGuard([&] {
                 StorageDebugUtil::printValidateResults(results);
@@ -4140,10 +4080,9 @@ public:
                                                      _nss,
                                                      mode,
                                                      CollectionValidation::RepairMode::kNone,
-                                                     /*additionalOptions=*/{},
                                                      &results,
                                                      &output,
-                                                     kLogDiagnostics));
+                                                     kTurnOnExtraLoggingForTest));
 
             ScopeGuard dumpOnErrorGuard([&] {
                 StorageDebugUtil::printValidateResults(results);
@@ -4239,10 +4178,9 @@ public:
                                                      _nss,
                                                      mode,
                                                      CollectionValidation::RepairMode::kNone,
-                                                     /*additionalOptions=*/{},
                                                      &results,
                                                      &output,
-                                                     kLogDiagnostics));
+                                                     kTurnOnExtraLoggingForTest));
 
             ScopeGuard dumpOnErrorGuard([&] {
                 StorageDebugUtil::printValidateResults(results);
@@ -4260,205 +4198,6 @@ public:
     }
 };
 
-/**
- * Validate detects duplicate keys in a secondary unique index {a: 1} when the index is
- * on a clustered collection.
- * Two cases are tested:
- * 1. The false negative case: when validate says there isn't a uniqueness
- * violation even though there is one.
- * 2. The false positive case: when validate says there is a uniqueness
- * violation even though there isn't one.
- *
- * False negative case:
- * Suppose we have two documents {_id: "1000000000", a: 1} and {_id: "1000000000", a: 1}
- * that live in a collection. Since they have the same value for field 'a', they violate
- * the uniqueness constraint of the index.
- * The key strings for index {a: 1} for the two docs look something like this.
- * They map from the value of 'a' in the document to the recordId.
- * Buffer for keystring1: 1,1000000000
- * Buffer for keystring2: 1,2000000000
- *
- * When we compareWithoutRecordIdLong(), we chop off only the number of
- * bytes used in a long before making the comparison in the buffer. Since a long
- * is 8 bytes, we cut 8 characters off.
- * Truncated buffer 1: 1,10
- * Truncated buffer 2: 1,20
- *
- * And we can see that the two truncated buffers above still aren't equal. But instead,
- * if we used compareWithoutRecordIdStr(), we first figure out how many bytes we need
- * to chop to exclude the recordId, and that way only the index entry value is compared.
- * Now the unique index violation can be detected, as both the truncated buffers are
- * equal.
- * Truncated buffer 1: 1
- * Truncated buffer 2: 1
- *
- * False positive case:
- * Suppose we have two documents {_id: "1", a: 10000001} and {_id: "2", a: 10000002}.
- * Clearly they don't violate any constraints. However it is possible, if we truncate
- * more bytes than necessary, that we will end up truncating some of the bytes of the
- * field 'a'. For example,
- * Pre-truncation:
- * Buffer for keystring1: 10000001,1
- * Buffer for keystring2: 10000002,2
- * Post-truncation:
- * Buffer for keystring1: 10000
- * Buffer for keystring2: 10000
- * This can lead to a false positive uniqueness violation.
- */
-template <bool falsePositiveCase>
-class ValidateDuplicateKeyOnClusteredCollection : public ValidateBase {
-public:
-    ValidateDuplicateKeyOnClusteredCollection()
-        : ValidateBase(/*full=*/true, /*background=*/false, /*clustered=*/true) {}
-
-    void run() {
-        // Cannot run validate with {background:true} if the storage engine does not support
-        // checkpoints.
-        if (_background && !_supportsBackgroundValidation) {
-            return;
-        }
-
-        SharedBufferFragmentBuilder pooledBuilder(
-            KeyString::HeapBuilder::kHeapAllocatorDefaultBytes);
-
-        lockDb(MODE_X);
-        ASSERT(coll());
-
-        // Create a unique index on {a: 1}
-        const auto indexName = "a";
-        const auto indexKey = BSON("a" << 1);
-        auto status = dbtests::createIndexFromSpec(
-            &_opCtx,
-            coll()->ns().ns(),
-            BSON("name" << indexName << "key" << indexKey << "v" << static_cast<int>(kIndexVersion)
-                        << "unique" << true));
-        ASSERT_OK(status);
-
-
-        // Insert documents.
-        auto firstDoc = BSON("_id"
-                             << "1000000000000"
-                             << "a" << 1);
-        auto secondDoc = BSON("_id"
-                              << "2000000000000"
-                              << "a" << 1);
-        if (falsePositiveCase) {
-            firstDoc = BSON("_id"
-                            << "1"
-                            << "a" << 10000001);
-            secondDoc = BSON("_id"
-                             << "2"
-                             << "a" << 10000002);
-        }
-        OpDebug* const nullOpDebug = nullptr;
-        lockDb(MODE_X);
-        {
-            WriteUnitOfWork wunit(&_opCtx);
-            ASSERT_OK(
-                coll()->insertDocument(&_opCtx, InsertStatement(firstDoc), nullOpDebug, true));
-            if (falsePositiveCase) {
-                ASSERT_OK(
-                    coll()->insertDocument(&_opCtx, InsertStatement(secondDoc), nullOpDebug, true));
-            }
-            wunit.commit();
-        }
-        releaseDb();
-        ensureValidateWorked();
-
-        // Insert a document with a duplicate key for "a".
-        if (!falsePositiveCase) {
-            lockDb(MODE_X);
-
-            const IndexCatalog* indexCatalog = coll()->getIndexCatalog();
-
-            InsertDeleteOptions options;
-            options.dupsAllowed = true;
-
-            WriteUnitOfWork wunit(&_opCtx);
-
-            // Insert a record and its keys separately. We do this to bypass duplicate constraint
-            // checking. Inserting a record and all of its keys ensures that validation fails
-            // because there are duplicate keys, and not just because there are keys without
-            // corresponding records.
-            auto swRecordId =
-                coll()->getRecordStore()->insertRecord(&_opCtx,
-                                                       record_id_helpers::keyForObj(secondDoc),
-                                                       secondDoc.objdata(),
-                                                       secondDoc.objsize(),
-                                                       Timestamp());
-            ASSERT_OK(swRecordId);
-            wunit.commit();
-
-            // Insert the key on "a".
-            {
-                auto descriptor = indexCatalog->findIndexByName(&_opCtx, indexName);
-                auto entry = const_cast<IndexCatalogEntry*>(indexCatalog->getEntry(descriptor));
-                auto iam = entry->accessMethod()->asSortedData();
-                auto interceptor = std::make_unique<IndexBuildInterceptor>(&_opCtx, entry);
-
-                KeyStringSet keys;
-                iam->getKeys(&_opCtx,
-                             coll(),
-                             pooledBuilder,
-                             secondDoc,
-                             InsertDeleteOptions::ConstraintEnforcementMode::kRelaxConstraints,
-                             SortedDataIndexAccessMethod::GetKeysContext::kAddingKeys,
-                             &keys,
-                             nullptr,
-                             nullptr,
-                             swRecordId.getValue());
-                ASSERT_EQ(1, keys.size());
-
-                {
-                    WriteUnitOfWork wunit(&_opCtx);
-
-                    int64_t numInserted;
-                    auto insertStatus = iam->insertKeysAndUpdateMultikeyPaths(
-                        &_opCtx,
-                        coll(),
-                        {keys.begin(), keys.end()},
-                        {},
-                        MultikeyPaths{},
-                        options,
-                        [this, &interceptor](const KeyString::Value& duplicateKey) {
-                            return interceptor->recordDuplicateKey(&_opCtx, duplicateKey);
-                        },
-                        &numInserted);
-
-                    ASSERT_EQUALS(numInserted, 1);
-                    ASSERT_OK(insertStatus);
-
-                    wunit.commit();
-                }
-
-                ASSERT_NOT_OK(interceptor->checkDuplicateKeyConstraints(&_opCtx));
-            }
-
-            releaseDb();
-        }
-
-        ValidateResults results = runValidate();
-
-        ScopeGuard dumpOnErrorGuard([&] {
-            StorageDebugUtil::printValidateResults(results);
-            StorageDebugUtil::printCollectionAndIndexTableEntries(&_opCtx, coll()->ns());
-        });
-
-        if (falsePositiveCase) {
-            ASSERT(results.valid) << "Validation failed when it should have worked.";
-            ASSERT_EQ(static_cast<size_t>(0), results.errors.size());
-        } else {
-            ASSERT_FALSE(results.valid) << "Validation worked when it should have failed.";
-            ASSERT_EQ(static_cast<size_t>(1), results.errors.size());
-        }
-        ASSERT_EQ(static_cast<size_t>(0), omitTransientWarningsFromCount(results));
-        ASSERT_EQ(static_cast<size_t>(0), results.extraIndexEntries.size());
-        ASSERT_EQ(static_cast<size_t>(0), results.missingIndexEntries.size());
-
-        dumpOnErrorGuard.dismiss();
-    }
-};
-
 class ValidateRepairOnClusteredCollection : public ValidateBase {
 public:
     ValidateRepairOnClusteredCollection()
@@ -4534,10 +4273,9 @@ public:
                                                      _nss,
                                                      mode,
                                                      CollectionValidation::RepairMode::kNone,
-                                                     /*additionalOptions=*/{},
                                                      &results,
                                                      &output,
-                                                     kLogDiagnostics));
+                                                     kTurnOnExtraLoggingForTest));
 
             ScopeGuard dumpOnErrorGuard([&] {
                 StorageDebugUtil::printValidateResults(results);
@@ -4566,10 +4304,9 @@ public:
                                                      _nss,
                                                      mode,
                                                      CollectionValidation::RepairMode::kFixErrors,
-                                                     /*additionalOptions=*/{},
                                                      &results,
                                                      &output,
-                                                     kLogDiagnostics));
+                                                     kTurnOnExtraLoggingForTest));
 
             ScopeGuard dumpOnErrorGuard([&] {
                 StorageDebugUtil::printValidateResults(results);
@@ -4687,10 +4424,9 @@ public:
                                                _nss,
                                                CollectionValidation::ValidateMode::kForegroundFull,
                                                CollectionValidation::RepairMode::kNone,
-                                               /*additionalOptions=*/{},
                                                &results,
                                                &output,
-                                               kLogDiagnostics));
+                                               kTurnOnExtraLoggingForTest));
 
             ScopeGuard dumpOnErrorGuard([&] {
                 StorageDebugUtil::printValidateResults(results);
@@ -4784,8 +4520,6 @@ public:
         add<ValidateInvalidBSONOnClusteredCollection<true>>();
         add<ValidateReportInfoOnClusteredCollection<false>>();
         add<ValidateReportInfoOnClusteredCollection<true>>();
-        add<ValidateDuplicateKeyOnClusteredCollection<true /*falsePositiveCase*/>>();
-        add<ValidateDuplicateKeyOnClusteredCollection<false /*falsePositiveCase*/>>();
         add<ValidateRepairOnClusteredCollection>();
 
         add<ValidateInvalidRecordIdOnClusteredCollection<false>>(false /*withSecondaryIndex*/);