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.3 by dl, Thu Sep 15 16:55:48 2005 UTC vs.
Revision 1.9 by jsr166, Sat Nov 21 10:25:05 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 <
33 >
34      /**
35       * new queue is empty
36       */
# 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());
112 <    }  
110 >        q.push(four);
111 >        assertEquals(four,q.peekFirst());
112 >    }
113  
114      /**
115       *  pop removes next element, or throws NSEE if empty
# Line 126 | Line 122 | public class ArrayDequeTest extends JSR1
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      /**
140 <     * OfferFirst succeeds
140 >     * OfferFirst succeeds
141       */
142      public void testOfferFirst() {
143          ArrayDeque q = new ArrayDeque();
# Line 152 | Line 146 | public class ArrayDequeTest extends JSR1
146      }
147  
148      /**
149 <     * OfferLast succeeds
149 >     * OfferLast succeeds
150       */
151      public void testOfferLast() {
152          ArrayDeque q = new ArrayDeque();
# 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      /**
# Line 209 | Line 202 | public class ArrayDequeTest extends JSR1
202          for (int i = 0; i < SIZE; ++i) {
203              assertEquals(i, ((Integer)q.pollFirst()).intValue());
204          }
205 <        assertNull(q.pollFirst());
205 >        assertNull(q.pollFirst());
206      }
207  
208      /**
# Line 220 | Line 213 | public class ArrayDequeTest extends JSR1
213          for (int i = SIZE-1; i >= 0; --i) {
214              assertEquals(i, ((Integer)q.pollLast()).intValue());
215          }
216 <        assertNull(q.pollLast());
216 >        assertNull(q.pollLast());
217      }
218  
219      /**
# Line 231 | Line 224 | public class ArrayDequeTest extends JSR1
224          for (int i = 0; i < SIZE; ++i) {
225              assertEquals(i, ((Integer)q.poll()).intValue());
226          }
227 <        assertNull(q.poll());
227 >        assertNull(q.poll());
228      }
229  
230      /**
# Line 245 | Line 238 | public class ArrayDequeTest extends JSR1
238          try {
239              q.remove();
240              shouldThrow();
241 <        } catch (NoSuchElementException success){
249 <        }  
241 >        } catch (NoSuchElementException success) {}
242      }
243  
244      /**
# Line 260 | Line 252 | public class ArrayDequeTest extends JSR1
252              assertTrue(q.peekFirst() == null ||
253                         i != ((Integer)q.peekFirst()).intValue());
254          }
255 <        assertNull(q.peekFirst());
255 >        assertNull(q.peekFirst());
256      }
257  
258      /**
# Line 274 | Line 266 | public class ArrayDequeTest extends JSR1
266              assertTrue(q.peek() == null ||
267                         i != ((Integer)q.peek()).intValue());
268          }
269 <        assertNull(q.peek());
269 >        assertNull(q.peek());
270      }
271  
272      /**
# Line 288 | Line 280 | public class ArrayDequeTest extends JSR1
280              assertTrue(q.peekLast() == null ||
281                         i != ((Integer)q.peekLast()).intValue());
282          }
283 <        assertNull(q.peekLast());
283 >        assertNull(q.peekLast());
284      }
285  
286      /**
# Line 303 | Line 295 | public class ArrayDequeTest extends JSR1
295          try {
296              q.getFirst();
297              shouldThrow();
298 <        }
307 <        catch (NoSuchElementException success) {}
298 >        } catch (NoSuchElementException success) {}
299      }
300  
301      /**
# Line 319 | Line 310 | public class ArrayDequeTest extends JSR1
310          try {
311              q.getLast();
312              shouldThrow();
313 <        }
314 <        catch (NoSuchElementException success) {}
324 <        assertNull(q.peekLast());
313 >        } catch (NoSuchElementException success) {}
314 >        assertNull(q.peekLast());
315      }
316  
317  
# Line 336 | Line 326 | public class ArrayDequeTest extends JSR1
326          try {
327              q.removeFirst();
328              shouldThrow();
329 <        } catch (NoSuchElementException success){
340 <        }  
329 >        } catch (NoSuchElementException success) {}
330      }
331  
332      /**
# Line 450 | Line 439 | public class ArrayDequeTest extends JSR1
439       */
440      public void testToArray() {
441          ArrayDeque q = populatedDeque(SIZE);
442 <        Object[] o = q.toArray();
442 >        Object[] o = q.toArray();
443          Arrays.sort(o);
444 <        for(int i = 0; i < o.length; i++)
445 <            assertEquals(o[i], q.pollFirst());
444 >        for (int i = 0; i < o.length; i++)
445 >            assertEquals(o[i], q.pollFirst());
446      }
447  
448      /**
# Line 461 | Line 450 | public class ArrayDequeTest extends JSR1
450       */
451      public void testToArray2() {
452          ArrayDeque q = populatedDeque(SIZE);
453 <        Integer[] ints = new Integer[SIZE];
454 <        ints = (Integer[])q.toArray(ints);
453 >        Integer[] ints = new Integer[SIZE];
454 >        ints = (Integer[])q.toArray(ints);
455          Arrays.sort(ints);
456 <        for(int i = 0; i < ints.length; i++)
456 >        for (int i = 0; i < ints.length; i++)
457              assertEquals(ints[i], q.pollFirst());
458      }
459  
# Line 472 | Line 461 | public class ArrayDequeTest extends JSR1
461       * toArray(null) throws NPE
462       */
463      public void testToArray_BadArg() {
464 <        try {
465 <            ArrayDeque l = new ArrayDeque();
466 <            l.add(new Object());
467 <            Object o[] = l.toArray(null);
468 <            shouldThrow();
469 <        } catch(NullPointerException success){}
464 >        try {
465 >            ArrayDeque l = new ArrayDeque();
466 >            l.add(new Object());
467 >            Object o[] = l.toArray(null);
468 >            shouldThrow();
469 >        } catch (NullPointerException success) {}
470      }
471  
472      /**
473       * toArray with incompatable aray type throws CCE
474       */
475      public void testToArray1_BadArg() {
476 <        try {
477 <            ArrayDeque l = new ArrayDeque();
478 <            l.add(new Integer(5));
479 <            Object o[] = l.toArray(new String[10] );
480 <            shouldThrow();
481 <        } catch(ArrayStoreException  success){}
476 >        try {
477 >            ArrayDeque l = new ArrayDeque();
478 >            l.add(new Integer(5));
479 >            Object o[] = l.toArray(new String[10] );
480 >            shouldThrow();
481 >        } catch (ArrayStoreException success) {}
482      }
483 <    
483 >
484      /**
485       *  iterator iterates through all elements
486       */
487      public void testIterator() {
488          ArrayDeque q = populatedDeque(SIZE);
489          int i = 0;
490 <        Iterator it = q.iterator();
491 <        while(it.hasNext()) {
490 >        Iterator it = q.iterator();
491 >        while (it.hasNext()) {
492              assertTrue(q.contains(it.next()));
493              ++i;
494          }
# Line 528 | Line 517 | public class ArrayDequeTest extends JSR1
517       */
518      public void testIteratorRemove () {
519          final ArrayDeque q = new ArrayDeque();
520 +        final Random rng = new Random();
521          for (int iters = 0; iters < 100; ++iters) {
522 <            q.add(new Integer(1));
523 <            q.add(new Integer(2));
524 <            q.add(new Integer(3));
522 >            int max = rng.nextInt(5) + 2;
523 >            int split = rng.nextInt(max-1) + 1;
524 >            for (int j = 1; j <= max; ++j)
525 >                q.add(new Integer(j));
526              Iterator it = q.iterator();
527 <            assertEquals(it.next(), new Integer(1));
527 >            for (int j = 1; j <= split; ++j)
528 >                assertEquals(it.next(), new Integer(j));
529              it.remove();
530 <            assertEquals(it.next(), new Integer(2));
530 >            assertEquals(it.next(), new Integer(split+1));
531 >            for (int j = 1; j <= split; ++j)
532 >                q.remove(new Integer(j));
533              it = q.iterator();
534 <            assertEquals(it.next(), new Integer(2));
535 <            assertEquals(it.next(), new Integer(3));
536 <            it.remove();
534 >            for (int j = split+1; j <= max; ++j) {
535 >                assertEquals(it.next(), new Integer(j));
536 >                it.remove();
537 >            }
538              assertFalse(it.hasNext());
539 <            q.remove();
539 >            assertTrue(q.isEmpty());
540          }
541      }
542  
# Line 551 | Line 546 | public class ArrayDequeTest extends JSR1
546      public void testDescendingIterator() {
547          ArrayDeque q = populatedDeque(SIZE);
548          int i = 0;
549 <        Iterator it = q.descendingIterator();
550 <        while(it.hasNext()) {
549 >        Iterator it = q.descendingIterator();
550 >        while (it.hasNext()) {
551              assertTrue(q.contains(it.next()));
552              ++i;
553          }
# Line 560 | Line 555 | public class ArrayDequeTest extends JSR1
555          assertFalse(it.hasNext());
556          try {
557              it.next();
558 <        } catch(NoSuchElementException success) {
564 <        }
558 >        } catch (NoSuchElementException success) {}
559      }
560  
561      /**
# Line 578 | Line 572 | public class ArrayDequeTest extends JSR1
572                  int i = ((Integer)(it.next())).intValue();
573                  assertEquals(++k, i);
574              }
575 <            
575 >
576              assertEquals(3, k);
577              q.remove();
578              q.remove();
# Line 591 | Line 585 | public class ArrayDequeTest extends JSR1
585       */
586      public void testDescendingIteratorRemove () {
587          final ArrayDeque q = new ArrayDeque();
588 +        final Random rng = new Random();
589          for (int iters = 0; iters < 100; ++iters) {
590 <            q.add(new Integer(3));
591 <            q.add(new Integer(2));
592 <            q.add(new Integer(1));
590 >            int max = rng.nextInt(5) + 2;
591 >            int split = rng.nextInt(max-1) + 1;
592 >            for (int j = max; j >= 1; --j)
593 >                q.add(new Integer(j));
594              Iterator it = q.descendingIterator();
595 <            assertEquals(it.next(), new Integer(1));
595 >            for (int j = 1; j <= split; ++j)
596 >                assertEquals(it.next(), new Integer(j));
597              it.remove();
598 <            assertEquals(it.next(), new Integer(2));
598 >            assertEquals(it.next(), new Integer(split+1));
599 >            for (int j = 1; j <= split; ++j)
600 >                q.remove(new Integer(j));
601              it = q.descendingIterator();
602 <            assertEquals(it.next(), new Integer(2));
603 <            assertEquals(it.next(), new Integer(3));
604 <            it.remove();
602 >            for (int j = split+1; j <= max; ++j) {
603 >                assertEquals(it.next(), new Integer(j));
604 >                it.remove();
605 >            }
606              assertFalse(it.hasNext());
607 <            q.remove();
607 >            assertTrue(q.isEmpty());
608          }
609      }
610  
# Line 618 | Line 618 | public class ArrayDequeTest extends JSR1
618          for (int i = 0; i < SIZE; ++i) {
619              assertTrue(s.indexOf(String.valueOf(i)) >= 0);
620          }
621 <    }        
621 >    }
622  
623      /**
624       * peekFirst returns element inserted with addFirst
625       */
626      public void testAddFirst() {
627          ArrayDeque q = populatedDeque(3);
628 <        q.addFirst(four);
629 <        assertEquals(four,q.peekFirst());
630 <    }  
628 >        q.addFirst(four);
629 >        assertEquals(four,q.peekFirst());
630 >    }
631  
632      /**
633       * peekLast returns element inserted with addLast
634       */
635      public void testAddLast() {
636          ArrayDeque q = populatedDeque(3);
637 <        q.addLast(four);
638 <        assertEquals(four,q.peekLast());
639 <    }  
637 >        q.addLast(four);
638 >        assertEquals(four,q.peekLast());
639 >    }
640  
641   }

Diff Legend

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