[jboss-cvs] JBossCache/tests/functional/org/jboss/cache/aop ...
Ben Wang
bwang at jboss.com
Wed Oct 25 10:13:41 EDT 2006
User: bwang
Date: 06/10/25 10:13:41
Added: tests/functional/org/jboss/cache/aop Tag:
Branch_JBossCache_1_4_0
PojoCollectionRollbackTest.java
Log:
created
Revision Changes Path
No revision
No revision
1.1.2.1 +375 -0 JBossCache/tests/functional/org/jboss/cache/aop/Attic/PojoCollectionRollbackTest.java
(In the diff below, changes in quantity of whitespace are not shown.)
Index: PojoCollectionRollbackTest.java
===================================================================
RCS file: PojoCollectionRollbackTest.java
diff -N PojoCollectionRollbackTest.java
--- /dev/null 1 Jan 1970 00:00:00 -0000
+++ PojoCollectionRollbackTest.java 25 Oct 2006 14:13:41 -0000 1.1.2.1
@@ -0,0 +1,375 @@
+/*
+ * JBoss, the OpenSource J2EE webOS
+ *
+ * Distributable under LGPL license.
+ * See terms of license at gnu.org.
+ */
+package org.jboss.cache.aop;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+import javax.transaction.TransactionManager;
+
+import junit.framework.TestCase;
+
+import org.jboss.cache.DummyTransactionManagerLookup;
+import org.jboss.cache.TreeCache;
+import org.jboss.cache.aop.PojoCache;
+import org.jboss.cache.lock.IsolationLevel;
+
+/**
+ * @author
+ * @version
+ */
+public class PojoCollectionRollbackTest extends TestCase
+{
+
+ private static final String ID = "id";
+ private static final String CONTAINER_FQN = "/objsIndex";
+
+
+ public PojoCollectionRollbackTest(String s)
+ {
+ super(s);
+ }
+
+ private PojoCache cache;
+
+ protected void setUp() throws Exception
+ {
+ super.setUp();
+ }
+
+ private void startTest() throws Exception {
+ cache = new PojoCache();
+ cache.setCacheMode(TreeCache.LOCAL);
+ cache.setIsolationLevel(IsolationLevel.REPEATABLE_READ);
+ cache.setTransactionManagerLookup(new DummyTransactionManagerLookup());
+ cache.create();
+ cache.start();
+ }
+
+ protected void tearDown() throws Exception
+ {
+ super.tearDown();
+ cache.stop();
+ cache.destroy();
+ }
+
+ public void testNestedMapAndIndexWithModifyRollback() throws Exception
+ {
+ System.out.println("testNestedMapAndIndexWithModifyRollback");
+ startTest();
+
+ // create cached data objects
+ Map obj1 = new HashMap();
+ obj1.put(ID, "1");
+ cache.putObject("/objs/1", obj1);
+ obj1 = (Map) cache.getObject("/objs/1");
+
+ // create cached collection of data objects
+ // initialize collection by adding a data object
+ Map indexMap = null;
+ final String KEY = "KEY";
+ Object beforeModify;
+ Object afterRollback;
+
+ indexMap = new HashMap();
+ cache.putObject(CONTAINER_FQN, indexMap);
+ indexMap = (Map) cache.getObject(CONTAINER_FQN);
+ indexMap.put(KEY, obj1);
+
+ beforeModify = indexMap.get(KEY);
+ Object idBeforeModify = ((Map)beforeModify).get(ID);
+
+ System.out.println("beforeModify: " + beforeModify + ", data object id: " + ((Map)beforeModify).get(ID));
+
+ // modify the collection by replacing the first data object with the second
+ // and then roll-back the transaction
+ TransactionManager tm = cache.getTransactionManager();
+ tm.begin();
+
+ obj1.put(ID, "newID");
+ indexMap.remove(KEY);
+ tm.rollback();
+
+ indexMap = (Map) cache.getObject(CONTAINER_FQN);
+ afterRollback = indexMap.get(KEY);
+ System.out.println("afterRollback: " + afterRollback + ", data object id: " + ((Map)afterRollback).get(ID));
+
+ // check if state of collection was restored
+ assertEquals(beforeModify, afterRollback);
+ assertTrue(beforeModify == afterRollback);
+ assertEquals(1, indexMap.size());
+
+ assertEquals("1", obj1.get(ID));
+ Object idAfterRollback = ((Map)afterRollback).get(ID);
+ System.out.println("idBeforeModify: " + idBeforeModify + " idAfterRollback: " + idAfterRollback);
+ assertEquals(idBeforeModify, idAfterRollback);
+ }
+
+ public void testNestedMapWithModifyRollback() throws Exception
+ {
+ System.out.println("testNestedMapWithModifyRollback");
+ startTest();
+
+ // create cached data objects
+ Map obj1 = new HashMap();
+ obj1.put(ID, "1");
+ cache.putObject("/objs/1", obj1);
+ obj1 = (Map) cache.getObject("/objs/1");
+
+ Map obj2 = new HashMap();
+ obj2.put(ID, "2");
+ cache.putObject("/objs/2", obj2);
+ obj2 = (Map) cache.getObject("/objs/2");
+
+ // create cached collection of data objects
+ // initialize collection by adding a data object
+ Map indexMap = null;
+ final String KEY = "KEY";
+ Object beforeModify;
+ Object afterRollback;
+
+ indexMap = new HashMap();
+ cache.putObject(CONTAINER_FQN, indexMap);
+ indexMap = (Map) cache.getObject(CONTAINER_FQN);
+ indexMap.put(KEY, obj1);
+ beforeModify = indexMap.get(KEY);
+
+ System.out.println("beforeModify: " + beforeModify + ", data object id: " + ((Map)beforeModify).get(ID));
+
+ // modify the collection by replacing the first data object with the second
+ // and then roll-back the transaction
+ TransactionManager tm = cache.getTransactionManager();
+ tm.begin();
+ Object removedByModify = indexMap.put(KEY, obj2);
+ System.out.println("removedByModify: " + removedByModify + ", data object id: " + ((Map)removedByModify).get(ID));
+ assertEquals(removedByModify, beforeModify);
+ tm.rollback();
+
+ indexMap = (Map) cache.getObject(CONTAINER_FQN);
+ afterRollback = indexMap.get(KEY);
+ System.out.println("afterRollback: " + afterRollback + ", data object id: " + ((Map)afterRollback).get(ID));
+
+ // check if state of collection was restored
+ assertEquals(beforeModify, afterRollback);
+ assertEquals(1, indexMap.size());
+ // check that map entry can now be modified
+ indexMap.put(KEY, obj2);
+ assertEquals(obj2, indexMap.get(KEY));
+ }
+
+ public void testNestedMapWithRemoveRollback() throws Exception
+ {
+ System.out.println("testNestedMapWithRemoveRollback");
+ startTest();
+
+ // create cached data objects
+ Map obj1 = new HashMap();
+ obj1.put(ID, "1");
+ cache.putObject("/objs/1", obj1);
+ obj1 = (Map) cache.getObject("/objs/1");
+
+ Map obj2 = new HashMap();
+ obj2.put(ID, "2");
+ cache.putObject("/objs/2", obj2);
+ obj2 = (Map) cache.getObject("/objs/2");
+
+ // create cached collection of data objects
+ Map indexMap = new HashMap();
+ cache.putObject(CONTAINER_FQN, indexMap);
+ indexMap = (Map) cache.getObject(CONTAINER_FQN);
+
+ // initialize collection by adding a data object
+ final String KEY = "KEY";
+ indexMap.put(KEY, obj1);
+
+ Object beforeModify = indexMap.get(KEY);
+ System.out.println("beforeModify: " + beforeModify + ", data object id: " + ((Map)beforeModify).get(ID));
+
+ // modify the collection by replacing the first data object with the second
+ // and then roll-back the transaction
+ TransactionManager tm = cache.getTransactionManager();
+ tm.begin();
+ Object removedByRemove = indexMap.remove(KEY);
+ System.out.println("removedByRemove: " + removedByRemove + ", data object id: " + ((Map)removedByRemove).get(ID));
+ assertEquals(beforeModify, removedByRemove);
+ tm.rollback();
+
+ Object afterRollback = indexMap.get(KEY);
+ System.out.println("afterRollback: " + afterRollback + ", data object id: " + ((Map)afterRollback).get(ID));
+
+ // check if state of collection was restored
+ assertEquals(beforeModify, afterRollback);
+ assertEquals(1, indexMap.size());
+
+ // check that map entry can now be modified
+ indexMap.put(KEY, obj2);
+ assertEquals(obj2, indexMap.get(KEY));
+ }
+
+ public void testNestedListWithModifyAddRollback() throws Exception
+ {
+ System.out.println("testNestedListWithModifyAddRollback");
+ startTest();
+
+ // create cached data objects
+ Map obj1 = new HashMap();
+ obj1.put(ID, "1");
+ cache.putObject("/objs/1", obj1);
+ obj1 = (Map) cache.getObject("/objs/1");
+
+ Map obj2 = new HashMap();
+ obj2.put(ID, "2");
+ cache.putObject("/objs/2", obj2);
+ obj2 = (Map) cache.getObject("/objs/2");
+ assertFalse(obj1.equals(obj2));
+
+ // create cached collection of data objects
+ List indexList = new ArrayList();
+ cache.putObject(CONTAINER_FQN, indexList);
+ indexList = (List) cache.getObject(CONTAINER_FQN);
+
+ // initialize collection by adding a data object
+ indexList.add(obj1);
+
+ Object beforeModify = indexList.get(0);
+ System.out.println("beforeModify: " + beforeModify + ", data object id: " + ((Map)beforeModify).get(ID));
+ int objIndex1, objIndex2;
+
+ // modify the collection by replacing the first data object with the second
+ // and then roll-back the transaction
+ TransactionManager tm = cache.getTransactionManager();
+ tm.begin();
+ indexList.add(obj2);
+ objIndex1 = indexList.indexOf(obj1);
+ objIndex2 = indexList.indexOf(obj2);
+ tm.rollback();
+
+ // before rollback - object set
+ assertFalse(obj1.equals(obj2));
+ assertEquals(0, objIndex1);
+ assertEquals(1, objIndex2);
+
+ Object afterRollback = indexList.get(0);
+ System.out.println("afterRollback: " + afterRollback + ", data object id: " + ((Map)afterRollback).get(ID));
+
+ // check if state of collection was restored
+ assertEquals(beforeModify, afterRollback);
+ assertEquals(1, indexList.size());
+
+ // check that list entry can now be modified
+ indexList.set(0, obj2);
+ assertEquals(obj2, indexList.get(0));
+ }
+
+ public void testNestedListWithModifySetRollback() throws Exception
+ {
+ System.out.println("testNestedListWithModifySetRollback");
+ startTest();
+
+ // create cached data objects
+ Map obj1 = new HashMap();
+ obj1.put(ID, "1");
+ cache.putObject("/objs/1", obj1);
+ obj1 = (Map) cache.getObject("/objs/1");
+
+ Map obj2 = new HashMap();
+ obj2.put(ID, "2");
+ cache.putObject("/objs/2", obj2);
+ obj2 = (Map) cache.getObject("/objs/2");
+
+ // create cached collection of data objects
+ List indexList = new ArrayList();
+ cache.putObject(CONTAINER_FQN, indexList);
+ indexList = (List) cache.getObject(CONTAINER_FQN);
+
+ // initialize collection by adding a data object
+ indexList.add(obj1);
+
+ Object beforeModify = indexList.get(0);
+ System.out.println("beforeModify: " + beforeModify + ", data object id: " + ((Map)beforeModify).get(ID));
+ int objIndex;
+
+ // modify the collection by replacing the first data object with the second
+ // and then roll-back the transaction
+ TransactionManager tm = cache.getTransactionManager();
+ tm.begin();
+ Object removedBySet = indexList.set(0, obj2);
+ System.out.println("removedBySet: " +removedBySet + ", data object id: " + ((Map)removedBySet).get(ID));
+ assertEquals(beforeModify, removedBySet);
+ objIndex = indexList.indexOf(obj2);
+ tm.rollback();
+
+ // before rollback - object set
+ assertEquals(0, objIndex);
+
+ Object afterRollback = indexList.get(0);
+ System.out.println("afterRollback: " + afterRollback + ", data object id: " + ((Map)afterRollback).get(ID));
+
+ // check if state of collection was restored
+ assertEquals(beforeModify, afterRollback);
+ assertEquals(1, indexList.size());
+
+ // check that list entry can now be modified
+ indexList.set(0, obj2);
+ assertEquals(obj2, indexList.get(0));
+ }
+
+ public void testNestedListWithRemoveRollback() throws Exception
+ {
+ System.out.println("testNestedListWithRemoveRollback");
+ startTest();
+
+ // create cached data objects
+ Map obj1 = new HashMap();
+ obj1.put(ID, "1");
+ cache.putObject("/objs/1", obj1);
+ obj1 = (Map) cache.getObject("/objs/1");
+
+ Map obj2 = new HashMap();
+ obj2.put(ID, "2");
+ cache.putObject("/objs/2", obj2);
+ obj2 = (Map) cache.getObject("/objs/2");
+
+ // create cached collection of data objects
+ List indexList = new ArrayList();
+ cache.putObject(CONTAINER_FQN, indexList);
+ indexList = (List) cache.getObject(CONTAINER_FQN);
+
+ // initialize collection by adding a data object
+ indexList.add(obj1);
+
+ Object beforeModify = indexList.get(0);
+ System.out.println("beforeModify: " + beforeModify + ", data object id: " + ((Map)beforeModify).get(ID));
+ int objIndex;
+
+ // modify the collection by replacing the first data object with the second
+ // and then roll-back the transaction
+ TransactionManager tm = cache.getTransactionManager();
+ tm.begin();
+ indexList.remove(obj1);
+ objIndex = indexList.indexOf(obj1);
+ tm.rollback();
+
+ // before rollback - object removed
+ assertEquals(-1, objIndex);
+
+ Object afterRollback = indexList.get(0);
+ System.out.println("afterRollback: " + afterRollback + ", data object id: " + ((Map)afterRollback).get(ID));
+
+ // check if state of collection was restored
+ assertEquals(beforeModify, afterRollback);
+ assertEquals(1, indexList.size());
+
+ // check that list entry can now be modified
+ indexList.set(0, obj2);
+ assertEquals(obj2, indexList.get(0));
+ }
+
+
+}
More information about the jboss-cvs-commits
mailing list