Index: ssts-web/src/test/java/test/forgon/system/concurrent/service/OptimisticLockManagerTest.java
===================================================================
diff -u -r23798 -r23801
--- ssts-web/src/test/java/test/forgon/system/concurrent/service/OptimisticLockManagerTest.java	(.../OptimisticLockManagerTest.java)	(revision 23798)
+++ ssts-web/src/test/java/test/forgon/system/concurrent/service/OptimisticLockManagerTest.java	(.../OptimisticLockManagerTests.java)	(revision 23801)
@@ -16,8 +16,10 @@
 import test.forgon.disinfectsystem.AbstractCSSDTest;
 
 import com.forgon.system.concurrent.model.OptimisticLock;
+import com.forgon.system.concurrent.model.OptimisticLockConflictException;
 import com.forgon.system.concurrent.model.OptimisticLockNoTransactionException;
 import com.forgon.system.concurrent.service.OptimisticLockManager;
+import com.forgon.system.concurrent.service.test.OptimisticLockManagerTest;
 import com.forgon.system.concurrent.service.test.OptimisticLockManagerTest.WaitObject;
 import com.forgon.system.concurrent.service.test.OptimisticLockManagerTestLevel1;
 
@@ -30,7 +32,7 @@
  */
 @Transactional(propagation = Propagation.NEVER)
 @Test(singleThreaded = true)
-public class OptimisticLockManagerTest extends AbstractCSSDTest {
+public class OptimisticLockManagerTests extends AbstractCSSDTest {
 
 	private static final String ENTITY_OPTIMISTICLOCKTEST = "OptimisticLockTest";
 	@Autowired
@@ -106,15 +108,15 @@
 		}
 
 	}
-	
+
 	/**
 	 * 一个事务请求锁_测试资源是否正确分配和释放
 	 */
 	@Test
 	public void test_requestLockByStringIds_OneTransaction_Normal() {
 		{
-			List<String> ids = Arrays
-					.asList(new String[] { "1", "2", "3", "4", "5" });
+			List<String> ids = Arrays.asList(new String[] { "1", "2", "3", "4",
+					"5" });
 			WaitObject notifyObject = new WaitObject();
 			WaitObject continueObject = new WaitObject();
 			Thread thread = new Thread() {
@@ -128,12 +130,13 @@
 			notifyObject.waitForDone();
 			List<OptimisticLock> allLocks = optimisticLockManager.getAllLocks();
 			assertEquals(allLocks.size(), ids.size());
-			for(int i=0;i<ids.size();++i){
+			for (int i = 0; i < ids.size(); ++i) {
 				OptimisticLock optimisticLock = allLocks.get(i);
-				assertEquals(optimisticLock.getEntity(), ENTITY_OPTIMISTICLOCKTEST);
+				assertEquals(optimisticLock.getEntity(),
+						ENTITY_OPTIMISTICLOCKTEST);
 				assertEquals(optimisticLock.getId(), ids.get(i));
 			}
-			
+
 			continueObject.setDone();
 			try {
 				thread.join();
@@ -171,8 +174,8 @@
 		{
 			WaitObject notifyObject = new WaitObject();
 			WaitObject continueObject = new WaitObject();
-			List<String> ids = Arrays
-					.asList(new String[] { "1", "2", "3", "4", "5" });
+			List<String> ids = Arrays.asList(new String[] { "1", "2", "3", "4",
+					"5" });
 			optimisticLockManagerTestLevel1
 					.test_requestLockByStringIds_OneTransaction_RepeatRequest(
 							ENTITY_OPTIMISTICLOCKTEST, ids, null, null);
@@ -262,17 +265,17 @@
 			assertEquals(allLocks_end.size(), 0);
 		}
 	}
-	
+
 	/**
 	 * 两个事务请求锁_测试资源是否正确分配和释放
 	 */
 	@Test
 	public void test_requestLockByStringIds_TwoTransactions_Normal() {
 		{
-			List<String> ids = Arrays
-					.asList(new String[] { "1", "2", "3", "4", "5" });
+			List<String> ids = Arrays.asList(new String[] { "1", "2", "3", "4",
+					"5" });
 			List<String> ids2 = Arrays
-					.asList(new String[] { "6", "7", "8", "9"});
+					.asList(new String[] { "6", "7", "8", "9" });
 			WaitObject notifyObject = new WaitObject();
 			WaitObject continueObject = new WaitObject();
 			Thread thread = new Thread() {
@@ -297,9 +300,10 @@
 				List<OptimisticLock> allLocks = optimisticLockManager
 						.getAllLocks();
 				assertEquals(allLocks.size(), ids.size());
-				for(int i=0;i<ids.size();++i){
+				for (int i = 0; i < ids.size(); ++i) {
 					OptimisticLock optimisticLock = allLocks.get(i);
-					assertEquals(optimisticLock.getEntity(), ENTITY_OPTIMISTICLOCKTEST);
+					assertEquals(optimisticLock.getEntity(),
+							ENTITY_OPTIMISTICLOCKTEST);
 					assertEquals(optimisticLock.getId(), ids.get(i));
 				}
 			}
@@ -312,9 +316,10 @@
 				List<String> idsTotal = new LinkedList<String>(ids);
 				idsTotal.addAll(ids2);
 				assertEquals(allLocks.size(), idsTotal.size());
-				for(int i=0;i<idsTotal.size();++i){
+				for (int i = 0; i < idsTotal.size(); ++i) {
 					OptimisticLock optimisticLock = allLocks.get(i);
-					assertEquals(optimisticLock.getEntity(), ENTITY_OPTIMISTICLOCKTEST);
+					assertEquals(optimisticLock.getEntity(),
+							ENTITY_OPTIMISTICLOCKTEST);
 					assertEquals(optimisticLock.getId(), idsTotal.get(i));
 				}
 			}
@@ -328,9 +333,10 @@
 				List<OptimisticLock> allLocks = optimisticLockManager
 						.getAllLocks();
 				assertEquals(allLocks.size(), ids2.size());
-				for(int i=0;i<ids2.size();++i){
+				for (int i = 0; i < ids2.size(); ++i) {
 					OptimisticLock optimisticLock = allLocks.get(i);
-					assertEquals(optimisticLock.getEntity(), ENTITY_OPTIMISTICLOCKTEST);
+					assertEquals(optimisticLock.getEntity(),
+							ENTITY_OPTIMISTICLOCKTEST);
 					assertEquals(optimisticLock.getId(), ids2.get(i));
 				}
 			}
@@ -348,90 +354,185 @@
 	}
 
 	/**
-	 * 两个实体，两个事务请求锁_测试资源是否正确分配和释放，多个
+	 * 两个实体，两个事务请求锁_测试资源是否正确分配和释放
 	 */
-	// @Test()
-	// public void test_TwoTransactions_Normal() {
-	// {
-	// WaitObject notifyObject = new WaitObject();
-	// WaitObject continueObject = new WaitObject();
-	// Thread thread = new Thread() {
-	// public void run() {
-	// optimisticLockManagerTestLevel1.requestLockById(
-	// ENTITY_OPTIMISTICLOCKTEST, "1", notifyObject,
-	// continueObject);
-	// };
-	// };
-	// thread.start();
-	// WaitObject notifyObject2 = new WaitObject();
-	// WaitObject continueObject2 = new WaitObject();
-	// Thread thread2 = new Thread() {
-	// public void run() {
-	// optimisticLockManagerTestLevel1.requestLockById(
-	// ENTITY_OPTIMISTICLOCKTEST, "2", notifyObject2,
-	// continueObject2);
-	// };
-	// };
-	// notifyObject.waitForDone();
-	// {
-	// List<OptimisticLock> allLocks = optimisticLockManager
-	// .getAllLocks();
-	// assertEquals(allLocks.size(), 1);
-	// OptimisticLock optimisticLock = allLocks.get(0);
-	// assertEquals(optimisticLock.getEntity(),
-	// ENTITY_OPTIMISTICLOCKTEST);
-	// assertEquals(optimisticLock.getId(), "1");
-	// }
-	//
-	// thread2.start();
-	// notifyObject2.waitForDone();
-	// {
-	// List<OptimisticLock> allLocks = optimisticLockManager
-	// .getAllLocks();
-	// assertEquals(allLocks.size(), 2);
-	// Collections.sort(allLocks, OptimisticLock.ID_COMPARATOR);
-	// OptimisticLock optimisticLock = allLocks.get(0);
-	// assertEquals(optimisticLock.getEntity(),
-	// ENTITY_OPTIMISTICLOCKTEST);
-	// assertEquals(optimisticLock.getId(), "1");
-	//
-	// OptimisticLock optimisticLock1 = allLocks.get(1);
-	// assertEquals(optimisticLock1.getEntity(),
-	// ENTITY_OPTIMISTICLOCKTEST);
-	// assertEquals(optimisticLock1.getId(), "2");
-	// }
-	// continueObject.setDone();
-	// try {
-	// thread.join();
-	// } catch (InterruptedException e) {
-	// e.printStackTrace();
-	// }
-	// {
-	// List<OptimisticLock> allLocks = optimisticLockManager
-	// .getAllLocks();
-	// assertEquals(allLocks.size(), 1);
-	// OptimisticLock optimisticLock = allLocks.get(0);
-	// assertEquals(optimisticLock.getEntity(),
-	// ENTITY_OPTIMISTICLOCKTEST);
-	// assertEquals(optimisticLock.getId(), "2");
-	// }
-	//
-	// continueObject2.setDone();
-	// try {
-	// thread2.join();
-	// } catch (InterruptedException e) {
-	// e.printStackTrace();
-	// }
-	// List<OptimisticLock> allLocks_end = optimisticLockManager
-	// .getAllLocks();
-	// assertEquals(allLocks_end.size(), 0);
-	// }
-	// }
+	@Test
+	public void test_TwoEntities_TwoTransactions_Normal() {
+		{
+			WaitObject notifyObject = new WaitObject();
+			WaitObject continueObject = new WaitObject();
+			Thread thread = new Thread() {
+				public void run() {
+					optimisticLockManagerTestLevel1.requestLockById(
+							ENTITY_OPTIMISTICLOCKTEST, "1", notifyObject,
+							continueObject);
+				};
+			};
+			thread.start();
+			WaitObject notifyObject2 = new WaitObject();
+			WaitObject continueObject2 = new WaitObject();
+			Thread thread2 = new Thread() {
+				public void run() {
+					optimisticLockManagerTestLevel1
+							.requestLockById(
+									OptimisticLockManagerTest.ENTITY_OPTIMISTICLOCKTEST_2,
+									"1", notifyObject2, continueObject2);
+				};
+			};
+			notifyObject.waitForDone();
+			{
+				List<OptimisticLock> allLocks = optimisticLockManager
+						.getAllLocks();
+				assertEquals(allLocks.size(), 1);
+				OptimisticLock optimisticLock = allLocks.get(0);
+				assertEquals(optimisticLock.getEntity(),
+						ENTITY_OPTIMISTICLOCKTEST);
+				assertEquals(optimisticLock.getId(), "1");
+			}
 
+			thread2.start();
+			notifyObject2.waitForDone();
+			{
+				List<OptimisticLock> allLocks = optimisticLockManager
+						.getAllLocks();
+				assertEquals(allLocks.size(), 2);
+				OptimisticLock optimisticLock = allLocks.get(0);
+				assertEquals(optimisticLock.getEntity(),
+						ENTITY_OPTIMISTICLOCKTEST);
+				assertEquals(optimisticLock.getId(), "1");
+
+				OptimisticLock optimisticLock1 = allLocks.get(1);
+				assertEquals(optimisticLock1.getEntity(),
+						OptimisticLockManagerTest.ENTITY_OPTIMISTICLOCKTEST_2);
+				assertEquals(optimisticLock1.getId(), "1");
+			}
+			continueObject.setDone();
+			try {
+				thread.join();
+			} catch (InterruptedException e) {
+				e.printStackTrace();
+			}
+			{
+				List<OptimisticLock> allLocks = optimisticLockManager
+						.getAllLocks();
+				assertEquals(allLocks.size(), 1);
+				OptimisticLock optimisticLock = allLocks.get(0);
+				assertEquals(optimisticLock.getEntity(),
+						OptimisticLockManagerTest.ENTITY_OPTIMISTICLOCKTEST_2);
+				assertEquals(optimisticLock.getId(), "1");
+			}
+
+			continueObject2.setDone();
+			try {
+				thread2.join();
+			} catch (InterruptedException e) {
+				e.printStackTrace();
+			}
+			List<OptimisticLock> allLocks_end = optimisticLockManager
+					.getAllLocks();
+			assertEquals(allLocks_end.size(), 0);
+		}
+	}
+
 	/**
+	 * 两个实体，两个事务请求锁_测试资源是否正确分配和释放
+	 */
+	@Test
+	public void test_requestLockByStringIds_TwoEntities_TwoTransactions_Normal() {
+		{
+			List<String> ids = Arrays.asList(new String[] { "1", "2", "3", "4",
+					"5" });
+			List<String> ids2 = Arrays.asList(new String[] { "1", "2", "3",
+					"4", "5", "6", "7", "8" });
+			WaitObject notifyObject = new WaitObject();
+			WaitObject continueObject = new WaitObject();
+			Thread thread = new Thread() {
+				public void run() {
+					optimisticLockManagerTestLevel1.requestLockByStringIds(
+							ENTITY_OPTIMISTICLOCKTEST, ids, notifyObject,
+							continueObject);
+				};
+			};
+			thread.start();
+			WaitObject notifyObject2 = new WaitObject();
+			WaitObject continueObject2 = new WaitObject();
+			Thread thread2 = new Thread() {
+				public void run() {
+					optimisticLockManagerTestLevel1
+							.requestLockByStringIds(
+									OptimisticLockManagerTest.ENTITY_OPTIMISTICLOCKTEST_2,
+									ids2, notifyObject2, continueObject2);
+				};
+			};
+			notifyObject.waitForDone();
+			{
+				List<OptimisticLock> allLocks = optimisticLockManager
+						.getAllLocks();
+				assertEquals(allLocks.size(), ids.size());
+				for (int i = 0; i < ids.size(); ++i) {
+					OptimisticLock optimisticLock = allLocks.get(i);
+					assertEquals(optimisticLock.getEntity(),
+							ENTITY_OPTIMISTICLOCKTEST);
+					assertEquals(optimisticLock.getId(), ids.get(i));
+				}
+			}
+
+			thread2.start();
+			notifyObject2.waitForDone();
+			{
+				List<OptimisticLock> allLocks = optimisticLockManager
+						.getAllLocks();
+				List<String> idsTotal = new LinkedList<String>(ids);
+				idsTotal.addAll(ids2);
+				assertEquals(allLocks.size(), idsTotal.size());
+				for (int i = 0; i < idsTotal.size(); ++i) {
+					OptimisticLock optimisticLock = allLocks.get(i);
+					if (i < ids.size()) {
+						assertEquals(optimisticLock.getEntity(),
+								ENTITY_OPTIMISTICLOCKTEST);
+					} else {
+						assertEquals(
+								optimisticLock.getEntity(),
+								OptimisticLockManagerTest.ENTITY_OPTIMISTICLOCKTEST_2);
+					}
+					assertEquals(optimisticLock.getId(), idsTotal.get(i));
+				}
+			}
+			continueObject.setDone();
+			try {
+				thread.join();
+			} catch (InterruptedException e) {
+				e.printStackTrace();
+			}
+			{
+				List<OptimisticLock> allLocks = optimisticLockManager
+						.getAllLocks();
+				assertEquals(allLocks.size(), ids2.size());
+				for (int i = 0; i < ids2.size(); ++i) {
+					OptimisticLock optimisticLock = allLocks.get(i);
+					assertEquals(
+							optimisticLock.getEntity(),
+							OptimisticLockManagerTest.ENTITY_OPTIMISTICLOCKTEST_2);
+					assertEquals(optimisticLock.getId(), ids2.get(i));
+				}
+			}
+
+			continueObject2.setDone();
+			try {
+				thread2.join();
+			} catch (InterruptedException e) {
+				e.printStackTrace();
+			}
+			List<OptimisticLock> allLocks_end = optimisticLockManager
+					.getAllLocks();
+			assertEquals(allLocks_end.size(), 0);
+		}
+	}
+
+	/**
 	 * 两个事务请求锁_冲突
 	 */
-//	@Test(expectedExceptions = OptimisticLockConflictException.class)
+	@Test(expectedExceptions = OptimisticLockConflictException.class)
 	public void test_TwoTransactions_Conflict(String id) {
 		{
 			WaitObject notifyObject = new WaitObject();
@@ -463,4 +564,45 @@
 			// 异常
 		}
 	}
+
+	/**
+	 * 两个事务请求锁_冲突
+	 */
+	@Test(expectedExceptions = OptimisticLockConflictException.class)
+	public void test_requestLockByStringIds_TwoTransactions_Conflict() {
+		{
+			List<String> ids = Arrays.asList(new String[] { "1", "2", "3", "4",
+					"5" });
+			List<String> ids2 = Arrays.asList(new String[] { "3" });
+			WaitObject notifyObject = new WaitObject();
+			WaitObject continueObject = new WaitObject();
+			Thread thread = new Thread() {
+				public void run() {
+					optimisticLockManagerTestLevel1.requestLockByStringIds(
+							ENTITY_OPTIMISTICLOCKTEST, ids, notifyObject,
+							continueObject);
+				};
+			};
+			thread.start();
+			WaitObject notifyObject2 = new WaitObject();
+			WaitObject continueObject2 = new WaitObject();
+
+			notifyObject.waitForDone();
+			{
+				List<OptimisticLock> allLocks = optimisticLockManager
+						.getAllLocks();
+				assertEquals(allLocks.size(), ids.size());
+				for (int i = 0; i < ids.size(); ++i) {
+					OptimisticLock optimisticLock = allLocks.get(i);
+					assertEquals(optimisticLock.getEntity(),
+							ENTITY_OPTIMISTICLOCKTEST);
+					assertEquals(optimisticLock.getId(), ids.get(i));
+				}
+			}
+			optimisticLockManagerTestLevel1.requestLockByStringIds(
+					ENTITY_OPTIMISTICLOCKTEST, ids2, notifyObject2,
+					continueObject2);
+			// 异常
+		}
+	}
 }
Fisheye: Tag 23801 refers to a dead (removed) revision in file `ssts-web/src/test/java/test/forgon/system/concurrent/service/OptimisticLockManagerTest.java'.
Fisheye: No comparison available.  Pass `N' to diff?