X-Git-Url: http://wamblee.org/gitweb/?a=blobdiff_plain;f=support%2Fgeneral%2Fsrc%2Ftest%2Fjava%2Forg%2Fwamblee%2Fconcurrency%2FReadWriteLockTest.java;h=8dccb3e135106f30155c6b2ae61097c4f86a43c3;hb=8de36ff0206c996baf3ee4adc3e2293b12ff5f39;hp=2e7996244752d68de4d659e1fa270821e79615d2;hpb=89c06d4d52b46c154128c97d6e758fa1f4fc7a6e;p=utils diff --git a/support/general/src/test/java/org/wamblee/concurrency/ReadWriteLockTest.java b/support/general/src/test/java/org/wamblee/concurrency/ReadWriteLockTest.java index 2e799624..8dccb3e1 100644 --- a/support/general/src/test/java/org/wamblee/concurrency/ReadWriteLockTest.java +++ b/support/general/src/test/java/org/wamblee/concurrency/ReadWriteLockTest.java @@ -18,27 +18,17 @@ package org.wamblee.concurrency; import junit.framework.Assert; import junit.framework.TestCase; - /** * Testing the read-write lock class. Note: in case of problems, test cases * could hang. - * + * * @see ReadWriteLock */ public class ReadWriteLockTest extends TestCase { - /** - * - */ private static final int HALF_SECOND = 500; - /** - * - */ private static final int ONE_SECOND = 1000; - /** - * - */ private static final int TWO_SECONDS = 2000; private ReadWriteLock lock; private int nReaders; @@ -46,7 +36,7 @@ public class ReadWriteLockTest extends TestCase { /** * Constructor for ReadWriteLockTest. - * + * * @param aName */ public ReadWriteLockTest(String aName) { @@ -111,8 +101,9 @@ public class ReadWriteLockTest extends TestCase { /** * Verify concurrent access by multiple readers is possible. - * - * @throws InterruptedException May not occur. + * + * @throws InterruptedException + * May not occur. */ public void testMultipleReaders() throws InterruptedException { Runnable runnable = new ReadLocker(lock, this, TWO_SECONDS); @@ -130,8 +121,9 @@ public class ReadWriteLockTest extends TestCase { /** * Verify that only one writer at a time can acquire the write lock. - * - * @throws InterruptedException May not occur. + * + * @throws InterruptedException + * May not occur. */ public void testSingleWriter() throws InterruptedException { WriteLocker writer = new WriteLocker(lock, this, ONE_SECOND); @@ -149,12 +141,13 @@ public class ReadWriteLockTest extends TestCase { /** * Verify that multiple writers cannot acquire the write lock concurrently. - * - * @throws InterruptedException May not occur. + * + * @throws InterruptedException + * May not occur. */ public void testMultipleWriters() throws InterruptedException { - WriteLocker writer1 = new WriteLocker(lock, this, - HALF_SECOND + ONE_SECOND); + WriteLocker writer1 = new WriteLocker(lock, this, HALF_SECOND + + ONE_SECOND); WriteLocker writer2 = new WriteLocker(lock, this, ONE_SECOND); Thread t1 = new Thread(writer1); Thread t2 = new Thread(writer2); @@ -170,17 +163,18 @@ public class ReadWriteLockTest extends TestCase { Thread.sleep(ONE_SECOND); // at t = 2, the second writer still must have - // a lock. + // a lock. assertTrue(getWriterCount() == 1); t1.join(); t2.join(); } /** - * Verify that after the first reader acquires a lock, a subsequent writer + * Verify that after the first reader acquires a lock, a subsequent writer * can only acquire the lock after the reader has released it. - * - * @throws InterruptedException May not occur. + * + * @throws InterruptedException + * May not occur. */ public void testReadWrite1() throws InterruptedException { ReadLocker readLocker = new ReadLocker(lock, this, TWO_SECONDS); @@ -195,13 +189,13 @@ public class ReadWriteLockTest extends TestCase { Thread.sleep(HALF_SECOND); // 1 second underway, reader still holding the - // lock so write lock cannot be acquired. + // lock so write lock cannot be acquired. assertTrue(getReaderCount() == 1); assertTrue(getWriterCount() == 0); Thread.sleep(ONE_SECOND + HALF_SECOND); - // 2.5 seconds underway, read lock released and - // write lock must be acquired. + // 2.5 seconds underway, read lock released and + // write lock must be acquired. assertTrue("Wrong no. of readers: " + getReaderCount(), getReaderCount() == 0); assertTrue(getWriterCount() == 1); @@ -212,14 +206,15 @@ public class ReadWriteLockTest extends TestCase { /** * Verify that when multiple readers have acquired a read lock, the writer * can only acquire the lock after all readers have released it. - * - * @throws InterruptedException May not occur. + * + * @throws InterruptedException + * May not occur. */ public void testReadWrite2() throws InterruptedException { - ReadLocker readLocker1 = new ReadLocker(lock, this, - TWO_SECONDS + HALF_SECOND); - ReadLocker readLocker2 = new ReadLocker(lock, this, - TWO_SECONDS + HALF_SECOND); + ReadLocker readLocker1 = new ReadLocker(lock, this, TWO_SECONDS + + HALF_SECOND); + ReadLocker readLocker2 = new ReadLocker(lock, this, TWO_SECONDS + + HALF_SECOND); Thread t1 = new Thread(readLocker1); Thread t2 = new Thread(readLocker2); WriteLocker writeLocker = new WriteLocker(lock, this, TWO_SECONDS); @@ -233,10 +228,10 @@ public class ReadWriteLockTest extends TestCase { Thread.sleep(HALF_SECOND); // t = 1.5 assertTrue(getReaderCount() == 2); - t3.start(); // write lock + t3.start(); // write lock Thread.sleep(HALF_SECOND); - // 2 seconds, + // 2 seconds, assertTrue(getReaderCount() == 2); assertTrue(getWriterCount() == 0); Thread.sleep(ONE_SECOND); @@ -247,8 +242,8 @@ public class ReadWriteLockTest extends TestCase { assertTrue(getWriterCount() == 0); Thread.sleep(ONE_SECOND); - // 4 seconds underway, write lock must have - // been acquired. + // 4 seconds underway, write lock must have + // been acquired. assertTrue(getReaderCount() == 0); assertTrue(getWriterCount() == 1); @@ -258,10 +253,11 @@ public class ReadWriteLockTest extends TestCase { } /** - * Verify that after a writer acquires a lock, a subsequent reader can - * only acquire the lock after the writer has released it. - * - * @throws InterruptedException May not occur. + * Verify that after a writer acquires a lock, a subsequent reader can only + * acquire the lock after the writer has released it. + * + * @throws InterruptedException + * May not occur. */ public void testReadWrite3() throws InterruptedException { ReadLocker readLocker = new ReadLocker(lock, this, TWO_SECONDS); @@ -276,13 +272,13 @@ public class ReadWriteLockTest extends TestCase { Thread.sleep(HALF_SECOND); // 1 second underway, writer still holding the - // lock so read lock cannot be acquired. + // lock so read lock cannot be acquired. assertTrue(getWriterCount() == 1); assertTrue(getReaderCount() == 0); Thread.sleep(ONE_SECOND + HALF_SECOND); - // 2.5 seconds underway, write lock released and - // read lock must be acquired. + // 2.5 seconds underway, write lock released and + // read lock must be acquired. assertTrue("Wrong no. of writers: " + getReaderCount(), getWriterCount() == 0); assertTrue(getReaderCount() == 1); @@ -291,29 +287,29 @@ public class ReadWriteLockTest extends TestCase { } /* - * The following test cases are for testing whether or not - * the read write lock checks the locking correctly. - * Strictly speaking, these checks wouldn't be necessary - * because it involves the contract of the ReadWriteLock which - * must be obeyed by users of the ReadWriteLock. Nevertheless, - * this is tested anyway to be absolutely sure. + * The following test cases are for testing whether or not the read write + * lock checks the locking correctly. Strictly speaking, these checks + * wouldn't be necessary because it involves the contract of the + * ReadWriteLock which must be obeyed by users of the ReadWriteLock. + * Nevertheless, this is tested anyway to be absolutely sure. */ /** - * Acquire a read lock from one thread, release it from another. Verify - * that a RuntimeException is thrown. - * - * @throws InterruptedException May not occur. + * Acquire a read lock from one thread, release it from another. Verify that + * a RuntimeException is thrown. + * + * @throws InterruptedException + * May not occur. */ public void testReleaseReadFromWrongThread() throws InterruptedException { Thread t1 = null; try { t1 = new Thread(new Runnable() { - public void run() { - ReadWriteLockTest.this.lock.acquireRead(); - } - }); + public void run() { + ReadWriteLockTest.this.lock.acquireRead(); + } + }); t1.start(); Thread.sleep(ONE_SECOND); // wait until thread is started lock.releaseRead(); // release lock from wrong thread. @@ -329,18 +325,19 @@ public class ReadWriteLockTest extends TestCase { /** * Acquire a write lock from one thread, release it from another. Verify * that a RuntimeException is thrown. - * - * @throws InterruptedException May not occur. + * + * @throws InterruptedException + * May not occur. */ public void testReleaseWriteFromWrongThread() throws InterruptedException { Thread t1 = null; try { t1 = new Thread(new Runnable() { - public void run() { - ReadWriteLockTest.this.lock.acquireWrite(); - } - }); + public void run() { + ReadWriteLockTest.this.lock.acquireWrite(); + } + }); t1.start(); Thread.sleep(ONE_SECOND); // wait until thread is started lock.releaseWrite(); // release lock from wrong thread. @@ -354,8 +351,8 @@ public class ReadWriteLockTest extends TestCase { } /** - * Try to acquire a read lock multiple times. Verify that a - * RuntimeException is thrown. + * Try to acquire a read lock multiple times. Verify that a RuntimeException + * is thrown. */ public void testAcquireReadTwice() { try { @@ -445,11 +442,10 @@ public class ReadWriteLockTest extends TestCase { } } - /** - * ReadLocker acquires a read lock and performs a callback when the lock as - * been acquired, sleeps for a designated amount of time, releases the read - * lock, and performs a callback after the lock has been released. + * ReadLocker acquires a read lock and performs a callback when the lock as been + * acquired, sleeps for a designated amount of time, releases the read lock, and + * performs a callback after the lock has been released. */ class ReadLocker implements Runnable { private ReadWriteLock lock; @@ -479,9 +475,8 @@ class ReadLocker implements Runnable { } } - /** - * WriteLocker acquires a write lock and performs a callback when the lock as + * WriteLocker acquires a write lock and performs a callback when the lock as * been acquired, sleeps for a designated amount of time, releases the write * lock, and performs a callback after the lock has been released. */