[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.1, Sun Aug 31 19:24:55 2003 UTC revision 1.5, Thu Sep 25 11:02:41 2003 UTC
# Line 9  Line 9 
9  import java.util.*;  import java.util.*;
10  import java.util.concurrent.*;  import java.util.concurrent.*;
11    
12  public class LinkedListTest extends TestCase {  public class LinkedListTest extends JSR166TestCase {
   
     private static final int N = 10;  
     private static final long SHORT_DELAY_MS = 100;  
     private static final long MEDIUM_DELAY_MS = 1000;  
     private static final long LONG_DELAY_MS = 10000;  
   
13      public static void main(String[] args) {      public static void main(String[] args) {
14          junit.textui.TestRunner.run (suite());          junit.textui.TestRunner.run (suite());
15      }      }
# Line 28  Line 22 
22       * Create a queue of given size containing consecutive       * Create a queue of given size containing consecutive
23       * Integers 0 ... n.       * Integers 0 ... n.
24       */       */
25      private LinkedList fullQueue(int n) {      private LinkedList populatedQueue(int n) {
26          LinkedList q = new LinkedList();          LinkedList q = new LinkedList();
27          assertTrue(q.isEmpty());          assertTrue(q.isEmpty());
28          for(int i = 0; i < n; ++i)          for(int i = 0; i < n; ++i)
# Line 38  Line 32 
32          return q;          return q;
33      }      }
34    
35        /**
36         * new queue is empty
37         */
38      public void testConstructor1(){      public void testConstructor1(){
39          assertEquals(0, new LinkedList().size());          assertEquals(0, new LinkedList().size());
40      }      }
41    
42        /**
43         * Initializing from null Collection throws NPE
44         */
45      public void testConstructor3() {      public void testConstructor3() {
46          try {          try {
47              LinkedList q = new LinkedList((Collection)null);              LinkedList q = new LinkedList((Collection)null);
48              fail("Cannot make from null collection");              shouldThrow();
49          }          }
50          catch (NullPointerException success) {}          catch (NullPointerException success) {}
51      }      }
52    
53        /**
54         * Queue contains all elements of collection used to initialize
55    
56         */
57      public void testConstructor6(){      public void testConstructor6(){
58          try {          try {
59              Integer[] ints = new Integer[N];              Integer[] ints = new Integer[SIZE];
60              for (int i = 0; i < N; ++i)              for (int i = 0; i < SIZE; ++i)
61                  ints[i] = new Integer(i);                  ints[i] = new Integer(i);
62              LinkedList q = new LinkedList(Arrays.asList(ints));              LinkedList q = new LinkedList(Arrays.asList(ints));
63              for (int i = 0; i < N; ++i)              for (int i = 0; i < SIZE; ++i)
64                  assertEquals(ints[i], q.poll());                  assertEquals(ints[i], q.poll());
65          }          }
66          finally {}          finally {}
67      }      }
68    
69        /**
70         * isEmpty is true before add, false after
71         */
72      public void testEmpty() {      public void testEmpty() {
73          LinkedList q = new LinkedList();          LinkedList q = new LinkedList();
74          assertTrue(q.isEmpty());          assertTrue(q.isEmpty());
# Line 73  Line 80 
80          assertTrue(q.isEmpty());          assertTrue(q.isEmpty());
81      }      }
82    
83        /**
84         * size changes when elements added and removed
85         */
86      public void testSize() {      public void testSize() {
87          LinkedList q = fullQueue(N);          LinkedList q = populatedQueue(SIZE);
88          for (int i = 0; i < N; ++i) {          for (int i = 0; i < SIZE; ++i) {
89              assertEquals(N-i, q.size());              assertEquals(SIZE-i, q.size());
90              q.remove();              q.remove();
91          }          }
92          for (int i = 0; i < N; ++i) {          for (int i = 0; i < SIZE; ++i) {
93              assertEquals(i, q.size());              assertEquals(i, q.size());
94              q.add(new Integer(i));              q.add(new Integer(i));
95          }          }
96      }      }
97    
98        /**
99         * offer(null) succeeds
100         */
101      public void testOfferNull(){      public void testOfferNull(){
102          try {          try {
103              LinkedList q = new LinkedList();              LinkedList q = new LinkedList();
104              q.offer(null);              q.offer(null);
105          } catch (NullPointerException ie) {          } catch (NullPointerException ie) {
106              fail("should not throw NPE");              unexpectedException();
107          }          }
108      }      }
109    
110        /**
111         * Offer succeeds
112         */
113      public void testOffer() {      public void testOffer() {
114          LinkedList q = new LinkedList();          LinkedList q = new LinkedList();
115          assertTrue(q.offer(new Integer(0)));          assertTrue(q.offer(new Integer(0)));
116          assertTrue(q.offer(new Integer(1)));          assertTrue(q.offer(new Integer(1)));
117      }      }
118    
119        /**
120         * add succeeds
121         */
122      public void testAdd(){      public void testAdd(){
123          LinkedList q = new LinkedList();          LinkedList q = new LinkedList();
124          for (int i = 0; i < N; ++i) {          for (int i = 0; i < SIZE; ++i) {
125              assertEquals(i, q.size());              assertEquals(i, q.size());
126              assertTrue(q.add(new Integer(i)));              assertTrue(q.add(new Integer(i)));
127          }          }
128      }      }
129    
130        /**
131         * addAll(null) throws NPE
132         */
133      public void testAddAll1(){      public void testAddAll1(){
134          try {          try {
135              LinkedList q = new LinkedList();              LinkedList q = new LinkedList();
136              q.addAll(null);              q.addAll(null);
137              fail("Cannot add null collection");              shouldThrow();
138          }          }
139          catch (NullPointerException success) {}          catch (NullPointerException success) {}
140      }      }
141    
142        /**
143         * Queue contains all elements, in traversal order, of successful addAll
144         */
145      public void testAddAll5(){      public void testAddAll5(){
146          try {          try {
147              Integer[] empty = new Integer[0];              Integer[] empty = new Integer[0];
148              Integer[] ints = new Integer[N];              Integer[] ints = new Integer[SIZE];
149              for (int i = 0; i < N; ++i)              for (int i = 0; i < SIZE; ++i)
150                  ints[i] = new Integer(i);                  ints[i] = new Integer(i);
151              LinkedList q = new LinkedList();              LinkedList q = new LinkedList();
152              assertFalse(q.addAll(Arrays.asList(empty)));              assertFalse(q.addAll(Arrays.asList(empty)));
153              assertTrue(q.addAll(Arrays.asList(ints)));              assertTrue(q.addAll(Arrays.asList(ints)));
154              for (int i = 0; i < N; ++i)              for (int i = 0; i < SIZE; ++i)
155                  assertEquals(ints[i], q.poll());                  assertEquals(ints[i], q.poll());
156          }          }
157          finally {}          finally {}
158      }      }
159    
160        /**
161         * addAll with too large an index throws IOOBE
162         */
163        public void testAddAll2_IndexOutOfBoundsException() {
164            try {
165                LinkedList l = new LinkedList();
166                l.add(new Object());
167                LinkedList m = new LinkedList();
168                m.add(new Object());
169                l.addAll(4,m);
170                shouldThrow();
171            } catch(IndexOutOfBoundsException  success) {}
172        }
173    
174        /**
175         * addAll with negative index throws IOOBE
176         */
177        public void testAddAll4_BadIndex() {
178            try {
179                LinkedList l = new LinkedList();
180                l.add(new Object());
181                LinkedList m = new LinkedList();
182                m.add(new Object());
183                l.addAll(-1,m);
184                shouldThrow();
185            } catch(IndexOutOfBoundsException  success){}
186        }
187    
188        /**
189         *  poll succeeds unless empty
190         */
191      public void testPoll(){      public void testPoll(){
192          LinkedList q = fullQueue(N);          LinkedList q = populatedQueue(SIZE);
193          for (int i = 0; i < N; ++i) {          for (int i = 0; i < SIZE; ++i) {
194              assertEquals(i, ((Integer)q.poll()).intValue());              assertEquals(i, ((Integer)q.poll()).intValue());
195          }          }
196          assertNull(q.poll());          assertNull(q.poll());
197      }      }
198    
199        /**
200         *  peek returns next element, or null if empty
201         */
202      public void testPeek(){      public void testPeek(){
203          LinkedList q = fullQueue(N);          LinkedList q = populatedQueue(SIZE);
204          for (int i = 0; i < N; ++i) {          for (int i = 0; i < SIZE; ++i) {
205              assertEquals(i, ((Integer)q.peek()).intValue());              assertEquals(i, ((Integer)q.peek()).intValue());
206              q.poll();              q.poll();
207              assertTrue(q.peek() == null ||              assertTrue(q.peek() == null ||
# Line 151  Line 210 
210          assertNull(q.peek());          assertNull(q.peek());
211      }      }
212    
213        /**
214         *
215         */
216      public void testElement(){      public void testElement(){
217          LinkedList q = fullQueue(N);          LinkedList q = populatedQueue(SIZE);
218          for (int i = 0; i < N; ++i) {          for (int i = 0; i < SIZE; ++i) {
219              assertEquals(i, ((Integer)q.element()).intValue());              assertEquals(i, ((Integer)q.element()).intValue());
220              q.poll();              q.poll();
221          }          }
222          try {          try {
223              q.element();              q.element();
224              fail("no such element");              shouldThrow();
225          }          }
226          catch (NoSuchElementException success) {}          catch (NoSuchElementException success) {}
227      }      }
228    
229        /**
230         * element returns next element, or throws NSEE if empty
231         */
232      public void testRemove(){      public void testRemove(){
233          LinkedList q = fullQueue(N);          LinkedList q = populatedQueue(SIZE);
234          for (int i = 0; i < N; ++i) {          for (int i = 0; i < SIZE; ++i) {
235              assertEquals(i, ((Integer)q.remove()).intValue());              assertEquals(i, ((Integer)q.remove()).intValue());
236          }          }
237          try {          try {
238              q.remove();              q.remove();
239              fail("remove should throw");              shouldThrow();
240          } catch (NoSuchElementException success){          } catch (NoSuchElementException success){
241          }          }
242      }      }
243    
244        /**
245         * remove(x) removes x and returns true if present
246         */
247      public void testRemoveElement(){      public void testRemoveElement(){
248          LinkedList q = fullQueue(N);          LinkedList q = populatedQueue(SIZE);
249          for (int i = 1; i < N; i+=2) {          for (int i = 1; i < SIZE; i+=2) {
250              assertTrue(q.remove(new Integer(i)));              assertTrue(q.remove(new Integer(i)));
251          }          }
252          for (int i = 0; i < N; i+=2) {          for (int i = 0; i < SIZE; i+=2) {
253              assertTrue(q.remove(new Integer(i)));              assertTrue(q.remove(new Integer(i)));
254              assertFalse(q.remove(new Integer(i+1)));              assertFalse(q.remove(new Integer(i+1)));
255          }          }
256          assert(q.isEmpty());          assertTrue(q.isEmpty());
257      }      }
258    
259        /**
260         * contains(x) reports true when elements added but not yet removed
261         */
262      public void testContains(){      public void testContains(){
263          LinkedList q = fullQueue(N);          LinkedList q = populatedQueue(SIZE);
264          for (int i = 0; i < N; ++i) {          for (int i = 0; i < SIZE; ++i) {
265              assertTrue(q.contains(new Integer(i)));              assertTrue(q.contains(new Integer(i)));
266              q.poll();              q.poll();
267              assertFalse(q.contains(new Integer(i)));              assertFalse(q.contains(new Integer(i)));
268          }          }
269      }      }
270    
271        /**
272         * clear removes all elements
273         */
274      public void testClear(){      public void testClear(){
275          LinkedList q = fullQueue(N);          LinkedList q = populatedQueue(SIZE);
276          q.clear();          q.clear();
277          assertTrue(q.isEmpty());          assertTrue(q.isEmpty());
278          assertEquals(0, q.size());          assertEquals(0, q.size());
# Line 208  Line 282 
282          assertTrue(q.isEmpty());          assertTrue(q.isEmpty());
283      }      }
284    
285        /**
286         * containsAll(c) is true when c contains a subset of elements
287         */
288      public void testContainsAll(){      public void testContainsAll(){
289          LinkedList q = fullQueue(N);          LinkedList q = populatedQueue(SIZE);
290          LinkedList p = new LinkedList();          LinkedList p = new LinkedList();
291          for (int i = 0; i < N; ++i) {          for (int i = 0; i < SIZE; ++i) {
292              assertTrue(q.containsAll(p));              assertTrue(q.containsAll(p));
293              assertFalse(p.containsAll(q));              assertFalse(p.containsAll(q));
294              p.add(new Integer(i));              p.add(new Integer(i));
# Line 219  Line 296 
296          assertTrue(p.containsAll(q));          assertTrue(p.containsAll(q));
297      }      }
298    
299        /**
300         * retainAll(c) retains only those elements of c and reports true if changed
301         */
302      public void testRetainAll(){      public void testRetainAll(){
303          LinkedList q = fullQueue(N);          LinkedList q = populatedQueue(SIZE);
304          LinkedList p = fullQueue(N);          LinkedList p = populatedQueue(SIZE);
305          for (int i = 0; i < N; ++i) {          for (int i = 0; i < SIZE; ++i) {
306              boolean changed = q.retainAll(p);              boolean changed = q.retainAll(p);
307              if (i == 0)              if (i == 0)
308                  assertFalse(changed);                  assertFalse(changed);
# Line 230  Line 310 
310                  assertTrue(changed);                  assertTrue(changed);
311    
312              assertTrue(q.containsAll(p));              assertTrue(q.containsAll(p));
313              assertEquals(N-i, q.size());              assertEquals(SIZE-i, q.size());
314              p.remove();              p.remove();
315          }          }
316      }      }
317    
318        /**
319         *  removeAll(c) removes only those elements of c and reports true if changed
320         */
321      public void testRemoveAll(){      public void testRemoveAll(){
322          for (int i = 1; i < N; ++i) {          for (int i = 1; i < SIZE; ++i) {
323              LinkedList q = fullQueue(N);              LinkedList q = populatedQueue(SIZE);
324              LinkedList p = fullQueue(i);              LinkedList p = populatedQueue(i);
325              assertTrue(q.removeAll(p));              assertTrue(q.removeAll(p));
326              assertEquals(N-i, q.size());              assertEquals(SIZE-i, q.size());
327              for (int j = 0; j < i; ++j) {              for (int j = 0; j < i; ++j) {
328                  Integer I = (Integer)(p.remove());                  Integer I = (Integer)(p.remove());
329                  assertFalse(q.contains(I));                  assertFalse(q.contains(I));
# Line 248  Line 331 
331          }          }
332      }      }
333    
334        /**
335         *  toArray contains all elements
336         */
337      public void testToArray(){      public void testToArray(){
338          LinkedList q = fullQueue(N);          LinkedList q = populatedQueue(SIZE);
339          Object[] o = q.toArray();          Object[] o = q.toArray();
340          Arrays.sort(o);          Arrays.sort(o);
341          for(int i = 0; i < o.length; i++)          for(int i = 0; i < o.length; i++)
342              assertEquals(o[i], q.poll());              assertEquals(o[i], q.poll());
343      }      }
344    
345        /**
346         *  toArray(a) contains all elements
347         */
348      public void testToArray2(){      public void testToArray2(){
349          LinkedList q = fullQueue(N);          LinkedList q = populatedQueue(SIZE);
350          Integer[] ints = new Integer[N];          Integer[] ints = new Integer[SIZE];
351          ints = (Integer[])q.toArray(ints);          ints = (Integer[])q.toArray(ints);
352          Arrays.sort(ints);          Arrays.sort(ints);
353          for(int i = 0; i < ints.length; i++)          for(int i = 0; i < ints.length; i++)
354              assertEquals(ints[i], q.poll());              assertEquals(ints[i], q.poll());
355      }      }
356    
357        /**
358         * toArray(null) throws NPE
359         */
360        public void testToArray_BadArg() {
361            try {
362                LinkedList l = new LinkedList();
363                l.add(new Object());
364                Object o[] = l.toArray(null);
365                shouldThrow();
366            } catch(NullPointerException success){}
367        }
368    
369        /**
370         * toArray with incompatable aray type throws CCE
371         */
372        public void testToArray1_BadArg() {
373            try {
374                LinkedList l = new LinkedList();
375                l.add(new Integer(5));
376                Object o[] = l.toArray(new String[10] );
377                shouldThrow();
378            } catch(ArrayStoreException  success){}
379        }
380    
381        /**
382         *  iterator iterates through all elements
383         */
384      public void testIterator(){      public void testIterator(){
385          LinkedList q = fullQueue(N);          LinkedList q = populatedQueue(SIZE);
386          int i = 0;          int i = 0;
387          Iterator it = q.iterator();          Iterator it = q.iterator();
388          while(it.hasNext()) {          while(it.hasNext()) {
389              assertTrue(q.contains(it.next()));              assertTrue(q.contains(it.next()));
390              ++i;              ++i;
391          }          }
392          assertEquals(i, N);          assertEquals(i, SIZE);
393      }      }
394    
395        /**
396         *  iterator ordering is FIFO
397         */
398      public void testIteratorOrdering() {      public void testIteratorOrdering() {
   
399          final LinkedList q = new LinkedList();          final LinkedList q = new LinkedList();
   
400          q.add(new Integer(1));          q.add(new Integer(1));
401          q.add(new Integer(2));          q.add(new Integer(2));
402          q.add(new Integer(3));          q.add(new Integer(3));
   
403          int k = 0;          int k = 0;
404          for (Iterator it = q.iterator(); it.hasNext();) {          for (Iterator it = q.iterator(); it.hasNext();) {
405              int i = ((Integer)(it.next())).intValue();              int i = ((Integer)(it.next())).intValue();
406              assertEquals("items should come out in order", ++k, i);              assertEquals(++k, i);
407          }          }
408    
409          assertEquals("should go through 3 elements", 3, k);          assertEquals(3, k);
410      }      }
411    
412        /**
413         * iterator.remove removes current element
414         */
415      public void testIteratorRemove () {      public void testIteratorRemove () {
416          final LinkedList q = new LinkedList();          final LinkedList q = new LinkedList();
   
417          q.add(new Integer(1));          q.add(new Integer(1));
418          q.add(new Integer(2));          q.add(new Integer(2));
419          q.add(new Integer(3));          q.add(new Integer(3));
   
420          Iterator it = q.iterator();          Iterator it = q.iterator();
421          it.next();          it.next();
422          it.remove();          it.remove();
   
423          it = q.iterator();          it = q.iterator();
424          assertEquals(it.next(), new Integer(2));          assertEquals(it.next(), new Integer(2));
425          assertEquals(it.next(), new Integer(3));          assertEquals(it.next(), new Integer(3));
# Line 311  Line 427 
427      }      }
428    
429    
430        /**
431         * toString contains toStrings of elements
432         */
433      public void testToString(){      public void testToString(){
434          LinkedList q = fullQueue(N);          LinkedList q = populatedQueue(SIZE);
435          String s = q.toString();          String s = q.toString();
436          for (int i = 0; i < N; ++i) {          for (int i = 0; i < SIZE; ++i) {
437              assertTrue(s.indexOf(String.valueOf(i)) >= 0);              assertTrue(s.indexOf(String.valueOf(i)) >= 0);
438          }          }
439      }      }
440    
441        /**
442         * peek returns element inserted with addFirst
443         */
444      public void testAddFirst(){      public void testAddFirst(){
445          LinkedList q = fullQueue(3);          LinkedList q = populatedQueue(3);
446          q.addFirst(new Integer(4));          q.addFirst(four);
447          assertEquals(new Integer(4),q.get(0));          assertEquals(four,q.peek());
     }  
   
     public void testAddLast(){  
         LinkedList q = fullQueue(3);  
         q.addLast(new Integer(3));  
         assertEquals(new Integer(3),q.get(3));  
     }  
   
     public void testGetFirst() {  
         LinkedList q = fullQueue(3);  
         assertEquals(new Integer(0),q.getFirst());  
     }  
   
     public void testGetLast() {  
         LinkedList q = fullQueue(3);  
         assertEquals(new Integer(2),q.getLast());  
     }  
   
     public void testIndexOf(){  
         LinkedList q = fullQueue(3);  
         assertEquals(0,q.indexOf(new Integer(0)));  
         assertEquals(1,q.indexOf(new Integer(1)));  
         assertEquals(2,q.indexOf(new Integer(2)));  
         assertEquals(-1, q.indexOf("not there"));  
     }  
   
     public void testLastIndexOf(){  
         LinkedList q = fullQueue(3);  
         q.add(new Integer(2));  
         assertEquals(3,q.lastIndexOf(new Integer(2)));  
         assertEquals(-1, q.lastIndexOf("not there"));  
     }  
   
     public void testSet(){  
         LinkedList q = fullQueue(3);  
         q.set(0,(new Integer(1)));  
         assertFalse(q.contains(new Integer(0)));  
         assertEquals(new Integer(1), q.get(0));  
     }  
   
   
     public void testGetFirst_NoSuchElementException(){  
         try {  
             LinkedList l = new LinkedList();  
             l.getFirst();  
             fail("First Element");  
         }  
         catch(NoSuchElementException success) {}  
     }  
   
     public void testRemoveFirst() {  
         try {  
             LinkedList l = new LinkedList();  
             l.removeFirst();  
             fail("R: First Element");  
         }  
         catch(NoSuchElementException success) {}  
     }  
   
     public void testRemoveLast() {  
         try {  
             LinkedList l = new LinkedList();  
             l.removeLast();  
             fail("R: Last Element");  
         }  
         catch(NoSuchElementException success) {}  
     }  
   
     public void testGetLast_NoSuchElementException(){  
         try {  
             LinkedList l = new LinkedList();  
             l.getLast();  
             fail("Last Element");  
         }  
         catch(NoSuchElementException success) {}  
     }  
   
   
     public void testAddAll_NullPointerException(){  
         try {  
             LinkedList l = new LinkedList();  
             l.addAll((Collection)null);  
             fail("Add All Failed");  
         }  
         catch(NullPointerException success){}  
     }  
   
   
     public void testAddAll1_OutOfBounds() {  
         try {  
             LinkedList l = new LinkedList();  
             l.addAll(4,new LinkedList());  
             fail("boolean addAll(int, Collection) should throw IndexOutOfBoundsException");  
         }  
         catch(IndexOutOfBoundsException  success) {}  
     }  
   
   
     public void testAddAll2_IndexOutOfBoundsException() {  
         try {  
             LinkedList l = new LinkedList();  
             l.add(new Object());  
             LinkedList m = new LinkedList();  
             m.add(new Object());  
             l.addAll(4,m);  
             fail("Add All Failed " + l.size());  
         }catch(IndexOutOfBoundsException  success) {}  
     }  
   
     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){}  
     }  
   
     public void testget1() {  
         try {  
             LinkedList l = new LinkedList();  
             l.add(new Object());  
             l.get(-1);  
             fail("get Failed - l.get(-1)");  
         }catch(IndexOutOfBoundsException  success) {}  
     }  
   
     public void testget2() {  
         try {  
             LinkedList l = new LinkedList();  
             l.add(new Object());  
             l.get(5);  
             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){}  
     }  
   
     public void testset2() {  
         try {  
             LinkedList l = new LinkedList();  
             l.add(new Object());  
             l.set(5,new Object());  
             fail("set failed = l.set(5,..) l.size():" + l.size());  
         }catch(IndexOutOfBoundsException  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){}  
     }  
   
     public void add2(){  
         try {  
             LinkedList l = new LinkedList();  
             l.add(new Object());  
             l.add(5,new Object());  
             fail("Add Failed  l.add(f,...)");  
         }catch(IndexOutOfBoundsException  success) {}  
     }  
   
     public void testremove(){  
         try {  
             LinkedList l = new LinkedList();  
             l.add(new Object());  
             l.remove(-1);  
             fail("Remove Failed l.remove(-1); l.size():" + l.size());  
         }catch(IndexOutOfBoundsException  success){}  
     }  
   
     public void testremove1(){  
         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){}  
     }  
   
   
     public void testremove2(){  
         try{  
             LinkedList l = new LinkedList();  
             l.remove();  
             fail("LinkedList - Object remove() should throw a NoSuchElementException");  
         }catch(NoSuchElementException e){}  
     }  
   
     public void testlistIt1() {  
         try {  
             LinkedList l = new LinkedList();  
             l.add(new Object());  
             l.listIterator(5);  
             fail("l.listIterator(5) l.size():" + l.size());  
         }catch(IndexOutOfBoundsException  success){}  
     }  
   
     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){}  
     }  
   
     public void testlistIt3() {  
         try {  
             LinkedList l = new LinkedList();  
             l.add(new Object());  
             ListIterator a = l.listIterator(0);  
             l.removeFirst();  
             a.next();  
             fail("l.listIterator(-1) l.size():" + l.size());  
         }catch(ConcurrentModificationException success){}  
     }  
   
     public void testToArray_BadArg() {  
         try {  
             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){}  
     }  
   
     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){}  
448      }      }
449    
450  }  }

Legend:
Removed from v.1.1  
changed lines
  Added in v.1.5

Doug Lea
ViewVC Help
Powered by ViewVC 1.0.8