TEST(LockerImpl, MMAPV1Locker) {
const ResourceId resId(RESOURCE_DATABASE, std::string("TestDB"));
MMAPV1LockerImpl locker;
ASSERT_EQUALS(LOCK_OK, locker.lockGlobal(MODE_IX));
ASSERT_EQUALS(LOCK_OK, locker.lock(resId, MODE_X));
// Make sure the flush lock IS held
Locker::LockerInfo info;
locker.getLockerInfo(&info);
ASSERT(!info.waitingResource.isValid());
ASSERT_EQUALS(3U, info.locks.size());
ASSERT_EQUALS(RESOURCE_GLOBAL, info.locks[0].resourceId.getType());
ASSERT_EQUALS(RESOURCE_MMAPV1_FLUSH, info.locks[1].resourceId.getType());
ASSERT_EQUALS(resId, info.locks[2].resourceId);
ASSERT(locker.unlockAll());
}
TEST(LockerImpl, ReLockNoConflict) {
const ResourceId resId(RESOURCE_COLLECTION, std::string("TestDB.collection"));
MMAPV1LockerImpl locker;
locker.lockGlobal(MODE_IX);
ASSERT(LOCK_OK == locker.lock(resId, MODE_S));
ASSERT(LOCK_OK == locker.lock(resId, MODE_X));
ASSERT(!locker.unlock(resId));
ASSERT(locker.isLockHeldForMode(resId, MODE_X));
ASSERT(locker.unlock(resId));
ASSERT(locker.isLockHeldForMode(resId, MODE_NONE));
ASSERT(locker.unlockAll());
}
TEST(LockerImpl, ReadTransaction) {
MMAPV1LockerImpl locker;
locker.lockGlobal(MODE_IS);
locker.unlockAll();
locker.lockGlobal(MODE_IX);
locker.unlockAll();
locker.lockGlobal(MODE_IX);
locker.lockGlobal(MODE_IS);
locker.unlockAll();
locker.unlockAll();
}
/**
* Test that saveMMAPV1LockerImpl works by examining the output.
*/
TEST(LockerImpl, saveAndRestoreGlobal) {
Locker::LockSnapshot lockInfo;
MMAPV1LockerImpl locker;
// No lock requests made, no locks held.
locker.saveLockStateAndUnlock(&lockInfo);
ASSERT_EQUALS(0U, lockInfo.locks.size());
// Lock the global lock, but just once.
locker.lockGlobal(MODE_IX);
// We've locked the global lock. This should be reflected in the lockInfo.
locker.saveLockStateAndUnlock(&lockInfo);
ASSERT(!locker.isLocked());
ASSERT_EQUALS(MODE_IX, lockInfo.globalMode);
// Restore the lock(s) we had.
locker.restoreLockState(lockInfo);
ASSERT(locker.isLocked());
ASSERT(locker.unlockAll());
}
/**
* Test that we don't unlock when we have the global lock more than once.
*/
TEST(LockerImpl, saveAndRestoreGlobalAcquiredTwice) {
Locker::LockSnapshot lockInfo;
MMAPV1LockerImpl locker;
// No lock requests made, no locks held.
locker.saveLockStateAndUnlock(&lockInfo);
ASSERT_EQUALS(0U, lockInfo.locks.size());
// Lock the global lock.
locker.lockGlobal(MODE_IX);
locker.lockGlobal(MODE_IX);
// This shouldn't actually unlock as we're in a nested scope.
ASSERT(!locker.saveLockStateAndUnlock(&lockInfo));
ASSERT(locker.isLocked());
// We must unlockAll twice.
ASSERT(!locker.unlockAll());
ASSERT(locker.unlockAll());
}
/**
* Tests that restoreMMAPV1LockerImpl works by locking a db and collection and saving + restoring.
*/
TEST(LockerImpl, saveAndRestoreDBAndCollection) {
Locker::LockSnapshot lockInfo;
MMAPV1LockerImpl locker;
const ResourceId resIdDatabase(RESOURCE_DATABASE, std::string("TestDB"));
const ResourceId resIdCollection(RESOURCE_COLLECTION, std::string("TestDB.collection"));
// Lock some stuff.
locker.lockGlobal(MODE_IX);
ASSERT(LOCK_OK == locker.lock(resIdDatabase, MODE_IX));
ASSERT(LOCK_OK == locker.lock(resIdCollection, MODE_X));
locker.saveLockStateAndUnlock(&lockInfo);
// Things shouldn't be locked anymore.
ASSERT(locker.getLockMode(resIdDatabase) == MODE_NONE);
ASSERT(locker.getLockMode(resIdCollection) == MODE_NONE);
// Restore lock state.
locker.restoreLockState(lockInfo);
// Make sure things were re-locked.
ASSERT(locker.getLockMode(resIdDatabase) == MODE_IX);
ASSERT(locker.getLockMode(resIdCollection) == MODE_X);
locker.unlockAll();
}
