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

Comparing jsr166/src/test/tck/LinkedTransferQueueTest.java (file contents):
Revision 1.47 by jsr166, Mon May 30 22:43:20 2011 UTC vs.
Revision 1.59 by jsr166, Sat Apr 25 04:55:31 2015 UTC

# Line 5 | Line 5
5   * Other contributors include John Vint
6   */
7  
8 < import java.io.BufferedInputStream;
9 < import java.io.BufferedOutputStream;
10 < import java.io.ByteArrayInputStream;
11 < import java.io.ByteArrayOutputStream;
12 < import java.io.ObjectInputStream;
13 < import java.io.ObjectOutputStream;
8 > import static java.util.concurrent.TimeUnit.MILLISECONDS;
9 >
10   import java.util.ArrayList;
11   import java.util.Arrays;
12   import java.util.Collection;
13   import java.util.Iterator;
14   import java.util.List;
15   import java.util.NoSuchElementException;
16 + import java.util.Queue;
17   import java.util.concurrent.BlockingQueue;
18   import java.util.concurrent.CountDownLatch;
19   import java.util.concurrent.Executors;
20   import java.util.concurrent.ExecutorService;
21   import java.util.concurrent.LinkedTransferQueue;
22 < import static java.util.concurrent.TimeUnit.MILLISECONDS;
26 < import static java.util.concurrent.TimeUnit.NANOSECONDS;
22 >
23   import junit.framework.Test;
28 – import junit.framework.TestSuite;
24  
25   @SuppressWarnings({"unchecked", "rawtypes"})
26   public class LinkedTransferQueueTest extends JSR166TestCase {
# Line 37 | Line 32 | public class LinkedTransferQueueTest ext
32      }
33  
34      public static void main(String[] args) {
35 <        junit.textui.TestRunner.run(suite());
35 >        main(suite(), args);
36      }
37  
38      public static Test suite() {
# Line 120 | Line 115 | public class LinkedTransferQueueTest ext
115       * remainingCapacity() always returns Integer.MAX_VALUE
116       */
117      public void testRemainingCapacity() {
118 <        LinkedTransferQueue<Integer> q = populatedQueue(SIZE);
118 >        BlockingQueue q = populatedQueue(SIZE);
119          for (int i = 0; i < SIZE; ++i) {
120              assertEquals(Integer.MAX_VALUE, q.remainingCapacity());
121              assertEquals(SIZE - i, q.size());
122 <            q.remove();
122 >            assertEquals(i, q.remove());
123          }
124          for (int i = 0; i < SIZE; ++i) {
125              assertEquals(Integer.MAX_VALUE, q.remainingCapacity());
126              assertEquals(i, q.size());
127 <            q.add(i);
127 >            assertTrue(q.add(i));
128          }
129      }
130  
# Line 183 | Line 178 | public class LinkedTransferQueueTest ext
178      public void testPut() {
179          LinkedTransferQueue<Integer> q = new LinkedTransferQueue<Integer>();
180          for (int i = 0; i < SIZE; ++i) {
181 <            assertEquals(q.size(), i);
181 >            assertEquals(i, q.size());
182              q.put(i);
183              assertTrue(q.contains(i));
184          }
# Line 374 | Line 369 | public class LinkedTransferQueueTest ext
369      }
370  
371      /**
377 –     * remove(x) removes x and returns true if present
378 –     */
379 –    public void testRemoveElement() throws InterruptedException {
380 –        LinkedTransferQueue q = populatedQueue(SIZE);
381 –        for (int i = 1; i < SIZE; i+=2) {
382 –            assertTrue(q.contains(i));
383 –            assertTrue(q.remove(i));
384 –            assertFalse(q.contains(i));
385 –            assertTrue(q.contains(i-1));
386 –        }
387 –        for (int i = 0; i < SIZE; i+=2) {
388 –            assertTrue(q.contains(i));
389 –            assertTrue(q.remove(i));
390 –            assertFalse(q.contains(i));
391 –            assertFalse(q.remove(i+1));
392 –            assertFalse(q.contains(i+1));
393 –        }
394 –        checkEmpty(q);
395 –    }
396 –
397 –    /**
372       * An add following remove(x) succeeds
373       */
374      public void testRemoveElementAndAdd() throws InterruptedException {
# Line 526 | Line 500 | public class LinkedTransferQueueTest ext
500      public void testIterator() throws InterruptedException {
501          LinkedTransferQueue q = populatedQueue(SIZE);
502          Iterator it = q.iterator();
503 <        int i = 0;
504 <        while (it.hasNext()) {
505 <            assertEquals(it.next(), i++);
532 <        }
503 >        int i;
504 >        for (i = 0; it.hasNext(); i++)
505 >            assertTrue(q.contains(it.next()));
506          assertEquals(i, SIZE);
507 +        assertIteratorExhausted(it);
508 +
509 +        it = q.iterator();
510 +        for (i = 0; it.hasNext(); i++)
511 +            assertEquals(it.next(), q.take());
512 +        assertEquals(i, SIZE);
513 +        assertIteratorExhausted(it);
514 +    }
515 +
516 +    /**
517 +     * iterator of empty collection has no elements
518 +     */
519 +    public void testEmptyIterator() {
520 +        assertIteratorExhausted(new LinkedTransferQueue().iterator());
521      }
522  
523      /**
# Line 649 | Line 636 | public class LinkedTransferQueueTest ext
636       * A deserialized serialized queue has same elements in same order
637       */
638      public void testSerialization() throws Exception {
639 <        LinkedTransferQueue q = populatedQueue(SIZE);
639 >        Queue x = populatedQueue(SIZE);
640 >        Queue y = serialClone(x);
641  
642 <        ByteArrayOutputStream bout = new ByteArrayOutputStream(10000);
643 <        ObjectOutputStream out
644 <            = new ObjectOutputStream(new BufferedOutputStream(bout));
645 <        out.writeObject(q);
646 <        out.close();
647 <
648 <        ByteArrayInputStream bin
661 <            = new ByteArrayInputStream(bout.toByteArray());
662 <        ObjectInputStream in
663 <            = new ObjectInputStream(new BufferedInputStream(bin));
664 <        LinkedTransferQueue r = (LinkedTransferQueue) in.readObject();
665 <
666 <        assertEquals(q.size(), r.size());
667 <        assertEquals(q.toString(), r.toString());
668 <        assertTrue(Arrays.equals(q.toArray(), r.toArray()));
669 <        while (!q.isEmpty()) {
670 <            assertEquals(q.remove(), r.remove());
642 >        assertNotSame(y, x);
643 >        assertEquals(x.size(), y.size());
644 >        assertEquals(x.toString(), y.toString());
645 >        assertTrue(Arrays.equals(x.toArray(), y.toArray()));
646 >        while (!x.isEmpty()) {
647 >            assertFalse(y.isEmpty());
648 >            assertEquals(x.remove(), y.remove());
649          }
650 +        assertTrue(y.isEmpty());
651      }
652  
653      /**
# Line 678 | Line 657 | public class LinkedTransferQueueTest ext
657          LinkedTransferQueue q = populatedQueue(SIZE);
658          ArrayList l = new ArrayList();
659          q.drainTo(l);
660 <        assertEquals(q.size(), 0);
661 <        assertEquals(l.size(), SIZE);
660 >        assertEquals(0, q.size());
661 >        assertEquals(SIZE, l.size());
662          for (int i = 0; i < SIZE; ++i) {
663 <            assertEquals(l.get(i), i);
663 >            assertEquals(i, l.get(i));
664          }
665          q.add(zero);
666          q.add(one);
# Line 690 | Line 669 | public class LinkedTransferQueueTest ext
669          assertTrue(q.contains(one));
670          l.clear();
671          q.drainTo(l);
672 <        assertEquals(q.size(), 0);
673 <        assertEquals(l.size(), 2);
672 >        assertEquals(0, q.size());
673 >        assertEquals(2, l.size());
674          for (int i = 0; i < 2; ++i) {
675 <            assertEquals(l.get(i), i);
675 >            assertEquals(i, l.get(i));
676          }
677      }
678  
# Line 709 | Line 688 | public class LinkedTransferQueueTest ext
688          ArrayList l = new ArrayList();
689          q.drainTo(l);
690          assertTrue(l.size() >= SIZE);
691 <        for (int i = 0; i < SIZE; ++i) {
692 <            assertEquals(l.get(i), i);
714 <        }
691 >        for (int i = 0; i < SIZE; ++i)
692 >            assertEquals(i, l.get(i));
693          awaitTermination(t, MEDIUM_DELAY_MS);
694          assertTrue(q.size() + l.size() >= SIZE);
695      }
# Line 728 | Line 706 | public class LinkedTransferQueueTest ext
706              ArrayList l = new ArrayList();
707              q.drainTo(l, i);
708              int k = (i < SIZE) ? i : SIZE;
709 <            assertEquals(l.size(), k);
710 <            assertEquals(q.size(), SIZE - k);
711 <            for (int j = 0; j < k; ++j) {
712 <                assertEquals(l.get(j), j);
713 <            }
736 <            while (q.poll() != null)
737 <                ;
709 >            assertEquals(k, l.size());
710 >            assertEquals(SIZE - k, q.size());
711 >            for (int j = 0; j < k; ++j)
712 >                assertEquals(j, l.get(j));
713 >            do {} while (q.poll() != null);
714          }
715      }
716  
# Line 744 | Line 720 | public class LinkedTransferQueueTest ext
720       */
721      public void testWaitingConsumer() throws InterruptedException {
722          final LinkedTransferQueue q = new LinkedTransferQueue();
723 <        assertEquals(q.getWaitingConsumerCount(), 0);
723 >        assertEquals(0, q.getWaitingConsumerCount());
724          assertFalse(q.hasWaitingConsumer());
725          final CountDownLatch threadStarted = new CountDownLatch(1);
726  
# Line 752 | Line 728 | public class LinkedTransferQueueTest ext
728              public void realRun() throws InterruptedException {
729                  threadStarted.countDown();
730                  assertSame(one, q.poll(LONG_DELAY_MS, MILLISECONDS));
731 <                assertEquals(q.getWaitingConsumerCount(), 0);
731 >                assertEquals(0, q.getWaitingConsumerCount());
732                  assertFalse(q.hasWaitingConsumer());
733              }});
734  
735          threadStarted.await();
736          waitForThreadToEnterWaitState(t, SMALL_DELAY_MS);
737 <        assertEquals(q.getWaitingConsumerCount(), 1);
737 >        assertEquals(1, q.getWaitingConsumerCount());
738          assertTrue(q.hasWaitingConsumer());
739  
740          assertTrue(q.offer(one));
741 <        assertEquals(q.getWaitingConsumerCount(), 0);
741 >        assertEquals(0, q.getWaitingConsumerCount());
742          assertFalse(q.hasWaitingConsumer());
743  
744          awaitTermination(t, MEDIUM_DELAY_MS);
# Line 1050 | Line 1026 | public class LinkedTransferQueueTest ext
1026          assertFalse(q.isEmpty());
1027          return q;
1028      }
1029 +
1030 +    /**
1031 +     * remove(null), contains(null) always return false
1032 +     */
1033 +    public void testNeverContainsNull() {
1034 +        Collection<?>[] qs = {
1035 +            new LinkedTransferQueue<Object>(),
1036 +            populatedQueue(2),
1037 +        };
1038 +
1039 +        for (Collection<?> q : qs) {
1040 +            assertFalse(q.contains(null));
1041 +            assertFalse(q.remove(null));
1042 +        }
1043 +    }
1044   }

Diff Legend

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