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.36 by jsr166, Sat May 28 13:40:20 2011 UTC

# Line 50 | Line 50 | public class SynchronousQueueTest extend
50      }
51  
52      /**
53 <     * offer(null) throws NPE
53 >     * offer(null) throws NullPointerException
54       */
55 <    public void testOfferNull() {
55 >    public void testOfferNull()      { testOfferNull(false); }
56 >    public void testOfferNull_fair() { testOfferNull(true); }
57 >    public void testOfferNull(boolean fair) {
58 >        SynchronousQueue q = new SynchronousQueue(fair);
59          try {
57 –            SynchronousQueue q = new SynchronousQueue();
60              q.offer(null);
61              shouldThrow();
62          } catch (NullPointerException success) {}
63      }
64  
65      /**
66 <     * add(null) throws NPE
66 >     * add(null) throws NullPointerException
67       */
68 <    public void testAddNull() {
68 >    public void testAddNull()      { testAddNull(false); }
69 >    public void testAddNull_fair() { testAddNull(true); }
70 >    public void testAddNull(boolean fair) {
71 >        SynchronousQueue q = new SynchronousQueue(fair);
72          try {
68 –            SynchronousQueue q = new SynchronousQueue();
73              q.add(null);
74              shouldThrow();
75          } catch (NullPointerException success) {}
# Line 74 | Line 78 | public class SynchronousQueueTest extend
78      /**
79       * offer fails if no active taker
80       */
81 <    public void testOffer() {
82 <        SynchronousQueue q = new SynchronousQueue();
81 >    public void testOffer()      { testOffer(false); }
82 >    public void testOffer_fair() { testOffer(true); }
83 >    public void testOffer(boolean fair) {
84 >        SynchronousQueue q = new SynchronousQueue(fair);
85          assertFalse(q.offer(one));
86      }
87  
88      /**
89 <     * add throws ISE if no active taker
89 >     * add throws IllegalStateException if no active taker
90       */
91 <    public void testAdd() {
91 >    public void testAdd()      { testAdd(false); }
92 >    public void testAdd_fair() { testAdd(true); }
93 >    public void testAdd(boolean fair) {
94 >        SynchronousQueue q = new SynchronousQueue(fair);
95 >        assertEquals(0, q.remainingCapacity());
96          try {
87 –            SynchronousQueue q = new SynchronousQueue();
88 –            assertEquals(0, q.remainingCapacity());
97              q.add(one);
98              shouldThrow();
99          } catch (IllegalStateException success) {}
100      }
101  
102      /**
103 <     * addAll(null) throws NPE
103 >     * addAll(null) throws NullPointerException
104       */
105 <    public void testAddAll1() {
105 >    public void testAddAll_null()      { testAddAll_null(false); }
106 >    public void testAddAll_null_fair() { testAddAll_null(true); }
107 >    public void testAddAll_null(boolean fair) {
108 >        SynchronousQueue q = new SynchronousQueue(fair);
109          try {
99 –            SynchronousQueue q = new SynchronousQueue();
110              q.addAll(null);
111              shouldThrow();
112          } catch (NullPointerException success) {}
113      }
114  
115      /**
116 <     * addAll(this) throws IAE
116 >     * addAll(this) throws IllegalArgumentException
117       */
118 <    public void testAddAllSelf() {
118 >    public void testAddAll_self()      { testAddAll_self(false); }
119 >    public void testAddAll_self_fair() { testAddAll_self(true); }
120 >    public void testAddAll_self(boolean fair) {
121 >        SynchronousQueue q = new SynchronousQueue(fair);
122          try {
110 –            SynchronousQueue q = new SynchronousQueue();
123              q.addAll(q);
124              shouldThrow();
125          } catch (IllegalArgumentException success) {}
126      }
127  
128      /**
129 <     * addAll of a collection with null elements throws NPE
129 >     * addAll of a collection with null elements throws NullPointerException
130       */
131 <    public void testAddAll2() {
131 >    public void testAddAll_null2()      { testAddAll_null2(false); }
132 >    public void testAddAll_null2_fair() { testAddAll_null2(true); }
133 >    public void testAddAll_null2(boolean fair) {
134 >        SynchronousQueue q = new SynchronousQueue(fair);
135 >        Collection<Integer> ints = Arrays.asList(new Integer[1]);
136          try {
137 <            SynchronousQueue q = new SynchronousQueue();
122 <            Integer[] ints = new Integer[1];
123 <            q.addAll(Arrays.asList(ints));
137 >            q.addAll(ints);
138              shouldThrow();
139          } catch (NullPointerException success) {}
140      }
# Line 128 | Line 142 | public class SynchronousQueueTest extend
142      /**
143       * addAll throws ISE if no active taker
144       */
145 <    public void testAddAll4() {
145 >    public void testAddAll_ISE()      { testAddAll_ISE(false); }
146 >    public void testAddAll_ISE_fair() { testAddAll_ISE(true); }
147 >    public void testAddAll_ISE(boolean fair) {
148 >        SynchronousQueue q = new SynchronousQueue(fair);
149 >        Integer[] ints = new Integer[1];
150 >        for (int i = 0; i < ints.length; i++)
151 >            ints[i] = i;
152 >        Collection<Integer> coll = Arrays.asList(ints);
153          try {
154 <            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));
154 >            q.addAll(coll);
155              shouldThrow();
156          } catch (IllegalStateException success) {}
157      }
# Line 245 | Line 262 | public class SynchronousQueueTest extend
262      /**
263       * poll return null if no active putter
264       */
265 <    public void testPoll() {
266 <        SynchronousQueue q = new SynchronousQueue();
265 >    public void testPoll()      { testPoll(false); }
266 >    public void testPoll_fair() { testPoll(true); }
267 >    public void testPoll(boolean fair) {
268 >        final SynchronousQueue q = new SynchronousQueue(fair);
269          assertNull(q.poll());
270      }
271  
272      /**
273       * timed poll with zero timeout times out if no active putter
274       */
275 <    public void testTimedPoll0() throws InterruptedException {
276 <        SynchronousQueue q = new SynchronousQueue();
277 <        assertNull(q.poll(0, MILLISECONDS));
275 >    public void testTimedPoll0()      { testTimedPoll0(false); }
276 >    public void testTimedPoll0_fair() { testTimedPoll0(true); }
277 >    public void testTimedPoll0(boolean fair) {
278 >        final SynchronousQueue q = new SynchronousQueue(fair);
279 >        try { assertNull(q.poll(0, MILLISECONDS)); }
280 >        catch (InterruptedException e) { threadUnexpectedException(e); }
281      }
282  
283      /**
284       * timed poll with nonzero timeout times out if no active putter
285       */
286 <    public void testTimedPoll() throws InterruptedException {
287 <        SynchronousQueue q = new SynchronousQueue();
286 >    public void testTimedPoll()      { testTimedPoll(false); }
287 >    public void testTimedPoll_fair() { testTimedPoll(true); }
288 >    public void testTimedPoll(boolean fair) {
289 >        final SynchronousQueue q = new SynchronousQueue(fair);
290          long startTime = System.nanoTime();
291 <        assertNull(q.poll(timeoutMillis(), MILLISECONDS));
291 >        try { assertNull(q.poll(timeoutMillis(), MILLISECONDS)); }
292 >        catch (InterruptedException e) { threadUnexpectedException(e); }
293          assertTrue(millisElapsedSince(startTime) >= timeoutMillis());
294      }
295  
# Line 272 | Line 297 | public class SynchronousQueueTest extend
297       * timed poll before a delayed offer times out, returning null;
298       * after offer succeeds; on interruption throws
299       */
300 <    public void testFairTimedPollWithOffer() throws InterruptedException {
301 <        final SynchronousQueue q = new SynchronousQueue(true);
300 >    public void testTimedPollWithOffer()      { testTimedPollWithOffer(false); }
301 >    public void testTimedPollWithOffer_fair() { testTimedPollWithOffer(true); }
302 >    public void testTimedPollWithOffer(boolean fair) {
303 >        final SynchronousQueue q = new SynchronousQueue(fair);
304          final CountDownLatch pleaseOffer = new CountDownLatch(1);
305 +        final CountDownLatch pleaseInterrupt = new CountDownLatch(1);
306          Thread t = newStartedThread(new CheckedRunnable() {
307              public void realRun() throws InterruptedException {
308 <                long t0 = System.nanoTime();
309 <                assertNull(q.poll(SHORT_DELAY_MS, MILLISECONDS));
310 <                assertTrue(millisElapsedSince(t0) >= SHORT_DELAY_MS);
308 >                long startTime = System.nanoTime();
309 >                assertNull(q.poll(timeoutMillis(), MILLISECONDS));
310 >                assertTrue(millisElapsedSince(startTime) >= timeoutMillis());
311  
312                  pleaseOffer.countDown();
313 <                t0 = System.nanoTime();
313 >                startTime = System.nanoTime();
314                  assertSame(zero, q.poll(LONG_DELAY_MS, MILLISECONDS));
315 <                assertTrue(millisElapsedSince(t0) < MEDIUM_DELAY_MS);
315 >                assertTrue(millisElapsedSince(startTime) < MEDIUM_DELAY_MS);
316 >
317 >                Thread.currentThread().interrupt();
318 >                try {
319 >                    q.poll(LONG_DELAY_MS, MILLISECONDS);
320 >                    shouldThrow();
321 >                } catch (InterruptedException success) {}
322 >                assertFalse(Thread.interrupted());
323  
324 <                t0 = System.nanoTime();
324 >                pleaseInterrupt.countDown();
325                  try {
326                      q.poll(LONG_DELAY_MS, MILLISECONDS);
327                      shouldThrow();
328                  } catch (InterruptedException success) {}
329 <                assertTrue(millisElapsedSince(t0) < MEDIUM_DELAY_MS);
329 >                assertFalse(Thread.interrupted());
330              }});
331  
332 <        assertTrue(pleaseOffer.await(MEDIUM_DELAY_MS, MILLISECONDS));
333 <        long t0 = System.nanoTime();
334 <        assertTrue(q.offer(zero, LONG_DELAY_MS, MILLISECONDS));
335 <        assertTrue(millisElapsedSince(t0) < MEDIUM_DELAY_MS);
332 >        await(pleaseOffer);
333 >        long startTime = System.nanoTime();
334 >        try { assertTrue(q.offer(zero, LONG_DELAY_MS, MILLISECONDS)); }
335 >        catch (InterruptedException e) { threadUnexpectedException(e); }
336 >        assertTrue(millisElapsedSince(startTime) < MEDIUM_DELAY_MS);
337  
338 +        await(pleaseInterrupt);
339 +        assertThreadStaysAlive(t);
340          t.interrupt();
341 <        awaitTermination(t, MEDIUM_DELAY_MS);
341 >        awaitTermination(t);
342      }
343  
344      /**
345       * peek() returns null if no active putter
346       */
347 <    public void testPeek() {
348 <        SynchronousQueue q = new SynchronousQueue();
347 >    public void testPeek()      { testPeek(false); }
348 >    public void testPeek_fair() { testPeek(true); }
349 >    public void testPeek(boolean fair) {
350 >        final SynchronousQueue q = new SynchronousQueue(fair);
351          assertNull(q.peek());
352      }
353  
354      /**
355 <     * element() throws NSEE if no active putter
355 >     * element() throws NoSuchElementException if no active putter
356       */
357 <    public void testElement() {
358 <        SynchronousQueue q = new SynchronousQueue();
357 >    public void testElement()      { testElement(false); }
358 >    public void testElement_fair() { testElement(true); }
359 >    public void testElement(boolean fair) {
360 >        final SynchronousQueue q = new SynchronousQueue(fair);
361          try {
362              q.element();
363              shouldThrow();
# Line 323 | Line 365 | public class SynchronousQueueTest extend
365      }
366  
367      /**
368 <     * remove() throws NSEE if no active putter
368 >     * remove() throws NoSuchElementException if no active putter
369       */
370 <    public void testRemove() {
371 <        SynchronousQueue q = new SynchronousQueue();
370 >    public void testRemove()      { testRemove(false); }
371 >    public void testRemove_fair() { testRemove(true); }
372 >    public void testRemove(boolean fair) {
373 >        final SynchronousQueue q = new SynchronousQueue(fair);
374          try {
375              q.remove();
376              shouldThrow();
# Line 336 | Line 380 | public class SynchronousQueueTest extend
380      /**
381       * remove(x) returns false
382       */
383 <    public void testRemoveElement() {
384 <        SynchronousQueue q = new SynchronousQueue();
383 >    public void testRemoveElement()      { testRemoveElement(false); }
384 >    public void testRemoveElement_fair() { testRemoveElement(true); }
385 >    public void testRemoveElement(boolean fair) {
386 >        final SynchronousQueue q = new SynchronousQueue(fair);
387          assertFalse(q.remove(zero));
388          assertTrue(q.isEmpty());
389      }
# Line 345 | Line 391 | public class SynchronousQueueTest extend
391      /**
392       * contains returns false
393       */
394 <    public void testContains() {
395 <        SynchronousQueue q = new SynchronousQueue();
394 >    public void testContains()      { testContains(false); }
395 >    public void testContains_fair() { testContains(true); }
396 >    public void testContains(boolean fair) {
397 >        final SynchronousQueue q = new SynchronousQueue(fair);
398          assertFalse(q.contains(zero));
399      }
400  
401      /**
402       * clear ensures isEmpty
403       */
404 <    public void testClear() {
405 <        SynchronousQueue q = new SynchronousQueue();
404 >    public void testClear()      { testClear(false); }
405 >    public void testClear_fair() { testClear(true); }
406 >    public void testClear(boolean fair) {
407 >        final SynchronousQueue q = new SynchronousQueue(fair);
408          q.clear();
409          assertTrue(q.isEmpty());
410      }
# Line 362 | Line 412 | public class SynchronousQueueTest extend
412      /**
413       * containsAll returns false unless empty
414       */
415 <    public void testContainsAll() {
416 <        SynchronousQueue q = new SynchronousQueue();
415 >    public void testContainsAll()      { testContainsAll(false); }
416 >    public void testContainsAll_fair() { testContainsAll(true); }
417 >    public void testContainsAll(boolean fair) {
418 >        final SynchronousQueue q = new SynchronousQueue(fair);
419          Integer[] empty = new Integer[0];
420          assertTrue(q.containsAll(Arrays.asList(empty)));
421          Integer[] ints = new Integer[1]; ints[0] = zero;
# Line 373 | Line 425 | public class SynchronousQueueTest extend
425      /**
426       * retainAll returns false
427       */
428 <    public void testRetainAll() {
429 <        SynchronousQueue q = new SynchronousQueue();
428 >    public void testRetainAll()      { testRetainAll(false); }
429 >    public void testRetainAll_fair() { testRetainAll(true); }
430 >    public void testRetainAll(boolean fair) {
431 >        final SynchronousQueue q = new SynchronousQueue(fair);
432          Integer[] empty = new Integer[0];
433          assertFalse(q.retainAll(Arrays.asList(empty)));
434          Integer[] ints = new Integer[1]; ints[0] = zero;
# Line 384 | Line 438 | public class SynchronousQueueTest extend
438      /**
439       * removeAll returns false
440       */
441 <    public void testRemoveAll() {
442 <        SynchronousQueue q = new SynchronousQueue();
441 >    public void testRemoveAll()      { testRemoveAll(false); }
442 >    public void testRemoveAll_fair() { testRemoveAll(true); }
443 >    public void testRemoveAll(boolean fair) {
444 >        final SynchronousQueue q = new SynchronousQueue(fair);
445          Integer[] empty = new Integer[0];
446          assertFalse(q.removeAll(Arrays.asList(empty)));
447          Integer[] ints = new Integer[1]; ints[0] = zero;
# Line 395 | Line 451 | public class SynchronousQueueTest extend
451      /**
452       * toArray is empty
453       */
454 <    public void testToArray() {
455 <        SynchronousQueue q = new SynchronousQueue();
454 >    public void testToArray()      { testToArray(false); }
455 >    public void testToArray_fair() { testToArray(true); }
456 >    public void testToArray(boolean fair) {
457 >        final SynchronousQueue q = new SynchronousQueue(fair);
458          Object[] o = q.toArray();
459          assertEquals(o.length, 0);
460      }
# Line 404 | Line 462 | public class SynchronousQueueTest extend
462      /**
463       * toArray(a) is nulled at position 0
464       */
465 <    public void testToArray2() {
466 <        SynchronousQueue q = new SynchronousQueue();
465 >    public void testToArray2()      { testToArray2(false); }
466 >    public void testToArray2_fair() { testToArray2(true); }
467 >    public void testToArray2(boolean fair) {
468 >        final SynchronousQueue q = new SynchronousQueue(fair);
469          Integer[] ints = new Integer[1];
470          assertNull(ints[0]);
471      }
# Line 413 | Line 473 | public class SynchronousQueueTest extend
473      /**
474       * toArray(null) throws NPE
475       */
476 <    public void testToArray_BadArg() {
477 <        SynchronousQueue q = new SynchronousQueue();
476 >    public void testToArray_null()      { testToArray_null(false); }
477 >    public void testToArray_null_fair() { testToArray_null(true); }
478 >    public void testToArray_null(boolean fair) {
479 >        final SynchronousQueue q = new SynchronousQueue(fair);
480          try {
481              Object o[] = q.toArray(null);
482              shouldThrow();
# Line 424 | Line 486 | public class SynchronousQueueTest extend
486      /**
487       * iterator does not traverse any elements
488       */
489 <    public void testIterator() {
490 <        SynchronousQueue q = new SynchronousQueue();
489 >    public void testIterator()      { testIterator(false); }
490 >    public void testIterator_fair() { testIterator(true); }
491 >    public void testIterator(boolean fair) {
492 >        final SynchronousQueue q = new SynchronousQueue(fair);
493          Iterator it = q.iterator();
494          assertFalse(it.hasNext());
495          try {
# Line 437 | Line 501 | public class SynchronousQueueTest extend
501      /**
502       * iterator remove throws ISE
503       */
504 <    public void testIteratorRemove() {
505 <        SynchronousQueue q = new SynchronousQueue();
504 >    public void testIteratorRemove()      { testIteratorRemove(false); }
505 >    public void testIteratorRemove_fair() { testIteratorRemove(true); }
506 >    public void testIteratorRemove(boolean fair) {
507 >        final SynchronousQueue q = new SynchronousQueue(fair);
508          Iterator it = q.iterator();
509          try {
510              it.remove();
# Line 449 | Line 515 | public class SynchronousQueueTest extend
515      /**
516       * toString returns a non-null string
517       */
518 <    public void testToString() {
519 <        SynchronousQueue q = new SynchronousQueue();
518 >    public void testToString()      { testToString(false); }
519 >    public void testToString_fair() { testToString(true); }
520 >    public void testToString(boolean fair) {
521 >        final SynchronousQueue q = new SynchronousQueue(fair);
522          String s = q.toString();
523          assertNotNull(s);
524      }
# Line 458 | Line 526 | public class SynchronousQueueTest extend
526      /**
527       * offer transfers elements across Executor tasks
528       */
529 <    public void testOfferInExecutor() {
530 <        final SynchronousQueue q = new SynchronousQueue();
529 >    public void testOfferInExecutor()      { testOfferInExecutor(false); }
530 >    public void testOfferInExecutor_fair() { testOfferInExecutor(true); }
531 >    public void testOfferInExecutor(boolean fair) {
532 >        final SynchronousQueue q = new SynchronousQueue(fair);
533          ExecutorService executor = Executors.newFixedThreadPool(2);
534          final CheckedBarrier threadsStarted = new CheckedBarrier(2);
535  
# Line 483 | Line 553 | public class SynchronousQueueTest extend
553      /**
554       * timed poll retrieves elements across Executor threads
555       */
556 <    public void testPollInExecutor() {
557 <        final SynchronousQueue q = new SynchronousQueue();
556 >    public void testPollInExecutor()      { testPollInExecutor(false); }
557 >    public void testPollInExecutor_fair() { testPollInExecutor(true); }
558 >    public void testPollInExecutor(boolean fair) {
559 >        final SynchronousQueue q = new SynchronousQueue(fair);
560          final CheckedBarrier threadsStarted = new CheckedBarrier(2);
561          ExecutorService executor = Executors.newFixedThreadPool(2);
562          executor.execute(new CheckedRunnable() {
# Line 507 | Line 579 | public class SynchronousQueueTest extend
579      /**
580       * a deserialized serialized queue is usable
581       */
582 <    public void testSerialization() throws Exception {
583 <        SynchronousQueue q = new SynchronousQueue();
584 <        ByteArrayOutputStream bout = new ByteArrayOutputStream(10000);
585 <        ObjectOutputStream out = new ObjectOutputStream(new BufferedOutputStream(bout));
586 <        out.writeObject(q);
587 <        out.close();
516 <
517 <        ByteArrayInputStream bin = new ByteArrayInputStream(bout.toByteArray());
518 <        ObjectInputStream in = new ObjectInputStream(new BufferedInputStream(bin));
519 <        SynchronousQueue r = (SynchronousQueue)in.readObject();
582 >    public void testSerialization()      { testSerialization(false); }
583 >    public void testSerialization_fair() { testSerialization(true); }
584 >    public void testSerialization(boolean fair) {
585 >        final SynchronousQueue q = new SynchronousQueue(fair);
586 >        final SynchronousQueue r = serialClone(q);
587 >        assertTrue(q != r);
588          assertEquals(q.size(), r.size());
589          while (!q.isEmpty())
590              assertEquals(q.remove(), r.remove());
# Line 525 | Line 593 | public class SynchronousQueueTest extend
593      /**
594       * drainTo(null) throws NPE
595       */
596 <    public void testDrainToNull() {
597 <        SynchronousQueue q = new SynchronousQueue();
596 >    public void testDrainToNull()      { testDrainToNull(false); }
597 >    public void testDrainToNull_fair() { testDrainToNull(true); }
598 >    public void testDrainToNull(boolean fair) {
599 >        final SynchronousQueue q = new SynchronousQueue(fair);
600          try {
601              q.drainTo(null);
602              shouldThrow();
# Line 536 | Line 606 | public class SynchronousQueueTest extend
606      /**
607       * drainTo(this) throws IAE
608       */
609 <    public void testDrainToSelf() {
610 <        SynchronousQueue q = new SynchronousQueue();
609 >    public void testDrainToSelf()      { testDrainToSelf(false); }
610 >    public void testDrainToSelf_fair() { testDrainToSelf(true); }
611 >    public void testDrainToSelf(boolean fair) {
612 >        final SynchronousQueue q = new SynchronousQueue(fair);
613          try {
614              q.drainTo(q);
615              shouldThrow();
# Line 547 | Line 619 | public class SynchronousQueueTest extend
619      /**
620       * drainTo(c) of empty queue doesn't transfer elements
621       */
622 <    public void testDrainTo() {
623 <        SynchronousQueue q = new SynchronousQueue();
622 >    public void testDrainTo()      { testDrainTo(false); }
623 >    public void testDrainTo_fair() { testDrainTo(true); }
624 >    public void testDrainTo(boolean fair) {
625 >        final SynchronousQueue q = new SynchronousQueue(fair);
626          ArrayList l = new ArrayList();
627          q.drainTo(l);
628          assertEquals(q.size(), 0);
# Line 558 | Line 632 | public class SynchronousQueueTest extend
632      /**
633       * drainTo empties queue, unblocking a waiting put.
634       */
635 <    public void testDrainToWithActivePut() throws InterruptedException {
636 <        final SynchronousQueue q = new SynchronousQueue();
635 >    public void testDrainToWithActivePut()      { testDrainToWithActivePut(false); }
636 >    public void testDrainToWithActivePut_fair() { testDrainToWithActivePut(true); }
637 >    public void testDrainToWithActivePut(boolean fair) {
638 >        final SynchronousQueue q = new SynchronousQueue(fair);
639          Thread t = newStartedThread(new CheckedRunnable() {
640              public void realRun() throws InterruptedException {
641                  q.put(one);
# Line 579 | Line 655 | public class SynchronousQueueTest extend
655      }
656  
657      /**
658 <     * drainTo(null, n) throws NPE
658 >     * drainTo(null, n) throws NullPointerException
659       */
660 <    public void testDrainToNullN() {
661 <        SynchronousQueue q = new SynchronousQueue();
660 >    public void testDrainToNullN()      { testDrainToNullN(false); }
661 >    public void testDrainToNullN_fair() { testDrainToNullN(true); }
662 >    public void testDrainToNullN(boolean fair) {
663 >        final SynchronousQueue q = new SynchronousQueue(fair);
664          try {
665              q.drainTo(null, 0);
666              shouldThrow();
# Line 590 | Line 668 | public class SynchronousQueueTest extend
668      }
669  
670      /**
671 <     * drainTo(this, n) throws IAE
671 >     * drainTo(this, n) throws IllegalArgumentException
672       */
673 <    public void testDrainToSelfN() {
674 <        SynchronousQueue q = new SynchronousQueue();
673 >    public void testDrainToSelfN()      { testDrainToSelfN(false); }
674 >    public void testDrainToSelfN_fair() { testDrainToSelfN(true); }
675 >    public void testDrainToSelfN(boolean fair) {
676 >        final SynchronousQueue q = new SynchronousQueue(fair);
677          try {
678              q.drainTo(q, 0);
679              shouldThrow();

Diff Legend

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