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

Doug Lea
ViewVC Help
Powered by ViewVC 1.0.8