ViewVC Help
View File | Revision Log | Show Annotations | Download File | Root Listing
root/jsr166/jsr166/src/test/tck/SynchronousQueueTest.java
(Generate patch)

Comparing jsr166/src/test/tck/SynchronousQueueTest.java (file contents):
Revision 1.35 by jsr166, Fri May 27 20:07:24 2011 UTC vs.
Revision 1.39 by jsr166, Fri Jul 15 18:49:31 2011 UTC

# Line 7 | Line 7
7   */
8  
9   import junit.framework.*;
10 < import java.util.*;
11 < import java.util.concurrent.*;
10 > import java.util.Arrays;
11 > import java.util.ArrayList;
12 > import java.util.Collection;
13 > import java.util.Iterator;
14 > import java.util.NoSuchElementException;
15 > import java.util.Queue;
16 > import java.util.concurrent.BlockingQueue;
17 > import java.util.concurrent.CountDownLatch;
18 > import java.util.concurrent.Executors;
19 > import java.util.concurrent.ExecutorService;
20 > import java.util.concurrent.SynchronousQueue;
21   import static java.util.concurrent.TimeUnit.MILLISECONDS;
13 – import java.io.*;
22  
23   public class SynchronousQueueTest extends JSR166TestCase {
24  
# Line 50 | Line 58 | public class SynchronousQueueTest extend
58      }
59  
60      /**
53 –     * offer(null) throws NPE
54 –     */
55 –    public void testOfferNull() {
56 –        try {
57 –            SynchronousQueue q = new SynchronousQueue();
58 –            q.offer(null);
59 –            shouldThrow();
60 –        } catch (NullPointerException success) {}
61 –    }
62 –
63 –    /**
64 –     * add(null) throws NPE
65 –     */
66 –    public void testAddNull() {
67 –        try {
68 –            SynchronousQueue q = new SynchronousQueue();
69 –            q.add(null);
70 –            shouldThrow();
71 –        } catch (NullPointerException success) {}
72 –    }
73 –
74 –    /**
61       * offer fails if no active taker
62       */
63 <    public void testOffer() {
64 <        SynchronousQueue q = new SynchronousQueue();
63 >    public void testOffer()      { testOffer(false); }
64 >    public void testOffer_fair() { testOffer(true); }
65 >    public void testOffer(boolean fair) {
66 >        SynchronousQueue q = new SynchronousQueue(fair);
67          assertFalse(q.offer(one));
68      }
69  
70      /**
71 <     * add throws ISE if no active taker
71 >     * add throws IllegalStateException if no active taker
72       */
73 <    public void testAdd() {
73 >    public void testAdd()      { testAdd(false); }
74 >    public void testAdd_fair() { testAdd(true); }
75 >    public void testAdd(boolean fair) {
76 >        SynchronousQueue q = new SynchronousQueue(fair);
77 >        assertEquals(0, q.remainingCapacity());
78          try {
87 –            SynchronousQueue q = new SynchronousQueue();
88 –            assertEquals(0, q.remainingCapacity());
79              q.add(one);
80              shouldThrow();
81          } catch (IllegalStateException success) {}
82      }
83  
84      /**
85 <     * addAll(null) throws NPE
96 <     */
97 <    public void testAddAll1() {
98 <        try {
99 <            SynchronousQueue q = new SynchronousQueue();
100 <            q.addAll(null);
101 <            shouldThrow();
102 <        } catch (NullPointerException success) {}
103 <    }
104 <
105 <    /**
106 <     * addAll(this) throws IAE
85 >     * addAll(this) throws IllegalArgumentException
86       */
87 <    public void testAddAllSelf() {
87 >    public void testAddAll_self()      { testAddAll_self(false); }
88 >    public void testAddAll_self_fair() { testAddAll_self(true); }
89 >    public void testAddAll_self(boolean fair) {
90 >        SynchronousQueue q = new SynchronousQueue(fair);
91          try {
110 –            SynchronousQueue q = new SynchronousQueue();
92              q.addAll(q);
93              shouldThrow();
94          } catch (IllegalArgumentException success) {}
95      }
96  
97      /**
117 –     * addAll of a collection with null elements throws NPE
118 –     */
119 –    public void testAddAll2() {
120 –        try {
121 –            SynchronousQueue q = new SynchronousQueue();
122 –            Integer[] ints = new Integer[1];
123 –            q.addAll(Arrays.asList(ints));
124 –            shouldThrow();
125 –        } catch (NullPointerException success) {}
126 –    }
127 –
128 –    /**
98       * addAll throws ISE if no active taker
99       */
100 <    public void testAddAll4() {
100 >    public void testAddAll_ISE()      { testAddAll_ISE(false); }
101 >    public void testAddAll_ISE_fair() { testAddAll_ISE(true); }
102 >    public void testAddAll_ISE(boolean fair) {
103 >        SynchronousQueue q = new SynchronousQueue(fair);
104 >        Integer[] ints = new Integer[1];
105 >        for (int i = 0; i < ints.length; i++)
106 >            ints[i] = i;
107 >        Collection<Integer> coll = Arrays.asList(ints);
108          try {
109 <            SynchronousQueue q = new SynchronousQueue();
134 <            Integer[] ints = new Integer[1];
135 <            for (int i = 0; i < 1; ++i)
136 <                ints[i] = new Integer(i);
137 <            q.addAll(Arrays.asList(ints));
109 >            q.addAll(coll);
110              shouldThrow();
111          } catch (IllegalStateException success) {}
112      }
113  
114      /**
143 –     * put(null) throws NPE
144 –     */
145 –    public void testPutNull() throws InterruptedException {
146 –        try {
147 –            SynchronousQueue q = new SynchronousQueue();
148 –            q.put(null);
149 –            shouldThrow();
150 –        } catch (NullPointerException success) {}
151 –    }
152 –
153 –    /**
115       * put blocks interruptibly if no active taker
116       */
117      public void testBlockingPut()      { testBlockingPut(false); }
# Line 245 | Line 206 | public class SynchronousQueueTest extend
206      /**
207       * poll return null if no active putter
208       */
209 <    public void testPoll() {
210 <        SynchronousQueue q = new SynchronousQueue();
209 >    public void testPoll()      { testPoll(false); }
210 >    public void testPoll_fair() { testPoll(true); }
211 >    public void testPoll(boolean fair) {
212 >        final SynchronousQueue q = new SynchronousQueue(fair);
213          assertNull(q.poll());
214      }
215  
216      /**
217       * timed poll with zero timeout times out if no active putter
218       */
219 <    public void testTimedPoll0() throws InterruptedException {
220 <        SynchronousQueue q = new SynchronousQueue();
221 <        assertNull(q.poll(0, MILLISECONDS));
219 >    public void testTimedPoll0()      { testTimedPoll0(false); }
220 >    public void testTimedPoll0_fair() { testTimedPoll0(true); }
221 >    public void testTimedPoll0(boolean fair) {
222 >        final SynchronousQueue q = new SynchronousQueue(fair);
223 >        try { assertNull(q.poll(0, MILLISECONDS)); }
224 >        catch (InterruptedException e) { threadUnexpectedException(e); }
225      }
226  
227      /**
228       * timed poll with nonzero timeout times out if no active putter
229       */
230 <    public void testTimedPoll() throws InterruptedException {
231 <        SynchronousQueue q = new SynchronousQueue();
230 >    public void testTimedPoll()      { testTimedPoll(false); }
231 >    public void testTimedPoll_fair() { testTimedPoll(true); }
232 >    public void testTimedPoll(boolean fair) {
233 >        final SynchronousQueue q = new SynchronousQueue(fair);
234          long startTime = System.nanoTime();
235 <        assertNull(q.poll(timeoutMillis(), MILLISECONDS));
235 >        try { assertNull(q.poll(timeoutMillis(), MILLISECONDS)); }
236 >        catch (InterruptedException e) { threadUnexpectedException(e); }
237          assertTrue(millisElapsedSince(startTime) >= timeoutMillis());
238      }
239  
# Line 272 | Line 241 | public class SynchronousQueueTest extend
241       * timed poll before a delayed offer times out, returning null;
242       * after offer succeeds; on interruption throws
243       */
244 <    public void testFairTimedPollWithOffer() throws InterruptedException {
245 <        final SynchronousQueue q = new SynchronousQueue(true);
244 >    public void testTimedPollWithOffer()      { testTimedPollWithOffer(false); }
245 >    public void testTimedPollWithOffer_fair() { testTimedPollWithOffer(true); }
246 >    public void testTimedPollWithOffer(boolean fair) {
247 >        final SynchronousQueue q = new SynchronousQueue(fair);
248          final CountDownLatch pleaseOffer = new CountDownLatch(1);
249 +        final CountDownLatch pleaseInterrupt = new CountDownLatch(1);
250          Thread t = newStartedThread(new CheckedRunnable() {
251              public void realRun() throws InterruptedException {
252 <                long t0 = System.nanoTime();
253 <                assertNull(q.poll(SHORT_DELAY_MS, MILLISECONDS));
254 <                assertTrue(millisElapsedSince(t0) >= SHORT_DELAY_MS);
252 >                long startTime = System.nanoTime();
253 >                assertNull(q.poll(timeoutMillis(), MILLISECONDS));
254 >                assertTrue(millisElapsedSince(startTime) >= timeoutMillis());
255  
256                  pleaseOffer.countDown();
257 <                t0 = System.nanoTime();
257 >                startTime = System.nanoTime();
258                  assertSame(zero, q.poll(LONG_DELAY_MS, MILLISECONDS));
259 <                assertTrue(millisElapsedSince(t0) < MEDIUM_DELAY_MS);
259 >                assertTrue(millisElapsedSince(startTime) < MEDIUM_DELAY_MS);
260 >
261 >                Thread.currentThread().interrupt();
262 >                try {
263 >                    q.poll(LONG_DELAY_MS, MILLISECONDS);
264 >                    shouldThrow();
265 >                } catch (InterruptedException success) {}
266 >                assertFalse(Thread.interrupted());
267  
268 <                t0 = System.nanoTime();
268 >                pleaseInterrupt.countDown();
269                  try {
270                      q.poll(LONG_DELAY_MS, MILLISECONDS);
271                      shouldThrow();
272                  } catch (InterruptedException success) {}
273 <                assertTrue(millisElapsedSince(t0) < MEDIUM_DELAY_MS);
273 >                assertFalse(Thread.interrupted());
274              }});
275  
276 <        assertTrue(pleaseOffer.await(MEDIUM_DELAY_MS, MILLISECONDS));
277 <        long t0 = System.nanoTime();
278 <        assertTrue(q.offer(zero, LONG_DELAY_MS, MILLISECONDS));
279 <        assertTrue(millisElapsedSince(t0) < MEDIUM_DELAY_MS);
276 >        await(pleaseOffer);
277 >        long startTime = System.nanoTime();
278 >        try { assertTrue(q.offer(zero, LONG_DELAY_MS, MILLISECONDS)); }
279 >        catch (InterruptedException e) { threadUnexpectedException(e); }
280 >        assertTrue(millisElapsedSince(startTime) < MEDIUM_DELAY_MS);
281  
282 +        await(pleaseInterrupt);
283 +        assertThreadStaysAlive(t);
284          t.interrupt();
285 <        awaitTermination(t, MEDIUM_DELAY_MS);
285 >        awaitTermination(t);
286      }
287  
288      /**
289       * peek() returns null if no active putter
290       */
291 <    public void testPeek() {
292 <        SynchronousQueue q = new SynchronousQueue();
291 >    public void testPeek()      { testPeek(false); }
292 >    public void testPeek_fair() { testPeek(true); }
293 >    public void testPeek(boolean fair) {
294 >        final SynchronousQueue q = new SynchronousQueue(fair);
295          assertNull(q.peek());
296      }
297  
298      /**
299 <     * element() throws NSEE if no active putter
299 >     * element() throws NoSuchElementException if no active putter
300       */
301 <    public void testElement() {
302 <        SynchronousQueue q = new SynchronousQueue();
301 >    public void testElement()      { testElement(false); }
302 >    public void testElement_fair() { testElement(true); }
303 >    public void testElement(boolean fair) {
304 >        final SynchronousQueue q = new SynchronousQueue(fair);
305          try {
306              q.element();
307              shouldThrow();
# Line 323 | Line 309 | public class SynchronousQueueTest extend
309      }
310  
311      /**
312 <     * remove() throws NSEE if no active putter
312 >     * remove() throws NoSuchElementException if no active putter
313       */
314 <    public void testRemove() {
315 <        SynchronousQueue q = new SynchronousQueue();
314 >    public void testRemove()      { testRemove(false); }
315 >    public void testRemove_fair() { testRemove(true); }
316 >    public void testRemove(boolean fair) {
317 >        final SynchronousQueue q = new SynchronousQueue(fair);
318          try {
319              q.remove();
320              shouldThrow();
# Line 334 | Line 322 | public class SynchronousQueueTest extend
322      }
323  
324      /**
337 –     * remove(x) returns false
338 –     */
339 –    public void testRemoveElement() {
340 –        SynchronousQueue q = new SynchronousQueue();
341 –        assertFalse(q.remove(zero));
342 –        assertTrue(q.isEmpty());
343 –    }
344 –
345 –    /**
325       * contains returns false
326       */
327 <    public void testContains() {
328 <        SynchronousQueue q = new SynchronousQueue();
327 >    public void testContains()      { testContains(false); }
328 >    public void testContains_fair() { testContains(true); }
329 >    public void testContains(boolean fair) {
330 >        final SynchronousQueue q = new SynchronousQueue(fair);
331          assertFalse(q.contains(zero));
332      }
333  
334      /**
335       * clear ensures isEmpty
336       */
337 <    public void testClear() {
338 <        SynchronousQueue q = new SynchronousQueue();
337 >    public void testClear()      { testClear(false); }
338 >    public void testClear_fair() { testClear(true); }
339 >    public void testClear(boolean fair) {
340 >        final SynchronousQueue q = new SynchronousQueue(fair);
341          q.clear();
342          assertTrue(q.isEmpty());
343      }
# Line 362 | Line 345 | public class SynchronousQueueTest extend
345      /**
346       * containsAll returns false unless empty
347       */
348 <    public void testContainsAll() {
349 <        SynchronousQueue q = new SynchronousQueue();
348 >    public void testContainsAll()      { testContainsAll(false); }
349 >    public void testContainsAll_fair() { testContainsAll(true); }
350 >    public void testContainsAll(boolean fair) {
351 >        final SynchronousQueue q = new SynchronousQueue(fair);
352          Integer[] empty = new Integer[0];
353          assertTrue(q.containsAll(Arrays.asList(empty)));
354          Integer[] ints = new Integer[1]; ints[0] = zero;
# Line 373 | Line 358 | public class SynchronousQueueTest extend
358      /**
359       * retainAll returns false
360       */
361 <    public void testRetainAll() {
362 <        SynchronousQueue q = new SynchronousQueue();
361 >    public void testRetainAll()      { testRetainAll(false); }
362 >    public void testRetainAll_fair() { testRetainAll(true); }
363 >    public void testRetainAll(boolean fair) {
364 >        final SynchronousQueue q = new SynchronousQueue(fair);
365          Integer[] empty = new Integer[0];
366          assertFalse(q.retainAll(Arrays.asList(empty)));
367          Integer[] ints = new Integer[1]; ints[0] = zero;
# Line 384 | Line 371 | public class SynchronousQueueTest extend
371      /**
372       * removeAll returns false
373       */
374 <    public void testRemoveAll() {
375 <        SynchronousQueue q = new SynchronousQueue();
374 >    public void testRemoveAll()      { testRemoveAll(false); }
375 >    public void testRemoveAll_fair() { testRemoveAll(true); }
376 >    public void testRemoveAll(boolean fair) {
377 >        final SynchronousQueue q = new SynchronousQueue(fair);
378          Integer[] empty = new Integer[0];
379          assertFalse(q.removeAll(Arrays.asList(empty)));
380          Integer[] ints = new Integer[1]; ints[0] = zero;
# Line 395 | Line 384 | public class SynchronousQueueTest extend
384      /**
385       * toArray is empty
386       */
387 <    public void testToArray() {
388 <        SynchronousQueue q = new SynchronousQueue();
387 >    public void testToArray()      { testToArray(false); }
388 >    public void testToArray_fair() { testToArray(true); }
389 >    public void testToArray(boolean fair) {
390 >        final SynchronousQueue q = new SynchronousQueue(fair);
391          Object[] o = q.toArray();
392          assertEquals(o.length, 0);
393      }
# Line 404 | Line 395 | public class SynchronousQueueTest extend
395      /**
396       * toArray(a) is nulled at position 0
397       */
398 <    public void testToArray2() {
399 <        SynchronousQueue q = new SynchronousQueue();
398 >    public void testToArray2()      { testToArray2(false); }
399 >    public void testToArray2_fair() { testToArray2(true); }
400 >    public void testToArray2(boolean fair) {
401 >        final SynchronousQueue q = new SynchronousQueue(fair);
402          Integer[] ints = new Integer[1];
403          assertNull(ints[0]);
404      }
# Line 413 | Line 406 | public class SynchronousQueueTest extend
406      /**
407       * toArray(null) throws NPE
408       */
409 <    public void testToArray_BadArg() {
410 <        SynchronousQueue q = new SynchronousQueue();
409 >    public void testToArray_null()      { testToArray_null(false); }
410 >    public void testToArray_null_fair() { testToArray_null(true); }
411 >    public void testToArray_null(boolean fair) {
412 >        final SynchronousQueue q = new SynchronousQueue(fair);
413          try {
414              Object o[] = q.toArray(null);
415              shouldThrow();
# Line 424 | Line 419 | public class SynchronousQueueTest extend
419      /**
420       * iterator does not traverse any elements
421       */
422 <    public void testIterator() {
423 <        SynchronousQueue q = new SynchronousQueue();
422 >    public void testIterator()      { testIterator(false); }
423 >    public void testIterator_fair() { testIterator(true); }
424 >    public void testIterator(boolean fair) {
425 >        final SynchronousQueue q = new SynchronousQueue(fair);
426          Iterator it = q.iterator();
427          assertFalse(it.hasNext());
428          try {
# Line 437 | Line 434 | public class SynchronousQueueTest extend
434      /**
435       * iterator remove throws ISE
436       */
437 <    public void testIteratorRemove() {
438 <        SynchronousQueue q = new SynchronousQueue();
437 >    public void testIteratorRemove()      { testIteratorRemove(false); }
438 >    public void testIteratorRemove_fair() { testIteratorRemove(true); }
439 >    public void testIteratorRemove(boolean fair) {
440 >        final SynchronousQueue q = new SynchronousQueue(fair);
441          Iterator it = q.iterator();
442          try {
443              it.remove();
# Line 449 | Line 448 | public class SynchronousQueueTest extend
448      /**
449       * toString returns a non-null string
450       */
451 <    public void testToString() {
452 <        SynchronousQueue q = new SynchronousQueue();
451 >    public void testToString()      { testToString(false); }
452 >    public void testToString_fair() { testToString(true); }
453 >    public void testToString(boolean fair) {
454 >        final SynchronousQueue q = new SynchronousQueue(fair);
455          String s = q.toString();
456          assertNotNull(s);
457      }
# Line 458 | Line 459 | public class SynchronousQueueTest extend
459      /**
460       * offer transfers elements across Executor tasks
461       */
462 <    public void testOfferInExecutor() {
463 <        final SynchronousQueue q = new SynchronousQueue();
462 >    public void testOfferInExecutor()      { testOfferInExecutor(false); }
463 >    public void testOfferInExecutor_fair() { testOfferInExecutor(true); }
464 >    public void testOfferInExecutor(boolean fair) {
465 >        final SynchronousQueue q = new SynchronousQueue(fair);
466          ExecutorService executor = Executors.newFixedThreadPool(2);
467          final CheckedBarrier threadsStarted = new CheckedBarrier(2);
468  
# Line 483 | Line 486 | public class SynchronousQueueTest extend
486      /**
487       * timed poll retrieves elements across Executor threads
488       */
489 <    public void testPollInExecutor() {
490 <        final SynchronousQueue q = new SynchronousQueue();
489 >    public void testPollInExecutor()      { testPollInExecutor(false); }
490 >    public void testPollInExecutor_fair() { testPollInExecutor(true); }
491 >    public void testPollInExecutor(boolean fair) {
492 >        final SynchronousQueue q = new SynchronousQueue(fair);
493          final CheckedBarrier threadsStarted = new CheckedBarrier(2);
494          ExecutorService executor = Executors.newFixedThreadPool(2);
495          executor.execute(new CheckedRunnable() {
# Line 507 | Line 512 | public class SynchronousQueueTest extend
512      /**
513       * a deserialized serialized queue is usable
514       */
515 <    public void testSerialization() throws Exception {
516 <        SynchronousQueue q = new SynchronousQueue();
517 <        ByteArrayOutputStream bout = new ByteArrayOutputStream(10000);
518 <        ObjectOutputStream out = new ObjectOutputStream(new BufferedOutputStream(bout));
519 <        out.writeObject(q);
520 <        out.close();
521 <
522 <        ByteArrayInputStream bin = new ByteArrayInputStream(bout.toByteArray());
518 <        ObjectInputStream in = new ObjectInputStream(new BufferedInputStream(bin));
519 <        SynchronousQueue r = (SynchronousQueue)in.readObject();
520 <        assertEquals(q.size(), r.size());
521 <        while (!q.isEmpty())
522 <            assertEquals(q.remove(), r.remove());
523 <    }
524 <
525 <    /**
526 <     * drainTo(null) throws NPE
527 <     */
528 <    public void testDrainToNull() {
529 <        SynchronousQueue q = new SynchronousQueue();
530 <        try {
531 <            q.drainTo(null);
532 <            shouldThrow();
533 <        } catch (NullPointerException success) {}
534 <    }
535 <
536 <    /**
537 <     * drainTo(this) throws IAE
538 <     */
539 <    public void testDrainToSelf() {
540 <        SynchronousQueue q = new SynchronousQueue();
541 <        try {
542 <            q.drainTo(q);
543 <            shouldThrow();
544 <        } catch (IllegalArgumentException success) {}
515 >    public void testSerialization()      { testSerialization(false); }
516 >    public void testSerialization_fair() { testSerialization(true); }
517 >    public void testSerialization(boolean fair) {
518 >        final SynchronousQueue x = new SynchronousQueue(fair);
519 >        final SynchronousQueue y = serialClone(x);
520 >        assertTrue(x != y);
521 >        assertTrue(x.isEmpty());
522 >        assertTrue(y.isEmpty());
523      }
524  
525      /**
526       * drainTo(c) of empty queue doesn't transfer elements
527       */
528 <    public void testDrainTo() {
529 <        SynchronousQueue q = new SynchronousQueue();
528 >    public void testDrainTo()      { testDrainTo(false); }
529 >    public void testDrainTo_fair() { testDrainTo(true); }
530 >    public void testDrainTo(boolean fair) {
531 >        final SynchronousQueue q = new SynchronousQueue(fair);
532          ArrayList l = new ArrayList();
533          q.drainTo(l);
534          assertEquals(q.size(), 0);
# Line 558 | Line 538 | public class SynchronousQueueTest extend
538      /**
539       * drainTo empties queue, unblocking a waiting put.
540       */
541 <    public void testDrainToWithActivePut() throws InterruptedException {
542 <        final SynchronousQueue q = new SynchronousQueue();
541 >    public void testDrainToWithActivePut()      { testDrainToWithActivePut(false); }
542 >    public void testDrainToWithActivePut_fair() { testDrainToWithActivePut(true); }
543 >    public void testDrainToWithActivePut(boolean fair) {
544 >        final SynchronousQueue q = new SynchronousQueue(fair);
545          Thread t = newStartedThread(new CheckedRunnable() {
546              public void realRun() throws InterruptedException {
547                  q.put(one);
# Line 579 | Line 561 | public class SynchronousQueueTest extend
561      }
562  
563      /**
582 –     * drainTo(null, n) throws NPE
583 –     */
584 –    public void testDrainToNullN() {
585 –        SynchronousQueue q = new SynchronousQueue();
586 –        try {
587 –            q.drainTo(null, 0);
588 –            shouldThrow();
589 –        } catch (NullPointerException success) {}
590 –    }
591 –
592 –    /**
593 –     * drainTo(this, n) throws IAE
594 –     */
595 –    public void testDrainToSelfN() {
596 –        SynchronousQueue q = new SynchronousQueue();
597 –        try {
598 –            q.drainTo(q, 0);
599 –            shouldThrow();
600 –        } catch (IllegalArgumentException success) {}
601 –    }
602 –
603 –    /**
564       * drainTo(c, n) empties up to n elements of queue into c
565       */
566      public void testDrainToN() throws InterruptedException {

Diff Legend

– Removed lines
+ Added lines
< Changed lines
> Changed lines