1 files changed, 225 insertions, 228 deletions
diff --git a/src/mongo/db/ops/log_builder_test.cpp b/src/mongo/db/ops/log_builder_test.cpp
index 253dd70e5a1..f2a3d20aa78 100644
--- a/src/mongo/db/ops/log_builder_test.cpp
+++ b/src/mongo/db/ops/log_builder_test.cpp
@@ -36,243 +36,240 @@
 
 namespace {
 
-    namespace mmb = mongo::mutablebson;
-    using mongo::LogBuilder;
+namespace mmb = mongo::mutablebson;
+using mongo::LogBuilder;
 
-    TEST(LogBuilder, Initialization) {
-        mmb::Document doc;
-        LogBuilder lb(doc.root());
-        ASSERT_EQUALS(&doc, &lb.getDocument());
-    }
+TEST(LogBuilder, Initialization) {
+    mmb::Document doc;
+    LogBuilder lb(doc.root());
+    ASSERT_EQUALS(&doc, &lb.getDocument());
+}
 
-    TEST(LogBuilder, AddOneToSet) {
-        mmb::Document doc;
-        LogBuilder lb(doc.root());
+TEST(LogBuilder, AddOneToSet) {
+    mmb::Document doc;
+    LogBuilder lb(doc.root());
 
-        const mmb::Element elt_ab = doc.makeElementInt("a.b", 1);
-        ASSERT_TRUE(elt_ab.ok());
-        ASSERT_OK(lb.addToSets(elt_ab));
+    const mmb::Element elt_ab = doc.makeElementInt("a.b", 1);
+    ASSERT_TRUE(elt_ab.ok());
+    ASSERT_OK(lb.addToSets(elt_ab));
 
-        ASSERT_EQUALS(mongo::fromjson("{ $set : { 'a.b' : 1 } }"), doc);
-    }
+    ASSERT_EQUALS(mongo::fromjson("{ $set : { 'a.b' : 1 } }"), doc);
+}
 
-    TEST(LogBuilder, AddElementToSet) {
-        mmb::Document doc;
-        LogBuilder lb(doc.root());
+TEST(LogBuilder, AddElementToSet) {
+    mmb::Document doc;
+    LogBuilder lb(doc.root());
 
-        const mmb::Element elt_ab = doc.makeElementInt("", 1);
-        ASSERT_TRUE(elt_ab.ok());
-        ASSERT_OK(lb.addToSetsWithNewFieldName("a.b", elt_ab));
+    const mmb::Element elt_ab = doc.makeElementInt("", 1);
+    ASSERT_TRUE(elt_ab.ok());
+    ASSERT_OK(lb.addToSetsWithNewFieldName("a.b", elt_ab));
 
-        ASSERT_EQUALS(mongo::fromjson("{ $set : { 'a.b' : 1 } }"), doc);
-    }
+    ASSERT_EQUALS(mongo::fromjson("{ $set : { 'a.b' : 1 } }"), doc);
+}
 
-    TEST(LogBuilder, AddBSONElementToSet) {
-        mmb::Document doc;
-        LogBuilder lb(doc.root());
+TEST(LogBuilder, AddBSONElementToSet) {
+    mmb::Document doc;
+    LogBuilder lb(doc.root());
 
-        mongo::BSONObj obj = mongo::fromjson("{'':1}");
-
-        ASSERT_OK(lb.addToSetsWithNewFieldName("a.b", obj.firstElement()));
+    mongo::BSONObj obj = mongo::fromjson("{'':1}");
 
-        ASSERT_EQUALS(mongo::fromjson("{ $set : { 'a.b' : 1 } }"), doc);
-    }
+    ASSERT_OK(lb.addToSetsWithNewFieldName("a.b", obj.firstElement()));
 
-    TEST(LogBuilder, AddSafeNumToSet) {
-        mmb::Document doc;
-        LogBuilder lb(doc.root());
+    ASSERT_EQUALS(mongo::fromjson("{ $set : { 'a.b' : 1 } }"), doc);
+}
 
-        mongo::BSONObj obj = mongo::fromjson("{'':1}");
-
-        ASSERT_OK(lb.addToSets("a.b", mongo::SafeNum(1)));
-
-        ASSERT_EQUALS(mongo::fromjson("{ $set : { 'a.b' : 1 } }"), doc);
-    }
-
-    TEST(LogBuilder, AddOneToUnset) {
-        mmb::Document doc;
-        LogBuilder lb(doc.root());
-        ASSERT_OK(lb.addToUnsets("x.y"));
-        ASSERT_EQUALS(mongo::fromjson("{ $unset : { 'x.y' : true } }"), doc);
-    }
-
-    TEST(LogBuilder, AddOneToEach) {
-        mmb::Document doc;
-        LogBuilder lb(doc.root());
-
-        const mmb::Element elt_ab = doc.makeElementInt("a.b", 1);
-        ASSERT_TRUE(elt_ab.ok());
-        ASSERT_OK(lb.addToSets(elt_ab));
-
-        ASSERT_OK(lb.addToUnsets("x.y"));
-
-        ASSERT_EQUALS(
-            mongo::fromjson(
-                "{ "
-                "   $set : { 'a.b' : 1 }, "
-                "   $unset : { 'x.y' : true } "
-                "}"
-                ), doc);
-    }
-
-    TEST(LogBuilder, AddOneObjectReplacementEntry) {
-        mmb::Document doc;
-        LogBuilder lb(doc.root());
-
-        mmb::Element replacement = doc.end();
-        ASSERT_FALSE(replacement.ok());
-        ASSERT_OK(lb.getReplacementObject(&replacement));
-        ASSERT_TRUE(replacement.ok());
-        ASSERT_TRUE(replacement.isType(mongo::Object));
-
-        const mmb::Element elt_a = doc.makeElementInt("a", 1);
-        ASSERT_TRUE(elt_a.ok());
-        ASSERT_OK(replacement.pushBack(elt_a));
-
-        ASSERT_EQUALS(mongo::fromjson("{ a : 1 }"), doc);
-    }
-
-    TEST(LogBuilder, AddTwoObjectReplacementEntry) {
-        mmb::Document doc;
-        LogBuilder lb(doc.root());
-
-        mmb::Element replacement = doc.end();
-        ASSERT_FALSE(replacement.ok());
-        ASSERT_OK(lb.getReplacementObject(&replacement));
-        ASSERT_TRUE(replacement.ok());
-        ASSERT_TRUE(replacement.isType(mongo::Object));
-
-        const mmb::Element elt_a = doc.makeElementInt("a", 1);
-        ASSERT_TRUE(elt_a.ok());
-        ASSERT_OK(replacement.pushBack(elt_a));
-
-        const mmb::Element elt_b = doc.makeElementInt("b", 2);
-        ASSERT_TRUE(elt_b.ok());
-        ASSERT_OK(replacement.pushBack(elt_b));
-
-        ASSERT_EQUALS(mongo::fromjson("{ a : 1, b: 2 }"), doc);
-    }
-
-    TEST(LogBuilder, VerifySetsAreGrouped) {
-        mmb::Document doc;
-        LogBuilder lb(doc.root());
-
-        const mmb::Element elt_ab = doc.makeElementInt("a.b", 1);
-        ASSERT_TRUE(elt_ab.ok());
-        ASSERT_OK(lb.addToSets(elt_ab));
-
-        const mmb::Element elt_xy = doc.makeElementInt("x.y", 1);
-        ASSERT_TRUE(elt_xy.ok());
-        ASSERT_OK(lb.addToSets(elt_xy));
-
-        ASSERT_EQUALS(
-            mongo::fromjson(
-                "{ $set : {"
-                "   'a.b' : 1, "
-                "   'x.y' : 1 "
-                "} }"
-                ), doc);
-    }
-
-    TEST(LogBuilder, VerifyUnsetsAreGrouped) {
-        mmb::Document doc;
-        LogBuilder lb(doc.root());
-
-        ASSERT_OK(lb.addToUnsets("a.b"));
-        ASSERT_OK(lb.addToUnsets("x.y"));
-
-        ASSERT_EQUALS(
-            mongo::fromjson(
-                "{ $unset : {"
-                "   'a.b' : true, "
-                "   'x.y' : true "
-                "} }"
-                ), doc);
-    }
-
-    TEST(LogBuilder, PresenceOfSetPreventsObjectReplacement) {
-        mmb::Document doc;
-        LogBuilder lb(doc.root());
-
-        mmb::Element replacement = doc.end();
-        ASSERT_FALSE(replacement.ok());
-        ASSERT_OK(lb.getReplacementObject(&replacement));
-        ASSERT_TRUE(replacement.ok());
-
-        const mmb::Element elt_ab = doc.makeElementInt("a.b", 1);
-        ASSERT_TRUE(elt_ab.ok());
-        ASSERT_OK(lb.addToSets(elt_ab));
-
-        replacement = doc.end();
-        ASSERT_FALSE(replacement.ok());
-        ASSERT_NOT_OK(lb.getReplacementObject(&replacement));
-        ASSERT_FALSE(replacement.ok());
-    }
-
-    TEST(LogBuilder, PresenceOfUnsetPreventsObjectReplacement) {
-        mmb::Document doc;
-        LogBuilder lb(doc.root());
-
-        mmb::Element replacement = doc.end();
-        ASSERT_FALSE(replacement.ok());
-        ASSERT_OK(lb.getReplacementObject(&replacement));
-        ASSERT_TRUE(replacement.ok());
-
-        const mmb::Element elt_ab = doc.makeElementInt("a.b", 1);
-        ASSERT_TRUE(elt_ab.ok());
-        ASSERT_OK(lb.addToSets(elt_ab));
-
-        replacement = doc.end();
-        ASSERT_FALSE(replacement.ok());
-        ASSERT_NOT_OK(lb.getReplacementObject(&replacement));
-        ASSERT_FALSE(replacement.ok());
-    }
-
-    TEST(LogBuilder, CantAddSetWithObjectReplacementDataPresent) {
-        mmb::Document doc;
-        LogBuilder lb(doc.root());
-
-        mmb::Element replacement = doc.end();
-        ASSERT_FALSE(replacement.ok());
-        ASSERT_OK(lb.getReplacementObject(&replacement));
-        ASSERT_TRUE(replacement.ok());
-        ASSERT_OK(replacement.appendInt("a", 1));
-
-        mmb::Element setCandidate = doc.makeElementInt("x", 0);
-        ASSERT_NOT_OK(lb.addToSets(setCandidate));
-    }
-
-    TEST(LogBuilder, CantAddUnsetWithObjectReplacementDataPresent) {
-        mmb::Document doc;
-        LogBuilder lb(doc.root());
-
-        mmb::Element replacement = doc.end();
-        ASSERT_FALSE(replacement.ok());
-        ASSERT_OK(lb.getReplacementObject(&replacement));
-        ASSERT_TRUE(replacement.ok());
-        ASSERT_OK(replacement.appendInt("a", 1));
-
-        ASSERT_NOT_OK(lb.addToUnsets("x"));
-    }
-
-    // Ensure that once you have obtained the object replacement slot and mutated it, that the
-    // object replacement slot becomes in accessible. This is a bit paranoid, since in practice
-    // the modifier conflict detection logic should prevent that outcome at a higher level, but
-    // preventing it here costs us nothing and add an extra safety check.
-    TEST(LogBuilder, CantReacquireObjectReplacementData) {
-        mmb::Document doc;
-        LogBuilder lb(doc.root());
-
-        mmb::Element replacement = doc.end();
-        ASSERT_FALSE(replacement.ok());
-        ASSERT_OK(lb.getReplacementObject(&replacement));
-        ASSERT_TRUE(replacement.ok());
-        ASSERT_OK(replacement.appendInt("a", 1));
-
-        mmb::Element again = doc.end();
-        ASSERT_FALSE(again.ok());
-        ASSERT_NOT_OK(lb.getReplacementObject(&again));
-        ASSERT_FALSE(again.ok());
-    }
-
-} // namespace
+TEST(LogBuilder, AddSafeNumToSet) {
+    mmb::Document doc;
+    LogBuilder lb(doc.root());
+
+    mongo::BSONObj obj = mongo::fromjson("{'':1}");
+
+    ASSERT_OK(lb.addToSets("a.b", mongo::SafeNum(1)));
+
+    ASSERT_EQUALS(mongo::fromjson("{ $set : { 'a.b' : 1 } }"), doc);
+}
+
+TEST(LogBuilder, AddOneToUnset) {
+    mmb::Document doc;
+    LogBuilder lb(doc.root());
+    ASSERT_OK(lb.addToUnsets("x.y"));
+    ASSERT_EQUALS(mongo::fromjson("{ $unset : { 'x.y' : true } }"), doc);
+}
+
+TEST(LogBuilder, AddOneToEach) {
+    mmb::Document doc;
+    LogBuilder lb(doc.root());
+
+    const mmb::Element elt_ab = doc.makeElementInt("a.b", 1);
+    ASSERT_TRUE(elt_ab.ok());
+    ASSERT_OK(lb.addToSets(elt_ab));
+
+    ASSERT_OK(lb.addToUnsets("x.y"));
+
+    ASSERT_EQUALS(mongo::fromjson(
+                      "{ "
+                      "   $set : { 'a.b' : 1 }, "
+                      "   $unset : { 'x.y' : true } "
+                      "}"),
+                  doc);
+}
+
+TEST(LogBuilder, AddOneObjectReplacementEntry) {
+    mmb::Document doc;
+    LogBuilder lb(doc.root());
+
+    mmb::Element replacement = doc.end();
+    ASSERT_FALSE(replacement.ok());
+    ASSERT_OK(lb.getReplacementObject(&replacement));
+    ASSERT_TRUE(replacement.ok());
+    ASSERT_TRUE(replacement.isType(mongo::Object));
+
+    const mmb::Element elt_a = doc.makeElementInt("a", 1);
+    ASSERT_TRUE(elt_a.ok());
+    ASSERT_OK(replacement.pushBack(elt_a));
+
+    ASSERT_EQUALS(mongo::fromjson("{ a : 1 }"), doc);
+}
+
+TEST(LogBuilder, AddTwoObjectReplacementEntry) {
+    mmb::Document doc;
+    LogBuilder lb(doc.root());
+
+    mmb::Element replacement = doc.end();
+    ASSERT_FALSE(replacement.ok());
+    ASSERT_OK(lb.getReplacementObject(&replacement));
+    ASSERT_TRUE(replacement.ok());
+    ASSERT_TRUE(replacement.isType(mongo::Object));
+
+    const mmb::Element elt_a = doc.makeElementInt("a", 1);
+    ASSERT_TRUE(elt_a.ok());
+    ASSERT_OK(replacement.pushBack(elt_a));
+
+    const mmb::Element elt_b = doc.makeElementInt("b", 2);
+    ASSERT_TRUE(elt_b.ok());
+    ASSERT_OK(replacement.pushBack(elt_b));
+
+    ASSERT_EQUALS(mongo::fromjson("{ a : 1, b: 2 }"), doc);
+}
+
+TEST(LogBuilder, VerifySetsAreGrouped) {
+    mmb::Document doc;
+    LogBuilder lb(doc.root());
+
+    const mmb::Element elt_ab = doc.makeElementInt("a.b", 1);
+    ASSERT_TRUE(elt_ab.ok());
+    ASSERT_OK(lb.addToSets(elt_ab));
+
+    const mmb::Element elt_xy = doc.makeElementInt("x.y", 1);
+    ASSERT_TRUE(elt_xy.ok());
+    ASSERT_OK(lb.addToSets(elt_xy));
+
+    ASSERT_EQUALS(mongo::fromjson(
+                      "{ $set : {"
+                      "   'a.b' : 1, "
+                      "   'x.y' : 1 "
+                      "} }"),
+                  doc);
+}
+
+TEST(LogBuilder, VerifyUnsetsAreGrouped) {
+    mmb::Document doc;
+    LogBuilder lb(doc.root());
+
+    ASSERT_OK(lb.addToUnsets("a.b"));
+    ASSERT_OK(lb.addToUnsets("x.y"));
+
+    ASSERT_EQUALS(mongo::fromjson(
+                      "{ $unset : {"
+                      "   'a.b' : true, "
+                      "   'x.y' : true "
+                      "} }"),
+                  doc);
+}
+
+TEST(LogBuilder, PresenceOfSetPreventsObjectReplacement) {
+    mmb::Document doc;
+    LogBuilder lb(doc.root());
+
+    mmb::Element replacement = doc.end();
+    ASSERT_FALSE(replacement.ok());
+    ASSERT_OK(lb.getReplacementObject(&replacement));
+    ASSERT_TRUE(replacement.ok());
+
+    const mmb::Element elt_ab = doc.makeElementInt("a.b", 1);
+    ASSERT_TRUE(elt_ab.ok());
+    ASSERT_OK(lb.addToSets(elt_ab));
+
+    replacement = doc.end();
+    ASSERT_FALSE(replacement.ok());
+    ASSERT_NOT_OK(lb.getReplacementObject(&replacement));
+    ASSERT_FALSE(replacement.ok());
+}
+
+TEST(LogBuilder, PresenceOfUnsetPreventsObjectReplacement) {
+    mmb::Document doc;
+    LogBuilder lb(doc.root());
+
+    mmb::Element replacement = doc.end();
+    ASSERT_FALSE(replacement.ok());
+    ASSERT_OK(lb.getReplacementObject(&replacement));
+    ASSERT_TRUE(replacement.ok());
+
+    const mmb::Element elt_ab = doc.makeElementInt("a.b", 1);
+    ASSERT_TRUE(elt_ab.ok());
+    ASSERT_OK(lb.addToSets(elt_ab));
+
+    replacement = doc.end();
+    ASSERT_FALSE(replacement.ok());
+    ASSERT_NOT_OK(lb.getReplacementObject(&replacement));
+    ASSERT_FALSE(replacement.ok());
+}
+
+TEST(LogBuilder, CantAddSetWithObjectReplacementDataPresent) {
+    mmb::Document doc;
+    LogBuilder lb(doc.root());
+
+    mmb::Element replacement = doc.end();
+    ASSERT_FALSE(replacement.ok());
+    ASSERT_OK(lb.getReplacementObject(&replacement));
+    ASSERT_TRUE(replacement.ok());
+    ASSERT_OK(replacement.appendInt("a", 1));
+
+    mmb::Element setCandidate = doc.makeElementInt("x", 0);
+    ASSERT_NOT_OK(lb.addToSets(setCandidate));
+}
+
+TEST(LogBuilder, CantAddUnsetWithObjectReplacementDataPresent) {
+    mmb::Document doc;
+    LogBuilder lb(doc.root());
+
+    mmb::Element replacement = doc.end();
+    ASSERT_FALSE(replacement.ok());
+    ASSERT_OK(lb.getReplacementObject(&replacement));
+    ASSERT_TRUE(replacement.ok());
+    ASSERT_OK(replacement.appendInt("a", 1));
+
+    ASSERT_NOT_OK(lb.addToUnsets("x"));
+}
+
+// Ensure that once you have obtained the object replacement slot and mutated it, that the
+// object replacement slot becomes in accessible. This is a bit paranoid, since in practice
+// the modifier conflict detection logic should prevent that outcome at a higher level, but
+// preventing it here costs us nothing and add an extra safety check.
+TEST(LogBuilder, CantReacquireObjectReplacementData) {
+    mmb::Document doc;
+    LogBuilder lb(doc.root());
+
+    mmb::Element replacement = doc.end();
+    ASSERT_FALSE(replacement.ok());
+    ASSERT_OK(lb.getReplacementObject(&replacement));
+    ASSERT_TRUE(replacement.ok());
+    ASSERT_OK(replacement.appendInt("a", 1));
+
+    mmb::Element again = doc.end();
+    ASSERT_FALSE(again.ok());
+    ASSERT_NOT_OK(lb.getReplacementObject(&again));
+    ASSERT_FALSE(again.ok());
+}
+
+}  // namespace