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.11 by jsr166, Mon Nov 16 05:30:08 2009 UTC vs.
Revision 1.32 by jsr166, Sat Feb 28 20:13:46 2015 UTC

# Line 1 | Line 1
1   /*
2   * Written by Doug Lea with assistance from members of JCP JSR-166
3   * Expert Group and released to the public domain, as explained at
4 < * http://creativecommons.org/licenses/publicdomain
4 > * http://creativecommons.org/publicdomain/zero/1.0/
5   * Other contributors include Andrew Wright, Jeffrey Hayes,
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 >        junit.textui.TestRunner.run(suite());
23      }
24      public static Test suite() {
25 <        return new TestSuite(PriorityQueueTest.class);
25 >        return new TestSuite(PriorityQueueTest.class);
26      }
27  
28      static class MyReverseComparator implements Comparator {
29          public int compare(Object x, Object y) {
30 <            int i = ((Integer)x).intValue();
25 <            int j = ((Integer)y).intValue();
26 <            if (i < j) return 1;
27 <            if (i > j) return -1;
28 <            return 0;
30 >            return ((Comparable)y).compareTo(x);
31          }
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 populatedQueue(int n) {
39 <        PriorityQueue q = new PriorityQueue(n);
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)
42 <            assertTrue(q.offer(new Integer(i)));
43 <        for (int i = (n & 1); i < n; i+=2)
44 <            assertTrue(q.offer(new Integer(i)));
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());
46 >        assertEquals(n, q.size());
47          return q;
48      }
49  
# Line 53 | Line 55 | public class PriorityQueueTest extends J
55      }
56  
57      /**
58 <     * Constructor throws IAE if  capacity argument nonpositive
58 >     * Constructor throws IAE if capacity argument nonpositive
59       */
60      public void testConstructor2() {
61          try {
62 <            PriorityQueue q = new PriorityQueue(0);
62 >            new PriorityQueue(0);
63              shouldThrow();
64 <        }
63 <        catch (IllegalArgumentException success) {}
64 >        } catch (IllegalArgumentException success) {}
65      }
66  
67      /**
# Line 68 | 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 <        }
74 <        catch (NullPointerException success) {}
74 >        } catch (NullPointerException success) {}
75      }
76  
77      /**
# Line 80 | Line 80 | public class PriorityQueueTest extends J
80      public void testConstructor4() {
81          try {
82              Integer[] ints = new Integer[SIZE];
83 <            PriorityQueue q = new PriorityQueue(Arrays.asList(ints));
83 >            new PriorityQueue(Arrays.asList(ints));
84              shouldThrow();
85 <        }
86 <        catch (NullPointerException success) {}
85 >        } catch (NullPointerException success) {}
86      }
87  
88      /**
# Line 94 | Line 93 | public class PriorityQueueTest extends J
93              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 <        }
100 <        catch (NullPointerException success) {}
98 >        } catch (NullPointerException success) {}
99      }
100  
101      /**
102       * Queue contains all elements of collection used to initialize
103       */
104      public void testConstructor6() {
105 <        try {
106 <            Integer[] ints = new Integer[SIZE];
107 <            for (int i = 0; i < SIZE; ++i)
108 <                ints[i] = new Integer(i);
109 <            PriorityQueue q = new PriorityQueue(Arrays.asList(ints));
110 <            for (int i = 0; i < SIZE; ++i)
113 <                assertEquals(ints[i], q.poll());
114 <        }
115 <        finally {}
105 >        Integer[] ints = new Integer[SIZE];
106 >        for (int i = 0; i < SIZE; ++i)
107 >            ints[i] = new Integer(i);
108 >        PriorityQueue q = new PriorityQueue(Arrays.asList(ints));
109 >        for (int i = 0; i < SIZE; ++i)
110 >            assertEquals(ints[i], q.poll());
111      }
112  
113      /**
114       * The comparator used in constructor is used
115       */
116      public void testConstructor7() {
117 <        try {
118 <            MyReverseComparator cmp = new MyReverseComparator();
119 <            PriorityQueue q = new PriorityQueue(SIZE, cmp);
120 <            assertEquals(cmp, q.comparator());
121 <            Integer[] ints = new Integer[SIZE];
122 <            for (int i = 0; i < SIZE; ++i)
123 <                ints[i] = new Integer(i);
124 <            q.addAll(Arrays.asList(ints));
125 <            for (int i = SIZE-1; i >= 0; --i)
131 <                assertEquals(ints[i], q.poll());
132 <        }
133 <        finally {}
117 >        MyReverseComparator cmp = new MyReverseComparator();
118 >        PriorityQueue q = new PriorityQueue(SIZE, cmp);
119 >        assertEquals(cmp, q.comparator());
120 >        Integer[] ints = new Integer[SIZE];
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)
125 >            assertEquals(ints[i], q.poll());
126      }
127  
128      /**
# Line 166 | Line 158 | public class PriorityQueueTest extends J
158       * offer(null) throws NPE
159       */
160      public void testOfferNull() {
161 <        try {
161 >        try {
162              PriorityQueue q = new PriorityQueue(1);
163              q.offer(null);
164              shouldThrow();
165 <        } catch (NullPointerException success) { }
165 >        } catch (NullPointerException success) {}
166      }
167  
168      /**
169       * add(null) throws NPE
170       */
171      public void testAddNull() {
172 <        try {
172 >        try {
173              PriorityQueue q = new PriorityQueue(1);
174              q.add(null);
175              shouldThrow();
176 <        } catch (NullPointerException success) { }
176 >        } catch (NullPointerException success) {}
177      }
178  
179      /**
# Line 197 | 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 {
201 –            PriorityQueue q = new PriorityQueue(1);
202 –            q.offer(new Object());
194              q.offer(new Object());
195              q.offer(new Object());
196              shouldThrow();
197 <        }
207 <        catch (ClassCastException success) {}
197 >        } catch (ClassCastException success) {}
198      }
199  
200      /**
# Line 226 | Line 216 | public class PriorityQueueTest extends J
216              PriorityQueue q = new PriorityQueue(1);
217              q.addAll(null);
218              shouldThrow();
219 <        }
230 <        catch (NullPointerException success) {}
219 >        } catch (NullPointerException success) {}
220      }
221 +
222      /**
223       * addAll of a collection with null elements throws NPE
224       */
# Line 238 | Line 228 | public class PriorityQueueTest extends J
228              Integer[] ints = new Integer[SIZE];
229              q.addAll(Arrays.asList(ints));
230              shouldThrow();
231 <        }
242 <        catch (NullPointerException success) {}
231 >        } catch (NullPointerException success) {}
232      }
233 +
234      /**
235       * addAll of a collection with any null elements throws NPE after
236       * possibly adding some elements
# Line 253 | Line 243 | public class PriorityQueueTest extends J
243                  ints[i] = new Integer(i);
244              q.addAll(Arrays.asList(ints));
245              shouldThrow();
246 <        }
257 <        catch (NullPointerException success) {}
246 >        } catch (NullPointerException success) {}
247      }
248  
249      /**
250       * Queue contains all elements of successful addAll
251       */
252      public void testAddAll5() {
253 <        try {
254 <            Integer[] empty = new Integer[0];
255 <            Integer[] ints = new Integer[SIZE];
256 <            for (int i = 0; i < SIZE; ++i)
257 <                ints[i] = new Integer(SIZE-1-i);
258 <            PriorityQueue q = new PriorityQueue(SIZE);
259 <            assertFalse(q.addAll(Arrays.asList(empty)));
260 <            assertTrue(q.addAll(Arrays.asList(ints)));
261 <            for (int i = 0; i < SIZE; ++i)
273 <                assertEquals(new Integer(i), q.poll());
274 <        }
275 <        finally {}
253 >        Integer[] empty = new Integer[0];
254 >        Integer[] ints = new Integer[SIZE];
255 >        for (int i = 0; i < SIZE; ++i)
256 >            ints[i] = new Integer(SIZE-1-i);
257 >        PriorityQueue q = new PriorityQueue(SIZE);
258 >        assertFalse(q.addAll(Arrays.asList(empty)));
259 >        assertTrue(q.addAll(Arrays.asList(ints)));
260 >        for (int i = 0; i < SIZE; ++i)
261 >            assertEquals(new Integer(i), q.poll());
262      }
263  
264      /**
# Line 281 | Line 267 | public class PriorityQueueTest extends J
267      public void testPoll() {
268          PriorityQueue q = populatedQueue(SIZE);
269          for (int i = 0; i < SIZE; ++i) {
270 <            assertEquals(i, ((Integer)q.poll()).intValue());
270 >            assertEquals(i, q.poll());
271          }
272 <        assertNull(q.poll());
272 >        assertNull(q.poll());
273      }
274  
275      /**
# Line 292 | Line 278 | public class PriorityQueueTest extends J
278      public void testPeek() {
279          PriorityQueue q = populatedQueue(SIZE);
280          for (int i = 0; i < SIZE; ++i) {
281 <            assertEquals(i, ((Integer)q.peek()).intValue());
282 <            q.poll();
281 >            assertEquals(i, q.peek());
282 >            assertEquals(i, q.poll());
283              assertTrue(q.peek() == null ||
284 <                       i != ((Integer)q.peek()).intValue());
284 >                       !q.peek().equals(i));
285          }
286 <        assertNull(q.peek());
286 >        assertNull(q.peek());
287      }
288  
289      /**
# Line 306 | Line 292 | public class PriorityQueueTest extends J
292      public void testElement() {
293          PriorityQueue q = populatedQueue(SIZE);
294          for (int i = 0; i < SIZE; ++i) {
295 <            assertEquals(i, ((Integer)q.element()).intValue());
296 <            q.poll();
295 >            assertEquals(i, q.element());
296 >            assertEquals(i, q.poll());
297          }
298          try {
299              q.element();
300              shouldThrow();
301 <        }
316 <        catch (NoSuchElementException success) {}
301 >        } catch (NoSuchElementException success) {}
302      }
303  
304      /**
# Line 322 | Line 307 | public class PriorityQueueTest extends J
307      public void testRemove() {
308          PriorityQueue q = populatedQueue(SIZE);
309          for (int i = 0; i < SIZE; ++i) {
310 <            assertEquals(i, ((Integer)q.remove()).intValue());
310 >            assertEquals(i, q.remove());
311          }
312          try {
313              q.remove();
314              shouldThrow();
315 <        } catch (NoSuchElementException success) {
331 <        }
315 >        } catch (NoSuchElementException success) {}
316      }
317  
318      /**
# Line 336 | Line 320 | public class PriorityQueueTest extends J
320       */
321      public void testRemoveElement() {
322          PriorityQueue q = populatedQueue(SIZE);
323 <        for (int i = 1; i < SIZE; i+=2) {
324 <            assertTrue(q.remove(new Integer(i)));
325 <        }
326 <        for (int i = 0; i < SIZE; i+=2) {
327 <            assertTrue(q.remove(new Integer(i)));
328 <            assertFalse(q.remove(new Integer(i+1)));
323 >        for (int i = 1; i < SIZE; i += 2) {
324 >            assertTrue(q.contains(i));
325 >            assertTrue(q.remove(i));
326 >            assertFalse(q.contains(i));
327 >            assertTrue(q.contains(i-1));
328 >        }
329 >        for (int i = 0; i < SIZE; i += 2) {
330 >            assertTrue(q.contains(i));
331 >            assertTrue(q.remove(i));
332 >            assertFalse(q.contains(i));
333 >            assertFalse(q.remove(i+1));
334 >            assertFalse(q.contains(i+1));
335          }
336          assertTrue(q.isEmpty());
337      }
# Line 415 | Line 405 | public class PriorityQueueTest extends J
405              assertTrue(q.removeAll(p));
406              assertEquals(SIZE-i, q.size());
407              for (int j = 0; j < i; ++j) {
408 <                Integer I = (Integer)(p.remove());
409 <                assertFalse(q.contains(I));
408 >                Integer x = (Integer)(p.remove());
409 >                assertFalse(q.contains(x));
410              }
411          }
412      }
# Line 426 | Line 416 | public class PriorityQueueTest extends J
416       */
417      public void testToArray() {
418          PriorityQueue q = populatedQueue(SIZE);
419 <        Object[] o = q.toArray();
419 >        Object[] o = q.toArray();
420          Arrays.sort(o);
421 <        for (int i = 0; i < o.length; i++)
422 <            assertEquals(o[i], q.poll());
421 >        for (int i = 0; i < o.length; i++)
422 >            assertSame(o[i], q.poll());
423      }
424  
425      /**
426       * toArray(a) contains all elements
427       */
428      public void testToArray2() {
429 <        PriorityQueue q = populatedQueue(SIZE);
430 <        Integer[] ints = new Integer[SIZE];
431 <        ints = (Integer[])q.toArray(ints);
429 >        PriorityQueue<Integer> q = populatedQueue(SIZE);
430 >        Integer[] ints = new Integer[SIZE];
431 >        Integer[] array = q.toArray(ints);
432 >        assertSame(ints, array);
433          Arrays.sort(ints);
434          for (int i = 0; i < ints.length; i++)
435 <            assertEquals(ints[i], q.poll());
435 >            assertSame(ints[i], q.poll());
436      }
437  
438      /**
# Line 449 | Line 440 | public class PriorityQueueTest extends J
440       */
441      public void testIterator() {
442          PriorityQueue q = populatedQueue(SIZE);
443 <        int i = 0;
444 <        Iterator it = q.iterator();
445 <        while (it.hasNext()) {
443 >        Iterator it = q.iterator();
444 >        int i;
445 >        for (i = 0; it.hasNext(); i++)
446              assertTrue(q.contains(it.next()));
456 –            ++i;
457 –        }
447          assertEquals(i, SIZE);
448 +        assertIteratorExhausted(it);
449 +    }
450 +
451 +    /**
452 +     * iterator of empty collection has no elements
453 +     */
454 +    public void testEmptyIterator() {
455 +        assertIteratorExhausted(new PriorityQueue().iterator());
456      }
457  
458      /**
459       * iterator.remove removes current element
460       */
461 <    public void testIteratorRemove () {
461 >    public void testIteratorRemove() {
462          final PriorityQueue q = new PriorityQueue(3);
463          q.add(new Integer(2));
464          q.add(new Integer(1));
# Line 477 | Line 474 | public class PriorityQueueTest extends J
474          assertFalse(it.hasNext());
475      }
476  
480 –
477      /**
478       * toString contains toStrings of elements
479       */
# Line 485 | Line 481 | public class PriorityQueueTest extends J
481          PriorityQueue q = populatedQueue(SIZE);
482          String s = q.toString();
483          for (int i = 0; i < SIZE; ++i) {
484 <            assertTrue(s.indexOf(String.valueOf(i)) >= 0);
484 >            assertTrue(s.contains(String.valueOf(i)));
485          }
486      }
487  
488      /**
489       * A deserialized serialized queue has same elements
490       */
491 <    public void testSerialization() {
492 <        PriorityQueue q = populatedQueue(SIZE);
493 <        try {
494 <            ByteArrayOutputStream bout = new ByteArrayOutputStream(10000);
495 <            ObjectOutputStream out = new ObjectOutputStream(new BufferedOutputStream(bout));
496 <            out.writeObject(q);
497 <            out.close();
498 <
499 <            ByteArrayInputStream bin = new ByteArrayInputStream(bout.toByteArray());
504 <            ObjectInputStream in = new ObjectInputStream(new BufferedInputStream(bin));
505 <            PriorityQueue r = (PriorityQueue)in.readObject();
506 <            assertEquals(q.size(), r.size());
507 <            while (!q.isEmpty())
508 <                assertEquals(q.remove(), r.remove());
509 <        } catch (Exception e) {
510 <            unexpectedException();
491 >    public void testSerialization() throws Exception {
492 >        Queue x = populatedQueue(SIZE);
493 >        Queue y = serialClone(x);
494 >
495 >        assertNotSame(x, y);
496 >        assertEquals(x.size(), y.size());
497 >        while (!x.isEmpty()) {
498 >            assertFalse(y.isEmpty());
499 >            assertEquals(x.remove(), y.remove());
500          }
501 +        assertTrue(y.isEmpty());
502      }
503   }

Diff Legend

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