1 files changed, 226 insertions, 236 deletions
diff --git a/src/mongo/s/catalog/dist_lock_catalog_mock.cpp b/src/mongo/s/catalog/dist_lock_catalog_mock.cpp
index 9b8fc3f8f5a..260d4dce6f3 100644
--- a/src/mongo/s/catalog/dist_lock_catalog_mock.cpp
+++ b/src/mongo/s/catalog/dist_lock_catalog_mock.cpp
@@ -40,302 +40,292 @@
 namespace mongo {
 
 namespace {
-    Status kBadRetValue(ErrorCodes::InternalError, "no return value");
-    StatusWith<LocksType> kLocksTypeBadRetValue(kBadRetValue);
-    StatusWith<LockpingsType> kLockpingsTypeBadRetValue(kBadRetValue);
-    StatusWith<DistLockCatalog::ServerInfo> kServerInfoBadRetValue(kBadRetValue);
+Status kBadRetValue(ErrorCodes::InternalError, "no return value");
+StatusWith<LocksType> kLocksTypeBadRetValue(kBadRetValue);
+StatusWith<LockpingsType> kLockpingsTypeBadRetValue(kBadRetValue);
+StatusWith<DistLockCatalog::ServerInfo> kServerInfoBadRetValue(kBadRetValue);
+
+void noGrabLockFuncSet(StringData lockID,
+                       const OID& lockSessionID,
+                       StringData who,
+                       StringData processId,
+                       Date_t time,
+                       StringData why) {
+    FAIL(str::stream() << "grabLock not expected to be called. "
+                       << "lockID: " << lockID << ", who: " << who << ", processId: " << processId
+                       << ", why: " << why);
+}
 
-    void noGrabLockFuncSet(StringData lockID,
+void noOvertakeLockFuncSet(StringData lockID,
                            const OID& lockSessionID,
+                           const OID& currentHolderTS,
                            StringData who,
                            StringData processId,
                            Date_t time,
                            StringData why) {
-        FAIL(str::stream() << "grabLock not expected to be called. "
-                           << "lockID: " << lockID
-                           << ", who: " << who
-                           << ", processId: " << processId
-                           << ", why: " << why);
-    }
-
-    void noOvertakeLockFuncSet(StringData lockID,
-                               const OID& lockSessionID,
-                               const OID& currentHolderTS,
-                               StringData who,
-                               StringData processId,
-                               Date_t time,
-                               StringData why) {
-        FAIL(str::stream() << "overtakeLock not expected to be called. "
-                           << "lockID: " << lockID
-                           << ", currentHolderTS: " << currentHolderTS
-                           << ", who: " << who
-                           << ", processId: " << processId
-                           << ", why: " << why);
-    }
-
-    void noUnLockFuncSet(const OID& lockSessionID) {
-        FAIL(str::stream() << "unlock not expected to be called. "
-                           << "lockSessionID: " << lockSessionID);
-    }
+    FAIL(str::stream() << "overtakeLock not expected to be called. "
+                       << "lockID: " << lockID << ", currentHolderTS: " << currentHolderTS
+                       << ", who: " << who << ", processId: " << processId << ", why: " << why);
+}
 
-    void noPingFuncSet(StringData processID, Date_t ping) {
-        // Ping is expected to be called all the time, so default behavior is do nothing.
-    }
+void noUnLockFuncSet(const OID& lockSessionID) {
+    FAIL(str::stream() << "unlock not expected to be called. "
+                       << "lockSessionID: " << lockSessionID);
+}
 
-    void noStopPingFuncSet(StringData processID) {
-        FAIL(str::stream() << "stopPing not expected to be called. "
-                           << "processID: " << processID);
-    }
+void noPingFuncSet(StringData processID, Date_t ping) {
+    // Ping is expected to be called all the time, so default behavior is do nothing.
+}
 
-    void noGetLockByTSSet(const OID& lockSessionID) {
-        FAIL(str::stream() << "getLockByTS not expected to be called. "
-                           << "lockSessionID: " << lockSessionID);
-    }
+void noStopPingFuncSet(StringData processID) {
+    FAIL(str::stream() << "stopPing not expected to be called. "
+                       << "processID: " << processID);
+}
 
-    void noGetLockByNameSet(StringData name) {
-        FAIL(str::stream() << "getLockByName not expected to be called. "
-                           << "lockName: " << name);
-    }
+void noGetLockByTSSet(const OID& lockSessionID) {
+    FAIL(str::stream() << "getLockByTS not expected to be called. "
+                       << "lockSessionID: " << lockSessionID);
+}
 
-    void noGetPingSet(StringData processId) {
-        FAIL(str::stream() << "getPing not expected to be called. "
-                           << "lockName: " << processId);
-    }
+void noGetLockByNameSet(StringData name) {
+    FAIL(str::stream() << "getLockByName not expected to be called. "
+                       << "lockName: " << name);
+}
 
-    void noGetServerInfoSet() {
-        FAIL("getServerInfo not expected to be called");
-    }
+void noGetPingSet(StringData processId) {
+    FAIL(str::stream() << "getPing not expected to be called. "
+                       << "lockName: " << processId);
+}
 
-} // unnamed namespace
-
-    DistLockCatalogMock::DistLockCatalogMock():
-            _grabLockChecker(noGrabLockFuncSet),
-            _grabLockReturnValue(kLocksTypeBadRetValue),
-            _unlockChecker(noUnLockFuncSet),
-            _unlockReturnValue(kBadRetValue),
-            _pingChecker(noPingFuncSet),
-            _pingReturnValue(kBadRetValue),
-            _stopPingChecker(noStopPingFuncSet),
-            _stopPingReturnValue(kBadRetValue),
-            _getLockByTSChecker(noGetLockByTSSet),
-            _getLockByTSReturnValue(kLocksTypeBadRetValue),
-            _getLockByNameChecker(noGetLockByNameSet),
-            _getLockByNameReturnValue(kLocksTypeBadRetValue),
-            _overtakeLockChecker(noOvertakeLockFuncSet),
-            _overtakeLockReturnValue(kLocksTypeBadRetValue),
-            _getPingChecker(noGetPingSet),
-            _getPingReturnValue(kLockpingsTypeBadRetValue),
-            _getServerInfoChecker(noGetServerInfoSet),
-            _getServerInfoReturnValue(kServerInfoBadRetValue) {
-    }
+void noGetServerInfoSet() {
+    FAIL("getServerInfo not expected to be called");
+}
 
-    DistLockCatalogMock::~DistLockCatalogMock() {
+}  // unnamed namespace
+
+DistLockCatalogMock::DistLockCatalogMock()
+    : _grabLockChecker(noGrabLockFuncSet),
+      _grabLockReturnValue(kLocksTypeBadRetValue),
+      _unlockChecker(noUnLockFuncSet),
+      _unlockReturnValue(kBadRetValue),
+      _pingChecker(noPingFuncSet),
+      _pingReturnValue(kBadRetValue),
+      _stopPingChecker(noStopPingFuncSet),
+      _stopPingReturnValue(kBadRetValue),
+      _getLockByTSChecker(noGetLockByTSSet),
+      _getLockByTSReturnValue(kLocksTypeBadRetValue),
+      _getLockByNameChecker(noGetLockByNameSet),
+      _getLockByNameReturnValue(kLocksTypeBadRetValue),
+      _overtakeLockChecker(noOvertakeLockFuncSet),
+      _overtakeLockReturnValue(kLocksTypeBadRetValue),
+      _getPingChecker(noGetPingSet),
+      _getPingReturnValue(kLockpingsTypeBadRetValue),
+      _getServerInfoChecker(noGetServerInfoSet),
+      _getServerInfoReturnValue(kServerInfoBadRetValue) {}
+
+DistLockCatalogMock::~DistLockCatalogMock() {}
+
+StatusWith<LockpingsType> DistLockCatalogMock::getPing(StringData processID) {
+    auto ret = kLockpingsTypeBadRetValue;
+    GetPingFunc checkerFunc = noGetPingSet;
+
+    {
+        stdx::lock_guard<stdx::mutex> lk(_mutex);
+        ret = _getPingReturnValue;
+        checkerFunc = _getPingChecker;
     }
 
-    StatusWith<LockpingsType> DistLockCatalogMock::getPing(StringData processID) {
-        auto ret = kLockpingsTypeBadRetValue;
-        GetPingFunc checkerFunc = noGetPingSet;
+    checkerFunc(processID);
+    return ret;
+}
 
-        {
-            stdx::lock_guard<stdx::mutex> lk(_mutex);
-            ret = _getPingReturnValue;
-            checkerFunc = _getPingChecker;
-        }
+Status DistLockCatalogMock::ping(StringData processID, Date_t ping) {
+    auto ret = kBadRetValue;
+    PingFunc checkerFunc = noPingFuncSet;
 
-        checkerFunc(processID);
-        return ret;
+    {
+        stdx::lock_guard<stdx::mutex> lk(_mutex);
+        ret = _pingReturnValue;
+        checkerFunc = _pingChecker;
     }
 
-    Status DistLockCatalogMock::ping(StringData processID, Date_t ping) {
-        auto ret = kBadRetValue;
-        PingFunc checkerFunc = noPingFuncSet;
+    checkerFunc(processID, ping);
+    return ret;
+}
 
-        {
-            stdx::lock_guard<stdx::mutex> lk(_mutex);
-            ret = _pingReturnValue;
-            checkerFunc = _pingChecker;
-        }
+StatusWith<LocksType> DistLockCatalogMock::grabLock(StringData lockID,
+                                                    const OID& lockSessionID,
+                                                    StringData who,
+                                                    StringData processId,
+                                                    Date_t time,
+                                                    StringData why) {
+    auto ret = kLocksTypeBadRetValue;
+    GrabLockFunc checkerFunc = noGrabLockFuncSet;
 
-        checkerFunc(processID, ping);
-        return ret;
+    {
+        stdx::lock_guard<stdx::mutex> lk(_mutex);
+        ret = _grabLockReturnValue;
+        checkerFunc = _grabLockChecker;
     }
 
-    StatusWith<LocksType> DistLockCatalogMock::grabLock(StringData lockID,
+    checkerFunc(lockID, lockSessionID, who, processId, time, why);
+    return ret;
+}
+
+StatusWith<LocksType> DistLockCatalogMock::overtakeLock(StringData lockID,
                                                         const OID& lockSessionID,
+                                                        const OID& currentHolderTS,
                                                         StringData who,
                                                         StringData processId,
                                                         Date_t time,
                                                         StringData why) {
-        auto ret = kLocksTypeBadRetValue;
-        GrabLockFunc checkerFunc = noGrabLockFuncSet;
-
-        {
-            stdx::lock_guard<stdx::mutex> lk(_mutex);
-            ret = _grabLockReturnValue;
-            checkerFunc = _grabLockChecker;
-        }
+    auto ret = kLocksTypeBadRetValue;
+    OvertakeLockFunc checkerFunc = noOvertakeLockFuncSet;
 
-        checkerFunc(lockID, lockSessionID, who, processId, time, why);
-        return ret;
-    }
-
-    StatusWith<LocksType> DistLockCatalogMock::overtakeLock(StringData lockID,
-                                                            const OID& lockSessionID,
-                                                            const OID& currentHolderTS,
-                                                            StringData who,
-                                                            StringData processId,
-                                                            Date_t time,
-                                                            StringData why) {
-        auto ret = kLocksTypeBadRetValue;
-        OvertakeLockFunc checkerFunc = noOvertakeLockFuncSet;
-
-        {
-            stdx::lock_guard<stdx::mutex> lk(_mutex);
-            ret = _overtakeLockReturnValue;
-            checkerFunc = _overtakeLockChecker;
-        }
-
-        checkerFunc(lockID, lockSessionID, currentHolderTS, who, processId, time, why);
-        return ret;
+    {
+        stdx::lock_guard<stdx::mutex> lk(_mutex);
+        ret = _overtakeLockReturnValue;
+        checkerFunc = _overtakeLockChecker;
     }
 
-    Status DistLockCatalogMock::unlock(const OID& lockSessionID) {
-        auto ret = kBadRetValue;
-        UnlockFunc checkerFunc = noUnLockFuncSet;
+    checkerFunc(lockID, lockSessionID, currentHolderTS, who, processId, time, why);
+    return ret;
+}
 
-        {
-            stdx::lock_guard<stdx::mutex> lk(_mutex);
-            ret = _unlockReturnValue;
-            checkerFunc = _unlockChecker;
-        }
+Status DistLockCatalogMock::unlock(const OID& lockSessionID) {
+    auto ret = kBadRetValue;
+    UnlockFunc checkerFunc = noUnLockFuncSet;
 
-        checkerFunc(lockSessionID);
-        return ret;
+    {
+        stdx::lock_guard<stdx::mutex> lk(_mutex);
+        ret = _unlockReturnValue;
+        checkerFunc = _unlockChecker;
     }
 
-    StatusWith<DistLockCatalog::ServerInfo> DistLockCatalogMock::getServerInfo() {
-        auto ret = kServerInfoBadRetValue;
-        GetServerInfoFunc checkerFunc = noGetServerInfoSet;
+    checkerFunc(lockSessionID);
+    return ret;
+}
 
-        {
-            stdx::lock_guard<stdx::mutex> lk(_mutex);
-            ret = _getServerInfoReturnValue;
-            checkerFunc = _getServerInfoChecker;
-        }
+StatusWith<DistLockCatalog::ServerInfo> DistLockCatalogMock::getServerInfo() {
+    auto ret = kServerInfoBadRetValue;
+    GetServerInfoFunc checkerFunc = noGetServerInfoSet;
 
-        checkerFunc();
-        return ret;
+    {
+        stdx::lock_guard<stdx::mutex> lk(_mutex);
+        ret = _getServerInfoReturnValue;
+        checkerFunc = _getServerInfoChecker;
     }
 
-    StatusWith<LocksType> DistLockCatalogMock::getLockByTS(const OID& lockSessionID) {
-        auto ret = kLocksTypeBadRetValue;
-        GetLockByTSFunc checkerFunc = noGetLockByTSSet;
+    checkerFunc();
+    return ret;
+}
 
-        {
-            stdx::lock_guard<stdx::mutex> lk(_mutex);
-            ret = _getLockByTSReturnValue;
-            checkerFunc = _getLockByTSChecker;
-        }
+StatusWith<LocksType> DistLockCatalogMock::getLockByTS(const OID& lockSessionID) {
+    auto ret = kLocksTypeBadRetValue;
+    GetLockByTSFunc checkerFunc = noGetLockByTSSet;
 
-        checkerFunc(lockSessionID);
-        return ret;
+    {
+        stdx::lock_guard<stdx::mutex> lk(_mutex);
+        ret = _getLockByTSReturnValue;
+        checkerFunc = _getLockByTSChecker;
     }
 
-    StatusWith<LocksType> DistLockCatalogMock::getLockByName(StringData name) {
-        auto ret = kLocksTypeBadRetValue;
-        GetLockByNameFunc checkerFunc = noGetLockByNameSet;
+    checkerFunc(lockSessionID);
+    return ret;
+}
 
-        {
-            stdx::lock_guard<stdx::mutex> lk(_mutex);
-            ret = _getLockByNameReturnValue;
-            checkerFunc = _getLockByNameChecker;
-        }
+StatusWith<LocksType> DistLockCatalogMock::getLockByName(StringData name) {
+    auto ret = kLocksTypeBadRetValue;
+    GetLockByNameFunc checkerFunc = noGetLockByNameSet;
 
-        checkerFunc(name);
-        return ret;
+    {
+        stdx::lock_guard<stdx::mutex> lk(_mutex);
+        ret = _getLockByNameReturnValue;
+        checkerFunc = _getLockByNameChecker;
     }
 
-    Status DistLockCatalogMock::stopPing(StringData processId) {
-        auto ret = kBadRetValue;
-        StopPingFunc checkerFunc = noStopPingFuncSet;
-
-        {
-            stdx::lock_guard<stdx::mutex> lk(_mutex);
-            ret = _stopPingReturnValue;
-            checkerFunc = _stopPingChecker;
-        }
+    checkerFunc(name);
+    return ret;
+}
 
-        checkerFunc(processId);
-        return ret;
-    }
+Status DistLockCatalogMock::stopPing(StringData processId) {
+    auto ret = kBadRetValue;
+    StopPingFunc checkerFunc = noStopPingFuncSet;
 
-    void DistLockCatalogMock::expectGrabLock(DistLockCatalogMock::GrabLockFunc checkerFunc,
-                                             StatusWith<LocksType> returnThis) {
+    {
         stdx::lock_guard<stdx::mutex> lk(_mutex);
-        _grabLockChecker = checkerFunc;
-        _grabLockReturnValue = returnThis;
+        ret = _stopPingReturnValue;
+        checkerFunc = _stopPingChecker;
     }
 
-    void DistLockCatalogMock::expectNoGrabLock() {
-        stdx::lock_guard<stdx::mutex> lk(_mutex);
-        _grabLockChecker = noGrabLockFuncSet;
-        _grabLockReturnValue = kLocksTypeBadRetValue;
-    }
+    checkerFunc(processId);
+    return ret;
+}
 
-    void DistLockCatalogMock::expectUnLock(DistLockCatalogMock::UnlockFunc checkerFunc,
-                                           Status returnThis) {
-        stdx::lock_guard<stdx::mutex> lk(_mutex);
-        _unlockChecker = checkerFunc;
-        _unlockReturnValue = returnThis;
-    }
+void DistLockCatalogMock::expectGrabLock(DistLockCatalogMock::GrabLockFunc checkerFunc,
+                                         StatusWith<LocksType> returnThis) {
+    stdx::lock_guard<stdx::mutex> lk(_mutex);
+    _grabLockChecker = checkerFunc;
+    _grabLockReturnValue = returnThis;
+}
 
-    void DistLockCatalogMock::expectPing(DistLockCatalogMock::PingFunc checkerFunc,
-                                         Status returnThis) {
-        stdx::lock_guard<stdx::mutex> lk(_mutex);
-        _pingChecker = checkerFunc;
-        _pingReturnValue = returnThis;
-    }
+void DistLockCatalogMock::expectNoGrabLock() {
+    stdx::lock_guard<stdx::mutex> lk(_mutex);
+    _grabLockChecker = noGrabLockFuncSet;
+    _grabLockReturnValue = kLocksTypeBadRetValue;
+}
 
-    void DistLockCatalogMock::expectStopPing(StopPingFunc checkerFunc, Status returnThis) {
-        stdx::lock_guard<stdx::mutex> lk(_mutex);
-        _stopPingChecker = checkerFunc;
-        _stopPingReturnValue = returnThis;
-    }
+void DistLockCatalogMock::expectUnLock(DistLockCatalogMock::UnlockFunc checkerFunc,
+                                       Status returnThis) {
+    stdx::lock_guard<stdx::mutex> lk(_mutex);
+    _unlockChecker = checkerFunc;
+    _unlockReturnValue = returnThis;
+}
 
-    void DistLockCatalogMock::expectGetLockByTS(GetLockByTSFunc checkerFunc,
-                                                StatusWith<LocksType> returnThis) {
-        stdx::lock_guard<stdx::mutex> lk(_mutex);
-        _getLockByTSChecker = checkerFunc;
-        _getLockByTSReturnValue = returnThis;
-    }
+void DistLockCatalogMock::expectPing(DistLockCatalogMock::PingFunc checkerFunc, Status returnThis) {
+    stdx::lock_guard<stdx::mutex> lk(_mutex);
+    _pingChecker = checkerFunc;
+    _pingReturnValue = returnThis;
+}
 
-    void DistLockCatalogMock::expectGetLockByName(GetLockByNameFunc checkerFunc,
-                                                  StatusWith<LocksType> returnThis) {
-        stdx::lock_guard<stdx::mutex> lk(_mutex);
-        _getLockByNameChecker = checkerFunc;
-        _getLockByNameReturnValue = returnThis;
-    }
+void DistLockCatalogMock::expectStopPing(StopPingFunc checkerFunc, Status returnThis) {
+    stdx::lock_guard<stdx::mutex> lk(_mutex);
+    _stopPingChecker = checkerFunc;
+    _stopPingReturnValue = returnThis;
+}
 
-    void DistLockCatalogMock::expectOvertakeLock(OvertakeLockFunc checkerFunc,
-                                                 StatusWith<LocksType> returnThis) {
-        stdx::lock_guard<stdx::mutex> lk(_mutex);
-        _overtakeLockChecker = checkerFunc;
-        _overtakeLockReturnValue = returnThis;
-    }
+void DistLockCatalogMock::expectGetLockByTS(GetLockByTSFunc checkerFunc,
+                                            StatusWith<LocksType> returnThis) {
+    stdx::lock_guard<stdx::mutex> lk(_mutex);
+    _getLockByTSChecker = checkerFunc;
+    _getLockByTSReturnValue = returnThis;
+}
 
-    void DistLockCatalogMock::expectGetPing(GetPingFunc checkerFunc,
-                                            StatusWith<LockpingsType> returnThis) {
-        stdx::lock_guard<stdx::mutex> lk(_mutex);
-        _getPingChecker = checkerFunc;
-        _getPingReturnValue = returnThis;
-    }
+void DistLockCatalogMock::expectGetLockByName(GetLockByNameFunc checkerFunc,
+                                              StatusWith<LocksType> returnThis) {
+    stdx::lock_guard<stdx::mutex> lk(_mutex);
+    _getLockByNameChecker = checkerFunc;
+    _getLockByNameReturnValue = returnThis;
+}
 
-    void DistLockCatalogMock::expectGetServerInfo(
-            GetServerInfoFunc checkerFunc,
-            StatusWith<DistLockCatalog::ServerInfo> returnThis) {
-        stdx::lock_guard<stdx::mutex> lk(_mutex);
-        _getServerInfoChecker = checkerFunc;
-        _getServerInfoReturnValue = returnThis;
-    }
+void DistLockCatalogMock::expectOvertakeLock(OvertakeLockFunc checkerFunc,
+                                             StatusWith<LocksType> returnThis) {
+    stdx::lock_guard<stdx::mutex> lk(_mutex);
+    _overtakeLockChecker = checkerFunc;
+    _overtakeLockReturnValue = returnThis;
+}
+
+void DistLockCatalogMock::expectGetPing(GetPingFunc checkerFunc,
+                                        StatusWith<LockpingsType> returnThis) {
+    stdx::lock_guard<stdx::mutex> lk(_mutex);
+    _getPingChecker = checkerFunc;
+    _getPingReturnValue = returnThis;
+}
 
+void DistLockCatalogMock::expectGetServerInfo(GetServerInfoFunc checkerFunc,
+                                              StatusWith<DistLockCatalog::ServerInfo> returnThis) {
+    stdx::lock_guard<stdx::mutex> lk(_mutex);
+    _getServerInfoChecker = checkerFunc;
+    _getServerInfoReturnValue = returnThis;
+}
 }