[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.27 - (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 : jsr166 1.22 * http://creativecommons.org/publicdomain/zero/1.0/
5 : dl 1.1 */
6 :    
7 :     import junit.framework.*;
8 : jsr166 1.24 import java.util.Arrays;
9 :     import java.util.ArrayDeque;
10 :     import java.util.Collection;
11 :     import java.util.Deque;
12 :     import java.util.Iterator;
13 :     import java.util.NoSuchElementException;
14 :     import java.util.Queue;
15 :     import java.util.Random;
16 : dl 1.1
17 :     public class ArrayDequeTest extends JSR166TestCase {
18 :     public static void main(String[] args) {
19 : jsr166 1.16 junit.textui.TestRunner.run(suite());
20 : dl 1.1 }
21 :    
22 :     public static Test suite() {
23 : jsr166 1.8 return new TestSuite(ArrayDequeTest.class);
24 : dl 1.1 }
25 :    
26 :     /**
27 : jsr166 1.26 * Returns a new deque of given size containing consecutive
28 : dl 1.1 * Integers 0 ... n.
29 :     */
30 : jsr166 1.20 private ArrayDeque<Integer> populatedDeque(int n) {
31 :     ArrayDeque<Integer> q = new ArrayDeque<Integer>();
32 : dl 1.1 assertTrue(q.isEmpty());
33 : jsr166 1.8 for (int i = 0; i < n; ++i)
34 :     assertTrue(q.offerLast(new Integer(i)));
35 : dl 1.1 assertFalse(q.isEmpty());
36 : jsr166 1.8 assertEquals(n, q.size());
37 : dl 1.1 return q;
38 :     }
39 : jsr166 1.5
40 : dl 1.1 /**
41 : jsr166 1.16 * new deque is empty
42 : dl 1.1 */
43 :     public void testConstructor1() {
44 :     assertEquals(0, new ArrayDeque().size());
45 :     }
46 :    
47 :     /**
48 :     * Initializing from null Collection throws NPE
49 :     */
50 :     public void testConstructor3() {
51 :     try {
52 :     ArrayDeque q = new ArrayDeque((Collection)null);
53 :     shouldThrow();
54 : jsr166 1.9 } catch (NullPointerException success) {}
55 : dl 1.1 }
56 :    
57 :     /**
58 : jsr166 1.16 * Initializing from Collection of null elements throws NPE
59 :     */
60 :     public void testConstructor4() {
61 :     try {
62 :     Integer[] ints = new Integer[SIZE];
63 :     ArrayDeque q = new ArrayDeque(Arrays.asList(ints));
64 :     shouldThrow();
65 :     } catch (NullPointerException success) {}
66 :     }
67 : dl 1.1
68 : jsr166 1.16 /**
69 :     * Initializing from Collection with some null elements throws NPE
70 :     */
71 :     public void testConstructor5() {
72 :     try {
73 :     Integer[] ints = new Integer[SIZE];
74 :     for (int i = 0; i < SIZE-1; ++i)
75 :     ints[i] = new Integer(i);
76 :     ArrayDeque q = new ArrayDeque(Arrays.asList(ints));
77 :     shouldThrow();
78 :     } catch (NullPointerException success) {}
79 :     }
80 :    
81 :     /**
82 :     * Deque contains all elements of collection used to initialize
83 : dl 1.1 */
84 :     public void testConstructor6() {
85 : jsr166 1.9 Integer[] ints = new Integer[SIZE];
86 :     for (int i = 0; i < SIZE; ++i)
87 :     ints[i] = new Integer(i);
88 :     ArrayDeque q = new ArrayDeque(Arrays.asList(ints));
89 :     for (int i = 0; i < SIZE; ++i)
90 :     assertEquals(ints[i], q.pollFirst());
91 : dl 1.1 }
92 :    
93 :     /**
94 :     * isEmpty is true before add, false after
95 :     */
96 :     public void testEmpty() {
97 :     ArrayDeque q = new ArrayDeque();
98 :     assertTrue(q.isEmpty());
99 :     q.add(new Integer(1));
100 :     assertFalse(q.isEmpty());
101 :     q.add(new Integer(2));
102 :     q.removeFirst();
103 :     q.removeFirst();
104 :     assertTrue(q.isEmpty());
105 :     }
106 :    
107 :     /**
108 :     * size changes when elements added and removed
109 :     */
110 :     public void testSize() {
111 :     ArrayDeque q = populatedDeque(SIZE);
112 :     for (int i = 0; i < SIZE; ++i) {
113 :     assertEquals(SIZE-i, q.size());
114 :     q.removeFirst();
115 :     }
116 :     for (int i = 0; i < SIZE; ++i) {
117 :     assertEquals(i, q.size());
118 :     q.add(new Integer(i));
119 :     }
120 :     }
121 :    
122 :     /**
123 :     * push(null) throws NPE
124 :     */
125 :     public void testPushNull() {
126 : jsr166 1.8 try {
127 : dl 1.1 ArrayDeque q = new ArrayDeque(1);
128 :     q.push(null);
129 :     shouldThrow();
130 : jsr166 1.9 } catch (NullPointerException success) {}
131 : dl 1.1 }
132 :    
133 :     /**
134 : jsr166 1.16 * peekFirst() returns element inserted with push
135 : dl 1.1 */
136 :     public void testPush() {
137 :     ArrayDeque q = populatedDeque(3);
138 :     q.pollLast();
139 : jsr166 1.8 q.push(four);
140 : jsr166 1.12 assertSame(four, q.peekFirst());
141 : jsr166 1.5 }
142 : dl 1.1
143 :     /**
144 : jsr166 1.16 * pop() removes next element, or throws NSEE if empty
145 : dl 1.1 */
146 :     public void testPop() {
147 :     ArrayDeque q = populatedDeque(SIZE);
148 :     for (int i = 0; i < SIZE; ++i) {
149 : jsr166 1.12 assertEquals(i, q.pop());
150 : dl 1.1 }
151 :     try {
152 :     q.pop();
153 :     shouldThrow();
154 : jsr166 1.9 } catch (NoSuchElementException success) {}
155 : dl 1.1 }
156 :    
157 :     /**
158 :     * offer(null) throws NPE
159 :     */
160 : jsr166 1.16 public void testOfferNull() {
161 :     try {
162 :     ArrayDeque q = new ArrayDeque();
163 :     q.offer(null);
164 :     shouldThrow();
165 :     } catch (NullPointerException success) {}
166 :     }
167 :    
168 :     /**
169 :     * offerFirst(null) throws NPE
170 :     */
171 : dl 1.1 public void testOfferFirstNull() {
172 : jsr166 1.8 try {
173 : dl 1.1 ArrayDeque q = new ArrayDeque();
174 :     q.offerFirst(null);
175 :     shouldThrow();
176 : jsr166 1.9 } catch (NullPointerException success) {}
177 : dl 1.1 }
178 :    
179 :     /**
180 : jsr166 1.16 * offerLast(null) throws NPE
181 :     */
182 :     public void testOfferLastNull() {
183 :     try {
184 :     ArrayDeque q = new ArrayDeque();
185 :     q.offerLast(null);
186 :     shouldThrow();
187 :     } catch (NullPointerException success) {}
188 :     }
189 :    
190 :     /**
191 :     * offer(x) succeeds
192 :     */
193 :     public void testOffer() {
194 :     ArrayDeque q = new ArrayDeque();
195 :     assertTrue(q.offer(zero));
196 :     assertTrue(q.offer(one));
197 :     assertSame(zero, q.peekFirst());
198 :     assertSame(one, q.peekLast());
199 :     }
200 :    
201 :     /**
202 :     * offerFirst(x) succeeds
203 : dl 1.1 */
204 :     public void testOfferFirst() {
205 :     ArrayDeque q = new ArrayDeque();
206 : jsr166 1.16 assertTrue(q.offerFirst(zero));
207 :     assertTrue(q.offerFirst(one));
208 :     assertSame(one, q.peekFirst());
209 :     assertSame(zero, q.peekLast());
210 : dl 1.1 }
211 :    
212 :     /**
213 : jsr166 1.16 * offerLast(x) succeeds
214 : dl 1.1 */
215 :     public void testOfferLast() {
216 :     ArrayDeque q = new ArrayDeque();
217 : jsr166 1.16 assertTrue(q.offerLast(zero));
218 :     assertTrue(q.offerLast(one));
219 :     assertSame(zero, q.peekFirst());
220 :     assertSame(one, q.peekLast());
221 : dl 1.1 }
222 :    
223 :     /**
224 : jsr166 1.16 * add(null) throws NPE
225 :     */
226 :     public void testAddNull() {
227 :     try {
228 :     ArrayDeque q = new ArrayDeque();
229 :     q.add(null);
230 :     shouldThrow();
231 :     } catch (NullPointerException success) {}
232 :     }
233 :    
234 :     /**
235 :     * addFirst(null) throws NPE
236 :     */
237 :     public void testAddFirstNull() {
238 :     try {
239 :     ArrayDeque q = new ArrayDeque();
240 :     q.addFirst(null);
241 :     shouldThrow();
242 :     } catch (NullPointerException success) {}
243 :     }
244 :    
245 :     /**
246 :     * addLast(null) throws NPE
247 :     */
248 :     public void testAddLastNull() {
249 :     try {
250 :     ArrayDeque q = new ArrayDeque();
251 :     q.addLast(null);
252 :     shouldThrow();
253 :     } catch (NullPointerException success) {}
254 :     }
255 :    
256 :     /**
257 :     * add(x) succeeds
258 : dl 1.1 */
259 :     public void testAdd() {
260 :     ArrayDeque q = new ArrayDeque();
261 : jsr166 1.16 assertTrue(q.add(zero));
262 :     assertTrue(q.add(one));
263 :     assertSame(zero, q.peekFirst());
264 :     assertSame(one, q.peekLast());
265 :     }
266 :    
267 :     /**
268 :     * addFirst(x) succeeds
269 :     */
270 :     public void testAddFirst() {
271 :     ArrayDeque q = new ArrayDeque();
272 :     q.addFirst(zero);
273 :     q.addFirst(one);
274 :     assertSame(one, q.peekFirst());
275 :     assertSame(zero, q.peekLast());
276 :     }
277 :    
278 :     /**
279 :     * addLast(x) succeeds
280 :     */
281 :     public void testAddLast() {
282 :     ArrayDeque q = new ArrayDeque();
283 :     q.addLast(zero);
284 :     q.addLast(one);
285 :     assertSame(zero, q.peekFirst());
286 :     assertSame(one, q.peekLast());
287 : dl 1.1 }
288 :    
289 :     /**
290 :     * addAll(null) throws NPE
291 :     */
292 :     public void testAddAll1() {
293 :     try {
294 :     ArrayDeque q = new ArrayDeque();
295 :     q.addAll(null);
296 :     shouldThrow();
297 : jsr166 1.9 } catch (NullPointerException success) {}
298 : dl 1.1 }
299 :    
300 :     /**
301 : jsr166 1.16 * addAll of a collection with null elements throws NPE
302 :     */
303 :     public void testAddAll2() {
304 :     try {
305 :     ArrayDeque q = new ArrayDeque();
306 :     Integer[] ints = new Integer[SIZE];
307 :     q.addAll(Arrays.asList(ints));
308 :     shouldThrow();
309 :     } catch (NullPointerException success) {}
310 :     }
311 :    
312 :     /**
313 :     * addAll of a collection with any null elements throws NPE after
314 :     * possibly adding some elements
315 :     */
316 :     public void testAddAll3() {
317 :     try {
318 :     ArrayDeque q = new ArrayDeque();
319 :     Integer[] ints = new Integer[SIZE];
320 :     for (int i = 0; i < SIZE-1; ++i)
321 :     ints[i] = new Integer(i);
322 :     q.addAll(Arrays.asList(ints));
323 :     shouldThrow();
324 :     } catch (NullPointerException success) {}
325 :     }
326 :    
327 :     /**
328 :     * Deque contains all elements, in traversal order, of successful addAll
329 : dl 1.1 */
330 :     public void testAddAll5() {
331 : jsr166 1.10 Integer[] empty = new Integer[0];
332 :     Integer[] ints = new Integer[SIZE];
333 :     for (int i = 0; i < SIZE; ++i)
334 :     ints[i] = new Integer(i);
335 :     ArrayDeque q = new ArrayDeque();
336 :     assertFalse(q.addAll(Arrays.asList(empty)));
337 :     assertTrue(q.addAll(Arrays.asList(ints)));
338 :     for (int i = 0; i < SIZE; ++i)
339 :     assertEquals(ints[i], q.pollFirst());
340 : dl 1.1 }
341 :    
342 :     /**
343 : jsr166 1.16 * pollFirst() succeeds unless empty
344 : dl 1.1 */
345 :     public void testPollFirst() {
346 :     ArrayDeque q = populatedDeque(SIZE);
347 :     for (int i = 0; i < SIZE; ++i) {
348 : jsr166 1.12 assertEquals(i, q.pollFirst());
349 : dl 1.1 }
350 : jsr166 1.8 assertNull(q.pollFirst());
351 : dl 1.1 }
352 :    
353 :     /**
354 : jsr166 1.16 * pollLast() succeeds unless empty
355 : dl 1.1 */
356 :     public void testPollLast() {
357 :     ArrayDeque q = populatedDeque(SIZE);
358 :     for (int i = SIZE-1; i >= 0; --i) {
359 : jsr166 1.12 assertEquals(i, q.pollLast());
360 : dl 1.1 }
361 : jsr166 1.8 assertNull(q.pollLast());
362 : dl 1.1 }
363 :    
364 :     /**
365 : jsr166 1.16 * poll() succeeds unless empty
366 : dl 1.1 */
367 :     public void testPoll() {
368 :     ArrayDeque q = populatedDeque(SIZE);
369 :     for (int i = 0; i < SIZE; ++i) {
370 : jsr166 1.12 assertEquals(i, q.poll());
371 : dl 1.1 }
372 : jsr166 1.8 assertNull(q.poll());
373 : dl 1.1 }
374 :    
375 :     /**
376 : jsr166 1.16 * remove() removes next element, or throws NSEE if empty
377 : dl 1.1 */
378 :     public void testRemove() {
379 :     ArrayDeque q = populatedDeque(SIZE);
380 :     for (int i = 0; i < SIZE; ++i) {
381 : jsr166 1.12 assertEquals(i, q.remove());
382 : dl 1.1 }
383 :     try {
384 :     q.remove();
385 :     shouldThrow();
386 : jsr166 1.9 } catch (NoSuchElementException success) {}
387 : dl 1.1 }
388 :    
389 :     /**
390 : jsr166 1.16 * remove(x) removes x and returns true if present
391 :     */
392 :     public void testRemoveElement() {
393 :     ArrayDeque q = populatedDeque(SIZE);
394 :     for (int i = 1; i < SIZE; i+=2) {
395 : jsr166 1.21 assertTrue(q.contains(i));
396 :     assertTrue(q.remove(i));
397 :     assertFalse(q.contains(i));
398 :     assertTrue(q.contains(i-1));
399 : jsr166 1.16 }
400 :     for (int i = 0; i < SIZE; i+=2) {
401 : jsr166 1.21 assertTrue(q.contains(i));
402 :     assertTrue(q.remove(i));
403 :     assertFalse(q.contains(i));
404 :     assertFalse(q.remove(i+1));
405 :     assertFalse(q.contains(i+1));
406 : jsr166 1.16 }
407 :     assertTrue(q.isEmpty());
408 :     }
409 :    
410 :     /**
411 :     * peekFirst() returns next element, or null if empty
412 : dl 1.1 */
413 :     public void testPeekFirst() {
414 :     ArrayDeque q = populatedDeque(SIZE);
415 :     for (int i = 0; i < SIZE; ++i) {
416 : jsr166 1.12 assertEquals(i, q.peekFirst());
417 :     assertEquals(i, q.pollFirst());
418 : dl 1.1 assertTrue(q.peekFirst() == null ||
419 : jsr166 1.12 !q.peekFirst().equals(i));
420 : dl 1.1 }
421 : jsr166 1.8 assertNull(q.peekFirst());
422 : dl 1.1 }
423 :    
424 :     /**
425 : jsr166 1.16 * peek() returns next element, or null if empty
426 : dl 1.1 */
427 :     public void testPeek() {
428 :     ArrayDeque q = populatedDeque(SIZE);
429 :     for (int i = 0; i < SIZE; ++i) {
430 : jsr166 1.12 assertEquals(i, q.peek());
431 :     assertEquals(i, q.poll());
432 : dl 1.1 assertTrue(q.peek() == null ||
433 : jsr166 1.12 !q.peek().equals(i));
434 : dl 1.1 }
435 : jsr166 1.8 assertNull(q.peek());
436 : dl 1.1 }
437 :    
438 :     /**
439 : jsr166 1.16 * peekLast() returns next element, or null if empty
440 : dl 1.1 */
441 :     public void testPeekLast() {
442 :     ArrayDeque q = populatedDeque(SIZE);
443 :     for (int i = SIZE-1; i >= 0; --i) {
444 : jsr166 1.12 assertEquals(i, q.peekLast());
445 :     assertEquals(i, q.pollLast());
446 : dl 1.1 assertTrue(q.peekLast() == null ||
447 : jsr166 1.12 !q.peekLast().equals(i));
448 : dl 1.1 }
449 : jsr166 1.8 assertNull(q.peekLast());
450 : dl 1.1 }
451 :    
452 :     /**
453 : jsr166 1.16 * element() returns first element, or throws NSEE if empty
454 :     */
455 :     public void testElement() {
456 :     ArrayDeque q = populatedDeque(SIZE);
457 :     for (int i = 0; i < SIZE; ++i) {
458 :     assertEquals(i, q.element());
459 :     assertEquals(i, q.poll());
460 :     }
461 :     try {
462 :     q.element();
463 :     shouldThrow();
464 :     } catch (NoSuchElementException success) {}
465 :     }
466 :    
467 :     /**
468 :     * getFirst() returns first element, or throws NSEE if empty
469 : dl 1.1 */
470 :     public void testFirstElement() {
471 :     ArrayDeque q = populatedDeque(SIZE);
472 :     for (int i = 0; i < SIZE; ++i) {
473 : jsr166 1.12 assertEquals(i, q.getFirst());
474 :     assertEquals(i, q.pollFirst());
475 : dl 1.1 }
476 :     try {
477 :     q.getFirst();
478 :     shouldThrow();
479 : jsr166 1.9 } catch (NoSuchElementException success) {}
480 : dl 1.1 }
481 :    
482 :     /**
483 : jsr166 1.16 * getLast() returns last element, or throws NSEE if empty
484 : dl 1.1 */
485 :     public void testLastElement() {
486 :     ArrayDeque q = populatedDeque(SIZE);
487 :     for (int i = SIZE-1; i >= 0; --i) {
488 : jsr166 1.12 assertEquals(i, q.getLast());
489 :     assertEquals(i, q.pollLast());
490 : dl 1.1 }
491 :     try {
492 :     q.getLast();
493 :     shouldThrow();
494 : jsr166 1.9 } catch (NoSuchElementException success) {}
495 : jsr166 1.8 assertNull(q.peekLast());
496 : dl 1.1 }
497 :    
498 :     /**
499 : jsr166 1.16 * removeFirst() removes first element, or throws NSEE if empty
500 : dl 1.1 */
501 :     public void testRemoveFirst() {
502 :     ArrayDeque q = populatedDeque(SIZE);
503 :     for (int i = 0; i < SIZE; ++i) {
504 : jsr166 1.12 assertEquals(i, q.removeFirst());
505 : dl 1.1 }
506 :     try {
507 :     q.removeFirst();
508 :     shouldThrow();
509 : jsr166 1.9 } catch (NoSuchElementException success) {}
510 : jsr166 1.16 assertNull(q.peekFirst());
511 :     }
512 :    
513 :     /**
514 :     * removeLast() removes last element, or throws NSEE if empty
515 :     */
516 :     public void testRemoveLast() {
517 :     ArrayDeque q = populatedDeque(SIZE);
518 :     for (int i = SIZE - 1; i >= 0; --i) {
519 :     assertEquals(i, q.removeLast());
520 :     }
521 :     try {
522 :     q.removeLast();
523 :     shouldThrow();
524 :     } catch (NoSuchElementException success) {}
525 :     assertNull(q.peekLast());
526 : dl 1.1 }
527 :    
528 :     /**
529 :     * removeFirstOccurrence(x) removes x and returns true if present
530 :     */
531 :     public void testRemoveFirstOccurrence() {
532 :     ArrayDeque q = populatedDeque(SIZE);
533 :     for (int i = 1; i < SIZE; i+=2) {
534 :     assertTrue(q.removeFirstOccurrence(new Integer(i)));
535 :     }
536 :     for (int i = 0; i < SIZE; i+=2) {
537 :     assertTrue(q.removeFirstOccurrence(new Integer(i)));
538 :     assertFalse(q.removeFirstOccurrence(new Integer(i+1)));
539 :     }
540 :     assertTrue(q.isEmpty());
541 :     }
542 :    
543 :     /**
544 :     * removeLastOccurrence(x) removes x and returns true if present
545 :     */
546 :     public void testRemoveLastOccurrence() {
547 :     ArrayDeque q = populatedDeque(SIZE);
548 :     for (int i = 1; i < SIZE; i+=2) {
549 :     assertTrue(q.removeLastOccurrence(new Integer(i)));
550 :     }
551 :     for (int i = 0; i < SIZE; i+=2) {
552 :     assertTrue(q.removeLastOccurrence(new Integer(i)));
553 :     assertFalse(q.removeLastOccurrence(new Integer(i+1)));
554 :     }
555 :     assertTrue(q.isEmpty());
556 :     }
557 :    
558 :     /**
559 :     * contains(x) reports true when elements added but not yet removed
560 :     */
561 :     public void testContains() {
562 :     ArrayDeque q = populatedDeque(SIZE);
563 :     for (int i = 0; i < SIZE; ++i) {
564 :     assertTrue(q.contains(new Integer(i)));
565 : jsr166 1.12 assertEquals(i, q.pollFirst());
566 : dl 1.1 assertFalse(q.contains(new Integer(i)));
567 :     }
568 :     }
569 :    
570 :     /**
571 :     * clear removes all elements
572 :     */
573 :     public void testClear() {
574 :     ArrayDeque q = populatedDeque(SIZE);
575 :     q.clear();
576 :     assertTrue(q.isEmpty());
577 :     assertEquals(0, q.size());
578 : jsr166 1.12 assertTrue(q.add(new Integer(1)));
579 : dl 1.1 assertFalse(q.isEmpty());
580 :     q.clear();
581 :     assertTrue(q.isEmpty());
582 :     }
583 :    
584 :     /**
585 :     * containsAll(c) is true when c contains a subset of elements
586 :     */
587 :     public void testContainsAll() {
588 :     ArrayDeque q = populatedDeque(SIZE);
589 :     ArrayDeque p = new ArrayDeque();
590 :     for (int i = 0; i < SIZE; ++i) {
591 :     assertTrue(q.containsAll(p));
592 :     assertFalse(p.containsAll(q));
593 : jsr166 1.12 assertTrue(p.add(new Integer(i)));
594 : dl 1.1 }
595 :     assertTrue(p.containsAll(q));
596 :     }
597 :    
598 :     /**
599 :     * retainAll(c) retains only those elements of c and reports true if changed
600 :     */
601 :     public void testRetainAll() {
602 :     ArrayDeque q = populatedDeque(SIZE);
603 :     ArrayDeque p = populatedDeque(SIZE);
604 :     for (int i = 0; i < SIZE; ++i) {
605 :     boolean changed = q.retainAll(p);
606 : jsr166 1.12 assertEquals(changed, (i > 0));
607 : dl 1.1 assertTrue(q.containsAll(p));
608 :     assertEquals(SIZE-i, q.size());
609 :     p.removeFirst();
610 :     }
611 :     }
612 :    
613 :     /**
614 :     * removeAll(c) removes only those elements of c and reports true if changed
615 :     */
616 :     public void testRemoveAll() {
617 :     for (int i = 1; i < SIZE; ++i) {
618 :     ArrayDeque q = populatedDeque(SIZE);
619 :     ArrayDeque p = populatedDeque(i);
620 :     assertTrue(q.removeAll(p));
621 :     assertEquals(SIZE-i, q.size());
622 :     for (int j = 0; j < i; ++j) {
623 : jsr166 1.12 assertFalse(q.contains(p.removeFirst()));
624 : dl 1.1 }
625 :     }
626 :     }
627 :    
628 : jsr166 1.27 void checkToArray(ArrayDeque q) {
629 :     int size = q.size();
630 :     Object[] o = q.toArray();
631 :     assertEquals(size, o.length);
632 :     Iterator it = q.iterator();
633 :     for (int i = 0; i < size; i++) {
634 :     Integer x = (Integer) it.next();
635 :     assertEquals((Integer)o[0] + i, (int) x);
636 :     assertSame(o[i], x);
637 :     }
638 :     }
639 :    
640 : dl 1.1 /**
641 : jsr166 1.19 * toArray() contains all elements in FIFO order
642 : dl 1.1 */
643 :     public void testToArray() {
644 : jsr166 1.27 ArrayDeque q = new ArrayDeque();
645 :     for (int i = 0; i < SIZE; i++) {
646 :     checkToArray(q);
647 :     q.addLast(i);
648 :     }
649 :     // Provoke wraparound
650 :     for (int i = 0; i < SIZE; i++) {
651 :     checkToArray(q);
652 :     assertEquals(i, q.poll());
653 :     q.addLast(SIZE+i);
654 :     }
655 :     for (int i = 0; i < SIZE; i++) {
656 :     checkToArray(q);
657 :     assertEquals(SIZE+i, q.poll());
658 :     }
659 :     }
660 :    
661 :     void checkToArray2(ArrayDeque q) {
662 :     int size = q.size();
663 :     Integer[] a1 = size == 0 ? null : new Integer[size-1];
664 :     Integer[] a2 = new Integer[size];
665 :     Integer[] a3 = new Integer[size+2];
666 :     if (size > 0) Arrays.fill(a1, 42);
667 :     Arrays.fill(a2, 42);
668 :     Arrays.fill(a3, 42);
669 :     Integer[] b1 = size == 0 ? null : (Integer[]) q.toArray(a1);
670 :     Integer[] b2 = (Integer[]) q.toArray(a2);
671 :     Integer[] b3 = (Integer[]) q.toArray(a3);
672 :     assertSame(a2, b2);
673 :     assertSame(a3, b3);
674 :     Iterator it = q.iterator();
675 :     for (int i = 0; i < size; i++) {
676 :     Integer x = (Integer) it.next();
677 :     assertSame(b1[i], x);
678 :     assertEquals(b1[0] + i, (int) x);
679 :     assertSame(b2[i], x);
680 :     assertSame(b3[i], x);
681 :     }
682 :     assertNull(a3[size]);
683 :     assertEquals(42, (int) a3[size+1]);
684 :     if (size > 0) {
685 :     assertNotSame(a1, b1);
686 :     assertEquals(size, b1.length);
687 :     for (int i = 0; i < a1.length; i++) {
688 :     assertEquals(42, (int) a1[i]);
689 :     }
690 :     }
691 : dl 1.1 }
692 :    
693 :     /**
694 : jsr166 1.19 * toArray(a) contains all elements in FIFO order
695 : dl 1.1 */
696 :     public void testToArray2() {
697 : jsr166 1.27 ArrayDeque q = new ArrayDeque();
698 :     for (int i = 0; i < SIZE; i++) {
699 :     checkToArray2(q);
700 :     q.addLast(i);
701 :     }
702 :     // Provoke wraparound
703 :     for (int i = 0; i < SIZE; i++) {
704 :     checkToArray2(q);
705 :     assertEquals(i, q.poll());
706 :     q.addLast(SIZE+i);
707 :     }
708 :     for (int i = 0; i < SIZE; i++) {
709 :     checkToArray2(q);
710 :     assertEquals(SIZE+i, q.poll());
711 :     }
712 : dl 1.1 }
713 :    
714 :     /**
715 : jsr166 1.18 * toArray(null) throws NullPointerException
716 : dl 1.1 */
717 : jsr166 1.18 public void testToArray_NullArg() {
718 : jsr166 1.12 ArrayDeque l = new ArrayDeque();
719 :     l.add(new Object());
720 : jsr166 1.8 try {
721 : jsr166 1.18 l.toArray(null);
722 : jsr166 1.8 shouldThrow();
723 :     } catch (NullPointerException success) {}
724 : dl 1.1 }
725 :    
726 :     /**
727 : jsr166 1.17 * toArray(incompatible array type) throws ArrayStoreException
728 : dl 1.1 */
729 :     public void testToArray1_BadArg() {
730 : jsr166 1.12 ArrayDeque l = new ArrayDeque();
731 :     l.add(new Integer(5));
732 : jsr166 1.8 try {
733 : jsr166 1.17 l.toArray(new String[10]);
734 : jsr166 1.8 shouldThrow();
735 : jsr166 1.9 } catch (ArrayStoreException success) {}
736 : dl 1.1 }
737 : jsr166 1.5
738 : dl 1.1 /**
739 : jsr166 1.16 * Iterator iterates through all elements
740 : dl 1.1 */
741 :     public void testIterator() {
742 :     ArrayDeque q = populatedDeque(SIZE);
743 :     int i = 0;
744 : jsr166 1.8 Iterator it = q.iterator();
745 : jsr166 1.6 while (it.hasNext()) {
746 : dl 1.1 assertTrue(q.contains(it.next()));
747 :     ++i;
748 :     }
749 :     assertEquals(i, SIZE);
750 :     }
751 :    
752 :     /**
753 : jsr166 1.16 * Iterator ordering is FIFO
754 : dl 1.1 */
755 :     public void testIteratorOrdering() {
756 :     final ArrayDeque q = new ArrayDeque();
757 : jsr166 1.16 q.add(one);
758 :     q.add(two);
759 :     q.add(three);
760 : dl 1.1 int k = 0;
761 :     for (Iterator it = q.iterator(); it.hasNext();) {
762 : jsr166 1.12 assertEquals(++k, it.next());
763 : dl 1.1 }
764 :    
765 :     assertEquals(3, k);
766 :     }
767 :    
768 :     /**
769 : jsr166 1.16 * iterator.remove() removes current element
770 : dl 1.1 */
771 : jsr166 1.16 public void testIteratorRemove() {
772 : dl 1.1 final ArrayDeque q = new ArrayDeque();
773 : dl 1.4 final Random rng = new Random();
774 : dl 1.3 for (int iters = 0; iters < 100; ++iters) {
775 : dl 1.4 int max = rng.nextInt(5) + 2;
776 :     int split = rng.nextInt(max-1) + 1;
777 :     for (int j = 1; j <= max; ++j)
778 :     q.add(new Integer(j));
779 : dl 1.3 Iterator it = q.iterator();
780 : jsr166 1.5 for (int j = 1; j <= split; ++j)
781 : dl 1.4 assertEquals(it.next(), new Integer(j));
782 : dl 1.3 it.remove();
783 : dl 1.4 assertEquals(it.next(), new Integer(split+1));
784 : jsr166 1.5 for (int j = 1; j <= split; ++j)
785 : dl 1.4 q.remove(new Integer(j));
786 : dl 1.3 it = q.iterator();
787 : dl 1.4 for (int j = split+1; j <= max; ++j) {
788 :     assertEquals(it.next(), new Integer(j));
789 :     it.remove();
790 :     }
791 : dl 1.3 assertFalse(it.hasNext());
792 : dl 1.4 assertTrue(q.isEmpty());
793 : dl 1.3 }
794 : dl 1.1 }
795 :    
796 : dl 1.2 /**
797 : jsr166 1.16 * Descending iterator iterates through all elements
798 : dl 1.2 */
799 :     public void testDescendingIterator() {
800 :     ArrayDeque q = populatedDeque(SIZE);
801 :     int i = 0;
802 : jsr166 1.8 Iterator it = q.descendingIterator();
803 : jsr166 1.6 while (it.hasNext()) {
804 : dl 1.2 assertTrue(q.contains(it.next()));
805 :     ++i;
806 :     }
807 :     assertEquals(i, SIZE);
808 :     assertFalse(it.hasNext());
809 :     try {
810 :     it.next();
811 : jsr166 1.11 shouldThrow();
812 : jsr166 1.9 } catch (NoSuchElementException success) {}
813 : dl 1.2 }
814 :    
815 :     /**
816 : jsr166 1.16 * Descending iterator ordering is reverse FIFO
817 : dl 1.2 */
818 :     public void testDescendingIteratorOrdering() {
819 :     final ArrayDeque q = new ArrayDeque();
820 : dl 1.3 for (int iters = 0; iters < 100; ++iters) {
821 :     q.add(new Integer(3));
822 :     q.add(new Integer(2));
823 :     q.add(new Integer(1));
824 :     int k = 0;
825 :     for (Iterator it = q.descendingIterator(); it.hasNext();) {
826 : jsr166 1.12 assertEquals(++k, it.next());
827 : dl 1.3 }
828 : jsr166 1.5
829 : dl 1.3 assertEquals(3, k);
830 :     q.remove();
831 :     q.remove();
832 :     q.remove();
833 : dl 1.2 }
834 :     }
835 :    
836 :     /**
837 : jsr166 1.16 * descendingIterator.remove() removes current element
838 : dl 1.2 */
839 : jsr166 1.16 public void testDescendingIteratorRemove() {
840 : dl 1.2 final ArrayDeque q = new ArrayDeque();
841 : dl 1.4 final Random rng = new Random();
842 : dl 1.3 for (int iters = 0; iters < 100; ++iters) {
843 : dl 1.4 int max = rng.nextInt(5) + 2;
844 :     int split = rng.nextInt(max-1) + 1;
845 :     for (int j = max; j >= 1; --j)
846 :     q.add(new Integer(j));
847 : dl 1.3 Iterator it = q.descendingIterator();
848 : jsr166 1.5 for (int j = 1; j <= split; ++j)
849 : dl 1.4 assertEquals(it.next(), new Integer(j));
850 : dl 1.3 it.remove();
851 : dl 1.4 assertEquals(it.next(), new Integer(split+1));
852 : jsr166 1.5 for (int j = 1; j <= split; ++j)
853 : dl 1.4 q.remove(new Integer(j));
854 : dl 1.3 it = q.descendingIterator();
855 : dl 1.4 for (int j = split+1; j <= max; ++j) {
856 :     assertEquals(it.next(), new Integer(j));
857 :     it.remove();
858 :     }
859 : dl 1.3 assertFalse(it.hasNext());
860 : dl 1.4 assertTrue(q.isEmpty());
861 : dl 1.3 }
862 : dl 1.2 }
863 :    
864 : dl 1.1 /**
865 : jsr166 1.16 * toString() contains toStrings of elements
866 : dl 1.1 */
867 :     public void testToString() {
868 :     ArrayDeque q = populatedDeque(SIZE);
869 :     String s = q.toString();
870 :     for (int i = 0; i < SIZE; ++i) {
871 : jsr166 1.23 assertTrue(s.contains(String.valueOf(i)));
872 : dl 1.1 }
873 : jsr166 1.5 }
874 : dl 1.1
875 :     /**
876 : jsr166 1.16 * A deserialized serialized deque has same elements in same order
877 : dl 1.1 */
878 : jsr166 1.16 public void testSerialization() throws Exception {
879 : jsr166 1.24 Queue x = populatedDeque(SIZE);
880 :     Queue y = serialClone(x);
881 :    
882 :     assertTrue(x != y);
883 :     assertEquals(x.size(), y.size());
884 :     assertEquals(x.toString(), y.toString());
885 :     assertTrue(Arrays.equals(x.toArray(), y.toArray()));
886 :     while (!x.isEmpty()) {
887 :     assertFalse(y.isEmpty());
888 :     assertEquals(x.remove(), y.remove());
889 :     }
890 :     assertTrue(y.isEmpty());
891 : jsr166 1.5 }
892 : dl 1.1
893 :     }

Doug Lea
ViewVC Help
Powered by ViewVC 1.0.8