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

Comparing jsr166/src/test/tck/LinkedBlockingQueueTest.java (file contents):
Revision 1.23 by jsr166, Sun Nov 22 18:57:17 2009 UTC vs.
Revision 1.32 by jsr166, Thu Oct 28 17:57:26 2010 UTC

# Line 14 | Line 14 | import java.io.*;
14  
15   public class LinkedBlockingQueueTest extends JSR166TestCase {
16  
17 +    public static class Unbounded extends BlockingQueueTest {
18 +        protected BlockingQueue emptyCollection() {
19 +            return new LinkedBlockingQueue();
20 +        }
21 +    }
22 +
23 +    public static class Bounded extends BlockingQueueTest {
24 +        protected BlockingQueue emptyCollection() {
25 +            return new LinkedBlockingQueue(20);
26 +        }
27 +    }
28 +
29      public static void main(String[] args) {
30 <        junit.textui.TestRunner.run (suite());
30 >        junit.textui.TestRunner.run(suite());
31      }
32  
33      public static Test suite() {
34 <        return new TestSuite(LinkedBlockingQueueTest.class);
34 >        return newTestSuite(LinkedBlockingQueueTest.class,
35 >                            new Unbounded().testSuite(),
36 >                            new Bounded().testSuite());
37      }
38  
39  
# Line 214 | Line 228 | public class LinkedBlockingQueueTest ext
228              shouldThrow();
229          } catch (NullPointerException success) {}
230      }
231 +
232      /**
233       * addAll of a collection with any null elements throws NPE after
234       * possibly adding some elements
# Line 228 | Line 243 | public class LinkedBlockingQueueTest ext
243              shouldThrow();
244          } catch (NullPointerException success) {}
245      }
246 +
247      /**
248       * addAll throws ISE if not enough room
249       */
# Line 241 | Line 257 | public class LinkedBlockingQueueTest ext
257              shouldThrow();
258          } catch (IllegalStateException success) {}
259      }
260 +
261      /**
262       * Queue contains all elements, in traversal order, of successful addAll
263       */
# Line 364 | Line 381 | public class LinkedBlockingQueueTest ext
381      }
382  
383      /**
367 –     * take blocks interruptibly when empty
368 –     */
369 –    public void testTakeFromEmpty() throws InterruptedException {
370 –        final LinkedBlockingQueue q = new LinkedBlockingQueue(2);
371 –        Thread t = new ThreadShouldThrow(InterruptedException.class) {
372 –            public void realRun() throws InterruptedException {
373 –                q.take();
374 –            }};
375 –
376 –        t.start();
377 –        Thread.sleep(SHORT_DELAY_MS);
378 –        t.interrupt();
379 –        t.join();
380 –    }
381 –
382 –    /**
384       * Take removes existing elements until empty, then blocks interruptibly
385       */
386      public void testBlockingTake() throws InterruptedException {
# Line 458 | Line 459 | public class LinkedBlockingQueueTest ext
459      }
460  
461      /**
461 –     *  timed poll before a delayed offer fails; after offer succeeds;
462 –     *  on interruption throws
463 –     */
464 –    public void testTimedPollWithOffer() throws InterruptedException {
465 –        final LinkedBlockingQueue q = new LinkedBlockingQueue(2);
466 –        Thread t = new Thread(new CheckedRunnable() {
467 –            public void realRun() throws InterruptedException {
468 –                assertNull(q.poll(SHORT_DELAY_MS, MILLISECONDS));
469 –                assertSame(zero, q.poll(LONG_DELAY_MS, MILLISECONDS));
470 –                try {
471 –                    q.poll(LONG_DELAY_MS, MILLISECONDS);
472 –                    shouldThrow();
473 –                } catch (InterruptedException success) {}
474 –            }});
475 –
476 –        t.start();
477 –        Thread.sleep(SMALL_DELAY_MS);
478 –        assertTrue(q.offer(zero, SHORT_DELAY_MS, MILLISECONDS));
479 –        t.interrupt();
480 –        t.join();
481 –    }
482 –
483 –    /**
462       * peek returns next element, or null if empty
463       */
464      public void testPeek() {
# Line 686 | Line 664 | public class LinkedBlockingQueueTest ext
664      /**
665       * iterator.remove removes current element
666       */
667 <    public void testIteratorRemove () {
667 >    public void testIteratorRemove() {
668          final LinkedBlockingQueue q = new LinkedBlockingQueue(3);
669          q.add(two);
670          q.add(one);
# Line 697 | Line 675 | public class LinkedBlockingQueueTest ext
675          it.remove();
676  
677          it = q.iterator();
678 <        assertEquals(it.next(), one);
679 <        assertEquals(it.next(), three);
678 >        assertSame(it.next(), one);
679 >        assertSame(it.next(), three);
680          assertFalse(it.hasNext());
681      }
682  
# Line 722 | Line 700 | public class LinkedBlockingQueueTest ext
700      /**
701       * Modifications do not cause iterators to fail
702       */
703 <    public void testWeaklyConsistentIteration () {
703 >    public void testWeaklyConsistentIteration() {
704          final LinkedBlockingQueue q = new LinkedBlockingQueue(3);
705          q.add(one);
706          q.add(two);
# Line 757 | Line 735 | public class LinkedBlockingQueueTest ext
735          ExecutorService executor = Executors.newFixedThreadPool(2);
736          executor.execute(new CheckedRunnable() {
737              public void realRun() throws InterruptedException {
738 <                threadAssertFalse(q.offer(three));
739 <                threadAssertTrue(q.offer(three, MEDIUM_DELAY_MS, MILLISECONDS));
740 <                threadAssertEquals(0, q.remainingCapacity());
738 >                assertFalse(q.offer(three));
739 >                assertTrue(q.offer(three, MEDIUM_DELAY_MS, MILLISECONDS));
740 >                assertEquals(0, q.remainingCapacity());
741              }});
742  
743          executor.execute(new CheckedRunnable() {
744              public void realRun() throws InterruptedException {
745                  Thread.sleep(SMALL_DELAY_MS);
746 <                threadAssertEquals(one, q.take());
746 >                assertSame(one, q.take());
747              }});
748  
749          joinPool(executor);
# Line 779 | Line 757 | public class LinkedBlockingQueueTest ext
757          ExecutorService executor = Executors.newFixedThreadPool(2);
758          executor.execute(new CheckedRunnable() {
759              public void realRun() throws InterruptedException {
760 <                threadAssertNull(q.poll());
761 <                threadAssertTrue(null != q.poll(MEDIUM_DELAY_MS, MILLISECONDS));
762 <                threadAssertTrue(q.isEmpty());
760 >                assertNull(q.poll());
761 >                assertSame(one, q.poll(MEDIUM_DELAY_MS, MILLISECONDS));
762 >                assertTrue(q.isEmpty());
763              }});
764  
765          executor.execute(new CheckedRunnable() {
# Line 901 | Line 879 | public class LinkedBlockingQueueTest ext
879      }
880  
881      /**
882 <     * drainTo(c, n) empties first max {n, size} elements of queue into c
882 >     * drainTo(c, n) empties first min(n, size) elements of queue into c
883       */
884      public void testDrainToN() {
885          LinkedBlockingQueue q = new LinkedBlockingQueue();
# Line 910 | Line 888 | public class LinkedBlockingQueueTest ext
888                  assertTrue(q.offer(new Integer(j)));
889              ArrayList l = new ArrayList();
890              q.drainTo(l, i);
891 <            int k = (i < SIZE)? i : SIZE;
891 >            int k = (i < SIZE) ? i : SIZE;
892              assertEquals(l.size(), k);
893              assertEquals(q.size(), SIZE-k);
894              for (int j = 0; j < k; ++j)

Diff Legend

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