From 050c817ad5a377a2ab60a51c2f44dad6ce90e106 Mon Sep 17 00:00:00 2001
From: "James W. Carman" <jcarman@apache.org>
Date: Wed, 23 Nov 2005 13:13:04 +0000
Subject: [PATCH] 37607: Enhance BlockingBuffer to allow for a timeout value

git-svn-id: https://svn.apache.org/repos/asf/jakarta/commons/proper/collections/trunk@348428 13f79535-47bb-0310-9956-ffa450edef68
---
 RELEASE-NOTES.html                            |   1 +
 STATUS.html                                   |   1 +
 .../commons/collections/BufferUtils.java      |  19 +-
 .../collections/buffer/BlockingBuffer.java    | 181 ++++---
 .../buffer/TestBlockingBuffer.java            | 493 ++++++++++--------
 5 files changed, 392 insertions(+), 303 deletions(-)

diff --git a/RELEASE-NOTES.html b/RELEASE-NOTES.html
index 8272ea1ee..e39bee820 100644
--- a/RELEASE-NOTES.html
+++ b/RELEASE-NOTES.html
@@ -72,6 +72,7 @@ If this causes major headaches to anyone please contact commons-dev at jakarta.a
 <li>ExtendedProperties - No longer uses an exception in normal processing [30497]</li>
 <li>BlockingBuffer - now includes stack trace if InterupttedException occurs [33700]</li>
 <li>BlockingBuffer - new methods that allow get and remove with a timeout [27691]</li>
+<li>BlockingBuffer - now allows you to specify a default timeout value for get/remove operations [37607]</li>
 <li>Transformed*Map - new factory decorateTransform() that transforms any existing entries in the map [30959]</li>
 <li>ListOrderedMap - values can now be accessed as a List using valueList() [37015]</li>
 <li>ListOrderedMap - additional list-like method, setValue(int,Object)</li>
diff --git a/STATUS.html b/STATUS.html
index f30390f02..1dcf5392f 100644
--- a/STATUS.html
+++ b/STATUS.html
@@ -83,6 +83,7 @@ component to ensure that it continues to meet a variety of needs.</p>
    <li><a href="mailto:rdonkin@apache.org">Robert Burrell Donkin</a></li>
    <li><a href="mailto:psteitz@apache.org">Phil Steitz</a></li>
    <li><a href="mailto:matth@apache.org">Matthew Hawthorne</a></li>
+   <li><a href="mailto:jcarman@apache.org">James Carman</a></li>
    <li>Arun M. Thomas</li>
 </ul>
 
diff --git a/src/java/org/apache/commons/collections/BufferUtils.java b/src/java/org/apache/commons/collections/BufferUtils.java
index af6883aba..77eba4610 100644
--- a/src/java/org/apache/commons/collections/BufferUtils.java
+++ b/src/java/org/apache/commons/collections/BufferUtils.java
@@ -21,14 +21,13 @@ import org.apache.commons.collections.buffer.SynchronizedBuffer;
 import org.apache.commons.collections.buffer.TransformedBuffer;
 import org.apache.commons.collections.buffer.TypedBuffer;
 import org.apache.commons.collections.buffer.UnmodifiableBuffer;
-import org.apache.commons.collections.buffer.TimeoutBuffer;
 
 /**
  * Provides utility methods and decorators for {@link Buffer} instances.
  *
  * @since Commons Collections 2.1
  * @version $Revision$ $Date$
- * 
+ *
  * @author Paul Jack
  * @author Stephen Colebourne
  */
@@ -48,10 +47,10 @@ public class BufferUtils {
     //-----------------------------------------------------------------------
     /**
      * Returns a synchronized buffer backed by the given buffer.
-     * Much like the synchronized collections returned by 
-     * {@link java.util.Collections}, you must manually synchronize on 
+     * Much like the synchronized collections returned by
+     * {@link java.util.Collections}, you must manually synchronize on
      * the returned buffer's iterator to avoid non-deterministic behavior:
-     *  
+     *
      * <pre>
      * Buffer b = BufferUtils.synchronizedBuffer(myBuffer);
      * synchronized (b) {
@@ -73,9 +72,9 @@ public class BufferUtils {
     /**
      * Returns a synchronized buffer backed by the given buffer that will
      * block on {@link Buffer#get()} and {@link Buffer#remove()} operations.
-     * If the buffer is empty, then the {@link Buffer#get()} and 
+     * If the buffer is empty, then the {@link Buffer#get()} and
      * {@link Buffer#remove()} operations will block until new elements
-     * are added to the buffer, rather than immediately throwing a 
+     * are added to the buffer, rather than immediately throwing a
      * <code>BufferUnderflowException</code>.
      *
      * @param buffer  the buffer to synchronize, must not be null
@@ -99,10 +98,10 @@ public class BufferUtils {
      * @throws IllegalArgumentException  if the Buffer is null
      * @since Commons Collections 3.2
      */
-    public static Buffer timeoutBuffer(Buffer buffer, long timeout) {
-        return TimeoutBuffer.decorate(buffer, timeout);
+    public static Buffer blockingBuffer(Buffer buffer, long timeout) {
+        return BlockingBuffer.decorate(buffer, timeout);
     }
-    
+
     /**
      * Returns an unmodifiable buffer backed by the given buffer.
      *
diff --git a/src/java/org/apache/commons/collections/buffer/BlockingBuffer.java b/src/java/org/apache/commons/collections/buffer/BlockingBuffer.java
index 048539529..de115bec1 100644
--- a/src/java/org/apache/commons/collections/buffer/BlockingBuffer.java
+++ b/src/java/org/apache/commons/collections/buffer/BlockingBuffer.java
@@ -15,41 +15,42 @@
  */
 package org.apache.commons.collections.buffer;
 
+import org.apache.commons.collections.Buffer;
+import org.apache.commons.collections.BufferUnderflowException;
+
 import java.io.PrintWriter;
 import java.io.StringWriter;
 import java.util.Collection;
 
-import org.apache.commons.collections.Buffer;
-import org.apache.commons.collections.BufferUnderflowException;
-
 /**
- * Decorates another <code>Buffer</code> to make {@link #get()} and
- * {@link #remove()} block when the <code>Buffer</code> is empty.
- * <p>
- * If either <code>get</code> or <code>remove</code> is called on an empty
- * <code>Buffer</code>, the calling thread waits for notification that
- * an <code>add</code> or <code>addAll</code> operation has completed.
- * <p>
- * When one or more entries are added to an empty <code>Buffer</code>,
- * all threads blocked in <code>get</code> or <code>remove</code> are notified.
- * There is no guarantee that concurrent blocked <code>get</code> or
- * <code>remove</code> requests will be "unblocked" and receive data in the
- * order that they arrive.
- * <p>
+ * Decorates another <code>Buffer</code> to make {@link #get()} and {@link #remove()} block when the <code>Buffer</code>
+ * is empty.
+ * <p/>
+ * If either <code>get</code> or <code>remove</code> is called on an empty <code>Buffer</code>, the calling thread waits
+ * for notification that an <code>add</code> or <code>addAll</code> operation has completed.
+ * <p/>
+ * When one or more entries are added to an empty <code>Buffer</code>, all threads blocked in <code>get</code> or
+ * <code>remove</code> are notified. There is no guarantee that concurrent blocked <code>get</code> or
+ * <code>remove</code> requests will be "unblocked" and receive data in the order that they arrive.
+ * <p/>
  * This class is Serializable from Commons Collections 3.1.
  *
  * @author Stephen Colebourne
  * @author Janek Bogucki
  * @author Phil Steitz
+ * @author James Carman
  * @version $Revision$ $Date$
  * @since Commons Collections 3.0
  */
 public class BlockingBuffer extends SynchronizedBuffer {
+
     /**
      * Serialization version
      */
     private static final long serialVersionUID = 1719328905017860541L;
 
+    private long timeout;
+
     /**
      * Factory method to create a blocking buffer.
      *
@@ -57,53 +58,83 @@ public class BlockingBuffer extends SynchronizedBuffer {
      * @return a new blocking Buffer
      * @throws IllegalArgumentException if buffer is null
      */
-    public static Buffer decorate(Buffer buffer) {
-        return new BlockingBuffer(buffer);
+    public static Buffer decorate( Buffer buffer ) {
+        return new BlockingBuffer( buffer );
     }
 
-    //-----------------------------------------------------------------------    
+    /**
+     * Factory method to create a blocking buffer with a timeout value.
+     *
+     * @param buffer  the buffer to decorate, must not be null
+     * @param timeout the maximum amount of time to block
+     * @return a new blocking buffer
+     * @throws IllegalArgumentException if the buffer is null
+     */
+    public static Buffer decorate( Buffer buffer, long timeout ) {
+        return new BlockingBuffer( buffer, timeout );
+    }
+
+    //-----------------------------------------------------------------------
+
     /**
      * Constructor that wraps (not copies).
      *
      * @param buffer the buffer to decorate, must not be null
      * @throws IllegalArgumentException if the buffer is null
      */
-    protected BlockingBuffer(Buffer buffer) {
-        super(buffer);
+    protected BlockingBuffer( Buffer buffer ) {
+        super( buffer );
+    }
+
+    /**
+     * Constructor that wraps (not copies).
+     *
+     * @param buffer  the buffer to decorate, must not be null
+     * @param timeout the maximum amount of time to block
+     * @throws IllegalArgumentException if the buffer is null
+     */
+    protected BlockingBuffer( Buffer buffer, long timeout ) {
+        super( buffer );
+        this.timeout = timeout < 0 ? 0 : timeout;
     }
 
     //-----------------------------------------------------------------------
-    public boolean add(Object o) {
-        synchronized (lock) {
-            boolean result = collection.add(o);
+    public boolean add( Object o ) {
+        synchronized( lock ) {
+            boolean result = collection.add( o );
             lock.notifyAll();
             return result;
         }
     }
 
-    public boolean addAll(Collection c) {
-        synchronized (lock) {
-            boolean result = collection.addAll(c);
+    public boolean addAll( Collection c ) {
+        synchronized( lock ) {
+            boolean result = collection.addAll( c );
             lock.notifyAll();
             return result;
         }
     }
 
     /**
-     * Gets the next value from the buffer, waiting until an object is
-     * added if the buffer is empty.
+     * Gets the next value from the buffer, waiting until an object is added if the buffer is empty.
      *
      * @throws BufferUnderflowException if an interrupt is received
      */
     public Object get() {
-        synchronized (lock) {
-            while (collection.isEmpty()) {
+        synchronized( lock ) {
+            while( collection.isEmpty() ) {
                 try {
-                    lock.wait();
-                } catch (InterruptedException e) {
-                    PrintWriter out = new PrintWriter(new StringWriter());
-                    e.printStackTrace(out);
-                    throw new BufferUnderflowException("Caused by InterruptedException: " + out.toString());
+                    if( timeout <= 0 ) {
+                        lock.wait();
+                    }
+                    else {
+                        return get( timeout );
+                    }
+                }
+                catch( InterruptedException e ) {
+                    PrintWriter out = new PrintWriter( new StringWriter() );
+                    e.printStackTrace( out );
+                    throw new BufferUnderflowException( "Caused by InterruptedException: " + out.toString() );
                 }
             }
             return getBuffer().get();
@@ -111,50 +142,56 @@ public class BlockingBuffer extends SynchronizedBuffer {
     }
 
     /**
-     * Gets the next value from the buffer, waiting until an object is
-     * added for up to the specified timeout value if the buffer is empty.
+     * Gets the next value from the buffer, waiting until an object is added for up to the specified timeout value if
+     * the buffer is empty.
      *
-     * @param timeout  the timeout value in milliseconds
+     * @param timeout the timeout value in milliseconds
      * @throws BufferUnderflowException if an interrupt is received
      * @throws BufferUnderflowException if the timeout expires
      * @since Commons Collections 3.2
      */
-    public Object get(final long timeout) {
-        synchronized (lock) {
+    public Object get( final long timeout ) {
+        synchronized( lock ) {
             final long expiration = System.currentTimeMillis() + timeout;
             long timeLeft = expiration - System.currentTimeMillis();
-            while (timeLeft > 0 && collection.isEmpty()) {
+            while( timeLeft > 0 && collection.isEmpty() ) {
                 try {
-                    lock.wait(timeLeft);
+                    lock.wait( timeLeft );
                     timeLeft = expiration - System.currentTimeMillis();
-                } catch(InterruptedException e) {
-                    PrintWriter out = new PrintWriter(new StringWriter());
-                    e.printStackTrace(out);
-                    throw new BufferUnderflowException("Caused by InterruptedException: " + out.toString());
+                }
+                catch( InterruptedException e ) {
+                    PrintWriter out = new PrintWriter( new StringWriter() );
+                    e.printStackTrace( out );
+                    throw new BufferUnderflowException( "Caused by InterruptedException: " + out.toString() );
                 }
             }
-            if (collection.isEmpty()) {
-                throw new BufferUnderflowException("Timeout expired.");
+            if( collection.isEmpty() ) {
+                throw new BufferUnderflowException( "Timeout expired." );
             }
             return getBuffer().get();
         }
     }
 
     /**
-     * Removes the next value from the buffer, waiting until an object is
-     * added if the buffer is empty.
+     * Removes the next value from the buffer, waiting until an object is added if the buffer is empty.
      *
      * @throws BufferUnderflowException if an interrupt is received
      */
     public Object remove() {
-        synchronized (lock) {
-            while (collection.isEmpty()) {
+        synchronized( lock ) {
+            while( collection.isEmpty() ) {
                 try {
-                    lock.wait();
-                } catch (InterruptedException e) {
-                    PrintWriter out = new PrintWriter(new StringWriter());
-                    e.printStackTrace(out);
-                    throw new BufferUnderflowException("Caused by InterruptedException: " + out.toString());
+                    if( timeout <= 0 ) {
+                        lock.wait();
+                    }
+                    else {
+                        return remove( timeout );
+                    }
+                }
+                catch( InterruptedException e ) {
+                    PrintWriter out = new PrintWriter( new StringWriter() );
+                    e.printStackTrace( out );
+                    throw new BufferUnderflowException( "Caused by InterruptedException: " + out.toString() );
                 }
             }
             return getBuffer().remove();
@@ -162,33 +199,33 @@ public class BlockingBuffer extends SynchronizedBuffer {
     }
 
     /**
-     * Removes the next value from the buffer, waiting until an object is
-     * added for up to the specified timeout value if the buffer is empty.
+     * Removes the next value from the buffer, waiting until an object is added for up to the specified timeout value if
+     * the buffer is empty.
      *
-     * @param timeout  the timeout value in milliseconds
+     * @param timeout the timeout value in milliseconds
      * @throws BufferUnderflowException if an interrupt is received
      * @throws BufferUnderflowException if the timeout expires
      * @since Commons Collections 3.2
      */
-    public Object remove(final long timeout) {
-        synchronized (lock) {
+    public Object remove( final long timeout ) {
+        synchronized( lock ) {
             final long expiration = System.currentTimeMillis() + timeout;
             long timeLeft = expiration - System.currentTimeMillis();
-            while (timeLeft > 0 && collection.isEmpty()) {
+            while( timeLeft > 0 && collection.isEmpty() ) {
                 try {
-                    lock.wait(timeLeft);
+                    lock.wait( timeLeft );
                     timeLeft = expiration - System.currentTimeMillis();
-                } catch(InterruptedException e) {
-                    PrintWriter out = new PrintWriter(new StringWriter());
-                    e.printStackTrace(out);
-                    throw new BufferUnderflowException("Caused by InterruptedException: " + out.toString());
+                }
+                catch( InterruptedException e ) {
+                    PrintWriter out = new PrintWriter( new StringWriter() );
+                    e.printStackTrace( out );
+                    throw new BufferUnderflowException( "Caused by InterruptedException: " + out.toString() );
                 }
             }
-            if (collection.isEmpty()) {
-                throw new BufferUnderflowException("Timeout expired.");
+            if( collection.isEmpty() ) {
+                throw new BufferUnderflowException( "Timeout expired." );
             }
             return getBuffer().remove();
         }
     }
-
 }
diff --git a/src/test/org/apache/commons/collections/buffer/TestBlockingBuffer.java b/src/test/org/apache/commons/collections/buffer/TestBlockingBuffer.java
index c51b24deb..2e0f8250e 100644
--- a/src/test/org/apache/commons/collections/buffer/TestBlockingBuffer.java
+++ b/src/test/org/apache/commons/collections/buffer/TestBlockingBuffer.java
@@ -15,46 +15,43 @@
  */
 package org.apache.commons.collections.buffer;
 
+import junit.framework.Test;
+import junit.framework.TestSuite;
+import org.apache.commons.collections.AbstractTestObject;
+import org.apache.commons.collections.Buffer;
+import org.apache.commons.collections.BufferUnderflowException;
+
 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.HashSet;
 import java.util.LinkedList;
 import java.util.Set;
 
-import junit.framework.Test;
-import junit.framework.TestSuite;
-
-import org.apache.commons.collections.AbstractTestObject;
-import org.apache.commons.collections.Buffer;
-import org.apache.commons.collections.BufferUnderflowException;
-
 /**
- * Extension of {@link TestObject} for exercising the {@link BlockingBuffer}
- * implementation.
+ * Extension of {@link AbstractTestObject} for exercising the {@link BlockingBuffer} implementation.
  *
- * @since Commons Collections 3.0
- * @version $Revision$
- * 
  * @author Janek Bogucki
  * @author Phil Steitz
+ * @version $Revision$
+ * @since Commons Collections 3.0
  */
 public class TestBlockingBuffer extends AbstractTestObject {
 
-    public TestBlockingBuffer(String testName) {
-        super(testName);
+    public TestBlockingBuffer( String testName ) {
+        super( testName );
     }
 
     public static Test suite() {
-        return new TestSuite(TestBlockingBuffer.class);
+        return new TestSuite( TestBlockingBuffer.class );
     }
 
-    public static void main(String args[]) {
-        String[] testCaseName = { TestBlockingBuffer.class.getName()};
-        junit.textui.TestRunner.main(testCaseName);
+    public static void main( String args[] ) {
+        String[] testCaseName = {TestBlockingBuffer.class.getName()};
+        junit.textui.TestRunner.main( testCaseName );
     }
 
     public Object makeObject() {
-        return BlockingBuffer.decorate(new MyBuffer());
+        return BlockingBuffer.decorate( new MyBuffer() );
     }
 
     public boolean isEqualsCheckable() {
@@ -62,446 +59,499 @@ public class TestBlockingBuffer extends AbstractTestObject {
     }
 
     //-----------------------------------------------------------------------
+
     /**
-     *  Tests {@link BlockingBuffer#get()} in combination with {@link BlockingBuffer#add()}.
+     * Tests {@link BlockingBuffer#get()} in combination with {@link BlockingBuffer#add(Object)}.
      */
     public void testGetWithAdd() {
-      
-        Buffer blockingBuffer = BlockingBuffer.decorate(new MyBuffer());
+        Buffer blockingBuffer = BlockingBuffer.decorate( new MyBuffer() );
         Object obj = new Object();
-
-        new DelayedAdd(blockingBuffer, obj).start();
+        new DelayedAdd( blockingBuffer, obj ).start();
 
         // verify does not throw BufferUnderflowException; should block until other thread has added to the buffer .
-        assertSame(obj, blockingBuffer.get());
+        assertSame( obj, blockingBuffer.get() );
+    }
+
+    public void testGetWithAddTimeout() {
+        Buffer blockingBuffer = BlockingBuffer.decorate( new MyBuffer(), 500 );
+        Object obj = new Object();
+        new DelayedAdd( blockingBuffer, obj, 100 ).start();
+
+        // verify does not throw BufferUnderflowException; should block until other thread has added to the buffer .
+        assertSame( obj, blockingBuffer.get() );
     }
 
     //-----------------------------------------------------------------------
+
     /**
-     *  Tests {@link BlockingBuffer#get()} in combination with {@link BlockingBuffer#addAll()}.
+     * Tests {@link BlockingBuffer#get()} in combination with {@link BlockingBuffer#addAll(java.util.Collection)}.
      */
     public void testGetWithAddAll() {
-        
-        Buffer blockingBuffer = BlockingBuffer.decorate(new MyBuffer());
+        Buffer blockingBuffer = BlockingBuffer.decorate( new MyBuffer() );
         Object obj = new Object();
-
-        new DelayedAddAll(blockingBuffer, obj).start();
+        new DelayedAddAll( blockingBuffer, obj ).start();
 
         // verify does not throw BufferUnderflowException; should block until other thread has added to the buffer .
-        assertSame(obj, blockingBuffer.get());
+        assertSame( obj, blockingBuffer.get() );
+    }
+
+    public void testGetWithAddAllTimeout() {
+        Buffer blockingBuffer = BlockingBuffer.decorate( new MyBuffer(), 500 );
+        Object obj = new Object();
+        new DelayedAddAll( blockingBuffer, obj, 100 ).start();
+
+        // verify does not throw BufferUnderflowException; should block until other thread has added to the buffer .
+        assertSame( obj, blockingBuffer.get() );
     }
 
     //-----------------------------------------------------------------------
+
     /**
-     *  Tests {@link BlockingBuffer#remove()} in combination with {@link BlockingBuffer#add()}.
+     * Tests {@link BlockingBuffer#remove()} in combination with {@link BlockingBuffer#add(Object)}.
      */
     public void testRemoveWithAdd() {
-        
-        Buffer blockingBuffer = BlockingBuffer.decorate(new MyBuffer());
+        Buffer blockingBuffer = BlockingBuffer.decorate( new MyBuffer() );
         Object obj = new Object();
-
-        new DelayedAdd(blockingBuffer, obj).start();
+        new DelayedAdd( blockingBuffer, obj ).start();
 
         // verify does not throw BufferUnderflowException; should block until other thread has added to the buffer .
-        assertSame(obj, blockingBuffer.remove());
+        assertSame( obj, blockingBuffer.remove() );
     }
 
+    public void testRemoveWithAddTimeout() {
+        Buffer blockingBuffer = BlockingBuffer.decorate( new MyBuffer(), 100 );
+        Object obj = new Object();
+        new DelayedAdd( blockingBuffer, obj, 500 ).start();
+        try {
+            blockingBuffer.remove();
+        }
+        catch( BufferUnderflowException e ) {
+        }
+    }
     //-----------------------------------------------------------------------
+
     /**
-     *  Tests {@link BlockingBuffer#remove()} in combination with {@link BlockingBuffer#addAll()}.
+     * Tests {@link BlockingBuffer#remove()} in combination with {@link BlockingBuffer#addAll(java.util.Collection)}.
      */
     public void testRemoveWithAddAll() {
-        
-        Buffer blockingBuffer = BlockingBuffer.decorate(new MyBuffer());
+        Buffer blockingBuffer = BlockingBuffer.decorate( new MyBuffer() );
         Object obj = new Object();
-
-        new DelayedAddAll(blockingBuffer, obj).start();
+        new DelayedAddAll( blockingBuffer, obj ).start();
 
         // verify does not throw BufferUnderflowException; should block until other thread has added to the buffer .
-        assertSame(obj, blockingBuffer.remove());
+        assertSame( obj, blockingBuffer.remove() );
     }
 
+    public void testRemoveWithAddAllTimeout() {
+        Buffer blockingBuffer = BlockingBuffer.decorate( new MyBuffer(), 100 );
+        Object obj = new Object();
+        new DelayedAddAll( blockingBuffer, obj, 500 ).start();
+        try {
+            blockingBuffer.remove();
+        }
+        catch( BufferUnderflowException e ) {
+        }
+    }
     //-----------------------------------------------------------------------
+
     /**
-     *  Tests {@link BlockingBuffer#get()} in combination with {@link BlockingBuffer#add()} using multiple read threads.
-     *
-     *  Two read threads should block on an empty buffer until one object
-     *  is added then both threads should complete.
+     * Tests {@link BlockingBuffer#get()} in combination with {@link BlockingBuffer#add(Object)} using multiple read
+     * threads.
+     * <p/>
+     * Two read threads should block on an empty buffer until one object is added then both threads should complete.
      */
     public void testBlockedGetWithAdd() {
-        
-        Buffer blockingBuffer = BlockingBuffer.decorate(new MyBuffer());
+        Buffer blockingBuffer = BlockingBuffer.decorate( new MyBuffer() );
         Object obj = new Object();
-        
+
         // run methods will get and compare -- must wait for add
-        Thread thread1 = new ReadThread(blockingBuffer, obj);
-        Thread thread2 = new ReadThread(blockingBuffer, obj);
+        Thread thread1 = new ReadThread( blockingBuffer, obj );
+        Thread thread2 = new ReadThread( blockingBuffer, obj );
         thread1.start();
         thread2.start();
-        
+
         // give hungry read threads ample time to hang
         delay();
-           
+
         // notifyAll should allow both read threads to complete
-        blockingBuffer.add(obj);
-        
+        blockingBuffer.add( obj );
+
         // allow notified threads to complete 
         delay();
-        
+
         // There should not be any threads waiting.
-        if (thread1.isAlive() || thread2.isAlive())
-            fail("Live thread(s) when both should be dead.");
+        if( thread1.isAlive() || thread2.isAlive() ) {
+            fail( "Live thread(s) when both should be dead." );
+        }
     }
-    
+
     //-----------------------------------------------------------------------
+
     /**
-     *  Tests {@link BlockingBuffer#get()} in combination with {@link BlockingBuffer#addAll()} using multiple read threads.
-     *
-     *  Two read threads should block on an empty buffer until a
-     *  singleton is added then both threads should complete.
+     * Tests {@link BlockingBuffer#get()} in combination with {@link BlockingBuffer#addAll(java.util.Collection)} using
+     * multiple read threads.
+     * <p/>
+     * Two read threads should block on an empty buffer until a singleton is added then both threads should complete.
      */
     public void testBlockedGetWithAddAll() {
-        
-        Buffer blockingBuffer = BlockingBuffer.decorate(new MyBuffer());
+        Buffer blockingBuffer = BlockingBuffer.decorate( new MyBuffer() );
         Object obj = new Object();
-        
+
         // run methods will get and compare -- must wait for addAll
-        Thread thread1 = new ReadThread(blockingBuffer, obj);
-        Thread thread2 = new ReadThread(blockingBuffer, obj);
+        Thread thread1 = new ReadThread( blockingBuffer, obj );
+        Thread thread2 = new ReadThread( blockingBuffer, obj );
         thread1.start();
         thread2.start();
-        
+
         // give hungry read threads ample time to hang
         delay();
-           
+
         // notifyAll should allow both read threads to complete
-        blockingBuffer.addAll(Collections.singleton(obj));
-               
+        blockingBuffer.addAll( Collections.singleton( obj ) );
+
         // allow notified threads to complete 
         delay();
-        
+
         // There should not be any threads waiting.
-        if (thread1.isAlive() || thread2.isAlive())
-            fail("Live thread(s) when both should be dead.");
+        if( thread1.isAlive() || thread2.isAlive() ) {
+            fail( "Live thread(s) when both should be dead." );
+        }
     }
-    
+
     //-----------------------------------------------------------------------
+
     /**
-     *  Tests interrupted {@link BlockingBuffer#get()}.
+     * Tests interrupted {@link BlockingBuffer#get()}.
      */
     public void testInterruptedGet() {
-        
-        Buffer blockingBuffer = BlockingBuffer.decorate(new MyBuffer());
+        Buffer blockingBuffer = BlockingBuffer.decorate( new MyBuffer() );
         Object obj = new Object();
-        
+
         // spawn a read thread to wait on the empty buffer
         ArrayList exceptionList = new ArrayList();
-        Thread thread = new ReadThread(blockingBuffer, obj, exceptionList);
+        Thread thread = new ReadThread( blockingBuffer, obj, exceptionList );
         thread.start();
-        
+
         // Interrupting the thread should cause it to throw BufferUnderflowException
         thread.interrupt();
-        
+
         // Chill, so thread can throw and add message to exceptionList
         delay();
-        
-        assertTrue("Thread interrupt should have led to underflow", 
-            exceptionList.contains("BufferUnderFlow"));
-        
-        if (thread.isAlive()) {
-            fail("Read thread has hung.");
+        assertTrue( "Thread interrupt should have led to underflow",
+                    exceptionList.contains( "BufferUnderFlow" ) );
+        if( thread.isAlive() ) {
+            fail( "Read thread has hung." );
         }
-        
+
     }
-    
+
     //-----------------------------------------------------------------------
+
     /**
-     *  Tests {@link BlockingBuffer#remove()} in combination with {@link BlockingBuffer#add()} using multiple read threads.
-     *
-     *  Two read threads should block on an empty buffer until one
-     *  object is added then one thread should complete. The remaining
-     *  thread should complete after the addition of a second object.
+     * Tests {@link BlockingBuffer#remove()} in combination with {@link BlockingBuffer#add(Object)} using multiple read
+     * threads.
+     * <p/>
+     * Two read threads should block on an empty buffer until one object is added then one thread should complete. The
+     * remaining thread should complete after the addition of a second object.
      */
     public void testBlockedRemoveWithAdd() {
-        
-        Buffer blockingBuffer = BlockingBuffer.decorate(new MyBuffer());
+        Buffer blockingBuffer = BlockingBuffer.decorate( new MyBuffer() );
         Object obj = new Object();
-        
+
         // run methods will remove and compare -- must wait for add
-        Thread thread1 = new ReadThread(blockingBuffer, obj, null, "remove");
-        Thread thread2 = new ReadThread(blockingBuffer, obj, null, "remove");
+        Thread thread1 = new ReadThread( blockingBuffer, obj, null, "remove" );
+        Thread thread2 = new ReadThread( blockingBuffer, obj, null, "remove" );
         thread1.start();
         thread2.start();
-        
+
         // give hungry read threads ample time to hang
         delay();
-           
-        blockingBuffer.add(obj);
-        
+        blockingBuffer.add( obj );
+
         // allow notified threads to complete 
         delay();
-        
+
         // There should be one thread waiting.
-        assertTrue ("There is one thread waiting", thread1.isAlive() ^ thread2.isAlive());
-           
-        blockingBuffer.add(obj);
-        
+        assertTrue( "There is one thread waiting", thread1.isAlive() ^ thread2.isAlive() );
+        blockingBuffer.add( obj );
+
         // allow notified thread to complete 
         delay();
 
         // There should not be any threads waiting.
-        if(thread1.isAlive() || thread2.isAlive())
-            fail("Live thread(s) when both should be dead.");
+        if( thread1.isAlive() || thread2.isAlive() ) {
+            fail( "Live thread(s) when both should be dead." );
+        }
     }
 
     //-----------------------------------------------------------------------
+
     /**
-     *  Tests {@link BlockingBuffer#remove()} in combination with {@link BlockingBuffer#addAll()} using multiple read threads.
-     *
-     *  Two read threads should block on an empty buffer until a
-     *  singleton collection is added then one thread should
-     *  complete. The remaining thread should complete after the
-     *  addition of a second singleton.
+     * Tests {@link BlockingBuffer#remove()} in combination with {@link BlockingBuffer#addAll(java.util.Collection)}
+     * using multiple read threads.
+     * <p/>
+     * Two read threads should block on an empty buffer until a singleton collection is added then one thread should
+     * complete. The remaining thread should complete after the addition of a second singleton.
      */
     public void testBlockedRemoveWithAddAll1() {
-        
-        Buffer blockingBuffer = BlockingBuffer.decorate(new MyBuffer());
+        Buffer blockingBuffer = BlockingBuffer.decorate( new MyBuffer() );
         Object obj = new Object();
-        
+
         // run methods will remove and compare -- must wait for addAll
-        Thread thread1 = new ReadThread(blockingBuffer, obj, null, "remove");
-        Thread thread2 = new ReadThread(blockingBuffer, obj, null, "remove");
+        Thread thread1 = new ReadThread( blockingBuffer, obj, null, "remove" );
+        Thread thread2 = new ReadThread( blockingBuffer, obj, null, "remove" );
         thread1.start();
         thread2.start();
-        
+
         // give hungry read threads ample time to hang
         delay();
-           
-        blockingBuffer.addAll(Collections.singleton(obj));
-        
+        blockingBuffer.addAll( Collections.singleton( obj ) );
+
         // allow notified threads to complete 
         delay();
-        
+
         // There should be one thread waiting.
-        assertTrue ("There is one thread waiting", thread1.isAlive() ^ thread2.isAlive());
-           
-        blockingBuffer.addAll(Collections.singleton(obj));
-        
+        assertTrue( "There is one thread waiting", thread1.isAlive() ^ thread2.isAlive() );
+        blockingBuffer.addAll( Collections.singleton( obj ) );
+
         // allow notified thread to complete 
         delay();
 
         // There should not be any threads waiting.
-        if(thread1.isAlive() || thread2.isAlive())
-            fail("Live thread(s) when both should be dead.");
+        if( thread1.isAlive() || thread2.isAlive() ) {
+            fail( "Live thread(s) when both should be dead." );
+        }
     }
 
-   
     //-----------------------------------------------------------------------
+
     /**
-     *  Tests {@link BlockingBuffer#remove()} in combination with {@link BlockingBuffer#addAll()} using multiple read threads.
-     *
-     *  Two read threads should block on an empty buffer until a
-     *  collection with two distinct objects is added then both
-     *  threads should complete. Each thread should have read a
-     *  different object.
+     * Tests {@link BlockingBuffer#remove()} in combination with {@link BlockingBuffer#addAll(java.util.Collection)}
+     * using multiple read threads.
+     * <p/>
+     * Two read threads should block on an empty buffer until a collection with two distinct objects is added then both
+     * threads should complete. Each thread should have read a different object.
      */
     public void testBlockedRemoveWithAddAll2() {
-        
-        Buffer blockingBuffer = BlockingBuffer.decorate(new MyBuffer());
+        Buffer blockingBuffer = BlockingBuffer.decorate( new MyBuffer() );
         Object obj1 = new Object();
         Object obj2 = new Object();
-        
-        Set objs = Collections.synchronizedSet(new HashSet());
-        objs.add(obj1);
-        objs.add(obj2);
+        Set objs = Collections.synchronizedSet( new HashSet() );
+        objs.add( obj1 );
+        objs.add( obj2 );
 
         // run methods will remove and compare -- must wait for addAll
-        Thread thread1 = new ReadThread(blockingBuffer, objs, "remove");
-        Thread thread2 = new ReadThread(blockingBuffer, objs, "remove");
+        Thread thread1 = new ReadThread( blockingBuffer, objs, "remove" );
+        Thread thread2 = new ReadThread( blockingBuffer, objs, "remove" );
         thread1.start();
         thread2.start();
-        
+
         // give hungry read threads ample time to hang
         delay();
-           
-        blockingBuffer.addAll(objs);
-        
+        blockingBuffer.addAll( objs );
+
         // allow notified threads to complete 
         delay();
-        
-        assertEquals("Both objects were removed", 0, objs.size());
+        assertEquals( "Both objects were removed", 0, objs.size() );
 
         // There should not be any threads waiting.
-        if(thread1.isAlive() || thread2.isAlive())
-            fail("Live thread(s) when both should be dead.");
+        if( thread1.isAlive() || thread2.isAlive() ) {
+            fail( "Live thread(s) when both should be dead." );
+        }
     }
 
     //-----------------------------------------------------------------------
+
     /**
-     *  Tests interrupted remove.
+     * Tests interrupted remove.
      */
     public void testInterruptedRemove() {
-        
-        Buffer blockingBuffer = BlockingBuffer.decorate(new MyBuffer());
+        Buffer blockingBuffer = BlockingBuffer.decorate( new MyBuffer() );
         Object obj = new Object();
-        
+
         // spawn a read thread to wait on the empty buffer
         ArrayList exceptionList = new ArrayList();
-        Thread thread = new ReadThread(blockingBuffer, obj, exceptionList, "remove");
+        Thread thread = new ReadThread( blockingBuffer, obj, exceptionList, "remove" );
         thread.start();
-        
+
         // Interrupting the thread should cause it to throw BufferUnderflowException
         thread.interrupt();
-        
+
         // Chill, so thread can throw and add message to exceptionList
         delay();
-        
-        assertTrue("Thread interrupt should have led to underflow", 
-            exceptionList.contains("BufferUnderFlow"));
-        
-        if (thread.isAlive()) {
-            fail("Read thread has hung.");
+        assertTrue( "Thread interrupt should have led to underflow",
+                    exceptionList.contains( "BufferUnderFlow" ) );
+        if( thread.isAlive() ) {
+            fail( "Read thread has hung." );
         }
-        
+
     }
 
     public void testTimeoutGet() {
-        final BlockingBuffer buffer = new BlockingBuffer(new MyBuffer());
+        final BlockingBuffer buffer = new BlockingBuffer( new MyBuffer() );
         try {
             buffer.get( 100 );
             fail( "Get should have timed out." );
         }
-        catch( BufferUnderflowException e ){
+        catch( BufferUnderflowException e ) {
         }
     }
 
     public void testTimeoutRemove() {
-        final BlockingBuffer buffer = new BlockingBuffer(new MyBuffer());
+        final BlockingBuffer buffer = new BlockingBuffer( new MyBuffer() );
         try {
             buffer.remove( 100 );
             fail( "Get should have timed out." );
         }
-        catch( BufferUnderflowException e ){
+        catch( BufferUnderflowException e ) {
         }
     }
+
     protected static class DelayedAdd extends Thread {
 
         Buffer buffer;
+
         Object obj;
 
-        DelayedAdd (Buffer buffer, Object obj) {
+        long delay = 1000;
+
+        public DelayedAdd( Buffer buffer, Object obj, long delay ) {
+            this.buffer = buffer;
+            this.obj = obj;
+            this.delay = delay;
+        }
+
+        DelayedAdd( Buffer buffer, Object obj ) {
             super();
             this.buffer = buffer;
             this.obj = obj;
         }
-                
-        public void run() {
 
+        public void run() {
             try {
                 // wait for other thread to block on get() or remove()
-                Thread.sleep(100);
+                Thread.sleep( delay );
             }
-            catch (InterruptedException e) {}
-
-            buffer.add(obj);
+            catch( InterruptedException e ) {
+            }
+            buffer.add( obj );
         }
     }
-    
+
     protected static class DelayedAddAll extends Thread {
 
         Buffer buffer;
+
         Object obj;
 
-        DelayedAddAll (Buffer buffer, Object obj) {
+        long delay = 100;
+
+        public DelayedAddAll( Buffer buffer, Object obj, long delay ) {
+            this.buffer = buffer;
+            this.obj = obj;
+            this.delay = delay;
+        }
+
+        DelayedAddAll( Buffer buffer, Object obj ) {
             super();
             this.buffer = buffer;
             this.obj = obj;
         }
-                
-        public void run() {
 
+        public void run() {
             try {
                 // wait for other thread to block on get() or remove()
-                Thread.sleep(100);
+                Thread.sleep( delay );
             }
-            catch (InterruptedException e) {}
-
-            buffer.addAll(Collections.singleton(obj));
+            catch( InterruptedException e ) {
+            }
+            buffer.addAll( Collections.singleton( obj ) );
         }
     }
-    
+
     protected static class ReadThread extends Thread {
 
         Buffer buffer;
+
         Object obj;
+
         ArrayList exceptionList = null;
+
         String action = "get";
+
         Set objs;
-        
-        ReadThread (Buffer buffer, Object obj) {
+
+        ReadThread( Buffer buffer, Object obj ) {
             super();
             this.buffer = buffer;
             this.obj = obj;
         }
 
-        ReadThread (Buffer buffer, Object obj, ArrayList exceptionList) {
+        ReadThread( Buffer buffer, Object obj, ArrayList exceptionList ) {
             super();
             this.buffer = buffer;
             this.obj = obj;
             this.exceptionList = exceptionList;
         }
-        
-        ReadThread (Buffer buffer, Object obj, ArrayList exceptionList, String action) {
+
+        ReadThread( Buffer buffer, Object obj, ArrayList exceptionList, String action ) {
             super();
             this.buffer = buffer;
             this.obj = obj;
             this.exceptionList = exceptionList;
             this.action = action;
         }
-                
-        ReadThread (Buffer buffer, Set objs, String action) {
+
+        ReadThread( Buffer buffer, Set objs, String action ) {
             super();
             this.buffer = buffer;
             this.objs = objs;
             this.action = action;
         }
-                
-        public void run()  {
+
+        public void run() {
             try {
-                if (action == "get") {
-                    assertSame(obj, buffer.get());
-                } else {
-                    if (null != obj)
-                        assertSame(obj, buffer.remove());
-                    else
-                        assertTrue(objs.remove(buffer.remove()));
+                if( action == "get" ) {
+                    assertSame( obj, buffer.get() );
                 }
-            } catch (BufferUnderflowException ex) {
-                exceptionList.add("BufferUnderFlow");
+                else {
+                    if( null != obj ) {
+                        assertSame( obj, buffer.remove() );
+                    }
+                    else {
+                        assertTrue( objs.remove( buffer.remove() ) );
+                    }
+                }
+            }
+            catch( BufferUnderflowException ex ) {
+                exceptionList.add( "BufferUnderFlow" );
             }
         }
     }
-        
 
     protected static class MyBuffer extends LinkedList implements Buffer {
 
         public Object get() {
-            if(isEmpty())
+            if( isEmpty() ) {
                 throw new BufferUnderflowException();
-            return get(0);
+            }
+            return get( 0 );
         }
 
         public Object remove() {
-            if(isEmpty())
+            if( isEmpty() ) {
                 throw new BufferUnderflowException();
-            return remove(0);
+            }
+            return remove( 0 );
         }
     }
 
-    private void delay(){
+    private void delay() {
         try {
-            Thread.sleep(100);
-        } catch (InterruptedException e) {}
+            Thread.sleep( 100 );
+        }
+        catch( InterruptedException e ) {
+        }
     }
 
     public String getCompatibilityVersion() {
@@ -510,12 +560,13 @@ public class TestBlockingBuffer extends AbstractTestObject {
 
 //    public void testCreate() throws Exception {
 //        Buffer buffer = BlockingBuffer.decorate(new UnboundedFifoBuffer());
-//        writeExternalFormToDisk((java.io.Serializable) buffer, "D:/dev/collections/data/test/BlockingBuffer.emptyCollection.version3.1.obj");
+//        writeExternalFormToDisk((java.io.Serializable) buffer,
+//        "D:/dev/collections/data/test/BlockingBuffer.emptyCollection.version3.1.obj");
 //        buffer = BlockingBuffer.decorate(new UnboundedFifoBuffer());
 //        buffer.add("A");
 //        buffer.add("B");
 //        buffer.add("C");
-//        writeExternalFormToDisk((java.io.Serializable) buffer, "D:/dev/collections/data/test/BlockingBuffer.fullCollection.version3.1.obj");
+//        writeExternalFormToDisk((java.io.Serializable) buffer,
+//        "D:/dev/collections/data/test/BlockingBuffer.fullCollection.version3.1.obj");
 //    }
-
 }