SERVER-41772 Apply clang-format 7.0.1 to the codebase

Author: clang-format-7.0.1

jstests/aggregation/bugs/cond.js

@@ -1,88 +1,87 @@
 // $cond returns the evaluated second argument if the first evaluates to true but the evaluated
 // third argument if the first evaluates to false.
 (function() {
-    "use strict";
-    load('jstests/aggregation/extras/utils.js');
+"use strict";
+load('jstests/aggregation/extras/utils.js');
 
-    const coll = db.jstests_aggregation_cond;
-    coll.drop();
+const coll = db.jstests_aggregation_cond;
+coll.drop();
 
-    coll.save({});
+coll.save({});
 
-    function assertError(expectedErrorCode, condSpec) {
-        assertErrorCode(coll, {$project: {a: {$cond: condSpec}}}, expectedErrorCode);
-    }
+function assertError(expectedErrorCode, condSpec) {
+    assertErrorCode(coll, {$project: {a: {$cond: condSpec}}}, expectedErrorCode);
+}
 
-    function assertResult(expectedResult, arg) {
-        assert.eq(expectedResult, coll.aggregate({$project: {a: {$cond: arg}}}).toArray()[0].a);
-    }
+function assertResult(expectedResult, arg) {
+    assert.eq(expectedResult, coll.aggregate({$project: {a: {$cond: arg}}}).toArray()[0].a);
+}
 
-    // Wrong number of args.
-    assertError(16020, []);
-    assertError(16020, [1]);
-    assertError(16020, [false]);
-    assertError(16020, [1, 1]);
-    assertError(16020, [1, 1, null, 1]);
-    assertError(16020, [1, 1, 1, undefined]);
+// Wrong number of args.
+assertError(16020, []);
+assertError(16020, [1]);
+assertError(16020, [false]);
+assertError(16020, [1, 1]);
+assertError(16020, [1, 1, null, 1]);
+assertError(16020, [1, 1, 1, undefined]);
 
-    // Bad object cases.
-    assertError(17080, {"else": 1, then: 1});
-    assertError(17081, {"if": 1, "else": 1});
-    assertError(17082, {"if": 1, then: 1});
-    assertError(17083, {asdf: 1, then: 1});
+// Bad object cases.
+assertError(17080, {"else": 1, then: 1});
+assertError(17081, {"if": 1, "else": 1});
+assertError(17082, {"if": 1, then: 1});
+assertError(17083, {asdf: 1, then: 1});
 
-    // Literal expressions.
-    assertResult(1, [true, 1, 2]);
-    assertResult(2, [false, 1, 2]);
+// Literal expressions.
+assertResult(1, [true, 1, 2]);
+assertResult(2, [false, 1, 2]);
 
-    // Order independence for object case.
-    assertResult(1, {"if": true, "then": 1, "else": 2});
-    assertResult(1, {"if": true, "else": 2, "then": 1});
-    assertResult(1, {"then": 1, "if": true, "else": 2});
-    assertResult(1, {"then": 1, "else": 2, "if": true});
-    assertResult(1, {"else": 2, "then": 1, "if": true});
-    assertResult(1, {"else": 2, "if": true, "then": 1});
+// Order independence for object case.
+assertResult(1, {"if": true, "then": 1, "else": 2});
+assertResult(1, {"if": true, "else": 2, "then": 1});
+assertResult(1, {"then": 1, "if": true, "else": 2});
+assertResult(1, {"then": 1, "else": 2, "if": true});
+assertResult(1, {"else": 2, "then": 1, "if": true});
+assertResult(1, {"else": 2, "if": true, "then": 1});
 
-    // Computed expressions.
-    assertResult(1, [{$and: []}, {$add: [1]}, {$add: [1, 1]}]);
-    assertResult(2, [{$or: []}, {$add: [1]}, {$add: [1, 1]}]);
+// Computed expressions.
+assertResult(1, [{$and: []}, {$add: [1]}, {$add: [1, 1]}]);
+assertResult(2, [{$or: []}, {$add: [1]}, {$add: [1, 1]}]);
 
-    assert(coll.drop());
-    assert.writeOK(coll.insert({t: true, f: false, x: 'foo', y: 'bar'}));
+assert(coll.drop());
+assert.writeOK(coll.insert({t: true, f: false, x: 'foo', y: 'bar'}));
 
-    // Field path expressions.
-    assertResult('foo', ['$t', '$x', '$y']);
-    assertResult('bar', ['$f', '$x', '$y']);
+// Field path expressions.
+assertResult('foo', ['$t', '$x', '$y']);
+assertResult('bar', ['$f', '$x', '$y']);
 
-    assert(coll.drop());
-    assert.writeOK(coll.insert({}));
+assert(coll.drop());
+assert.writeOK(coll.insert({}));
 
-    // Coerce to bool.
-    assertResult('a', [1, 'a', 'b']);
-    assertResult('a', ['', 'a', 'b']);
-    assertResult('b', [0, 'a', 'b']);
+// Coerce to bool.
+assertResult('a', [1, 'a', 'b']);
+assertResult('a', ['', 'a', 'b']);
+assertResult('b', [0, 'a', 'b']);
 
-    // Nested.
-    assert(coll.drop());
-    assert.writeOK(coll.insert({noonSense: 'am', mealCombined: 'no'}));
-    assert.writeOK(coll.insert({noonSense: 'am', mealCombined: 'yes'}));
-    assert.writeOK(coll.insert({noonSense: 'pm', mealCombined: 'yes'}));
-    assert.writeOK(coll.insert({noonSense: 'pm', mealCombined: 'no'}));
-    assert.eq(
-        ['breakfast', 'brunch', 'dinner', 'linner'],
-        coll.aggregate([
-                {
-                  $project: {
-                      meal: {
-                          $cond: [
-                              {$eq: ['$noonSense', 'am']},
-                              {$cond: [{$eq: ['$mealCombined', 'yes']}, 'brunch', 'breakfast']},
-                              {$cond: [{$eq: ['$mealCombined', 'yes']}, 'linner', 'dinner']}
-                          ]
+// Nested.
+assert(coll.drop());
+assert.writeOK(coll.insert({noonSense: 'am', mealCombined: 'no'}));
+assert.writeOK(coll.insert({noonSense: 'am', mealCombined: 'yes'}));
+assert.writeOK(coll.insert({noonSense: 'pm', mealCombined: 'yes'}));
+assert.writeOK(coll.insert({noonSense: 'pm', mealCombined: 'no'}));
+assert.eq(['breakfast', 'brunch', 'dinner', 'linner'],
+          coll.aggregate([
+                  {
+                      $project: {
+                          meal: {
+                              $cond: [
+                                  {$eq: ['$noonSense', 'am']},
+                                  {$cond: [{$eq: ['$mealCombined', 'yes']}, 'brunch', 'breakfast']},
+                                  {$cond: [{$eq: ['$mealCombined', 'yes']}, 'linner', 'dinner']}
+                              ]
+                          }
                       }
-                  }
-                },
-                {$sort: {meal: 1}}
-            ])
-            .map(doc => doc.meal));
+                  },
+                  {$sort: {meal: 1}}
+              ])
+              .map(doc => doc.meal));
 }());

jstests/aggregation/bugs/cursor_timeout.js

@@ -7,83 +7,82 @@
  * ]
  */
 (function() {
-    'use strict';
+'use strict';
 
-    // Cursor timeout on mongod is handled by a single thread/timer that will sleep for
-    // "clientCursorMonitorFrequencySecs" and add the sleep value to each operation's duration when
-    // it wakes up, timing out those whose "now() - last accessed since" time exceeds. A cursor
-    // timeout of 2 seconds with a monitor frequency of 1 second means an effective timeout period
-    // of 1 to 2 seconds.
-    const cursorTimeoutMs = 2000;
-    const cursorMonitorFrequencySecs = 1;
+// Cursor timeout on mongod is handled by a single thread/timer that will sleep for
+// "clientCursorMonitorFrequencySecs" and add the sleep value to each operation's duration when
+// it wakes up, timing out those whose "now() - last accessed since" time exceeds. A cursor
+// timeout of 2 seconds with a monitor frequency of 1 second means an effective timeout period
+// of 1 to 2 seconds.
+const cursorTimeoutMs = 2000;
+const cursorMonitorFrequencySecs = 1;
 
-    const options = {
-        setParameter: {
-            internalDocumentSourceCursorBatchSizeBytes: 1,
-            // We use the "cursorTimeoutMillis" server parameter to decrease how long it takes for a
-            // non-exhausted cursor to time out. We use the "clientCursorMonitorFrequencySecs"
-            // server parameter to make the ClientCursorMonitor that cleans up the timed out cursors
-            // run more often. The combination of these server parameters reduces the amount of time
-            // we need to wait within this test.
-            cursorTimeoutMillis: cursorTimeoutMs,
-            clientCursorMonitorFrequencySecs: cursorMonitorFrequencySecs,
-        }
-    };
-    const conn = MongoRunner.runMongod(options);
-    assert.neq(null, conn, 'mongod was unable to start up with options: ' + tojson(options));
+const options = {
+    setParameter: {
+        internalDocumentSourceCursorBatchSizeBytes: 1,
+        // We use the "cursorTimeoutMillis" server parameter to decrease how long it takes for a
+        // non-exhausted cursor to time out. We use the "clientCursorMonitorFrequencySecs"
+        // server parameter to make the ClientCursorMonitor that cleans up the timed out cursors
+        // run more often. The combination of these server parameters reduces the amount of time
+        // we need to wait within this test.
+        cursorTimeoutMillis: cursorTimeoutMs,
+        clientCursorMonitorFrequencySecs: cursorMonitorFrequencySecs,
+    }
+};
+const conn = MongoRunner.runMongod(options);
+assert.neq(null, conn, 'mongod was unable to start up with options: ' + tojson(options));
 
-    const testDB = conn.getDB('test');
+const testDB = conn.getDB('test');
 
-    // We use a batch size of 2 to ensure that the mongo shell does not exhaust the cursor on its
-    // first batch.
-    const batchSize = 2;
-    const numMatches = 5;
+// We use a batch size of 2 to ensure that the mongo shell does not exhaust the cursor on its
+// first batch.
+const batchSize = 2;
+const numMatches = 5;
 
-    function assertCursorTimesOut(collName, pipeline) {
-        const res = assert.commandWorked(testDB.runCommand({
-            aggregate: collName,
-            pipeline: pipeline,
-            cursor: {
-                batchSize: batchSize,
-            },
-        }));
+function assertCursorTimesOut(collName, pipeline) {
+    const res = assert.commandWorked(testDB.runCommand({
+        aggregate: collName,
+        pipeline: pipeline,
+        cursor: {
+            batchSize: batchSize,
+        },
+    }));
 
-        let serverStatus = assert.commandWorked(testDB.serverStatus());
-        const expectedNumTimedOutCursors = serverStatus.metrics.cursor.timedOut + 1;
+    let serverStatus = assert.commandWorked(testDB.serverStatus());
+    const expectedNumTimedOutCursors = serverStatus.metrics.cursor.timedOut + 1;
 
-        const cursor = new DBCommandCursor(testDB, res, batchSize);
+    const cursor = new DBCommandCursor(testDB, res, batchSize);
 
-        // Wait until the idle cursor background job has killed the aggregation cursor.
-        assert.soon(
-            function() {
-                serverStatus = assert.commandWorked(testDB.serverStatus());
-                return +serverStatus.metrics.cursor.timedOut === expectedNumTimedOutCursors;
-            },
-            function() {
-                return "aggregation cursor failed to time out: " +
-                    tojson(serverStatus.metrics.cursor);
-            });
+    // Wait until the idle cursor background job has killed the aggregation cursor.
+    assert.soon(
+        function() {
+            serverStatus = assert.commandWorked(testDB.serverStatus());
+            return +serverStatus.metrics.cursor.timedOut === expectedNumTimedOutCursors;
+        },
+        function() {
+            return "aggregation cursor failed to time out: " + tojson(serverStatus.metrics.cursor);
+        });
 
-        assert.eq(0, serverStatus.metrics.cursor.open.total, tojson(serverStatus));
+    assert.eq(0, serverStatus.metrics.cursor.open.total, tojson(serverStatus));
 
-        // We attempt to exhaust the aggregation cursor to verify that sending a getMore returns an
-        // error due to the cursor being killed.
-        let err = assert.throws(function() {
-            cursor.itcount();
-        });
-        assert.eq(ErrorCodes.CursorNotFound, err.code, tojson(err));
-    }
+    // We attempt to exhaust the aggregation cursor to verify that sending a getMore returns an
+    // error due to the cursor being killed.
+    let err = assert.throws(function() {
+        cursor.itcount();
+    });
+    assert.eq(ErrorCodes.CursorNotFound, err.code, tojson(err));
+}
 
-    assert.writeOK(testDB.source.insert({local: 1}));
-    for (let i = 0; i < numMatches; ++i) {
-        assert.writeOK(testDB.dest.insert({foreign: 1}));
-    }
+assert.writeOK(testDB.source.insert({local: 1}));
+for (let i = 0; i < numMatches; ++i) {
+    assert.writeOK(testDB.dest.insert({foreign: 1}));
+}
 
-    // Test that a regular aggregation cursor is killed when the timeout is reached.
-    assertCursorTimesOut('dest', []);
+// Test that a regular aggregation cursor is killed when the timeout is reached.
+assertCursorTimesOut('dest', []);
 
-    // Test that an aggregation cursor with a $lookup stage is killed when the timeout is reached.
-    assertCursorTimesOut('source', [
+// Test that an aggregation cursor with a $lookup stage is killed when the timeout is reached.
+assertCursorTimesOut('source', [
         {
           $lookup: {
               from: 'dest',
@@ -97,9 +96,9 @@
         },
     ]);
 
-    // Test that an aggregation cursor with nested $lookup stages is killed when the timeout is
-    // reached.
-    assertCursorTimesOut('source', [
+// Test that an aggregation cursor with nested $lookup stages is killed when the timeout is
+// reached.
+assertCursorTimesOut('source', [
         {
           $lookup: {
               from: 'dest',
@@ -126,5 +125,5 @@
         },
     ]);
 
-    MongoRunner.stopMongod(conn);
+MongoRunner.stopMongod(conn);
 })();

jstests/aggregation/bugs/explain_options_helper.js

@@ -2,23 +2,25 @@
 // This test was designed to reproduce SERVER-32300".
 
 (function() {
-    "use strict";
+"use strict";
 
-    const coll = db.explain_options;
-    coll.drop();
+const coll = db.explain_options;
+coll.drop();
 
-    for (let i = 0; i < 10; ++i) {
-        assert.writeOK(coll.insert({_id: i}));
-    }
+for (let i = 0; i < 10; ++i) {
+    assert.writeOK(coll.insert({_id: i}));
+}
 
-    const collation = {collation: {locale: "zh", backwards: false}};
+const collation = {
+    collation: {locale: "zh", backwards: false}
+};
 
-    const firstResults = coll.aggregate([{$sort: {_id: 1}}], collation).toArray();
-    // Issue an explain in order to verify that 'collation' is not modified to include the explain
-    // flag.
-    assert.commandWorked(coll.explain().aggregate([], collation));
+const firstResults = coll.aggregate([{$sort: {_id: 1}}], collation).toArray();
+// Issue an explain in order to verify that 'collation' is not modified to include the explain
+// flag.
+assert.commandWorked(coll.explain().aggregate([], collation));
 
-    const secondResults = coll.aggregate([{$sort: {_id: 1}}], collation).toArray();
-    // Assert that the result didn't change after an explain helper is issued.
-    assert.eq(firstResults, secondResults);
+const secondResults = coll.aggregate([{$sort: {_id: 1}}], collation).toArray();
+// Assert that the result didn't change after an explain helper is issued.
+assert.eq(firstResults, secondResults);
 }());