[jbosscache-commits] JBoss Cache SVN: r6104 - in core/trunk/src/test/java/org/jboss/cache/api/mvcc: read_committed and 1 other directories.
jbosscache-commits at lists.jboss.org
jbosscache-commits at lists.jboss.org
Fri Jun 27 13:16:51 EDT 2008
Author: manik.surtani at 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 at jboss.org">manik at jboss.org</a>)
+ * @since 3.0
+ */
+ at 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;
+
+ at 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;
+
+ at 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;
+
+ at 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;
+
+ at 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;
+
+ at 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;
+
+ at Test(groups = {"functional", "mvcc"})
+public class RepeatableReadWriteSkewWithParentLockTest extends LockTestBase
+{
+ public RepeatableReadWriteSkewWithParentLockTest()
+ {
+ repeatableRead = true;
+ allowWriteSkew = true;
+ lockParentForInsertRemove = true;
+ }
+}
More information about the jbosscache-commits
mailing list