Apply formatting per `clang-format-7.0.1`

1 files changed, 263 insertions, 264 deletions

diff --git a/jstests/core/explain_find_and_modify.js b/jstests/core/explain_find_and_modify.js
index a0ba989dd0e..8b7c65d519e 100644
--- a/jstests/core/explain_find_and_modify.js
+++ b/jstests/core/explain_find_and_modify.js
@@ -12,300 +12,299 @@
  * 5. The reported stats should reflect how the command would be executed.
  */
 (function() {
-    "use strict";
-    var cName = "explain_find_and_modify";
-    var t = db.getCollection(cName);
+"use strict";
+var cName = "explain_find_and_modify";
+var t = db.getCollection(cName);
 
-    // Different types of findAndModify explain requests.
-    var explainRemove = {explain: {findAndModify: cName, remove: true, query: {_id: 0}}};
-    var explainUpdate = {explain: {findAndModify: cName, update: {$inc: {i: 1}}, query: {_id: 0}}};
-    var explainUpsert = {
-        explain: {findAndModify: cName, update: {$inc: {i: 1}}, query: {_id: 0}, upsert: true}
-    };
+// Different types of findAndModify explain requests.
+var explainRemove = {explain: {findAndModify: cName, remove: true, query: {_id: 0}}};
+var explainUpdate = {explain: {findAndModify: cName, update: {$inc: {i: 1}}, query: {_id: 0}}};
+var explainUpsert = {
+    explain: {findAndModify: cName, update: {$inc: {i: 1}}, query: {_id: 0}, upsert: true}
+};
 
-    // 1. Explaining findAndModify should never create a database.
+// 1. Explaining findAndModify should never create a database.
 
-    // Make sure this one doesn't exist before we start.
-    assert.commandWorked(db.getSiblingDB(cName).runCommand({dropDatabase: 1}));
-    var newDB = db.getSiblingDB(cName);
+// Make sure this one doesn't exist before we start.
+assert.commandWorked(db.getSiblingDB(cName).runCommand({dropDatabase: 1}));
+var newDB = db.getSiblingDB(cName);
 
-    // Explain the command, ensuring the database is not created.
-    var err_msg = "Explaining findAndModify on a non-existent database should return an error.";
-    assert.commandFailed(newDB.runCommand(explainRemove), err_msg);
-    assertDBDoesNotExist(newDB, "Explaining a remove should not create a database.");
+// Explain the command, ensuring the database is not created.
+var err_msg = "Explaining findAndModify on a non-existent database should return an error.";
+assert.commandFailed(newDB.runCommand(explainRemove), err_msg);
+assertDBDoesNotExist(newDB, "Explaining a remove should not create a database.");
 
-    assert.commandFailed(newDB.runCommand(explainUpsert), err_msg);
-    assertDBDoesNotExist(newDB, "Explaining an upsert should not create a database.");
+assert.commandFailed(newDB.runCommand(explainUpsert), err_msg);
+assertDBDoesNotExist(newDB, "Explaining an upsert should not create a database.");
 
-    // 2. Explaining findAndModify should never create a collection.
+// 2. Explaining findAndModify should never create a collection.
 
-    // Insert a document to make sure the database exists.
-    t.insert({'will': 'be dropped'});
-    // Make sure the collection doesn't exist.
-    t.drop();
+// Insert a document to make sure the database exists.
+t.insert({'will': 'be dropped'});
+// Make sure the collection doesn't exist.
+t.drop();
 
-    // Explain the command, ensuring the collection is not created.
-    assert.commandWorked(db.runCommand(explainRemove));
-    assertCollDoesNotExist(cName, "explaining a remove should not create a new collection.");
+// Explain the command, ensuring the collection is not created.
+assert.commandWorked(db.runCommand(explainRemove));
+assertCollDoesNotExist(cName, "explaining a remove should not create a new collection.");
 
-    assert.commandWorked(db.runCommand(explainUpsert));
-    assertCollDoesNotExist(cName, "explaining an upsert should not create a new collection.");
+assert.commandWorked(db.runCommand(explainUpsert));
+assertCollDoesNotExist(cName, "explaining an upsert should not create a new collection.");
 
-    assert.commandWorked(db.runCommand(Object.merge(explainUpsert, {fields: {x: 1}})));
-    assertCollDoesNotExist(cName, "explaining an upsert should not create a new collection.");
+assert.commandWorked(db.runCommand(Object.merge(explainUpsert, {fields: {x: 1}})));
+assertCollDoesNotExist(cName, "explaining an upsert should not create a new collection.");
 
-    // 3. Explaining findAndModify should not work with an invalid findAndModify command object.
+// 3. Explaining findAndModify should not work with an invalid findAndModify command object.
 
-    // Specifying both remove and new is illegal.
-    assert.commandFailed(db.runCommand({remove: true, new: true}));
+// Specifying both remove and new is illegal.
+assert.commandFailed(db.runCommand({remove: true, new: true}));
 
-    // 4. Explaining findAndModify should not modify any contents of the collection.
-    var onlyDoc = {_id: 0, i: 1};
-    assert.writeOK(t.insert(onlyDoc));
+// 4. Explaining findAndModify should not modify any contents of the collection.
+var onlyDoc = {_id: 0, i: 1};
+assert.writeOK(t.insert(onlyDoc));
 
-    // Explaining a delete should not delete anything.
-    var matchingRemoveCmd = {findAndModify: cName, remove: true, query: {_id: onlyDoc._id}};
-    var res = db.runCommand({explain: matchingRemoveCmd});
-    assert.commandWorked(res);
-    assert.eq(t.find().itcount(), 1, "Explaining a remove should not remove any documents.");
+// Explaining a delete should not delete anything.
+var matchingRemoveCmd = {findAndModify: cName, remove: true, query: {_id: onlyDoc._id}};
+var res = db.runCommand({explain: matchingRemoveCmd});
+assert.commandWorked(res);
+assert.eq(t.find().itcount(), 1, "Explaining a remove should not remove any documents.");
 
-    // Explaining an update should not update anything.
-    var matchingUpdateCmd = {findAndModify: cName, update: {x: "x"}, query: {_id: onlyDoc._id}};
-    var res = db.runCommand({explain: matchingUpdateCmd});
-    assert.commandWorked(res);
-    assert.eq(t.findOne(), onlyDoc, "Explaining an update should not update any documents.");
+// Explaining an update should not update anything.
+var matchingUpdateCmd = {findAndModify: cName, update: {x: "x"}, query: {_id: onlyDoc._id}};
+var res = db.runCommand({explain: matchingUpdateCmd});
+assert.commandWorked(res);
+assert.eq(t.findOne(), onlyDoc, "Explaining an update should not update any documents.");
 
-    // Explaining an upsert should not insert anything.
-    var matchingUpsertCmd =
-        {findAndModify: cName, update: {x: "x"}, query: {_id: "non-match"}, upsert: true};
-    var res = db.runCommand({explain: matchingUpsertCmd});
-    assert.commandWorked(res);
-    assert.eq(t.find().itcount(), 1, "Explaining an upsert should not insert any documents.");
+// Explaining an upsert should not insert anything.
+var matchingUpsertCmd =
+    {findAndModify: cName, update: {x: "x"}, query: {_id: "non-match"}, upsert: true};
+var res = db.runCommand({explain: matchingUpsertCmd});
+assert.commandWorked(res);
+assert.eq(t.find().itcount(), 1, "Explaining an upsert should not insert any documents.");
 
-    // 5. The reported stats should reflect how it would execute and what it would modify.
-    var isMongos = db.runCommand({isdbgrid: 1}).isdbgrid;
+// 5. The reported stats should reflect how it would execute and what it would modify.
+var isMongos = db.runCommand({isdbgrid: 1}).isdbgrid;
 
-    // List out the command to be explained, and the expected results of that explain.
-    var testCases = [
-        // -------------------------------------- Removes ----------------------------------------
-        {
-          // Non-matching remove command.
-          cmd: {remove: true, query: {_id: "no-match"}},
-          expectedResult: {
-              executionStats: {
-                  nReturned: 0,
-                  executionSuccess: true,
-                  executionStages: {stage: "DELETE", nWouldDelete: 0}
-              }
-          }
-        },
-        {
-          // Matching remove command.
-          cmd: {remove: true, query: {_id: onlyDoc._id}},
-          expectedResult: {
-              executionStats: {
-                  nReturned: 1,
-                  executionSuccess: true,
-                  executionStages: {stage: "DELETE", nWouldDelete: 1}
-              }
-          }
-        },
-        // -------------------------------------- Updates ----------------------------------------
-        {
-          // Non-matching update query.
-          cmd: {update: {$inc: {i: 1}}, query: {_id: "no-match"}},
-          expectedResult: {
-              executionStats: {
-                  nReturned: 0,
-                  executionSuccess: true,
-                  executionStages: {stage: "UPDATE", nWouldModify: 0, wouldInsert: false}
-              }
-          }
-        },
-        {
-          // Non-matching update query, returning new doc.
-          cmd: {update: {$inc: {i: 1}}, query: {_id: "no-match"}, new: true},
-          expectedResult: {
-              executionStats: {
-                  nReturned: 0,
-                  executionSuccess: true,
-                  executionStages: {stage: "UPDATE", nWouldModify: 0, wouldInsert: false}
-              }
-          }
-        },
-        {
-          // Matching update query.
-          cmd: {update: {$inc: {i: 1}}, query: {_id: onlyDoc._id}},
-          expectedResult: {
-              executionStats: {
-                  nReturned: 1,
-                  executionSuccess: true,
-                  executionStages: {stage: "UPDATE", nWouldModify: 1, wouldInsert: false}
-              }
-          }
-        },
-        {
-          // Matching update query, returning new doc.
-          cmd: {update: {$inc: {i: 1}}, query: {_id: onlyDoc._id}, new: true},
-          expectedResult: {
-              executionStats: {
-                  nReturned: 1,
-                  executionSuccess: true,
-                  executionStages: {stage: "UPDATE", nWouldModify: 1, wouldInsert: false}
-              }
-          }
-        },
-        // -------------------------------------- Upserts ----------------------------------------
-        {
-          // Non-matching upsert query.
-          cmd: {update: {$inc: {i: 1}}, upsert: true, query: {_id: "no-match"}},
-          expectedResult: {
-              executionStats: {
-                  nReturned: 0,
-                  executionSuccess: true,
-                  executionStages: {stage: "UPDATE", nWouldModify: 0, wouldInsert: true}
-              }
-          }
-        },
-        {
-          // Non-matching upsert query, returning new doc.
-          cmd: {update: {$inc: {i: 1}}, upsert: true, query: {_id: "no-match"}, new: true},
-          expectedResult: {
-              executionStats: {
-                  nReturned: 1,
-                  executionSuccess: true,
-                  executionStages: {stage: "UPDATE", nWouldModify: 0, wouldInsert: true}
-              }
-          }
-        },
-        {
-          // Matching upsert query, returning new doc.
-          cmd: {update: {$inc: {i: 1}}, upsert: true, query: {_id: onlyDoc._id}, new: true},
-          expectedResult: {
-              executionStats: {
-                  nReturned: 1,
-                  executionSuccess: true,
-                  executionStages: {stage: "UPDATE", nWouldModify: 1, wouldInsert: false}
-              }
-          }
+// List out the command to be explained, and the expected results of that explain.
+var testCases = [
+    // -------------------------------------- Removes ----------------------------------------
+    {
+        // Non-matching remove command.
+        cmd: {remove: true, query: {_id: "no-match"}},
+        expectedResult: {
+            executionStats: {
+                nReturned: 0,
+                executionSuccess: true,
+                executionStages: {stage: "DELETE", nWouldDelete: 0}
+            }
         }
-    ];
-
-    // Apply all the same test cases, this time adding a projection stage.
-    testCases = testCases.concat(testCases.map(function makeProjection(testCase) {
-        return {
-            cmd: Object.merge(testCase.cmd, {fields: {i: 0}}),
-            expectedResult: {
-                executionStats: {
-                    // nReturned Shouldn't change.
-                    nReturned: testCase.expectedResult.executionStats.nReturned,
-                    executionStages: {
-                        stage: "PROJECTION_DEFAULT",
-                        transformBy: {i: 0},
-                        // put previous root stage under projection stage.
-                        inputStage: testCase.expectedResult.executionStats.executionStages
-                    }
-                }
+    },
+    {
+        // Matching remove command.
+        cmd: {remove: true, query: {_id: onlyDoc._id}},
+        expectedResult: {
+            executionStats: {
+                nReturned: 1,
+                executionSuccess: true,
+                executionStages: {stage: "DELETE", nWouldDelete: 1}
             }
-        };
-    }));
-    // Actually assert on the test cases.
-    testCases.forEach(function(testCase) {
-        assertExplainMatchedAllVerbosities(testCase.cmd, testCase.expectedResult);
-    });
-
-    // ----------------------------------------- Helpers -----------------------------------------
-
-    /**
-     * Helper to make this test work in the sharding passthrough suite.
-     *
-     * Transforms the explain output so that if it came from a mongos, it will be modified
-     * to have the same format as though it had come from a mongod.
-     */
-    function transformIfSharded(explainOut) {
-        if (!isMongos) {
-            return explainOut;
         }
+    },
+    // -------------------------------------- Updates ----------------------------------------
+    {
+        // Non-matching update query.
+        cmd: {update: {$inc: {i: 1}}, query: {_id: "no-match"}},
+        expectedResult: {
+            executionStats: {
+                nReturned: 0,
+                executionSuccess: true,
+                executionStages: {stage: "UPDATE", nWouldModify: 0, wouldInsert: false}
+            }
+        }
+    },
+    {
+        // Non-matching update query, returning new doc.
+        cmd: {update: {$inc: {i: 1}}, query: {_id: "no-match"}, new: true},
+        expectedResult: {
+            executionStats: {
+                nReturned: 0,
+                executionSuccess: true,
+                executionStages: {stage: "UPDATE", nWouldModify: 0, wouldInsert: false}
+            }
+        }
+    },
+    {
+        // Matching update query.
+        cmd: {update: {$inc: {i: 1}}, query: {_id: onlyDoc._id}},
+        expectedResult: {
+            executionStats: {
+                nReturned: 1,
+                executionSuccess: true,
+                executionStages: {stage: "UPDATE", nWouldModify: 1, wouldInsert: false}
+            }
+        }
+    },
+    {
+        // Matching update query, returning new doc.
+        cmd: {update: {$inc: {i: 1}}, query: {_id: onlyDoc._id}, new: true},
+        expectedResult: {
+            executionStats: {
+                nReturned: 1,
+                executionSuccess: true,
+                executionStages: {stage: "UPDATE", nWouldModify: 1, wouldInsert: false}
+            }
+        }
+    },
+    // -------------------------------------- Upserts ----------------------------------------
+    {
+        // Non-matching upsert query.
+        cmd: {update: {$inc: {i: 1}}, upsert: true, query: {_id: "no-match"}},
+        expectedResult: {
+            executionStats: {
+                nReturned: 0,
+                executionSuccess: true,
+                executionStages: {stage: "UPDATE", nWouldModify: 0, wouldInsert: true}
+            }
+        }
+    },
+    {
+        // Non-matching upsert query, returning new doc.
+        cmd: {update: {$inc: {i: 1}}, upsert: true, query: {_id: "no-match"}, new: true},
+        expectedResult: {
+            executionStats: {
+                nReturned: 1,
+                executionSuccess: true,
+                executionStages: {stage: "UPDATE", nWouldModify: 0, wouldInsert: true}
+            }
+        }
+    },
+    {
+        // Matching upsert query, returning new doc.
+        cmd: {update: {$inc: {i: 1}}, upsert: true, query: {_id: onlyDoc._id}, new: true},
+        expectedResult: {
+            executionStats: {
+                nReturned: 1,
+                executionSuccess: true,
+                executionStages: {stage: "UPDATE", nWouldModify: 1, wouldInsert: false}
+            }
+        }
+    }
+];
 
-        // Asserts that the explain command ran on a single shard and modifies the given
-        // explain output to have a top-level UPDATE or DELETE stage by removing the
-        // top-level SINGLE_SHARD stage.
-        function replace(outerKey, innerKey) {
-            assert(explainOut.hasOwnProperty(outerKey));
-            assert(explainOut[outerKey].hasOwnProperty(innerKey));
-
-            var shardStage = explainOut[outerKey][innerKey];
-            assert.eq("SINGLE_SHARD", shardStage.stage);
-            assert.eq(1, shardStage.shards.length);
-            Object.extend(explainOut[outerKey], shardStage.shards[0], false);
+// Apply all the same test cases, this time adding a projection stage.
+testCases = testCases.concat(testCases.map(function makeProjection(testCase) {
+    return {
+        cmd: Object.merge(testCase.cmd, {fields: {i: 0}}),
+        expectedResult: {
+            executionStats: {
+                // nReturned Shouldn't change.
+                nReturned: testCase.expectedResult.executionStats.nReturned,
+                executionStages: {
+                    stage: "PROJECTION_DEFAULT",
+                    transformBy: {i: 0},
+                    // put previous root stage under projection stage.
+                    inputStage: testCase.expectedResult.executionStats.executionStages
+                }
+            }
         }
+    };
+}));
+// Actually assert on the test cases.
+testCases.forEach(function(testCase) {
+    assertExplainMatchedAllVerbosities(testCase.cmd, testCase.expectedResult);
+});
 
-        replace("queryPlanner", "winningPlan");
-        replace("executionStats", "executionStages");
+// ----------------------------------------- Helpers -----------------------------------------
 
+/**
+ * Helper to make this test work in the sharding passthrough suite.
+ *
+ * Transforms the explain output so that if it came from a mongos, it will be modified
+ * to have the same format as though it had come from a mongod.
+ */
+function transformIfSharded(explainOut) {
+    if (!isMongos) {
         return explainOut;
     }
 
-    /**
-     * Assert the results from running the explain match the expected results.
-     *
-     * Since we aren't expecting a perfect match (we only specify a subset of the fields we expect
-     * to match), recursively go through the expected results, and make sure each one has a
-     * corresponding field on the actual results, and that their values match.
-     * Example doc for expectedMatches:
-     * {executionStats: {nReturned: 0, executionStages: {isEOF: 1}}}
-     */
-    function assertExplainResultsMatch(explainOut, expectedMatches, preMsg, currentPath) {
-        // This is only used recursively, to keep track of where we are in the document.
-        var isRootLevel = typeof currentPath === "undefined";
-        Object.keys(expectedMatches).forEach(function(key) {
-            var totalFieldName = isRootLevel ? key : currentPath + "." + key;
-            assert(explainOut.hasOwnProperty(key),
-                   preMsg + "Explain's output does not have a value for " + key);
-            if (typeof expectedMatches[key] === "object") {
-                // Sub-doc, recurse to match on it's fields
-                assertExplainResultsMatch(
-                    explainOut[key], expectedMatches[key], preMsg, totalFieldName);
-            } else {
-                assert.eq(explainOut[key],
-                          expectedMatches[key],
-                          preMsg + "Explain's " + totalFieldName + " (" + explainOut[key] + ")" +
-                              " does not match expected value (" + expectedMatches[key] + ").");
-            }
-        });
-    }
+    // Asserts that the explain command ran on a single shard and modifies the given
+    // explain output to have a top-level UPDATE or DELETE stage by removing the
+    // top-level SINGLE_SHARD stage.
+    function replace(outerKey, innerKey) {
+        assert(explainOut.hasOwnProperty(outerKey));
+        assert(explainOut[outerKey].hasOwnProperty(innerKey));
 
-    /**
-     * Assert that running explain on the given findAndModify command matches the expected results,
-     * on all the different verbosities (but just assert the command worked on the lowest verbosity,
-     * since it doesn't have any useful stats).
-     */
-    function assertExplainMatchedAllVerbosities(findAndModifyArgs, expectedResult) {
-        ["queryPlanner", "executionStats", "allPlansExecution"].forEach(function(verbosityMode) {
-            var cmd = {
-                explain: Object.merge({findAndModify: cName}, findAndModifyArgs),
-                verbosity: verbosityMode
-            };
-            var msg = "Error after running command: " + tojson(cmd) + ": ";
-            var explainOut = db.runCommand(cmd);
-            assert.commandWorked(explainOut, "command: " + tojson(cmd));
-            // Don't check explain results for queryPlanner mode, as that doesn't have any of the
-            // interesting stats.
-            if (verbosityMode !== "queryPlanner") {
-                explainOut = transformIfSharded(explainOut);
-                assertExplainResultsMatch(explainOut, expectedResult, msg);
-            }
-        });
+        var shardStage = explainOut[outerKey][innerKey];
+        assert.eq("SINGLE_SHARD", shardStage.stage);
+        assert.eq(1, shardStage.shards.length);
+        Object.extend(explainOut[outerKey], shardStage.shards[0], false);
     }
 
-    function assertDBDoesNotExist(db, msg) {
-        assert.eq(db.getMongo().getDBNames().indexOf(db.getName()),
-                  -1,
-                  msg + "db " + db.getName() + " exists.");
-    }
+    replace("queryPlanner", "winningPlan");
+    replace("executionStats", "executionStages");
 
-    function assertCollDoesNotExist(cName, msg) {
-        assert.eq(
-            db.getCollectionNames().indexOf(cName), -1, msg + "collection " + cName + " exists.");
-    }
+    return explainOut;
+}
+
+/**
+ * Assert the results from running the explain match the expected results.
+ *
+ * Since we aren't expecting a perfect match (we only specify a subset of the fields we expect
+ * to match), recursively go through the expected results, and make sure each one has a
+ * corresponding field on the actual results, and that their values match.
+ * Example doc for expectedMatches:
+ * {executionStats: {nReturned: 0, executionStages: {isEOF: 1}}}
+ */
+function assertExplainResultsMatch(explainOut, expectedMatches, preMsg, currentPath) {
+    // This is only used recursively, to keep track of where we are in the document.
+    var isRootLevel = typeof currentPath === "undefined";
+    Object.keys(expectedMatches).forEach(function(key) {
+        var totalFieldName = isRootLevel ? key : currentPath + "." + key;
+        assert(explainOut.hasOwnProperty(key),
+               preMsg + "Explain's output does not have a value for " + key);
+        if (typeof expectedMatches[key] === "object") {
+            // Sub-doc, recurse to match on it's fields
+            assertExplainResultsMatch(
+                explainOut[key], expectedMatches[key], preMsg, totalFieldName);
+        } else {
+            assert.eq(explainOut[key],
+                      expectedMatches[key],
+                      preMsg + "Explain's " + totalFieldName + " (" + explainOut[key] + ")" +
+                          " does not match expected value (" + expectedMatches[key] + ").");
+        }
+    });
+}
+
+/**
+ * Assert that running explain on the given findAndModify command matches the expected results,
+ * on all the different verbosities (but just assert the command worked on the lowest verbosity,
+ * since it doesn't have any useful stats).
+ */
+function assertExplainMatchedAllVerbosities(findAndModifyArgs, expectedResult) {
+    ["queryPlanner", "executionStats", "allPlansExecution"].forEach(function(verbosityMode) {
+        var cmd = {
+            explain: Object.merge({findAndModify: cName}, findAndModifyArgs),
+            verbosity: verbosityMode
+        };
+        var msg = "Error after running command: " + tojson(cmd) + ": ";
+        var explainOut = db.runCommand(cmd);
+        assert.commandWorked(explainOut, "command: " + tojson(cmd));
+        // Don't check explain results for queryPlanner mode, as that doesn't have any of the
+        // interesting stats.
+        if (verbosityMode !== "queryPlanner") {
+            explainOut = transformIfSharded(explainOut);
+            assertExplainResultsMatch(explainOut, expectedResult, msg);
+        }
+    });
+}
+
+function assertDBDoesNotExist(db, msg) {
+    assert.eq(db.getMongo().getDBNames().indexOf(db.getName()),
+              -1,
+              msg + "db " + db.getName() + " exists.");
+}
+
+function assertCollDoesNotExist(cName, msg) {
+    assert.eq(db.getCollectionNames().indexOf(cName), -1, msg + "collection " + cName + " exists.");
+}
 })();