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

Doug Lea
ViewVC Help
Powered by ViewVC 1.0.8