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.30 by jsr166, Sat Jan 17 22:55:06 2015 UTC vs.
Revision 1.38 by jsr166, Sun Oct 16 20:44:18 2016 UTC

# Line 19 | Line 19 | 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 33 | 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)
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 59 | 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 69 | 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 79 | Line 80 | public class PriorityQueueTest extends J
80       */
81      public void testConstructor4() {
82          try {
83 <            Integer[] ints = new Integer[SIZE];
83 <            PriorityQueue q = new PriorityQueue(Arrays.asList(ints));
83 >            new PriorityQueue(Arrays.asList(new Integer[SIZE]));
84              shouldThrow();
85          } catch (NullPointerException success) {}
86      }
# Line 89 | 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];
94 <            for (int i = 0; i < SIZE-1; ++i)
95 <                ints[i] = new Integer(i);
96 <            PriorityQueue q = new PriorityQueue(Arrays.asList(ints));
96 >            new PriorityQueue(Arrays.asList(ints));
97              shouldThrow();
98          } catch (NullPointerException success) {}
99      }
# Line 121 | 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 145 | 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 158 | 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 {
162 –            PriorityQueue q = new PriorityQueue(1);
163              q.offer(null);
164              shouldThrow();
165          } catch (NullPointerException success) {}
# Line 169 | 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 {
173 –            PriorityQueue q = new PriorityQueue(1);
174              q.add(null);
175              shouldThrow();
176          } catch (NullPointerException success) {}
# Line 189 | 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 {
193 –            PriorityQueue q = new PriorityQueue(1);
194 –            q.offer(new Object());
195 –            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 213 | 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 {
217 –            PriorityQueue q = new PriorityQueue(1);
220              q.addAll(null);
221              shouldThrow();
222          } catch (NullPointerException success) {}
# Line 224 | 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);
229 <            Integer[] ints = new Integer[SIZE];
230 <            q.addAll(Arrays.asList(ints));
231 >            q.addAll(Arrays.asList(new Integer[SIZE]));
232              shouldThrow();
233          } catch (NullPointerException success) {}
234      }
# Line 237 | 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 {
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);
246              q.addAll(Arrays.asList(ints));
247              shouldThrow();
248          } catch (NullPointerException success) {}
# Line 254 | 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 325 | Line 326 | public class PriorityQueueTest extends J
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) {
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 391 | 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 404 | 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 x = (Integer)(p.remove());
411                  assertFalse(q.contains(x));

Diff Legend

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