| Methods Summary |
|---|
| public static void | main(java.lang.String[] args)
junit.textui.TestRunner.run (suite());
|
| public static junit.framework.Test | suite()
return new TestSuite(SynchronousQueueTest.class);
|
| public void | testAdd()add throws ISE if no active taker
try {
SynchronousQueue q = new SynchronousQueue();
assertEquals(0, q.remainingCapacity());
q.add(one);
shouldThrow();
} catch (IllegalStateException success){
}
|
| public void | testAddAll1()addAll(null) throws NPE
try {
SynchronousQueue q = new SynchronousQueue();
q.addAll(null);
shouldThrow();
}
catch (NullPointerException success) {}
|
| public void | testAddAll2()addAll of a collection with null elements throws NPE
try {
SynchronousQueue q = new SynchronousQueue();
Integer[] ints = new Integer[1];
q.addAll(Arrays.asList(ints));
shouldThrow();
}
catch (NullPointerException success) {}
|
| public void | testAddAll4()addAll throws ISE if no active taker
try {
SynchronousQueue q = new SynchronousQueue();
Integer[] ints = new Integer[1];
for (int i = 0; i < 1; ++i)
ints[i] = new Integer(i);
q.addAll(Arrays.asList(ints));
shouldThrow();
}
catch (IllegalStateException success) {}
|
| public void | testAddAllSelf()addAll(this) throws IAE
try {
SynchronousQueue q = new SynchronousQueue();
q.addAll(q);
shouldThrow();
}
catch (IllegalArgumentException success) {}
|
| public void | testAddNull()add(null) throws NPE
try {
SynchronousQueue q = new SynchronousQueue();
q.add(null);
shouldThrow();
} catch (NullPointerException success) { }
|
| public void | testBlockingPut()put blocks interruptibly if no active taker
Thread t = new Thread(new Runnable() {
public void run() {
try {
SynchronousQueue q = new SynchronousQueue();
q.put(zero);
threadShouldThrow();
} catch (InterruptedException ie){
}
}});
t.start();
try {
Thread.sleep(SHORT_DELAY_MS);
t.interrupt();
t.join();
}
catch (InterruptedException ie) {
unexpectedException();
}
|
| public void | testClear()clear ensures isEmpty
SynchronousQueue q = new SynchronousQueue();
q.clear();
assertTrue(q.isEmpty());
|
| public void | testContains()contains returns false
SynchronousQueue q = new SynchronousQueue();
assertFalse(q.contains(zero));
|
| public void | testContainsAll()containsAll returns false unless empty
SynchronousQueue q = new SynchronousQueue();
Integer[] empty = new Integer[0];
assertTrue(q.containsAll(Arrays.asList(empty)));
Integer[] ints = new Integer[1]; ints[0] = zero;
assertFalse(q.containsAll(Arrays.asList(ints)));
|
| public void | testDrainTo()drainTo(c) of empty queue doesn't transfer elements
SynchronousQueue q = new SynchronousQueue();
ArrayList l = new ArrayList();
q.drainTo(l);
assertEquals(q.size(), 0);
assertEquals(l.size(), 0);
|
| public void | testDrainToN()drainTo(c, n) empties up to n elements of queue into c
final SynchronousQueue q = new SynchronousQueue();
Thread t1 = new Thread(new Runnable() {
public void run() {
try {
q.put(one);
} catch (InterruptedException ie){
threadUnexpectedException();
}
}
});
Thread t2 = new Thread(new Runnable() {
public void run() {
try {
q.put(two);
} catch (InterruptedException ie){
threadUnexpectedException();
}
}
});
try {
t1.start();
t2.start();
ArrayList l = new ArrayList();
Thread.sleep(SHORT_DELAY_MS);
q.drainTo(l, 1);
assertTrue(l.size() == 1);
q.drainTo(l, 1);
assertTrue(l.size() == 2);
assertTrue(l.contains(one));
assertTrue(l.contains(two));
t1.join();
t2.join();
} catch(Exception e){
unexpectedException();
}
|
| public void | testDrainToNull()drainTo(null) throws NPE
SynchronousQueue q = new SynchronousQueue();
try {
q.drainTo(null);
shouldThrow();
} catch(NullPointerException success) {
}
|
| public void | testDrainToNullN()drainTo(null, n) throws NPE
SynchronousQueue q = new SynchronousQueue();
try {
q.drainTo(null, 0);
shouldThrow();
} catch(NullPointerException success) {
}
|
| public void | testDrainToSelf()drainTo(this) throws IAE
SynchronousQueue q = new SynchronousQueue();
try {
q.drainTo(q);
shouldThrow();
} catch(IllegalArgumentException success) {
}
|
| public void | testDrainToSelfN()drainTo(this, n) throws IAE
SynchronousQueue q = new SynchronousQueue();
try {
q.drainTo(q, 0);
shouldThrow();
} catch(IllegalArgumentException success) {
}
|
| public void | testDrainToWithActivePut()drainTo empties queue, unblocking a waiting put.
final SynchronousQueue q = new SynchronousQueue();
Thread t = new Thread(new Runnable() {
public void run() {
try {
q.put(new Integer(1));
} catch (InterruptedException ie){
threadUnexpectedException();
}
}
});
try {
t.start();
ArrayList l = new ArrayList();
Thread.sleep(SHORT_DELAY_MS);
q.drainTo(l);
assertTrue(l.size() <= 1);
if (l.size() > 0)
assertEquals(l.get(0), new Integer(1));
t.join();
assertTrue(l.size() <= 1);
} catch(Exception e){
unexpectedException();
}
|
| public void | testElement()element throws NSEE
SynchronousQueue q = new SynchronousQueue();
try {
q.element();
shouldThrow();
}
catch (NoSuchElementException success) {}
|
| public void | testEmptyFull()A SynchronousQueue is both empty and full
SynchronousQueue q = new SynchronousQueue();
assertTrue(q.isEmpty());
assertEquals(0, q.size());
assertEquals(0, q.remainingCapacity());
assertFalse(q.offer(zero));
|
| public void | testFairBlockingPut()put blocks interruptibly if no active taker
Thread t = new Thread(new Runnable() {
public void run() {
try {
SynchronousQueue q = new SynchronousQueue(true);
q.put(zero);
threadShouldThrow();
} catch (InterruptedException ie){
}
}});
t.start();
try {
Thread.sleep(SHORT_DELAY_MS);
t.interrupt();
t.join();
}
catch (InterruptedException ie) {
unexpectedException();
}
|
| public void | testFairEmptyFull()A fair SynchronousQueue is both empty and full
SynchronousQueue q = new SynchronousQueue(true);
assertTrue(q.isEmpty());
assertEquals(0, q.size());
assertEquals(0, q.remainingCapacity());
assertFalse(q.offer(zero));
|
| public void | testFairInterruptedTimedPoll()Interrupted timed poll throws InterruptedException instead of
returning timeout status
Thread t = new Thread(new Runnable() {
public void run() {
try {
SynchronousQueue q = new SynchronousQueue(true);
assertNull(q.poll(SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
} catch (InterruptedException success){
}
}});
t.start();
try {
Thread.sleep(SHORT_DELAY_MS);
t.interrupt();
t.join();
}
catch (InterruptedException ie) {
unexpectedException();
}
|
| public void | testFairPutWithTake()put blocks waiting for take
final SynchronousQueue q = new SynchronousQueue(true);
Thread t = new Thread(new Runnable() {
public void run() {
int added = 0;
try {
q.put(new Object());
++added;
q.put(new Object());
++added;
q.put(new Object());
++added;
q.put(new Object());
++added;
threadShouldThrow();
} catch (InterruptedException e){
assertTrue(added >= 1);
}
}
});
try {
t.start();
Thread.sleep(SHORT_DELAY_MS);
q.take();
Thread.sleep(SHORT_DELAY_MS);
t.interrupt();
t.join();
} catch (Exception e){
unexpectedException();
}
|
| public void | testFairTakeFromEmpty()take blocks interruptibly when empty
final SynchronousQueue q = new SynchronousQueue(true);
Thread t = new Thread(new Runnable() {
public void run() {
try {
q.take();
threadShouldThrow();
} catch (InterruptedException success){ }
}
});
try {
t.start();
Thread.sleep(SHORT_DELAY_MS);
t.interrupt();
t.join();
} catch (Exception e){
unexpectedException();
}
|
| public void | testFairTimedOffer()timed offer times out if elements not taken
final SynchronousQueue q = new SynchronousQueue(true);
Thread t = new Thread(new Runnable() {
public void run() {
try {
threadAssertFalse(q.offer(new Object(), SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
q.offer(new Object(), LONG_DELAY_MS, TimeUnit.MILLISECONDS);
threadShouldThrow();
} catch (InterruptedException success){}
}
});
try {
t.start();
Thread.sleep(SMALL_DELAY_MS);
t.interrupt();
t.join();
} catch (Exception e){
unexpectedException();
}
|
| public void | testFairTimedPollWithOffer()timed poll before a delayed offer fails; after offer succeeds;
on interruption throws
final SynchronousQueue q = new SynchronousQueue(true);
Thread t = new Thread(new Runnable() {
public void run() {
try {
threadAssertNull(q.poll(SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
q.poll(LONG_DELAY_MS, TimeUnit.MILLISECONDS);
q.poll(LONG_DELAY_MS, TimeUnit.MILLISECONDS);
threadShouldThrow();
} catch (InterruptedException success) { }
}
});
try {
t.start();
Thread.sleep(SMALL_DELAY_MS);
assertTrue(q.offer(zero, SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
t.interrupt();
t.join();
} catch (Exception e){
unexpectedException();
}
|
| public void | testInterruptedTimedPoll()Interrupted timed poll throws InterruptedException instead of
returning timeout status
Thread t = new Thread(new Runnable() {
public void run() {
try {
SynchronousQueue q = new SynchronousQueue();
assertNull(q.poll(SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
} catch (InterruptedException success){
}
}});
t.start();
try {
Thread.sleep(SHORT_DELAY_MS);
t.interrupt();
t.join();
}
catch (InterruptedException ie) {
unexpectedException();
}
|
| public void | testIterator()iterator does not traverse any elements
SynchronousQueue q = new SynchronousQueue();
Iterator it = q.iterator();
assertFalse(it.hasNext());
try {
Object x = it.next();
shouldThrow();
}
catch (NoSuchElementException success) {}
|
| public void | testIteratorRemove()iterator remove throws ISE
SynchronousQueue q = new SynchronousQueue();
Iterator it = q.iterator();
try {
it.remove();
shouldThrow();
}
catch (IllegalStateException success) {}
|
| public void | testOffer()offer fails if no active taker
SynchronousQueue q = new SynchronousQueue();
assertFalse(q.offer(one));
|
| public void | testOfferInExecutor()offer transfers elements across Executor tasks
final SynchronousQueue q = new SynchronousQueue();
ExecutorService executor = Executors.newFixedThreadPool(2);
final Integer one = new Integer(1);
executor.execute(new Runnable() {
public void run() {
threadAssertFalse(q.offer(one));
try {
threadAssertTrue(q.offer(one, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS));
threadAssertEquals(0, q.remainingCapacity());
}
catch (InterruptedException e) {
threadUnexpectedException();
}
}
});
executor.execute(new Runnable() {
public void run() {
try {
Thread.sleep(SMALL_DELAY_MS);
threadAssertEquals(one, q.take());
}
catch (InterruptedException e) {
threadUnexpectedException();
}
}
});
joinPool(executor);
|
| public void | testOfferNull()offer(null) throws NPE
try {
SynchronousQueue q = new SynchronousQueue();
q.offer(null);
shouldThrow();
} catch (NullPointerException success) { }
|
| public void | testPeek()peek returns null
SynchronousQueue q = new SynchronousQueue();
assertNull(q.peek());
|
| public void | testPoll()poll fails unless active taker
SynchronousQueue q = new SynchronousQueue();
assertNull(q.poll());
|
| public void | testPollInExecutor()poll retrieves elements across Executor threads
final SynchronousQueue q = new SynchronousQueue();
ExecutorService executor = Executors.newFixedThreadPool(2);
executor.execute(new Runnable() {
public void run() {
threadAssertNull(q.poll());
try {
threadAssertTrue(null != q.poll(MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS));
threadAssertTrue(q.isEmpty());
}
catch (InterruptedException e) {
threadUnexpectedException();
}
}
});
executor.execute(new Runnable() {
public void run() {
try {
Thread.sleep(SMALL_DELAY_MS);
q.put(new Integer(1));
}
catch (InterruptedException e) {
threadUnexpectedException();
}
}
});
joinPool(executor);
|
| public void | testPutNull()put(null) throws NPE
try {
SynchronousQueue q = new SynchronousQueue();
q.put(null);
shouldThrow();
}
catch (NullPointerException success){
}
catch (InterruptedException ie) {
unexpectedException();
}
|
| public void | testPutWithTake()put blocks waiting for take
final SynchronousQueue q = new SynchronousQueue();
Thread t = new Thread(new Runnable() {
public void run() {
int added = 0;
try {
q.put(new Object());
++added;
q.put(new Object());
++added;
q.put(new Object());
++added;
q.put(new Object());
++added;
threadShouldThrow();
} catch (InterruptedException e){
assertTrue(added >= 1);
}
}
});
try {
t.start();
Thread.sleep(SHORT_DELAY_MS);
q.take();
Thread.sleep(SHORT_DELAY_MS);
t.interrupt();
t.join();
} catch (Exception e){
unexpectedException();
}
|
| public void | testRemove()remove throws NSEE if no active taker
SynchronousQueue q = new SynchronousQueue();
try {
q.remove();
shouldThrow();
} catch (NoSuchElementException success){
}
|
| public void | testRemoveAll()removeAll returns false
SynchronousQueue q = new SynchronousQueue();
Integer[] empty = new Integer[0];
assertFalse(q.removeAll(Arrays.asList(empty)));
Integer[] ints = new Integer[1]; ints[0] = zero;
assertFalse(q.containsAll(Arrays.asList(ints)));
|
| public void | testRemoveElement()remove(x) returns false
SynchronousQueue q = new SynchronousQueue();
assertFalse(q.remove(zero));
assertTrue(q.isEmpty());
|
| public void | testRetainAll()retainAll returns false
SynchronousQueue q = new SynchronousQueue();
Integer[] empty = new Integer[0];
assertFalse(q.retainAll(Arrays.asList(empty)));
Integer[] ints = new Integer[1]; ints[0] = zero;
assertFalse(q.retainAll(Arrays.asList(ints)));
|
| public void | testSerialization()a deserialized serialized queue is usable
SynchronousQueue q = new SynchronousQueue();
try {
ByteArrayOutputStream bout = new ByteArrayOutputStream(10000);
ObjectOutputStream out = new ObjectOutputStream(new BufferedOutputStream(bout));
out.writeObject(q);
out.close();
ByteArrayInputStream bin = new ByteArrayInputStream(bout.toByteArray());
ObjectInputStream in = new ObjectInputStream(new BufferedInputStream(bin));
SynchronousQueue r = (SynchronousQueue)in.readObject();
assertEquals(q.size(), r.size());
while (!q.isEmpty())
assertEquals(q.remove(), r.remove());
} catch(Exception e){
unexpectedException();
}
|
| public void | testTakeFromEmpty()take blocks interruptibly when empty
final SynchronousQueue q = new SynchronousQueue();
Thread t = new Thread(new Runnable() {
public void run() {
try {
q.take();
threadShouldThrow();
} catch (InterruptedException success){ }
}
});
try {
t.start();
Thread.sleep(SHORT_DELAY_MS);
t.interrupt();
t.join();
} catch (Exception e){
unexpectedException();
}
|
| public void | testTimedOffer()timed offer times out if elements not taken
final SynchronousQueue q = new SynchronousQueue();
Thread t = new Thread(new Runnable() {
public void run() {
try {
threadAssertFalse(q.offer(new Object(), SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
q.offer(new Object(), LONG_DELAY_MS, TimeUnit.MILLISECONDS);
threadShouldThrow();
} catch (InterruptedException success){}
}
});
try {
t.start();
Thread.sleep(SMALL_DELAY_MS);
t.interrupt();
t.join();
} catch (Exception e){
unexpectedException();
}
|
| public void | testTimedPoll()timed pool with nonzero timeout times out if no active taker
try {
SynchronousQueue q = new SynchronousQueue();
assertNull(q.poll(SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
} catch (InterruptedException e){
unexpectedException();
}
|
| public void | testTimedPoll0()timed pool with zero timeout times out if no active taker
try {
SynchronousQueue q = new SynchronousQueue();
assertNull(q.poll(0, TimeUnit.MILLISECONDS));
} catch (InterruptedException e){
unexpectedException();
}
|
| public void | testTimedPollWithOffer()timed poll before a delayed offer fails; after offer succeeds;
on interruption throws
final SynchronousQueue q = new SynchronousQueue();
Thread t = new Thread(new Runnable() {
public void run() {
try {
threadAssertNull(q.poll(SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
q.poll(LONG_DELAY_MS, TimeUnit.MILLISECONDS);
q.poll(LONG_DELAY_MS, TimeUnit.MILLISECONDS);
threadShouldThrow();
} catch (InterruptedException success) { }
}
});
try {
t.start();
Thread.sleep(SMALL_DELAY_MS);
assertTrue(q.offer(zero, SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
t.interrupt();
t.join();
} catch (Exception e){
unexpectedException();
}
|
| public void | testToArray()toArray is empty
SynchronousQueue q = new SynchronousQueue();
Object[] o = q.toArray();
assertEquals(o.length, 0);
|
| public void | testToArray2()toArray(a) is nulled at position 0
SynchronousQueue q = new SynchronousQueue();
Integer[] ints = new Integer[1];
assertNull(ints[0]);
|
| public void | testToArray_BadArg()toArray(null) throws NPE
try {
SynchronousQueue q = new SynchronousQueue();
Object o[] = q.toArray(null);
shouldThrow();
} catch(NullPointerException success){}
|
| public void | testToString()toString returns a non-null string
SynchronousQueue q = new SynchronousQueue();
String s = q.toString();
assertNotNull(s);
|
