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.34 by jsr166, Fri May 15 18:21:19 2015 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) {
22 <        junit.textui.TestRunner.run(suite());
22 >        main(suite(), args);
23      }
24      public static Test suite() {
25          return new TestSuite(PriorityQueueTest.class);
# 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 53 | Line 59 | public class PriorityQueueTest extends J
59       */
60      public void testConstructor2() {
61          try {
62 <            PriorityQueue q = new PriorityQueue(0);
62 >            new PriorityQueue(0);
63              shouldThrow();
64          } catch (IllegalArgumentException success) {}
65      }
# Line 63 | Line 69 | public class PriorityQueueTest extends J
69       */
70      public void testConstructor3() {
71          try {
72 <            PriorityQueue q = new PriorityQueue((Collection)null);
72 >            new PriorityQueue((Collection)null);
73              shouldThrow();
74          } catch (NullPointerException success) {}
75      }
# Line 73 | Line 79 | public class PriorityQueueTest extends J
79       */
80      public void testConstructor4() {
81          try {
82 <            Integer[] ints = new Integer[SIZE];
77 <            PriorityQueue q = new PriorityQueue(Arrays.asList(ints));
82 >            new PriorityQueue(Arrays.asList(new Integer[SIZE]));
83              shouldThrow();
84          } catch (NullPointerException success) {}
85      }
# Line 83 | Line 88 | public class PriorityQueueTest extends J
88       * Initializing from Collection with some null elements throws NPE
89       */
90      public void testConstructor5() {
91 +        Integer[] ints = new Integer[SIZE];
92 +        for (int i = 0; i < SIZE-1; ++i)
93 +            ints[i] = new Integer(i);
94          try {
95 <            Integer[] ints = new Integer[SIZE];
88 <            for (int i = 0; i < SIZE-1; ++i)
89 <                ints[i] = new Integer(i);
90 <            PriorityQueue q = new PriorityQueue(Arrays.asList(ints));
95 >            new PriorityQueue(Arrays.asList(ints));
96              shouldThrow();
97          } catch (NullPointerException success) {}
98      }
# Line 152 | Line 157 | public class PriorityQueueTest extends J
157       * offer(null) throws NPE
158       */
159      public void testOfferNull() {
160 +        PriorityQueue q = new PriorityQueue(1);
161          try {
156 –            PriorityQueue q = new PriorityQueue(1);
162              q.offer(null);
163              shouldThrow();
164          } catch (NullPointerException success) {}
# Line 163 | Line 168 | public class PriorityQueueTest extends J
168       * add(null) throws NPE
169       */
170      public void testAddNull() {
171 +        PriorityQueue q = new PriorityQueue(1);
172          try {
167 –            PriorityQueue q = new PriorityQueue(1);
173              q.add(null);
174              shouldThrow();
175          } catch (NullPointerException success) {}
# Line 183 | Line 188 | public class PriorityQueueTest extends J
188       * Offer of non-Comparable throws CCE
189       */
190      public void testOfferNonComparable() {
191 +        PriorityQueue q = new PriorityQueue(1);
192          try {
187 –            PriorityQueue q = new PriorityQueue(1);
188 –            q.offer(new Object());
193              q.offer(new Object());
194              q.offer(new Object());
195              shouldThrow();
# Line 207 | Line 211 | public class PriorityQueueTest extends J
211       * addAll(null) throws NPE
212       */
213      public void testAddAll1() {
214 +        PriorityQueue q = new PriorityQueue(1);
215          try {
211 –            PriorityQueue q = new PriorityQueue(1);
216              q.addAll(null);
217              shouldThrow();
218          } catch (NullPointerException success) {}
# Line 218 | Line 222 | public class PriorityQueueTest extends J
222       * addAll of a collection with null elements throws NPE
223       */
224      public void testAddAll2() {
225 +        PriorityQueue q = new PriorityQueue(SIZE);
226          try {
227 <            PriorityQueue q = new PriorityQueue(SIZE);
223 <            Integer[] ints = new Integer[SIZE];
224 <            q.addAll(Arrays.asList(ints));
227 >            q.addAll(Arrays.asList(new Integer[SIZE]));
228              shouldThrow();
229          } catch (NullPointerException success) {}
230      }
# Line 231 | Line 234 | public class PriorityQueueTest extends J
234       * possibly adding some elements
235       */
236      public void testAddAll3() {
237 +        PriorityQueue q = new PriorityQueue(SIZE);
238 +        Integer[] ints = new Integer[SIZE];
239 +        for (int i = 0; i < SIZE-1; ++i)
240 +            ints[i] = new Integer(i);
241          try {
235 –            PriorityQueue q = new PriorityQueue(SIZE);
236 –            Integer[] ints = new Integer[SIZE];
237 –            for (int i = 0; i < SIZE-1; ++i)
238 –                ints[i] = new Integer(i);
242              q.addAll(Arrays.asList(ints));
243              shouldThrow();
244          } catch (NullPointerException success) {}
# Line 315 | Line 318 | public class PriorityQueueTest extends J
318       */
319      public void testRemoveElement() {
320          PriorityQueue q = populatedQueue(SIZE);
321 <        for (int i = 1; i < SIZE; i+=2) {
321 >        for (int i = 1; i < SIZE; i += 2) {
322              assertTrue(q.contains(i));
323              assertTrue(q.remove(i));
324              assertFalse(q.contains(i));
325              assertTrue(q.contains(i-1));
326          }
327 <        for (int i = 0; i < SIZE; i+=2) {
327 >        for (int i = 0; i < SIZE; i += 2) {
328              assertTrue(q.contains(i));
329              assertTrue(q.remove(i));
330              assertFalse(q.contains(i));
# Line 400 | Line 403 | public class PriorityQueueTest extends J
403              assertTrue(q.removeAll(p));
404              assertEquals(SIZE-i, q.size());
405              for (int j = 0; j < i; ++j) {
406 <                Integer I = (Integer)(p.remove());
407 <                assertFalse(q.contains(I));
406 >                Integer x = (Integer)(p.remove());
407 >                assertFalse(q.contains(x));
408              }
409          }
410      }
# Line 435 | Line 438 | public class PriorityQueueTest extends J
438       */
439      public void testIterator() {
440          PriorityQueue q = populatedQueue(SIZE);
438 –        int i = 0;
441          Iterator it = q.iterator();
442 <        while (it.hasNext()) {
442 >        int i;
443 >        for (i = 0; it.hasNext(); i++)
444              assertTrue(q.contains(it.next()));
442 –            ++i;
443 –        }
445          assertEquals(i, SIZE);
446 +        assertIteratorExhausted(it);
447 +    }
448 +
449 +    /**
450 +     * iterator of empty collection has no elements
451 +     */
452 +    public void testEmptyIterator() {
453 +        assertIteratorExhausted(new PriorityQueue().iterator());
454      }
455  
456      /**
# Line 463 | Line 472 | public class PriorityQueueTest extends J
472          assertFalse(it.hasNext());
473      }
474  
466 –
475      /**
476       * toString contains toStrings of elements
477       */
# Line 471 | Line 479 | public class PriorityQueueTest extends J
479          PriorityQueue q = populatedQueue(SIZE);
480          String s = q.toString();
481          for (int i = 0; i < SIZE; ++i) {
482 <            assertTrue(s.indexOf(String.valueOf(i)) >= 0);
482 >            assertTrue(s.contains(String.valueOf(i)));
483          }
484      }
485  
# Line 479 | Line 487 | public class PriorityQueueTest extends J
487       * A deserialized serialized queue has same elements
488       */
489      public void testSerialization() throws Exception {
490 <        PriorityQueue q = populatedQueue(SIZE);
491 <        ByteArrayOutputStream bout = new ByteArrayOutputStream(10000);
492 <        ObjectOutputStream out = new ObjectOutputStream(new BufferedOutputStream(bout));
493 <        out.writeObject(q);
494 <        out.close();
495 <
496 <        ByteArrayInputStream bin = new ByteArrayInputStream(bout.toByteArray());
497 <        ObjectInputStream in = new ObjectInputStream(new BufferedInputStream(bin));
498 <        PriorityQueue r = (PriorityQueue)in.readObject();
499 <        assertEquals(q.size(), r.size());
492 <        while (!q.isEmpty())
493 <            assertEquals(q.remove(), r.remove());
490 >        Queue x = populatedQueue(SIZE);
491 >        Queue y = serialClone(x);
492 >
493 >        assertNotSame(x, y);
494 >        assertEquals(x.size(), y.size());
495 >        while (!x.isEmpty()) {
496 >            assertFalse(y.isEmpty());
497 >            assertEquals(x.remove(), y.remove());
498 >        }
499 >        assertTrue(y.isEmpty());
500      }
501   }

Diff Legend

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