ViewVC Help
View File | Revision Log | Show Annotations | Download File | Root Listing
root/jsr166/jsr166/src/test/tck/ArrayDequeTest.java
(Generate patch)

Comparing jsr166/src/test/tck/ArrayDequeTest.java (file contents):
Revision 1.7 by jsr166, Mon Nov 16 05:30:07 2009 UTC vs.
Revision 1.12 by jsr166, Sun Nov 22 18:57:16 2009 UTC

# Line 10 | Line 10 | import java.util.concurrent.*;
10  
11   public class ArrayDequeTest extends JSR166TestCase {
12      public static void main(String[] args) {
13 <        junit.textui.TestRunner.run (suite());
13 >        junit.textui.TestRunner.run (suite());
14      }
15  
16      public static Test suite() {
17 <        return new TestSuite(ArrayDequeTest.class);
17 >        return new TestSuite(ArrayDequeTest.class);
18      }
19  
20      /**
# Line 24 | Line 24 | public class ArrayDequeTest extends JSR1
24      private ArrayDeque populatedDeque(int n) {
25          ArrayDeque q = new ArrayDeque();
26          assertTrue(q.isEmpty());
27 <        for (int i = 0; i < n; ++i)
28 <            assertTrue(q.offerLast(new Integer(i)));
27 >        for (int i = 0; i < n; ++i)
28 >            assertTrue(q.offerLast(new Integer(i)));
29          assertFalse(q.isEmpty());
30 <        assertEquals(n, q.size());
30 >        assertEquals(n, q.size());
31          return q;
32      }
33  
# Line 45 | Line 45 | public class ArrayDequeTest extends JSR1
45          try {
46              ArrayDeque q = new ArrayDeque((Collection)null);
47              shouldThrow();
48 <        }
49 <        catch (NullPointerException success) {}
48 >        } catch (NullPointerException success) {}
49      }
50  
51      /**
# Line 54 | Line 53 | public class ArrayDequeTest extends JSR1
53  
54       */
55      public void testConstructor6() {
56 <        try {
57 <            Integer[] ints = new Integer[SIZE];
58 <            for (int i = 0; i < SIZE; ++i)
59 <                ints[i] = new Integer(i);
60 <            ArrayDeque q = new ArrayDeque(Arrays.asList(ints));
61 <            for (int i = 0; i < SIZE; ++i)
63 <                assertEquals(ints[i], q.pollFirst());
64 <        }
65 <        finally {}
56 >        Integer[] ints = new Integer[SIZE];
57 >        for (int i = 0; i < SIZE; ++i)
58 >            ints[i] = new Integer(i);
59 >        ArrayDeque q = new ArrayDeque(Arrays.asList(ints));
60 >        for (int i = 0; i < SIZE; ++i)
61 >            assertEquals(ints[i], q.pollFirst());
62      }
63  
64      /**
# Line 98 | Line 94 | public class ArrayDequeTest extends JSR1
94       * push(null) throws NPE
95       */
96      public void testPushNull() {
97 <        try {
97 >        try {
98              ArrayDeque q = new ArrayDeque(1);
99              q.push(null);
100              shouldThrow();
101 <        } catch (NullPointerException success) { }
101 >        } catch (NullPointerException success) {}
102      }
103  
104      /**
# Line 111 | Line 107 | public class ArrayDequeTest extends JSR1
107      public void testPush() {
108          ArrayDeque q = populatedDeque(3);
109          q.pollLast();
110 <        q.push(four);
111 <        assertEquals(four,q.peekFirst());
110 >        q.push(four);
111 >        assertSame(four, q.peekFirst());
112      }
113  
114      /**
# Line 121 | Line 117 | public class ArrayDequeTest extends JSR1
117      public void testPop() {
118          ArrayDeque q = populatedDeque(SIZE);
119          for (int i = 0; i < SIZE; ++i) {
120 <            assertEquals(i, ((Integer)q.pop()).intValue());
120 >            assertEquals(i, q.pop());
121          }
122          try {
123              q.pop();
124              shouldThrow();
125 <        } catch (NoSuchElementException success) {
130 <        }
125 >        } catch (NoSuchElementException success) {}
126      }
127  
128      /**
129       * offer(null) throws NPE
130       */
131      public void testOfferFirstNull() {
132 <        try {
132 >        try {
133              ArrayDeque q = new ArrayDeque();
134              q.offerFirst(null);
135              shouldThrow();
136 <        } catch (NullPointerException success) {
142 <        }
136 >        } catch (NullPointerException success) {}
137      }
138  
139      /**
# Line 179 | Line 173 | public class ArrayDequeTest extends JSR1
173              ArrayDeque q = new ArrayDeque();
174              q.addAll(null);
175              shouldThrow();
176 <        }
183 <        catch (NullPointerException success) {}
176 >        } catch (NullPointerException success) {}
177      }
178  
179      /**
180       * Queue contains all elements, in traversal order, of successful addAll
181       */
182      public void testAddAll5() {
183 <        try {
184 <            Integer[] empty = new Integer[0];
185 <            Integer[] ints = new Integer[SIZE];
186 <            for (int i = 0; i < SIZE; ++i)
187 <                ints[i] = new Integer(i);
188 <            ArrayDeque q = new ArrayDeque();
189 <            assertFalse(q.addAll(Arrays.asList(empty)));
190 <            assertTrue(q.addAll(Arrays.asList(ints)));
191 <            for (int i = 0; i < SIZE; ++i)
199 <                assertEquals(ints[i], q.pollFirst());
200 <        }
201 <        finally {}
183 >        Integer[] empty = new Integer[0];
184 >        Integer[] ints = new Integer[SIZE];
185 >        for (int i = 0; i < SIZE; ++i)
186 >            ints[i] = new Integer(i);
187 >        ArrayDeque q = new ArrayDeque();
188 >        assertFalse(q.addAll(Arrays.asList(empty)));
189 >        assertTrue(q.addAll(Arrays.asList(ints)));
190 >        for (int i = 0; i < SIZE; ++i)
191 >            assertEquals(ints[i], q.pollFirst());
192      }
193  
194      /**
# Line 207 | Line 197 | public class ArrayDequeTest extends JSR1
197      public void testPollFirst() {
198          ArrayDeque q = populatedDeque(SIZE);
199          for (int i = 0; i < SIZE; ++i) {
200 <            assertEquals(i, ((Integer)q.pollFirst()).intValue());
200 >            assertEquals(i, q.pollFirst());
201          }
202 <        assertNull(q.pollFirst());
202 >        assertNull(q.pollFirst());
203      }
204  
205      /**
# Line 218 | Line 208 | public class ArrayDequeTest extends JSR1
208      public void testPollLast() {
209          ArrayDeque q = populatedDeque(SIZE);
210          for (int i = SIZE-1; i >= 0; --i) {
211 <            assertEquals(i, ((Integer)q.pollLast()).intValue());
211 >            assertEquals(i, q.pollLast());
212          }
213 <        assertNull(q.pollLast());
213 >        assertNull(q.pollLast());
214      }
215  
216      /**
# Line 229 | Line 219 | public class ArrayDequeTest extends JSR1
219      public void testPoll() {
220          ArrayDeque q = populatedDeque(SIZE);
221          for (int i = 0; i < SIZE; ++i) {
222 <            assertEquals(i, ((Integer)q.poll()).intValue());
222 >            assertEquals(i, q.poll());
223          }
224 <        assertNull(q.poll());
224 >        assertNull(q.poll());
225      }
226  
227      /**
# Line 240 | Line 230 | public class ArrayDequeTest extends JSR1
230      public void testRemove() {
231          ArrayDeque q = populatedDeque(SIZE);
232          for (int i = 0; i < SIZE; ++i) {
233 <            assertEquals(i, ((Integer)q.remove()).intValue());
233 >            assertEquals(i, q.remove());
234          }
235          try {
236              q.remove();
237              shouldThrow();
238 <        } catch (NoSuchElementException success) {
249 <        }
238 >        } catch (NoSuchElementException success) {}
239      }
240  
241      /**
# Line 255 | Line 244 | public class ArrayDequeTest extends JSR1
244      public void testPeekFirst() {
245          ArrayDeque q = populatedDeque(SIZE);
246          for (int i = 0; i < SIZE; ++i) {
247 <            assertEquals(i, ((Integer)q.peekFirst()).intValue());
248 <            q.pollFirst();
247 >            assertEquals(i, q.peekFirst());
248 >            assertEquals(i, q.pollFirst());
249              assertTrue(q.peekFirst() == null ||
250 <                       i != ((Integer)q.peekFirst()).intValue());
250 >                       !q.peekFirst().equals(i));
251          }
252 <        assertNull(q.peekFirst());
252 >        assertNull(q.peekFirst());
253      }
254  
255      /**
# Line 269 | Line 258 | public class ArrayDequeTest extends JSR1
258      public void testPeek() {
259          ArrayDeque q = populatedDeque(SIZE);
260          for (int i = 0; i < SIZE; ++i) {
261 <            assertEquals(i, ((Integer)q.peek()).intValue());
262 <            q.poll();
261 >            assertEquals(i, q.peek());
262 >            assertEquals(i, q.poll());
263              assertTrue(q.peek() == null ||
264 <                       i != ((Integer)q.peek()).intValue());
264 >                       !q.peek().equals(i));
265          }
266 <        assertNull(q.peek());
266 >        assertNull(q.peek());
267      }
268  
269      /**
# Line 283 | Line 272 | public class ArrayDequeTest extends JSR1
272      public void testPeekLast() {
273          ArrayDeque q = populatedDeque(SIZE);
274          for (int i = SIZE-1; i >= 0; --i) {
275 <            assertEquals(i, ((Integer)q.peekLast()).intValue());
276 <            q.pollLast();
275 >            assertEquals(i, q.peekLast());
276 >            assertEquals(i, q.pollLast());
277              assertTrue(q.peekLast() == null ||
278 <                       i != ((Integer)q.peekLast()).intValue());
278 >                       !q.peekLast().equals(i));
279          }
280 <        assertNull(q.peekLast());
280 >        assertNull(q.peekLast());
281      }
282  
283      /**
# Line 297 | Line 286 | public class ArrayDequeTest extends JSR1
286      public void testFirstElement() {
287          ArrayDeque q = populatedDeque(SIZE);
288          for (int i = 0; i < SIZE; ++i) {
289 <            assertEquals(i, ((Integer)q.getFirst()).intValue());
290 <            q.pollFirst();
289 >            assertEquals(i, q.getFirst());
290 >            assertEquals(i, q.pollFirst());
291          }
292          try {
293              q.getFirst();
294              shouldThrow();
295 <        }
307 <        catch (NoSuchElementException success) {}
295 >        } catch (NoSuchElementException success) {}
296      }
297  
298      /**
# Line 313 | Line 301 | public class ArrayDequeTest extends JSR1
301      public void testLastElement() {
302          ArrayDeque q = populatedDeque(SIZE);
303          for (int i = SIZE-1; i >= 0; --i) {
304 <            assertEquals(i, ((Integer)q.getLast()).intValue());
305 <            q.pollLast();
304 >            assertEquals(i, q.getLast());
305 >            assertEquals(i, q.pollLast());
306          }
307          try {
308              q.getLast();
309              shouldThrow();
310 <        }
311 <        catch (NoSuchElementException success) {}
324 <        assertNull(q.peekLast());
310 >        } catch (NoSuchElementException success) {}
311 >        assertNull(q.peekLast());
312      }
313  
314  
# Line 331 | Line 318 | public class ArrayDequeTest extends JSR1
318      public void testRemoveFirst() {
319          ArrayDeque q = populatedDeque(SIZE);
320          for (int i = 0; i < SIZE; ++i) {
321 <            assertEquals(i, ((Integer)q.removeFirst()).intValue());
321 >            assertEquals(i, q.removeFirst());
322          }
323          try {
324              q.removeFirst();
325              shouldThrow();
326 <        } catch (NoSuchElementException success) {
340 <        }
326 >        } catch (NoSuchElementException success) {}
327      }
328  
329      /**
# Line 377 | Line 363 | public class ArrayDequeTest extends JSR1
363          ArrayDeque q = populatedDeque(SIZE);
364          for (int i = 0; i < SIZE; ++i) {
365              assertTrue(q.contains(new Integer(i)));
366 <            q.pollFirst();
366 >            assertEquals(i, q.pollFirst());
367              assertFalse(q.contains(new Integer(i)));
368          }
369      }
# Line 390 | Line 376 | public class ArrayDequeTest extends JSR1
376          q.clear();
377          assertTrue(q.isEmpty());
378          assertEquals(0, q.size());
379 <        q.add(new Integer(1));
379 >        assertTrue(q.add(new Integer(1)));
380          assertFalse(q.isEmpty());
381          q.clear();
382          assertTrue(q.isEmpty());
# Line 405 | Line 391 | public class ArrayDequeTest extends JSR1
391          for (int i = 0; i < SIZE; ++i) {
392              assertTrue(q.containsAll(p));
393              assertFalse(p.containsAll(q));
394 <            p.add(new Integer(i));
394 >            assertTrue(p.add(new Integer(i)));
395          }
396          assertTrue(p.containsAll(q));
397      }
# Line 418 | Line 404 | public class ArrayDequeTest extends JSR1
404          ArrayDeque p = populatedDeque(SIZE);
405          for (int i = 0; i < SIZE; ++i) {
406              boolean changed = q.retainAll(p);
407 <            if (i == 0)
422 <                assertFalse(changed);
423 <            else
424 <                assertTrue(changed);
425 <
407 >            assertEquals(changed, (i > 0));
408              assertTrue(q.containsAll(p));
409              assertEquals(SIZE-i, q.size());
410              p.removeFirst();
# Line 439 | Line 421 | public class ArrayDequeTest extends JSR1
421              assertTrue(q.removeAll(p));
422              assertEquals(SIZE-i, q.size());
423              for (int j = 0; j < i; ++j) {
424 <                Integer I = (Integer)(p.removeFirst());
443 <                assertFalse(q.contains(I));
424 >                assertFalse(q.contains(p.removeFirst()));
425              }
426          }
427      }
# Line 450 | Line 431 | public class ArrayDequeTest extends JSR1
431       */
432      public void testToArray() {
433          ArrayDeque q = populatedDeque(SIZE);
434 <        Object[] o = q.toArray();
434 >        Object[] o = q.toArray();
435          Arrays.sort(o);
436 <        for (int i = 0; i < o.length; i++)
437 <            assertEquals(o[i], q.pollFirst());
436 >        for (int i = 0; i < o.length; i++)
437 >            assertEquals(o[i], q.pollFirst());
438      }
439  
440      /**
# Line 461 | Line 442 | public class ArrayDequeTest extends JSR1
442       */
443      public void testToArray2() {
444          ArrayDeque q = populatedDeque(SIZE);
445 <        Integer[] ints = new Integer[SIZE];
446 <        ints = (Integer[])q.toArray(ints);
445 >        Integer[] ints = new Integer[SIZE];
446 >        ints = (Integer[])q.toArray(ints);
447          Arrays.sort(ints);
448          for (int i = 0; i < ints.length; i++)
449              assertEquals(ints[i], q.pollFirst());
# Line 472 | Line 453 | public class ArrayDequeTest extends JSR1
453       * toArray(null) throws NPE
454       */
455      public void testToArray_BadArg() {
456 <        try {
457 <            ArrayDeque l = new ArrayDeque();
458 <            l.add(new Object());
459 <            Object o[] = l.toArray(null);
460 <            shouldThrow();
461 <        } catch (NullPointerException success) {}
456 >        ArrayDeque l = new ArrayDeque();
457 >        l.add(new Object());
458 >        try {
459 >            Object o[] = l.toArray(null);
460 >            shouldThrow();
461 >        } catch (NullPointerException success) {}
462      }
463  
464      /**
465       * toArray with incompatable aray type throws CCE
466       */
467      public void testToArray1_BadArg() {
468 <        try {
469 <            ArrayDeque l = new ArrayDeque();
470 <            l.add(new Integer(5));
471 <            Object o[] = l.toArray(new String[10] );
472 <            shouldThrow();
473 <        } catch (ArrayStoreException  success) {}
468 >        ArrayDeque l = new ArrayDeque();
469 >        l.add(new Integer(5));
470 >        try {
471 >            Object o[] = l.toArray(new String[10]);
472 >            shouldThrow();
473 >        } catch (ArrayStoreException success) {}
474      }
475  
476      /**
# Line 498 | Line 479 | public class ArrayDequeTest extends JSR1
479      public void testIterator() {
480          ArrayDeque q = populatedDeque(SIZE);
481          int i = 0;
482 <        Iterator it = q.iterator();
482 >        Iterator it = q.iterator();
483          while (it.hasNext()) {
484              assertTrue(q.contains(it.next()));
485              ++i;
# Line 516 | Line 497 | public class ArrayDequeTest extends JSR1
497          q.add(new Integer(3));
498          int k = 0;
499          for (Iterator it = q.iterator(); it.hasNext();) {
500 <            int i = ((Integer)(it.next())).intValue();
520 <            assertEquals(++k, i);
500 >            assertEquals(++k, it.next());
501          }
502  
503          assertEquals(3, k);
# Line 557 | Line 537 | public class ArrayDequeTest extends JSR1
537      public void testDescendingIterator() {
538          ArrayDeque q = populatedDeque(SIZE);
539          int i = 0;
540 <        Iterator it = q.descendingIterator();
540 >        Iterator it = q.descendingIterator();
541          while (it.hasNext()) {
542              assertTrue(q.contains(it.next()));
543              ++i;
# Line 566 | Line 546 | public class ArrayDequeTest extends JSR1
546          assertFalse(it.hasNext());
547          try {
548              it.next();
549 <        } catch (NoSuchElementException success) {
550 <        }
549 >            shouldThrow();
550 >        } catch (NoSuchElementException success) {}
551      }
552  
553      /**
# Line 581 | Line 561 | public class ArrayDequeTest extends JSR1
561              q.add(new Integer(1));
562              int k = 0;
563              for (Iterator it = q.descendingIterator(); it.hasNext();) {
564 <                int i = ((Integer)(it.next())).intValue();
585 <                assertEquals(++k, i);
564 >                assertEquals(++k, it.next());
565              }
566  
567              assertEquals(3, k);
# Line 637 | Line 616 | public class ArrayDequeTest extends JSR1
616       */
617      public void testAddFirst() {
618          ArrayDeque q = populatedDeque(3);
619 <        q.addFirst(four);
620 <        assertEquals(four,q.peekFirst());
619 >        q.addFirst(four);
620 >        assertEquals(four,q.peekFirst());
621      }
622  
623      /**
# Line 646 | Line 625 | public class ArrayDequeTest extends JSR1
625       */
626      public void testAddLast() {
627          ArrayDeque q = populatedDeque(3);
628 <        q.addLast(four);
629 <        assertEquals(four,q.peekLast());
628 >        q.addLast(four);
629 >        assertEquals(four,q.peekLast());
630      }
631  
632   }

Diff Legend

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