[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.1 - (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 :     public class LinkedListTest extends TestCase {
13 :    
14 :     private static final int N = 10;
15 :     private static final long SHORT_DELAY_MS = 100;
16 :     private static final long MEDIUM_DELAY_MS = 1000;
17 :     private static final long LONG_DELAY_MS = 10000;
18 :    
19 :     public static void main(String[] args) {
20 :     junit.textui.TestRunner.run (suite());
21 :     }
22 :    
23 :     public static Test suite() {
24 :     return new TestSuite(LinkedListTest.class);
25 :     }
26 :    
27 :     /**
28 :     * Create a queue of given size containing consecutive
29 :     * Integers 0 ... n.
30 :     */
31 :     private LinkedList fullQueue(int n) {
32 :     LinkedList q = new LinkedList();
33 :     assertTrue(q.isEmpty());
34 :     for(int i = 0; i < n; ++i)
35 :     assertTrue(q.offer(new Integer(i)));
36 :     assertFalse(q.isEmpty());
37 :     assertEquals(n, q.size());
38 :     return q;
39 :     }
40 :    
41 :     public void testConstructor1(){
42 :     assertEquals(0, new LinkedList().size());
43 :     }
44 :    
45 :     public void testConstructor3() {
46 :     try {
47 :     LinkedList q = new LinkedList((Collection)null);
48 :     fail("Cannot make from null collection");
49 :     }
50 :     catch (NullPointerException success) {}
51 :     }
52 :    
53 :     public void testConstructor6(){
54 :     try {
55 :     Integer[] ints = new Integer[N];
56 :     for (int i = 0; i < N; ++i)
57 :     ints[i] = new Integer(i);
58 :     LinkedList q = new LinkedList(Arrays.asList(ints));
59 :     for (int i = 0; i < N; ++i)
60 :     assertEquals(ints[i], q.poll());
61 :     }
62 :     finally {}
63 :     }
64 :    
65 :     public void testEmpty() {
66 :     LinkedList q = new LinkedList();
67 :     assertTrue(q.isEmpty());
68 :     q.add(new Integer(1));
69 :     assertFalse(q.isEmpty());
70 :     q.add(new Integer(2));
71 :     q.remove();
72 :     q.remove();
73 :     assertTrue(q.isEmpty());
74 :     }
75 :    
76 :     public void testSize() {
77 :     LinkedList q = fullQueue(N);
78 :     for (int i = 0; i < N; ++i) {
79 :     assertEquals(N-i, q.size());
80 :     q.remove();
81 :     }
82 :     for (int i = 0; i < N; ++i) {
83 :     assertEquals(i, q.size());
84 :     q.add(new Integer(i));
85 :     }
86 :     }
87 :    
88 :     public void testOfferNull(){
89 :     try {
90 :     LinkedList q = new LinkedList();
91 :     q.offer(null);
92 :     } catch (NullPointerException ie) {
93 :     fail("should not throw NPE");
94 :     }
95 :     }
96 :    
97 :     public void testOffer() {
98 :     LinkedList q = new LinkedList();
99 :     assertTrue(q.offer(new Integer(0)));
100 :     assertTrue(q.offer(new Integer(1)));
101 :     }
102 :    
103 :     public void testAdd(){
104 :     LinkedList q = new LinkedList();
105 :     for (int i = 0; i < N; ++i) {
106 :     assertEquals(i, q.size());
107 :     assertTrue(q.add(new Integer(i)));
108 :     }
109 :     }
110 :    
111 :     public void testAddAll1(){
112 :     try {
113 :     LinkedList q = new LinkedList();
114 :     q.addAll(null);
115 :     fail("Cannot add null collection");
116 :     }
117 :     catch (NullPointerException success) {}
118 :     }
119 :    
120 :     public void testAddAll5(){
121 :     try {
122 :     Integer[] empty = new Integer[0];
123 :     Integer[] ints = new Integer[N];
124 :     for (int i = 0; i < N; ++i)
125 :     ints[i] = new Integer(i);
126 :     LinkedList q = new LinkedList();
127 :     assertFalse(q.addAll(Arrays.asList(empty)));
128 :     assertTrue(q.addAll(Arrays.asList(ints)));
129 :     for (int i = 0; i < N; ++i)
130 :     assertEquals(ints[i], q.poll());
131 :     }
132 :     finally {}
133 :     }
134 :    
135 :     public void testPoll(){
136 :     LinkedList q = fullQueue(N);
137 :     for (int i = 0; i < N; ++i) {
138 :     assertEquals(i, ((Integer)q.poll()).intValue());
139 :     }
140 :     assertNull(q.poll());
141 :     }
142 :    
143 :     public void testPeek(){
144 :     LinkedList q = fullQueue(N);
145 :     for (int i = 0; i < N; ++i) {
146 :     assertEquals(i, ((Integer)q.peek()).intValue());
147 :     q.poll();
148 :     assertTrue(q.peek() == null ||
149 :     i != ((Integer)q.peek()).intValue());
150 :     }
151 :     assertNull(q.peek());
152 :     }
153 :    
154 :     public void testElement(){
155 :     LinkedList q = fullQueue(N);
156 :     for (int i = 0; i < N; ++i) {
157 :     assertEquals(i, ((Integer)q.element()).intValue());
158 :     q.poll();
159 :     }
160 :     try {
161 :     q.element();
162 :     fail("no such element");
163 :     }
164 :     catch (NoSuchElementException success) {}
165 :     }
166 :    
167 :     public void testRemove(){
168 :     LinkedList q = fullQueue(N);
169 :     for (int i = 0; i < N; ++i) {
170 :     assertEquals(i, ((Integer)q.remove()).intValue());
171 :     }
172 :     try {
173 :     q.remove();
174 :     fail("remove should throw");
175 :     } catch (NoSuchElementException success){
176 :     }
177 :     }
178 :    
179 :     public void testRemoveElement(){
180 :     LinkedList q = fullQueue(N);
181 :     for (int i = 1; i < N; i+=2) {
182 :     assertTrue(q.remove(new Integer(i)));
183 :     }
184 :     for (int i = 0; i < N; i+=2) {
185 :     assertTrue(q.remove(new Integer(i)));
186 :     assertFalse(q.remove(new Integer(i+1)));
187 :     }
188 :     assert(q.isEmpty());
189 :     }
190 :    
191 :     public void testContains(){
192 :     LinkedList q = fullQueue(N);
193 :     for (int i = 0; i < N; ++i) {
194 :     assertTrue(q.contains(new Integer(i)));
195 :     q.poll();
196 :     assertFalse(q.contains(new Integer(i)));
197 :     }
198 :     }
199 :    
200 :     public void testClear(){
201 :     LinkedList q = fullQueue(N);
202 :     q.clear();
203 :     assertTrue(q.isEmpty());
204 :     assertEquals(0, q.size());
205 :     q.add(new Integer(1));
206 :     assertFalse(q.isEmpty());
207 :     q.clear();
208 :     assertTrue(q.isEmpty());
209 :     }
210 :    
211 :     public void testContainsAll(){
212 :     LinkedList q = fullQueue(N);
213 :     LinkedList p = new LinkedList();
214 :     for (int i = 0; i < N; ++i) {
215 :     assertTrue(q.containsAll(p));
216 :     assertFalse(p.containsAll(q));
217 :     p.add(new Integer(i));
218 :     }
219 :     assertTrue(p.containsAll(q));
220 :     }
221 :    
222 :     public void testRetainAll(){
223 :     LinkedList q = fullQueue(N);
224 :     LinkedList p = fullQueue(N);
225 :     for (int i = 0; i < N; ++i) {
226 :     boolean changed = q.retainAll(p);
227 :     if (i == 0)
228 :     assertFalse(changed);
229 :     else
230 :     assertTrue(changed);
231 :    
232 :     assertTrue(q.containsAll(p));
233 :     assertEquals(N-i, q.size());
234 :     p.remove();
235 :     }
236 :     }
237 :    
238 :     public void testRemoveAll(){
239 :     for (int i = 1; i < N; ++i) {
240 :     LinkedList q = fullQueue(N);
241 :     LinkedList p = fullQueue(i);
242 :     assertTrue(q.removeAll(p));
243 :     assertEquals(N-i, q.size());
244 :     for (int j = 0; j < i; ++j) {
245 :     Integer I = (Integer)(p.remove());
246 :     assertFalse(q.contains(I));
247 :     }
248 :     }
249 :     }
250 :    
251 :     public void testToArray(){
252 :     LinkedList q = fullQueue(N);
253 :     Object[] o = q.toArray();
254 :     Arrays.sort(o);
255 :     for(int i = 0; i < o.length; i++)
256 :     assertEquals(o[i], q.poll());
257 :     }
258 :    
259 :     public void testToArray2(){
260 :     LinkedList q = fullQueue(N);
261 :     Integer[] ints = new Integer[N];
262 :     ints = (Integer[])q.toArray(ints);
263 :     Arrays.sort(ints);
264 :     for(int i = 0; i < ints.length; i++)
265 :     assertEquals(ints[i], q.poll());
266 :     }
267 :    
268 :     public void testIterator(){
269 :     LinkedList q = fullQueue(N);
270 :     int i = 0;
271 :     Iterator it = q.iterator();
272 :     while(it.hasNext()) {
273 :     assertTrue(q.contains(it.next()));
274 :     ++i;
275 :     }
276 :     assertEquals(i, N);
277 :     }
278 :    
279 :     public void testIteratorOrdering() {
280 :    
281 :     final LinkedList q = new LinkedList();
282 :    
283 :     q.add(new Integer(1));
284 :     q.add(new Integer(2));
285 :     q.add(new Integer(3));
286 :    
287 :     int k = 0;
288 :     for (Iterator it = q.iterator(); it.hasNext();) {
289 :     int i = ((Integer)(it.next())).intValue();
290 :     assertEquals("items should come out in order", ++k, i);
291 :     }
292 :    
293 :     assertEquals("should go through 3 elements", 3, k);
294 :     }
295 :    
296 :     public void testIteratorRemove () {
297 :     final LinkedList q = new LinkedList();
298 :    
299 :     q.add(new Integer(1));
300 :     q.add(new Integer(2));
301 :     q.add(new Integer(3));
302 :    
303 :     Iterator it = q.iterator();
304 :     it.next();
305 :     it.remove();
306 :    
307 :     it = q.iterator();
308 :     assertEquals(it.next(), new Integer(2));
309 :     assertEquals(it.next(), new Integer(3));
310 :     assertFalse(it.hasNext());
311 :     }
312 :    
313 :    
314 :     public void testToString(){
315 :     LinkedList q = fullQueue(N);
316 :     String s = q.toString();
317 :     for (int i = 0; i < N; ++i) {
318 :     assertTrue(s.indexOf(String.valueOf(i)) >= 0);
319 :     }
320 :     }
321 :    
322 :     public void testAddFirst(){
323 :     LinkedList q = fullQueue(3);
324 :     q.addFirst(new Integer(4));
325 :     assertEquals(new Integer(4),q.get(0));
326 :     }
327 :    
328 :     public void testAddLast(){
329 :     LinkedList q = fullQueue(3);
330 :     q.addLast(new Integer(3));
331 :     assertEquals(new Integer(3),q.get(3));
332 :     }
333 :    
334 :     public void testGetFirst() {
335 :     LinkedList q = fullQueue(3);
336 :     assertEquals(new Integer(0),q.getFirst());
337 :     }
338 :    
339 :     public void testGetLast() {
340 :     LinkedList q = fullQueue(3);
341 :     assertEquals(new Integer(2),q.getLast());
342 :     }
343 :    
344 :     public void testIndexOf(){
345 :     LinkedList q = fullQueue(3);
346 :     assertEquals(0,q.indexOf(new Integer(0)));
347 :     assertEquals(1,q.indexOf(new Integer(1)));
348 :     assertEquals(2,q.indexOf(new Integer(2)));
349 :     assertEquals(-1, q.indexOf("not there"));
350 :     }
351 :    
352 :     public void testLastIndexOf(){
353 :     LinkedList q = fullQueue(3);
354 :     q.add(new Integer(2));
355 :     assertEquals(3,q.lastIndexOf(new Integer(2)));
356 :     assertEquals(-1, q.lastIndexOf("not there"));
357 :     }
358 :    
359 :     public void testSet(){
360 :     LinkedList q = fullQueue(3);
361 :     q.set(0,(new Integer(1)));
362 :     assertFalse(q.contains(new Integer(0)));
363 :     assertEquals(new Integer(1), q.get(0));
364 :     }
365 :    
366 :    
367 :     public void testGetFirst_NoSuchElementException(){
368 :     try {
369 :     LinkedList l = new LinkedList();
370 :     l.getFirst();
371 :     fail("First Element");
372 :     }
373 :     catch(NoSuchElementException success) {}
374 :     }
375 :    
376 :     public void testRemoveFirst() {
377 :     try {
378 :     LinkedList l = new LinkedList();
379 :     l.removeFirst();
380 :     fail("R: First Element");
381 :     }
382 :     catch(NoSuchElementException success) {}
383 :     }
384 :    
385 :     public void testRemoveLast() {
386 :     try {
387 :     LinkedList l = new LinkedList();
388 :     l.removeLast();
389 :     fail("R: Last Element");
390 :     }
391 :     catch(NoSuchElementException success) {}
392 :     }
393 :    
394 :     public void testGetLast_NoSuchElementException(){
395 :     try {
396 :     LinkedList l = new LinkedList();
397 :     l.getLast();
398 :     fail("Last Element");
399 :     }
400 :     catch(NoSuchElementException success) {}
401 :     }
402 :    
403 :    
404 :     public void testAddAll_NullPointerException(){
405 :     try {
406 :     LinkedList l = new LinkedList();
407 :     l.addAll((Collection)null);
408 :     fail("Add All Failed");
409 :     }
410 :     catch(NullPointerException success){}
411 :     }
412 :    
413 :    
414 :     public void testAddAll1_OutOfBounds() {
415 :     try {
416 :     LinkedList l = new LinkedList();
417 :     l.addAll(4,new LinkedList());
418 :     fail("boolean addAll(int, Collection) should throw IndexOutOfBoundsException");
419 :     }
420 :     catch(IndexOutOfBoundsException success) {}
421 :     }
422 :    
423 :    
424 :     public void testAddAll2_IndexOutOfBoundsException() {
425 :     try {
426 :     LinkedList l = new LinkedList();
427 :     l.add(new Object());
428 :     LinkedList m = new LinkedList();
429 :     m.add(new Object());
430 :     l.addAll(4,m);
431 :     fail("Add All Failed " + l.size());
432 :     }catch(IndexOutOfBoundsException success) {}
433 :     }
434 :    
435 :     public void testAddAll4_BadIndex() {
436 :     try {
437 :     LinkedList l = new LinkedList();
438 :     l.add(new Object());
439 :     LinkedList m = new LinkedList();
440 :     m.add(new Object());
441 :     l.addAll(-1,m);
442 :     fail("Add All Failed " + l.size());
443 :     }catch(IndexOutOfBoundsException success){}
444 :     }
445 :    
446 :     public void testget1() {
447 :     try {
448 :     LinkedList l = new LinkedList();
449 :     l.add(new Object());
450 :     l.get(-1);
451 :     fail("get Failed - l.get(-1)");
452 :     }catch(IndexOutOfBoundsException success) {}
453 :     }
454 :    
455 :     public void testget2() {
456 :     try {
457 :     LinkedList l = new LinkedList();
458 :     l.add(new Object());
459 :     l.get(5);
460 :     fail("get Failed - l.get(5) l.size(): " + l.size());
461 :     }catch(IndexOutOfBoundsException success){}
462 :     }
463 :    
464 :     public void testset1() {
465 :     try {
466 :     LinkedList l = new LinkedList();
467 :     l.add(new Object());
468 :     l.set(-1,new Object());
469 :     fail("set failed - l.set(-1,...)" + l.size());
470 :     }catch(IndexOutOfBoundsException success){}
471 :     }
472 :    
473 :     public void testset2() {
474 :     try {
475 :     LinkedList l = new LinkedList();
476 :     l.add(new Object());
477 :     l.set(5,new Object());
478 :     fail("set failed = l.set(5,..) l.size():" + l.size());
479 :     }catch(IndexOutOfBoundsException success){}
480 :     }
481 :    
482 :     public void testadd1() {
483 :     try {
484 :     LinkedList l = new LinkedList();
485 :     l.add(new Object());
486 :     l.add(-1,new Object());
487 :     fail("Add Failed - l.add(-1) l.size(): " + l.size());
488 :     }catch(IndexOutOfBoundsException success){}
489 :     }
490 :    
491 :     public void add2(){
492 :     try {
493 :     LinkedList l = new LinkedList();
494 :     l.add(new Object());
495 :     l.add(5,new Object());
496 :     fail("Add Failed l.add(f,...)");
497 :     }catch(IndexOutOfBoundsException success) {}
498 :     }
499 :    
500 :     public void testremove(){
501 :     try {
502 :     LinkedList l = new LinkedList();
503 :     l.add(new Object());
504 :     l.remove(-1);
505 :     fail("Remove Failed l.remove(-1); l.size():" + l.size());
506 :     }catch(IndexOutOfBoundsException success){}
507 :     }
508 :    
509 :     public void testremove1(){
510 :     try {
511 :     LinkedList l = new LinkedList();
512 :     l.add(new Object());
513 :     l.remove(5);
514 :     fail("Remove Failed l.remove(5); l.size():" + l.size());
515 :     }catch(IndexOutOfBoundsException success){}
516 :     }
517 :    
518 :    
519 :     public void testremove2(){
520 :     try{
521 :     LinkedList l = new LinkedList();
522 :     l.remove();
523 :     fail("LinkedList - Object remove() should throw a NoSuchElementException");
524 :     }catch(NoSuchElementException e){}
525 :     }
526 :    
527 :     public void testlistIt1() {
528 :     try {
529 :     LinkedList l = new LinkedList();
530 :     l.add(new Object());
531 :     l.listIterator(5);
532 :     fail("l.listIterator(5) l.size():" + l.size());
533 :     }catch(IndexOutOfBoundsException success){}
534 :     }
535 :    
536 :     public void testlistIt2() {
537 :     try {
538 :     LinkedList l = new LinkedList();
539 :     l.add(new Object());
540 :     l.listIterator(-1);
541 :     fail("l.listIterator(-1) l.size():" + l.size());
542 :     }catch(IndexOutOfBoundsException success){}
543 :     }
544 :    
545 :     public void testlistIt3() {
546 :     try {
547 :     LinkedList l = new LinkedList();
548 :     l.add(new Object());
549 :     ListIterator a = l.listIterator(0);
550 :     l.removeFirst();
551 :     a.next();
552 :     fail("l.listIterator(-1) l.size():" + l.size());
553 :     }catch(ConcurrentModificationException success){}
554 :     }
555 :    
556 :     public void testToArray_BadArg() {
557 :     try {
558 :     LinkedList l = new LinkedList();
559 :     l.add(new Object());
560 :     Object o[] = l.toArray(null);
561 :     fail("l.toArray(null) did not throw an exception");
562 :     }catch(NullPointerException success){}
563 :     }
564 :    
565 :     public void testToArray1_BadArg() {
566 :     try {
567 :     LinkedList l = new LinkedList();
568 :     l.add(new Integer(5));
569 :     Object o[] = l.toArray(new String[10] );
570 :     fail("l.toArray(String[] f) did not throw an exception, an Integer was added");
571 :     }catch(ArrayStoreException success){}
572 :     }
573 :    
574 :     }

Doug Lea
ViewVC Help
Powered by ViewVC 1.0.8