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.50 by jsr166, Sat Nov 26 05:19:17 2011 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;
14 < import java.util.ArrayList;
8 > import junit.framework.*;
9   import java.util.Arrays;
10 + import java.util.ArrayList;
11   import java.util.Collection;
12   import java.util.Iterator;
13   import java.util.List;
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;
# Line 24 | Line 20 | import java.util.concurrent.ExecutorServ
20   import java.util.concurrent.LinkedTransferQueue;
21   import static java.util.concurrent.TimeUnit.MILLISECONDS;
22   import static java.util.concurrent.TimeUnit.NANOSECONDS;
27 – import junit.framework.Test;
28 – import junit.framework.TestSuite;
23  
24   @SuppressWarnings({"unchecked", "rawtypes"})
25   public class LinkedTransferQueueTest extends JSR166TestCase {
# Line 374 | Line 368 | public class LinkedTransferQueueTest ext
368      }
369  
370      /**
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 –    /**
371       * An add following remove(x) succeeds
372       */
373      public void testRemoveElementAndAdd() throws InterruptedException {
# Line 649 | Line 622 | public class LinkedTransferQueueTest ext
622       * A deserialized serialized queue has same elements in same order
623       */
624      public void testSerialization() throws Exception {
625 <        LinkedTransferQueue q = populatedQueue(SIZE);
625 >        Queue x = populatedQueue(SIZE);
626 >        Queue y = serialClone(x);
627  
628 <        ByteArrayOutputStream bout = new ByteArrayOutputStream(10000);
629 <        ObjectOutputStream out
630 <            = new ObjectOutputStream(new BufferedOutputStream(bout));
631 <        out.writeObject(q);
632 <        out.close();
633 <
634 <        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());
628 >        assertTrue(x != y);
629 >        assertEquals(x.size(), y.size());
630 >        assertEquals(x.toString(), y.toString());
631 >        assertTrue(Arrays.equals(x.toArray(), y.toArray()));
632 >        while (!x.isEmpty()) {
633 >            assertFalse(y.isEmpty());
634 >            assertEquals(x.remove(), y.remove());
635          }
636 +        assertTrue(y.isEmpty());
637      }
638  
639      /**
# Line 678 | Line 643 | public class LinkedTransferQueueTest ext
643          LinkedTransferQueue q = populatedQueue(SIZE);
644          ArrayList l = new ArrayList();
645          q.drainTo(l);
646 <        assertEquals(q.size(), 0);
647 <        assertEquals(l.size(), SIZE);
646 >        assertEquals(0, q.size());
647 >        assertEquals(SIZE, l.size());
648          for (int i = 0; i < SIZE; ++i) {
649              assertEquals(l.get(i), i);
650          }
# Line 690 | Line 655 | public class LinkedTransferQueueTest ext
655          assertTrue(q.contains(one));
656          l.clear();
657          q.drainTo(l);
658 <        assertEquals(q.size(), 0);
659 <        assertEquals(l.size(), 2);
658 >        assertEquals(0, q.size());
659 >        assertEquals(2, l.size());
660          for (int i = 0; i < 2; ++i) {
661              assertEquals(l.get(i), i);
662          }
# Line 744 | Line 709 | public class LinkedTransferQueueTest ext
709       */
710      public void testWaitingConsumer() throws InterruptedException {
711          final LinkedTransferQueue q = new LinkedTransferQueue();
712 <        assertEquals(q.getWaitingConsumerCount(), 0);
712 >        assertEquals(0, q.getWaitingConsumerCount());
713          assertFalse(q.hasWaitingConsumer());
714          final CountDownLatch threadStarted = new CountDownLatch(1);
715  
# Line 752 | Line 717 | public class LinkedTransferQueueTest ext
717              public void realRun() throws InterruptedException {
718                  threadStarted.countDown();
719                  assertSame(one, q.poll(LONG_DELAY_MS, MILLISECONDS));
720 <                assertEquals(q.getWaitingConsumerCount(), 0);
720 >                assertEquals(0, q.getWaitingConsumerCount());
721                  assertFalse(q.hasWaitingConsumer());
722              }});
723  
724          threadStarted.await();
725          waitForThreadToEnterWaitState(t, SMALL_DELAY_MS);
726 <        assertEquals(q.getWaitingConsumerCount(), 1);
726 >        assertEquals(1, q.getWaitingConsumerCount());
727          assertTrue(q.hasWaitingConsumer());
728  
729          assertTrue(q.offer(one));
730 <        assertEquals(q.getWaitingConsumerCount(), 0);
730 >        assertEquals(0, q.getWaitingConsumerCount());
731          assertFalse(q.hasWaitingConsumer());
732  
733          awaitTermination(t, MEDIUM_DELAY_MS);

Diff Legend

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