1 files changed, 338 insertions, 338 deletions

diff --git a/src/mongo/db/ops/modifier_rename_test.cpp b/src/mongo/db/ops/modifier_rename_test.cpp
index 637926da8e1..4841c4b15a1 100644
--- a/src/mongo/db/ops/modifier_rename_test.cpp
+++ b/src/mongo/db/ops/modifier_rename_test.cpp
@@ -41,355 +41,355 @@
 
 namespace {
 
-    using mongo::BSONObj;
-    using mongo::fromjson;
-    using mongo::LogBuilder;
-    using mongo::ModifierInterface;
-    using mongo::NumberInt;
-    using mongo::ModifierRename;
-    using mongo::Status;
-    using mongo::StringData;
-    using mongo::mutablebson::ConstElement;
-    using mongo::mutablebson::Document;
-    using mongo::mutablebson::Element;
-
-    /** Helper to build and manipulate the mod. */
-    class Mod {
-    public:
-        Mod() : _mod() {}
-
-        explicit Mod(BSONObj modObj) {
-            _modObj = modObj;
-            ASSERT_OK(_mod.init(_modObj["$rename"].embeddedObject().firstElement(),
-                                ModifierInterface::Options::normal()));
-        }
-
-        Status prepare(Element root,
-                       StringData matchedField,
-                       ModifierInterface::ExecInfo* execInfo) {
-            return _mod.prepare(root, matchedField, execInfo);
-        }
-
-        Status apply() const {
-            return _mod.apply();
-        }
-
-        Status log(LogBuilder* logBuilder) const {
-            return _mod.log(logBuilder);
-        }
-
-        ModifierRename& mod() { return _mod; }
-
-    private:
-        ModifierRename _mod;
-        BSONObj _modObj;
-    };
-
-    /**
-     * These test negative cases:
-     *  -- No '$' support for positional operator
-     *  -- No empty field names (ex. .a, b. )
-     *  -- Can't rename to an invalid fieldname (empty fieldname part)
-     */
-    TEST(InvalidInit, FromDbTests) {
-        ModifierRename mod;
-        ASSERT_NOT_OK(mod.init(fromjson("{'a.$':'b'}").firstElement(),
-                               ModifierInterface::Options::normal()));
-        ASSERT_NOT_OK(mod.init(fromjson("{'a':'b.$'}").firstElement(),
-                               ModifierInterface::Options::normal()));
-        ASSERT_NOT_OK(mod.init(fromjson("{'.b':'a'}").firstElement(),
-                               ModifierInterface::Options::normal()));
-        ASSERT_NOT_OK(mod.init(fromjson("{'b.':'a'}").firstElement(),
-                               ModifierInterface::Options::normal()));
-        ASSERT_NOT_OK(mod.init(fromjson("{'b':'.a'}").firstElement(),
-                               ModifierInterface::Options::normal()));
-        ASSERT_NOT_OK(mod.init(fromjson("{'b':'a.'}").firstElement(),
-                               ModifierInterface::Options::normal()));
+using mongo::BSONObj;
+using mongo::fromjson;
+using mongo::LogBuilder;
+using mongo::ModifierInterface;
+using mongo::NumberInt;
+using mongo::ModifierRename;
+using mongo::Status;
+using mongo::StringData;
+using mongo::mutablebson::ConstElement;
+using mongo::mutablebson::Document;
+using mongo::mutablebson::Element;
+
+/** Helper to build and manipulate the mod. */
+class Mod {
+public:
+    Mod() : _mod() {}
+
+    explicit Mod(BSONObj modObj) {
+        _modObj = modObj;
+        ASSERT_OK(_mod.init(_modObj["$rename"].embeddedObject().firstElement(),
+                            ModifierInterface::Options::normal()));
     }
 
-    TEST(MissingFrom, InitPrepLog) {
-        Document doc(fromjson("{a: 2}"));
-        Mod setMod(fromjson("{$rename: {'b':'a'}}"));
-
-        ModifierInterface::ExecInfo execInfo;
-        ASSERT_OK(setMod.prepare(doc.root(), "", &execInfo));
-
-        Document logDoc;
-        LogBuilder logBuilder(logDoc.root());
-        BSONObj logObj = fromjson("{}");
-        ASSERT_OK(setMod.log(&logBuilder));
-        ASSERT_EQUALS(logDoc, logObj);
-    }
-
-    TEST(MissingFromDotted, InitPrepLog) {
-        Document doc(fromjson("{a: {r:2}}"));
-        Mod setMod(fromjson("{$rename: {'a.b':'a.c'}}"));
-
-        ModifierInterface::ExecInfo execInfo;
-        ASSERT_OK(setMod.prepare(doc.root(), "", &execInfo));
-        ASSERT_TRUE(execInfo.noOp);
-
-        Document logDoc;
-        LogBuilder logBuilder(logDoc.root());
-        BSONObj logObj = fromjson("{}");
-        ASSERT_OK(setMod.log(&logBuilder));
-        ASSERT_EQUALS(logDoc, logObj);
-    }
-
-    TEST(BasicInit, DifferentRoots) {
-        Document doc(fromjson("{a: 2}"));
-        Mod setMod(fromjson("{$rename: {'a':'f.g'}}"));
-    }
-
-    TEST(MoveOnSamePath, MoveUp) {
-        ModifierRename mod;
-        ASSERT_NOT_OK(mod.init(fromjson("{'b.a':'b'}").firstElement(),
-                               ModifierInterface::Options::normal()));
-    }
-
-    TEST(MoveOnSamePath, MoveDown) {
-        ModifierRename mod;
-        ASSERT_NOT_OK(mod.init(fromjson("{'b':'b.a'}").firstElement(),
-                               ModifierInterface::Options::normal()));
-    }
-
-    TEST(MissingTo, SimpleNumberAtRoot) {
-        Document doc(fromjson("{a: 2}"));
-        Mod setMod(fromjson("{$rename: {'a':'b'}}"));
-
-        ModifierInterface::ExecInfo execInfo;
-        ASSERT_OK(setMod.prepare(doc.root(), "", &execInfo));
-
-        ASSERT_EQUALS(execInfo.fieldRef[0]->dottedField(), "a");
-        ASSERT_EQUALS(execInfo.fieldRef[1]->dottedField(), "b");
-        ASSERT_FALSE(execInfo.noOp);
-
-        ASSERT_OK(setMod.apply());
-        ASSERT_FALSE(doc.isInPlaceModeEnabled());
-        ASSERT_EQUALS(doc, fromjson("{b:2}"));
-
-        Document logDoc;
-        LogBuilder logBuilder(logDoc.root());
-        BSONObj logObj = fromjson("{$set:{ 'b': 2}, $unset: {'a': true}}");
-        ASSERT_OK(setMod.log(&logBuilder));
-        ASSERT_EQUALS(logDoc, logObj);
-    }
-
-    TEST(SimpleReplace, SameLevel) {
-        Document doc(fromjson("{a: 2, b: 1}"));
-        Mod setMod(fromjson("{$rename: {'a':'b'}}"));
-
-        ModifierInterface::ExecInfo execInfo;
-        ASSERT_OK(setMod.prepare(doc.root(), "", &execInfo));
-
-        ASSERT_EQUALS(execInfo.fieldRef[0]->dottedField(), "a");
-        ASSERT_EQUALS(execInfo.fieldRef[1]->dottedField(), "b");
-        ASSERT_FALSE(execInfo.noOp);
-
-        ASSERT_OK(setMod.apply());
-        ASSERT_FALSE(doc.isInPlaceModeEnabled());
-        ASSERT_EQUALS(doc, fromjson("{b:2}"));
-
-        Document logDoc;
-        LogBuilder logBuilder(logDoc.root());
-        BSONObj logObj = fromjson("{$set:{ 'b': 2}, $unset: {'a': true}}");
-        ASSERT_OK(setMod.log(&logBuilder));
-        ASSERT_EQUALS(logDoc, logObj);
-    }
-
-    TEST(SimpleReplace, FromDottedElement) {
-        Document doc(fromjson("{a: {c: {d: 6}}, b: 1}"));
-        Mod setMod(fromjson("{$rename: {'a.c':'b'}}"));
-
-        ModifierInterface::ExecInfo execInfo;
-        ASSERT_OK(setMod.prepare(doc.root(), "", &execInfo));
-
-        ASSERT_EQUALS(execInfo.fieldRef[0]->dottedField(), "a.c");
-        ASSERT_EQUALS(execInfo.fieldRef[1]->dottedField(), "b");
-        ASSERT_FALSE(execInfo.noOp);
-
-        ASSERT_OK(setMod.apply());
-        ASSERT_FALSE(doc.isInPlaceModeEnabled());
-        ASSERT_EQUALS(doc, fromjson("{a: {}, b:{ d: 6}}"));
-
-        Document logDoc;
-        LogBuilder logBuilder(logDoc.root());
-        BSONObj logObj = fromjson("{$set:{ 'b': {d: 6}}, $unset: {'a.c': true}}");
-        ASSERT_OK(setMod.log(&logBuilder));
-        ASSERT_EQUALS(logDoc, logObj);
-    }
-
-    TEST(DottedTo, MissingCompleteTo) {
-        Document doc(fromjson("{a: 2, b: 1, c: {}}"));
-        Mod setMod(fromjson("{$rename: {'a':'c.r.d'}}"));
-
-        ModifierInterface::ExecInfo execInfo;
-        ASSERT_OK(setMod.prepare(doc.root(), "", &execInfo));
-
-        ASSERT_EQUALS(execInfo.fieldRef[0]->dottedField(), "a");
-        ASSERT_EQUALS(execInfo.fieldRef[1]->dottedField(), "c.r.d");
-        ASSERT_FALSE(execInfo.noOp);
-
-        ASSERT_OK(setMod.apply());
-        ASSERT_FALSE(doc.isInPlaceModeEnabled());
-        ASSERT_EQUALS(doc, fromjson("{b:1, c: { r: { d: 2}}}"));
-
-        Document logDoc;
-        LogBuilder logBuilder(logDoc.root());
-        BSONObj logObj = fromjson("{$set:{ 'c.r.d': 2}, $unset: {'a': true}}");
-        ASSERT_OK(setMod.log(&logBuilder));
-        ASSERT_EQUALS(logDoc, logObj);
-    }
-
-    TEST(DottedTo, ToIsCompletelyMissing) {
-        Document doc(fromjson("{a: 2}"));
-        Mod setMod(fromjson("{$rename: {'a':'b.c.d'}}"));
-
-        ModifierInterface::ExecInfo execInfo;
-        ASSERT_OK(setMod.prepare(doc.root(), "", &execInfo));
-
-        ASSERT_EQUALS(execInfo.fieldRef[0]->dottedField(), "a");
-        ASSERT_EQUALS(execInfo.fieldRef[1]->dottedField(), "b.c.d");
-        ASSERT_FALSE(execInfo.noOp);
-
-        ASSERT_OK(setMod.apply());
-        ASSERT_FALSE(doc.isInPlaceModeEnabled());
-        ASSERT_EQUALS(doc, fromjson("{b: {c: {d: 2}}}"));
-
-        Document logDoc;
-        LogBuilder logBuilder(logDoc.root());
-        BSONObj logObj = fromjson("{$set:{ 'b.c.d': 2}, $unset: {'a': true}}");
-        ASSERT_OK(setMod.log(&logBuilder));
-        ASSERT_EQUALS(logDoc, logObj);
+    Status prepare(Element root, StringData matchedField, ModifierInterface::ExecInfo* execInfo) {
+        return _mod.prepare(root, matchedField, execInfo);
     }
 
-    TEST(FromArrayOfEmbeddedDocs, ToMissingDottedField) {
-        Document doc(fromjson("{a: [ {a:2, b:1} ] }"));
-        Mod setMod(fromjson("{$rename: {'a':'b.c.d'}}"));
-
-        ModifierInterface::ExecInfo execInfo;
-        ASSERT_OK(setMod.prepare(doc.root(), "", &execInfo));
-
-        ASSERT_EQUALS(execInfo.fieldRef[0]->dottedField(), "a");
-        ASSERT_EQUALS(execInfo.fieldRef[1]->dottedField(), "b.c.d");
-        ASSERT_FALSE(execInfo.noOp);
-
-        ASSERT_OK(setMod.apply());
-        ASSERT_FALSE(doc.isInPlaceModeEnabled());
-        ASSERT_EQUALS(doc, fromjson("{b: {c: {d: [ {a:2, b:1} ]}}}"));
-
-        Document logDoc;
-        LogBuilder logBuilder(logDoc.root());
-        BSONObj logObj = fromjson("{$set:{ 'b.c.d': [ {a:2, b:1} ]}, $unset: {'a': true}}");
-        ASSERT_OK(setMod.log(&logBuilder));
-        ASSERT_EQUALS(logDoc, logObj);
+    Status apply() const {
+        return _mod.apply();
     }
 
-    TEST(FromArrayOfEmbeddedDocs, ToArray) {
-        Document doc(fromjson("{a: [ {a:2, b:1} ] }"));
-        Mod setMod(fromjson("{$rename: {'a.a':'a.b'}}"));
-
-        ModifierInterface::ExecInfo execInfo;
-        ASSERT_NOT_OK(setMod.prepare(doc.root(), "", &execInfo));
+    Status log(LogBuilder* logBuilder) const {
+        return _mod.log(logBuilder);
     }
 
-    TEST(Arrays, MoveInto) {
-        Document doc(fromjson("{a: [1, 2], b:2}"));
-        Mod setMod(fromjson("{$rename: {'b':'a.2'}}"));
-
-        ModifierInterface::ExecInfo execInfo;
-        ASSERT_NOT_OK(setMod.prepare(doc.root(), "", &execInfo));
+    ModifierRename& mod() {
+        return _mod;
     }
 
-    TEST(Arrays, MoveOut) {
-        Document doc(fromjson("{a: [1, 2]}"));
-        Mod setMod(fromjson("{$rename: {'a.0':'b'}}"));
-
-        ModifierInterface::ExecInfo execInfo;
-        ASSERT_NOT_OK(setMod.prepare(doc.root(), "", &execInfo));
-    }
-
-    TEST(Arrays, MoveNonexistantEmbeddedFieldOut) {
-        Document doc(fromjson("{a: [{a:1}, {b:2}]}"));
-        Mod setMod(fromjson("{$rename: {'a.a':'b'}}"));
-
-        ModifierInterface::ExecInfo execInfo;
-        ASSERT_NOT_OK(setMod.prepare(doc.root(), "", &execInfo));
-    }
-
-    TEST(Arrays, MoveEmbeddedFieldOutWithElementNumber) {
-        Document doc(fromjson("{a: [{a:1}, {b:2}]}"));
-        Mod setMod(fromjson("{$rename: {'a.0.a':'b'}}"));
-
-        ModifierInterface::ExecInfo execInfo;
-        ASSERT_NOT_OK(setMod.prepare(doc.root(), "", &execInfo));
-    }
+private:
+    ModifierRename _mod;
+    BSONObj _modObj;
+};
 
-    TEST(Arrays, ReplaceArrayField) {
-        Document doc(fromjson("{a: 2, b: []}"));
-        Mod setMod(fromjson("{$rename: {'a':'b'}}"));
-
-        ModifierInterface::ExecInfo execInfo;
-        ASSERT_OK(setMod.prepare(doc.root(), "", &execInfo));
-
-        ASSERT_EQUALS(execInfo.fieldRef[0]->dottedField(), "a");
-        ASSERT_EQUALS(execInfo.fieldRef[1]->dottedField(), "b");
-        ASSERT_FALSE(execInfo.noOp);
-
-        ASSERT_OK(setMod.apply());
-        ASSERT_FALSE(doc.isInPlaceModeEnabled());
-        ASSERT_EQUALS(doc, fromjson("{b:2}"));
-
-        Document logDoc;
-        LogBuilder logBuilder(logDoc.root());
-        BSONObj logObj = fromjson("{$set:{ 'b': 2}, $unset: {'a': true}}");
-        ASSERT_OK(setMod.log(&logBuilder));
-        ASSERT_EQUALS(logDoc, logObj);
-    }
-
-
-    TEST(Arrays, ReplaceWithArrayField) {
-        Document doc(fromjson("{a: [], b: 2}"));
-        Mod setMod(fromjson("{$rename: {'a':'b'}}"));
-
-        ModifierInterface::ExecInfo execInfo;
-        ASSERT_OK(setMod.prepare(doc.root(), "", &execInfo));
-
-        ASSERT_EQUALS(execInfo.fieldRef[0]->dottedField(), "a");
-        ASSERT_EQUALS(execInfo.fieldRef[1]->dottedField(), "b");
-        ASSERT_FALSE(execInfo.noOp);
-
-        ASSERT_OK(setMod.apply());
-        ASSERT_FALSE(doc.isInPlaceModeEnabled());
-        ASSERT_EQUALS(doc, fromjson("{b:[]}"));
-
-        Document logDoc;
-        LogBuilder logBuilder(logDoc.root());
-        BSONObj logObj = fromjson("{$set:{ 'b': []}, $unset: {'a': true}}");
-        ASSERT_OK(setMod.log(&logBuilder));
-        ASSERT_EQUALS(logDoc, logObj);
-    }
-
-    TEST(LegacyData, CanRenameFromInvalidFieldName) {
-        Document doc(fromjson("{$a: 2}"));
-        Mod setMod(fromjson("{$rename: {'$a':'a'}}"));
-
-        ModifierInterface::ExecInfo execInfo;
-        ASSERT_OK(setMod.prepare(doc.root(), "", &execInfo));
-
-        ASSERT_EQUALS(execInfo.fieldRef[0]->dottedField(), "$a");
-        ASSERT_EQUALS(execInfo.fieldRef[1]->dottedField(), "a");
-        ASSERT_FALSE(execInfo.noOp);
+/**
+ * These test negative cases:
+ *  -- No '$' support for positional operator
+ *  -- No empty field names (ex. .a, b. )
+ *  -- Can't rename to an invalid fieldname (empty fieldname part)
+ */
+TEST(InvalidInit, FromDbTests) {
+    ModifierRename mod;
+    ASSERT_NOT_OK(
+        mod.init(fromjson("{'a.$':'b'}").firstElement(), ModifierInterface::Options::normal()));
+    ASSERT_NOT_OK(
+        mod.init(fromjson("{'a':'b.$'}").firstElement(), ModifierInterface::Options::normal()));
+    ASSERT_NOT_OK(
+        mod.init(fromjson("{'.b':'a'}").firstElement(), ModifierInterface::Options::normal()));
+    ASSERT_NOT_OK(
+        mod.init(fromjson("{'b.':'a'}").firstElement(), ModifierInterface::Options::normal()));
+    ASSERT_NOT_OK(
+        mod.init(fromjson("{'b':'.a'}").firstElement(), ModifierInterface::Options::normal()));
+    ASSERT_NOT_OK(
+        mod.init(fromjson("{'b':'a.'}").firstElement(), ModifierInterface::Options::normal()));
+}
+
+TEST(MissingFrom, InitPrepLog) {
+    Document doc(fromjson("{a: 2}"));
+    Mod setMod(fromjson("{$rename: {'b':'a'}}"));
+
+    ModifierInterface::ExecInfo execInfo;
+    ASSERT_OK(setMod.prepare(doc.root(), "", &execInfo));
+
+    Document logDoc;
+    LogBuilder logBuilder(logDoc.root());
+    BSONObj logObj = fromjson("{}");
+    ASSERT_OK(setMod.log(&logBuilder));
+    ASSERT_EQUALS(logDoc, logObj);
+}
+
+TEST(MissingFromDotted, InitPrepLog) {
+    Document doc(fromjson("{a: {r:2}}"));
+    Mod setMod(fromjson("{$rename: {'a.b':'a.c'}}"));
+
+    ModifierInterface::ExecInfo execInfo;
+    ASSERT_OK(setMod.prepare(doc.root(), "", &execInfo));
+    ASSERT_TRUE(execInfo.noOp);
+
+    Document logDoc;
+    LogBuilder logBuilder(logDoc.root());
+    BSONObj logObj = fromjson("{}");
+    ASSERT_OK(setMod.log(&logBuilder));
+    ASSERT_EQUALS(logDoc, logObj);
+}
+
+TEST(BasicInit, DifferentRoots) {
+    Document doc(fromjson("{a: 2}"));
+    Mod setMod(fromjson("{$rename: {'a':'f.g'}}"));
+}
+
+TEST(MoveOnSamePath, MoveUp) {
+    ModifierRename mod;
+    ASSERT_NOT_OK(
+        mod.init(fromjson("{'b.a':'b'}").firstElement(), ModifierInterface::Options::normal()));
+}
+
+TEST(MoveOnSamePath, MoveDown) {
+    ModifierRename mod;
+    ASSERT_NOT_OK(
+        mod.init(fromjson("{'b':'b.a'}").firstElement(), ModifierInterface::Options::normal()));
+}
+
+TEST(MissingTo, SimpleNumberAtRoot) {
+    Document doc(fromjson("{a: 2}"));
+    Mod setMod(fromjson("{$rename: {'a':'b'}}"));
+
+    ModifierInterface::ExecInfo execInfo;
+    ASSERT_OK(setMod.prepare(doc.root(), "", &execInfo));
+
+    ASSERT_EQUALS(execInfo.fieldRef[0]->dottedField(), "a");
+    ASSERT_EQUALS(execInfo.fieldRef[1]->dottedField(), "b");
+    ASSERT_FALSE(execInfo.noOp);
+
+    ASSERT_OK(setMod.apply());
+    ASSERT_FALSE(doc.isInPlaceModeEnabled());
+    ASSERT_EQUALS(doc, fromjson("{b:2}"));
+
+    Document logDoc;
+    LogBuilder logBuilder(logDoc.root());
+    BSONObj logObj = fromjson("{$set:{ 'b': 2}, $unset: {'a': true}}");
+    ASSERT_OK(setMod.log(&logBuilder));
+    ASSERT_EQUALS(logDoc, logObj);
+}
+
+TEST(SimpleReplace, SameLevel) {
+    Document doc(fromjson("{a: 2, b: 1}"));
+    Mod setMod(fromjson("{$rename: {'a':'b'}}"));
+
+    ModifierInterface::ExecInfo execInfo;
+    ASSERT_OK(setMod.prepare(doc.root(), "", &execInfo));
+
+    ASSERT_EQUALS(execInfo.fieldRef[0]->dottedField(), "a");
+    ASSERT_EQUALS(execInfo.fieldRef[1]->dottedField(), "b");
+    ASSERT_FALSE(execInfo.noOp);
+
+    ASSERT_OK(setMod.apply());
+    ASSERT_FALSE(doc.isInPlaceModeEnabled());
+    ASSERT_EQUALS(doc, fromjson("{b:2}"));
+
+    Document logDoc;
+    LogBuilder logBuilder(logDoc.root());
+    BSONObj logObj = fromjson("{$set:{ 'b': 2}, $unset: {'a': true}}");
+    ASSERT_OK(setMod.log(&logBuilder));
+    ASSERT_EQUALS(logDoc, logObj);
+}
+
+TEST(SimpleReplace, FromDottedElement) {
+    Document doc(fromjson("{a: {c: {d: 6}}, b: 1}"));
+    Mod setMod(fromjson("{$rename: {'a.c':'b'}}"));
+
+    ModifierInterface::ExecInfo execInfo;
+    ASSERT_OK(setMod.prepare(doc.root(), "", &execInfo));
+
+    ASSERT_EQUALS(execInfo.fieldRef[0]->dottedField(), "a.c");
+    ASSERT_EQUALS(execInfo.fieldRef[1]->dottedField(), "b");
+    ASSERT_FALSE(execInfo.noOp);
+
+    ASSERT_OK(setMod.apply());
+    ASSERT_FALSE(doc.isInPlaceModeEnabled());
+    ASSERT_EQUALS(doc, fromjson("{a: {}, b:{ d: 6}}"));
+
+    Document logDoc;
+    LogBuilder logBuilder(logDoc.root());
+    BSONObj logObj = fromjson("{$set:{ 'b': {d: 6}}, $unset: {'a.c': true}}");
+    ASSERT_OK(setMod.log(&logBuilder));
+    ASSERT_EQUALS(logDoc, logObj);
+}
+
+TEST(DottedTo, MissingCompleteTo) {
+    Document doc(fromjson("{a: 2, b: 1, c: {}}"));
+    Mod setMod(fromjson("{$rename: {'a':'c.r.d'}}"));
+
+    ModifierInterface::ExecInfo execInfo;
+    ASSERT_OK(setMod.prepare(doc.root(), "", &execInfo));
+
+    ASSERT_EQUALS(execInfo.fieldRef[0]->dottedField(), "a");
+    ASSERT_EQUALS(execInfo.fieldRef[1]->dottedField(), "c.r.d");
+    ASSERT_FALSE(execInfo.noOp);
+
+    ASSERT_OK(setMod.apply());
+    ASSERT_FALSE(doc.isInPlaceModeEnabled());
+    ASSERT_EQUALS(doc, fromjson("{b:1, c: { r: { d: 2}}}"));
+
+    Document logDoc;
+    LogBuilder logBuilder(logDoc.root());
+    BSONObj logObj = fromjson("{$set:{ 'c.r.d': 2}, $unset: {'a': true}}");
+    ASSERT_OK(setMod.log(&logBuilder));
+    ASSERT_EQUALS(logDoc, logObj);
+}
+
+TEST(DottedTo, ToIsCompletelyMissing) {
+    Document doc(fromjson("{a: 2}"));
+    Mod setMod(fromjson("{$rename: {'a':'b.c.d'}}"));
+
+    ModifierInterface::ExecInfo execInfo;
+    ASSERT_OK(setMod.prepare(doc.root(), "", &execInfo));
+
+    ASSERT_EQUALS(execInfo.fieldRef[0]->dottedField(), "a");
+    ASSERT_EQUALS(execInfo.fieldRef[1]->dottedField(), "b.c.d");
+    ASSERT_FALSE(execInfo.noOp);
+
+    ASSERT_OK(setMod.apply());
+    ASSERT_FALSE(doc.isInPlaceModeEnabled());
+    ASSERT_EQUALS(doc, fromjson("{b: {c: {d: 2}}}"));
+
+    Document logDoc;
+    LogBuilder logBuilder(logDoc.root());
+    BSONObj logObj = fromjson("{$set:{ 'b.c.d': 2}, $unset: {'a': true}}");
+    ASSERT_OK(setMod.log(&logBuilder));
+    ASSERT_EQUALS(logDoc, logObj);
+}
+
+TEST(FromArrayOfEmbeddedDocs, ToMissingDottedField) {
+    Document doc(fromjson("{a: [ {a:2, b:1} ] }"));
+    Mod setMod(fromjson("{$rename: {'a':'b.c.d'}}"));
+
+    ModifierInterface::ExecInfo execInfo;
+    ASSERT_OK(setMod.prepare(doc.root(), "", &execInfo));
+
+    ASSERT_EQUALS(execInfo.fieldRef[0]->dottedField(), "a");
+    ASSERT_EQUALS(execInfo.fieldRef[1]->dottedField(), "b.c.d");
+    ASSERT_FALSE(execInfo.noOp);
+
+    ASSERT_OK(setMod.apply());
+    ASSERT_FALSE(doc.isInPlaceModeEnabled());
+    ASSERT_EQUALS(doc, fromjson("{b: {c: {d: [ {a:2, b:1} ]}}}"));
+
+    Document logDoc;
+    LogBuilder logBuilder(logDoc.root());
+    BSONObj logObj = fromjson("{$set:{ 'b.c.d': [ {a:2, b:1} ]}, $unset: {'a': true}}");
+    ASSERT_OK(setMod.log(&logBuilder));
+    ASSERT_EQUALS(logDoc, logObj);
+}
+
+TEST(FromArrayOfEmbeddedDocs, ToArray) {
+    Document doc(fromjson("{a: [ {a:2, b:1} ] }"));
+    Mod setMod(fromjson("{$rename: {'a.a':'a.b'}}"));
+
+    ModifierInterface::ExecInfo execInfo;
+    ASSERT_NOT_OK(setMod.prepare(doc.root(), "", &execInfo));
+}
+
+TEST(Arrays, MoveInto) {
+    Document doc(fromjson("{a: [1, 2], b:2}"));
+    Mod setMod(fromjson("{$rename: {'b':'a.2'}}"));
+
+    ModifierInterface::ExecInfo execInfo;
+    ASSERT_NOT_OK(setMod.prepare(doc.root(), "", &execInfo));
+}
+
+TEST(Arrays, MoveOut) {
+    Document doc(fromjson("{a: [1, 2]}"));
+    Mod setMod(fromjson("{$rename: {'a.0':'b'}}"));
+
+    ModifierInterface::ExecInfo execInfo;
+    ASSERT_NOT_OK(setMod.prepare(doc.root(), "", &execInfo));
+}
+
+TEST(Arrays, MoveNonexistantEmbeddedFieldOut) {
+    Document doc(fromjson("{a: [{a:1}, {b:2}]}"));
+    Mod setMod(fromjson("{$rename: {'a.a':'b'}}"));
+
+    ModifierInterface::ExecInfo execInfo;
+    ASSERT_NOT_OK(setMod.prepare(doc.root(), "", &execInfo));
+}
+
+TEST(Arrays, MoveEmbeddedFieldOutWithElementNumber) {
+    Document doc(fromjson("{a: [{a:1}, {b:2}]}"));
+    Mod setMod(fromjson("{$rename: {'a.0.a':'b'}}"));
+
+    ModifierInterface::ExecInfo execInfo;
+    ASSERT_NOT_OK(setMod.prepare(doc.root(), "", &execInfo));
+}
+
+TEST(Arrays, ReplaceArrayField) {
+    Document doc(fromjson("{a: 2, b: []}"));
+    Mod setMod(fromjson("{$rename: {'a':'b'}}"));
+
+    ModifierInterface::ExecInfo execInfo;
+    ASSERT_OK(setMod.prepare(doc.root(), "", &execInfo));
+
+    ASSERT_EQUALS(execInfo.fieldRef[0]->dottedField(), "a");
+    ASSERT_EQUALS(execInfo.fieldRef[1]->dottedField(), "b");
+    ASSERT_FALSE(execInfo.noOp);
+
+    ASSERT_OK(setMod.apply());
+    ASSERT_FALSE(doc.isInPlaceModeEnabled());
+    ASSERT_EQUALS(doc, fromjson("{b:2}"));
+
+    Document logDoc;
+    LogBuilder logBuilder(logDoc.root());
+    BSONObj logObj = fromjson("{$set:{ 'b': 2}, $unset: {'a': true}}");
+    ASSERT_OK(setMod.log(&logBuilder));
+    ASSERT_EQUALS(logDoc, logObj);
+}
+
+
+TEST(Arrays, ReplaceWithArrayField) {
+    Document doc(fromjson("{a: [], b: 2}"));
+    Mod setMod(fromjson("{$rename: {'a':'b'}}"));
+
+    ModifierInterface::ExecInfo execInfo;
+    ASSERT_OK(setMod.prepare(doc.root(), "", &execInfo));
+
+    ASSERT_EQUALS(execInfo.fieldRef[0]->dottedField(), "a");
+    ASSERT_EQUALS(execInfo.fieldRef[1]->dottedField(), "b");
+    ASSERT_FALSE(execInfo.noOp);
+
+    ASSERT_OK(setMod.apply());
+    ASSERT_FALSE(doc.isInPlaceModeEnabled());
+    ASSERT_EQUALS(doc, fromjson("{b:[]}"));
 
-        ASSERT_OK(setMod.apply());
-        ASSERT_FALSE(doc.isInPlaceModeEnabled());
-        ASSERT_EQUALS(doc, fromjson("{a:2}"));
+    Document logDoc;
+    LogBuilder logBuilder(logDoc.root());
+    BSONObj logObj = fromjson("{$set:{ 'b': []}, $unset: {'a': true}}");
+    ASSERT_OK(setMod.log(&logBuilder));
+    ASSERT_EQUALS(logDoc, logObj);
+}
+
+TEST(LegacyData, CanRenameFromInvalidFieldName) {
+    Document doc(fromjson("{$a: 2}"));
+    Mod setMod(fromjson("{$rename: {'$a':'a'}}"));
+
+    ModifierInterface::ExecInfo execInfo;
+    ASSERT_OK(setMod.prepare(doc.root(), "", &execInfo));
+
+    ASSERT_EQUALS(execInfo.fieldRef[0]->dottedField(), "$a");
+    ASSERT_EQUALS(execInfo.fieldRef[1]->dottedField(), "a");
+    ASSERT_FALSE(execInfo.noOp);
+
+    ASSERT_OK(setMod.apply());
+    ASSERT_FALSE(doc.isInPlaceModeEnabled());
+    ASSERT_EQUALS(doc, fromjson("{a:2}"));
 
-        Document logDoc;
-        LogBuilder logBuilder(logDoc.root());
-        BSONObj logObj = fromjson("{$set:{ 'a': 2}, $unset: {'$a': true}}");
-        ASSERT_OK(setMod.log(&logBuilder));
-        ASSERT_EQUALS(logDoc, logObj);
-    }
+    Document logDoc;
+    LogBuilder logBuilder(logDoc.root());
+    BSONObj logObj = fromjson("{$set:{ 'a': 2}, $unset: {'$a': true}}");
+    ASSERT_OK(setMod.log(&logBuilder));
+    ASSERT_EQUALS(logDoc, logObj);
+}
 
-} // namespace
+}  // namespace