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.13 by jsr166, Sat Nov 21 10:25:05 2009 UTC vs.
Revision 1.30 by jsr166, Sat Jan 17 22:55:06 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);
# Line 21 | Line 27 | public class PriorityQueueTest extends J
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)
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 100 | Line 102 | public class PriorityQueueTest extends J
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)
109 <                assertEquals(ints[i], q.poll());
110 <        }
111 <        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)
127 <                assertEquals(ints[i], q.poll());
128 <        }
129 <        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 223 | Line 219 | public class PriorityQueueTest extends J
219              shouldThrow();
220          } catch (NullPointerException success) {}
221      }
222 +
223      /**
224       * addAll of a collection with null elements throws NPE
225       */
# Line 234 | Line 231 | public class PriorityQueueTest extends J
231              shouldThrow();
232          } catch (NullPointerException success) {}
233      }
234 +
235      /**
236       * addAll of a collection with any null elements throws NPE after
237       * possibly adding some elements
# Line 253 | Line 251 | public class PriorityQueueTest extends J
251       * Queue contains all elements of successful addAll
252       */
253      public void testAddAll5() {
254 <        try {
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);
259 <            PriorityQueue q = new PriorityQueue(SIZE);
260 <            assertFalse(q.addAll(Arrays.asList(empty)));
261 <            assertTrue(q.addAll(Arrays.asList(ints)));
262 <            for (int i = 0; i < SIZE; ++i)
265 <                assertEquals(new Integer(i), q.poll());
266 <        }
267 <        finally {}
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)
262 >            assertEquals(new Integer(i), q.poll());
263      }
264  
265      /**
# Line 273 | Line 268 | public class PriorityQueueTest extends J
268      public void testPoll() {
269          PriorityQueue q = populatedQueue(SIZE);
270          for (int i = 0; i < SIZE; ++i) {
271 <            assertEquals(i, ((Integer)q.poll()).intValue());
271 >            assertEquals(i, q.poll());
272          }
273          assertNull(q.poll());
274      }
# Line 284 | Line 279 | public class PriorityQueueTest extends J
279      public void testPeek() {
280          PriorityQueue q = populatedQueue(SIZE);
281          for (int i = 0; i < SIZE; ++i) {
282 <            assertEquals(i, ((Integer)q.peek()).intValue());
283 <            q.poll();
282 >            assertEquals(i, q.peek());
283 >            assertEquals(i, q.poll());
284              assertTrue(q.peek() == null ||
285 <                       i != ((Integer)q.peek()).intValue());
285 >                       !q.peek().equals(i));
286          }
287          assertNull(q.peek());
288      }
# Line 298 | Line 293 | public class PriorityQueueTest extends J
293      public void testElement() {
294          PriorityQueue q = populatedQueue(SIZE);
295          for (int i = 0; i < SIZE; ++i) {
296 <            assertEquals(i, ((Integer)q.element()).intValue());
297 <            q.poll();
296 >            assertEquals(i, q.element());
297 >            assertEquals(i, q.poll());
298          }
299          try {
300              q.element();
# Line 313 | Line 308 | public class PriorityQueueTest extends J
308      public void testRemove() {
309          PriorityQueue q = populatedQueue(SIZE);
310          for (int i = 0; i < SIZE; ++i) {
311 <            assertEquals(i, ((Integer)q.remove()).intValue());
311 >            assertEquals(i, q.remove());
312          }
313          try {
314              q.remove();
# Line 326 | Line 321 | public class PriorityQueueTest extends J
321       */
322      public void testRemoveElement() {
323          PriorityQueue q = populatedQueue(SIZE);
324 <        for (int i = 1; i < SIZE; i+=2) {
325 <            assertTrue(q.remove(new Integer(i)));
326 <        }
327 <        for (int i = 0; i < SIZE; i+=2) {
328 <            assertTrue(q.remove(new Integer(i)));
329 <            assertFalse(q.remove(new Integer(i+1)));
324 >        for (int i = 1; i < SIZE; i += 2) {
325 >            assertTrue(q.contains(i));
326 >            assertTrue(q.remove(i));
327 >            assertFalse(q.contains(i));
328 >            assertTrue(q.contains(i-1));
329 >        }
330 >        for (int i = 0; i < SIZE; i += 2) {
331 >            assertTrue(q.contains(i));
332 >            assertTrue(q.remove(i));
333 >            assertFalse(q.contains(i));
334 >            assertFalse(q.remove(i+1));
335 >            assertFalse(q.contains(i+1));
336          }
337          assertTrue(q.isEmpty());
338      }
# Line 405 | Line 406 | public class PriorityQueueTest extends J
406              assertTrue(q.removeAll(p));
407              assertEquals(SIZE-i, q.size());
408              for (int j = 0; j < i; ++j) {
409 <                Integer I = (Integer)(p.remove());
410 <                assertFalse(q.contains(I));
409 >                Integer x = (Integer)(p.remove());
410 >                assertFalse(q.contains(x));
411              }
412          }
413      }
# Line 419 | Line 420 | public class PriorityQueueTest extends J
420          Object[] o = q.toArray();
421          Arrays.sort(o);
422          for (int i = 0; i < o.length; i++)
423 <            assertEquals(o[i], q.poll());
423 >            assertSame(o[i], q.poll());
424      }
425  
426      /**
427       * toArray(a) contains all elements
428       */
429      public void testToArray2() {
430 <        PriorityQueue q = populatedQueue(SIZE);
430 >        PriorityQueue<Integer> q = populatedQueue(SIZE);
431          Integer[] ints = new Integer[SIZE];
432 <        ints = (Integer[])q.toArray(ints);
432 >        Integer[] array = q.toArray(ints);
433 >        assertSame(ints, array);
434          Arrays.sort(ints);
435          for (int i = 0; i < ints.length; i++)
436 <            assertEquals(ints[i], q.poll());
436 >            assertSame(ints[i], q.poll());
437      }
438  
439      /**
# Line 439 | Line 441 | public class PriorityQueueTest extends J
441       */
442      public void testIterator() {
443          PriorityQueue q = populatedQueue(SIZE);
442 –        int i = 0;
444          Iterator it = q.iterator();
445 <        while (it.hasNext()) {
445 >        int i;
446 >        for (i = 0; it.hasNext(); i++)
447              assertTrue(q.contains(it.next()));
446 –            ++i;
447 –        }
448          assertEquals(i, SIZE);
449 +        assertIteratorExhausted(it);
450 +    }
451 +
452 +    /**
453 +     * iterator of empty collection has no elements
454 +     */
455 +    public void testEmptyIterator() {
456 +        assertIteratorExhausted(new PriorityQueue().iterator());
457      }
458  
459      /**
460       * iterator.remove removes current element
461       */
462 <    public void testIteratorRemove () {
462 >    public void testIteratorRemove() {
463          final PriorityQueue q = new PriorityQueue(3);
464          q.add(new Integer(2));
465          q.add(new Integer(1));
# Line 467 | Line 475 | public class PriorityQueueTest extends J
475          assertFalse(it.hasNext());
476      }
477  
470 –
478      /**
479       * toString contains toStrings of elements
480       */
# Line 475 | Line 482 | public class PriorityQueueTest extends J
482          PriorityQueue q = populatedQueue(SIZE);
483          String s = q.toString();
484          for (int i = 0; i < SIZE; ++i) {
485 <            assertTrue(s.indexOf(String.valueOf(i)) >= 0);
485 >            assertTrue(s.contains(String.valueOf(i)));
486          }
487      }
488  
# Line 483 | Line 490 | public class PriorityQueueTest extends J
490       * A deserialized serialized queue has same elements
491       */
492      public void testSerialization() throws Exception {
493 <        PriorityQueue q = populatedQueue(SIZE);
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());
500 <        ObjectInputStream in = new ObjectInputStream(new BufferedInputStream(bin));
501 <        PriorityQueue r = (PriorityQueue)in.readObject();
502 <        assertEquals(q.size(), r.size());
496 <        while (!q.isEmpty())
497 <            assertEquals(q.remove(), r.remove());
493 >        Queue x = populatedQueue(SIZE);
494 >        Queue y = serialClone(x);
495 >
496 >        assertNotSame(x, y);
497 >        assertEquals(x.size(), y.size());
498 >        while (!x.isEmpty()) {
499 >            assertFalse(y.isEmpty());
500 >            assertEquals(x.remove(), y.remove());
501 >        }
502 >        assertTrue(y.isEmpty());
503      }
504   }

Diff Legend

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