1 |
/* |
/* |
2 |
* Written by Doug Lea with assistance from members of JCP JSR-166 |
* Written by Doug Lea with assistance from members of JCP JSR-166 |
3 |
* Expert Group and released to the public domain, as explained at |
* Expert Group and released to the public domain, as explained at |
4 |
* http://creativecommons.org/licenses/publicdomain |
* http://creativecommons.org/publicdomain/zero/1.0/ |
5 |
* Other contributors include Andrew Wright, Jeffrey Hayes, |
* Other contributors include Andrew Wright, Jeffrey Hayes, |
6 |
* Pat Fisher, Mike Judd. |
* Pat Fisher, Mike Judd. |
7 |
*/ |
*/ |
8 |
|
|
9 |
import junit.framework.*; |
import junit.framework.*; |
10 |
import java.util.*; |
import java.util.Arrays; |
11 |
import java.util.concurrent.*; |
import java.util.Collection; |
12 |
|
import java.util.Iterator; |
13 |
|
import java.util.LinkedList; |
14 |
|
import java.util.NoSuchElementException; |
15 |
|
|
16 |
public class LinkedListTest extends JSR166TestCase { |
public class LinkedListTest extends JSR166TestCase { |
17 |
public static void main(String[] args) { |
public static void main(String[] args) { |
26 |
* Create a queue of given size containing consecutive |
* Create a queue of given size containing consecutive |
27 |
* Integers 0 ... n. |
* Integers 0 ... n. |
28 |
*/ |
*/ |
29 |
private LinkedList populatedQueue(int n) { |
private LinkedList<Integer> populatedQueue(int n) { |
30 |
LinkedList q = new LinkedList(); |
LinkedList<Integer> q = new LinkedList<Integer>(); |
31 |
assertTrue(q.isEmpty()); |
assertTrue(q.isEmpty()); |
32 |
for (int i = 0; i < n; ++i) |
for (int i = 0; i < n; ++i) |
33 |
assertTrue(q.offer(new Integer(i))); |
assertTrue(q.offer(new Integer(i))); |
236 |
public void testRemoveElement() { |
public void testRemoveElement() { |
237 |
LinkedList q = populatedQueue(SIZE); |
LinkedList q = populatedQueue(SIZE); |
238 |
for (int i = 1; i < SIZE; i+=2) { |
for (int i = 1; i < SIZE; i+=2) { |
239 |
assertTrue(q.remove(new Integer(i))); |
assertTrue(q.contains(i)); |
240 |
|
assertTrue(q.remove((Integer)i)); |
241 |
|
assertFalse(q.contains(i)); |
242 |
|
assertTrue(q.contains(i-1)); |
243 |
} |
} |
244 |
for (int i = 0; i < SIZE; i+=2) { |
for (int i = 0; i < SIZE; i+=2) { |
245 |
assertTrue(q.remove(new Integer(i))); |
assertTrue(q.contains(i)); |
246 |
assertFalse(q.remove(new Integer(i+1))); |
assertTrue(q.remove((Integer)i)); |
247 |
|
assertFalse(q.contains(i)); |
248 |
|
assertFalse(q.remove((Integer)(i+1))); |
249 |
|
assertFalse(q.contains(i+1)); |
250 |
} |
} |
251 |
assertTrue(q.isEmpty()); |
assertTrue(q.isEmpty()); |
252 |
} |
} |
327 |
} |
} |
328 |
|
|
329 |
/** |
/** |
330 |
* toArray contains all elements |
* toArray contains all elements in FIFO order |
331 |
*/ |
*/ |
332 |
public void testToArray() { |
public void testToArray() { |
333 |
LinkedList q = populatedQueue(SIZE); |
LinkedList q = populatedQueue(SIZE); |
334 |
Object[] o = q.toArray(); |
Object[] o = q.toArray(); |
|
Arrays.sort(o); |
|
335 |
for (int i = 0; i < o.length; i++) |
for (int i = 0; i < o.length; i++) |
336 |
assertEquals(o[i], q.poll()); |
assertSame(o[i], q.poll()); |
337 |
} |
} |
338 |
|
|
339 |
/** |
/** |
340 |
* toArray(a) contains all elements |
* toArray(a) contains all elements in FIFO order |
341 |
*/ |
*/ |
342 |
public void testToArray2() { |
public void testToArray2() { |
343 |
LinkedList q = populatedQueue(SIZE); |
LinkedList<Integer> q = populatedQueue(SIZE); |
344 |
Integer[] ints = new Integer[SIZE]; |
Integer[] ints = new Integer[SIZE]; |
345 |
ints = (Integer[])q.toArray(ints); |
Integer[] array = q.toArray(ints); |
346 |
Arrays.sort(ints); |
assertSame(ints, array); |
347 |
for (int i = 0; i < ints.length; i++) |
for (int i = 0; i < ints.length; i++) |
348 |
assertEquals(ints[i], q.poll()); |
assertSame(ints[i], q.poll()); |
349 |
} |
} |
350 |
|
|
351 |
/** |
/** |
352 |
* toArray(null) throws NPE |
* toArray(null) throws NullPointerException |
353 |
*/ |
*/ |
354 |
public void testToArray_BadArg() { |
public void testToArray_NullArg() { |
355 |
LinkedList l = new LinkedList(); |
LinkedList l = new LinkedList(); |
356 |
l.add(new Object()); |
l.add(new Object()); |
357 |
try { |
try { |
358 |
Object o[] = l.toArray(null); |
l.toArray(null); |
359 |
shouldThrow(); |
shouldThrow(); |
360 |
} catch (NullPointerException success) {} |
} catch (NullPointerException success) {} |
361 |
} |
} |
362 |
|
|
363 |
/** |
/** |
364 |
* toArray with incompatable aray type throws CCE |
* toArray(incompatible array type) throws ArrayStoreException |
365 |
*/ |
*/ |
366 |
public void testToArray1_BadArg() { |
public void testToArray1_BadArg() { |
367 |
LinkedList l = new LinkedList(); |
LinkedList l = new LinkedList(); |
368 |
l.add(new Integer(5)); |
l.add(new Integer(5)); |
369 |
try { |
try { |
370 |
Object o[] = l.toArray(new String[10]); |
l.toArray(new String[10]); |
371 |
shouldThrow(); |
shouldThrow(); |
372 |
} catch (ArrayStoreException success) {} |
} catch (ArrayStoreException success) {} |
373 |
} |
} |
459 |
*/ |
*/ |
460 |
public void testDescendingIteratorRemove () { |
public void testDescendingIteratorRemove () { |
461 |
final LinkedList q = new LinkedList(); |
final LinkedList q = new LinkedList(); |
462 |
q.add(new Integer(3)); |
q.add(three); |
463 |
q.add(new Integer(2)); |
q.add(two); |
464 |
q.add(new Integer(1)); |
q.add(one); |
465 |
Iterator it = q.descendingIterator(); |
Iterator it = q.descendingIterator(); |
466 |
it.next(); |
it.next(); |
467 |
it.remove(); |
it.remove(); |
468 |
it = q.descendingIterator(); |
it = q.descendingIterator(); |
469 |
assertEquals(it.next(), 2); |
assertSame(it.next(), two); |
470 |
assertEquals(it.next(), 3); |
assertSame(it.next(), three); |
471 |
assertFalse(it.hasNext()); |
assertFalse(it.hasNext()); |
472 |
} |
} |
473 |
|
|
|
|
|
474 |
/** |
/** |
475 |
* toString contains toStrings of elements |
* toString contains toStrings of elements |
476 |
*/ |
*/ |
478 |
LinkedList q = populatedQueue(SIZE); |
LinkedList q = populatedQueue(SIZE); |
479 |
String s = q.toString(); |
String s = q.toString(); |
480 |
for (int i = 0; i < SIZE; ++i) { |
for (int i = 0; i < SIZE; ++i) { |
481 |
assertTrue(s.indexOf(String.valueOf(i)) >= 0); |
assertTrue(s.contains(String.valueOf(i))); |
482 |
} |
} |
483 |
} |
} |
484 |
|
|
488 |
public void testAddFirst() { |
public void testAddFirst() { |
489 |
LinkedList q = populatedQueue(3); |
LinkedList q = populatedQueue(3); |
490 |
q.addFirst(four); |
q.addFirst(four); |
491 |
assertEquals(four,q.peek()); |
assertSame(four, q.peek()); |
492 |
} |
} |
493 |
|
|
494 |
/** |
/** |
496 |
*/ |
*/ |
497 |
public void testPush() { |
public void testPush() { |
498 |
LinkedList q = populatedQueue(3); |
LinkedList q = populatedQueue(3); |
|
q.pollLast(); |
|
499 |
q.push(four); |
q.push(four); |
500 |
assertEquals(four,q.peekFirst()); |
assertSame(four, q.peekFirst()); |
501 |
} |
} |
502 |
|
|
503 |
/** |
/** |
557 |
assertNull(q.peekFirst()); |
assertNull(q.peekFirst()); |
558 |
} |
} |
559 |
|
|
|
|
|
560 |
/** |
/** |
561 |
* peekLast returns next element, or null if empty |
* peekLast returns next element, or null if empty |
562 |
*/ |
*/ |