Author: manik.surtani(a)jboss.com Date: 2008-06-27 13:16:50 -0400 (Fri, 27 Jun 2008) New Revision: 6104 Added: core/trunk/src/test/java/org/jboss/cache/api/mvcc/LockTestBase.java core/trunk/src/test/java/org/jboss/cache/api/mvcc/read_committed/ core/trunk/src/test/java/org/jboss/cache/api/mvcc/read_committed/ReadCommittedLockTest.java core/trunk/src/test/java/org/jboss/cache/api/mvcc/read_committed/ReadCommittedWithParentLockTest.java core/trunk/src/test/java/org/jboss/cache/api/mvcc/repeatable_read/ core/trunk/src/test/java/org/jboss/cache/api/mvcc/repeatable_read/RepeatableReadNoWriteSkewLockTest.java core/trunk/src/test/java/org/jboss/cache/api/mvcc/repeatable_read/RepeatableReadNoWriteSkewWithParentLockTest.java core/trunk/src/test/java/org/jboss/cache/api/mvcc/repeatable_read/RepeatableReadWriteSkewLockTest.java core/trunk/src/test/java/org/jboss/cache/api/mvcc/repeatable_read/RepeatableReadWriteSkewWithParentLockTest.java Log: More MVCC tests Copied: core/trunk/src/test/java/org/jboss/cache/api/mvcc/LockTestBase.java (from rev 6103, core/trunk/src/test/java/org/jboss/cache/api/mvcc/LockTest.java) =================================================================== --- core/trunk/src/test/java/org/jboss/cache/api/mvcc/LockTestBase.java (rev 0) +++ core/trunk/src/test/java/org/jboss/cache/api/mvcc/LockTestBase.java 2008-06-27 17:16:50 UTC (rev 6104) @@ -0,0 +1,541 @@ +package org.jboss.cache.api.mvcc; + +import org.jboss.cache.Cache; +import org.jboss.cache.DefaultCacheFactory; +import org.jboss.cache.Fqn; +import org.jboss.cache.config.Configuration.CacheMode; +import org.jboss.cache.config.Configuration.NodeLockingScheme; +import org.jboss.cache.factories.UnitTestCacheConfigurationFactory; +import org.jboss.cache.invocation.InvocationContextContainer; +import org.jboss.cache.lock.IsolationLevel; +import org.jboss.cache.lock.LockManager; +import org.jboss.cache.lock.MVCCLockManager.LockContainer; +import org.jboss.cache.lock.TimeoutException; +import org.jboss.cache.transaction.DummyTransactionManagerLookup; +import org.jboss.cache.util.TestingUtil; +import org.testng.annotations.AfterMethod; +import org.testng.annotations.BeforeMethod; +import org.testng.annotations.Test; + +import javax.transaction.Transaction; +import javax.transaction.TransactionManager; +import java.util.Collections; +import java.util.HashSet; +import java.util.Set; +import java.util.concurrent.CountDownLatch; + +/** + * @author Manik Surtani (<a href="mailto:manik@jboss.org">manik@jboss.org</a>) + * @since 3.0 + */ +@Test(groups = {"functional", "mvcc"}) +public abstract class LockTestBase +{ + Cache<String, String> cache; + TransactionManager tm; + Fqn A = Fqn.fromString("/a"); + Fqn AB = Fqn.fromString("/a/b"); + Fqn ABC = Fqn.fromString("/a/b/c"); + Fqn ABCD = Fqn.fromString("/a/b/c/d"); + LockManager lockManager; + InvocationContextContainer icc; + protected boolean lockParentForInsertRemove = false; + protected boolean repeatableRead = true; + protected boolean allowWriteSkew = false; + + @BeforeMethod + public void setUp() + { + cache = new DefaultCacheFactory<String, String>().createCache(UnitTestCacheConfigurationFactory.createConfiguration(CacheMode.LOCAL), false); + cache.getConfiguration().setNodeLockingScheme(NodeLockingScheme.MVCC); + cache.getConfiguration().setTransactionManagerLookupClass(DummyTransactionManagerLookup.class.getName()); + cache.getConfiguration().setLockParentForChildInsertRemove(lockParentForInsertRemove); + cache.getConfiguration().setIsolationLevel(repeatableRead ? IsolationLevel.REPEATABLE_READ : IsolationLevel.READ_COMMITTED); + cache.start(); + lockManager = TestingUtil.extractComponentRegistry(cache).getComponent(LockManager.class); + icc = TestingUtil.extractComponentRegistry(cache).getComponent(InvocationContextContainer.class); + tm = TestingUtil.extractComponentRegistry(cache).getComponent(TransactionManager.class); + } + + @AfterMethod + public void tearDown() + { + TestingUtil.killCaches(cache); + } + + private void assertLocked(Fqn fqn) + { + assert lockManager.isLocked(fqn) : fqn + " not locked!"; + assert icc.get().getLocks().contains(fqn) : "Lock not recorded for " + fqn; + } + + private void assertNotLocked(Fqn fqn) + { + // can't rely on the negative test since other nodes may share the same lock with lock striping. +// assert !lockManager.isLocked(fqn) : fqn + " is locked!"; + assert !icc.get().getLocks().contains(fqn) : fqn + " lock recorded!"; + } + + private void assertNoLocks() + { + LockContainer lc = (LockContainer) TestingUtil.extractField(lockManager, "lockContainer"); + assert lc.getNumLocksHeld() == 0 : "Stale locks exist!" + lockManager.printLockInfo(); + assert icc.get().getLocks().isEmpty() : "Stale (?) locks recorded! " + icc.get().getLocks(); + } + + public void testLocksOnPutKeyVal() throws Exception + { + tm.begin(); + cache.put(AB, "k", "v"); + if (lockParentForInsertRemove) + assertLocked(Fqn.ROOT); + else + assertNotLocked(Fqn.ROOT); + assertLocked(A); + assertLocked(AB); + assertNotLocked(ABC); + tm.commit(); + + assertNoLocks(); + + tm.begin(); + assert cache.get(AB, "k").equals("v"); + assertNotLocked(Fqn.ROOT); + assertNotLocked(A); + assertNotLocked(AB); + assertNotLocked(ABC); + tm.commit(); + + assertNoLocks(); + + tm.begin(); + cache.put(ABC, "k", "v"); + assertNotLocked(Fqn.ROOT); + assertNotLocked(A); + if (lockParentForInsertRemove) + assertLocked(AB); + else + assertNotLocked(AB); + assertLocked(ABC); + tm.commit(); + + assertNoLocks(); + } + + public void testLocksOnPutData() throws Exception + { + tm.begin(); + cache.put(AB, Collections.singletonMap("k", "v")); + if (lockParentForInsertRemove) + assertLocked(Fqn.ROOT); + else + assertNotLocked(Fqn.ROOT); + assertLocked(A); + assertLocked(AB); + assertNotLocked(ABC); + tm.commit(); + + assertNoLocks(); + + tm.begin(); + assert cache.get(AB, "k").equals("v"); + assertNotLocked(Fqn.ROOT); + assertNotLocked(A); + assertNotLocked(AB); + assertNotLocked(ABC); + tm.commit(); + + assertNoLocks(); + + tm.begin(); + cache.put(ABC, Collections.singletonMap("k", "v")); + assertNotLocked(Fqn.ROOT); + assertNotLocked(A); + if (lockParentForInsertRemove) + assertLocked(AB); + else + assertNotLocked(AB); + assertLocked(ABC); + tm.commit(); + + assertNoLocks(); + } + + public void testLocksOnRemoveNode() throws Exception + { + // init some data on a node + cache.put(AB, Collections.singletonMap("k", "v")); + + assert "v".equals(cache.get(AB, "k")); + + tm.begin(); + cache.removeNode(AB); + assertLocked(AB); + if (lockParentForInsertRemove) + assertLocked(A); + else + assertNotLocked(A); + assertNotLocked(Fqn.ROOT); + tm.commit(); + assert cache.getNode(AB) == null : "Should not exist"; + assertNoLocks(); + } + + public void testLocksOnEvictNode() throws Exception + { + // init some data on a node + cache.put(AB, Collections.singletonMap("k", "v")); + + assert "v".equals(cache.get(AB, "k")); + + tm.begin(); + cache.evict(AB); + assertLocked(AB); + if (lockParentForInsertRemove) + assertLocked(A); + else + assertNotLocked(A); + assertNotLocked(Fqn.ROOT); + tm.commit(); + assert cache.getNode(AB) == null : "Should not exist"; + assertNoLocks(); + } + + public void testLocksOnEvictRecursiveNode() throws Exception + { + // init some data on a node + cache.put(AB, Collections.singletonMap("k", "v")); + cache.put(ABC, Collections.singletonMap("k", "v")); + cache.put(ABCD, Collections.singletonMap("k", "v")); + + assert "v".equals(cache.get(AB, "k")); + assert "v".equals(cache.get(ABC, "k")); + assert "v".equals(cache.get(ABCD, "k")); + + tm.begin(); + cache.evict(AB, true); + assertLocked(AB); + assertLocked(ABC); + assertLocked(ABCD); + if (lockParentForInsertRemove) + assertLocked(A); + else + assertNotLocked(A); + assertNotLocked(Fqn.ROOT); + tm.commit(); + assert cache.getNode(AB) == null : "Should not exist"; + assertNoLocks(); + } + + public void testLocksOnRemoveNonexistentNode() throws Exception + { + assert cache.getNode(AB) == null : "Should not exist"; + + tm.begin(); + cache.removeNode(AB); + assertLocked(AB); + if (lockParentForInsertRemove) + assertLocked(A); + else + assertNotLocked(A); + assertNotLocked(Fqn.ROOT); + tm.commit(); + assert cache.getNode(AB) == null : "Should not exist"; + assertNoLocks(); + } + + public void testLocksOnEvictNonexistentNode() throws Exception + { + assert cache.getNode(AB) == null : "Should not exist"; + + tm.begin(); + cache.evict(AB); + assertLocked(AB); + if (lockParentForInsertRemove) + assertLocked(A); + else + assertNotLocked(A); + assertNotLocked(Fqn.ROOT); + tm.commit(); + assert cache.getNode(AB) == null : "Should not exist"; + assertNoLocks(); + } + + public void testLocksOnRemoveData() throws Exception + { + // init some data on a node + cache.put(AB, "k", "v"); + cache.put(AB, "k2", "v2"); + + assert "v".equals(cache.get(AB, "k")); + assert "v2".equals(cache.get(AB, "k2")); + + // remove + tm.begin(); + Object x = cache.remove(AB, "k"); + assert x.equals("v"); + assertLocked(AB); + assertNotLocked(A); + assertNotLocked(Fqn.ROOT); + tm.commit(); + assert cache.get(AB, "k") == null : "Should not exist"; + assert "v2".equals(cache.get(AB, "k2")); + assertNoLocks(); + + // clearData + tm.begin(); + cache.clearData(AB); + assertLocked(AB); + assertNotLocked(A); + assertNotLocked(Fqn.ROOT); + tm.commit(); + + assert cache.get(AB, "k") == null : "Should not exist"; + assert cache.get(AB, "k2") == null : "Should not exist"; + assertNoLocks(); + + // nonexistent key + assert cache.get(AB, "k3") == null : "Should not exist"; + tm.begin(); + cache.remove(AB, "k3"); + assertLocked(AB); + assertNotLocked(A); + assertNotLocked(Fqn.ROOT); + tm.commit(); + assertNoLocks(); + } + + public void testLocksOnRemoveDataNonExistentNode() throws Exception + { + assert cache.getNode(AB) == null : "Should not exist"; + + tm.begin(); + cache.remove(AB, "k"); + assertNotLocked(AB); + assertNotLocked(A); + assertNotLocked(Fqn.ROOT); + tm.commit(); + assert cache.getNode(AB) == null : "Should not exist"; + } + + public void testReadMethods() throws Exception + { + cache.put(AB, "k", "v"); + + tm.begin(); + assert "v".equals(cache.get(AB, "k")); + assertNoLocks(); + tm.commit(); + assertNoLocks(); + + tm.begin(); + assert cache.getData(AB).containsKey("k"); + assertNoLocks(); + tm.commit(); + assertNoLocks(); + + tm.begin(); + assert cache.getKeys(AB).contains("k"); + assertNoLocks(); + tm.commit(); + assertNoLocks(); + + tm.begin(); + assert cache.getNode(AB) != null; + assertNoLocks(); + tm.commit(); + assertNoLocks(); + + tm.begin(); + assert !(cache.getNode(A).getChildrenNames().isEmpty()); + assertNoLocks(); + tm.commit(); + assertNoLocks(); + } + + public void testWriteDoesntBlockRead() throws Exception + { + cache.put(AB, "k", "v"); + + // start a write. + tm.begin(); + cache.put(AB, "k2", "v2"); + assertLocked(AB); + Transaction write = tm.suspend(); + + // now start a read and confirm that the write doesn't block it. + tm.begin(); + assert "v".equals(cache.get(AB, "k")); + assert null == cache.get(AB, "k2") : "Should not see uncommitted changes"; + Transaction read = tm.suspend(); + + // commit the write + tm.resume(write); + tm.commit(); + + assertNoLocks(); + + tm.resume(read); + if (repeatableRead) + assert null == cache.get(AB, "k2") : "Should have repeatable read"; + else + assert "v2".equals(cache.get(AB, "k2")) : "Read committed should see committed changes"; + tm.commit(); + assertNoLocks(); + } + + public void testWriteDoesntBlockReadNonexistent() throws Exception + { + // start a write. + tm.begin(); + cache.put(AB, "k", "v"); + assertLocked(AB); + Transaction write = tm.suspend(); + + // now start a read and confirm that the write doesn't block it. + tm.begin(); + assert null == cache.get(AB, "k") : "Should not see uncommitted changes"; + assert null == cache.getNode(AB); + Transaction read = tm.suspend(); + + // commit the write + tm.resume(write); + tm.commit(); + + assertNoLocks(); + + tm.resume(read); + if (repeatableRead) + { + assert null == cache.get(AB, "k") : "Should have repeatable read"; + assert null == cache.getNode(AB); + } + else + { + assert "v".equals(cache.get(AB, "k")) : "Read committed should see committed changes"; + assert null != cache.getNode(AB); + } + tm.commit(); + assertNoLocks(); + } + + public void testConcurrentWriters() throws Exception + { + tm.begin(); + cache.put(AB, "k", "v"); + Transaction t1 = tm.suspend(); + + tm.begin(); + try + { + cache.put(AB, "k", "v"); + assert false : "Should fail lock acquisition"; + } + catch (TimeoutException expected) + { + + } + tm.commit(); + tm.resume(t1); + tm.commit(); + assertNoLocks(); + } + + public void testRollbacks() throws Exception + { + cache.put(AB, "k", "v"); + tm.begin(); + assert "v".equals(cache.get(AB, "k")); + Transaction reader = tm.suspend(); + + tm.begin(); + cache.put(AB, "k", "v2"); + tm.rollback(); + + tm.resume(reader); + assert "v".equals(cache.get(AB, "k")); + tm.commit(); + + // even after commit + assert "v".equals(cache.get(AB, "k")); + assertNoLocks(); + } + + public void testWriteSkew() throws Exception + { + if (repeatableRead) + { + cache.put(AB, "k", "v"); + final Set<Exception> w1exceptions = new HashSet<Exception>(); + final Set<Exception> w2exceptions = new HashSet<Exception>(); + final CountDownLatch w1Signal = new CountDownLatch(1); + final CountDownLatch w2Signal = new CountDownLatch(1); + + Thread w1 = new Thread() + { + public void run() + { + try + { + tm.begin(); + assert "v".equals(cache.get(AB, "k")); + w1Signal.await(); + cache.put(AB, "k", "v2"); + tm.commit(); + } + catch (Exception e) + { + w1exceptions.add(e); + } + } + }; + + Thread w2 = new Thread() + { + public void run() + { + try + { + tm.begin(); + assert "v".equals(cache.get(AB, "k")); + w2Signal.await(); + cache.put(AB, "k", "v3"); + tm.commit(); + } + catch (Exception e) + { + w2exceptions.add(e); + } + } + }; + + w1.start(); + w2.start(); + + // now. both txs have read. + // let tx1 start writing + w1Signal.countDown(); + w1.join(); + + w2Signal.countDown(); + w2.join(); + + if (allowWriteSkew) + { + assert "v3".equals(cache.get(AB, "k")) : "W2 should have overwritten W1's work!"; + // should have no exceptions!! + assert w2exceptions.size() == 0; + assert w1exceptions.size() == 0; + } + else + { + assert "v2".equals(cache.get(AB, "k")) : "W2 should NOT have overwritten W1's work!"; + // there should be a single exception from w2. + assert w2exceptions.size() == 1; + assert w1exceptions.size() == 0; + } + + assertNoLocks(); + } + } +} Added: core/trunk/src/test/java/org/jboss/cache/api/mvcc/read_committed/ReadCommittedLockTest.java =================================================================== --- core/trunk/src/test/java/org/jboss/cache/api/mvcc/read_committed/ReadCommittedLockTest.java (rev 0) +++ core/trunk/src/test/java/org/jboss/cache/api/mvcc/read_committed/ReadCommittedLockTest.java 2008-06-27 17:16:50 UTC (rev 6104) @@ -0,0 +1,14 @@ +package org.jboss.cache.api.mvcc.read_committed; + +import org.jboss.cache.api.mvcc.LockTestBase; +import org.testng.annotations.Test; + +@Test(groups = {"functional", "mvcc"}) +public class ReadCommittedLockTest extends LockTestBase +{ + public ReadCommittedLockTest() + { + repeatableRead = false; + lockParentForInsertRemove = false; + } +} Added: core/trunk/src/test/java/org/jboss/cache/api/mvcc/read_committed/ReadCommittedWithParentLockTest.java =================================================================== --- core/trunk/src/test/java/org/jboss/cache/api/mvcc/read_committed/ReadCommittedWithParentLockTest.java (rev 0) +++ core/trunk/src/test/java/org/jboss/cache/api/mvcc/read_committed/ReadCommittedWithParentLockTest.java 2008-06-27 17:16:50 UTC (rev 6104) @@ -0,0 +1,14 @@ +package org.jboss.cache.api.mvcc.read_committed; + +import org.jboss.cache.api.mvcc.LockTestBase; +import org.testng.annotations.Test; + +@Test(groups = {"functional", "mvcc"}) +public class ReadCommittedWithParentLockTest extends LockTestBase +{ + public ReadCommittedWithParentLockTest() + { + repeatableRead = false; + lockParentForInsertRemove = true; + } +} Added: core/trunk/src/test/java/org/jboss/cache/api/mvcc/repeatable_read/RepeatableReadNoWriteSkewLockTest.java =================================================================== --- core/trunk/src/test/java/org/jboss/cache/api/mvcc/repeatable_read/RepeatableReadNoWriteSkewLockTest.java (rev 0) +++ core/trunk/src/test/java/org/jboss/cache/api/mvcc/repeatable_read/RepeatableReadNoWriteSkewLockTest.java 2008-06-27 17:16:50 UTC (rev 6104) @@ -0,0 +1,15 @@ +package org.jboss.cache.api.mvcc.repeatable_read; + +import org.jboss.cache.api.mvcc.LockTestBase; +import org.testng.annotations.Test; + +@Test(groups = {"functional", "mvcc"}) +public class RepeatableReadNoWriteSkewLockTest extends LockTestBase +{ + public RepeatableReadNoWriteSkewLockTest() + { + repeatableRead = true; + allowWriteSkew = false; + lockParentForInsertRemove = false; + } +} Added: core/trunk/src/test/java/org/jboss/cache/api/mvcc/repeatable_read/RepeatableReadNoWriteSkewWithParentLockTest.java =================================================================== --- core/trunk/src/test/java/org/jboss/cache/api/mvcc/repeatable_read/RepeatableReadNoWriteSkewWithParentLockTest.java (rev 0) +++ core/trunk/src/test/java/org/jboss/cache/api/mvcc/repeatable_read/RepeatableReadNoWriteSkewWithParentLockTest.java 2008-06-27 17:16:50 UTC (rev 6104) @@ -0,0 +1,15 @@ +package org.jboss.cache.api.mvcc.repeatable_read; + +import org.jboss.cache.api.mvcc.LockTestBase; +import org.testng.annotations.Test; + +@Test(groups = {"functional", "mvcc"}) +public class RepeatableReadNoWriteSkewWithParentLockTest extends LockTestBase +{ + public RepeatableReadNoWriteSkewWithParentLockTest() + { + repeatableRead = true; + allowWriteSkew = false; + lockParentForInsertRemove = true; + } +} Added: core/trunk/src/test/java/org/jboss/cache/api/mvcc/repeatable_read/RepeatableReadWriteSkewLockTest.java =================================================================== --- core/trunk/src/test/java/org/jboss/cache/api/mvcc/repeatable_read/RepeatableReadWriteSkewLockTest.java (rev 0) +++ core/trunk/src/test/java/org/jboss/cache/api/mvcc/repeatable_read/RepeatableReadWriteSkewLockTest.java 2008-06-27 17:16:50 UTC (rev 6104) @@ -0,0 +1,15 @@ +package org.jboss.cache.api.mvcc.repeatable_read; + +import org.jboss.cache.api.mvcc.LockTestBase; +import org.testng.annotations.Test; + +@Test(groups = {"functional", "mvcc"}) +public class RepeatableReadWriteSkewLockTest extends LockTestBase +{ + public RepeatableReadWriteSkewLockTest() + { + repeatableRead = true; + allowWriteSkew = true; + lockParentForInsertRemove = false; + } +} Added: core/trunk/src/test/java/org/jboss/cache/api/mvcc/repeatable_read/RepeatableReadWriteSkewWithParentLockTest.java =================================================================== --- core/trunk/src/test/java/org/jboss/cache/api/mvcc/repeatable_read/RepeatableReadWriteSkewWithParentLockTest.java (rev 0) +++ core/trunk/src/test/java/org/jboss/cache/api/mvcc/repeatable_read/RepeatableReadWriteSkewWithParentLockTest.java 2008-06-27 17:16:50 UTC (rev 6104) @@ -0,0 +1,15 @@ +package org.jboss.cache.api.mvcc.repeatable_read; + +import org.jboss.cache.api.mvcc.LockTestBase; +import org.testng.annotations.Test; + +@Test(groups = {"functional", "mvcc"}) +public class RepeatableReadWriteSkewWithParentLockTest extends LockTestBase +{ + public RepeatableReadWriteSkewWithParentLockTest() + { + repeatableRead = true; + allowWriteSkew = true; + lockParentForInsertRemove = true; + } +}