openjpa-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From allee8...@apache.org
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 GMT
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



Mime
View raw message