Return-Path: Delivered-To: apmail-openjpa-commits-archive@www.apache.org Received: (qmail 32310 invoked from network); 5 Apr 2009 21:30:12 -0000 Received: from hermes.apache.org (HELO mail.apache.org) (140.211.11.3) by minotaur.apache.org with SMTP; 5 Apr 2009 21:30:12 -0000 Received: (qmail 75541 invoked by uid 500); 5 Apr 2009 21:30:12 -0000 Delivered-To: apmail-openjpa-commits-archive@openjpa.apache.org Received: (qmail 75487 invoked by uid 500); 5 Apr 2009 21:30:12 -0000 Mailing-List: contact commits-help@openjpa.apache.org; run by ezmlm Precedence: bulk List-Help: List-Unsubscribe: List-Post: List-Id: Reply-To: dev@openjpa.apache.org Delivered-To: mailing list commits@openjpa.apache.org Received: (qmail 75478 invoked by uid 99); 5 Apr 2009 21:30:12 -0000 Received: from nike.apache.org (HELO nike.apache.org) (192.87.106.230) by apache.org (qpsmtpd/0.29) with ESMTP; Sun, 05 Apr 2009 21:30:12 +0000 X-ASF-Spam-Status: No, hits=-2000.0 required=10.0 tests=ALL_TRUSTED X-Spam-Check-By: apache.org Received: from [140.211.11.4] (HELO eris.apache.org) (140.211.11.4) by apache.org (qpsmtpd/0.29) with ESMTP; Sun, 05 Apr 2009 21:30:07 +0000 Received: by eris.apache.org (Postfix, from userid 65534) id F15F72388ACF; Sun, 5 Apr 2009 21:29:45 +0000 (UTC) Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit Subject: svn commit: r762161 [4/7] - in /openjpa/trunk: openjpa-jdbc/src/main/java/org/apache/openjpa/jdbc/kernel/ openjpa-jdbc/src/main/java/org/apache/openjpa/jdbc/sql/ openjpa-jdbc/src/main/resources/org/apache/openjpa/jdbc/kernel/ openjpa-kernel/src/main/ja... Date: Sun, 05 Apr 2009 21:29:44 -0000 To: commits@openjpa.apache.org From: allee8285@apache.org X-Mailer: svnmailer-1.0.8 Message-Id: <20090405212945.F15F72388ACF@eris.apache.org> X-Virus-Checked: Checked by ClamAV on apache.org Propchange: openjpa/trunk/openjpa-persistence-jdbc/src/test/java/org/apache/openjpa/persistence/lockmgr/TestFetchHints.java ------------------------------------------------------------------------------ svn:eol-style = native Added: openjpa/trunk/openjpa-persistence-jdbc/src/test/java/org/apache/openjpa/persistence/lockmgr/TestMixedLockManagerFindBasic.java URL: http://svn.apache.org/viewvc/openjpa/trunk/openjpa-persistence-jdbc/src/test/java/org/apache/openjpa/persistence/lockmgr/TestMixedLockManagerFindBasic.java?rev=762161&view=auto ============================================================================== --- openjpa/trunk/openjpa-persistence-jdbc/src/test/java/org/apache/openjpa/persistence/lockmgr/TestMixedLockManagerFindBasic.java (added) +++ openjpa/trunk/openjpa-persistence-jdbc/src/test/java/org/apache/openjpa/persistence/lockmgr/TestMixedLockManagerFindBasic.java Sun Apr 5 21:29:42 2009 @@ -0,0 +1,118 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, + * software distributed under the License is distributed on an + * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY + * KIND, either express or implied. See the License for the + * specific language governing permissions and limitations + * under the License. + */ +package org.apache.openjpa.persistence.lockmgr; + +import javax.persistence.LockModeType; + +/** + * Test JPA 2.0 em.find(LockMode) behaviors with "mixed" lock manager. + */ +public class TestMixedLockManagerFindBasic extends SequencedActionsTest { + public void setUp() { + setUp(LockEmployee.class + , "openjpa.LockManager", "mixed" + ); + commonSetUp(); + } + + public void testFindRead() { + testCommon("testFindRead", + LockModeType.READ, 0, 1); + } + + public void testFindWrite() { + testCommon("testFindWrite", + LockModeType.WRITE, 1, 1); + } + + public void testFindOptimistic() { + testCommon("testFindOptimistic", + LockModeType.OPTIMISTIC, 0, 1); + } + + public void testFindOptimisticForceInc() { + testCommon("testFindOptimisticForceInc", + LockModeType.OPTIMISTIC_FORCE_INCREMENT, 1, 1); + } + + public void testFindPessimisticRead() { + testCommon("testFindPessimisticRead", + LockModeType.PESSIMISTIC_READ, 0, 1); + } + + public void testFindPessimisticWrite() { + testCommon("testFindPessimisticWrite", + LockModeType.PESSIMISTIC_WRITE, 0, 1); + } + + public void testFindPessimisticForceInc() { + testCommon("testFindPessimisticForceInc", + LockModeType.PESSIMISTIC_FORCE_INCREMENT, 1, 1); + } + + public void testCommon(String testName, LockModeType lockMode, + int commitVersionIncrement, int updateCommitVersionIncrement) { + Object[][] threadMain = { + // Find entity, no transaction, no update. + { Act.CreateEm }, + { Act.Clear }, + { Act.Find, 1 }, + { Act.TestEmployee, 1, Default_FirstName}, + + // Find entity with lLock, no update and commit. + { Act.StartTx }, + { Act.Clear }, + { Act.FindWithLock, 1, lockMode }, + { Act.TestEmployee, 1, Default_FirstName}, + { Act.SaveVersion }, + { Act.CommitTx }, + { Act.Clear }, + { Act.Find, 1 }, + { Act.TestEmployee, 1, Default_FirstName, + commitVersionIncrement }, + + // Find entity with lock, update and commit. + { Act.StartTx }, + { Act.Clear }, + { Act.FindWithLock, 1, lockMode }, + { Act.SaveVersion }, + { Act.TestEmployee, 1, Default_FirstName}, + { Act.UpdateEmployee, 1, lockMode.toString() }, + { Act.CommitTx }, + { Act.Clear }, + { Act.Find, 1 }, + { Act.TestEmployee, 1, lockMode.toString(), + updateCommitVersionIncrement }, + + // Find entity with lock, update but rollback. + { Act.StartTx }, + { Act.Clear }, + { Act.FindWithLock, 1, lockMode }, + { Act.SaveVersion }, + { Act.TestEmployee, 1, lockMode.toString()}, + { Act.UpdateEmployee, 1, lockMode.toString() + " Again" }, + { Act.RollbackTx }, + { Act.Clear }, + { Act.Find, 1 }, + { Act.TestEmployee, 1, lockMode.toString(), 0 }, + }; + + launchActionSequence(testName, "LockMode=" + lockMode, threadMain); + } +} \ No newline at end of file Propchange: openjpa/trunk/openjpa-persistence-jdbc/src/test/java/org/apache/openjpa/persistence/lockmgr/TestMixedLockManagerFindBasic.java ------------------------------------------------------------------------------ svn:eol-style = native Added: openjpa/trunk/openjpa-persistence-jdbc/src/test/java/org/apache/openjpa/persistence/lockmgr/TestMixedLockManagerFindException.java URL: http://svn.apache.org/viewvc/openjpa/trunk/openjpa-persistence-jdbc/src/test/java/org/apache/openjpa/persistence/lockmgr/TestMixedLockManagerFindException.java?rev=762161&view=auto ============================================================================== --- openjpa/trunk/openjpa-persistence-jdbc/src/test/java/org/apache/openjpa/persistence/lockmgr/TestMixedLockManagerFindException.java (added) +++ openjpa/trunk/openjpa-persistence-jdbc/src/test/java/org/apache/openjpa/persistence/lockmgr/TestMixedLockManagerFindException.java Sun Apr 5 21:29:42 2009 @@ -0,0 +1,259 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, + * software distributed under the License is distributed on an + * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY + * KIND, either express or implied. See the License for the + * specific language governing permissions and limitations + * under the License. + */ +package org.apache.openjpa.persistence.lockmgr; + +import javax.persistence.EntityNotFoundException; +import javax.persistence.LockModeType; +import javax.persistence.OptimisticLockException; +import javax.persistence.TransactionRequiredException; + +/** + * Test JPA 2.0 em.find(LockMode) exception behaviors with "mixed" lock manager. + */ +public class TestMixedLockManagerFindException extends SequencedActionsTest { + public void setUp() { + setUp(LockEmployee.class + , "openjpa.LockManager", "mixed" + ); + commonSetUp(); + } + + /** + * TransactionRequiredException if there is no transaction + */ + public void testFindTxReqExceptions() { + Object[][] threadMainTxReqTest = { + {Act.CreateEm}, + {Act.Find}, + {Act.SaveVersion}, + {Act.TestEmployee, 1, Default_FirstName}, + + {Act.FindWithLock, 1, LockModeType.NONE }, + {Act.TestException}, + + {Act.FindWithLock, 1, LockModeType.READ }, + {Act.TestException, 0, TransactionRequiredException.class }, + + {Act.FindWithLock, 1, LockModeType.WRITE }, + {Act.TestException, 0, TransactionRequiredException.class }, + + {Act.FindWithLock, 1, LockModeType.OPTIMISTIC }, + {Act.TestException, 0, TransactionRequiredException.class }, + + {Act.FindWithLock, 1, LockModeType.OPTIMISTIC_FORCE_INCREMENT }, + {Act.TestException, 0, TransactionRequiredException.class }, + + {Act.FindWithLock, 1, LockModeType.PESSIMISTIC_READ}, + {Act.TestException, 0, TransactionRequiredException.class }, + + {Act.FindWithLock, 1, LockModeType.PESSIMISTIC_WRITE}, + {Act.TestException, 0, TransactionRequiredException.class }, + + {Act.FindWithLock, 1, LockModeType.PESSIMISTIC_FORCE_INCREMENT }, + {Act.TestException, 0, TransactionRequiredException.class }, + }; + launchActionSequence("testLockTxReqExceptions()", + null, threadMainTxReqTest); + } + + /* + * IllegalArgumentException if the instance is not an entity or is a + * detached entity + */ + public void testFindIllegalArgrumentExceptions() { + // Test invalid entity argument throws IllegalArgumentException. + Object[][] threadMainInvEntityIllegalArgTest = { + {Act.CreateEm}, + {Act.Find}, + {Act.SaveVersion}, + {Act.TestEmployee, 1, Default_FirstName}, + {Act.StartTx}, + + {Act.FindObject, null, 0, LockModeType.NONE }, + {Act.TestException, 0, IllegalArgumentException.class }, + {Act.FindObject, Object.class, 0, LockModeType.NONE }, + {Act.TestException, 0, IllegalArgumentException.class }, + {Act.FindObject, LockEmployee.class, null, LockModeType.NONE }, + {Act.TestException, 0, EntityNotFoundException.class }, + {Act.FindObject, LockEmployee.class, Boolean.TRUE, + LockModeType.NONE }, + {Act.TestException, 0, IllegalArgumentException.class }, + + {Act.FindObject, null, 0, LockModeType.READ }, + {Act.TestException, 0, IllegalArgumentException.class }, + {Act.FindObject, Object.class, 0, LockModeType.READ }, + {Act.TestException, 0, IllegalArgumentException.class }, + {Act.FindObject, LockEmployee.class, null, LockModeType.READ }, + {Act.TestException, 0, EntityNotFoundException.class }, + {Act.FindObject, LockEmployee.class, Boolean.TRUE, + LockModeType.READ }, + {Act.TestException, 0, IllegalArgumentException.class }, + + {Act.FindObject, null, 0, LockModeType.WRITE }, + {Act.TestException, 0, IllegalArgumentException.class }, + {Act.FindObject, Object.class, 0, LockModeType.WRITE }, + {Act.TestException, 0, IllegalArgumentException.class }, + {Act.FindObject, LockEmployee.class, null, LockModeType.WRITE }, + {Act.TestException, 0, EntityNotFoundException.class }, + {Act.FindObject, LockEmployee.class, Boolean.TRUE, + LockModeType.WRITE }, + {Act.TestException, 0, IllegalArgumentException.class }, + + {Act.FindObject, null, 0, LockModeType.OPTIMISTIC }, + {Act.TestException, 0, IllegalArgumentException.class }, + {Act.FindObject, Object.class, 0, LockModeType.OPTIMISTIC }, + {Act.TestException, 0, IllegalArgumentException.class }, + {Act.FindObject, LockEmployee.class, null, + LockModeType.OPTIMISTIC }, + {Act.TestException, 0, EntityNotFoundException.class }, + {Act.FindObject, LockEmployee.class, Boolean.TRUE, + LockModeType.OPTIMISTIC }, + {Act.TestException, 0, IllegalArgumentException.class }, + + {Act.FindObject, null, 0, + LockModeType.OPTIMISTIC_FORCE_INCREMENT }, + {Act.TestException, 0, IllegalArgumentException.class }, + {Act.FindObject, Object.class, 0, + LockModeType.OPTIMISTIC_FORCE_INCREMENT }, + {Act.TestException, 0, IllegalArgumentException.class }, + {Act.FindObject, LockEmployee.class, null, + LockModeType.OPTIMISTIC_FORCE_INCREMENT }, + {Act.TestException, 0, EntityNotFoundException.class }, + {Act.FindObject, LockEmployee.class, Boolean.TRUE, + LockModeType.OPTIMISTIC_FORCE_INCREMENT }, + {Act.TestException, 0, IllegalArgumentException.class }, + + {Act.FindObject, null, 0, + LockModeType.PESSIMISTIC_READ }, + {Act.TestException, 0, IllegalArgumentException.class }, + {Act.FindObject, Object.class, 0, + LockModeType.PESSIMISTIC_READ }, + {Act.TestException, 0, IllegalArgumentException.class }, + {Act.FindObject, LockEmployee.class, null, + LockModeType.PESSIMISTIC_READ }, + {Act.TestException, 0, EntityNotFoundException.class }, + {Act.FindObject, LockEmployee.class, Boolean.TRUE, + LockModeType.PESSIMISTIC_READ }, + {Act.TestException, 0, IllegalArgumentException.class }, + + {Act.FindObject, null, 0, + LockModeType.PESSIMISTIC_WRITE }, + {Act.TestException, 0, + IllegalArgumentException.class }, + {Act.FindObject, Object.class, 0, + LockModeType.PESSIMISTIC_WRITE }, + {Act.TestException, 0, + IllegalArgumentException.class }, + {Act.FindObject, LockEmployee.class, null, + LockModeType.PESSIMISTIC_WRITE }, + {Act.TestException, 0, + EntityNotFoundException.class }, + {Act.FindObject, LockEmployee.class, Boolean.TRUE, + LockModeType.PESSIMISTIC_WRITE }, + {Act.TestException, 0, IllegalArgumentException.class }, + + {Act.FindObject, null, 0, + LockModeType.PESSIMISTIC_FORCE_INCREMENT }, + {Act.TestException, 0, + IllegalArgumentException.class }, + {Act.FindObject, Object.class, 0, + LockModeType.PESSIMISTIC_FORCE_INCREMENT }, + {Act.TestException, 0, + IllegalArgumentException.class }, + {Act.FindObject, LockEmployee.class, null, + LockModeType.PESSIMISTIC_FORCE_INCREMENT }, + {Act.TestException, 0, EntityNotFoundException.class }, + {Act.FindObject, LockEmployee.class, Boolean.TRUE, + LockModeType.PESSIMISTIC_FORCE_INCREMENT }, + {Act.TestException, 0, IllegalArgumentException.class }, + }; + launchActionSequence("testLockIllegalArgrumentExceptions()", + "Test invalid entity.", threadMainInvEntityIllegalArgTest); + } + + /* + * If a pessimistic lock mode type is specified and the entity + * contains a version attribute, the persistence provider must + * also perform optimistic version checks when obtaining the + * database lock. If these checks fail, the + * OptimisticLockException will be thrown. + */ + public void testLockOptimisticLockExceptions() { + commonLockOptimisticLockExceptions( + LockModeType.NONE, true, false); + commonLockOptimisticLockExceptions( + LockModeType.READ, true, false); + commonLockOptimisticLockExceptions( + LockModeType.WRITE, true, false); + commonLockOptimisticLockExceptions( + LockModeType.OPTIMISTIC, true, false); + commonLockOptimisticLockExceptions( + LockModeType.OPTIMISTIC_FORCE_INCREMENT, true, false); + commonLockOptimisticLockExceptions( + LockModeType.PESSIMISTIC_READ, false, true); + commonLockOptimisticLockExceptions( + LockModeType.PESSIMISTIC_WRITE, false, true); + commonLockOptimisticLockExceptions( + LockModeType.PESSIMISTIC_FORCE_INCREMENT, false, true); + } + + public void commonLockOptimisticLockExceptions(LockModeType lockMode, + boolean expectingOptLockException1, + boolean expectingOptLockException2) { + Object[][] threadMainOptLockExTest = { + {Act.CreateEm}, + {Act.Find}, + {Act.SaveVersion}, + {Act.TestEmployee, 1, Default_FirstName}, + {Act.Clear}, + + {Act.NewThread, 1 }, + {Act.StartThread, 1 }, + {Act.Wait}, + + {Act.StartTx}, + {Act.FindWithLock, 1, lockMode}, + {Act.UpdateEmployee}, + {Act.Notify, 1}, + {Act.Wait}, + {Act.CommitTx}, + + {Act.WaitAllChildren}, + {Act.TestException, 0, expectingOptLockException1 + ? OptimisticLockException.class : null}, + {Act.TestException, 1, expectingOptLockException2 + ? OptimisticLockException.class : null}, + }; + Object[][] thread1OptLockExTest = { + {Act.CreateEm}, + {Act.StartTx}, + {Act.FindWithLock, 1, LockModeType.OPTIMISTIC}, + {Act.SaveVersion}, + {Act.UpdateEmployee}, + + {Act.Notify, 0}, + {Act.Wait}, + + {Act.CommitTx}, + {Act.Notify, 0}, + }; + launchActionSequence("testLockOptimisticLockExceptions()", null, + threadMainOptLockExTest, thread1OptLockExTest); + } +} \ No newline at end of file Propchange: openjpa/trunk/openjpa-persistence-jdbc/src/test/java/org/apache/openjpa/persistence/lockmgr/TestMixedLockManagerFindException.java ------------------------------------------------------------------------------ svn:eol-style = native Added: openjpa/trunk/openjpa-persistence-jdbc/src/test/java/org/apache/openjpa/persistence/lockmgr/TestMixedLockManagerFindPermutation.java URL: http://svn.apache.org/viewvc/openjpa/trunk/openjpa-persistence-jdbc/src/test/java/org/apache/openjpa/persistence/lockmgr/TestMixedLockManagerFindPermutation.java?rev=762161&view=auto ============================================================================== --- openjpa/trunk/openjpa-persistence-jdbc/src/test/java/org/apache/openjpa/persistence/lockmgr/TestMixedLockManagerFindPermutation.java (added) +++ openjpa/trunk/openjpa-persistence-jdbc/src/test/java/org/apache/openjpa/persistence/lockmgr/TestMixedLockManagerFindPermutation.java Sun Apr 5 21:29:42 2009 @@ -0,0 +1,384 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, + * software distributed under the License is distributed on an + * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY + * KIND, either express or implied. See the License for the + * specific language governing permissions and limitations + * under the License. + */ +package org.apache.openjpa.persistence.lockmgr; + +import java.util.Arrays; + +import javax.persistence.LockModeType; + +/** + * Test JPA 2.0 LockMode type permutation behaviors with "mixed" lock manager. + */ +public class TestMixedLockManagerFindPermutation extends SequencedActionsTest { + public void setUp() { + setUp(LockEmployee.class + , "openjpa.LockManager", "mixed" + ); + commonSetUp(); + } + + /* ======== Thread 1 : Read Lock ============*/ + public void testFindReadRead() { + commonFindTest( + "testFind(Read,Commit/Read,Commit)", + LockModeType.READ, Act.CommitTx, 1, null, + LockModeType.READ, Act.CommitTx, 0, ExpectingOptimisticLockExClass); + commonFindTest( + "testFind(Read,Commit/Read,Rollback)", + LockModeType.READ, Act.CommitTx, 1, null, + LockModeType.READ, Act.RollbackTx, 1, null); + } + + public void testFindReadWrite() { + commonFindTest( + "testFind(Read,Commit/Write,Commit)", + LockModeType.READ, Act.CommitTx, 1, null, + LockModeType.WRITE, Act.CommitTx, 0, + ExpectingOptimisticLockExClass); + commonFindTest( + "testFind(Read,Commit/Write,Rollback)", + LockModeType.READ, Act.CommitTx, 1, null, + LockModeType.WRITE, Act.RollbackTx, 1, null); + } + + public void testFindReadPessimisticRead() { + commonFindTest( + "testFind(Read,Commit/PessimisticRead,Commit)", + LockModeType.READ, Act.CommitTx, 1, null, + LockModeType.PESSIMISTIC_READ, Act.CommitTx, 0, null); + commonFindTest( + "testFind(Read,Commit/PessimisticRead,Rollback)", + LockModeType.READ, Act.CommitTx, 1, null, + LockModeType.PESSIMISTIC_READ, Act.RollbackTx, 1, null); + } + + public void testFindReadPessimisticWrite() { + commonFindTest( + "testFind(Read,Commit/PessimisticWrite,Commit)", + LockModeType.READ, Act.CommitTx, 1, null, + LockModeType.PESSIMISTIC_WRITE, Act.CommitTx, 0, null); + commonFindTest( + "testFind(Read,Commit/PessimisticWrite,Rollback)", + LockModeType.READ, Act.CommitTx, 1, null, + LockModeType.PESSIMISTIC_WRITE, Act.RollbackTx, 1, null); + } + + public void testFindReadPessimisticForceInc() { + commonFindTest( + "testFind(Read,Commit/PessimisticForceInc,Commit)", + LockModeType.READ, Act.CommitTx, 1, ExpectingOptimisticLockExClass, + LockModeType.PESSIMISTIC_FORCE_INCREMENT, Act.CommitTx, 1, null); + commonFindTest( + "testFind(Read,Commit/PessimisticForceInc,Rollback)", + LockModeType.READ, Act.CommitTx, 1, null, + LockModeType.PESSIMISTIC_FORCE_INCREMENT, Act.RollbackTx, 1, null); + } + + /* ======== Thread 1 : Write Lock ============*/ + public void testFindWriteRead() { + commonFindTest( + "testFind(Write,Commit/Read,Commit)", + LockModeType.WRITE, Act.CommitTx, 1, null, + LockModeType.READ, Act.CommitTx, 0, ExpectingOptimisticLockExClass); + commonFindTest( + "testFind(Write,Commit/Read,Rollback)", + LockModeType.WRITE, Act.CommitTx, 1, null, + LockModeType.READ, Act.RollbackTx, 1, null); + } + + public void testFindWriteWrite() { + commonFindTest( + "testFind(Write,Commit/Write,Commit)", + LockModeType.WRITE, Act.CommitTx, 1, null, + LockModeType.WRITE, Act.CommitTx, 0, + ExpectingOptimisticLockExClass); + commonFindTest( + "testFind(Write,Commit/Write,Rollback)", + LockModeType.WRITE, Act.CommitTx, 1, null, + LockModeType.WRITE, Act.RollbackTx, 1, null); + } + + public void testFindWritePessimisticRead() { + commonFindTest( + "testFind(Write,Commit/PessimisticRead,Commit)", + LockModeType.WRITE, Act.CommitTx, 1, null, + LockModeType.PESSIMISTIC_READ, Act.CommitTx, 0, null); + commonFindTest( + "testFind(Write,Commit/PessimisticRead,Rollback)", + LockModeType.WRITE, Act.CommitTx, 1, null, + LockModeType.PESSIMISTIC_READ, Act.RollbackTx, 1, null); + } + + public void testFindWritePessimisticWrite() { + commonFindTest( + "testFind(Write,Commit/PessimisticWrite,Commit)", + LockModeType.WRITE, Act.CommitTx, 1, null, + LockModeType.PESSIMISTIC_WRITE, Act.CommitTx, 0, null); + commonFindTest( + "testFind(Write,Commit/PessimisticWrite,Rollback)", + LockModeType.WRITE, Act.CommitTx, 1, null, + LockModeType.PESSIMISTIC_WRITE, Act.RollbackTx, 1, null); + } + + public void testFindWritePessimisticForceInc() { + commonFindTest( + "testFind(Write,Commit/PessimisticForceInc,Commit)", + LockModeType.WRITE, Act.CommitTx, 1, ExpectingOptimisticLockExClass, + LockModeType.PESSIMISTIC_FORCE_INCREMENT, Act.CommitTx, 1, null); + commonFindTest( + "testFind(Write,Commit/PessimisticForceInc,Rollback)", + LockModeType.WRITE, Act.CommitTx, 1, null, + LockModeType.PESSIMISTIC_FORCE_INCREMENT, Act.RollbackTx, 1, null); + } + + /* ======== Thread 1 : PessimisticRead Lock ============*/ + public void testFindPessimisticReadRead() { + commonFindTest( + "testFind(PessimisticRead,Commit/Read,Commit)", + LockModeType.PESSIMISTIC_READ, Act.CommitTx, 1, null, + LockModeType.READ, Act.CommitTx, 0, ExpectingOptimisticLockExClass); + commonFindTest( + "testFind(PessimisticRead,Commit/Read,Rollback)", + LockModeType.PESSIMISTIC_READ, Act.CommitTx, 1, null, + LockModeType.READ, Act.RollbackTx, 1, null); + } + + public void testFindPessimisticReadWrite() { + commonFindTest( + "testFind(PessimisticRead,Commit/Write,Commit)", + LockModeType.PESSIMISTIC_READ, Act.CommitTx, 1, null, + LockModeType.WRITE, Act.CommitTx, 0, + ExpectingOptimisticLockExClass); + commonFindTest( + "testFind(PessimisticRead,Commit/Write,Rollback)", + LockModeType.PESSIMISTIC_READ, Act.CommitTx, 1, null, + LockModeType.WRITE, Act.RollbackTx, 1, null); + } + + public void testFindPessimisticReadPessimisticRead() { + commonFindTest( + "testFind(PessimisticRead,Commit/PessimisticRead,Commit)", + LockModeType.PESSIMISTIC_READ, Act.CommitTx, 1, null, + LockModeType.PESSIMISTIC_READ, Act.CommitTx, 0, null); +// ExpectingOptimisticLockExClass); + commonFindTest( + "testFind(PessimisticRead,Commit/PessimisticRead,Rollback)", + LockModeType.PESSIMISTIC_READ, Act.CommitTx, 1, null, + LockModeType.PESSIMISTIC_READ, Act.RollbackTx, 0, null); +// ExpectingOptimisticLockExClass); + } + + public void testFindPessimisticReadPessimisticWrite() { + commonFindTest( + "testFind(PessimisticRead,Commit/PessimisticWrite,Commit)", + LockModeType.PESSIMISTIC_READ, Act.CommitTx, 1, null, + LockModeType.PESSIMISTIC_WRITE, Act.CommitTx, 0, null); + commonFindTest( + "testFind(PessimisticRead,Commit/PessimisticWrite,Rollback)", + LockModeType.PESSIMISTIC_READ, Act.CommitTx, 1, null, + LockModeType.PESSIMISTIC_WRITE, Act.RollbackTx, 0, null); + } + + public void testFindPessimisticReadPessimisticForceInc() { + commonFindTest( + "testFind(PessimisticRead,Commit/PessimisticForceInc,Commit)", + LockModeType.PESSIMISTIC_READ, Act.CommitTx, 1, null, + LockModeType.PESSIMISTIC_FORCE_INCREMENT, Act.CommitTx, 1, null); + commonFindTest( + "testFind(PessimisticRead,Commit/PessimisticForceInc,Rollback)", + LockModeType.PESSIMISTIC_READ, Act.CommitTx, 1, null, + LockModeType.PESSIMISTIC_FORCE_INCREMENT, Act.RollbackTx, 0, null); + } + + /* ======== Thread 1 : Pessimsitic Write Lock ============*/ + public void testFindPessimsiticWriteRead() { + commonFindTest( + "testFind(PessimsiticWrite,Commit/Read,Commit)", + LockModeType.PESSIMISTIC_WRITE, Act.CommitTx, 1, null, + LockModeType.READ, Act.CommitTx, 0, ExpectingOptimisticLockExClass); + commonFindTest( + "testFind(PessimsiticWrite,Commit/Read,Rollback)", + LockModeType.PESSIMISTIC_WRITE, Act.CommitTx, 1, null, + LockModeType.READ, Act.RollbackTx, 1, null); + } + + public void testFindPessimsiticWriteWrite() { + commonFindTest( + "testFind(PessimsiticWrite,Commit/Write,Commit)", + LockModeType.PESSIMISTIC_WRITE, Act.CommitTx, 1, null, + LockModeType.WRITE, Act.CommitTx, 0, + ExpectingOptimisticLockExClass); + commonFindTest( + "testFind(PessimsiticWrite,Commit/Write,Rollback)", + LockModeType.PESSIMISTIC_WRITE, Act.CommitTx, 1, null, + LockModeType.WRITE, Act.RollbackTx, 1, null); + } + + public void testFindPessimsiticWritePessimisticRead() { + commonFindTest( + "testFind(PessimsiticWrite,Commit/PessimisticRead,Commit)", + LockModeType.PESSIMISTIC_WRITE, Act.CommitTx, 1, null, + LockModeType.PESSIMISTIC_READ, Act.CommitTx, 0, null); + commonFindTest( + "testFind(PessimsiticWrite,Commit/PessimisticRead,Rollback)", + LockModeType.PESSIMISTIC_WRITE, Act.CommitTx, 1, null, + LockModeType.PESSIMISTIC_READ, Act.RollbackTx, 0, null); + } + + public void testFindPessimsiticWritePessimisticWrite() { + commonFindTest( + "testFind(PessimsiticWrite,Commit/PessimisticWrite,Commit)", + LockModeType.PESSIMISTIC_WRITE, Act.CommitTx, 1, null, + LockModeType.PESSIMISTIC_WRITE, Act.CommitTx, 0, null); + commonFindTest( + "testFind(PessimsiticWrite,Commit/PessimisticWrite,Rollback)", + LockModeType.PESSIMISTIC_WRITE, Act.CommitTx, 1, null, + LockModeType.PESSIMISTIC_WRITE, Act.RollbackTx, 0, null); + } + + public void testFindPessimsiticWritePessimisticForceInc() { + commonFindTest( + "testFind(PessimsiticWrite,Commit/PessimisticForceInc,Commit)", + LockModeType.PESSIMISTIC_WRITE, Act.CommitTx, 1, null, + LockModeType.PESSIMISTIC_FORCE_INCREMENT, Act.CommitTx, 1, null); + commonFindTest( + "testFind(PessimsiticWrite,Commit/PessimisticForceInc,Rollback)", + LockModeType.PESSIMISTIC_WRITE, Act.CommitTx, 1, null, + LockModeType.PESSIMISTIC_FORCE_INCREMENT, Act.RollbackTx, 0, null); + } + + /* ======== Thread 1 : Pessimsitic Force Increment Lock ============*/ + public void testFindPessimsiticForceIncRead() { + commonFindTest( + "testFind(PessimsiticForceInc,Commit/Read,Commit)", + LockModeType.PESSIMISTIC_FORCE_INCREMENT, Act.CommitTx, 1, null, + LockModeType.READ, Act.CommitTx, 0, ExpectingOptimisticLockExClass); + commonFindTest( + "testFind(PessimsiticForceInc,Commit/Read,Rollback)", + LockModeType.PESSIMISTIC_FORCE_INCREMENT, Act.CommitTx, 1, null, + LockModeType.READ, Act.RollbackTx, 1, null); + } + + public void testFindPessimsiticForceIncWrite() { + commonFindTest( + "testFind(PessimsiticForceInc,Commit/Write,Commit)", + LockModeType.PESSIMISTIC_FORCE_INCREMENT, Act.CommitTx, 1, null, + LockModeType.WRITE, Act.CommitTx, 0, + ExpectingOptimisticLockExClass); + commonFindTest( + "testFind(PessimsiticForceInc,Commit/Write,Rollback)", + LockModeType.PESSIMISTIC_FORCE_INCREMENT, Act.CommitTx, 1, null, + LockModeType.WRITE, Act.RollbackTx, 1, null); + } + + public void testFindPessimsiticForceIncPessimisticRead() { + commonFindTest( + "testFind(PessimsiticForceInc,Commit/PessimisticRead,Commit)", + LockModeType.PESSIMISTIC_FORCE_INCREMENT, Act.CommitTx, 1, null, + LockModeType.PESSIMISTIC_READ, Act.CommitTx, 0, null); + commonFindTest( + "testFind(PessimsiticForceInc,Commit/PessimisticRead,Rollback)", + LockModeType.PESSIMISTIC_FORCE_INCREMENT, Act.CommitTx, 1, null, + LockModeType.PESSIMISTIC_READ, Act.RollbackTx, 0, null); + } + + public void testFindPessimsiticForceIncPessimisticWrite() { + commonFindTest( + "testFind(PessimsiticForceInc,Commit/PessimisticWrite,Commit)", + LockModeType.PESSIMISTIC_FORCE_INCREMENT, Act.CommitTx, 1, null, + LockModeType.PESSIMISTIC_WRITE, Act.CommitTx, 0, null); + commonFindTest( + "testFind(PessimsiticForceInc,Commit/PessimisticWrite,Rollback)", + LockModeType.PESSIMISTIC_FORCE_INCREMENT, Act.CommitTx, 1, null, + LockModeType.PESSIMISTIC_WRITE, Act.RollbackTx, 0, null); + } + + public void testFindPessimsiticForceIncPessimisticForceInc() { + commonFindTest( + "testFind(PessimsiticForceInc,Commit/PessimisticForceInc,Commit)", + LockModeType.PESSIMISTIC_FORCE_INCREMENT, Act.CommitTx, 1, null, + LockModeType.PESSIMISTIC_FORCE_INCREMENT, Act.CommitTx, 1, null); + commonFindTest( + "testFind(PessimsiticForceInc,Commit/PessimisticForceInc,Rollback)", + LockModeType.PESSIMISTIC_FORCE_INCREMENT, Act.CommitTx, 1, null, + LockModeType.PESSIMISTIC_FORCE_INCREMENT, Act.RollbackTx, 0, null); + } + + private void commonFindTest( String testName, + LockModeType t1Lock, Act t1IsCommit, int t1VersionInc, + Class[] t1Exceptions, + LockModeType t2Lock, Act t2IsCommit, int t2VersionInc, + Class[] t2Exceptions ) { + String[] parameters = new String[] { + "Thread 1: lock= " + t1Lock + ", isCommit= " + t1IsCommit + + ", versionInc= +" + t1VersionInc + + ", expectedEx= " + Arrays.toString(t1Exceptions), + "Thread 2: lock= " + t2Lock + ", isCommit= " + t2IsCommit + + ", versionInc= +" + t2VersionInc + + ", expectedEx= " + Arrays.toString(t2Exceptions)}; + + Object[][] threadMain = { + {Act.CreateEm}, + {Act.Find}, + {Act.SaveVersion}, + {Act.TestEmployee, 1, Default_FirstName}, + + {Act.NewThread, 1 }, + {Act.NewThread, 2 }, + {Act.StartThread, 1 }, + {Act.Wait}, + {Act.StartThread, 2 }, + {Act.Notify, 1, 1000 }, + {Act.Notify, 2, 1000 }, + {Act.WaitAllChildren}, + {Act.Find}, + {Act.TestEmployee, 1}, + {Act.TestException, 1, t1Exceptions }, + {Act.TestException, 2, t2Exceptions }, + }; + Object[][] thread1 = { + {Act.CreateEm}, + {Act.StartTx}, + {Act.FindWithLock, 1, t1Lock}, + {Act.SaveVersion}, + {Act.TestException}, + {Act.Notify, 0}, + {Act.Wait}, + {Act.UpdateEmployee}, + + {t1IsCommit}, + {Act.Find}, + {Act.TestEmployee, 1, null, t1VersionInc} + }; + Object[][] thread2 = { + {Act.CreateEm}, + {Act.StartTx}, + {Act.FindWithLock, 1, t2Lock}, + {Act.SaveVersion}, + {Act.Notify, 0}, + {Act.Wait}, + + {t2IsCommit}, + {Act.Find}, + {Act.TestEmployee, 1, null, t2VersionInc} + }; + launchActionSequence(testName, parameters, threadMain, thread1, + thread2); + } +} Propchange: openjpa/trunk/openjpa-persistence-jdbc/src/test/java/org/apache/openjpa/persistence/lockmgr/TestMixedLockManagerFindPermutation.java ------------------------------------------------------------------------------ svn:eol-style = native Added: openjpa/trunk/openjpa-persistence-jdbc/src/test/java/org/apache/openjpa/persistence/lockmgr/TestMixedLockManagerLockBasic.java URL: http://svn.apache.org/viewvc/openjpa/trunk/openjpa-persistence-jdbc/src/test/java/org/apache/openjpa/persistence/lockmgr/TestMixedLockManagerLockBasic.java?rev=762161&view=auto ============================================================================== --- openjpa/trunk/openjpa-persistence-jdbc/src/test/java/org/apache/openjpa/persistence/lockmgr/TestMixedLockManagerLockBasic.java (added) +++ openjpa/trunk/openjpa-persistence-jdbc/src/test/java/org/apache/openjpa/persistence/lockmgr/TestMixedLockManagerLockBasic.java Sun Apr 5 21:29:42 2009 @@ -0,0 +1,115 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, + * software distributed under the License is distributed on an + * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY + * KIND, either express or implied. See the License for the + * specific language governing permissions and limitations + * under the License. + */ +package org.apache.openjpa.persistence.lockmgr; + +import javax.persistence.LockModeType; + +/** + * Test JPA 2.0 em.lock(LockMode) basic behaviors with "mixed" lock manager. + */ +public class TestMixedLockManagerLockBasic extends SequencedActionsTest { + public void setUp() { + setUp(LockEmployee.class + , "openjpa.LockManager", "mixed" + ); + commonSetUp(); + } + + public void testLockRead() { + testCommon("testLockRead", + LockModeType.READ, 0, 1); + } + + public void testLockWrite() { + testCommon("testLockWrite", + LockModeType.WRITE, 1, 1); + } + + public void testLockOptimistic() { + testCommon("testLockOptimistic", + LockModeType.OPTIMISTIC, 0, 1); + } + + public void testLockOptimisticForceInc() { + testCommon("testLockOptimisticForceInc", + LockModeType.OPTIMISTIC_FORCE_INCREMENT, 1, 1); + } + + public void testLockPessimisticRead() { + testCommon("testLockPessimisticRead", + LockModeType.PESSIMISTIC_READ, 0, 1); + } + + public void testLockPessimisticWrite() { + testCommon("testLockPessimisticWrite", + LockModeType.PESSIMISTIC_WRITE, 0, 1); + } + + public void testLockPessimisticForceInc() { + testCommon("testLockPessimisticForceInc", + LockModeType.PESSIMISTIC_FORCE_INCREMENT, 1, 1); + } + + public void testCommon(String testName, LockModeType lockMode, + int commitVersionIncrement, int updateCommitVersionIncrement) { + Object[][] threadMain = { + // Find entity, lock, no update and commit. + { Act.CreateEm }, + { Act.StartTx }, + { Act.Clear }, + { Act.Find, 1 }, + { Act.TestEmployee, 1, Default_FirstName}, + { Act.SaveVersion }, + { Act.Lock, 1, lockMode }, + { Act.CommitTx }, + { Act.Clear }, + { Act.Find, 1 }, + { Act.TestEmployee, 1, Default_FirstName, + commitVersionIncrement }, + + // Find entity, lock, update and commit. + { Act.StartTx }, + { Act.Clear }, + { Act.Find, 1 }, + { Act.TestEmployee, 1, Default_FirstName}, + { Act.SaveVersion }, + { Act.Lock, 1, lockMode }, + { Act.UpdateEmployee, 1, lockMode.toString() }, + { Act.CommitTx }, + { Act.Clear }, + { Act.Find, 1 }, + { Act.TestEmployee, 1, lockMode.toString(), + updateCommitVersionIncrement }, + + // Find entity, lock, update but rollback. + { Act.StartTx }, + { Act.Clear }, + { Act.Find, 1 }, + { Act.TestEmployee, 1, lockMode.toString()}, + { Act.SaveVersion }, + { Act.Lock, 1, lockMode }, + { Act.UpdateEmployee, 1, lockMode.toString() + " Again" }, + { Act.RollbackTx }, + { Act.Clear }, + { Act.Find, 1 }, + { Act.TestEmployee, 1, lockMode.toString(), 0 }, + }; + launchActionSequence(testName, "LockMode=" + lockMode, threadMain); + } +} Propchange: openjpa/trunk/openjpa-persistence-jdbc/src/test/java/org/apache/openjpa/persistence/lockmgr/TestMixedLockManagerLockBasic.java ------------------------------------------------------------------------------ svn:eol-style = native Added: openjpa/trunk/openjpa-persistence-jdbc/src/test/java/org/apache/openjpa/persistence/lockmgr/TestMixedLockManagerLockException.java URL: http://svn.apache.org/viewvc/openjpa/trunk/openjpa-persistence-jdbc/src/test/java/org/apache/openjpa/persistence/lockmgr/TestMixedLockManagerLockException.java?rev=762161&view=auto ============================================================================== --- openjpa/trunk/openjpa-persistence-jdbc/src/test/java/org/apache/openjpa/persistence/lockmgr/TestMixedLockManagerLockException.java (added) +++ openjpa/trunk/openjpa-persistence-jdbc/src/test/java/org/apache/openjpa/persistence/lockmgr/TestMixedLockManagerLockException.java Sun Apr 5 21:29:42 2009 @@ -0,0 +1,316 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, + * software distributed under the License is distributed on an + * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY + * KIND, either express or implied. See the License for the + * specific language governing permissions and limitations + * under the License. + */ +package org.apache.openjpa.persistence.lockmgr; + +import javax.persistence.LockModeType; +import javax.persistence.OptimisticLockException; +import javax.persistence.TransactionRequiredException; + +/** + * Test JPA 2.0 em.lock(LockMode) exception behaviors with "mixed" lock manager. + */ +public class TestMixedLockManagerLockException extends SequencedActionsTest { + public void setUp() { + setUp(LockEmployee.class + , "openjpa.LockManager", "mixed" + ); + commonSetUp(); + } + + /** + * TransactionRequiredException if there is no transaction + */ + public void testLockTxReqExceptions() { + Object[][] threadMainTxReqTest = { + {Act.CreateEm}, + {Act.Find}, + {Act.SaveVersion}, + {Act.TestEmployee, 1, Default_FirstName}, + + {Act.Lock, 1, LockModeType.NONE }, + {Act.TestException, 0, TransactionRequiredException.class }, + + {Act.Lock, 1, LockModeType.READ }, + {Act.TestException, 0, TransactionRequiredException.class }, + + {Act.Lock, 1, LockModeType.WRITE }, + {Act.TestException, 0, TransactionRequiredException.class }, + + {Act.Lock, 1, LockModeType.OPTIMISTIC }, + {Act.TestException, 0, TransactionRequiredException.class }, + + {Act.Lock, 1, LockModeType.OPTIMISTIC_FORCE_INCREMENT }, + {Act.TestException, 0, TransactionRequiredException.class }, + + {Act.Lock, 1, LockModeType.PESSIMISTIC_READ}, + {Act.TestException, 0, TransactionRequiredException.class }, + + {Act.Lock, 1, LockModeType.PESSIMISTIC_WRITE}, + {Act.TestException, 0, TransactionRequiredException.class }, + + {Act.Lock, 1, LockModeType.PESSIMISTIC_FORCE_INCREMENT }, + {Act.TestException, 0, TransactionRequiredException.class }, + }; + + launchActionSequence("testLockTxReqExceptions()", + null, threadMainTxReqTest); + } + + /* + * IllegalArgumentException if the instance is not an entity or is a + * detached entity + */ + public void testLockIllegalArgrumentExceptions() { + // Test invalid entity argument throws IllegalArgumentException. + Object[][] threadMainInvEntityIllegalArgTest = { + {Act.CreateEm}, + {Act.Find}, + {Act.SaveVersion}, + {Act.TestEmployee, 1, Default_FirstName}, + {Act.StartTx}, + + {Act.LockObject, null, LockModeType.NONE }, + {Act.TestException, 0, IllegalArgumentException.class }, + {Act.LockObject, "null", LockModeType.NONE }, + {Act.TestException, 0, IllegalArgumentException.class }, + + {Act.LockObject, null, LockModeType.READ }, + {Act.TestException, 0, IllegalArgumentException.class }, + {Act.LockObject, "null", LockModeType.READ }, + {Act.TestException, 0, IllegalArgumentException.class }, + + {Act.LockObject, null, LockModeType.WRITE }, + {Act.TestException, 0, IllegalArgumentException.class }, + {Act.LockObject, "null", LockModeType.WRITE }, + {Act.TestException, 0, IllegalArgumentException.class }, + + {Act.LockObject, null, LockModeType.OPTIMISTIC }, + {Act.TestException, 0, IllegalArgumentException.class }, + {Act.LockObject, "null", LockModeType.OPTIMISTIC }, + {Act.TestException, 0, IllegalArgumentException.class }, + + {Act.LockObject, null, LockModeType.OPTIMISTIC_FORCE_INCREMENT }, + {Act.TestException, 0, IllegalArgumentException.class }, + {Act.LockObject, "null", LockModeType.OPTIMISTIC_FORCE_INCREMENT }, + {Act.TestException, 0, IllegalArgumentException.class }, + + {Act.LockObject, null, LockModeType.PESSIMISTIC_READ }, + {Act.TestException, 0, IllegalArgumentException.class }, + {Act.LockObject, "null", LockModeType.PESSIMISTIC_READ }, + {Act.TestException, 0, IllegalArgumentException.class }, + + {Act.LockObject, null, LockModeType.PESSIMISTIC_WRITE }, + {Act.TestException, 0, IllegalArgumentException.class }, + {Act.LockObject, "null", LockModeType.PESSIMISTIC_WRITE }, + {Act.TestException, 0, IllegalArgumentException.class }, + + {Act.LockObject, null, LockModeType.PESSIMISTIC_FORCE_INCREMENT }, + {Act.TestException, 0, IllegalArgumentException.class }, + {Act.LockObject, "null", LockModeType.PESSIMISTIC_FORCE_INCREMENT }, + {Act.TestException, 0, IllegalArgumentException.class }, + }; + launchActionSequence("testLockIllegalArgrumentExceptions()", + "Test invalid entity.", threadMainInvEntityIllegalArgTest); + + // Test detached entity argument throws IllegalArgumentException. + Object[][] threadMainDetachEntityIllegalArgTest = { + {Act.CreateEm}, + {Act.Find}, + {Act.SaveVersion}, + {Act.TestEmployee, 1, Default_FirstName}, + {Act.StartTx}, + {Act.Detach, 1, 2}, + + {Act.Lock, 2, LockModeType.PESSIMISTIC_FORCE_INCREMENT }, + {Act.TestException, 0, IllegalArgumentException.class }, + + {Act.Lock, 2, LockModeType.NONE }, + {Act.TestException, 0, IllegalArgumentException.class }, + + {Act.Lock, 2, LockModeType.READ }, + {Act.TestException, 0, IllegalArgumentException.class }, + + {Act.Lock, 2, LockModeType.WRITE }, + {Act.TestException, 0, IllegalArgumentException.class }, + + {Act.Lock, 2, LockModeType.OPTIMISTIC }, + {Act.TestException, 0, IllegalArgumentException.class }, + + {Act.Lock, 2, LockModeType.OPTIMISTIC_FORCE_INCREMENT }, + {Act.TestException, 0, IllegalArgumentException.class }, + + {Act.Lock, 2, LockModeType.PESSIMISTIC_READ }, + {Act.TestException, 0, IllegalArgumentException.class }, + + {Act.Lock, 2, LockModeType.PESSIMISTIC_WRITE }, + {Act.TestException, 0, IllegalArgumentException.class }, + + {Act.Lock, 2, LockModeType.PESSIMISTIC_FORCE_INCREMENT }, + {Act.TestException, 0, IllegalArgumentException.class }, + }; + launchActionSequence("testLockIllegalArgrumentExceptions()", + "Test detached entity.", threadMainDetachEntityIllegalArgTest); + + // Test detached argument from serialized entity throws + // IllegalArgumentException. + Object[][] threadMainDetachSerializeIllegalArgTest = { + {Act.CreateEm}, + {Act.Find}, + {Act.SaveVersion}, + {Act.TestEmployee, 1, Default_FirstName}, + {Act.StartTx}, + {Act.DetachSerialize, 1, 2}, + + {Act.Lock, 2, LockModeType.NONE }, + {Act.TestException, 0, IllegalArgumentException.class }, + + {Act.Lock, 2, LockModeType.READ }, + {Act.TestException, 0, IllegalArgumentException.class }, + + {Act.Lock, 2, LockModeType.WRITE }, + {Act.TestException, 0, IllegalArgumentException.class }, + + {Act.Lock, 2, LockModeType.OPTIMISTIC }, + {Act.TestException, 0, IllegalArgumentException.class }, + + {Act.Lock, 2, LockModeType.OPTIMISTIC_FORCE_INCREMENT }, + {Act.TestException, 0, IllegalArgumentException.class }, + + {Act.Lock, 2, LockModeType.PESSIMISTIC_READ }, + {Act.TestException, 0, IllegalArgumentException.class }, + + {Act.Lock, 2, LockModeType.PESSIMISTIC_WRITE }, + {Act.TestException, 0, IllegalArgumentException.class }, + + {Act.Lock, 2, LockModeType.PESSIMISTIC_FORCE_INCREMENT }, + {Act.TestException, 0, IllegalArgumentException.class }, + }; + launchActionSequence("testLockIllegalArgrumentExceptions()", + "Test detached entity using serialization.", + threadMainDetachSerializeIllegalArgTest); + + Object[][] threadMainRemoveIllegalArgTest = { + {Act.CreateEm}, + {Act.Find}, + {Act.SaveVersion}, + {Act.TestEmployee, 1, Default_FirstName}, + {Act.StartTx}, + {Act.Remove}, + + {Act.Lock, 1, LockModeType.NONE }, + {Act.TestException}, + + {Act.Lock, 1, LockModeType.READ }, + {Act.TestException}, + + {Act.Lock, 1, LockModeType.WRITE }, + {Act.TestException}, + + {Act.Lock, 1, LockModeType.OPTIMISTIC }, + {Act.TestException}, + + {Act.Lock, 1, LockModeType.OPTIMISTIC_FORCE_INCREMENT }, + {Act.TestException}, + + {Act.Lock, 1, LockModeType.PESSIMISTIC_READ }, + {Act.TestException}, + + {Act.Lock, 1, LockModeType.PESSIMISTIC_WRITE }, + {Act.TestException}, + + {Act.Lock, 1, LockModeType.PESSIMISTIC_FORCE_INCREMENT }, + {Act.TestException}, + + {Act.RollbackTx}, + }; + launchActionSequence( + "testLockIllegalArgrumentExceptions()", + "Test removed entity - no exception since it is still " + +"in the context.", + threadMainRemoveIllegalArgTest); + } + + /* + * If a pessimistic lock mode type is specified and the entity + * contains a version attribute, the persistence provider must + * also perform optimistic version checks when obtaining the + * database lock. If these checks fail, the + * OptimisticLockException will be thrown. + */ + public void testLockOptimisticLockExceptions() { + commonLockOptimisticLockExceptions( + LockModeType.NONE, false); + commonLockOptimisticLockExceptions( + LockModeType.READ, false); + commonLockOptimisticLockExceptions( + LockModeType.WRITE, false); + commonLockOptimisticLockExceptions( + LockModeType.OPTIMISTIC, false); + commonLockOptimisticLockExceptions( + LockModeType.OPTIMISTIC_FORCE_INCREMENT, false); + commonLockOptimisticLockExceptions( + LockModeType.PESSIMISTIC_READ, true); + commonLockOptimisticLockExceptions( + LockModeType.PESSIMISTIC_WRITE, true); + commonLockOptimisticLockExceptions( + LockModeType.PESSIMISTIC_FORCE_INCREMENT, true); + } + + public void commonLockOptimisticLockExceptions(LockModeType lockMode, + boolean expectingOptLockException) { + Object[][] threadMainOptLockExTest = { + {Act.CreateEm}, + {Act.Find}, + {Act.SaveVersion}, + {Act.TestEmployee, 1, Default_FirstName}, + {Act.Clear}, + + {Act.NewThread, 1 }, + {Act.StartThread, 1 }, + {Act.Wait}, + + {Act.StartTx}, + {Act.Find}, + {Act.Notify, 1}, + + {Act.Wait}, + {Act.Lock, 1, lockMode}, + {Act.WaitAllChildren}, + {Act.TestException, 0, expectingOptLockException + ? OptimisticLockException.class : null}, + + {Act.RollbackTx}, + }; + Object[][] thread1OptLockExTest = { + {Act.CreateEm}, + {Act.StartTx}, + {Act.Find}, + {Act.SaveVersion}, + + {Act.Notify, 0}, + {Act.Wait}, + {Act.UpdateEmployee}, + + {Act.CommitTx}, + {Act.Notify, 0}, + }; + launchActionSequence("testLockOptimisticLockExceptions()", null, + threadMainOptLockExTest, thread1OptLockExTest); + } +} Propchange: openjpa/trunk/openjpa-persistence-jdbc/src/test/java/org/apache/openjpa/persistence/lockmgr/TestMixedLockManagerLockException.java ------------------------------------------------------------------------------ svn:eol-style = native Added: openjpa/trunk/openjpa-persistence-jdbc/src/test/java/org/apache/openjpa/persistence/lockmgr/TestMixedLockManagerLockPermutation.java URL: http://svn.apache.org/viewvc/openjpa/trunk/openjpa-persistence-jdbc/src/test/java/org/apache/openjpa/persistence/lockmgr/TestMixedLockManagerLockPermutation.java?rev=762161&view=auto ============================================================================== --- openjpa/trunk/openjpa-persistence-jdbc/src/test/java/org/apache/openjpa/persistence/lockmgr/TestMixedLockManagerLockPermutation.java (added) +++ openjpa/trunk/openjpa-persistence-jdbc/src/test/java/org/apache/openjpa/persistence/lockmgr/TestMixedLockManagerLockPermutation.java Sun Apr 5 21:29:42 2009 @@ -0,0 +1,402 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, + * software distributed under the License is distributed on an + * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY + * KIND, either express or implied. See the License for the + * specific language governing permissions and limitations + * under the License. + */ +package org.apache.openjpa.persistence.lockmgr; + +import java.util.Arrays; + +import javax.persistence.LockModeType; + +/** + * Test JPA 2.0 LockMode type permutation behaviors with "mixed" lock manager. + */ +public class TestMixedLockManagerLockPermutation extends SequencedActionsTest { + public void setUp() { + setUp(LockEmployee.class + , "openjpa.LockManager", "mixed" + ); + commonSetUp(); + } + + /* ======== Thread 1 : Read Lock ============*/ + public void testLockReadRead() { + commonLockTest( + "testLock(Read,Commit/Read,Commit)", + LockModeType.READ, Act.CommitTx, 1, null, + LockModeType.READ, Act.CommitTx, 0, ExpectingOptimisticLockExClass); + commonLockTest( + "testLock(Read,Commit/Read,Rollback)", + LockModeType.READ, Act.CommitTx, 1, null, + LockModeType.READ, Act.RollbackTx, 1, null); + } + + public void testLockReadWrite() { + commonLockTest( + "testLock(Read,Commit/Write,Commit)", + LockModeType.READ, Act.CommitTx, 1, null, + LockModeType.WRITE, Act.CommitTx, 0, + ExpectingOptimisticLockExClass); + commonLockTest( + "testLock(Read,Commit/Write,Rollback)", + LockModeType.READ, Act.CommitTx, 1, null, + LockModeType.WRITE, Act.RollbackTx, 1, null); + } + + public void testLockReadPessimisticRead() { + commonLockTest( + "testLock(Read,Commit/PessimisticRead,Commit)", + LockModeType.READ, Act.CommitTx, 1, null, + LockModeType.PESSIMISTIC_READ, Act.CommitTx, 0, null); + commonLockTest( + "testLock(Read,Commit/PessimisticRead,Rollback)", + LockModeType.READ, Act.CommitTx, 1, null, + LockModeType.PESSIMISTIC_READ, Act.RollbackTx, 1, null); + } + + public void testLockReadPessimisticWrite() { + commonLockTest( + "testLock(Read,Commit/PessimisticWrite,Commit)", + LockModeType.READ, Act.CommitTx, 1, null, + LockModeType.PESSIMISTIC_WRITE, Act.CommitTx, 0, null); + commonLockTest( + "testLock(Read,Commit/PessimisticWrite,Rollback)", + LockModeType.READ, Act.CommitTx, 1, null, + LockModeType.PESSIMISTIC_WRITE, Act.RollbackTx, 1, null); + } + + public void testLockReadPessimisticForceInc() { + commonLockTest( + "testLock(Read,Commit/PessimisticForceInc,Commit)", + LockModeType.READ, Act.CommitTx, 1, ExpectingOptimisticLockExClass, + LockModeType.PESSIMISTIC_FORCE_INCREMENT, Act.CommitTx, 1, null); + commonLockTest( + "testLock(Read,Commit/PessimisticForceInc,Rollback)", + LockModeType.READ, Act.CommitTx, 1, null, + LockModeType.PESSIMISTIC_FORCE_INCREMENT, Act.RollbackTx, 1, null); + } + + /* ======== Thread 1 : Write Lock ============*/ + public void testLockWriteRead() { + commonLockTest( + "testLock(Write,Commit/Read,Commit)", + LockModeType.WRITE, Act.CommitTx, 1, null, + LockModeType.READ, Act.CommitTx, 0, ExpectingOptimisticLockExClass); + commonLockTest( + "testLock(Write,Commit/Read,Rollback)", + LockModeType.WRITE, Act.CommitTx, 1, null, + LockModeType.READ, Act.RollbackTx, 1, null); + } + + public void testLockWriteWrite() { + commonLockTest( + "testLock(Write,Commit/Write,Commit)", + LockModeType.WRITE, Act.CommitTx, 1, null, + LockModeType.WRITE, Act.CommitTx, 0, + ExpectingOptimisticLockExClass); + commonLockTest( + "testLock(Write,Commit/Write,Rollback)", + LockModeType.WRITE, Act.CommitTx, 1, null, + LockModeType.WRITE, Act.RollbackTx, 1, null); + } + + public void testLockWritePessimisticRead() { + commonLockTest( + "testLock(Write,Commit/PessimisticRead,Commit)", + LockModeType.WRITE, Act.CommitTx, 1, null, + LockModeType.PESSIMISTIC_READ, Act.CommitTx, 0, null); + commonLockTest( + "testLock(Write,Commit/PessimisticRead,Rollback)", + LockModeType.WRITE, Act.CommitTx, 1, null, + LockModeType.PESSIMISTIC_READ, Act.RollbackTx, 1, null); + } + + public void testLockWritePessimisticWrite() { + commonLockTest( + "testLock(Write,Commit/PessimisticWrite,Commit)", + LockModeType.WRITE, Act.CommitTx, 1, null, + LockModeType.PESSIMISTIC_WRITE, Act.CommitTx, 0, null); + commonLockTest( + "testLock(Write,Commit/PessimisticWrite,Rollback)", + LockModeType.WRITE, Act.CommitTx, 1, null, + LockModeType.PESSIMISTIC_WRITE, Act.RollbackTx, 1, null); + } + + public void testLockWritePessimisticForceInc() { + commonLockTest( + "testLock(Write,Commit/PessimisticForceInc,Commit)", + LockModeType.WRITE, Act.CommitTx, 1, ExpectingOptimisticLockExClass, + LockModeType.PESSIMISTIC_FORCE_INCREMENT, Act.CommitTx, 1, null); + commonLockTest( + "testLock(Write,Commit/PessimisticForceInc,Rollback)", + LockModeType.WRITE, Act.CommitTx, 1, null, + LockModeType.PESSIMISTIC_FORCE_INCREMENT, Act.RollbackTx, 1, null); + } + + /* ======== Thread 1 : PessimisticRead Lock ============*/ + public void testLockPessimisticReadRead() { + commonLockTest( + "testLock(PessimisticRead,Commit/Read,Commit)", + LockModeType.PESSIMISTIC_READ, Act.CommitTx, 1, null, + LockModeType.READ, Act.CommitTx, 0, ExpectingOptimisticLockExClass); + commonLockTest( + "testLock(PessimisticRead,Commit/Read,Rollback)", + LockModeType.PESSIMISTIC_READ, Act.CommitTx, 1, null, + LockModeType.READ, Act.RollbackTx, 1, null); + } + + public void testLockPessimisticReadWrite() { + commonLockTest( + "testLock(PessimisticRead,Commit/Write,Commit)", + LockModeType.PESSIMISTIC_READ, Act.CommitTx, 1, null, + LockModeType.WRITE, Act.CommitTx, 0, + ExpectingOptimisticLockExClass); + commonLockTest( + "testLock(PessimisticRead,Commit/Write,Rollback)", + LockModeType.PESSIMISTIC_READ, Act.CommitTx, 1, null, + LockModeType.WRITE, Act.RollbackTx, 1, null); + } + + public void testLockPessimisticReadPessimisticRead() { + commonLockTest( + "testLock(PessimisticRead,Commit/PessimisticRead,Commit)", + LockModeType.PESSIMISTIC_READ, Act.CommitTx, 1, null, + LockModeType.PESSIMISTIC_READ, Act.CommitTx, 1, + ExpectingOptimisticLockExClass); + commonLockTest( + "testLock(PessimisticRead,Commit/PessimisticRead,Rollback)", + LockModeType.PESSIMISTIC_READ, Act.CommitTx, 1, null, + LockModeType.PESSIMISTIC_READ, Act.RollbackTx, 1, + ExpectingOptimisticLockExClass); + } + + public void testLockPessimisticReadPessimisticWrite() { + commonLockTest( + "testLock(PessimisticRead,Commit/PessimisticWrite,Commit)", + LockModeType.PESSIMISTIC_READ, Act.CommitTx, 1, null, + LockModeType.PESSIMISTIC_WRITE, Act.CommitTx, 1, + ExpectingOptimisticLockExClass); + commonLockTest( + "testLock(PessimisticRead,Commit/PessimisticWrite,Rollback)", + LockModeType.PESSIMISTIC_READ, Act.CommitTx, 1, null, + LockModeType.PESSIMISTIC_WRITE, Act.RollbackTx, 1, + ExpectingOptimisticLockExClass); + } + + public void testLockPessimisticReadPessimisticForceInc() { + commonLockTest( + "testLock(PessimisticRead,Commit/PessimisticForceInc,Commit)", + LockModeType.PESSIMISTIC_READ, Act.CommitTx, 1, null, + LockModeType.PESSIMISTIC_FORCE_INCREMENT, Act.CommitTx, 2, + ExpectingOptimisticLockExClass); + commonLockTest( + "testLock(PessimisticRead,Commit/PessimisticForceInc,Rollback)", + LockModeType.PESSIMISTIC_READ, Act.CommitTx, 1, null, + LockModeType.PESSIMISTIC_FORCE_INCREMENT, Act.RollbackTx, 1, + ExpectingOptimisticLockExClass); + } + + /* ======== Thread 1 : Pessimsitic Write Lock ============*/ + public void testLockPessimsiticWriteRead() { + commonLockTest( + "testLock(PessimsiticWrite,Commit/Read,Commit)", + LockModeType.PESSIMISTIC_WRITE, Act.CommitTx, 1, null, + LockModeType.READ, Act.CommitTx, 0, ExpectingOptimisticLockExClass); + commonLockTest( + "testLock(PessimsiticWrite,Commit/Read,Rollback)", + LockModeType.PESSIMISTIC_WRITE, Act.CommitTx, 1, null, + LockModeType.READ, Act.RollbackTx, 1, null); + } + + public void testLockPessimsiticWriteWrite() { + commonLockTest( + "testLock(PessimsiticWrite,Commit/Write,Commit)", + LockModeType.PESSIMISTIC_WRITE, Act.CommitTx, 1, null, + LockModeType.WRITE, Act.CommitTx, 0, + ExpectingOptimisticLockExClass); + commonLockTest( + "testLock(PessimsiticWrite,Commit/Write,Rollback)", + LockModeType.PESSIMISTIC_WRITE, Act.CommitTx, 1, null, + LockModeType.WRITE, Act.RollbackTx, 1, null); + } + + public void testLockPessimsiticWritePessimisticRead() { + commonLockTest( + "testLock(PessimsiticWrite,Commit/PessimisticRead,Commit)", + LockModeType.PESSIMISTIC_WRITE, Act.CommitTx, 1, null, + LockModeType.PESSIMISTIC_READ, Act.CommitTx, 1, + ExpectingOptimisticLockExClass); + commonLockTest( + "testLock(PessimsiticWrite,Commit/PessimisticRead,Rollback)", + LockModeType.PESSIMISTIC_WRITE, Act.CommitTx, 1, null, + LockModeType.PESSIMISTIC_READ, Act.RollbackTx, 1, + ExpectingOptimisticLockExClass); + } + + public void testLockPessimsiticWritePessimisticWrite() { + commonLockTest( + "testLock(PessimsiticWrite,Commit/PessimisticWrite,Commit)", + LockModeType.PESSIMISTIC_WRITE, Act.CommitTx, 1, null, + LockModeType.PESSIMISTIC_WRITE, Act.CommitTx, 1, + ExpectingOptimisticLockExClass); + commonLockTest( + "testLock(PessimsiticWrite,Commit/PessimisticWrite,Rollback)", + LockModeType.PESSIMISTIC_WRITE, Act.CommitTx, 1, null, + LockModeType.PESSIMISTIC_WRITE, Act.RollbackTx, 1, + ExpectingOptimisticLockExClass); + } + + public void testLockPessimsiticWritePessimisticForceInc() { + commonLockTest( + "testLock(PessimsiticWrite,Commit/PessimisticForceInc,Commit)", + LockModeType.PESSIMISTIC_WRITE, Act.CommitTx, 1, null, + LockModeType.PESSIMISTIC_FORCE_INCREMENT, Act.CommitTx, 2, + ExpectingOptimisticLockExClass); + commonLockTest( + "testLock(PessimsiticWrite,Commit/PessimisticForceInc,Rollback)", + LockModeType.PESSIMISTIC_WRITE, Act.CommitTx, 1, null, + LockModeType.PESSIMISTIC_FORCE_INCREMENT, Act.RollbackTx, 1, + ExpectingOptimisticLockExClass); + } + + /* ======== Thread 1 : Pessimsitic Force Increment Lock ============*/ + public void testLockPessimsiticForceIncRead() { + commonLockTest( + "testLock(PessimsiticForceInc,Commit/Read,Commit)", + LockModeType.PESSIMISTIC_FORCE_INCREMENT, Act.CommitTx, 1, null, + LockModeType.READ, Act.CommitTx, 0, ExpectingOptimisticLockExClass); + commonLockTest( + "testLock(PessimsiticForceInc,Commit/Read,Rollback)", + LockModeType.PESSIMISTIC_FORCE_INCREMENT, Act.CommitTx, 1, null, + LockModeType.READ, Act.RollbackTx, 1, null); + } + + public void testLockPessimsiticForceIncWrite() { + commonLockTest( + "testLock(PessimsiticForceInc,Commit/Write,Commit)", + LockModeType.PESSIMISTIC_FORCE_INCREMENT, Act.CommitTx, 1, null, + LockModeType.WRITE, Act.CommitTx, 0, + ExpectingOptimisticLockExClass); + commonLockTest( + "testLock(PessimsiticForceInc,Commit/Write,Rollback)", + LockModeType.PESSIMISTIC_FORCE_INCREMENT, Act.CommitTx, 1, null, + LockModeType.WRITE, Act.RollbackTx, 1, null); + } + + public void testLockPessimsiticForceIncPessimisticRead() { + commonLockTest( + "testLock(PessimsiticForceInc,Commit/PessimisticRead,Commit)", + LockModeType.PESSIMISTIC_FORCE_INCREMENT, Act.CommitTx, 1, null, + LockModeType.PESSIMISTIC_READ, Act.CommitTx, 1, + ExpectingOptimisticLockExClass); + commonLockTest( + "testLock(PessimsiticForceInc,Commit/PessimisticRead,Rollback)", + LockModeType.PESSIMISTIC_FORCE_INCREMENT, Act.CommitTx, 1, null, + LockModeType.PESSIMISTIC_READ, Act.RollbackTx, 1, + ExpectingOptimisticLockExClass); + } + + public void testLockPessimsiticForceIncPessimisticWrite() { + commonLockTest( + "testLock(PessimsiticForceInc,Commit/PessimisticWrite,Commit)", + LockModeType.PESSIMISTIC_FORCE_INCREMENT, Act.CommitTx, 1, null, + LockModeType.PESSIMISTIC_WRITE, Act.CommitTx, 1, + ExpectingOptimisticLockExClass); + commonLockTest( + "testLock(PessimsiticForceInc,Commit/PessimisticWrite,Rollback)", + LockModeType.PESSIMISTIC_FORCE_INCREMENT, Act.CommitTx, 1, null, + LockModeType.PESSIMISTIC_WRITE, Act.RollbackTx, 1, + ExpectingOptimisticLockExClass); + } + + public void testLockPessimsiticForceIncPessimisticForceInc() { + commonLockTest( + "testLock(PessimsiticForceInc,Commit/PessimisticForceInc,Commit)", + LockModeType.PESSIMISTIC_FORCE_INCREMENT, Act.CommitTx, 1, null, + LockModeType.PESSIMISTIC_FORCE_INCREMENT, Act.CommitTx, 2, + ExpectingOptimisticLockExClass); + commonLockTest( + "testLock(PessimsiticForceInc,Commit/PessimisticForceInc,Rollback)", + LockModeType.PESSIMISTIC_FORCE_INCREMENT, Act.CommitTx, 1, null, + LockModeType.PESSIMISTIC_FORCE_INCREMENT, Act.RollbackTx, 1, + ExpectingOptimisticLockExClass); + } + + private void commonLockTest( String testName, + LockModeType t1Lock, Act t1IsCommit, int t1VersionInc, + Class[] t1Exceptions, + LockModeType t2Lock, Act t2IsCommit, int t2VersionInc, + Class[] t2Exceptions ) { + String[] parameters = new String[] { + "Thread 1: lock= " + t1Lock + ", isCommit= " + t1IsCommit + + ", versionInc= +" + t1VersionInc + + ", expectedEx= " + Arrays.toString(t1Exceptions), + "Thread 2: lock= " + t2Lock + ", isCommit= " + t2IsCommit + + ", versionInc= +" + t2VersionInc + + ", expectedEx= " + Arrays.toString(t2Exceptions)}; + + Object[][] threadMain = { + {Act.CreateEm}, + {Act.Find}, + {Act.SaveVersion}, + {Act.TestEmployee, 1, Default_FirstName}, + + {Act.NewThread, 1 }, + {Act.NewThread, 2 }, + {Act.StartThread, 1 }, + {Act.Wait}, + {Act.StartThread, 2 }, + {Act.Notify, 1, 1000 }, + {Act.Notify, 2, 1000 }, + {Act.WaitAllChildren}, + {Act.Find}, + {Act.TestEmployee, 1}, + {Act.TestException, 1, t1Exceptions }, + {Act.TestException, 2, t2Exceptions }, + }; + Object[][] thread1 = { + {Act.CreateEm}, + {Act.StartTx}, + {Act.Find}, + {Act.SaveVersion}, + {Act.Lock, 1, t1Lock }, + {Act.TestException}, + {Act.Notify, 0}, + {Act.Wait}, + {Act.UpdateEmployee}, + + {t1IsCommit}, + {Act.Find}, + {Act.TestEmployee, 1, null, t1VersionInc} + }; + Object[][] thread2 = { + {Act.CreateEm}, + {Act.StartTx}, + {Act.Find}, + {Act.SaveVersion}, + {Act.Lock, 1, t2Lock }, + {Act.Notify, 0}, + {Act.Wait}, + + {t2IsCommit}, + {Act.Find}, + {Act.TestEmployee, 1, null, t2VersionInc} + }; + launchActionSequence(testName, parameters, threadMain, thread1, + thread2); + } +} Propchange: openjpa/trunk/openjpa-persistence-jdbc/src/test/java/org/apache/openjpa/persistence/lockmgr/TestMixedLockManagerLockPermutation.java ------------------------------------------------------------------------------ svn:eol-style = native Added: openjpa/trunk/openjpa-persistence-jdbc/src/test/java/org/apache/openjpa/persistence/lockmgr/TestMixedLockManagerRefreshBasic.java URL: http://svn.apache.org/viewvc/openjpa/trunk/openjpa-persistence-jdbc/src/test/java/org/apache/openjpa/persistence/lockmgr/TestMixedLockManagerRefreshBasic.java?rev=762161&view=auto ============================================================================== --- openjpa/trunk/openjpa-persistence-jdbc/src/test/java/org/apache/openjpa/persistence/lockmgr/TestMixedLockManagerRefreshBasic.java (added) +++ openjpa/trunk/openjpa-persistence-jdbc/src/test/java/org/apache/openjpa/persistence/lockmgr/TestMixedLockManagerRefreshBasic.java Sun Apr 5 21:29:42 2009 @@ -0,0 +1,122 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, + * software distributed under the License is distributed on an + * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY + * KIND, either express or implied. See the License for the + * specific language governing permissions and limitations + * under the License. + */ +package org.apache.openjpa.persistence.lockmgr; + +import javax.persistence.LockModeType; + +/** + * Test JPA 2.0 em.refresh(LockMode) basic behaviors with "mixed" lock manager. + */ +public class TestMixedLockManagerRefreshBasic extends SequencedActionsTest { + public void setUp() { + setUp(LockEmployee.class + , "openjpa.LockManager", "mixed" + ); + commonSetUp(); + } + + public void testRefreshRead() { + testCommon("testRefreshRead", + LockModeType.READ, 0, 1); + } + + public void testRefreshWrite() { + testCommon("testRefreshWrite", + LockModeType.WRITE, 1, 1); + } + + public void testRefreshOptimistic() { + testCommon("testRefreshOptimistic", + LockModeType.OPTIMISTIC, 0, 1); + } + + public void testRefreshOptimisticForceInc() { + testCommon("testRefreshOptimisticForceInc", + LockModeType.OPTIMISTIC_FORCE_INCREMENT, 1, 1); + } + + public void testRefreshPessimisticRead() { + testCommon("testRefreshPessimisticRead", + LockModeType.PESSIMISTIC_READ, 0, 1); + } + + public void testRefreshPessimisticWrite() { + testCommon("testRefreshPessimisticWrite", + LockModeType.PESSIMISTIC_WRITE, 0, 1); + } + + public void testRefreshPessimisticForceInc() { + testCommon("testRefreshPessimisticForceInc", + LockModeType.PESSIMISTIC_FORCE_INCREMENT, 1, 1); + } + + public void testCommon(String testName, LockModeType lockMode, + int commitVersionIncrement, int updateCommitVersionIncrement) { + Object[][] threadMain = { + // Find entity, refresh with Lock, no update and commit. + { Act.CreateEm }, + { Act.StartTx }, + { Act.Clear }, + { Act.Find, 1 }, + { Act.TestEmployee, 1, Default_FirstName}, + { Act.SaveVersion }, + { Act.RefreshWithLock, 1, lockMode }, + { Act.TestEmployee, 1, Default_FirstName}, + { Act.CommitTx }, + { Act.Clear }, + { Act.Find, 1 }, + { Act.TestEmployee, 1, Default_FirstName, + commitVersionIncrement }, + + // Find entity, refresh with Lock, update and commit. + { Act.StartTx }, + { Act.Clear }, + { Act.Find, 1 }, + { Act.TestEmployee, 1, Default_FirstName}, + { Act.SaveVersion }, + { Act.UpdateEmployee, 1, "New Name 2"}, + { Act.TestEmployee, 1, "New Name 2"}, + { Act.RefreshWithLock, 1, lockMode }, + { Act.TestEmployee, 1, Default_FirstName, 0}, + { Act.UpdateEmployee, 1, lockMode.toString()}, + { Act.CommitTx }, + { Act.Clear }, + { Act.Find, 1 }, + { Act.TestEmployee, 1, lockMode.toString(), + updateCommitVersionIncrement }, + + // Find entity, refresh with Lock, update and rollback. + { Act.StartTx }, + { Act.Clear }, + { Act.Find, 1}, + { Act.TestEmployee, 1, lockMode.toString()}, + { Act.SaveVersion }, + { Act.UpdateEmployee, 1, "New Name 3"}, + { Act.TestEmployee, 1, "New Name 3", 0}, + { Act.RefreshWithLock, 1, lockMode }, + { Act.TestEmployee, 1, lockMode.toString(), 0}, + { Act.UpdateEmployee, 1, lockMode.toString() + " Again" }, + { Act.RollbackTx }, + { Act.Clear }, + { Act.Find, 1 }, + { Act.TestEmployee, 1, lockMode.toString(), 0 }, + }; + launchActionSequence(testName, "LockMode=" + lockMode, threadMain); + } +} Propchange: openjpa/trunk/openjpa-persistence-jdbc/src/test/java/org/apache/openjpa/persistence/lockmgr/TestMixedLockManagerRefreshBasic.java ------------------------------------------------------------------------------ svn:eol-style = native