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

Comparing jsr166/src/test/tck/ConcurrentLinkedQueueTest.java (file contents):
Revision 1.25 by jsr166, Tue Mar 15 19:47:06 2011 UTC vs.
Revision 1.34 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.*;
11 < import java.util.concurrent.*;
12 < import java.io.*;
9 > import java.util.Arrays;
10 > import java.util.Collection;
11 > import java.util.Iterator;
12 > import java.util.NoSuchElementException;
13 > import java.util.Queue;
14 > import java.util.concurrent.ConcurrentLinkedQueue;
15 >
16 > import junit.framework.Test;
17 > import junit.framework.TestSuite;
18  
19   public class ConcurrentLinkedQueueTest extends JSR166TestCase {
20  
# Line 22 | Line 27 | public class ConcurrentLinkedQueueTest e
27      }
28  
29      /**
30 <     * Create a queue of given size containing consecutive
30 >     * Returns a new queue of given size containing consecutive
31       * Integers 0 ... n.
32       */
33      private ConcurrentLinkedQueue<Integer> populatedQueue(int n) {
# Line 139 | Line 144 | public class ConcurrentLinkedQueueTest e
144          } catch (NullPointerException success) {}
145      }
146  
142 –
147      /**
148       * Offer returns true
149       */
# Line 283 | Line 287 | public class ConcurrentLinkedQueueTest e
287       */
288      public void testRemoveElement() {
289          ConcurrentLinkedQueue q = populatedQueue(SIZE);
290 <        for (int i = 1; i < SIZE; i+=2) {
290 >        for (int i = 1; i < SIZE; i += 2) {
291              assertTrue(q.contains(i));
292              assertTrue(q.remove(i));
293              assertFalse(q.contains(i));
294              assertTrue(q.contains(i-1));
295          }
296 <        for (int i = 0; i < SIZE; i+=2) {
296 >        for (int i = 0; i < SIZE; i += 2) {
297              assertTrue(q.contains(i));
298              assertTrue(q.remove(i));
299              assertFalse(q.contains(i));
# Line 368 | Line 372 | public class ConcurrentLinkedQueueTest e
372              assertTrue(q.removeAll(p));
373              assertEquals(SIZE-i, q.size());
374              for (int j = 0; j < i; ++j) {
375 <                Integer I = (Integer)(p.remove());
376 <                assertFalse(q.contains(I));
375 >                Integer x = (Integer)(p.remove());
376 >                assertFalse(q.contains(x));
377              }
378          }
379      }
# Line 483 | Line 487 | public class ConcurrentLinkedQueueTest e
487          assertFalse(it.hasNext());
488      }
489  
486 –
490      /**
491       * toString contains toStrings of elements
492       */
# Line 491 | Line 494 | public class ConcurrentLinkedQueueTest e
494          ConcurrentLinkedQueue q = populatedQueue(SIZE);
495          String s = q.toString();
496          for (int i = 0; i < SIZE; ++i) {
497 <            assertTrue(s.indexOf(String.valueOf(i)) >= 0);
497 >            assertTrue(s.contains(String.valueOf(i)));
498          }
499      }
500  
# Line 499 | Line 502 | public class ConcurrentLinkedQueueTest e
502       * A deserialized serialized queue has same elements in same order
503       */
504      public void testSerialization() throws Exception {
505 <        ConcurrentLinkedQueue q = populatedQueue(SIZE);
506 <        ByteArrayOutputStream bout = new ByteArrayOutputStream(10000);
507 <        ObjectOutputStream out = new ObjectOutputStream(new BufferedOutputStream(bout));
508 <        out.writeObject(q);
509 <        out.close();
510 <
511 <        ByteArrayInputStream bin = new ByteArrayInputStream(bout.toByteArray());
512 <        ObjectInputStream in = new ObjectInputStream(new BufferedInputStream(bin));
513 <        ConcurrentLinkedQueue r = (ConcurrentLinkedQueue)in.readObject();
514 <        assertEquals(q.size(), r.size());
515 <        while (!q.isEmpty())
516 <            assertEquals(q.remove(), r.remove());
505 >        Queue x = populatedQueue(SIZE);
506 >        Queue y = serialClone(x);
507 >
508 >        assertNotSame(x, y);
509 >        assertEquals(x.size(), y.size());
510 >        assertEquals(x.toString(), y.toString());
511 >        assertTrue(Arrays.equals(x.toArray(), y.toArray()));
512 >        while (!x.isEmpty()) {
513 >            assertFalse(y.isEmpty());
514 >            assertEquals(x.remove(), y.remove());
515 >        }
516 >        assertTrue(y.isEmpty());
517      }
518  
519 +    /**
520 +     * remove(null), contains(null) always return false
521 +     */
522 +    public void testNeverContainsNull() {
523 +        Collection<?>[] qs = {
524 +            new ConcurrentLinkedQueue<Object>(),
525 +            populatedQueue(2),
526 +        };
527 +
528 +        for (Collection<?> q : qs) {
529 +            assertFalse(q.contains(null));
530 +            assertFalse(q.remove(null));
531 +        }
532 +    }
533   }

Diff Legend

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