| 4 |
|
* http://creativecommons.org/publicdomain/zero/1.0/ |
| 5 |
|
*/ |
| 6 |
|
|
| 7 |
– |
import junit.framework.*; |
| 7 |
|
import java.util.Arrays; |
| 8 |
|
import java.util.BitSet; |
| 9 |
|
import java.util.Collection; |
| 16 |
|
import java.util.SortedSet; |
| 17 |
|
import java.util.concurrent.ConcurrentSkipListSet; |
| 18 |
|
|
| 19 |
+ |
import junit.framework.Test; |
| 20 |
+ |
import junit.framework.TestSuite; |
| 21 |
+ |
|
| 22 |
|
public class ConcurrentSkipListSetTest extends JSR166TestCase { |
| 23 |
|
public static void main(String[] args) { |
| 24 |
|
junit.textui.TestRunner.run(suite()); |
| 34 |
|
} |
| 35 |
|
|
| 36 |
|
/** |
| 37 |
< |
* Create a set of given size containing consecutive |
| 37 |
> |
* Returns a new set of given size containing consecutive |
| 38 |
|
* Integers 0 ... n. |
| 39 |
|
*/ |
| 40 |
|
private ConcurrentSkipListSet<Integer> populatedSet(int n) { |
| 41 |
|
ConcurrentSkipListSet<Integer> q = |
| 42 |
|
new ConcurrentSkipListSet<Integer>(); |
| 43 |
|
assertTrue(q.isEmpty()); |
| 44 |
< |
for (int i = n-1; i >= 0; i-=2) |
| 44 |
> |
for (int i = n-1; i >= 0; i -= 2) |
| 45 |
|
assertTrue(q.add(new Integer(i))); |
| 46 |
< |
for (int i = (n & 1); i < n; i+=2) |
| 46 |
> |
for (int i = (n & 1); i < n; i += 2) |
| 47 |
|
assertTrue(q.add(new Integer(i))); |
| 48 |
|
assertFalse(q.isEmpty()); |
| 49 |
|
assertEquals(n, q.size()); |
| 51 |
|
} |
| 52 |
|
|
| 53 |
|
/** |
| 54 |
< |
* Create set of first 5 ints |
| 54 |
> |
* Returns a new set of first 5 ints. |
| 55 |
|
*/ |
| 56 |
|
private ConcurrentSkipListSet set5() { |
| 57 |
|
ConcurrentSkipListSet q = new ConcurrentSkipListSet(); |
| 284 |
|
*/ |
| 285 |
|
public void testRemoveElement() { |
| 286 |
|
ConcurrentSkipListSet q = populatedSet(SIZE); |
| 287 |
< |
for (int i = 1; i < SIZE; i+=2) { |
| 287 |
> |
for (int i = 1; i < SIZE; i += 2) { |
| 288 |
|
assertTrue(q.contains(i)); |
| 289 |
|
assertTrue(q.remove(i)); |
| 290 |
|
assertFalse(q.contains(i)); |
| 291 |
|
assertTrue(q.contains(i-1)); |
| 292 |
|
} |
| 293 |
< |
for (int i = 0; i < SIZE; i+=2) { |
| 293 |
> |
for (int i = 0; i < SIZE; i += 2) { |
| 294 |
|
assertTrue(q.contains(i)); |
| 295 |
|
assertTrue(q.remove(i)); |
| 296 |
|
assertFalse(q.contains(i)); |
| 369 |
|
assertTrue(q.removeAll(p)); |
| 370 |
|
assertEquals(SIZE-i, q.size()); |
| 371 |
|
for (int j = 0; j < i; ++j) { |
| 372 |
< |
Integer I = (Integer)(p.pollFirst()); |
| 373 |
< |
assertFalse(q.contains(I)); |
| 372 |
> |
Integer x = (Integer)(p.pollFirst()); |
| 373 |
> |
assertFalse(q.contains(x)); |
| 374 |
|
} |
| 375 |
|
} |
| 376 |
|
} |
| 463 |
|
public void testToArray2() { |
| 464 |
|
ConcurrentSkipListSet<Integer> q = populatedSet(SIZE); |
| 465 |
|
Integer[] ints = new Integer[SIZE]; |
| 466 |
< |
Integer[] array = q.toArray(ints); |
| 465 |
< |
assertSame(ints, array); |
| 466 |
> |
assertSame(ints, q.toArray(ints)); |
| 467 |
|
for (int i = 0; i < ints.length; i++) |
| 468 |
|
assertSame(ints[i], q.pollFirst()); |
| 469 |
|
} |
| 473 |
|
*/ |
| 474 |
|
public void testIterator() { |
| 475 |
|
ConcurrentSkipListSet q = populatedSet(SIZE); |
| 475 |
– |
int i = 0; |
| 476 |
|
Iterator it = q.iterator(); |
| 477 |
< |
while (it.hasNext()) { |
| 477 |
> |
int i; |
| 478 |
> |
for (i = 0; it.hasNext(); i++) |
| 479 |
|
assertTrue(q.contains(it.next())); |
| 479 |
– |
++i; |
| 480 |
– |
} |
| 480 |
|
assertEquals(i, SIZE); |
| 481 |
+ |
assertIteratorExhausted(it); |
| 482 |
|
} |
| 483 |
|
|
| 484 |
|
/** |
| 485 |
|
* iterator of empty set has no elements |
| 486 |
|
*/ |
| 487 |
|
public void testEmptyIterator() { |
| 488 |
< |
ConcurrentSkipListSet q = new ConcurrentSkipListSet(); |
| 489 |
< |
int i = 0; |
| 490 |
< |
Iterator it = q.iterator(); |
| 491 |
< |
while (it.hasNext()) { |
| 492 |
< |
assertTrue(q.contains(it.next())); |
| 493 |
< |
++i; |
| 494 |
< |
} |
| 495 |
< |
assertEquals(i, 0); |
| 488 |
> |
NavigableSet s = new ConcurrentSkipListSet(); |
| 489 |
> |
assertIteratorExhausted(s.iterator()); |
| 490 |
> |
assertIteratorExhausted(s.descendingSet().iterator()); |
| 491 |
|
} |
| 492 |
|
|
| 493 |
|
/** |
| 527 |
|
NavigableSet x = populatedSet(SIZE); |
| 528 |
|
NavigableSet y = serialClone(x); |
| 529 |
|
|
| 530 |
< |
assertTrue(x != y); |
| 530 |
> |
assertNotSame(x, y); |
| 531 |
|
assertEquals(x.size(), y.size()); |
| 532 |
|
assertEquals(x, y); |
| 533 |
|
assertEquals(y, x); |
| 681 |
|
0, setSize - 1, true, bs); |
| 682 |
|
} |
| 683 |
|
|
| 684 |
+ |
/** |
| 685 |
+ |
* addAll is idempotent |
| 686 |
+ |
*/ |
| 687 |
+ |
public void testAddAll_idempotent() throws Exception { |
| 688 |
+ |
Set x = populatedSet(SIZE); |
| 689 |
+ |
Set y = new ConcurrentSkipListSet(x); |
| 690 |
+ |
y.addAll(x); |
| 691 |
+ |
assertEquals(x, y); |
| 692 |
+ |
assertEquals(y, x); |
| 693 |
+ |
} |
| 694 |
+ |
|
| 695 |
|
static NavigableSet<Integer> newSet(Class cl) throws Exception { |
| 696 |
|
NavigableSet<Integer> result = (NavigableSet<Integer>) cl.newInstance(); |
| 697 |
< |
assertEquals(result.size(), 0); |
| 697 |
> |
assertEquals(0, result.size()); |
| 698 |
|
assertFalse(result.iterator().hasNext()); |
| 699 |
|
return result; |
| 700 |
|
} |
| 726 |
|
// Add entries till we're back to original size |
| 727 |
|
while (set.size() < size) { |
| 728 |
|
int element = min + rnd.nextInt(rangeSize); |
| 729 |
< |
assertTrue(element >= min && element<= max); |
| 729 |
> |
assertTrue(element >= min && element <= max); |
| 730 |
|
put(set, element, bs); |
| 731 |
|
} |
| 732 |
|
} |
| 752 |
|
// Add entries till we're back to original size |
| 753 |
|
while (set.size() < size) { |
| 754 |
|
int element = min - 5 + rnd.nextInt(rangeSize + 10); |
| 755 |
< |
if (element >= min && element<= max) { |
| 755 |
> |
if (element >= min && element <= max) { |
| 756 |
|
put(set, element, bs); |
| 757 |
|
} else { |
| 758 |
|
try { |
| 928 |
|
if (bsContainsI) |
| 929 |
|
size++; |
| 930 |
|
} |
| 931 |
< |
assertEquals(set.size(), size); |
| 931 |
> |
assertEquals(size, set.size()); |
| 932 |
|
|
| 933 |
|
// Test contents using contains elementSet iterator |
| 934 |
|
int size2 = 0; |
