[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.38 - (view) (download)

1 : dl 1.1 /*
2 : dl 1.7 * 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 : jsr166 1.26 * http://creativecommons.org/publicdomain/zero/1.0/
5 : jsr166 1.10 * Other contributors include Andrew Wright, Jeffrey Hayes,
6 :     * Pat Fisher, Mike Judd.
7 : dl 1.1 */
8 :    
9 : jsr166 1.28 import java.util.Arrays;
10 :     import java.util.Collection;
11 :     import java.util.Iterator;
12 :     import java.util.LinkedList;
13 :     import java.util.NoSuchElementException;
14 : dl 1.1
15 : jsr166 1.32 import junit.framework.Test;
16 :     import junit.framework.TestSuite;
17 :    
18 : dl 1.3 public class LinkedListTest extends JSR166TestCase {
19 : dl 1.1 public static void main(String[] args) {
20 : jsr166 1.37 main(suite(), args);
21 : dl 1.1 }
22 :    
23 :     public static Test suite() {
24 : jsr166 1.13 return new TestSuite(LinkedListTest.class);
25 : dl 1.1 }
26 :    
27 :     /**
28 : jsr166 1.31 * Returns a new queue of given size containing consecutive
29 : dl 1.1 * Integers 0 ... n.
30 :     */
31 : jsr166 1.24 private LinkedList<Integer> populatedQueue(int n) {
32 :     LinkedList<Integer> q = new LinkedList<Integer>();
33 : dl 1.1 assertTrue(q.isEmpty());
34 : jsr166 1.13 for (int i = 0; i < n; ++i)
35 :     assertTrue(q.offer(new Integer(i)));
36 : dl 1.1 assertFalse(q.isEmpty());
37 : jsr166 1.13 assertEquals(n, q.size());
38 : dl 1.1 return q;
39 :     }
40 : jsr166 1.10
41 : dl 1.4 /**
42 : dl 1.5 * new queue is empty
43 : dl 1.4 */
44 :     public void testConstructor1() {
45 : dl 1.1 assertEquals(0, new LinkedList().size());
46 :     }
47 :    
48 : dl 1.4 /**
49 : dl 1.5 * Initializing from null Collection throws NPE
50 : dl 1.4 */
51 : dl 1.1 public void testConstructor3() {
52 :     try {
53 : jsr166 1.36 new LinkedList((Collection)null);
54 : dl 1.4 shouldThrow();
55 : jsr166 1.14 } catch (NullPointerException success) {}
56 : dl 1.1 }
57 :    
58 : dl 1.4 /**
59 : dl 1.5 * Queue contains all elements of collection used to initialize
60 : dl 1.4 */
61 :     public void testConstructor6() {
62 : jsr166 1.14 Integer[] ints = new Integer[SIZE];
63 :     for (int i = 0; i < SIZE; ++i)
64 : jsr166 1.16 ints[i] = i;
65 : jsr166 1.14 LinkedList q = new LinkedList(Arrays.asList(ints));
66 :     for (int i = 0; i < SIZE; ++i)
67 :     assertEquals(ints[i], q.poll());
68 : dl 1.1 }
69 :    
70 : dl 1.4 /**
71 : dl 1.5 * isEmpty is true before add, false after
72 : dl 1.4 */
73 : dl 1.1 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 : dl 1.4 /**
85 : dl 1.5 * size changes when elements added and removed
86 : dl 1.4 */
87 : dl 1.1 public void testSize() {
88 : dl 1.3 LinkedList q = populatedQueue(SIZE);
89 :     for (int i = 0; i < SIZE; ++i) {
90 :     assertEquals(SIZE-i, q.size());
91 : dl 1.1 q.remove();
92 :     }
93 : dl 1.3 for (int i = 0; i < SIZE; ++i) {
94 : dl 1.1 assertEquals(i, q.size());
95 :     q.add(new Integer(i));
96 :     }
97 :     }
98 :    
99 : dl 1.4 /**
100 : dl 1.5 * offer(null) succeeds
101 : dl 1.4 */
102 :     public void testOfferNull() {
103 : jsr166 1.14 LinkedList q = new LinkedList();
104 :     q.offer(null);
105 : jsr166 1.38 assertNull(q.get(0));
106 :     assertTrue(q.contains(null));
107 : dl 1.1 }
108 :    
109 : dl 1.4 /**
110 : jsr166 1.10 * Offer succeeds
111 : dl 1.4 */
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 : dl 1.5 * add succeeds
120 : dl 1.4 */
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 : dl 1.5 * addAll(null) throws NPE
131 : dl 1.4 */
132 :     public void testAddAll1() {
133 : jsr166 1.38 LinkedList q = new LinkedList();
134 : dl 1.1 try {
135 :     q.addAll(null);
136 : dl 1.4 shouldThrow();
137 : jsr166 1.14 } catch (NullPointerException success) {}
138 : dl 1.1 }
139 :    
140 : dl 1.4 /**
141 : dl 1.5 * Queue contains all elements, in traversal order, of successful addAll
142 : dl 1.4 */
143 :     public void testAddAll5() {
144 : jsr166 1.14 Integer[] empty = new Integer[0];
145 :     Integer[] ints = new Integer[SIZE];
146 :     for (int i = 0; i < SIZE; ++i)
147 : jsr166 1.16 ints[i] = i;
148 : jsr166 1.14 LinkedList q = new LinkedList();
149 :     assertFalse(q.addAll(Arrays.asList(empty)));
150 :     assertTrue(q.addAll(Arrays.asList(ints)));
151 :     for (int i = 0; i < SIZE; ++i)
152 :     assertEquals(ints[i], q.poll());
153 : dl 1.1 }
154 :    
155 : dl 1.4 /**
156 : dl 1.5 * addAll with too large an index throws IOOBE
157 :     */
158 :     public void testAddAll2_IndexOutOfBoundsException() {
159 : jsr166 1.14 LinkedList l = new LinkedList();
160 :     l.add(new Object());
161 :     LinkedList m = new LinkedList();
162 :     m.add(new Object());
163 : jsr166 1.13 try {
164 :     l.addAll(4,m);
165 :     shouldThrow();
166 : jsr166 1.15 } catch (IndexOutOfBoundsException success) {}
167 : dl 1.5 }
168 :    
169 :     /**
170 :     * addAll with negative index throws IOOBE
171 :     */
172 :     public void testAddAll4_BadIndex() {
173 : jsr166 1.14 LinkedList l = new LinkedList();
174 :     l.add(new Object());
175 :     LinkedList m = new LinkedList();
176 :     m.add(new Object());
177 : jsr166 1.13 try {
178 :     l.addAll(-1,m);
179 :     shouldThrow();
180 : jsr166 1.15 } catch (IndexOutOfBoundsException success) {}
181 : dl 1.5 }
182 :    
183 :     /**
184 : jsr166 1.20 * poll succeeds unless empty
185 : dl 1.4 */
186 :     public void testPoll() {
187 : dl 1.3 LinkedList q = populatedQueue(SIZE);
188 :     for (int i = 0; i < SIZE; ++i) {
189 : jsr166 1.16 assertEquals(i, q.poll());
190 : dl 1.1 }
191 : jsr166 1.13 assertNull(q.poll());
192 : dl 1.1 }
193 :    
194 : dl 1.4 /**
195 : jsr166 1.20 * peek returns next element, or null if empty
196 : dl 1.4 */
197 :     public void testPeek() {
198 : dl 1.3 LinkedList q = populatedQueue(SIZE);
199 :     for (int i = 0; i < SIZE; ++i) {
200 : jsr166 1.16 assertEquals(i, q.peek());
201 :     assertEquals(i, q.poll());
202 : dl 1.1 assertTrue(q.peek() == null ||
203 : jsr166 1.16 !q.peek().equals(i));
204 : dl 1.1 }
205 : jsr166 1.13 assertNull(q.peek());
206 : dl 1.1 }
207 :    
208 : dl 1.4 /**
209 : dl 1.6 * element returns next element, or throws NSEE if empty
210 : dl 1.4 */
211 :     public void testElement() {
212 : dl 1.3 LinkedList q = populatedQueue(SIZE);
213 :     for (int i = 0; i < SIZE; ++i) {
214 : jsr166 1.16 assertEquals(i, q.element());
215 :     assertEquals(i, q.poll());
216 : dl 1.1 }
217 :     try {
218 :     q.element();
219 : dl 1.4 shouldThrow();
220 : jsr166 1.14 } catch (NoSuchElementException success) {}
221 : dl 1.1 }
222 :    
223 : dl 1.4 /**
224 : jsr166 1.20 * remove removes next element, or throws NSEE if empty
225 : dl 1.4 */
226 :     public void testRemove() {
227 : dl 1.3 LinkedList q = populatedQueue(SIZE);
228 :     for (int i = 0; i < SIZE; ++i) {
229 : jsr166 1.16 assertEquals(i, q.remove());
230 : dl 1.1 }
231 :     try {
232 :     q.remove();
233 : dl 1.4 shouldThrow();
234 : jsr166 1.14 } catch (NoSuchElementException success) {}
235 : dl 1.1 }
236 :    
237 : dl 1.4 /**
238 : dl 1.5 * remove(x) removes x and returns true if present
239 : dl 1.4 */
240 :     public void testRemoveElement() {
241 : dl 1.3 LinkedList q = populatedQueue(SIZE);
242 : jsr166 1.33 for (int i = 1; i < SIZE; i += 2) {
243 : jsr166 1.25 assertTrue(q.contains(i));
244 :     assertTrue(q.remove((Integer)i));
245 :     assertFalse(q.contains(i));
246 :     assertTrue(q.contains(i-1));
247 : dl 1.1 }
248 : jsr166 1.33 for (int i = 0; i < SIZE; i += 2) {
249 : jsr166 1.25 assertTrue(q.contains(i));
250 :     assertTrue(q.remove((Integer)i));
251 :     assertFalse(q.contains(i));
252 :     assertFalse(q.remove((Integer)(i+1)));
253 :     assertFalse(q.contains(i+1));
254 : dl 1.1 }
255 : dl 1.2 assertTrue(q.isEmpty());
256 : dl 1.1 }
257 : jsr166 1.10
258 : dl 1.4 /**
259 : dl 1.5 * contains(x) reports true when elements added but not yet removed
260 : dl 1.4 */
261 :     public void testContains() {
262 : dl 1.3 LinkedList q = populatedQueue(SIZE);
263 :     for (int i = 0; i < SIZE; ++i) {
264 : dl 1.1 assertTrue(q.contains(new Integer(i)));
265 :     q.poll();
266 :     assertFalse(q.contains(new Integer(i)));
267 :     }
268 :     }
269 :    
270 : dl 1.4 /**
271 : dl 1.5 * clear removes all elements
272 : dl 1.4 */
273 :     public void testClear() {
274 : dl 1.3 LinkedList q = populatedQueue(SIZE);
275 : dl 1.1 q.clear();
276 :     assertTrue(q.isEmpty());
277 :     assertEquals(0, q.size());
278 : jsr166 1.16 assertTrue(q.add(new Integer(1)));
279 : dl 1.1 assertFalse(q.isEmpty());
280 :     q.clear();
281 :     assertTrue(q.isEmpty());
282 :     }
283 :    
284 : dl 1.4 /**
285 : dl 1.5 * containsAll(c) is true when c contains a subset of elements
286 : dl 1.4 */
287 :     public void testContainsAll() {
288 : dl 1.3 LinkedList q = populatedQueue(SIZE);
289 : dl 1.1 LinkedList p = new LinkedList();
290 : dl 1.3 for (int i = 0; i < SIZE; ++i) {
291 : dl 1.1 assertTrue(q.containsAll(p));
292 :     assertFalse(p.containsAll(q));
293 : jsr166 1.16 assertTrue(p.add(new Integer(i)));
294 : dl 1.1 }
295 :     assertTrue(p.containsAll(q));
296 :     }
297 :    
298 : dl 1.4 /**
299 : dl 1.5 * retainAll(c) retains only those elements of c and reports true if changed
300 : dl 1.4 */
301 :     public void testRetainAll() {
302 : dl 1.3 LinkedList q = populatedQueue(SIZE);
303 :     LinkedList p = populatedQueue(SIZE);
304 :     for (int i = 0; i < SIZE; ++i) {
305 : dl 1.1 boolean changed = q.retainAll(p);
306 :     if (i == 0)
307 :     assertFalse(changed);
308 :     else
309 :     assertTrue(changed);
310 :    
311 :     assertTrue(q.containsAll(p));
312 : dl 1.3 assertEquals(SIZE-i, q.size());
313 : dl 1.1 p.remove();
314 :     }
315 :     }
316 :    
317 : dl 1.4 /**
318 : dl 1.6 * removeAll(c) removes only those elements of c and reports true if changed
319 : dl 1.4 */
320 :     public void testRemoveAll() {
321 : dl 1.3 for (int i = 1; i < SIZE; ++i) {
322 :     LinkedList q = populatedQueue(SIZE);
323 :     LinkedList p = populatedQueue(i);
324 : dl 1.1 assertTrue(q.removeAll(p));
325 : dl 1.3 assertEquals(SIZE-i, q.size());
326 : dl 1.1 for (int j = 0; j < i; ++j) {
327 : jsr166 1.34 Integer x = (Integer)(p.remove());
328 :     assertFalse(q.contains(x));
329 : dl 1.1 }
330 :     }
331 :     }
332 :    
333 : dl 1.4 /**
334 : jsr166 1.23 * toArray contains all elements in FIFO order
335 : dl 1.4 */
336 :     public void testToArray() {
337 : dl 1.3 LinkedList q = populatedQueue(SIZE);
338 : jsr166 1.13 Object[] o = q.toArray();
339 :     for (int i = 0; i < o.length; i++)
340 : jsr166 1.23 assertSame(o[i], q.poll());
341 : dl 1.1 }
342 :    
343 : dl 1.4 /**
344 : jsr166 1.23 * toArray(a) contains all elements in FIFO order
345 : dl 1.4 */
346 :     public void testToArray2() {
347 : jsr166 1.24 LinkedList<Integer> q = populatedQueue(SIZE);
348 : jsr166 1.13 Integer[] ints = new Integer[SIZE];
349 : jsr166 1.24 Integer[] array = q.toArray(ints);
350 :     assertSame(ints, array);
351 : jsr166 1.11 for (int i = 0; i < ints.length; i++)
352 : jsr166 1.23 assertSame(ints[i], q.poll());
353 : dl 1.1 }
354 : dl 1.5
355 :     /**
356 : jsr166 1.22 * toArray(null) throws NullPointerException
357 : dl 1.5 */
358 : jsr166 1.22 public void testToArray_NullArg() {
359 : jsr166 1.16 LinkedList l = new LinkedList();
360 :     l.add(new Object());
361 : jsr166 1.13 try {
362 : jsr166 1.22 l.toArray(null);
363 : jsr166 1.13 shouldThrow();
364 :     } catch (NullPointerException success) {}
365 : dl 1.5 }
366 :    
367 :     /**
368 : jsr166 1.21 * toArray(incompatible array type) throws ArrayStoreException
369 : dl 1.5 */
370 :     public void testToArray1_BadArg() {
371 : jsr166 1.16 LinkedList l = new LinkedList();
372 :     l.add(new Integer(5));
373 : jsr166 1.13 try {
374 : jsr166 1.21 l.toArray(new String[10]);
375 : jsr166 1.13 shouldThrow();
376 : jsr166 1.14 } catch (ArrayStoreException success) {}
377 : dl 1.5 }
378 : jsr166 1.10
379 : dl 1.4 /**
380 : jsr166 1.20 * iterator iterates through all elements
381 : dl 1.4 */
382 :     public void testIterator() {
383 : dl 1.3 LinkedList q = populatedQueue(SIZE);
384 : jsr166 1.13 Iterator it = q.iterator();
385 : jsr166 1.35 int i;
386 :     for (i = 0; it.hasNext(); i++)
387 : dl 1.1 assertTrue(q.contains(it.next()));
388 : dl 1.3 assertEquals(i, SIZE);
389 : jsr166 1.35 assertIteratorExhausted(it);
390 :     }
391 :    
392 :     /**
393 :     * iterator of empty collection has no elements
394 :     */
395 :     public void testEmptyIterator() {
396 :     assertIteratorExhausted(new LinkedList().iterator());
397 : dl 1.1 }
398 :    
399 : dl 1.4 /**
400 : jsr166 1.20 * iterator ordering is FIFO
401 : dl 1.4 */
402 : dl 1.1 public void testIteratorOrdering() {
403 :     final LinkedList q = new LinkedList();
404 :     q.add(new Integer(1));
405 :     q.add(new Integer(2));
406 :     q.add(new Integer(3));
407 :     int k = 0;
408 :     for (Iterator it = q.iterator(); it.hasNext();) {
409 : jsr166 1.16 assertEquals(++k, it.next());
410 : dl 1.1 }
411 :    
412 : dl 1.4 assertEquals(3, k);
413 : dl 1.1 }
414 :    
415 : dl 1.4 /**
416 : dl 1.5 * iterator.remove removes current element
417 : dl 1.4 */
418 : jsr166 1.19 public void testIteratorRemove() {
419 : dl 1.1 final LinkedList q = new LinkedList();
420 :     q.add(new Integer(1));
421 :     q.add(new Integer(2));
422 :     q.add(new Integer(3));
423 :     Iterator it = q.iterator();
424 : jsr166 1.29 assertEquals(1, it.next());
425 : dl 1.1 it.remove();
426 :     it = q.iterator();
427 : jsr166 1.29 assertEquals(2, it.next());
428 :     assertEquals(3, it.next());
429 : dl 1.1 assertFalse(it.hasNext());
430 :     }
431 :    
432 : dl 1.9 /**
433 : jsr166 1.20 * Descending iterator iterates through all elements
434 : dl 1.9 */
435 :     public void testDescendingIterator() {
436 :     LinkedList q = populatedQueue(SIZE);
437 :     int i = 0;
438 : jsr166 1.13 Iterator it = q.descendingIterator();
439 : jsr166 1.11 while (it.hasNext()) {
440 : dl 1.9 assertTrue(q.contains(it.next()));
441 :     ++i;
442 :     }
443 :     assertEquals(i, SIZE);
444 :     assertFalse(it.hasNext());
445 :     try {
446 :     it.next();
447 : jsr166 1.14 shouldThrow();
448 :     } catch (NoSuchElementException success) {}
449 : dl 1.9 }
450 :    
451 :     /**
452 : jsr166 1.20 * Descending iterator ordering is reverse FIFO
453 : dl 1.9 */
454 :     public void testDescendingIteratorOrdering() {
455 :     final LinkedList q = new LinkedList();
456 :     q.add(new Integer(3));
457 :     q.add(new Integer(2));
458 :     q.add(new Integer(1));
459 :     int k = 0;
460 :     for (Iterator it = q.descendingIterator(); it.hasNext();) {
461 : jsr166 1.16 assertEquals(++k, it.next());
462 : dl 1.9 }
463 :    
464 :     assertEquals(3, k);
465 :     }
466 :    
467 :     /**
468 :     * descendingIterator.remove removes current element
469 :     */
470 : jsr166 1.19 public void testDescendingIteratorRemove() {
471 : dl 1.9 final LinkedList q = new LinkedList();
472 : jsr166 1.17 q.add(three);
473 :     q.add(two);
474 :     q.add(one);
475 : dl 1.9 Iterator it = q.descendingIterator();
476 :     it.next();
477 :     it.remove();
478 :     it = q.descendingIterator();
479 : jsr166 1.17 assertSame(it.next(), two);
480 :     assertSame(it.next(), three);
481 : dl 1.9 assertFalse(it.hasNext());
482 :     }
483 :    
484 : dl 1.4 /**
485 : dl 1.5 * toString contains toStrings of elements
486 : dl 1.4 */
487 :     public void testToString() {
488 : dl 1.3 LinkedList q = populatedQueue(SIZE);
489 : dl 1.1 String s = q.toString();
490 : dl 1.3 for (int i = 0; i < SIZE; ++i) {
491 : jsr166 1.27 assertTrue(s.contains(String.valueOf(i)));
492 : dl 1.1 }
493 : jsr166 1.10 }
494 : dl 1.1
495 : dl 1.4 /**
496 : dl 1.5 * peek returns element inserted with addFirst
497 : dl 1.4 */
498 :     public void testAddFirst() {
499 : dl 1.3 LinkedList q = populatedQueue(3);
500 : jsr166 1.13 q.addFirst(four);
501 : jsr166 1.17 assertSame(four, q.peek());
502 : jsr166 1.10 }
503 : dl 1.1
504 : dl 1.8 /**
505 :     * peekFirst returns element inserted with push
506 :     */
507 :     public void testPush() {
508 :     LinkedList q = populatedQueue(3);
509 : jsr166 1.13 q.push(four);
510 : jsr166 1.17 assertSame(four, q.peekFirst());
511 : jsr166 1.10 }
512 : dl 1.8
513 :     /**
514 : jsr166 1.20 * pop removes next element, or throws NSEE if empty
515 : dl 1.8 */
516 :     public void testPop() {
517 :     LinkedList q = populatedQueue(SIZE);
518 :     for (int i = 0; i < SIZE; ++i) {
519 : jsr166 1.16 assertEquals(i, q.pop());
520 : dl 1.8 }
521 :     try {
522 :     q.pop();
523 :     shouldThrow();
524 : jsr166 1.14 } catch (NoSuchElementException success) {}
525 : dl 1.8 }
526 :    
527 :     /**
528 : jsr166 1.10 * OfferFirst succeeds
529 : dl 1.8 */
530 :     public void testOfferFirst() {
531 :     LinkedList q = new LinkedList();
532 :     assertTrue(q.offerFirst(new Integer(0)));
533 :     assertTrue(q.offerFirst(new Integer(1)));
534 :     }
535 :    
536 :     /**
537 : jsr166 1.10 * OfferLast succeeds
538 : dl 1.8 */
539 :     public void testOfferLast() {
540 :     LinkedList q = new LinkedList();
541 :     assertTrue(q.offerLast(new Integer(0)));
542 :     assertTrue(q.offerLast(new Integer(1)));
543 :     }
544 :    
545 :     /**
546 : jsr166 1.20 * pollLast succeeds unless empty
547 : dl 1.8 */
548 :     public void testPollLast() {
549 :     LinkedList q = populatedQueue(SIZE);
550 :     for (int i = SIZE-1; i >= 0; --i) {
551 : jsr166 1.16 assertEquals(i, q.pollLast());
552 : dl 1.8 }
553 : jsr166 1.13 assertNull(q.pollLast());
554 : dl 1.8 }
555 :    
556 :     /**
557 : jsr166 1.20 * peekFirst returns next element, or null if empty
558 : dl 1.8 */
559 :     public void testPeekFirst() {
560 :     LinkedList q = populatedQueue(SIZE);
561 :     for (int i = 0; i < SIZE; ++i) {
562 : jsr166 1.16 assertEquals(i, q.peekFirst());
563 :     assertEquals(i, q.pollFirst());
564 : dl 1.8 assertTrue(q.peekFirst() == null ||
565 : jsr166 1.16 !q.peekFirst().equals(i));
566 : dl 1.8 }
567 : jsr166 1.13 assertNull(q.peekFirst());
568 : dl 1.8 }
569 :    
570 :     /**
571 : jsr166 1.20 * peekLast returns next element, or null if empty
572 : dl 1.8 */
573 :     public void testPeekLast() {
574 :     LinkedList q = populatedQueue(SIZE);
575 :     for (int i = SIZE-1; i >= 0; --i) {
576 : jsr166 1.16 assertEquals(i, q.peekLast());
577 :     assertEquals(i, q.pollLast());
578 : dl 1.8 assertTrue(q.peekLast() == null ||
579 : jsr166 1.16 !q.peekLast().equals(i));
580 : dl 1.8 }
581 : jsr166 1.13 assertNull(q.peekLast());
582 : dl 1.8 }
583 :    
584 :     public void testFirstElement() {
585 :     LinkedList q = populatedQueue(SIZE);
586 :     for (int i = 0; i < SIZE; ++i) {
587 : jsr166 1.16 assertEquals(i, q.getFirst());
588 :     assertEquals(i, q.pollFirst());
589 : dl 1.8 }
590 :     try {
591 :     q.getFirst();
592 :     shouldThrow();
593 : jsr166 1.14 } catch (NoSuchElementException success) {}
594 : dl 1.8 }
595 :    
596 :     /**
597 : jsr166 1.20 * getLast returns next element, or throws NSEE if empty
598 : dl 1.8 */
599 :     public void testLastElement() {
600 :     LinkedList q = populatedQueue(SIZE);
601 :     for (int i = SIZE-1; i >= 0; --i) {
602 : jsr166 1.16 assertEquals(i, q.getLast());
603 :     assertEquals(i, q.pollLast());
604 : dl 1.8 }
605 :     try {
606 :     q.getLast();
607 :     shouldThrow();
608 : jsr166 1.14 } catch (NoSuchElementException success) {}
609 : jsr166 1.13 assertNull(q.peekLast());
610 : dl 1.8 }
611 :    
612 :     /**
613 :     * removeFirstOccurrence(x) removes x and returns true if present
614 :     */
615 :     public void testRemoveFirstOccurrence() {
616 :     LinkedList q = populatedQueue(SIZE);
617 : jsr166 1.33 for (int i = 1; i < SIZE; i += 2) {
618 : dl 1.8 assertTrue(q.removeFirstOccurrence(new Integer(i)));
619 :     }
620 : jsr166 1.33 for (int i = 0; i < SIZE; i += 2) {
621 : dl 1.8 assertTrue(q.removeFirstOccurrence(new Integer(i)));
622 :     assertFalse(q.removeFirstOccurrence(new Integer(i+1)));
623 :     }
624 :     assertTrue(q.isEmpty());
625 :     }
626 :    
627 :     /**
628 :     * removeLastOccurrence(x) removes x and returns true if present
629 :     */
630 :     public void testRemoveLastOccurrence() {
631 :     LinkedList q = populatedQueue(SIZE);
632 : jsr166 1.33 for (int i = 1; i < SIZE; i += 2) {
633 : dl 1.8 assertTrue(q.removeLastOccurrence(new Integer(i)));
634 :     }
635 : jsr166 1.33 for (int i = 0; i < SIZE; i += 2) {
636 : dl 1.8 assertTrue(q.removeLastOccurrence(new Integer(i)));
637 :     assertFalse(q.removeLastOccurrence(new Integer(i+1)));
638 :     }
639 :     assertTrue(q.isEmpty());
640 :     }
641 :    
642 : dl 1.1 }

Doug Lea
ViewVC Help
Powered by ViewVC 1.0.8