1 files changed, 177 insertions, 177 deletions

diff --git a/src/mongo/db/exec/working_set_test.cpp b/src/mongo/db/exec/working_set_test.cpp
index d4d7163831b..ff95717963c 100644
--- a/src/mongo/db/exec/working_set_test.cpp
+++ b/src/mongo/db/exec/working_set_test.cpp
@@ -41,207 +41,207 @@ using namespace mongo;
 
 namespace {
 
-    using std::string;
-
-    class WorkingSetFixture : public mongo::unittest::Test {
-    protected:
-        void setUp() {
-            ws.reset(new WorkingSet());
-            WorkingSetID id = ws->allocate();
-            ASSERT(id != WorkingSet::INVALID_ID);
-            member = ws->get(id);
-            ASSERT(NULL != member);
-        }
-
-        void tearDown() {
-            ws.reset();
-            member = NULL;
-        }
-
-        std::unique_ptr<WorkingSet> ws;
-        WorkingSetMember* member;
-    };
-
-    TEST_F(WorkingSetFixture, noFieldToGet) {
-        BSONElement elt;
-
-        // Make sure we're not getting anything out of an invalid WSM.
-        ASSERT_EQUALS(WorkingSetMember::INVALID, member->state);
-        ASSERT_FALSE(member->getFieldDotted("foo", &elt));
-
-        member->state = WorkingSetMember::LOC_AND_IDX;
-        ASSERT_FALSE(member->getFieldDotted("foo", &elt));
-
-        // Our state is that of a valid object.  The getFieldDotted shouldn't throw; there's
-        // something to call getFieldDotted on, but there's no field there.
-        member->state = WorkingSetMember::LOC_AND_UNOWNED_OBJ;
-        ASSERT_TRUE(member->getFieldDotted("foo", &elt));
-
-        member->state = WorkingSetMember::OWNED_OBJ;
-        ASSERT_TRUE(member->getFieldDotted("foo", &elt));
+using std::string;
+
+class WorkingSetFixture : public mongo::unittest::Test {
+protected:
+    void setUp() {
+        ws.reset(new WorkingSet());
+        WorkingSetID id = ws->allocate();
+        ASSERT(id != WorkingSet::INVALID_ID);
+        member = ws->get(id);
+        ASSERT(NULL != member);
     }
 
-    TEST_F(WorkingSetFixture, getFieldUnowned) {
-        string fieldName = "x";
-
-        BSONObj obj = BSON(fieldName << 5);
-        // Not truthful since the loc is bogus, but the loc isn't accessed anyway...
-        member->state = WorkingSetMember::LOC_AND_UNOWNED_OBJ;
-        member->obj = Snapshotted<BSONObj>(SnapshotId(), BSONObj(obj.objdata()));
-        ASSERT_TRUE(obj.isOwned());
-        ASSERT_FALSE(member->obj.value().isOwned());
-
-        // Get out the field we put in.
-        BSONElement elt;
-        ASSERT_TRUE(member->getFieldDotted(fieldName, &elt));
-        ASSERT_EQUALS(elt.numberInt(), 5);
+    void tearDown() {
+        ws.reset();
+        member = NULL;
     }
 
-    TEST_F(WorkingSetFixture, getFieldOwned) {
-        string fieldName = "x";
-
-        BSONObj obj = BSON(fieldName << 5);
-        member->obj = Snapshotted<BSONObj>(SnapshotId(), obj);
-        ASSERT_TRUE(member->obj.value().isOwned());
-        member->state = WorkingSetMember::OWNED_OBJ;
-        BSONElement elt;
-        ASSERT_TRUE(member->getFieldDotted(fieldName, &elt));
-        ASSERT_EQUALS(elt.numberInt(), 5);
+    std::unique_ptr<WorkingSet> ws;
+    WorkingSetMember* member;
+};
+
+TEST_F(WorkingSetFixture, noFieldToGet) {
+    BSONElement elt;
+
+    // Make sure we're not getting anything out of an invalid WSM.
+    ASSERT_EQUALS(WorkingSetMember::INVALID, member->state);
+    ASSERT_FALSE(member->getFieldDotted("foo", &elt));
+
+    member->state = WorkingSetMember::LOC_AND_IDX;
+    ASSERT_FALSE(member->getFieldDotted("foo", &elt));
+
+    // Our state is that of a valid object.  The getFieldDotted shouldn't throw; there's
+    // something to call getFieldDotted on, but there's no field there.
+    member->state = WorkingSetMember::LOC_AND_UNOWNED_OBJ;
+    ASSERT_TRUE(member->getFieldDotted("foo", &elt));
+
+    member->state = WorkingSetMember::OWNED_OBJ;
+    ASSERT_TRUE(member->getFieldDotted("foo", &elt));
+}
+
+TEST_F(WorkingSetFixture, getFieldUnowned) {
+    string fieldName = "x";
+
+    BSONObj obj = BSON(fieldName << 5);
+    // Not truthful since the loc is bogus, but the loc isn't accessed anyway...
+    member->state = WorkingSetMember::LOC_AND_UNOWNED_OBJ;
+    member->obj = Snapshotted<BSONObj>(SnapshotId(), BSONObj(obj.objdata()));
+    ASSERT_TRUE(obj.isOwned());
+    ASSERT_FALSE(member->obj.value().isOwned());
+
+    // Get out the field we put in.
+    BSONElement elt;
+    ASSERT_TRUE(member->getFieldDotted(fieldName, &elt));
+    ASSERT_EQUALS(elt.numberInt(), 5);
+}
+
+TEST_F(WorkingSetFixture, getFieldOwned) {
+    string fieldName = "x";
+
+    BSONObj obj = BSON(fieldName << 5);
+    member->obj = Snapshotted<BSONObj>(SnapshotId(), obj);
+    ASSERT_TRUE(member->obj.value().isOwned());
+    member->state = WorkingSetMember::OWNED_OBJ;
+    BSONElement elt;
+    ASSERT_TRUE(member->getFieldDotted(fieldName, &elt));
+    ASSERT_EQUALS(elt.numberInt(), 5);
+}
+
+TEST_F(WorkingSetFixture, getFieldFromIndex) {
+    string firstName = "x";
+    int firstValue = 5;
+
+    string secondName = "y";
+    int secondValue = 10;
+
+    member->keyData.push_back(IndexKeyDatum(BSON(firstName << 1), BSON("" << firstValue), NULL));
+    // Also a minor lie as loc is bogus.
+    member->state = WorkingSetMember::LOC_AND_IDX;
+    BSONElement elt;
+    ASSERT_TRUE(member->getFieldDotted(firstName, &elt));
+    ASSERT_EQUALS(elt.numberInt(), firstValue);
+    // No foo field.
+    ASSERT_FALSE(member->getFieldDotted("foo", &elt));
+
+    // Add another index datum.
+    member->keyData.push_back(IndexKeyDatum(BSON(secondName << 1), BSON("" << secondValue), NULL));
+    ASSERT_TRUE(member->getFieldDotted(secondName, &elt));
+    ASSERT_EQUALS(elt.numberInt(), secondValue);
+    ASSERT_TRUE(member->getFieldDotted(firstName, &elt));
+    ASSERT_EQUALS(elt.numberInt(), firstValue);
+    // Still no foo.
+    ASSERT_FALSE(member->getFieldDotted("foo", &elt));
+}
+
+TEST_F(WorkingSetFixture, getDottedFieldFromIndex) {
+    string firstName = "x.y";
+    int firstValue = 5;
+
+    member->keyData.push_back(IndexKeyDatum(BSON(firstName << 1), BSON("" << firstValue), NULL));
+    member->state = WorkingSetMember::LOC_AND_IDX;
+    BSONElement elt;
+    ASSERT_TRUE(member->getFieldDotted(firstName, &elt));
+    ASSERT_EQUALS(elt.numberInt(), firstValue);
+    ASSERT_FALSE(member->getFieldDotted("x", &elt));
+    ASSERT_FALSE(member->getFieldDotted("y", &elt));
+}
+
+//
+// WorkingSet::iterator tests
+//
+
+TEST(WorkingSetIteratorTest, BasicIteratorTest) {
+    WorkingSet ws;
+
+    WorkingSetID id1 = ws.allocate();
+    WorkingSetMember* member1 = ws.get(id1);
+    member1->state = WorkingSetMember::LOC_AND_IDX;
+    member1->keyData.push_back(IndexKeyDatum(BSON("a" << 1), BSON("" << 3), NULL));
+
+    WorkingSetID id2 = ws.allocate();
+    WorkingSetMember* member2 = ws.get(id2);
+    member2->state = WorkingSetMember::LOC_AND_UNOWNED_OBJ;
+    member2->obj = Snapshotted<BSONObj>(SnapshotId(), BSON("a" << 3));
+
+    int counter = 0;
+    for (WorkingSet::iterator it = ws.begin(); it != ws.end(); ++it) {
+        ASSERT(it->state == WorkingSetMember::LOC_AND_IDX ||
+               it->state == WorkingSetMember::LOC_AND_UNOWNED_OBJ);
+        counter++;
     }
+    ASSERT_EQ(counter, 2);
+}
 
-    TEST_F(WorkingSetFixture, getFieldFromIndex) {
-        string firstName = "x";
-        int firstValue = 5;
-
-        string secondName = "y";
-        int secondValue = 10;
-
-        member->keyData.push_back(IndexKeyDatum(BSON(firstName << 1), BSON("" << firstValue), NULL));
-        // Also a minor lie as loc is bogus.
-        member->state = WorkingSetMember::LOC_AND_IDX;
-        BSONElement elt;
-        ASSERT_TRUE(member->getFieldDotted(firstName, &elt));
-        ASSERT_EQUALS(elt.numberInt(), firstValue);
-        // No foo field.
-        ASSERT_FALSE(member->getFieldDotted("foo", &elt));
-
-        // Add another index datum.
-        member->keyData.push_back(IndexKeyDatum(BSON(secondName << 1), BSON("" << secondValue), NULL));
-        ASSERT_TRUE(member->getFieldDotted(secondName, &elt));
-        ASSERT_EQUALS(elt.numberInt(), secondValue);
-        ASSERT_TRUE(member->getFieldDotted(firstName, &elt));
-        ASSERT_EQUALS(elt.numberInt(), firstValue);
-        // Still no foo.
-        ASSERT_FALSE(member->getFieldDotted("foo", &elt));
-    }
+TEST(WorkingSetIteratorTest, EmptyWorkingSet) {
+    WorkingSet ws;
 
-    TEST_F(WorkingSetFixture, getDottedFieldFromIndex) {
-        string firstName = "x.y";
-        int firstValue = 5;
-
-        member->keyData.push_back(IndexKeyDatum(BSON(firstName << 1), BSON("" << firstValue), NULL));
-        member->state = WorkingSetMember::LOC_AND_IDX;
-        BSONElement elt;
-        ASSERT_TRUE(member->getFieldDotted(firstName, &elt));
-        ASSERT_EQUALS(elt.numberInt(), firstValue);
-        ASSERT_FALSE(member->getFieldDotted("x", &elt));
-        ASSERT_FALSE(member->getFieldDotted("y", &elt));
+    int counter = 0;
+    for (WorkingSet::iterator it = ws.begin(); it != ws.end(); ++it) {
+        counter++;
     }
+    ASSERT_EQ(counter, 0);
+}
 
-    //
-    // WorkingSet::iterator tests
-    //
+TEST(WorkingSetIteratorTest, EmptyWorkingSetDueToFree) {
+    WorkingSet ws;
 
-    TEST(WorkingSetIteratorTest, BasicIteratorTest) {
-        WorkingSet ws;
+    WorkingSetID id = ws.allocate();
+    ws.free(id);
 
-        WorkingSetID id1 = ws.allocate();
-        WorkingSetMember* member1 = ws.get(id1);
-        member1->state = WorkingSetMember::LOC_AND_IDX;
-        member1->keyData.push_back(IndexKeyDatum(BSON("a" << 1), BSON("" << 3), NULL));
-
-        WorkingSetID id2 = ws.allocate();
-        WorkingSetMember* member2 = ws.get(id2);
-        member2->state = WorkingSetMember::LOC_AND_UNOWNED_OBJ;
-        member2->obj = Snapshotted<BSONObj>(SnapshotId(), BSON("a" << 3));
-
-        int counter = 0;
-        for (WorkingSet::iterator it = ws.begin(); it != ws.end(); ++it) {
-            ASSERT(it->state == WorkingSetMember::LOC_AND_IDX ||
-                   it->state == WorkingSetMember::LOC_AND_UNOWNED_OBJ);
-            counter++;
-        }
-        ASSERT_EQ(counter, 2);
+    int counter = 0;
+    for (WorkingSet::iterator it = ws.begin(); it != ws.end(); ++it) {
+        counter++;
     }
+    ASSERT_EQ(counter, 0);
+}
 
-    TEST(WorkingSetIteratorTest, EmptyWorkingSet) {
-        WorkingSet ws;
+TEST(WorkingSetIteratorTest, MixedFreeAndInUse) {
+    WorkingSet ws;
 
-        int counter = 0;
-        for (WorkingSet::iterator it = ws.begin(); it != ws.end(); ++it) {
-            counter++;
-        }
-        ASSERT_EQ(counter, 0);
-    }
+    WorkingSetID id1 = ws.allocate();
+    WorkingSetID id2 = ws.allocate();
+    WorkingSetID id3 = ws.allocate();
 
-    TEST(WorkingSetIteratorTest, EmptyWorkingSetDueToFree) {
-        WorkingSet ws;
+    WorkingSetMember* member = ws.get(id2);
+    member->state = WorkingSetMember::LOC_AND_UNOWNED_OBJ;
+    member->obj = Snapshotted<BSONObj>(SnapshotId(), BSON("a" << 3));
 
-        WorkingSetID id = ws.allocate();
-        ws.free(id);
+    ws.free(id1);
+    ws.free(id3);
 
-        int counter = 0;
-        for (WorkingSet::iterator it = ws.begin(); it != ws.end(); ++it) {
-            counter++;
-        }
-        ASSERT_EQ(counter, 0);
+    int counter = 0;
+    for (WorkingSet::iterator it = ws.begin(); it != ws.end(); ++it) {
+        ASSERT(it->state == WorkingSetMember::LOC_AND_UNOWNED_OBJ);
+        counter++;
     }
+    ASSERT_EQ(counter, 1);
+}
 
-    TEST(WorkingSetIteratorTest, MixedFreeAndInUse) {
-        WorkingSet ws;
-
-        WorkingSetID id1 = ws.allocate();
-        WorkingSetID id2 = ws.allocate();
-        WorkingSetID id3 = ws.allocate();
+TEST(WorkingSetIteratorTest, FreeWhileIterating) {
+    WorkingSet ws;
 
-        WorkingSetMember* member = ws.get(id2);
-        member->state = WorkingSetMember::LOC_AND_UNOWNED_OBJ;
-        member->obj = Snapshotted<BSONObj>(SnapshotId(), BSON("a" << 3));
+    ws.allocate();
+    ws.allocate();
+    ws.allocate();
 
-        ws.free(id1);
-        ws.free(id3);
-
-        int counter = 0;
-        for (WorkingSet::iterator it = ws.begin(); it != ws.end(); ++it) {
-            ASSERT(it->state == WorkingSetMember::LOC_AND_UNOWNED_OBJ);
-            counter++;
+    // Free the last two members during iteration.
+    int counter = 0;
+    for (WorkingSet::iterator it = ws.begin(); it != ws.end(); ++it) {
+        if (counter > 0) {
+            it.free();
         }
-        ASSERT_EQ(counter, 1);
+        counter++;
     }
+    ASSERT_EQ(counter, 3);
 
-    TEST(WorkingSetIteratorTest, FreeWhileIterating) {
-        WorkingSet ws;
-
-        ws.allocate();
-        ws.allocate();
-        ws.allocate();
-
-        // Free the last two members during iteration.
-        int counter = 0;
-        for (WorkingSet::iterator it = ws.begin(); it != ws.end(); ++it) {
-            if (counter > 0) {
-                it.free();
-            }
-            counter++;
-        }
-        ASSERT_EQ(counter, 3);
-
-        // Verify that only one item remains in the working set.
-        counter = 0;
-        for (WorkingSet::iterator it = ws.begin(); it != ws.end(); ++it) {
-            counter++;
-        }
-        ASSERT_EQ(counter, 1);
+    // Verify that only one item remains in the working set.
+    counter = 0;
+    for (WorkingSet::iterator it = ws.begin(); it != ws.end(); ++it) {
+        counter++;
     }
+    ASSERT_EQ(counter, 1);
+}
 
 }  // namespace