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

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

Parent Directory Parent Directory | Revision Log Revision Log


Revision 1.8 - (show annotations)
Tue Dec 28 16:15:59 2004 UTC (14 years, 7 months ago) by dl
Branch: MAIN
Changes since 1.7: +143 -0 lines
Integrate tests for jsr166x classes

1 /*
2 * Written by Doug Lea with assistance from members of JCP JSR-166
3 * Expert Group and released to the public domain, as explained at
4 * http://creativecommons.org/licenses/publicdomain
5 * Other contributors include Andrew Wright, Jeffrey Hayes,
6 * Pat Fisher, Mike Judd.
7 */
8
9 import junit.framework.*;
10 import java.util.*;
11 import java.util.concurrent.*;
12
13 public class LinkedListTest extends JSR166TestCase {
14 public static void main(String[] args) {
15 junit.textui.TestRunner.run (suite());
16 }
17
18 public static Test suite() {
19 return new TestSuite(LinkedListTest.class);
20 }
21
22 /**
23 * Create a queue of given size containing consecutive
24 * Integers 0 ... n.
25 */
26 private LinkedList populatedQueue(int n) {
27 LinkedList q = new LinkedList();
28 assertTrue(q.isEmpty());
29 for(int i = 0; i < n; ++i)
30 assertTrue(q.offer(new Integer(i)));
31 assertFalse(q.isEmpty());
32 assertEquals(n, q.size());
33 return q;
34 }
35
36 /**
37 * new queue is empty
38 */
39 public void testConstructor1() {
40 assertEquals(0, new LinkedList().size());
41 }
42
43 /**
44 * Initializing from null Collection throws NPE
45 */
46 public void testConstructor3() {
47 try {
48 LinkedList q = new LinkedList((Collection)null);
49 shouldThrow();
50 }
51 catch (NullPointerException success) {}
52 }
53
54 /**
55 * Queue contains all elements of collection used to initialize
56
57 */
58 public void testConstructor6() {
59 try {
60 Integer[] ints = new Integer[SIZE];
61 for (int i = 0; i < SIZE; ++i)
62 ints[i] = new Integer(i);
63 LinkedList q = new LinkedList(Arrays.asList(ints));
64 for (int i = 0; i < SIZE; ++i)
65 assertEquals(ints[i], q.poll());
66 }
67 finally {}
68 }
69
70 /**
71 * isEmpty is true before add, false after
72 */
73 public void testEmpty() {
74 LinkedList q = new LinkedList();
75 assertTrue(q.isEmpty());
76 q.add(new Integer(1));
77 assertFalse(q.isEmpty());
78 q.add(new Integer(2));
79 q.remove();
80 q.remove();
81 assertTrue(q.isEmpty());
82 }
83
84 /**
85 * size changes when elements added and removed
86 */
87 public void testSize() {
88 LinkedList q = populatedQueue(SIZE);
89 for (int i = 0; i < SIZE; ++i) {
90 assertEquals(SIZE-i, q.size());
91 q.remove();
92 }
93 for (int i = 0; i < SIZE; ++i) {
94 assertEquals(i, q.size());
95 q.add(new Integer(i));
96 }
97 }
98
99 /**
100 * offer(null) succeeds
101 */
102 public void testOfferNull() {
103 try {
104 LinkedList q = new LinkedList();
105 q.offer(null);
106 } catch (NullPointerException ie) {
107 unexpectedException();
108 }
109 }
110
111 /**
112 * Offer succeeds
113 */
114 public void testOffer() {
115 LinkedList q = new LinkedList();
116 assertTrue(q.offer(new Integer(0)));
117 assertTrue(q.offer(new Integer(1)));
118 }
119
120 /**
121 * add succeeds
122 */
123 public void testAdd() {
124 LinkedList q = new LinkedList();
125 for (int i = 0; i < SIZE; ++i) {
126 assertEquals(i, q.size());
127 assertTrue(q.add(new Integer(i)));
128 }
129 }
130
131 /**
132 * addAll(null) throws NPE
133 */
134 public void testAddAll1() {
135 try {
136 LinkedList q = new LinkedList();
137 q.addAll(null);
138 shouldThrow();
139 }
140 catch (NullPointerException success) {}
141 }
142
143 /**
144 * Queue contains all elements, in traversal order, of successful addAll
145 */
146 public void testAddAll5() {
147 try {
148 Integer[] empty = new Integer[0];
149 Integer[] ints = new Integer[SIZE];
150 for (int i = 0; i < SIZE; ++i)
151 ints[i] = new Integer(i);
152 LinkedList q = new LinkedList();
153 assertFalse(q.addAll(Arrays.asList(empty)));
154 assertTrue(q.addAll(Arrays.asList(ints)));
155 for (int i = 0; i < SIZE; ++i)
156 assertEquals(ints[i], q.poll());
157 }
158 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() {
193 LinkedList q = populatedQueue(SIZE);
194 for (int i = 0; i < SIZE; ++i) {
195 assertEquals(i, ((Integer)q.poll()).intValue());
196 }
197 assertNull(q.poll());
198 }
199
200 /**
201 * peek returns next element, or null if empty
202 */
203 public void testPeek() {
204 LinkedList q = populatedQueue(SIZE);
205 for (int i = 0; i < SIZE; ++i) {
206 assertEquals(i, ((Integer)q.peek()).intValue());
207 q.poll();
208 assertTrue(q.peek() == null ||
209 i != ((Integer)q.peek()).intValue());
210 }
211 assertNull(q.peek());
212 }
213
214 /**
215 * element returns next element, or throws NSEE if empty
216 */
217 public void testElement() {
218 LinkedList q = populatedQueue(SIZE);
219 for (int i = 0; i < SIZE; ++i) {
220 assertEquals(i, ((Integer)q.element()).intValue());
221 q.poll();
222 }
223 try {
224 q.element();
225 shouldThrow();
226 }
227 catch (NoSuchElementException success) {}
228 }
229
230 /**
231 * remove removes next element, or throws NSEE if empty
232 */
233 public void testRemove() {
234 LinkedList q = populatedQueue(SIZE);
235 for (int i = 0; i < SIZE; ++i) {
236 assertEquals(i, ((Integer)q.remove()).intValue());
237 }
238 try {
239 q.remove();
240 shouldThrow();
241 } catch (NoSuchElementException success){
242 }
243 }
244
245 /**
246 * remove(x) removes x and returns true if present
247 */
248 public void testRemoveElement() {
249 LinkedList q = populatedQueue(SIZE);
250 for (int i = 1; i < SIZE; i+=2) {
251 assertTrue(q.remove(new Integer(i)));
252 }
253 for (int i = 0; i < SIZE; i+=2) {
254 assertTrue(q.remove(new Integer(i)));
255 assertFalse(q.remove(new Integer(i+1)));
256 }
257 assertTrue(q.isEmpty());
258 }
259
260 /**
261 * contains(x) reports true when elements added but not yet removed
262 */
263 public void testContains() {
264 LinkedList q = populatedQueue(SIZE);
265 for (int i = 0; i < SIZE; ++i) {
266 assertTrue(q.contains(new Integer(i)));
267 q.poll();
268 assertFalse(q.contains(new Integer(i)));
269 }
270 }
271
272 /**
273 * clear removes all elements
274 */
275 public void testClear() {
276 LinkedList q = populatedQueue(SIZE);
277 q.clear();
278 assertTrue(q.isEmpty());
279 assertEquals(0, q.size());
280 q.add(new Integer(1));
281 assertFalse(q.isEmpty());
282 q.clear();
283 assertTrue(q.isEmpty());
284 }
285
286 /**
287 * containsAll(c) is true when c contains a subset of elements
288 */
289 public void testContainsAll() {
290 LinkedList q = populatedQueue(SIZE);
291 LinkedList p = new LinkedList();
292 for (int i = 0; i < SIZE; ++i) {
293 assertTrue(q.containsAll(p));
294 assertFalse(p.containsAll(q));
295 p.add(new Integer(i));
296 }
297 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() {
304 LinkedList q = populatedQueue(SIZE);
305 LinkedList p = populatedQueue(SIZE);
306 for (int i = 0; i < SIZE; ++i) {
307 boolean changed = q.retainAll(p);
308 if (i == 0)
309 assertFalse(changed);
310 else
311 assertTrue(changed);
312
313 assertTrue(q.containsAll(p));
314 assertEquals(SIZE-i, q.size());
315 p.remove();
316 }
317 }
318
319 /**
320 * removeAll(c) removes only those elements of c and reports true if changed
321 */
322 public void testRemoveAll() {
323 for (int i = 1; i < SIZE; ++i) {
324 LinkedList q = populatedQueue(SIZE);
325 LinkedList p = populatedQueue(i);
326 assertTrue(q.removeAll(p));
327 assertEquals(SIZE-i, q.size());
328 for (int j = 0; j < i; ++j) {
329 Integer I = (Integer)(p.remove());
330 assertFalse(q.contains(I));
331 }
332 }
333 }
334
335 /**
336 * toArray contains all elements
337 */
338 public void testToArray() {
339 LinkedList q = populatedQueue(SIZE);
340 Object[] o = q.toArray();
341 Arrays.sort(o);
342 for(int i = 0; i < o.length; i++)
343 assertEquals(o[i], q.poll());
344 }
345
346 /**
347 * toArray(a) contains all elements
348 */
349 public void testToArray2() {
350 LinkedList q = populatedQueue(SIZE);
351 Integer[] ints = new Integer[SIZE];
352 ints = (Integer[])q.toArray(ints);
353 Arrays.sort(ints);
354 for(int i = 0; i < ints.length; i++)
355 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() {
386 LinkedList q = populatedQueue(SIZE);
387 int i = 0;
388 Iterator it = q.iterator();
389 while(it.hasNext()) {
390 assertTrue(q.contains(it.next()));
391 ++i;
392 }
393 assertEquals(i, SIZE);
394 }
395
396 /**
397 * iterator ordering is FIFO
398 */
399 public void testIteratorOrdering() {
400 final LinkedList q = new LinkedList();
401 q.add(new Integer(1));
402 q.add(new Integer(2));
403 q.add(new Integer(3));
404 int k = 0;
405 for (Iterator it = q.iterator(); it.hasNext();) {
406 int i = ((Integer)(it.next())).intValue();
407 assertEquals(++k, i);
408 }
409
410 assertEquals(3, k);
411 }
412
413 /**
414 * iterator.remove removes current element
415 */
416 public void testIteratorRemove () {
417 final LinkedList q = new LinkedList();
418 q.add(new Integer(1));
419 q.add(new Integer(2));
420 q.add(new Integer(3));
421 Iterator it = q.iterator();
422 it.next();
423 it.remove();
424 it = q.iterator();
425 assertEquals(it.next(), new Integer(2));
426 assertEquals(it.next(), new Integer(3));
427 assertFalse(it.hasNext());
428 }
429
430
431 /**
432 * toString contains toStrings of elements
433 */
434 public void testToString() {
435 LinkedList q = populatedQueue(SIZE);
436 String s = q.toString();
437 for (int i = 0; i < SIZE; ++i) {
438 assertTrue(s.indexOf(String.valueOf(i)) >= 0);
439 }
440 }
441
442 /**
443 * peek returns element inserted with addFirst
444 */
445 public void testAddFirst() {
446 LinkedList q = populatedQueue(3);
447 q.addFirst(four);
448 assertEquals(four,q.peek());
449 }
450
451 /**
452 * peekFirst returns element inserted with push
453 */
454 public void testPush() {
455 LinkedList q = populatedQueue(3);
456 q.pollLast();
457 q.push(four);
458 assertEquals(four,q.peekFirst());
459 }
460
461 /**
462 * pop removes next element, or throws NSEE if empty
463 */
464 public void testPop() {
465 LinkedList q = populatedQueue(SIZE);
466 for (int i = 0; i < SIZE; ++i) {
467 assertEquals(i, ((Integer)q.pop()).intValue());
468 }
469 try {
470 q.pop();
471 shouldThrow();
472 } catch (NoSuchElementException success){
473 }
474 }
475
476 /**
477 * OfferFirst succeeds
478 */
479 public void testOfferFirst() {
480 LinkedList q = new LinkedList();
481 assertTrue(q.offerFirst(new Integer(0)));
482 assertTrue(q.offerFirst(new Integer(1)));
483 }
484
485 /**
486 * OfferLast succeeds
487 */
488 public void testOfferLast() {
489 LinkedList q = new LinkedList();
490 assertTrue(q.offerLast(new Integer(0)));
491 assertTrue(q.offerLast(new Integer(1)));
492 }
493
494 /**
495 * pollLast succeeds unless empty
496 */
497 public void testPollLast() {
498 LinkedList q = populatedQueue(SIZE);
499 for (int i = SIZE-1; i >= 0; --i) {
500 assertEquals(i, ((Integer)q.pollLast()).intValue());
501 }
502 assertNull(q.pollLast());
503 }
504
505 /**
506 * peekFirst returns next element, or null if empty
507 */
508 public void testPeekFirst() {
509 LinkedList q = populatedQueue(SIZE);
510 for (int i = 0; i < SIZE; ++i) {
511 assertEquals(i, ((Integer)q.peekFirst()).intValue());
512 q.pollFirst();
513 assertTrue(q.peekFirst() == null ||
514 i != ((Integer)q.peekFirst()).intValue());
515 }
516 assertNull(q.peekFirst());
517 }
518
519
520 /**
521 * peekLast returns next element, or null if empty
522 */
523 public void testPeekLast() {
524 LinkedList q = populatedQueue(SIZE);
525 for (int i = SIZE-1; i >= 0; --i) {
526 assertEquals(i, ((Integer)q.peekLast()).intValue());
527 q.pollLast();
528 assertTrue(q.peekLast() == null ||
529 i != ((Integer)q.peekLast()).intValue());
530 }
531 assertNull(q.peekLast());
532 }
533
534 public void testFirstElement() {
535 LinkedList q = populatedQueue(SIZE);
536 for (int i = 0; i < SIZE; ++i) {
537 assertEquals(i, ((Integer)q.getFirst()).intValue());
538 q.pollFirst();
539 }
540 try {
541 q.getFirst();
542 shouldThrow();
543 }
544 catch (NoSuchElementException success) {}
545 }
546
547 /**
548 * getLast returns next element, or throws NSEE if empty
549 */
550 public void testLastElement() {
551 LinkedList q = populatedQueue(SIZE);
552 for (int i = SIZE-1; i >= 0; --i) {
553 assertEquals(i, ((Integer)q.getLast()).intValue());
554 q.pollLast();
555 }
556 try {
557 q.getLast();
558 shouldThrow();
559 }
560 catch (NoSuchElementException success) {}
561 assertNull(q.peekLast());
562 }
563
564 /**
565 * removeFirstOccurrence(x) removes x and returns true if present
566 */
567 public void testRemoveFirstOccurrence() {
568 LinkedList q = populatedQueue(SIZE);
569 for (int i = 1; i < SIZE; i+=2) {
570 assertTrue(q.removeFirstOccurrence(new Integer(i)));
571 }
572 for (int i = 0; i < SIZE; i+=2) {
573 assertTrue(q.removeFirstOccurrence(new Integer(i)));
574 assertFalse(q.removeFirstOccurrence(new Integer(i+1)));
575 }
576 assertTrue(q.isEmpty());
577 }
578
579 /**
580 * removeLastOccurrence(x) removes x and returns true if present
581 */
582 public void testRemoveLastOccurrence() {
583 LinkedList q = populatedQueue(SIZE);
584 for (int i = 1; i < SIZE; i+=2) {
585 assertTrue(q.removeLastOccurrence(new Integer(i)));
586 }
587 for (int i = 0; i < SIZE; i+=2) {
588 assertTrue(q.removeLastOccurrence(new Integer(i)));
589 assertFalse(q.removeLastOccurrence(new Integer(i+1)));
590 }
591 assertTrue(q.isEmpty());
592 }
593
594 }

dl@cs.oswego.edu
ViewVC Help
Powered by ViewVC 1.1.27