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

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

Parent Directory Parent Directory | Revision Log Revision Log


Revision 1.4 - (view) (download)

1 : dl 1.1 /*
2 :     * Written by members of JCP JSR-166 Expert Group and released to the
3 :     * public domain. Use, modify, and redistribute this code in any way
4 :     * without acknowledgement. Other contributors include Andrew Wright,
5 :     * Jeffrey Hayes, Pat Fischer, Mike Judd.
6 :     */
7 :    
8 :     import junit.framework.*;
9 :     import java.util.*;
10 :     import java.util.concurrent.*;
11 :    
12 : dl 1.3 public class LinkedListTest extends JSR166TestCase {
13 : dl 1.1 public static void main(String[] args) {
14 :     junit.textui.TestRunner.run (suite());
15 :     }
16 :    
17 :     public static Test suite() {
18 :     return new TestSuite(LinkedListTest.class);
19 :     }
20 :    
21 :     /**
22 :     * Create a queue of given size containing consecutive
23 :     * Integers 0 ... n.
24 :     */
25 : dl 1.3 private LinkedList populatedQueue(int n) {
26 : dl 1.1 LinkedList q = new LinkedList();
27 :     assertTrue(q.isEmpty());
28 :     for(int i = 0; i < n; ++i)
29 :     assertTrue(q.offer(new Integer(i)));
30 :     assertFalse(q.isEmpty());
31 :     assertEquals(n, q.size());
32 :     return q;
33 :     }
34 :    
35 : dl 1.4 /**
36 :     *
37 :     */
38 :     public void testConstructor1() {
39 : dl 1.1 assertEquals(0, new LinkedList().size());
40 :     }
41 :    
42 : dl 1.4 /**
43 :     *
44 :     */
45 : dl 1.1 public void testConstructor3() {
46 :     try {
47 :     LinkedList q = new LinkedList((Collection)null);
48 : dl 1.4 shouldThrow();
49 : dl 1.1 }
50 :     catch (NullPointerException success) {}
51 :     }
52 :    
53 : dl 1.4 /**
54 :     *
55 :     */
56 :     public void testConstructor6() {
57 : dl 1.1 try {
58 : dl 1.3 Integer[] ints = new Integer[SIZE];
59 :     for (int i = 0; i < SIZE; ++i)
60 : dl 1.1 ints[i] = new Integer(i);
61 :     LinkedList q = new LinkedList(Arrays.asList(ints));
62 : dl 1.3 for (int i = 0; i < SIZE; ++i)
63 : dl 1.1 assertEquals(ints[i], q.poll());
64 :     }
65 :     finally {}
66 :     }
67 :    
68 : dl 1.4 /**
69 :     *
70 :     */
71 : dl 1.1 public void testEmpty() {
72 :     LinkedList q = new LinkedList();
73 :     assertTrue(q.isEmpty());
74 :     q.add(new Integer(1));
75 :     assertFalse(q.isEmpty());
76 :     q.add(new Integer(2));
77 :     q.remove();
78 :     q.remove();
79 :     assertTrue(q.isEmpty());
80 :     }
81 :    
82 : dl 1.4 /**
83 :     *
84 :     */
85 : dl 1.1 public void testSize() {
86 : dl 1.3 LinkedList q = populatedQueue(SIZE);
87 :     for (int i = 0; i < SIZE; ++i) {
88 :     assertEquals(SIZE-i, q.size());
89 : dl 1.1 q.remove();
90 :     }
91 : dl 1.3 for (int i = 0; i < SIZE; ++i) {
92 : dl 1.1 assertEquals(i, q.size());
93 :     q.add(new Integer(i));
94 :     }
95 :     }
96 :    
97 : dl 1.4 /**
98 :     *
99 :     */
100 :     public void testOfferNull() {
101 : dl 1.1 try {
102 :     LinkedList q = new LinkedList();
103 :     q.offer(null);
104 :     } catch (NullPointerException ie) {
105 : dl 1.4 unexpectedException();
106 : dl 1.1 }
107 :     }
108 :    
109 : dl 1.4 /**
110 :     *
111 :     */
112 : dl 1.1 public void testOffer() {
113 :     LinkedList q = new LinkedList();
114 :     assertTrue(q.offer(new Integer(0)));
115 :     assertTrue(q.offer(new Integer(1)));
116 :     }
117 :    
118 : dl 1.4 /**
119 :     *
120 :     */
121 :     public void testAdd() {
122 : dl 1.1 LinkedList q = new LinkedList();
123 : dl 1.3 for (int i = 0; i < SIZE; ++i) {
124 : dl 1.1 assertEquals(i, q.size());
125 :     assertTrue(q.add(new Integer(i)));
126 :     }
127 :     }
128 :    
129 : dl 1.4 /**
130 :     *
131 :     */
132 :     public void testAddAll1() {
133 : dl 1.1 try {
134 :     LinkedList q = new LinkedList();
135 :     q.addAll(null);
136 : dl 1.4 shouldThrow();
137 : dl 1.1 }
138 :     catch (NullPointerException success) {}
139 :     }
140 :    
141 : dl 1.4 /**
142 :     *
143 :     */
144 :     public void testAddAll5() {
145 : dl 1.1 try {
146 :     Integer[] empty = new Integer[0];
147 : dl 1.3 Integer[] ints = new Integer[SIZE];
148 :     for (int i = 0; i < SIZE; ++i)
149 : dl 1.1 ints[i] = new Integer(i);
150 :     LinkedList q = new LinkedList();
151 :     assertFalse(q.addAll(Arrays.asList(empty)));
152 :     assertTrue(q.addAll(Arrays.asList(ints)));
153 : dl 1.3 for (int i = 0; i < SIZE; ++i)
154 : dl 1.1 assertEquals(ints[i], q.poll());
155 :     }
156 :     finally {}
157 :     }
158 :    
159 : dl 1.4 /**
160 :     *
161 :     */
162 :     public void testPoll() {
163 : dl 1.3 LinkedList q = populatedQueue(SIZE);
164 :     for (int i = 0; i < SIZE; ++i) {
165 : dl 1.1 assertEquals(i, ((Integer)q.poll()).intValue());
166 :     }
167 :     assertNull(q.poll());
168 :     }
169 :    
170 : dl 1.4 /**
171 :     *
172 :     */
173 :     public void testPeek() {
174 : dl 1.3 LinkedList q = populatedQueue(SIZE);
175 :     for (int i = 0; i < SIZE; ++i) {
176 : dl 1.1 assertEquals(i, ((Integer)q.peek()).intValue());
177 :     q.poll();
178 :     assertTrue(q.peek() == null ||
179 :     i != ((Integer)q.peek()).intValue());
180 :     }
181 :     assertNull(q.peek());
182 :     }
183 :    
184 : dl 1.4 /**
185 :     *
186 :     */
187 :     public void testElement() {
188 : dl 1.3 LinkedList q = populatedQueue(SIZE);
189 :     for (int i = 0; i < SIZE; ++i) {
190 : dl 1.1 assertEquals(i, ((Integer)q.element()).intValue());
191 :     q.poll();
192 :     }
193 :     try {
194 :     q.element();
195 : dl 1.4 shouldThrow();
196 : dl 1.1 }
197 :     catch (NoSuchElementException success) {}
198 :     }
199 :    
200 : dl 1.4 /**
201 :     *
202 :     */
203 :     public void testRemove() {
204 : dl 1.3 LinkedList q = populatedQueue(SIZE);
205 :     for (int i = 0; i < SIZE; ++i) {
206 : dl 1.1 assertEquals(i, ((Integer)q.remove()).intValue());
207 :     }
208 :     try {
209 :     q.remove();
210 : dl 1.4 shouldThrow();
211 : dl 1.1 } catch (NoSuchElementException success){
212 :     }
213 :     }
214 :    
215 : dl 1.4 /**
216 :     *
217 :     */
218 :     public void testRemoveElement() {
219 : dl 1.3 LinkedList q = populatedQueue(SIZE);
220 :     for (int i = 1; i < SIZE; i+=2) {
221 : dl 1.1 assertTrue(q.remove(new Integer(i)));
222 :     }
223 : dl 1.3 for (int i = 0; i < SIZE; i+=2) {
224 : dl 1.1 assertTrue(q.remove(new Integer(i)));
225 :     assertFalse(q.remove(new Integer(i+1)));
226 :     }
227 : dl 1.2 assertTrue(q.isEmpty());
228 : dl 1.1 }
229 :    
230 : dl 1.4 /**
231 :     *
232 :     */
233 :     public void testContains() {
234 : dl 1.3 LinkedList q = populatedQueue(SIZE);
235 :     for (int i = 0; i < SIZE; ++i) {
236 : dl 1.1 assertTrue(q.contains(new Integer(i)));
237 :     q.poll();
238 :     assertFalse(q.contains(new Integer(i)));
239 :     }
240 :     }
241 :    
242 : dl 1.4 /**
243 :     *
244 :     */
245 :     public void testClear() {
246 : dl 1.3 LinkedList q = populatedQueue(SIZE);
247 : dl 1.1 q.clear();
248 :     assertTrue(q.isEmpty());
249 :     assertEquals(0, q.size());
250 :     q.add(new Integer(1));
251 :     assertFalse(q.isEmpty());
252 :     q.clear();
253 :     assertTrue(q.isEmpty());
254 :     }
255 :    
256 : dl 1.4 /**
257 :     *
258 :     */
259 :     public void testContainsAll() {
260 : dl 1.3 LinkedList q = populatedQueue(SIZE);
261 : dl 1.1 LinkedList p = new LinkedList();
262 : dl 1.3 for (int i = 0; i < SIZE; ++i) {
263 : dl 1.1 assertTrue(q.containsAll(p));
264 :     assertFalse(p.containsAll(q));
265 :     p.add(new Integer(i));
266 :     }
267 :     assertTrue(p.containsAll(q));
268 :     }
269 :    
270 : dl 1.4 /**
271 :     *
272 :     */
273 :     public void testRetainAll() {
274 : dl 1.3 LinkedList q = populatedQueue(SIZE);
275 :     LinkedList p = populatedQueue(SIZE);
276 :     for (int i = 0; i < SIZE; ++i) {
277 : dl 1.1 boolean changed = q.retainAll(p);
278 :     if (i == 0)
279 :     assertFalse(changed);
280 :     else
281 :     assertTrue(changed);
282 :    
283 :     assertTrue(q.containsAll(p));
284 : dl 1.3 assertEquals(SIZE-i, q.size());
285 : dl 1.1 p.remove();
286 :     }
287 :     }
288 :    
289 : dl 1.4 /**
290 :     *
291 :     */
292 :     public void testRemoveAll() {
293 : dl 1.3 for (int i = 1; i < SIZE; ++i) {
294 :     LinkedList q = populatedQueue(SIZE);
295 :     LinkedList p = populatedQueue(i);
296 : dl 1.1 assertTrue(q.removeAll(p));
297 : dl 1.3 assertEquals(SIZE-i, q.size());
298 : dl 1.1 for (int j = 0; j < i; ++j) {
299 :     Integer I = (Integer)(p.remove());
300 :     assertFalse(q.contains(I));
301 :     }
302 :     }
303 :     }
304 :    
305 : dl 1.4 /**
306 :     *
307 :     */
308 :     public void testToArray() {
309 : dl 1.3 LinkedList q = populatedQueue(SIZE);
310 : dl 1.1 Object[] o = q.toArray();
311 :     Arrays.sort(o);
312 :     for(int i = 0; i < o.length; i++)
313 :     assertEquals(o[i], q.poll());
314 :     }
315 :    
316 : dl 1.4 /**
317 :     *
318 :     */
319 :     public void testToArray2() {
320 : dl 1.3 LinkedList q = populatedQueue(SIZE);
321 :     Integer[] ints = new Integer[SIZE];
322 : dl 1.1 ints = (Integer[])q.toArray(ints);
323 :     Arrays.sort(ints);
324 :     for(int i = 0; i < ints.length; i++)
325 :     assertEquals(ints[i], q.poll());
326 :     }
327 :    
328 : dl 1.4 /**
329 :     *
330 :     */
331 :     public void testIterator() {
332 : dl 1.3 LinkedList q = populatedQueue(SIZE);
333 : dl 1.1 int i = 0;
334 :     Iterator it = q.iterator();
335 :     while(it.hasNext()) {
336 :     assertTrue(q.contains(it.next()));
337 :     ++i;
338 :     }
339 : dl 1.3 assertEquals(i, SIZE);
340 : dl 1.1 }
341 :    
342 : dl 1.4 /**
343 :     *
344 :     */
345 : dl 1.1 public void testIteratorOrdering() {
346 :    
347 :     final LinkedList q = new LinkedList();
348 :    
349 :     q.add(new Integer(1));
350 :     q.add(new Integer(2));
351 :     q.add(new Integer(3));
352 :    
353 :     int k = 0;
354 :     for (Iterator it = q.iterator(); it.hasNext();) {
355 :     int i = ((Integer)(it.next())).intValue();
356 : dl 1.4 assertEquals(++k, i);
357 : dl 1.1 }
358 :    
359 : dl 1.4 assertEquals(3, k);
360 : dl 1.1 }
361 :    
362 : dl 1.4 /**
363 :     *
364 :     */
365 : dl 1.1 public void testIteratorRemove () {
366 :     final LinkedList q = new LinkedList();
367 :    
368 :     q.add(new Integer(1));
369 :     q.add(new Integer(2));
370 :     q.add(new Integer(3));
371 :    
372 :     Iterator it = q.iterator();
373 :     it.next();
374 :     it.remove();
375 :    
376 :     it = q.iterator();
377 :     assertEquals(it.next(), new Integer(2));
378 :     assertEquals(it.next(), new Integer(3));
379 :     assertFalse(it.hasNext());
380 :     }
381 :    
382 :    
383 : dl 1.4 /**
384 :     *
385 :     */
386 :     public void testToString() {
387 : dl 1.3 LinkedList q = populatedQueue(SIZE);
388 : dl 1.1 String s = q.toString();
389 : dl 1.3 for (int i = 0; i < SIZE; ++i) {
390 : dl 1.1 assertTrue(s.indexOf(String.valueOf(i)) >= 0);
391 :     }
392 :     }
393 :    
394 : dl 1.4 /**
395 :     *
396 :     */
397 :     public void testAddFirst() {
398 : dl 1.3 LinkedList q = populatedQueue(3);
399 : dl 1.1 q.addFirst(new Integer(4));
400 :     assertEquals(new Integer(4),q.get(0));
401 :     }
402 :    
403 : dl 1.4 /**
404 :     *
405 :     */
406 :     public void testAddLast() {
407 : dl 1.3 LinkedList q = populatedQueue(3);
408 : dl 1.1 q.addLast(new Integer(3));
409 :     assertEquals(new Integer(3),q.get(3));
410 :     }
411 :    
412 : dl 1.4 /**
413 :     *
414 :     */
415 : dl 1.1 public void testGetFirst() {
416 : dl 1.3 LinkedList q = populatedQueue(3);
417 : dl 1.1 assertEquals(new Integer(0),q.getFirst());
418 :     }
419 :    
420 : dl 1.4 /**
421 :     *
422 :     */
423 : dl 1.1 public void testGetLast() {
424 : dl 1.3 LinkedList q = populatedQueue(3);
425 : dl 1.1 assertEquals(new Integer(2),q.getLast());
426 :     }
427 :    
428 : dl 1.4 /**
429 :     *
430 :     */
431 :     public void testIndexOf() {
432 : dl 1.3 LinkedList q = populatedQueue(3);
433 : dl 1.1 assertEquals(0,q.indexOf(new Integer(0)));
434 :     assertEquals(1,q.indexOf(new Integer(1)));
435 :     assertEquals(2,q.indexOf(new Integer(2)));
436 :     assertEquals(-1, q.indexOf("not there"));
437 :     }
438 :    
439 : dl 1.4 /**
440 :     *
441 :     */
442 :     public void testLastIndexOf() {
443 : dl 1.3 LinkedList q = populatedQueue(3);
444 : dl 1.1 q.add(new Integer(2));
445 :     assertEquals(3,q.lastIndexOf(new Integer(2)));
446 :     assertEquals(-1, q.lastIndexOf("not there"));
447 :     }
448 :    
449 : dl 1.4 /**
450 :     *
451 :     */
452 :     public void testSet() {
453 : dl 1.3 LinkedList q = populatedQueue(3);
454 : dl 1.1 q.set(0,(new Integer(1)));
455 :     assertFalse(q.contains(new Integer(0)));
456 :     assertEquals(new Integer(1), q.get(0));
457 :     }
458 :    
459 :    
460 : dl 1.4 /**
461 :     *
462 :     */
463 :     public void testGetFirst_NoSuchElementException() {
464 : dl 1.1 try {
465 :     LinkedList l = new LinkedList();
466 :     l.getFirst();
467 : dl 1.4 shouldThrow();
468 : dl 1.1 }
469 :     catch(NoSuchElementException success) {}
470 :     }
471 :    
472 : dl 1.4 /**
473 :     *
474 :     */
475 : dl 1.1 public void testRemoveFirst() {
476 :     try {
477 :     LinkedList l = new LinkedList();
478 :     l.removeFirst();
479 : dl 1.4 shouldThrow();
480 : dl 1.1 }
481 :     catch(NoSuchElementException success) {}
482 :     }
483 :    
484 : dl 1.4 /**
485 :     *
486 :     */
487 : dl 1.1 public void testRemoveLast() {
488 :     try {
489 :     LinkedList l = new LinkedList();
490 :     l.removeLast();
491 : dl 1.4 shouldThrow();
492 : dl 1.1 }
493 :     catch(NoSuchElementException success) {}
494 :     }
495 :    
496 : dl 1.4 /**
497 :     *
498 :     */
499 :     public void testGetLast_NoSuchElementException() {
500 : dl 1.1 try {
501 :     LinkedList l = new LinkedList();
502 :     l.getLast();
503 : dl 1.4 shouldThrow();
504 : dl 1.1 }
505 :     catch(NoSuchElementException success) {}
506 :     }
507 :    
508 :    
509 : dl 1.4 /**
510 :     *
511 :     */
512 :     public void testAddAll_NullPointerException() {
513 : dl 1.1 try {
514 :     LinkedList l = new LinkedList();
515 :     l.addAll((Collection)null);
516 : dl 1.4 shouldThrow();
517 : dl 1.1 }
518 :     catch(NullPointerException success){}
519 :     }
520 :    
521 :    
522 : dl 1.4 /**
523 :     *
524 :     */
525 : dl 1.1 public void testAddAll1_OutOfBounds() {
526 :     try {
527 :     LinkedList l = new LinkedList();
528 :     l.addAll(4,new LinkedList());
529 : dl 1.4 shouldThrow();
530 : dl 1.1 }
531 :     catch(IndexOutOfBoundsException success) {}
532 :     }
533 :    
534 :    
535 : dl 1.4 /**
536 :     *
537 :     */
538 : dl 1.1 public void testAddAll2_IndexOutOfBoundsException() {
539 :     try {
540 :     LinkedList l = new LinkedList();
541 :     l.add(new Object());
542 :     LinkedList m = new LinkedList();
543 :     m.add(new Object());
544 :     l.addAll(4,m);
545 : dl 1.4 shouldThrow();
546 :     } catch(IndexOutOfBoundsException success) {}
547 : dl 1.1 }
548 :    
549 : dl 1.4 /**
550 :     *
551 :     */
552 : dl 1.1 public void testAddAll4_BadIndex() {
553 :     try {
554 :     LinkedList l = new LinkedList();
555 :     l.add(new Object());
556 :     LinkedList m = new LinkedList();
557 :     m.add(new Object());
558 :     l.addAll(-1,m);
559 : dl 1.4 shouldThrow();
560 :     } catch(IndexOutOfBoundsException success){}
561 : dl 1.1 }
562 :    
563 : dl 1.4 /**
564 :     *
565 :     */
566 : dl 1.1 public void testget1() {
567 :     try {
568 :     LinkedList l = new LinkedList();
569 :     l.add(new Object());
570 :     l.get(-1);
571 : dl 1.4 shouldThrow();
572 :     } catch(IndexOutOfBoundsException success) {}
573 : dl 1.1 }
574 :    
575 : dl 1.4 /**
576 :     *
577 :     */
578 : dl 1.1 public void testget2() {
579 :     try {
580 :     LinkedList l = new LinkedList();
581 :     l.add(new Object());
582 :     l.get(5);
583 : dl 1.4 shouldThrow();
584 :     } catch(IndexOutOfBoundsException success){}
585 : dl 1.1 }
586 :    
587 : dl 1.4 /**
588 :     *
589 :     */
590 : dl 1.1 public void testset1() {
591 :     try {
592 :     LinkedList l = new LinkedList();
593 :     l.add(new Object());
594 :     l.set(-1,new Object());
595 : dl 1.4 shouldThrow();
596 :     } catch(IndexOutOfBoundsException success){}
597 : dl 1.1 }
598 :    
599 : dl 1.4 /**
600 :     *
601 :     */
602 : dl 1.1 public void testset2() {
603 :     try {
604 :     LinkedList l = new LinkedList();
605 :     l.add(new Object());
606 :     l.set(5,new Object());
607 : dl 1.4 shouldThrow();
608 :     } catch(IndexOutOfBoundsException success){}
609 : dl 1.1 }
610 :    
611 : dl 1.4 /**
612 :     *
613 :     */
614 : dl 1.1 public void testadd1() {
615 :     try {
616 :     LinkedList l = new LinkedList();
617 :     l.add(new Object());
618 :     l.add(-1,new Object());
619 : dl 1.4 shouldThrow();
620 :     } catch(IndexOutOfBoundsException success){}
621 : dl 1.1 }
622 :    
623 : dl 1.4 public void add2() {
624 : dl 1.1 try {
625 :     LinkedList l = new LinkedList();
626 :     l.add(new Object());
627 :     l.add(5,new Object());
628 : dl 1.4 shouldThrow();
629 :     } catch(IndexOutOfBoundsException success) {}
630 : dl 1.1 }
631 :    
632 : dl 1.4 /**
633 :     *
634 :     */
635 :     public void testremove() {
636 : dl 1.1 try {
637 :     LinkedList l = new LinkedList();
638 :     l.add(new Object());
639 :     l.remove(-1);
640 : dl 1.4 shouldThrow();
641 :     } catch(IndexOutOfBoundsException success){}
642 : dl 1.1 }
643 :    
644 : dl 1.4 /**
645 :     *
646 :     */
647 :     public void testremove1() {
648 : dl 1.1 try {
649 :     LinkedList l = new LinkedList();
650 :     l.add(new Object());
651 :     l.remove(5);
652 : dl 1.4 shouldThrow();
653 :     } catch(IndexOutOfBoundsException success){}
654 : dl 1.1 }
655 :    
656 :    
657 : dl 1.4 /**
658 :     *
659 :     */
660 :     public void testremove2() {
661 :     try {
662 : dl 1.1 LinkedList l = new LinkedList();
663 :     l.remove();
664 : dl 1.4 shouldThrow();
665 :     } catch(NoSuchElementException e){}
666 : dl 1.1 }
667 :    
668 : dl 1.4 /**
669 :     *
670 :     */
671 : dl 1.1 public void testlistIt1() {
672 :     try {
673 :     LinkedList l = new LinkedList();
674 :     l.add(new Object());
675 :     l.listIterator(5);
676 : dl 1.4 shouldThrow();
677 :     } catch(IndexOutOfBoundsException success){}
678 : dl 1.1 }
679 :    
680 : dl 1.4 /**
681 :     *
682 :     */
683 : dl 1.1 public void testlistIt2() {
684 :     try {
685 :     LinkedList l = new LinkedList();
686 :     l.add(new Object());
687 :     l.listIterator(-1);
688 : dl 1.4 shouldThrow();
689 :     } catch(IndexOutOfBoundsException success){}
690 : dl 1.1 }
691 :    
692 : dl 1.4 /**
693 :     *
694 :     */
695 : dl 1.1 public void testlistIt3() {
696 :     try {
697 :     LinkedList l = new LinkedList();
698 :     l.add(new Object());
699 :     ListIterator a = l.listIterator(0);
700 :     l.removeFirst();
701 :     a.next();
702 : dl 1.4 shouldThrow();
703 :     } catch(ConcurrentModificationException success){}
704 : dl 1.1 }
705 :    
706 : dl 1.4 /**
707 :     *
708 :     */
709 : dl 1.1 public void testToArray_BadArg() {
710 :     try {
711 :     LinkedList l = new LinkedList();
712 :     l.add(new Object());
713 :     Object o[] = l.toArray(null);
714 : dl 1.4 shouldThrow();
715 :     } catch(NullPointerException success){}
716 : dl 1.1 }
717 :    
718 : dl 1.4 /**
719 :     *
720 :     */
721 : dl 1.1 public void testToArray1_BadArg() {
722 :     try {
723 :     LinkedList l = new LinkedList();
724 :     l.add(new Integer(5));
725 :     Object o[] = l.toArray(new String[10] );
726 : dl 1.4 shouldThrow();
727 :     } catch(ArrayStoreException success){}
728 : dl 1.1 }
729 :    
730 :     }

Doug Lea
ViewVC Help
Powered by ViewVC 1.0.8