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