[cvs] / jsr166 / src / test / tck / LinkedListTest.java Repository:
ViewVC logotype

Diff of /jsr166/src/test/tck/LinkedListTest.java

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 1.3, Sun Sep 14 20:42:40 2003 UTC revision 1.9, Wed Sep 14 23:50:31 2005 UTC
# Line 1  Line 1 
1  /*  /*
2   * Written by members of JCP JSR-166 Expert Group and released to the   * Written by Doug Lea with assistance from members of JCP JSR-166
3   * public domain. Use, modify, and redistribute this code in any way   * Expert Group and released to the public domain, as explained at
4   * without acknowledgement. Other contributors include Andrew Wright,   * http://creativecommons.org/licenses/publicdomain
5   * Jeffrey Hayes, Pat Fischer, Mike Judd.   * Other contributors include Andrew Wright, Jeffrey Hayes,
6     * Pat Fisher, Mike Judd.
7   */   */
8    
9  import junit.framework.*;  import junit.framework.*;
# Line 32  Line 33 
33          return q;          return q;
34      }      }
35    
36        /**
37         * new queue is empty
38         */
39      public void testConstructor1(){      public void testConstructor1(){
40          assertEquals(0, new LinkedList().size());          assertEquals(0, new LinkedList().size());
41      }      }
42    
43        /**
44         * Initializing from null Collection throws NPE
45         */
46      public void testConstructor3() {      public void testConstructor3() {
47          try {          try {
48              LinkedList q = new LinkedList((Collection)null);              LinkedList q = new LinkedList((Collection)null);
49              fail("Cannot make from null collection");              shouldThrow();
50          }          }
51          catch (NullPointerException success) {}          catch (NullPointerException success) {}
52      }      }
53    
54        /**
55         * Queue contains all elements of collection used to initialize
56    
57         */
58      public void testConstructor6(){      public void testConstructor6(){
59          try {          try {
60              Integer[] ints = new Integer[SIZE];              Integer[] ints = new Integer[SIZE];
# Line 56  Line 67 
67          finally {}          finally {}
68      }      }
69    
70        /**
71         * isEmpty is true before add, false after
72         */
73      public void testEmpty() {      public void testEmpty() {
74          LinkedList q = new LinkedList();          LinkedList q = new LinkedList();
75          assertTrue(q.isEmpty());          assertTrue(q.isEmpty());
# Line 67  Line 81 
81          assertTrue(q.isEmpty());          assertTrue(q.isEmpty());
82      }      }
83    
84        /**
85         * size changes when elements added and removed
86         */
87      public void testSize() {      public void testSize() {
88          LinkedList q = populatedQueue(SIZE);          LinkedList q = populatedQueue(SIZE);
89          for (int i = 0; i < SIZE; ++i) {          for (int i = 0; i < SIZE; ++i) {
# Line 79  Line 96 
96          }          }
97      }      }
98    
99        /**
100         * offer(null) succeeds
101         */
102      public void testOfferNull(){      public void testOfferNull(){
103          try {          try {
104              LinkedList q = new LinkedList();              LinkedList q = new LinkedList();
105              q.offer(null);              q.offer(null);
106          } catch (NullPointerException ie) {          } catch (NullPointerException ie) {
107              fail("should not throw NPE");              unexpectedException();
108          }          }
109      }      }
110    
111        /**
112         * Offer succeeds
113         */
114      public void testOffer() {      public void testOffer() {
115          LinkedList q = new LinkedList();          LinkedList q = new LinkedList();
116          assertTrue(q.offer(new Integer(0)));          assertTrue(q.offer(new Integer(0)));
117          assertTrue(q.offer(new Integer(1)));          assertTrue(q.offer(new Integer(1)));
118      }      }
119    
120        /**
121         * add succeeds
122         */
123      public void testAdd(){      public void testAdd(){
124          LinkedList q = new LinkedList();          LinkedList q = new LinkedList();
125          for (int i = 0; i < SIZE; ++i) {          for (int i = 0; i < SIZE; ++i) {
# Line 102  Line 128 
128          }          }
129      }      }
130    
131        /**
132         * addAll(null) throws NPE
133         */
134      public void testAddAll1(){      public void testAddAll1(){
135          try {          try {
136              LinkedList q = new LinkedList();              LinkedList q = new LinkedList();
137              q.addAll(null);              q.addAll(null);
138              fail("Cannot add null collection");              shouldThrow();
139          }          }
140          catch (NullPointerException success) {}          catch (NullPointerException success) {}
141      }      }
142    
143        /**
144         * Queue contains all elements, in traversal order, of successful addAll
145         */
146      public void testAddAll5(){      public void testAddAll5(){
147          try {          try {
148              Integer[] empty = new Integer[0];              Integer[] empty = new Integer[0];
# Line 126  Line 158 
158          finally {}          finally {}
159      }      }
160    
161        /**
162         * addAll with too large an index throws IOOBE
163         */
164        public void testAddAll2_IndexOutOfBoundsException() {
165            try {
166                LinkedList l = new LinkedList();
167                l.add(new Object());
168                LinkedList m = new LinkedList();
169                m.add(new Object());
170                l.addAll(4,m);
171                shouldThrow();
172            } catch(IndexOutOfBoundsException  success) {}
173        }
174    
175        /**
176         * addAll with negative index throws IOOBE
177         */
178        public void testAddAll4_BadIndex() {
179            try {
180                LinkedList l = new LinkedList();
181                l.add(new Object());
182                LinkedList m = new LinkedList();
183                m.add(new Object());
184                l.addAll(-1,m);
185                shouldThrow();
186            } catch(IndexOutOfBoundsException  success){}
187        }
188    
189        /**
190         *  poll succeeds unless empty
191         */
192      public void testPoll(){      public void testPoll(){
193          LinkedList q = populatedQueue(SIZE);          LinkedList q = populatedQueue(SIZE);
194          for (int i = 0; i < SIZE; ++i) {          for (int i = 0; i < SIZE; ++i) {
# Line 134  Line 197 
197          assertNull(q.poll());          assertNull(q.poll());
198      }      }
199    
200        /**
201         *  peek returns next element, or null if empty
202         */
203      public void testPeek(){      public void testPeek(){
204          LinkedList q = populatedQueue(SIZE);          LinkedList q = populatedQueue(SIZE);
205          for (int i = 0; i < SIZE; ++i) {          for (int i = 0; i < SIZE; ++i) {
# Line 145  Line 211 
211          assertNull(q.peek());          assertNull(q.peek());
212      }      }
213    
214        /**
215         * element returns next element, or throws NSEE if empty
216         */
217      public void testElement(){      public void testElement(){
218          LinkedList q = populatedQueue(SIZE);          LinkedList q = populatedQueue(SIZE);
219          for (int i = 0; i < SIZE; ++i) {          for (int i = 0; i < SIZE; ++i) {
# Line 153  Line 222 
222          }          }
223          try {          try {
224              q.element();              q.element();
225              fail("no such element");              shouldThrow();
226          }          }
227          catch (NoSuchElementException success) {}          catch (NoSuchElementException success) {}
228      }      }
229    
230        /**
231         *  remove removes next element, or throws NSEE if empty
232         */
233      public void testRemove(){      public void testRemove(){
234          LinkedList q = populatedQueue(SIZE);          LinkedList q = populatedQueue(SIZE);
235          for (int i = 0; i < SIZE; ++i) {          for (int i = 0; i < SIZE; ++i) {
# Line 165  Line 237 
237          }          }
238          try {          try {
239              q.remove();              q.remove();
240              fail("remove should throw");              shouldThrow();
241          } catch (NoSuchElementException success){          } catch (NoSuchElementException success){
242          }          }
243      }      }
244    
245        /**
246         * remove(x) removes x and returns true if present
247         */
248      public void testRemoveElement(){      public void testRemoveElement(){
249          LinkedList q = populatedQueue(SIZE);          LinkedList q = populatedQueue(SIZE);
250          for (int i = 1; i < SIZE; i+=2) {          for (int i = 1; i < SIZE; i+=2) {
# Line 182  Line 257 
257          assertTrue(q.isEmpty());          assertTrue(q.isEmpty());
258      }      }
259    
260        /**
261         * contains(x) reports true when elements added but not yet removed
262         */
263      public void testContains(){      public void testContains(){
264          LinkedList q = populatedQueue(SIZE);          LinkedList q = populatedQueue(SIZE);
265          for (int i = 0; i < SIZE; ++i) {          for (int i = 0; i < SIZE; ++i) {
# Line 191  Line 269 
269          }          }
270      }      }
271    
272        /**
273         * clear removes all elements
274         */
275      public void testClear(){      public void testClear(){
276          LinkedList q = populatedQueue(SIZE);          LinkedList q = populatedQueue(SIZE);
277          q.clear();          q.clear();
# Line 202  Line 283 
283          assertTrue(q.isEmpty());          assertTrue(q.isEmpty());
284      }      }
285    
286        /**
287         * containsAll(c) is true when c contains a subset of elements
288         */
289      public void testContainsAll(){      public void testContainsAll(){
290          LinkedList q = populatedQueue(SIZE);          LinkedList q = populatedQueue(SIZE);
291          LinkedList p = new LinkedList();          LinkedList p = new LinkedList();
# Line 213  Line 297 
297          assertTrue(p.containsAll(q));          assertTrue(p.containsAll(q));
298      }      }
299    
300        /**
301         * retainAll(c) retains only those elements of c and reports true if changed
302         */
303      public void testRetainAll(){      public void testRetainAll(){
304          LinkedList q = populatedQueue(SIZE);          LinkedList q = populatedQueue(SIZE);
305          LinkedList p = populatedQueue(SIZE);          LinkedList p = populatedQueue(SIZE);
# Line 229  Line 316 
316          }          }
317      }      }
318    
319        /**
320         * removeAll(c) removes only those elements of c and reports true if changed
321         */
322      public void testRemoveAll(){      public void testRemoveAll(){
323          for (int i = 1; i < SIZE; ++i) {          for (int i = 1; i < SIZE; ++i) {
324              LinkedList q = populatedQueue(SIZE);              LinkedList q = populatedQueue(SIZE);
# Line 242  Line 332 
332          }          }
333      }      }
334    
335        /**
336         *  toArray contains all elements
337         */
338      public void testToArray(){      public void testToArray(){
339          LinkedList q = populatedQueue(SIZE);          LinkedList q = populatedQueue(SIZE);
340          Object[] o = q.toArray();          Object[] o = q.toArray();
# Line 250  Line 343 
343              assertEquals(o[i], q.poll());              assertEquals(o[i], q.poll());
344      }      }
345    
346        /**
347         *  toArray(a) contains all elements
348         */
349      public void testToArray2(){      public void testToArray2(){
350          LinkedList q = populatedQueue(SIZE);          LinkedList q = populatedQueue(SIZE);
351          Integer[] ints = new Integer[SIZE];          Integer[] ints = new Integer[SIZE];
# Line 259  Line 355 
355              assertEquals(ints[i], q.poll());              assertEquals(ints[i], q.poll());
356      }      }
357    
358        /**
359         * toArray(null) throws NPE
360         */
361        public void testToArray_BadArg() {
362            try {
363                LinkedList l = new LinkedList();
364                l.add(new Object());
365                Object o[] = l.toArray(null);
366                shouldThrow();
367            } catch(NullPointerException success){}
368        }
369    
370        /**
371         * toArray with incompatable aray type throws CCE
372         */
373        public void testToArray1_BadArg() {
374            try {
375                LinkedList l = new LinkedList();
376                l.add(new Integer(5));
377                Object o[] = l.toArray(new String[10] );
378                shouldThrow();
379            } catch(ArrayStoreException  success){}
380        }
381    
382        /**
383         *  iterator iterates through all elements
384         */
385      public void testIterator(){      public void testIterator(){
386          LinkedList q = populatedQueue(SIZE);          LinkedList q = populatedQueue(SIZE);
387          int i = 0;          int i = 0;
# Line 270  Line 393 
393          assertEquals(i, SIZE);          assertEquals(i, SIZE);
394      }      }
395    
396        /**
397         *  iterator ordering is FIFO
398         */
399      public void testIteratorOrdering() {      public void testIteratorOrdering() {
   
400          final LinkedList q = new LinkedList();          final LinkedList q = new LinkedList();
   
401          q.add(new Integer(1));          q.add(new Integer(1));
402          q.add(new Integer(2));          q.add(new Integer(2));
403          q.add(new Integer(3));          q.add(new Integer(3));
   
404          int k = 0;          int k = 0;
405          for (Iterator it = q.iterator(); it.hasNext();) {          for (Iterator it = q.iterator(); it.hasNext();) {
406              int i = ((Integer)(it.next())).intValue();              int i = ((Integer)(it.next())).intValue();
407              assertEquals("items should come out in order", ++k, i);              assertEquals(++k, i);
408          }          }
409    
410          assertEquals("should go through 3 elements", 3, k);          assertEquals(3, k);
411      }      }
412    
413        /**
414         * iterator.remove removes current element
415         */
416      public void testIteratorRemove () {      public void testIteratorRemove () {
417          final LinkedList q = new LinkedList();          final LinkedList q = new LinkedList();
   
418          q.add(new Integer(1));          q.add(new Integer(1));
419          q.add(new Integer(2));          q.add(new Integer(2));
420          q.add(new Integer(3));          q.add(new Integer(3));
   
421          Iterator it = q.iterator();          Iterator it = q.iterator();
422          it.next();          it.next();
423          it.remove();          it.remove();
   
424          it = q.iterator();          it = q.iterator();
425          assertEquals(it.next(), new Integer(2));          assertEquals(it.next(), new Integer(2));
426          assertEquals(it.next(), new Integer(3));          assertEquals(it.next(), new Integer(3));
427          assertFalse(it.hasNext());          assertFalse(it.hasNext());
428      }      }
429    
430        /**
431      public void testToString(){       *  Descending iterator iterates through all elements
432         */
433        public void testDescendingIterator() {
434          LinkedList q = populatedQueue(SIZE);          LinkedList q = populatedQueue(SIZE);
435          String s = q.toString();          int i = 0;
436          for (int i = 0; i < SIZE; ++i) {          Iterator it = q.descendingIterator();
437              assertTrue(s.indexOf(String.valueOf(i)) >= 0);          while(it.hasNext()) {
438                assertTrue(q.contains(it.next()));
439                ++i;
440            }
441            assertEquals(i, SIZE);
442            assertFalse(it.hasNext());
443            try {
444                it.next();
445            } catch(NoSuchElementException success) {
446          }          }
447      }      }
448    
449      public void testAddFirst(){      /**
450          LinkedList q = populatedQueue(3);       *  Descending iterator ordering is reverse FIFO
451          q.addFirst(new Integer(4));       */
452          assertEquals(new Integer(4),q.get(0));      public void testDescendingIteratorOrdering() {
453            final LinkedList q = new LinkedList();
454            q.add(new Integer(3));
455            q.add(new Integer(2));
456            q.add(new Integer(1));
457            int k = 0;
458            for (Iterator it = q.descendingIterator(); it.hasNext();) {
459                int i = ((Integer)(it.next())).intValue();
460                assertEquals(++k, i);
461      }      }
462    
463      public void testAddLast(){          assertEquals(3, k);
         LinkedList q = populatedQueue(3);  
         q.addLast(new Integer(3));  
         assertEquals(new Integer(3),q.get(3));  
464      }      }
465    
466      public void testGetFirst() {      /**
467          LinkedList q = populatedQueue(3);       * descendingIterator.remove removes current element
468          assertEquals(new Integer(0),q.getFirst());       */
469        public void testDescendingIteratorRemove () {
470            final LinkedList q = new LinkedList();
471            q.add(new Integer(3));
472            q.add(new Integer(2));
473            q.add(new Integer(1));
474            Iterator it = q.descendingIterator();
475            it.next();
476            it.remove();
477            it = q.descendingIterator();
478            assertEquals(it.next(), new Integer(2));
479            assertEquals(it.next(), new Integer(3));
480            assertFalse(it.hasNext());
481      }      }
482    
     public void testGetLast() {  
         LinkedList q = populatedQueue(3);  
         assertEquals(new Integer(2),q.getLast());  
     }  
483    
484      public void testIndexOf(){      /**
485          LinkedList q = populatedQueue(3);       * toString contains toStrings of elements
486          assertEquals(0,q.indexOf(new Integer(0)));       */
487          assertEquals(1,q.indexOf(new Integer(1)));      public void testToString() {
488          assertEquals(2,q.indexOf(new Integer(2)));          LinkedList q = populatedQueue(SIZE);
489          assertEquals(-1, q.indexOf("not there"));          String s = q.toString();
490            for (int i = 0; i < SIZE; ++i) {
491                assertTrue(s.indexOf(String.valueOf(i)) >= 0);
492            }
493      }      }
494    
495      public void testLastIndexOf(){      /**
496         * peek returns element inserted with addFirst
497         */
498        public void testAddFirst() {
499          LinkedList q = populatedQueue(3);          LinkedList q = populatedQueue(3);
500          q.add(new Integer(2));          q.addFirst(four);
501          assertEquals(3,q.lastIndexOf(new Integer(2)));          assertEquals(four,q.peek());
         assertEquals(-1, q.lastIndexOf("not there"));  
502      }      }
503    
504      public void testSet(){      /**
505         * peekFirst returns element inserted with push
506         */
507        public void testPush() {
508          LinkedList q = populatedQueue(3);          LinkedList q = populatedQueue(3);
509          q.set(0,(new Integer(1)));          q.pollLast();
510          assertFalse(q.contains(new Integer(0)));          q.push(four);
511          assertEquals(new Integer(1), q.get(0));          assertEquals(four,q.peekFirst());
512      }      }
513    
514        /**
515      public void testGetFirst_NoSuchElementException(){       *  pop removes next element, or throws NSEE if empty
516          try {       */
517              LinkedList l = new LinkedList();      public void testPop() {
518              l.getFirst();          LinkedList q = populatedQueue(SIZE);
519              fail("First Element");          for (int i = 0; i < SIZE; ++i) {
520          }              assertEquals(i, ((Integer)q.pop()).intValue());
         catch(NoSuchElementException success) {}  
521      }      }
   
     public void testRemoveFirst() {  
522          try {          try {
523              LinkedList l = new LinkedList();              q.pop();
524              l.removeFirst();              shouldThrow();
525              fail("R: First Element");          } catch (NoSuchElementException success){
526          }          }
         catch(NoSuchElementException success) {}  
527      }      }
528    
529      public void testRemoveLast() {      /**
530          try {       * OfferFirst succeeds
531              LinkedList l = new LinkedList();       */
532              l.removeLast();      public void testOfferFirst() {
533              fail("R: Last Element");          LinkedList q = new LinkedList();
534          }          assertTrue(q.offerFirst(new Integer(0)));
535          catch(NoSuchElementException success) {}          assertTrue(q.offerFirst(new Integer(1)));
536      }      }
537    
538      public void testGetLast_NoSuchElementException(){      /**
539          try {       * OfferLast succeeds
540              LinkedList l = new LinkedList();       */
541              l.getLast();      public void testOfferLast() {
542              fail("Last Element");          LinkedList q = new LinkedList();
543          }          assertTrue(q.offerLast(new Integer(0)));
544          catch(NoSuchElementException success) {}          assertTrue(q.offerLast(new Integer(1)));
545      }      }
546    
547        /**
548      public void testAddAll_NullPointerException(){       *  pollLast succeeds unless empty
549          try {       */
550              LinkedList l = new LinkedList();      public void testPollLast() {
551              l.addAll((Collection)null);          LinkedList q = populatedQueue(SIZE);
552              fail("Add All Failed");          for (int i = SIZE-1; i >= 0; --i) {
553                assertEquals(i, ((Integer)q.pollLast()).intValue());
554          }          }
555          catch(NullPointerException success){}          assertNull(q.pollLast());
556      }      }
557    
558        /**
559      public void testAddAll1_OutOfBounds() {       *  peekFirst returns next element, or null if empty
560          try {       */
561              LinkedList l = new LinkedList();      public void testPeekFirst() {
562              l.addAll(4,new LinkedList());          LinkedList q = populatedQueue(SIZE);
563              fail("boolean addAll(int, Collection) should throw IndexOutOfBoundsException");          for (int i = 0; i < SIZE; ++i) {
564                assertEquals(i, ((Integer)q.peekFirst()).intValue());
565                q.pollFirst();
566                assertTrue(q.peekFirst() == null ||
567                           i != ((Integer)q.peekFirst()).intValue());
568          }          }
569          catch(IndexOutOfBoundsException  success) {}          assertNull(q.peekFirst());
570      }      }
571    
572    
573      public void testAddAll2_IndexOutOfBoundsException() {      /**
574          try {       *  peekLast returns next element, or null if empty
575              LinkedList l = new LinkedList();       */
576              l.add(new Object());      public void testPeekLast() {
577              LinkedList m = new LinkedList();          LinkedList q = populatedQueue(SIZE);
578              m.add(new Object());          for (int i = SIZE-1; i >= 0; --i) {
579              l.addAll(4,m);              assertEquals(i, ((Integer)q.peekLast()).intValue());
580              fail("Add All Failed " + l.size());              q.pollLast();
581          }catch(IndexOutOfBoundsException  success) {}              assertTrue(q.peekLast() == null ||
582      }                         i != ((Integer)q.peekLast()).intValue());
   
     public void testAddAll4_BadIndex() {  
         try {  
             LinkedList l = new LinkedList();  
             l.add(new Object());  
             LinkedList m = new LinkedList();  
             m.add(new Object());  
             l.addAll(-1,m);  
             fail("Add All Failed " + l.size());  
         }catch(IndexOutOfBoundsException  success){}  
583      }      }
584            assertNull(q.peekLast());
     public void testget1() {  
         try {  
             LinkedList l = new LinkedList();  
             l.add(new Object());  
             l.get(-1);  
             fail("get Failed - l.get(-1)");  
         }catch(IndexOutOfBoundsException  success) {}  
585      }      }
586    
587      public void testget2() {      public void testFirstElement() {
588          try {          LinkedList q = populatedQueue(SIZE);
589              LinkedList l = new LinkedList();          for (int i = 0; i < SIZE; ++i) {
590              l.add(new Object());              assertEquals(i, ((Integer)q.getFirst()).intValue());
591              l.get(5);              q.pollFirst();
             fail("get Failed - l.get(5) l.size(): " + l.size());  
         }catch(IndexOutOfBoundsException  success){}  
     }  
   
     public void testset1() {  
         try {  
             LinkedList l = new LinkedList();  
             l.add(new Object());  
             l.set(-1,new Object());  
             fail("set failed - l.set(-1,...)" + l.size());  
         }catch(IndexOutOfBoundsException  success){}  
592      }      }
   
     public void testset2() {  
593          try {          try {
594              LinkedList l = new LinkedList();              q.getFirst();
595              l.add(new Object());              shouldThrow();
             l.set(5,new Object());  
             fail("set failed = l.set(5,..) l.size():" + l.size());  
         }catch(IndexOutOfBoundsException  success){}  
596      }      }
597            catch (NoSuchElementException success) {}
     public void testadd1() {  
         try {  
             LinkedList l = new LinkedList();  
             l.add(new Object());  
             l.add(-1,new Object());  
             fail("Add Failed - l.add(-1) l.size(): " + l.size());  
         }catch(IndexOutOfBoundsException  success){}  
598      }      }
599    
600      public void add2(){      /**
601          try {       *  getLast returns next element, or throws NSEE if empty
602              LinkedList l = new LinkedList();       */
603              l.add(new Object());      public void testLastElement() {
604              l.add(5,new Object());          LinkedList q = populatedQueue(SIZE);
605              fail("Add Failed  l.add(f,...)");          for (int i = SIZE-1; i >= 0; --i) {
606          }catch(IndexOutOfBoundsException  success) {}              assertEquals(i, ((Integer)q.getLast()).intValue());
607                q.pollLast();
608      }      }
   
     public void testremove(){  
609          try {          try {
610              LinkedList l = new LinkedList();              q.getLast();
611              l.add(new Object());              shouldThrow();
             l.remove(-1);  
             fail("Remove Failed l.remove(-1); l.size():" + l.size());  
         }catch(IndexOutOfBoundsException  success){}  
612      }      }
613            catch (NoSuchElementException success) {}
614      public void testremove1(){          assertNull(q.peekLast());
         try {  
             LinkedList l = new LinkedList();  
             l.add(new Object());  
             l.remove(5);  
             fail("Remove Failed l.remove(5); l.size():" + l.size());  
         }catch(IndexOutOfBoundsException  success){}  
615      }      }
616    
617        /**
618      public void testremove2(){       * removeFirstOccurrence(x) removes x and returns true if present
619          try{       */
620              LinkedList l = new LinkedList();      public void testRemoveFirstOccurrence() {
621              l.remove();          LinkedList q = populatedQueue(SIZE);
622              fail("LinkedList - Object remove() should throw a NoSuchElementException");          for (int i = 1; i < SIZE; i+=2) {
623          }catch(NoSuchElementException e){}              assertTrue(q.removeFirstOccurrence(new Integer(i)));
624      }      }
625            for (int i = 0; i < SIZE; i+=2) {
626      public void testlistIt1() {              assertTrue(q.removeFirstOccurrence(new Integer(i)));
627          try {              assertFalse(q.removeFirstOccurrence(new Integer(i+1)));
             LinkedList l = new LinkedList();  
             l.add(new Object());  
             l.listIterator(5);  
             fail("l.listIterator(5) l.size():" + l.size());  
         }catch(IndexOutOfBoundsException  success){}  
628      }      }
629            assertTrue(q.isEmpty());
     public void testlistIt2() {  
         try {  
             LinkedList l = new LinkedList();  
             l.add(new Object());  
             l.listIterator(-1);  
             fail("l.listIterator(-1) l.size():" + l.size());  
         }catch(IndexOutOfBoundsException  success){}  
630      }      }
631    
632      public void testlistIt3() {      /**
633          try {       * removeLastOccurrence(x) removes x and returns true if present
634              LinkedList l = new LinkedList();       */
635              l.add(new Object());      public void testRemoveLastOccurrence() {
636              ListIterator a = l.listIterator(0);          LinkedList q = populatedQueue(SIZE);
637              l.removeFirst();          for (int i = 1; i < SIZE; i+=2) {
638              a.next();              assertTrue(q.removeLastOccurrence(new Integer(i)));
             fail("l.listIterator(-1) l.size():" + l.size());  
         }catch(ConcurrentModificationException success){}  
639      }      }
640            for (int i = 0; i < SIZE; i+=2) {
641      public void testToArray_BadArg() {              assertTrue(q.removeLastOccurrence(new Integer(i)));
642          try {              assertFalse(q.removeLastOccurrence(new Integer(i+1)));
             LinkedList l = new LinkedList();  
             l.add(new Object());  
             Object o[] = l.toArray(null);  
             fail("l.toArray(null) did not throw an exception");  
         }catch(NullPointerException success){}  
643      }      }
644            assertTrue(q.isEmpty());
     public void testToArray1_BadArg() {  
         try {  
             LinkedList l = new LinkedList();  
             l.add(new Integer(5));  
             Object o[] = l.toArray(new String[10] );  
             fail("l.toArray(String[] f) did not throw an exception, an Integer was added");  
         }catch(ArrayStoreException  success){}  
645      }      }
646    
647  }  }

Legend:
Removed from v.1.3  
changed lines
  Added in v.1.9

Doug Lea
ViewVC Help
Powered by ViewVC 1.0.8