Author: manik.surtani(a)jboss.com Date: 2008-07-02 13:34:40 -0400 (Wed, 02 Jul 2008) New Revision: 6154 Removed: 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/RepeatableReadNoWriteSkewWithParentLockTest.java core/trunk/src/test/java/org/jboss/cache/api/mvcc/repeatable_read/RepeatableReadWriteSkewWithParentLockTest.java Modified: core/trunk/src/main/java/org/jboss/cache/commands/write/EvictCommand.java core/trunk/src/main/java/org/jboss/cache/interceptors/MVCCLockingInterceptor.java core/trunk/src/main/java/org/jboss/cache/mvcc/NodeReference.java core/trunk/src/main/java/org/jboss/cache/mvcc/NullMarkerNode.java core/trunk/src/main/java/org/jboss/cache/mvcc/ReadCommittedNode.java core/trunk/src/main/java/org/jboss/cache/mvcc/RepeatableReadNode.java core/trunk/src/test/java/org/jboss/cache/api/mvcc/LockTestBase.java core/trunk/src/test/java/org/jboss/cache/api/mvcc/read_committed/ReadCommittedLockTest.java core/trunk/src/test/java/org/jboss/cache/api/mvcc/repeatable_read/NodeAPIMVCCTest.java 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/RepeatableReadWriteSkewLockTest.java Log: MVCC to lock parents always Modified: core/trunk/src/main/java/org/jboss/cache/commands/write/EvictCommand.java =================================================================== --- core/trunk/src/main/java/org/jboss/cache/commands/write/EvictCommand.java 2008-07-02 13:39:16 UTC (rev 6153) +++ core/trunk/src/main/java/org/jboss/cache/commands/write/EvictCommand.java 2008-07-02 17:34:40 UTC (rev 6154) @@ -71,7 +71,7 @@ { // TODO: remove this ugly hack NodeSPI node = lookupForEviction(ctx, fqn); - if (node == null) + if (node == null || node.isDeleted()) { return false; } Modified: core/trunk/src/main/java/org/jboss/cache/interceptors/MVCCLockingInterceptor.java =================================================================== --- core/trunk/src/main/java/org/jboss/cache/interceptors/MVCCLockingInterceptor.java 2008-07-02 13:39:16 UTC (rev 6153) +++ core/trunk/src/main/java/org/jboss/cache/interceptors/MVCCLockingInterceptor.java 2008-07-02 17:34:40 UTC (rev 6154) @@ -1,5 +1,6 @@ package org.jboss.cache.interceptors; +import org.jboss.cache.CacheException; import org.jboss.cache.DataContainer; import org.jboss.cache.Fqn; import org.jboss.cache.NodeFactory; @@ -33,6 +34,7 @@ import static org.jboss.cache.lock.LockType.WRITE; import org.jboss.cache.lock.TimeoutException; import org.jboss.cache.mvcc.InternalNode; +import org.jboss.cache.mvcc.NullMarkerNode; import org.jboss.cache.mvcc.ReadCommittedNode; import java.util.ArrayList; @@ -58,7 +60,7 @@ // How will wrapper nodes unwrap? - boolean allowWriteSkew, lockParentForChildInsertRemove; + boolean allowWriteSkew; LockManager lockManager; DataContainer dataContainer; NodeFactory nodeFactory; @@ -76,7 +78,6 @@ public void start() { allowWriteSkew = configuration.isAllowWriteSkew(); - lockParentForChildInsertRemove = configuration.isLockParentForChildInsertRemove(); defaultLockAcquisitionTimeout = configuration.getLockAcquisitionTimeout(); } @@ -104,31 +105,83 @@ @Override public Object handleRemoveNodeCommand(InvocationContext ctx, RemoveNodeCommand command) throws Throwable { + addNodeAndParentForRemoval(ctx, command.getFqn(), true); + return invokeNextInterceptor(ctx, command); + } + + private List<Fqn> addNodeAndParentForRemoval(InvocationContext ctx, Fqn nodeFqn, boolean recursive) throws InterruptedException + { // when removing a node we want to get a lock on the Fqn anyway and return the wrapped node. - Fqn nodeFqn = command.getFqn(); + if (nodeFqn.isRoot()) throw new CacheException("Attempting to remove Fqn.ROOT!"); - if (!nodeFqn.isRoot()) + Fqn parentFqn = nodeFqn.getParent(); + // inspect parent + boolean needToCopyParent = lock(ctx, parentFqn); + + // Ensure the node is in the context. + putNodeInContext(ctx, parentFqn, needToCopyParent); + + boolean needToCopyNode = lock(ctx, nodeFqn); + + // Ensure the node is in the context. + putNodeInContext(ctx, nodeFqn, needToCopyNode); + + ReadCommittedNode node = (ReadCommittedNode) ctx.lookUpNode(nodeFqn); + + // update child ref on parent to point to child as this is now a copy. + if (node != null && !(node instanceof NullMarkerNode)) { - Fqn parentFqn = nodeFqn.getParent(); - // inspect parent - InternalNode parent = dataContainer.peekInternalNode(parentFqn, false); + if (needToCopyNode || needToCopyParent) { - if (lockParentForChildInsertRemove || (parent != null && parent.isLockForChildInsertRemove())) + + ReadCommittedNode parent = (ReadCommittedNode) ctx.lookUpNode(parentFqn); + parent.addChildDirect(nodeFactory.createNodeInvocationDelegate((InternalNode) node.getDelegationTarget())); + } + + // now deal with children. + if (recursive) + { + Map childMap = node.getChildrenMapDirect(); + List<Fqn> fqnsToBeRemoved = new LinkedList<Fqn>(); + fqnsToBeRemoved.add(nodeFqn); + if (childMap == null || childMap.isEmpty()) return fqnsToBeRemoved; + + for (Object n : childMap.values()) { - boolean needToCopyNode = lock(ctx, parentFqn); + NodeSPI child = (NodeSPI) n; + lockForRemoval(child.getFqn(), recursive, ctx, fqnsToBeRemoved); + } - // Ensure the node is in the context. - putNodeInContext(ctx, parentFqn, needToCopyNode); - } + return fqnsToBeRemoved; } } - boolean needToCopyNode = lock(ctx, nodeFqn); + return null; + } - // Ensure the node is in the context. - putNodeInContext(ctx, nodeFqn, needToCopyNode); + private void lockForRemoval(Fqn fqn, boolean isRecursive, InvocationContext ctx, List<Fqn> fqnList) throws InterruptedException + { + lock(ctx, fqn); // lock node + if (fqnList != null) fqnList.add(fqn); - return invokeNextInterceptor(ctx, command); + // now wrap and add to the context + ReadCommittedNode rcn = (ReadCommittedNode) getWrappedNode(ctx, fqn, true, false, true); + if (rcn != null) + { + rcn.copyNodeForUpdate(dataContainer, allowWriteSkew, ctx, nodeFactory); + + if (isRecursive) + { + Map<Object, NodeSPI> children = rcn.getChildrenMapDirect(); + if (children != null) + { + for (NodeSPI child : children.values()) + { + lockForRemoval(child.getFqn(), isRecursive, ctx, fqnList); + } + } + } + } } private void putNodeInContext(InvocationContext ctx, Fqn fqn, boolean needToCopyNode) @@ -143,7 +196,7 @@ if (needToCopyNode && node != null && !node.isChanged()) // node could be null if using read-committed { - node.copyNodeForUpdate(dataContainer, allowWriteSkew, ctx, nodeFactory, lockParentForChildInsertRemove); + node.copyNodeForUpdate(dataContainer, allowWriteSkew, ctx, nodeFactory); } } @@ -159,33 +212,8 @@ { // set lock acquisition timeout to 0 - we need to fail fast. ctx.getOptionOverrides().setLockAcquisitionTimeout(0); + List<Fqn> fqnsToEvict = addNodeAndParentForRemoval(ctx, command.getFqn(), command.isRecursive()); - // similar to remove node, except that we need to take care of the recursive case. - Fqn nodeFqn = command.getFqn(); - - if (!nodeFqn.isRoot()) - { - Fqn parentFqn = nodeFqn.getParent(); - // inspect parent - InternalNode parent = dataContainer.peekInternalNode(parentFqn, true); - { - if (lockParentForChildInsertRemove || (parent != null && parent.isLockForChildInsertRemove())) - { - // lock parent - lockManager.lockAndRecord(parentFqn, WRITE, ctx); - - // retrieve again from the dataContainer in case we have a race, and add to the context - ReadCommittedNode rcn = (ReadCommittedNode) getWrappedNode(ctx, parentFqn, true, false, false); - if (rcn != null) - rcn.copyNodeForUpdate(dataContainer, allowWriteSkew, ctx, nodeFactory, lockParentForChildInsertRemove); - } - } - } - - List<Fqn> fqnsToEvict = command.isRecursive() ? new LinkedList<Fqn>() : null; - - lockForEviction(nodeFqn, command.isRecursive(), ctx, fqnsToEvict); - if (fqnsToEvict != null) // add this set to the command { command.setNodesToEvict(fqnsToEvict); @@ -194,31 +222,6 @@ return invokeNextInterceptor(ctx, command); } - private void lockForEviction(Fqn fqn, boolean isRecursive, InvocationContext ctx, List<Fqn> fqnsToEvict) throws InterruptedException - { - lockManager.lockAndRecord(fqn, WRITE, ctx); // lock node. - if (fqnsToEvict != null) fqnsToEvict.add(fqn); - - // now wrap and add to the context - ReadCommittedNode rcn = (ReadCommittedNode) getWrappedNode(ctx, fqn, true, false, true); - if (rcn != null) - { - rcn.copyNodeForUpdate(dataContainer, allowWriteSkew, ctx, nodeFactory, lockParentForChildInsertRemove); - - if (isRecursive) - { - Map<Object, NodeSPI> children = rcn.getChildrenMapDirect(); - if (children != null) - { - for (NodeSPI child : children.values()) - { - lockForEviction(child.getFqn(), isRecursive, ctx, fqnsToEvict); - } - } - } - } - } - @Override public Object handleInvalidateCommand(InvocationContext ctx, InvalidateCommand command) throws Throwable { @@ -340,8 +343,7 @@ { // for each of these, swap refs ReadCommittedNode rcn = (ReadCommittedNode) ctx.lookUpNode(fqnsToUnlock[i]); -// rcn.copyNodeForUpdate(dataContainer, allowWriteSkew); - rcn.commitUpdate(dataContainer, nodeFactory); + if (rcn != null) rcn.commitUpdate(dataContainer, nodeFactory); // could be null with read-committed // and then unlock lockManager.unlock(fqnsToUnlock[i], owner); } @@ -462,7 +464,7 @@ if (lockForWriting && lock(context, fqn)) { // create a copy of the underlying node - n.copyNodeForUpdate(dataContainer, allowWriteSkew, context, nodeFactory, lockParentForChildInsertRemove); + n.copyNodeForUpdate(dataContainer, allowWriteSkew, context, nodeFactory); } if (trace) log.trace("Retrieving wrapped node " + fqn); return n; @@ -481,7 +483,7 @@ ReadCommittedNode wrapped = nodeFactory.createMvccNode(in); context.putLookedUpNode(fqn, wrapped); if (needToCopy) - wrapped.copyNodeForUpdate(dataContainer, allowWriteSkew, context, nodeFactory, lockParentForChildInsertRemove); + wrapped.copyNodeForUpdate(dataContainer, allowWriteSkew, context, nodeFactory); return wrapped; } @@ -491,14 +493,11 @@ Fqn parentFqn = fqn.getParent(); NodeSPI parent = getWrappedNode(context, parentFqn, false, createIfAbsent, false); // do we need to lock the parent to create children? - if (lockParentForChildInsertRemove || parent.isLockForChildInsertRemove()) + // get a lock on the parent. + if (lock(context, parentFqn)) { - // get a lock on the parent. - if (lock(context, parentFqn)) - { - ReadCommittedNode parentRCN = (ReadCommittedNode) context.lookUpNode(parentFqn); - parentRCN.copyNodeForUpdate(dataContainer, allowWriteSkew, context, nodeFactory, lockParentForChildInsertRemove); - } + ReadCommittedNode parentRCN = (ReadCommittedNode) context.lookUpNode(parentFqn); + parentRCN.copyNodeForUpdate(dataContainer, allowWriteSkew, context, nodeFactory); } // now to lock and create the node. @@ -508,7 +507,10 @@ in = (InternalNode) ((NodeInvocationDelegate) temp).getDelegationTarget(); ReadCommittedNode wrapped = nodeFactory.createMvccNode(in); context.putLookedUpNode(fqn, wrapped); - wrapped.copyNodeForUpdate(dataContainer, allowWriteSkew, context, nodeFactory, lockParentForChildInsertRemove); + wrapped.copyNodeForUpdate(dataContainer, allowWriteSkew, context, nodeFactory); + // since we copied the child make sure we update the parent's ref + parent.addChildDirect(nodeFactory.createNodeInvocationDelegate(wrapped.getNode())); + return wrapped; } Modified: core/trunk/src/main/java/org/jboss/cache/mvcc/NodeReference.java =================================================================== --- core/trunk/src/main/java/org/jboss/cache/mvcc/NodeReference.java 2008-07-02 13:39:16 UTC (rev 6153) +++ core/trunk/src/main/java/org/jboss/cache/mvcc/NodeReference.java 2008-07-02 17:34:40 UTC (rev 6154) @@ -281,4 +281,12 @@ { delegate.printDetails(sb, indent); } + + @Override + public String toString() + { + return "NodeReference{" + + "delegate=" + delegate + + '}'; + } } Modified: core/trunk/src/main/java/org/jboss/cache/mvcc/NullMarkerNode.java =================================================================== --- core/trunk/src/main/java/org/jboss/cache/mvcc/NullMarkerNode.java 2008-07-02 13:39:16 UTC (rev 6153) +++ core/trunk/src/main/java/org/jboss/cache/mvcc/NullMarkerNode.java 2008-07-02 17:34:40 UTC (rev 6154) @@ -36,7 +36,7 @@ } @Override - public void copyNodeForUpdate(DataContainer d, boolean b, InvocationContext ctx, NodeFactory nodeFactory, boolean lockParent) + public void copyNodeForUpdate(DataContainer d, boolean b, InvocationContext ctx, NodeFactory nodeFactory) { // no op } Modified: core/trunk/src/main/java/org/jboss/cache/mvcc/ReadCommittedNode.java =================================================================== --- core/trunk/src/main/java/org/jboss/cache/mvcc/ReadCommittedNode.java 2008-07-02 13:39:16 UTC (rev 6153) +++ core/trunk/src/main/java/org/jboss/cache/mvcc/ReadCommittedNode.java 2008-07-02 17:34:40 UTC (rev 6154) @@ -30,7 +30,7 @@ return false; } - public void copyNodeForUpdate(DataContainer container, boolean allowWriteSkew, InvocationContext ctx, NodeFactory nodeFactory, boolean lockParent) + public void copyNodeForUpdate(DataContainer container, boolean allowWriteSkew, InvocationContext ctx, NodeFactory nodeFactory) { changed = true; backup = node; @@ -52,16 +52,25 @@ protected void updateNode(DataContainer container, NodeFactory nf) { - // TODO: Deal with creating - what if children is null? - if (isDeleted()) { Fqn fqn = getFqn(); - NodeSPI parent = container.peek(fqn); - if (parent != null) + if (!fqn.isRoot()) { - parent.removeChildDirect(fqn.getLastElement()); + NodeSPI parent = container.peek(fqn.getParent()); + if (parent != null) + { + parent.removeChildDirect(fqn.getLastElement()); + } + else + { + if (trace) log.trace("Parent is null in the underlying cache; cannot remove."); + } } + else + { + log.warn("Attempting to remove the root node. Not doing anything!"); + } } else { @@ -86,4 +95,14 @@ { this.changed = changed; } + + public InternalNode getNode() + { + return node; + } + + public InternalNode getBackupNode() + { + return backup; + } } Modified: core/trunk/src/main/java/org/jboss/cache/mvcc/RepeatableReadNode.java =================================================================== --- core/trunk/src/main/java/org/jboss/cache/mvcc/RepeatableReadNode.java 2008-07-02 13:39:16 UTC (rev 6153) +++ core/trunk/src/main/java/org/jboss/cache/mvcc/RepeatableReadNode.java 2008-07-02 17:34:40 UTC (rev 6154) @@ -23,7 +23,7 @@ } @Override - public void copyNodeForUpdate(DataContainer container, boolean allowWriteSkew, InvocationContext ctx, NodeFactory nodeFactory, boolean lockParent) + public void copyNodeForUpdate(DataContainer container, boolean allowWriteSkew, InvocationContext ctx, NodeFactory nodeFactory) { Fqn fqn = getFqn(); @@ -48,14 +48,6 @@ // TODO: Make sure this works with custom versions as well! DataVersion newVersion = ((DefaultDataVersion) node.getVersion()).increment(); node.setVersion(newVersion); - - // if the parent is in the context make sure the parent has a ref to the copy now. - Fqn parentFqn = getFqn().getParent(); - if (!getFqn().isRoot() && (lockParent || container.peek(parentFqn) == null)) - { - NodeSPI parent = ctx.lookUpNode(parentFqn); - if (parent != null) parent.addChildDirect(nodeFactory.createNodeInvocationDelegate(node)); - } } @Override Modified: core/trunk/src/test/java/org/jboss/cache/api/mvcc/LockTestBase.java =================================================================== --- core/trunk/src/test/java/org/jboss/cache/api/mvcc/LockTestBase.java 2008-07-02 13:39:16 UTC (rev 6153) +++ core/trunk/src/test/java/org/jboss/cache/api/mvcc/LockTestBase.java 2008-07-02 17:34:40 UTC (rev 6154) @@ -41,7 +41,6 @@ protected Fqn ABCD = Fqn.fromString("/a/b/c/d"); protected LockManager lockManager; protected InvocationContextContainer icc; - protected boolean lockParentForInsertRemove = false; protected boolean repeatableRead = true; protected boolean allowWriteSkew = false; @@ -51,7 +50,6 @@ 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.getConfiguration().setAllowWriteSkew(allowWriteSkew); // reduce lock acquisition timeout so this doesn't take forever to run @@ -92,10 +90,7 @@ { tm.begin(); cache.put(AB, "k", "v"); - if (lockParentForInsertRemove) - assertLocked(Fqn.ROOT); - else - assertNotLocked(Fqn.ROOT); + assertLocked(Fqn.ROOT); assertLocked(A); assertLocked(AB); assertNotLocked(ABC); @@ -117,10 +112,7 @@ cache.put(ABC, "k", "v"); assertNotLocked(Fqn.ROOT); assertNotLocked(A); - if (lockParentForInsertRemove) - assertLocked(AB); - else - assertNotLocked(AB); + assertLocked(AB); assertLocked(ABC); tm.commit(); @@ -131,10 +123,7 @@ { tm.begin(); cache.put(AB, Collections.singletonMap("k", "v")); - if (lockParentForInsertRemove) - assertLocked(Fqn.ROOT); - else - assertNotLocked(Fqn.ROOT); + assertLocked(Fqn.ROOT); assertLocked(A); assertLocked(AB); assertNotLocked(ABC); @@ -157,10 +146,7 @@ cache.put(ABC, Collections.singletonMap("k", "v")); assertNotLocked(Fqn.ROOT); assertNotLocked(A); - if (lockParentForInsertRemove) - assertLocked(AB); - else - assertNotLocked(AB); + assertLocked(AB); assertLocked(ABC); tm.commit(); @@ -177,10 +163,7 @@ tm.begin(); cache.removeNode(AB); assertLocked(AB); - if (lockParentForInsertRemove) - assertLocked(A); - else - assertNotLocked(A); + assertLocked(A); assertNotLocked(Fqn.ROOT); tm.commit(); assert cache.getNode(AB) == null : "Should not exist"; @@ -197,10 +180,7 @@ tm.begin(); cache.evict(AB); assertLocked(AB); - if (lockParentForInsertRemove) - assertLocked(A); - else - assertNotLocked(A); + assertLocked(A); assertNotLocked(Fqn.ROOT); tm.commit(); assert cache.getNode(AB) == null : "Should not exist"; @@ -223,10 +203,7 @@ assertLocked(AB); assertLocked(ABC); assertLocked(ABCD); - if (lockParentForInsertRemove) - assertLocked(A); - else - assertNotLocked(A); + assertLocked(A); assertNotLocked(Fqn.ROOT); tm.commit(); assert cache.getNode(AB) == null : "Should not exist"; @@ -240,10 +217,7 @@ tm.begin(); cache.removeNode(AB); assertLocked(AB); - if (lockParentForInsertRemove) - assertLocked(A); - else - assertNotLocked(A); + assertLocked(A); assertNotLocked(Fqn.ROOT); tm.commit(); assert cache.getNode(AB) == null : "Should not exist"; @@ -257,10 +231,7 @@ tm.begin(); cache.evict(AB); assertLocked(AB); - if (lockParentForInsertRemove) - assertLocked(A); - else - assertNotLocked(A); + assertLocked(A); assertNotLocked(Fqn.ROOT); tm.commit(); assert cache.getNode(AB) == null : "Should not exist"; Modified: 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 2008-07-02 13:39:16 UTC (rev 6153) +++ core/trunk/src/test/java/org/jboss/cache/api/mvcc/read_committed/ReadCommittedLockTest.java 2008-07-02 17:34:40 UTC (rev 6154) @@ -9,6 +9,5 @@ public ReadCommittedLockTest() { repeatableRead = false; - lockParentForInsertRemove = false; } } Deleted: 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 2008-07-02 13:39:16 UTC (rev 6153) +++ core/trunk/src/test/java/org/jboss/cache/api/mvcc/read_committed/ReadCommittedWithParentLockTest.java 2008-07-02 17:34:40 UTC (rev 6154) @@ -1,14 +0,0 @@ -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; - } -} Modified: core/trunk/src/test/java/org/jboss/cache/api/mvcc/repeatable_read/NodeAPIMVCCTest.java =================================================================== --- core/trunk/src/test/java/org/jboss/cache/api/mvcc/repeatable_read/NodeAPIMVCCTest.java 2008-07-02 13:39:16 UTC (rev 6153) +++ core/trunk/src/test/java/org/jboss/cache/api/mvcc/repeatable_read/NodeAPIMVCCTest.java 2008-07-02 17:34:40 UTC (rev 6154) @@ -25,6 +25,7 @@ protected void configure(Configuration c) { c.setIsolationLevel(IsolationLevel.REPEATABLE_READ); + c.setLockParentForChildInsertRemove(true); } protected void assertNodeLockingScheme() Modified: 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 2008-07-02 13:39:16 UTC (rev 6153) +++ core/trunk/src/test/java/org/jboss/cache/api/mvcc/repeatable_read/RepeatableReadNoWriteSkewLockTest.java 2008-07-02 17:34:40 UTC (rev 6154) @@ -8,6 +8,5 @@ public RepeatableReadNoWriteSkewLockTest() { allowWriteSkew = false; - lockParentForInsertRemove = false; } } Deleted: 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 2008-07-02 13:39:16 UTC (rev 6153) +++ core/trunk/src/test/java/org/jboss/cache/api/mvcc/repeatable_read/RepeatableReadNoWriteSkewWithParentLockTest.java 2008-07-02 17:34:40 UTC (rev 6154) @@ -1,13 +0,0 @@ -package org.jboss.cache.api.mvcc.repeatable_read; - -import org.testng.annotations.Test; - -@Test(groups = {"functional", "mvcc"}) -public class RepeatableReadNoWriteSkewWithParentLockTest extends RepeatableReadTestBase -{ - public RepeatableReadNoWriteSkewWithParentLockTest() - { - allowWriteSkew = false; - lockParentForInsertRemove = true; - } -} Modified: 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 2008-07-02 13:39:16 UTC (rev 6153) +++ core/trunk/src/test/java/org/jboss/cache/api/mvcc/repeatable_read/RepeatableReadWriteSkewLockTest.java 2008-07-02 17:34:40 UTC (rev 6154) @@ -8,6 +8,5 @@ public RepeatableReadWriteSkewLockTest() { allowWriteSkew = true; - lockParentForInsertRemove = false; } } Deleted: 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 2008-07-02 13:39:16 UTC (rev 6153) +++ core/trunk/src/test/java/org/jboss/cache/api/mvcc/repeatable_read/RepeatableReadWriteSkewWithParentLockTest.java 2008-07-02 17:34:40 UTC (rev 6154) @@ -1,13 +0,0 @@ -package org.jboss.cache.api.mvcc.repeatable_read; - -import org.testng.annotations.Test; - -@Test(groups = {"functional", "mvcc"}) -public class RepeatableReadWriteSkewWithParentLockTest extends RepeatableReadTestBase -{ - public RepeatableReadWriteSkewWithParentLockTest() - { - allowWriteSkew = true; - lockParentForInsertRemove = true; - } -}