/** * 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() ); 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" ); thread1.start(); thread2.start(); // give hungry read threads ample time to hang delay(); 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 ) ); // 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." ); } }
/** * 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() ); Object obj1 = new Object(); Object obj2 = new Object(); 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" ); thread1.start(); thread2.start(); // give hungry read threads ample time to hang delay(); blockingBuffer.addAll( objs ); // allow notified threads to complete delay(); 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." ); } }
/** * 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() ); 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" ); thread1.start(); thread2.start(); // give hungry read threads ample time to hang delay(); 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 ); // 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." ); } }
/** * 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() ); 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 ); thread1.start(); thread2.start(); // give hungry read threads ample time to hang delay(); // notifyAll should allow both read threads to complete 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." ); } }
/** * 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() ); 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 ); 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 ) ); // 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." ); } }
/** * Tests interrupted {@link BlockingBuffer#get()}. */ public void testInterruptedGet() { 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.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." ); } }
/** * Tests interrupted remove. */ public void testInterruptedRemove() { 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.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." ); } }
public Object makeObject() { return BlockingBuffer.decorate( new MyBuffer() ); }
public void testTimeoutRemove() { final BlockingBuffer buffer = new BlockingBuffer( new MyBuffer() ); try { buffer.remove( 100 ); fail( "Get should have timed out." ); } catch( BufferUnderflowException e ) { } }
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#remove()} in combination with {@link BlockingBuffer#addAll(java.util.Collection)}. */ public void testRemoveWithAddAll() { Buffer blockingBuffer = BlockingBuffer.decorate( new MyBuffer() ); Object obj = new Object(); new DelayedAddAll( blockingBuffer, obj ).start(); // verify does not throw BufferUnderflowException; should block until other thread has added to the buffer . assertSame( obj, blockingBuffer.remove() ); }
/** * Tests {@link BlockingBuffer#get()} in combination with {@link BlockingBuffer#addAll(java.util.Collection)}. */ public void testGetWithAddAll() { Buffer blockingBuffer = BlockingBuffer.decorate( new MyBuffer() ); Object obj = new Object(); new DelayedAddAll( blockingBuffer, obj ).start(); // verify does not throw BufferUnderflowException; should block until other thread has added to the buffer . assertSame( obj, blockingBuffer.get() ); }
public void testTimeoutGet() { final BlockingBuffer buffer = new BlockingBuffer( new MyBuffer() ); try { buffer.get( 100 ); fail( "Get should have timed out." ); } catch( BufferUnderflowException e ) { } }
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 ) { } } //-----------------------------------------------------------------------
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() ); }
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#add(Object)}. */ public void testGetWithAdd() { Buffer blockingBuffer = BlockingBuffer.decorate( new MyBuffer() ); Object obj = new Object(); new DelayedAdd( blockingBuffer, obj ).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(Object)}. */ public void testRemoveWithAdd() { Buffer blockingBuffer = BlockingBuffer.decorate( new MyBuffer() ); Object obj = new Object(); new DelayedAdd( blockingBuffer, obj ).start(); // verify does not throw BufferUnderflowException; should block until other thread has added to the buffer . assertSame( obj, blockingBuffer.remove() ); }