[jboss-cvs] JBossCache/tests/functional/org/jboss/cache/transaction ...
Manik Surtani
msurtani at jboss.com
Sun Nov 26 06:52:05 EST 2006
User: msurtani
Date: 06/11/26 06:52:05
Added: tests/functional/org/jboss/cache/transaction Tag:
Branch_JBossCache_1_3_0
IsolationLevelRepeatableReadTest.java
Log:
More fixes
Revision Changes Path
No revision
No revision
1.1.2.1 +380 -0 JBossCache/tests/functional/org/jboss/cache/transaction/Attic/IsolationLevelRepeatableReadTest.java
(In the diff below, changes in quantity of whitespace are not shown.)
Index: IsolationLevelRepeatableReadTest.java
===================================================================
RCS file: IsolationLevelRepeatableReadTest.java
diff -N IsolationLevelRepeatableReadTest.java
--- /dev/null 1 Jan 1970 00:00:00 -0000
+++ IsolationLevelRepeatableReadTest.java 26 Nov 2006 11:52:05 -0000 1.1.2.1
@@ -0,0 +1,380 @@
+package org.jboss.cache.transaction;
+
+import junit.framework.AssertionFailedError;
+import junit.framework.Test;
+import junit.framework.TestCase;
+import junit.framework.TestSuite;
+import org.jboss.cache.DummyTransactionManagerLookup;
+import org.jboss.cache.Fqn;
+import org.jboss.cache.TreeCache;
+import org.jboss.cache.lock.IsolationLevel;
+
+import javax.transaction.NotSupportedException;
+import javax.transaction.SystemException;
+import javax.transaction.Transaction;
+
+/**
+ * Tests READ_COMMITED isolation level.
+ *
+ * @author <a href="mailto:ovidiu at jboss.org">Ovidiu Feodorov</a>
+ *
+ * @version $Id: IsolationLevelRepeatableReadTest.java,v 1.1.2.1 2006/11/26 11:52:05 msurtani Exp $
+ */
+
+public class IsolationLevelRepeatableReadTest extends TestCase
+{
+
+ private TreeCache cache = null;
+ private final Fqn FQN = Fqn.fromString("/a");
+ private final String KEY = "key";
+ private final String VALUE = "value";
+
+ private volatile boolean writerFailed;
+ private volatile boolean readerFailed;
+ private volatile AssertionFailedError writerError;
+ private volatile AssertionFailedError readerError;
+
+ protected void setUp() throws Exception
+ {
+ super.setUp();
+
+ writerFailed = false;
+ readerFailed = false;
+
+ writerError = null;
+ readerError = null;
+
+ cache = new TreeCache();
+ cache.setCacheMode(TreeCache.LOCAL);
+ cache.setIsolationLevel(IsolationLevel.REPEATABLE_READ);
+ cache.setTransactionManagerLookupClass(DummyTransactionManagerLookup.class.getName());
+ cache.setLockAcquisitionTimeout(1000);
+ cache.startService();
+ }
+
+
+ protected void tearDown() throws Exception
+ {
+ super.tearDown();
+
+ cache.stopService();
+ cache.destroyService();
+ cache=null;
+ }
+
+ public void testMultipleReaders() throws Exception
+ {
+ final Fqn fqn = Fqn.fromString("/test");
+// final Latch latch = new Latch();
+ final Object lock = new Object();
+
+ class ReaderThread extends Thread
+ {
+ public void run()
+ {
+ try
+ {
+ cache.getTransactionManager().begin();
+// latch.acquire();
+
+ synchronized(lock)
+ {
+ System.out.println(getName() + " waiting on lock");
+ lock.wait();
+ }
+
+ assertNotNull(cache.get(fqn));
+
+ synchronized(lock)
+ {
+ System.out.println(getName() + " waiting on lock");
+ lock.wait();
+ }
+ cache.getTransactionManager().commit();
+ }
+ catch (Exception e)
+ {
+ e.printStackTrace();
+ fail();
+ }
+ }
+ }
+
+ Thread[] t = new Thread[5];
+ for (int i=0; i<t.length; i++)
+ {
+ t[i] = new ReaderThread();
+ t[i].start();
+ }
+
+ cache.put(fqn, "k", "v");
+ // now all are ready to go...
+// latch.release();
+
+ synchronized(lock)
+ {
+ System.out.println(cache.printLockInfo());
+ lock.notifyAll();
+ }
+
+ System.out.println("2nd time...");
+
+ synchronized(lock)
+ {
+ System.out.println(cache.printLockInfo());
+ // check that we have multiple readers:
+ assertEquals(5, cache.get(Fqn.ROOT).getLock().getReaderOwners().size());
+ assertEquals(5, cache.get(fqn).getLock().getReaderOwners().size());
+ assertNull(cache.get(Fqn.ROOT).getLock().getWriterOwner());
+ assertNull(cache.get(fqn).getLock().getWriterOwner());
+
+ lock.notifyAll();
+ }
+
+
+ for (int i=0; i<t.length; i++) t[i].join();
+
+
+
+ assertEquals(0, cache.get(Fqn.ROOT).getLock().getReaderOwners().size());
+ assertEquals(0, cache.get(fqn).getLock().getReaderOwners().size());
+ assertNull(cache.get(Fqn.ROOT).getLock().getWriterOwner());
+ assertNull(cache.get(fqn).getLock().getWriterOwner());
+ }
+
+
+ public void testMultipleReadersOneWriter() throws Exception
+ {
+ final Fqn fqn = Fqn.fromString("/test");
+// final Latch latch = new Latch();
+ final Object rLock = new Object();
+ final Object wLock = new Object();
+
+ class ReaderThread extends Thread
+ {
+ public void run()
+ {
+ try
+ {
+ cache.getTransactionManager().begin();
+// latch.acquire();
+
+ synchronized(rLock)
+ {
+ System.out.println(getName() + " waiting on lock");
+ rLock.wait();
+ }
+
+ assertNotNull(cache.get(fqn));
+
+ synchronized(rLock)
+ {
+ System.out.println(getName() + " waiting on lock");
+ rLock.wait();
+ }
+ cache.getTransactionManager().commit();
+ }
+ catch (Exception e)
+ {
+ e.printStackTrace();
+ fail();
+ }
+ }
+ }
+
+ class WriterThread extends Thread
+ {
+ public void run()
+ {
+ try
+ {
+ cache.getTransactionManager().begin();
+// latch.acquire();
+
+ synchronized(wLock)
+ {
+ System.out.println(getName() + " waiting on lock");
+ wLock.wait();
+ }
+
+ cache.put(fqn, "k2", "v2");
+ fail("Should not be allowed to acquire the WL");
+
+ synchronized(rLock)
+ {
+ System.out.println(getName() + " waiting on lock");
+ rLock.wait();
+ }
+ cache.getTransactionManager().commit();
+ }
+ catch (Exception e)
+ {
+ //expected
+ }
+ finally
+ {
+ try
+ {
+ cache.getTransactionManager().rollback();
+ }
+ catch (Exception e)
+ {
+ }
+ }
+ }
+ }
+
+ cache.put(fqn, "k", "v");
+
+ Thread[] t = new Thread[6];
+ for (int i=0; i<t.length - 1; i++)
+ {
+ t[i] = new ReaderThread();
+ t[i].start();
+ }
+
+ t[t.length - 1] = new WriterThread();
+ t[t.length - 1].start();
+
+
+ // now all are ready to go...
+// latch.release();
+
+ synchronized(rLock) { rLock.notifyAll();}
+ synchronized(wLock) { wLock.notifyAll();}
+
+ System.out.println("2nd time...");
+
+ synchronized(rLock)
+ {
+ System.out.println(cache.printLockInfo());
+ // check that we have multiple readers:
+ assertEquals(6, cache.get(Fqn.ROOT).getLock().getReaderOwners().size());
+ assertEquals(5, cache.get(fqn).getLock().getReaderOwners().size());
+ assertNull(cache.get(Fqn.ROOT).getLock().getWriterOwner());
+ assertNull(cache.get(fqn).getLock().getWriterOwner());
+
+ rLock.notifyAll();
+ }
+
+
+ for (int i=0; i<t.length; i++) t[i].join();
+
+
+ System.out.println("Locks: " + cache.printLockInfo());
+
+ assertEquals(0, cache.get(Fqn.ROOT).getLock().getReaderOwners().size());
+ assertEquals(0, cache.get(fqn).getLock().getReaderOwners().size());
+ assertNull(cache.get(Fqn.ROOT).getLock().getWriterOwner());
+ assertNull(cache.get(fqn).getLock().getWriterOwner());
+ }
+
+
+ /**
+ * Test creates a cache node then starts a separate thread that removes
+ * the node inside a tx. Test confirms that the removal cannot be seen
+ * before the test commits.
+ *
+ * @throws Exception
+ */
+// public void testNodeRemoved() throws Exception
+// {
+// final Latch readerCanRead = new Latch();
+// final Latch readerDone = new Latch();
+// final Latch writerDone = new Latch();
+//
+// cache.put(FQN, KEY, VALUE);
+// assertEquals(VALUE, cache.get(FQN, KEY));
+//
+// // start a writer thread and a transaction
+//
+// Thread writerThread = new Thread(new Runnable()
+// {
+// public void run()
+// {
+// try
+// {
+// Transaction tx = startTransaction();
+//
+// // change VALUE in a transaction
+// cache.remove(FQN);
+//
+// // notify the reading thread
+// readerCanRead.release();
+//
+// readerDone.acquire();
+//
+// tx.commit();
+// }
+// catch (AssertionFailedError e)
+// {
+// writerError = e;
+// }
+// catch(Throwable t)
+// {
+// t.printStackTrace();
+// writerFailed = true;
+// }
+// finally
+// {
+// System.out.println("writer thread exits");
+// readerCanRead.release();
+// writerDone.release();
+// }
+// }
+// }, "WRITER");
+// writerThread.start();
+//
+// try
+// {
+// // wait until the writer thread changes the value in a transaction,
+// // but it did not yet commit or roll back.
+// readerCanRead.acquire();
+//
+// // I shouldn't be able to see the "dirty" value
+// assertEquals("2nd thread cannot see uncommitted changes",
+// VALUE, cache.get(FQN, KEY));
+// }
+// catch (TimeoutException t)
+// {
+// // ignore, this is good
+// }
+// finally
+// {
+// System.out.println("reader thread exits");
+// readerDone.release();
+// }
+//
+// // wait for the writer to finish
+// writerDone.acquire();
+//
+// assertNull("Node was removed", cache.get(FQN));
+//
+// // If any assertion failed, throw on the AssertionFailedError
+//
+// if (writerError != null)
+// {
+// throw writerError;
+// }
+//
+// if (writerFailed)
+// {
+// fail("The writer thread exited incorrectly. Watch the log for previous stack traces");
+// }
+//
+// }
+
+ private Transaction startTransaction() throws SystemException, NotSupportedException
+ {
+ DummyTransactionManager mgr=DummyTransactionManager.getInstance();
+ mgr.begin();
+ return mgr.getTransaction();
+ }
+
+ public static Test suite() {
+
+ return new TestSuite(IsolationLevelRepeatableReadTest.class);
+
+ }
+
+}
More information about the jboss-cvs-commits
mailing list