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.42 by jsr166, Sat Mar 11 18:20:47 2017 UTC

# Line 15 | Line 15 | import java.util.PriorityQueue;
15   import java.util.Queue;
16  
17   import junit.framework.Test;
18 – import junit.framework.TestSuite;
18  
19   public class PriorityQueueTest extends JSR166TestCase {
20      public static void main(String[] args) {
21 <        junit.textui.TestRunner.run(suite());
21 >        main(suite(), args);
22      }
23      public static Test suite() {
24 <        return new TestSuite(PriorityQueueTest.class);
24 >        class Implementation implements CollectionImplementation {
25 >            public Class<?> klazz() { return PriorityQueue.class; }
26 >            public Collection emptyCollection() { return new PriorityQueue(); }
27 >            public Object makeElement(int i) { return i; }
28 >            public boolean isConcurrent() { return false; }
29 >            public boolean permitsNulls() { return false; }
30 >        }
31 >        return newTestSuite(PriorityQueueTest.class,
32 >                            CollectionTest.testSuite(new Implementation()));
33      }
34  
35      static class MyReverseComparator implements Comparator {
# Line 33 | Line 40 | public class PriorityQueueTest extends J
40  
41      /**
42       * Returns a new queue of given size containing consecutive
43 <     * Integers 0 ... n.
43 >     * Integers 0 ... n - 1.
44       */
45 <    private PriorityQueue<Integer> populatedQueue(int n) {
46 <        PriorityQueue<Integer> q = new PriorityQueue<Integer>(n);
45 >    private static PriorityQueue<Integer> populatedQueue(int n) {
46 >        PriorityQueue<Integer> q = new PriorityQueue<>(n);
47          assertTrue(q.isEmpty());
48 <        for (int i = n-1; i >= 0; i -= 2)
48 >        for (int i = n - 1; i >= 0; i -= 2)
49              assertTrue(q.offer(new Integer(i)));
50          for (int i = (n & 1); i < n; i += 2)
51              assertTrue(q.offer(new Integer(i)));
52          assertFalse(q.isEmpty());
53          assertEquals(n, q.size());
54 +        assertEquals((Integer) 0, q.peek());
55          return q;
56      }
57  
# Line 59 | Line 67 | public class PriorityQueueTest extends J
67       */
68      public void testConstructor2() {
69          try {
70 <            PriorityQueue q = new PriorityQueue(0);
70 >            new PriorityQueue(0);
71              shouldThrow();
72          } catch (IllegalArgumentException success) {}
73      }
# Line 69 | Line 77 | public class PriorityQueueTest extends J
77       */
78      public void testConstructor3() {
79          try {
80 <            PriorityQueue q = new PriorityQueue((Collection)null);
80 >            new PriorityQueue((Collection)null);
81              shouldThrow();
82          } catch (NullPointerException success) {}
83      }
# Line 79 | Line 87 | public class PriorityQueueTest extends J
87       */
88      public void testConstructor4() {
89          try {
90 <            Integer[] ints = new Integer[SIZE];
83 <            PriorityQueue q = new PriorityQueue(Arrays.asList(ints));
90 >            new PriorityQueue(Arrays.asList(new Integer[SIZE]));
91              shouldThrow();
92          } catch (NullPointerException success) {}
93      }
# Line 89 | Line 96 | public class PriorityQueueTest extends J
96       * Initializing from Collection with some null elements throws NPE
97       */
98      public void testConstructor5() {
99 +        Integer[] ints = new Integer[SIZE];
100 +        for (int i = 0; i < SIZE - 1; ++i)
101 +            ints[i] = new Integer(i);
102          try {
103 <            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));
103 >            new PriorityQueue(Arrays.asList(ints));
104              shouldThrow();
105          } catch (NullPointerException success) {}
106      }
# Line 121 | Line 128 | public class PriorityQueueTest extends J
128          for (int i = 0; i < SIZE; ++i)
129              ints[i] = new Integer(i);
130          q.addAll(Arrays.asList(ints));
131 <        for (int i = SIZE-1; i >= 0; --i)
131 >        for (int i = SIZE - 1; i >= 0; --i)
132              assertEquals(ints[i], q.poll());
133      }
134  
# Line 145 | Line 152 | public class PriorityQueueTest extends J
152      public void testSize() {
153          PriorityQueue q = populatedQueue(SIZE);
154          for (int i = 0; i < SIZE; ++i) {
155 <            assertEquals(SIZE-i, q.size());
155 >            assertEquals(SIZE - i, q.size());
156              q.remove();
157          }
158          for (int i = 0; i < SIZE; ++i) {
# Line 158 | Line 165 | public class PriorityQueueTest extends J
165       * offer(null) throws NPE
166       */
167      public void testOfferNull() {
168 +        PriorityQueue q = new PriorityQueue(1);
169          try {
162 –            PriorityQueue q = new PriorityQueue(1);
170              q.offer(null);
171              shouldThrow();
172          } catch (NullPointerException success) {}
# Line 169 | Line 176 | public class PriorityQueueTest extends J
176       * add(null) throws NPE
177       */
178      public void testAddNull() {
179 +        PriorityQueue q = new PriorityQueue(1);
180          try {
173 –            PriorityQueue q = new PriorityQueue(1);
181              q.add(null);
182              shouldThrow();
183          } catch (NullPointerException success) {}
# Line 189 | Line 196 | public class PriorityQueueTest extends J
196       * Offer of non-Comparable throws CCE
197       */
198      public void testOfferNonComparable() {
199 +        PriorityQueue q = new PriorityQueue(1);
200          try {
193 –            PriorityQueue q = new PriorityQueue(1);
194 –            q.offer(new Object());
195 –            q.offer(new Object());
201              q.offer(new Object());
202              shouldThrow();
203 <        } catch (ClassCastException success) {}
203 >        } catch (ClassCastException success) {
204 >            assertTrue(q.isEmpty());
205 >            assertEquals(0, q.size());
206 >            assertNull(q.poll());
207 >        }
208      }
209  
210      /**
# Line 213 | Line 222 | public class PriorityQueueTest extends J
222       * addAll(null) throws NPE
223       */
224      public void testAddAll1() {
225 +        PriorityQueue q = new PriorityQueue(1);
226          try {
217 –            PriorityQueue q = new PriorityQueue(1);
227              q.addAll(null);
228              shouldThrow();
229          } catch (NullPointerException success) {}
# Line 224 | Line 233 | public class PriorityQueueTest extends J
233       * addAll of a collection with null elements throws NPE
234       */
235      public void testAddAll2() {
236 +        PriorityQueue q = new PriorityQueue(SIZE);
237          try {
238 <            PriorityQueue q = new PriorityQueue(SIZE);
229 <            Integer[] ints = new Integer[SIZE];
230 <            q.addAll(Arrays.asList(ints));
238 >            q.addAll(Arrays.asList(new Integer[SIZE]));
239              shouldThrow();
240          } catch (NullPointerException success) {}
241      }
# Line 237 | Line 245 | public class PriorityQueueTest extends J
245       * possibly adding some elements
246       */
247      public void testAddAll3() {
248 +        PriorityQueue q = new PriorityQueue(SIZE);
249 +        Integer[] ints = new Integer[SIZE];
250 +        for (int i = 0; i < SIZE - 1; ++i)
251 +            ints[i] = new Integer(i);
252          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);
253              q.addAll(Arrays.asList(ints));
254              shouldThrow();
255          } catch (NullPointerException success) {}
# Line 254 | Line 262 | public class PriorityQueueTest extends J
262          Integer[] empty = new Integer[0];
263          Integer[] ints = new Integer[SIZE];
264          for (int i = 0; i < SIZE; ++i)
265 <            ints[i] = new Integer(SIZE-1-i);
265 >            ints[i] = new Integer(SIZE - 1 - i);
266          PriorityQueue q = new PriorityQueue(SIZE);
267          assertFalse(q.addAll(Arrays.asList(empty)));
268          assertTrue(q.addAll(Arrays.asList(ints)));
# Line 325 | Line 333 | public class PriorityQueueTest extends J
333              assertTrue(q.contains(i));
334              assertTrue(q.remove(i));
335              assertFalse(q.contains(i));
336 <            assertTrue(q.contains(i-1));
336 >            assertTrue(q.contains(i - 1));
337          }
338          for (int i = 0; i < SIZE; i += 2) {
339              assertTrue(q.contains(i));
340              assertTrue(q.remove(i));
341              assertFalse(q.contains(i));
342 <            assertFalse(q.remove(i+1));
343 <            assertFalse(q.contains(i+1));
342 >            assertFalse(q.remove(i + 1));
343 >            assertFalse(q.contains(i + 1));
344          }
345          assertTrue(q.isEmpty());
346      }
# Line 391 | Line 399 | public class PriorityQueueTest extends J
399                  assertTrue(changed);
400  
401              assertTrue(q.containsAll(p));
402 <            assertEquals(SIZE-i, q.size());
402 >            assertEquals(SIZE - i, q.size());
403              p.remove();
404          }
405      }
# Line 404 | Line 412 | public class PriorityQueueTest extends J
412              PriorityQueue q = populatedQueue(SIZE);
413              PriorityQueue p = populatedQueue(i);
414              assertTrue(q.removeAll(p));
415 <            assertEquals(SIZE-i, q.size());
415 >            assertEquals(SIZE - i, q.size());
416              for (int j = 0; j < i; ++j) {
417                  Integer x = (Integer)(p.remove());
418                  assertFalse(q.contains(x));

Diff Legend

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