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.26 by jsr166, Thu May 30 03:28:55 2013 UTC vs.
Revision 1.38 by jsr166, Sun Oct 16 20:44:18 2016 UTC

# Line 6 | Line 6
6   * Pat Fisher, Mike Judd.
7   */
8  
9 – import junit.framework.*;
9   import java.util.Arrays;
10   import java.util.Collection;
11   import java.util.Comparator;
# Line 15 | Line 14 | 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 31 | Line 33 | public class PriorityQueueTest extends J
33  
34      /**
35       * Returns a new queue of given size containing consecutive
36 <     * Integers 0 ... n.
36 >     * Integers 0 ... n - 1.
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());
47 +        assertEquals((Integer) 0, q.peek());
48          return q;
49      }
50  
# Line 57 | Line 60 | public class PriorityQueueTest extends J
60       */
61      public void testConstructor2() {
62          try {
63 <            PriorityQueue q = new PriorityQueue(0);
63 >            new PriorityQueue(0);
64              shouldThrow();
65          } catch (IllegalArgumentException success) {}
66      }
# Line 67 | Line 70 | public class PriorityQueueTest extends J
70       */
71      public void testConstructor3() {
72          try {
73 <            PriorityQueue q = new PriorityQueue((Collection)null);
73 >            new PriorityQueue((Collection)null);
74              shouldThrow();
75          } catch (NullPointerException success) {}
76      }
# Line 77 | Line 80 | public class PriorityQueueTest extends J
80       */
81      public void testConstructor4() {
82          try {
83 <            Integer[] ints = new Integer[SIZE];
81 <            PriorityQueue q = new PriorityQueue(Arrays.asList(ints));
83 >            new PriorityQueue(Arrays.asList(new Integer[SIZE]));
84              shouldThrow();
85          } catch (NullPointerException success) {}
86      }
# Line 87 | Line 89 | public class PriorityQueueTest extends J
89       * Initializing from Collection with some null elements throws NPE
90       */
91      public void testConstructor5() {
92 +        Integer[] ints = new Integer[SIZE];
93 +        for (int i = 0; i < SIZE - 1; ++i)
94 +            ints[i] = new Integer(i);
95          try {
96 <            Integer[] ints = new Integer[SIZE];
92 <            for (int i = 0; i < SIZE-1; ++i)
93 <                ints[i] = new Integer(i);
94 <            PriorityQueue q = new PriorityQueue(Arrays.asList(ints));
96 >            new PriorityQueue(Arrays.asList(ints));
97              shouldThrow();
98          } catch (NullPointerException success) {}
99      }
# Line 119 | Line 121 | public class PriorityQueueTest extends J
121          for (int i = 0; i < SIZE; ++i)
122              ints[i] = new Integer(i);
123          q.addAll(Arrays.asList(ints));
124 <        for (int i = SIZE-1; i >= 0; --i)
124 >        for (int i = SIZE - 1; i >= 0; --i)
125              assertEquals(ints[i], q.poll());
126      }
127  
# Line 143 | Line 145 | public class PriorityQueueTest extends J
145      public void testSize() {
146          PriorityQueue q = populatedQueue(SIZE);
147          for (int i = 0; i < SIZE; ++i) {
148 <            assertEquals(SIZE-i, q.size());
148 >            assertEquals(SIZE - i, q.size());
149              q.remove();
150          }
151          for (int i = 0; i < SIZE; ++i) {
# Line 156 | Line 158 | public class PriorityQueueTest extends J
158       * offer(null) throws NPE
159       */
160      public void testOfferNull() {
161 +        PriorityQueue q = new PriorityQueue(1);
162          try {
160 –            PriorityQueue q = new PriorityQueue(1);
163              q.offer(null);
164              shouldThrow();
165          } catch (NullPointerException success) {}
# Line 167 | Line 169 | public class PriorityQueueTest extends J
169       * add(null) throws NPE
170       */
171      public void testAddNull() {
172 +        PriorityQueue q = new PriorityQueue(1);
173          try {
171 –            PriorityQueue q = new PriorityQueue(1);
174              q.add(null);
175              shouldThrow();
176          } catch (NullPointerException success) {}
# Line 187 | Line 189 | public class PriorityQueueTest extends J
189       * Offer of non-Comparable throws CCE
190       */
191      public void testOfferNonComparable() {
192 +        PriorityQueue q = new PriorityQueue(1);
193          try {
191 –            PriorityQueue q = new PriorityQueue(1);
192 –            q.offer(new Object());
193 –            q.offer(new Object());
194              q.offer(new Object());
195              shouldThrow();
196 <        } catch (ClassCastException success) {}
196 >        } catch (ClassCastException success) {
197 >            assertTrue(q.isEmpty());
198 >            assertEquals(0, q.size());
199 >            assertNull(q.poll());
200 >        }
201      }
202  
203      /**
# Line 211 | Line 215 | public class PriorityQueueTest extends J
215       * addAll(null) throws NPE
216       */
217      public void testAddAll1() {
218 +        PriorityQueue q = new PriorityQueue(1);
219          try {
215 –            PriorityQueue q = new PriorityQueue(1);
220              q.addAll(null);
221              shouldThrow();
222          } catch (NullPointerException success) {}
# Line 222 | Line 226 | public class PriorityQueueTest extends J
226       * addAll of a collection with null elements throws NPE
227       */
228      public void testAddAll2() {
229 +        PriorityQueue q = new PriorityQueue(SIZE);
230          try {
231 <            PriorityQueue q = new PriorityQueue(SIZE);
227 <            Integer[] ints = new Integer[SIZE];
228 <            q.addAll(Arrays.asList(ints));
231 >            q.addAll(Arrays.asList(new Integer[SIZE]));
232              shouldThrow();
233          } catch (NullPointerException success) {}
234      }
# Line 235 | Line 238 | public class PriorityQueueTest extends J
238       * possibly adding some elements
239       */
240      public void testAddAll3() {
241 +        PriorityQueue q = new PriorityQueue(SIZE);
242 +        Integer[] ints = new Integer[SIZE];
243 +        for (int i = 0; i < SIZE - 1; ++i)
244 +            ints[i] = new Integer(i);
245          try {
239 –            PriorityQueue q = new PriorityQueue(SIZE);
240 –            Integer[] ints = new Integer[SIZE];
241 –            for (int i = 0; i < SIZE-1; ++i)
242 –                ints[i] = new Integer(i);
246              q.addAll(Arrays.asList(ints));
247              shouldThrow();
248          } catch (NullPointerException success) {}
# Line 252 | Line 255 | public class PriorityQueueTest extends J
255          Integer[] empty = new Integer[0];
256          Integer[] ints = new Integer[SIZE];
257          for (int i = 0; i < SIZE; ++i)
258 <            ints[i] = new Integer(SIZE-1-i);
258 >            ints[i] = new Integer(SIZE - 1 - i);
259          PriorityQueue q = new PriorityQueue(SIZE);
260          assertFalse(q.addAll(Arrays.asList(empty)));
261          assertTrue(q.addAll(Arrays.asList(ints)));
# Line 319 | Line 322 | public class PriorityQueueTest extends J
322       */
323      public void testRemoveElement() {
324          PriorityQueue q = populatedQueue(SIZE);
325 <        for (int i = 1; i < SIZE; i+=2) {
325 >        for (int i = 1; i < SIZE; i += 2) {
326              assertTrue(q.contains(i));
327              assertTrue(q.remove(i));
328              assertFalse(q.contains(i));
329 <            assertTrue(q.contains(i-1));
329 >            assertTrue(q.contains(i - 1));
330          }
331 <        for (int i = 0; i < SIZE; i+=2) {
331 >        for (int i = 0; i < SIZE; i += 2) {
332              assertTrue(q.contains(i));
333              assertTrue(q.remove(i));
334              assertFalse(q.contains(i));
335 <            assertFalse(q.remove(i+1));
336 <            assertFalse(q.contains(i+1));
335 >            assertFalse(q.remove(i + 1));
336 >            assertFalse(q.contains(i + 1));
337          }
338          assertTrue(q.isEmpty());
339      }
# Line 389 | Line 392 | public class PriorityQueueTest extends J
392                  assertTrue(changed);
393  
394              assertTrue(q.containsAll(p));
395 <            assertEquals(SIZE-i, q.size());
395 >            assertEquals(SIZE - i, q.size());
396              p.remove();
397          }
398      }
# Line 402 | Line 405 | public class PriorityQueueTest extends J
405              PriorityQueue q = populatedQueue(SIZE);
406              PriorityQueue p = populatedQueue(i);
407              assertTrue(q.removeAll(p));
408 <            assertEquals(SIZE-i, q.size());
408 >            assertEquals(SIZE - i, q.size());
409              for (int j = 0; j < i; ++j) {
410 <                Integer I = (Integer)(p.remove());
411 <                assertFalse(q.contains(I));
410 >                Integer x = (Integer)(p.remove());
411 >                assertFalse(q.contains(x));
412              }
413          }
414      }
# Line 439 | Line 442 | public class PriorityQueueTest extends J
442       */
443      public void testIterator() {
444          PriorityQueue q = populatedQueue(SIZE);
442 –        int i = 0;
445          Iterator it = q.iterator();
446 <        while (it.hasNext()) {
446 >        int i;
447 >        for (i = 0; it.hasNext(); i++)
448              assertTrue(q.contains(it.next()));
446 –            ++i;
447 –        }
449          assertEquals(i, SIZE);
450 +        assertIteratorExhausted(it);
451 +    }
452 +
453 +    /**
454 +     * iterator of empty collection has no elements
455 +     */
456 +    public void testEmptyIterator() {
457 +        assertIteratorExhausted(new PriorityQueue().iterator());
458      }
459  
460      /**

Diff Legend

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