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.15 by jsr166, Sun Nov 22 18:57:17 2009 UTC vs.
Revision 1.37 by jsr166, Wed Jun 1 16:08:04 2016 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 >        main(suite(), args);
23      }
24      public static Test suite() {
25          return new TestSuite(PriorityQueueTest.class);
# Line 26 | Line 32 | public class PriorityQueueTest extends J
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 53 | Line 59 | public class PriorityQueueTest extends J
59       */
60      public void testConstructor2() {
61          try {
62 <            PriorityQueue q = new PriorityQueue(0);
62 >            new PriorityQueue(0);
63              shouldThrow();
64          } catch (IllegalArgumentException success) {}
65      }
# Line 63 | 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          } catch (NullPointerException success) {}
75      }
# Line 73 | Line 79 | public class PriorityQueueTest extends J
79       */
80      public void testConstructor4() {
81          try {
82 <            Integer[] ints = new Integer[SIZE];
77 <            PriorityQueue q = new PriorityQueue(Arrays.asList(ints));
82 >            new PriorityQueue(Arrays.asList(new Integer[SIZE]));
83              shouldThrow();
84          } catch (NullPointerException success) {}
85      }
# Line 83 | Line 88 | public class PriorityQueueTest extends J
88       * Initializing from Collection with some null elements throws NPE
89       */
90      public void testConstructor5() {
91 +        Integer[] ints = new Integer[SIZE];
92 +        for (int i = 0; i < SIZE - 1; ++i)
93 +            ints[i] = new Integer(i);
94          try {
95 <            Integer[] ints = new Integer[SIZE];
88 <            for (int i = 0; i < SIZE-1; ++i)
89 <                ints[i] = new Integer(i);
90 <            PriorityQueue q = new PriorityQueue(Arrays.asList(ints));
95 >            new PriorityQueue(Arrays.asList(ints));
96              shouldThrow();
97          } catch (NullPointerException success) {}
98      }
# Line 115 | Line 120 | public class PriorityQueueTest extends J
120          for (int i = 0; i < SIZE; ++i)
121              ints[i] = new Integer(i);
122          q.addAll(Arrays.asList(ints));
123 <        for (int i = SIZE-1; i >= 0; --i)
123 >        for (int i = SIZE - 1; i >= 0; --i)
124              assertEquals(ints[i], q.poll());
125      }
126  
# Line 139 | Line 144 | public class PriorityQueueTest extends J
144      public void testSize() {
145          PriorityQueue q = populatedQueue(SIZE);
146          for (int i = 0; i < SIZE; ++i) {
147 <            assertEquals(SIZE-i, q.size());
147 >            assertEquals(SIZE - i, q.size());
148              q.remove();
149          }
150          for (int i = 0; i < SIZE; ++i) {
# Line 152 | Line 157 | public class PriorityQueueTest extends J
157       * offer(null) throws NPE
158       */
159      public void testOfferNull() {
160 +        PriorityQueue q = new PriorityQueue(1);
161          try {
156 –            PriorityQueue q = new PriorityQueue(1);
162              q.offer(null);
163              shouldThrow();
164          } catch (NullPointerException success) {}
# Line 163 | Line 168 | public class PriorityQueueTest extends J
168       * add(null) throws NPE
169       */
170      public void testAddNull() {
171 +        PriorityQueue q = new PriorityQueue(1);
172          try {
167 –            PriorityQueue q = new PriorityQueue(1);
173              q.add(null);
174              shouldThrow();
175          } catch (NullPointerException success) {}
# Line 183 | Line 188 | public class PriorityQueueTest extends J
188       * Offer of non-Comparable throws CCE
189       */
190      public void testOfferNonComparable() {
191 +        PriorityQueue q = new PriorityQueue(1);
192          try {
187 –            PriorityQueue q = new PriorityQueue(1);
188 –            q.offer(new Object());
189 –            q.offer(new Object());
193              q.offer(new Object());
194              shouldThrow();
195 <        } catch (ClassCastException success) {}
195 >        } catch (ClassCastException success) {
196 >            assertTrue(q.isEmpty());
197 >            assertEquals(0, q.size());
198 >            assertNull(q.poll());
199 >        }
200      }
201  
202      /**
# Line 207 | Line 214 | public class PriorityQueueTest extends J
214       * addAll(null) throws NPE
215       */
216      public void testAddAll1() {
217 +        PriorityQueue q = new PriorityQueue(1);
218          try {
211 –            PriorityQueue q = new PriorityQueue(1);
219              q.addAll(null);
220              shouldThrow();
221          } catch (NullPointerException success) {}
222      }
223 +
224      /**
225       * addAll of a collection with null elements throws NPE
226       */
227      public void testAddAll2() {
228 +        PriorityQueue q = new PriorityQueue(SIZE);
229          try {
230 <            PriorityQueue q = new PriorityQueue(SIZE);
222 <            Integer[] ints = new Integer[SIZE];
223 <            q.addAll(Arrays.asList(ints));
230 >            q.addAll(Arrays.asList(new Integer[SIZE]));
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
238       */
239      public void testAddAll3() {
240 +        PriorityQueue q = new PriorityQueue(SIZE);
241 +        Integer[] ints = new Integer[SIZE];
242 +        for (int i = 0; i < SIZE - 1; ++i)
243 +            ints[i] = new Integer(i);
244          try {
233 –            PriorityQueue q = new PriorityQueue(SIZE);
234 –            Integer[] ints = new Integer[SIZE];
235 –            for (int i = 0; i < SIZE-1; ++i)
236 –                ints[i] = new Integer(i);
245              q.addAll(Arrays.asList(ints));
246              shouldThrow();
247          } catch (NullPointerException success) {}
# Line 246 | Line 254 | public class PriorityQueueTest extends J
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);
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)));
# Line 313 | 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 377 | Line 391 | public class PriorityQueueTest extends J
391                  assertTrue(changed);
392  
393              assertTrue(q.containsAll(p));
394 <            assertEquals(SIZE-i, q.size());
394 >            assertEquals(SIZE - i, q.size());
395              p.remove();
396          }
397      }
# Line 390 | Line 404 | public class PriorityQueueTest extends J
404              PriorityQueue q = populatedQueue(SIZE);
405              PriorityQueue p = populatedQueue(i);
406              assertTrue(q.removeAll(p));
407 <            assertEquals(SIZE-i, q.size());
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 406 | 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 426 | Line 441 | public class PriorityQueueTest extends J
441       */
442      public void testIterator() {
443          PriorityQueue q = populatedQueue(SIZE);
429 –        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()));
433 –            ++i;
434 –        }
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 454 | Line 475 | public class PriorityQueueTest extends J
475          assertFalse(it.hasNext());
476      }
477  
457 –
478      /**
479       * toString contains toStrings of elements
480       */
# Line 462 | 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 470 | 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());
483 <        while (!q.isEmpty())
484 <            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