[cvs] / jsr166 / src / test / tck / ArrayDequeTest.java Repository:
ViewVC logotype

Annotation of /jsr166/src/test/tck/ArrayDequeTest.java

Parent Directory Parent Directory | Revision Log Revision Log


Revision 1.10 - (view) (download)

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

Doug Lea
ViewVC Help
Powered by ViewVC 1.0.8