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.47 by jsr166, Fri Jul 15 18:49:31 2011 UTC vs.
Revision 1.56 by jsr166, Wed Dec 31 20:17:39 2014 UTC

# Line 6 | Line 6
6   * Pat Fisher, Mike Judd.
7   */
8  
9 < import junit.framework.*;
10 < import java.util.Arrays;
9 > import static java.util.concurrent.TimeUnit.MILLISECONDS;
10 >
11   import java.util.ArrayList;
12 + import java.util.Arrays;
13   import java.util.Collection;
14   import java.util.Iterator;
15   import java.util.NoSuchElementException;
16   import java.util.Queue;
17   import java.util.concurrent.BlockingQueue;
18   import java.util.concurrent.CountDownLatch;
18 – import java.util.concurrent.LinkedBlockingQueue;
19   import java.util.concurrent.Executors;
20   import java.util.concurrent.ExecutorService;
21 < import static java.util.concurrent.TimeUnit.MILLISECONDS;
21 > import java.util.concurrent.LinkedBlockingQueue;
22 >
23 > import junit.framework.Test;
24  
25   public class LinkedBlockingQueueTest extends JSR166TestCase {
26  
# Line 45 | Line 47 | public class LinkedBlockingQueueTest ext
47      }
48  
49      /**
50 <     * Create a queue of given size containing consecutive
50 >     * Returns a new queue of given size containing consecutive
51       * Integers 0 ... n.
52       */
53      private LinkedBlockingQueue<Integer> populatedQueue(int n) {
# Line 245 | Line 247 | public class LinkedBlockingQueueTest ext
247      public void testPut() throws InterruptedException {
248          LinkedBlockingQueue q = new LinkedBlockingQueue(SIZE);
249          for (int i = 0; i < SIZE; ++i) {
250 <            Integer I = new Integer(i);
251 <            q.put(I);
252 <            assertTrue(q.contains(I));
250 >            Integer x = new Integer(i);
251 >            q.put(x);
252 >            assertTrue(q.contains(x));
253          }
254          assertEquals(0, q.remainingCapacity());
255      }
# Line 312 | Line 314 | public class LinkedBlockingQueueTest ext
314              }});
315  
316          await(pleaseTake);
317 <        assertEquals(q.remainingCapacity(), 0);
317 >        assertEquals(0, q.remainingCapacity());
318          assertEquals(0, q.take());
319  
320          await(pleaseInterrupt);
321          assertThreadStaysAlive(t);
322          t.interrupt();
323          awaitTermination(t);
324 <        assertEquals(q.remainingCapacity(), 0);
324 >        assertEquals(0, q.remainingCapacity());
325      }
326  
327      /**
# Line 513 | Line 515 | public class LinkedBlockingQueueTest ext
515          assertTrue(q.remove(new Integer(1)));
516          assertTrue(q.remove(new Integer(2)));
517          assertTrue(q.add(new Integer(3)));
518 <        assertTrue(q.take() != null);
518 >        assertNotNull(q.take());
519      }
520  
521      /**
# Line 587 | Line 589 | public class LinkedBlockingQueueTest ext
589              assertTrue(q.removeAll(p));
590              assertEquals(SIZE-i, q.size());
591              for (int j = 0; j < i; ++j) {
592 <                Integer I = (Integer)(p.remove());
593 <                assertFalse(q.contains(I));
592 >                Integer x = (Integer)(p.remove());
593 >                assertFalse(q.contains(x));
594              }
595          }
596      }
# Line 755 | Line 757 | public class LinkedBlockingQueueTest ext
757          Queue x = populatedQueue(SIZE);
758          Queue y = serialClone(x);
759  
760 <        assertTrue(x != y);
760 >        assertNotSame(x, y);
761          assertEquals(x.size(), y.size());
762          assertEquals(x.toString(), y.toString());
763          assertTrue(Arrays.equals(x.toArray(), y.toArray()));
# Line 773 | Line 775 | public class LinkedBlockingQueueTest ext
775          LinkedBlockingQueue q = populatedQueue(SIZE);
776          ArrayList l = new ArrayList();
777          q.drainTo(l);
778 <        assertEquals(q.size(), 0);
779 <        assertEquals(l.size(), SIZE);
778 >        assertEquals(0, q.size());
779 >        assertEquals(SIZE, l.size());
780          for (int i = 0; i < SIZE; ++i)
781              assertEquals(l.get(i), new Integer(i));
782          q.add(zero);
# Line 784 | Line 786 | public class LinkedBlockingQueueTest ext
786          assertTrue(q.contains(one));
787          l.clear();
788          q.drainTo(l);
789 <        assertEquals(q.size(), 0);
790 <        assertEquals(l.size(), 2);
789 >        assertEquals(0, q.size());
790 >        assertEquals(2, l.size());
791          for (int i = 0; i < 2; ++i)
792              assertEquals(l.get(i), new Integer(i));
793      }
# Line 821 | Line 823 | public class LinkedBlockingQueueTest ext
823              ArrayList l = new ArrayList();
824              q.drainTo(l, i);
825              int k = (i < SIZE) ? i : SIZE;
826 <            assertEquals(l.size(), k);
827 <            assertEquals(q.size(), SIZE-k);
826 >            assertEquals(k, l.size());
827 >            assertEquals(SIZE-k, q.size());
828              for (int j = 0; j < k; ++j)
829                  assertEquals(l.get(j), new Integer(j));
830 <            while (q.poll() != null) ;
830 >            do {} while (q.poll() != null);
831 >        }
832 >    }
833 >
834 >    /**
835 >     * remove(null), contains(null) always return false
836 >     */
837 >    public void testNeverContainsNull() {
838 >        Collection<?>[] qs = {
839 >            new LinkedBlockingQueue<Object>(),
840 >            populatedQueue(2),
841 >        };
842 >
843 >        for (Collection<?> q : qs) {
844 >            assertFalse(q.contains(null));
845 >            assertFalse(q.remove(null));
846          }
847      }
848  

Diff Legend

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