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

Comparing jsr166/src/test/tck/PriorityQueueTest.java (file contents):
Revision 1.21 by jsr166, Tue Mar 15 19:47:07 2011 UTC vs.
Revision 1.29 by jsr166, Wed Dec 31 20:17:40 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.Comparator;
12 > import java.util.Iterator;
13 > import java.util.NoSuchElementException;
14 > import java.util.PriorityQueue;
15 > import java.util.Queue;
16 >
17 > import junit.framework.Test;
18 > import junit.framework.TestSuite;
19  
20   public class PriorityQueueTest extends JSR166TestCase {
21      public static void main(String[] args) {
# Line 26 | Line 32 | public class PriorityQueueTest extends J
32      }
33  
34      /**
35 <     * Create a queue of given size containing consecutive
35 >     * Returns a new queue of given size containing consecutive
36       * Integers 0 ... n.
37       */
38      private PriorityQueue<Integer> populatedQueue(int n) {
39          PriorityQueue<Integer> q = new PriorityQueue<Integer>(n);
40          assertTrue(q.isEmpty());
41 <        for (int i = n-1; i >= 0; i-=2)
41 >        for (int i = n-1; i >= 0; i -= 2)
42              assertTrue(q.offer(new Integer(i)));
43 <        for (int i = (n & 1); i < n; i+=2)
43 >        for (int i = (n & 1); i < n; i += 2)
44              assertTrue(q.offer(new Integer(i)));
45          assertFalse(q.isEmpty());
46          assertEquals(n, q.size());
# Line 315 | Line 321 | public class PriorityQueueTest extends J
321       */
322      public void testRemoveElement() {
323          PriorityQueue q = populatedQueue(SIZE);
324 <        for (int i = 1; i < SIZE; i+=2) {
324 >        for (int i = 1; i < SIZE; i += 2) {
325              assertTrue(q.contains(i));
326              assertTrue(q.remove(i));
327              assertFalse(q.contains(i));
328              assertTrue(q.contains(i-1));
329          }
330 <        for (int i = 0; i < SIZE; i+=2) {
330 >        for (int i = 0; i < SIZE; i += 2) {
331              assertTrue(q.contains(i));
332              assertTrue(q.remove(i));
333              assertFalse(q.contains(i));
# Line 400 | Line 406 | public class PriorityQueueTest extends J
406              assertTrue(q.removeAll(p));
407              assertEquals(SIZE-i, q.size());
408              for (int j = 0; j < i; ++j) {
409 <                Integer I = (Integer)(p.remove());
410 <                assertFalse(q.contains(I));
409 >                Integer x = (Integer)(p.remove());
410 >                assertFalse(q.contains(x));
411              }
412          }
413      }
# Line 463 | Line 469 | public class PriorityQueueTest extends J
469          assertFalse(it.hasNext());
470      }
471  
466 –
472      /**
473       * toString contains toStrings of elements
474       */
# Line 471 | Line 476 | public class PriorityQueueTest extends J
476          PriorityQueue q = populatedQueue(SIZE);
477          String s = q.toString();
478          for (int i = 0; i < SIZE; ++i) {
479 <            assertTrue(s.indexOf(String.valueOf(i)) >= 0);
479 >            assertTrue(s.contains(String.valueOf(i)));
480          }
481      }
482  
# Line 479 | Line 484 | public class PriorityQueueTest extends J
484       * A deserialized serialized queue has same elements
485       */
486      public void testSerialization() throws Exception {
487 <        PriorityQueue q = populatedQueue(SIZE);
488 <        ByteArrayOutputStream bout = new ByteArrayOutputStream(10000);
489 <        ObjectOutputStream out = new ObjectOutputStream(new BufferedOutputStream(bout));
490 <        out.writeObject(q);
491 <        out.close();
492 <
493 <        ByteArrayInputStream bin = new ByteArrayInputStream(bout.toByteArray());
494 <        ObjectInputStream in = new ObjectInputStream(new BufferedInputStream(bin));
495 <        PriorityQueue r = (PriorityQueue)in.readObject();
496 <        assertEquals(q.size(), r.size());
492 <        while (!q.isEmpty())
493 <            assertEquals(q.remove(), r.remove());
487 >        Queue x = populatedQueue(SIZE);
488 >        Queue y = serialClone(x);
489 >
490 >        assertNotSame(x, y);
491 >        assertEquals(x.size(), y.size());
492 >        while (!x.isEmpty()) {
493 >            assertFalse(y.isEmpty());
494 >            assertEquals(x.remove(), y.remove());
495 >        }
496 >        assertTrue(y.isEmpty());
497      }
498   }

Diff Legend

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