Update JSR166 tck tests.
The following tests have been omitted because they are
unsupported :
- Atomic8Test.java
- CompletableFutureTest.java
- ConcurrentHashMap8Test.java
- DoubleAccumulatorTest.java
- DoubleAdderTest.java
- ForkJoinPool8Test.java
- ForkJoinTask8Test.java
- LongAccumulatorTest.java
- LongAdderTest.java
- SplittableRandomTest.java
- StampedLockTest.java
- ThreadLocalRandom8Test.java
- ThreadPoolExecutor9Test.java
A package declaration has been added to all files (package jsr166;)
and the base-class JSR166Test has been changed not to rely on features
that aren't available on android / junit in the android environment.
We also avoid using junit4 style TestSuite declarations. While the CTS
test runner handles them properly usually, it trips over itself when it
encounters a failure and tries to run each test in an invidual process
and fails each test for no good reason (needs investigation on the CTS
side of things)
bug: 20628776
(cherry picked from commit 5da8b2b3cac51f0f592a5e1941bd84eade9648cd)
Change-Id: If35be0881ad8da4c604ce6683149b15c1a85f289
diff --git a/jsr166-tests/src/test/java/jsr166/AbstractExecutorServiceTest.java b/jsr166-tests/src/test/java/jsr166/AbstractExecutorServiceTest.java
index ba4cc66..9e83de2 100644
--- a/jsr166-tests/src/test/java/jsr166/AbstractExecutorServiceTest.java
+++ b/jsr166-tests/src/test/java/jsr166/AbstractExecutorServiceTest.java
@@ -8,14 +8,38 @@
package jsr166;
-import junit.framework.*;
-import java.util.*;
-import java.util.concurrent.*;
-import java.util.concurrent.atomic.AtomicBoolean;
import static java.util.concurrent.TimeUnit.MILLISECONDS;
-import java.security.*;
+
+import java.security.PrivilegedAction;
+import java.security.PrivilegedExceptionAction;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import java.util.concurrent.AbstractExecutorService;
+import java.util.concurrent.ArrayBlockingQueue;
+import java.util.concurrent.Callable;
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.Executors;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Future;
+import java.util.concurrent.ThreadPoolExecutor;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicBoolean;
+
+import junit.framework.Test;
+import junit.framework.TestSuite;
public class AbstractExecutorServiceTest extends JSR166TestCase {
+ // android-note: Removed because the CTS runner does a bad job of
+ // retrying tests that have suite() declarations.
+ //
+ // public static void main(String[] args) {
+ // main(suite(), args);
+ // }
+ // public static Test suite() {
+ // return new TestSuite(...);
+ // }
/**
* A no-frills implementation of AbstractExecutorService, designed
@@ -42,11 +66,10 @@
public void testExecuteRunnable() throws Exception {
ExecutorService e = new DirectExecutorService();
final AtomicBoolean done = new AtomicBoolean(false);
- CheckedRunnable task = new CheckedRunnable() {
+ Future<?> future = e.submit(new CheckedRunnable() {
public void realRun() {
done.set(true);
- }};
- Future<?> future = e.submit(task);
+ }});
assertNull(future.get());
assertNull(future.get(0, MILLISECONDS));
assertTrue(done.get());
@@ -149,8 +172,8 @@
* execute(null runnable) throws NPE
*/
public void testExecuteNullRunnable() {
+ ExecutorService e = new DirectExecutorService();
try {
- ExecutorService e = new DirectExecutorService();
e.submit((Runnable) null);
shouldThrow();
} catch (NullPointerException success) {}
@@ -160,8 +183,8 @@
* submit(null callable) throws NPE
*/
public void testSubmitNullCallable() {
+ ExecutorService e = new DirectExecutorService();
try {
- ExecutorService e = new DirectExecutorService();
e.submit((Callable) null);
shouldThrow();
} catch (NullPointerException success) {}
diff --git a/jsr166-tests/src/test/java/jsr166/AbstractQueueTest.java b/jsr166-tests/src/test/java/jsr166/AbstractQueueTest.java
index e74fc3c..2aa7326 100644
--- a/jsr166-tests/src/test/java/jsr166/AbstractQueueTest.java
+++ b/jsr166-tests/src/test/java/jsr166/AbstractQueueTest.java
@@ -8,13 +8,24 @@
package jsr166;
-import junit.framework.*;
import java.util.AbstractQueue;
import java.util.Arrays;
import java.util.Iterator;
import java.util.NoSuchElementException;
+import junit.framework.Test;
+import junit.framework.TestSuite;
+
public class AbstractQueueTest extends JSR166TestCase {
+ // android-note: Removed because the CTS runner does a bad job of
+ // retrying tests that have suite() declarations.
+ //
+ // public static void main(String[] args) {
+ // main(suite(), args);
+ // }
+ // public static Test suite() {
+ // return new TestSuite(...);
+ // }
static class Succeed extends AbstractQueue<Integer> {
public boolean offer(Integer x) {
@@ -110,8 +121,8 @@
* addAll(null) throws NPE
*/
public void testAddAll1() {
+ Succeed q = new Succeed();
try {
- Succeed q = new Succeed();
q.addAll(null);
shouldThrow();
} catch (NullPointerException success) {}
@@ -121,8 +132,8 @@
* addAll(this) throws IAE
*/
public void testAddAllSelf() {
+ Succeed q = new Succeed();
try {
- Succeed q = new Succeed();
q.addAll(q);
shouldThrow();
} catch (IllegalArgumentException success) {}
@@ -132,9 +143,9 @@
* addAll of a collection with null elements throws NPE
*/
public void testAddAll2() {
+ Succeed q = new Succeed();
+ Integer[] ints = new Integer[SIZE];
try {
- Succeed q = new Succeed();
- Integer[] ints = new Integer[SIZE];
q.addAll(Arrays.asList(ints));
shouldThrow();
} catch (NullPointerException success) {}
@@ -145,11 +156,11 @@
* possibly adding some elements
*/
public void testAddAll3() {
+ Succeed q = new Succeed();
+ Integer[] ints = new Integer[SIZE];
+ for (int i = 0; i < SIZE-1; ++i)
+ ints[i] = new Integer(i);
try {
- Succeed q = new Succeed();
- Integer[] ints = new Integer[SIZE];
- for (int i = 0; i < SIZE-1; ++i)
- ints[i] = new Integer(i);
q.addAll(Arrays.asList(ints));
shouldThrow();
} catch (NullPointerException success) {}
@@ -159,11 +170,11 @@
* addAll throws ISE if an add fails
*/
public void testAddAll4() {
+ Fail q = new Fail();
+ Integer[] ints = new Integer[SIZE];
+ for (int i = 0; i < SIZE; ++i)
+ ints[i] = new Integer(i);
try {
- Fail q = new Fail();
- Integer[] ints = new Integer[SIZE];
- for (int i = 0; i < SIZE; ++i)
- ints[i] = new Integer(i);
q.addAll(Arrays.asList(ints));
shouldThrow();
} catch (IllegalStateException success) {}
diff --git a/jsr166-tests/src/test/java/jsr166/AbstractQueuedLongSynchronizerTest.java b/jsr166-tests/src/test/java/jsr166/AbstractQueuedLongSynchronizerTest.java
index d957e61..8604d86 100644
--- a/jsr166-tests/src/test/java/jsr166/AbstractQueuedLongSynchronizerTest.java
+++ b/jsr166-tests/src/test/java/jsr166/AbstractQueuedLongSynchronizerTest.java
@@ -8,13 +8,29 @@
package jsr166;
-import junit.framework.*;
-import java.util.*;
import static java.util.concurrent.TimeUnit.MILLISECONDS;
+import static java.util.concurrent.TimeUnit.NANOSECONDS;
+
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.HashSet;
import java.util.concurrent.locks.AbstractQueuedLongSynchronizer;
import java.util.concurrent.locks.AbstractQueuedLongSynchronizer.ConditionObject;
+import junit.framework.AssertionFailedError;
+import junit.framework.Test;
+import junit.framework.TestSuite;
+
public class AbstractQueuedLongSynchronizerTest extends JSR166TestCase {
+ // android-note: Removed because the CTS runner does a bad job of
+ // retrying tests that have suite() declarations.
+ //
+ // public static void main(String[] args) {
+ // main(suite(), args);
+ // }
+ // public static Test suite() {
+ // return new TestSuite(...);
+ // }
/**
* A simple mutex class, adapted from the class javadoc. Exclusive
@@ -83,7 +99,7 @@
}
public boolean tryReleaseShared(long ignore) {
- setState(1 << 62);
+ setState(1L << 62);
return true;
}
}
@@ -191,7 +207,7 @@
new HashSet<Thread>(Arrays.asList(threads)));
}
- enum AwaitMethod { await, awaitTimed, awaitNanos, awaitUntil };
+ enum AwaitMethod { await, awaitTimed, awaitNanos, awaitUntil }
/**
* Awaits condition using the specified AwaitMethod.
@@ -214,6 +230,8 @@
case awaitUntil:
assertTrue(c.awaitUntil(delayedDate(timeoutMillis)));
break;
+ default:
+ throw new AssertionError();
}
}
@@ -1184,7 +1202,6 @@
public void testTryAcquireSharedNanos_Timeout() {
final BooleanLatch l = new BooleanLatch();
final BooleanLatch observedQueued = new BooleanLatch();
- final long timeoutMillis = timeoutMillis();
Thread t = newStartedThread(new CheckedRunnable() {
public void realRun() throws InterruptedException {
assertFalse(l.isSignalled());
@@ -1206,4 +1223,28 @@
assertFalse(l.isSignalled());
}
+ /**
+ * awaitNanos/timed await with 0 wait times out immediately
+ */
+ public void testAwait_Zero() throws InterruptedException {
+ final Mutex sync = new Mutex();
+ final ConditionObject c = sync.newCondition();
+ sync.acquire();
+ assertTrue(c.awaitNanos(0L) <= 0);
+ assertFalse(c.await(0L, NANOSECONDS));
+ sync.release();
+ }
+
+ /**
+ * awaitNanos/timed await with maximum negative wait times does not underflow
+ */
+ public void testAwait_NegativeInfinity() throws InterruptedException {
+ final Mutex sync = new Mutex();
+ final ConditionObject c = sync.newCondition();
+ sync.acquire();
+ assertTrue(c.awaitNanos(Long.MIN_VALUE) <= 0);
+ assertFalse(c.await(Long.MIN_VALUE, NANOSECONDS));
+ sync.release();
+ }
+
}
diff --git a/jsr166-tests/src/test/java/jsr166/AbstractQueuedSynchronizerTest.java b/jsr166-tests/src/test/java/jsr166/AbstractQueuedSynchronizerTest.java
index b9dab06..b3c4110 100644
--- a/jsr166-tests/src/test/java/jsr166/AbstractQueuedSynchronizerTest.java
+++ b/jsr166-tests/src/test/java/jsr166/AbstractQueuedSynchronizerTest.java
@@ -8,13 +8,29 @@
package jsr166;
-import junit.framework.*;
-import java.util.*;
import static java.util.concurrent.TimeUnit.MILLISECONDS;
+import static java.util.concurrent.TimeUnit.NANOSECONDS;
+
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.HashSet;
import java.util.concurrent.locks.AbstractQueuedSynchronizer;
import java.util.concurrent.locks.AbstractQueuedSynchronizer.ConditionObject;
+import junit.framework.AssertionFailedError;
+import junit.framework.Test;
+import junit.framework.TestSuite;
+
public class AbstractQueuedSynchronizerTest extends JSR166TestCase {
+ // android-note: Removed because the CTS runner does a bad job of
+ // retrying tests that have suite() declarations.
+ //
+ // public static void main(String[] args) {
+ // main(suite(), args);
+ // }
+ // public static Test suite() {
+ // return new TestSuite(...);
+ // }
/**
* A simple mutex class, adapted from the class javadoc. Exclusive
@@ -194,7 +210,7 @@
new HashSet<Thread>(Arrays.asList(threads)));
}
- enum AwaitMethod { await, awaitTimed, awaitNanos, awaitUntil };
+ enum AwaitMethod { await, awaitTimed, awaitNanos, awaitUntil }
/**
* Awaits condition using the specified AwaitMethod.
@@ -217,6 +233,8 @@
case awaitUntil:
assertTrue(c.awaitUntil(delayedDate(timeoutMillis)));
break;
+ default:
+ throw new AssertionError();
}
}
@@ -1187,7 +1205,6 @@
public void testTryAcquireSharedNanos_Timeout() {
final BooleanLatch l = new BooleanLatch();
final BooleanLatch observedQueued = new BooleanLatch();
- final long timeoutMillis = timeoutMillis();
Thread t = newStartedThread(new CheckedRunnable() {
public void realRun() throws InterruptedException {
assertFalse(l.isSignalled());
@@ -1209,4 +1226,28 @@
assertFalse(l.isSignalled());
}
+ /**
+ * awaitNanos/timed await with 0 wait times out immediately
+ */
+ public void testAwait_Zero() throws InterruptedException {
+ final Mutex sync = new Mutex();
+ final ConditionObject c = sync.newCondition();
+ sync.acquire();
+ assertTrue(c.awaitNanos(0L) <= 0);
+ assertFalse(c.await(0L, NANOSECONDS));
+ sync.release();
+ }
+
+ /**
+ * awaitNanos/timed await with maximum negative wait times does not underflow
+ */
+ public void testAwait_NegativeInfinity() throws InterruptedException {
+ final Mutex sync = new Mutex();
+ final ConditionObject c = sync.newCondition();
+ sync.acquire();
+ assertTrue(c.awaitNanos(Long.MIN_VALUE) <= 0);
+ assertFalse(c.await(Long.MIN_VALUE, NANOSECONDS));
+ sync.release();
+ }
+
}
diff --git a/jsr166-tests/src/test/java/jsr166/ArrayBlockingQueueNotFairTest.java b/jsr166-tests/src/test/java/jsr166/ArrayBlockingQueueNonFairTest.java
similarity index 88%
rename from jsr166-tests/src/test/java/jsr166/ArrayBlockingQueueNotFairTest.java
rename to jsr166-tests/src/test/java/jsr166/ArrayBlockingQueueNonFairTest.java
index ddb1c5d..7bd920f 100644
--- a/jsr166-tests/src/test/java/jsr166/ArrayBlockingQueueNotFairTest.java
+++ b/jsr166-tests/src/test/java/jsr166/ArrayBlockingQueueNonFairTest.java
@@ -11,7 +11,7 @@
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;
-public class ArrayBlockingQueueNotFairTest extends BlockingQueueTest {
+public class ArrayBlockingQueueNonFairTest extends BlockingQueueTest {
protected BlockingQueue emptyCollection() {
return new ArrayBlockingQueue(SIZE, false);
diff --git a/jsr166-tests/src/test/java/jsr166/ArrayBlockingQueueTest.java b/jsr166-tests/src/test/java/jsr166/ArrayBlockingQueueTest.java
index b999496..247c90e 100644
--- a/jsr166-tests/src/test/java/jsr166/ArrayBlockingQueueTest.java
+++ b/jsr166-tests/src/test/java/jsr166/ArrayBlockingQueueTest.java
@@ -8,9 +8,10 @@
package jsr166;
-import junit.framework.*;
-import java.util.Arrays;
+import static java.util.concurrent.TimeUnit.MILLISECONDS;
+
import java.util.ArrayList;
+import java.util.Arrays;
import java.util.Collection;
import java.util.Iterator;
import java.util.NoSuchElementException;
@@ -20,10 +21,36 @@
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.Executors;
import java.util.concurrent.ExecutorService;
-import static java.util.concurrent.TimeUnit.MILLISECONDS;
+
+import junit.framework.Test;
public class ArrayBlockingQueueTest extends JSR166TestCase {
+ // android-note: These tests have been moved into their own separate
+ // classes to work around CTS issues.
+ //
+ // public static class Fair extends BlockingQueueTest {
+ // protected BlockingQueue emptyCollection() {
+ // return new ArrayBlockingQueue(SIZE, true);
+ // }
+ // }
+ //
+ // public static class NonFair extends BlockingQueueTest {
+ // protected BlockingQueue emptyCollection() {
+ // return new ArrayBlockingQueue(SIZE, false);
+ // }
+ // }
+ //
+ // public static void main(String[] args) {
+ // main(suite(), args);
+ // }
+ //
+ // public static Test suite() {
+ // return newTestSuite(ArrayBlockingQueueTest.class,
+ // new Fair().testSuite(),
+ // new NonFair().testSuite());
+ // }
+
/**
* Returns a new queue of given size containing consecutive
* Integers 0 ... n.
@@ -86,7 +113,7 @@
ints[i] = i;
Collection<Integer> elements = Arrays.asList(ints);
try {
- new ArrayBlockingQueue(SIZE, false, Arrays.asList(ints));
+ new ArrayBlockingQueue(SIZE, false, elements);
shouldThrow();
} catch (NullPointerException success) {}
}
@@ -137,16 +164,16 @@
* remainingCapacity decreases on add, increases on remove
*/
public void testRemainingCapacity() {
- ArrayBlockingQueue q = populatedQueue(SIZE);
+ BlockingQueue q = populatedQueue(SIZE);
for (int i = 0; i < SIZE; ++i) {
assertEquals(i, q.remainingCapacity());
- assertEquals(SIZE-i, q.size());
- q.remove();
+ assertEquals(SIZE, q.size() + q.remainingCapacity());
+ assertEquals(i, q.remove());
}
for (int i = 0; i < SIZE; ++i) {
assertEquals(SIZE-i, q.remainingCapacity());
- assertEquals(i, q.size());
- q.add(new Integer(i));
+ assertEquals(SIZE, q.size() + q.remainingCapacity());
+ assertTrue(q.add(i));
}
}
@@ -163,12 +190,12 @@
* add succeeds if not full; throws ISE if full
*/
public void testAdd() {
+ ArrayBlockingQueue q = new ArrayBlockingQueue(SIZE);
+ for (int i = 0; i < SIZE; ++i) {
+ assertTrue(q.add(new Integer(i)));
+ }
+ assertEquals(0, q.remainingCapacity());
try {
- ArrayBlockingQueue q = new ArrayBlockingQueue(SIZE);
- for (int i = 0; i < SIZE; ++i) {
- assertTrue(q.add(new Integer(i)));
- }
- assertEquals(0, q.remainingCapacity());
q.add(new Integer(SIZE));
shouldThrow();
} catch (IllegalStateException success) {}
@@ -178,8 +205,8 @@
* addAll(this) throws IAE
*/
public void testAddAllSelf() {
+ ArrayBlockingQueue q = populatedQueue(SIZE);
try {
- ArrayBlockingQueue q = populatedQueue(SIZE);
q.addAll(q);
shouldThrow();
} catch (IllegalArgumentException success) {}
@@ -190,11 +217,11 @@
* possibly adding some elements
*/
public void testAddAll3() {
+ ArrayBlockingQueue q = new ArrayBlockingQueue(SIZE);
+ Integer[] ints = new Integer[SIZE];
+ for (int i = 0; i < SIZE-1; ++i)
+ ints[i] = new Integer(i);
try {
- ArrayBlockingQueue q = new ArrayBlockingQueue(SIZE);
- Integer[] ints = new Integer[SIZE];
- for (int i = 0; i < SIZE-1; ++i)
- ints[i] = new Integer(i);
q.addAll(Arrays.asList(ints));
shouldThrow();
} catch (NullPointerException success) {}
@@ -204,11 +231,11 @@
* addAll throws ISE if not enough room
*/
public void testAddAll4() {
+ ArrayBlockingQueue q = new ArrayBlockingQueue(1);
+ Integer[] ints = new Integer[SIZE];
+ for (int i = 0; i < SIZE; ++i)
+ ints[i] = new Integer(i);
try {
- ArrayBlockingQueue q = new ArrayBlockingQueue(1);
- Integer[] ints = new Integer[SIZE];
- for (int i = 0; i < SIZE; ++i)
- ints[i] = new Integer(i);
q.addAll(Arrays.asList(ints));
shouldThrow();
} catch (IllegalStateException success) {}
@@ -235,9 +262,9 @@
public void testPut() throws InterruptedException {
ArrayBlockingQueue q = new ArrayBlockingQueue(SIZE);
for (int i = 0; i < SIZE; ++i) {
- Integer I = new Integer(i);
- q.put(I);
- assertTrue(q.contains(I));
+ Integer x = new Integer(i);
+ q.put(x);
+ assertTrue(q.contains(x));
}
assertEquals(0, q.remainingCapacity());
}
@@ -565,8 +592,8 @@
assertTrue(q.removeAll(p));
assertEquals(SIZE-i, q.size());
for (int j = 0; j < i; ++j) {
- Integer I = (Integer)(p.remove());
- assertFalse(q.contains(I));
+ Integer x = (Integer)(p.remove());
+ assertFalse(q.contains(x));
}
}
}
@@ -676,9 +703,24 @@
public void testIterator() throws InterruptedException {
ArrayBlockingQueue q = populatedQueue(SIZE);
Iterator it = q.iterator();
- while (it.hasNext()) {
+ int i;
+ for (i = 0; it.hasNext(); i++)
+ assertTrue(q.contains(it.next()));
+ assertEquals(i, SIZE);
+ assertIteratorExhausted(it);
+
+ it = q.iterator();
+ for (i = 0; it.hasNext(); i++)
assertEquals(it.next(), q.take());
- }
+ assertEquals(i, SIZE);
+ assertIteratorExhausted(it);
+ }
+
+ /**
+ * iterator of empty collection has no elements
+ */
+ public void testEmptyIterator() {
+ assertIteratorExhausted(new ArrayBlockingQueue(SIZE).iterator());
}
/**
@@ -872,8 +914,22 @@
assertEquals(SIZE-k, q.size());
for (int j = 0; j < k; ++j)
assertEquals(l.get(j), new Integer(j));
- while (q.poll() != null) ;
+ do {} while (q.poll() != null);
}
}
+ /**
+ * remove(null), contains(null) always return false
+ */
+ public void testNeverContainsNull() {
+ Collection<?>[] qs = {
+ new ArrayBlockingQueue<Object>(10),
+ populatedQueue(2),
+ };
+
+ for (Collection<?> q : qs) {
+ assertFalse(q.contains(null));
+ assertFalse(q.remove(null));
+ }
+ }
}
diff --git a/jsr166-tests/src/test/java/jsr166/ArrayDequeTest.java b/jsr166-tests/src/test/java/jsr166/ArrayDequeTest.java
index d18a560..16290e9 100644
--- a/jsr166-tests/src/test/java/jsr166/ArrayDequeTest.java
+++ b/jsr166-tests/src/test/java/jsr166/ArrayDequeTest.java
@@ -6,9 +6,8 @@
package jsr166;
-import junit.framework.*;
-import java.util.Arrays;
import java.util.ArrayDeque;
+import java.util.Arrays;
import java.util.Collection;
import java.util.Deque;
import java.util.Iterator;
@@ -16,7 +15,19 @@
import java.util.Queue;
import java.util.Random;
+import junit.framework.Test;
+import junit.framework.TestSuite;
+
public class ArrayDequeTest extends JSR166TestCase {
+ // android-note: Removed because the CTS runner does a bad job of
+ // retrying tests that have suite() declarations.
+ //
+ // public static void main(String[] args) {
+ // main(suite(), args);
+ // }
+ // public static Test suite() {
+ // return new TestSuite(...);
+ // }
/**
* Returns a new deque of given size containing consecutive
@@ -44,7 +55,7 @@
*/
public void testConstructor3() {
try {
- ArrayDeque q = new ArrayDeque((Collection)null);
+ new ArrayDeque((Collection)null);
shouldThrow();
} catch (NullPointerException success) {}
}
@@ -55,7 +66,7 @@
public void testConstructor4() {
try {
Integer[] ints = new Integer[SIZE];
- ArrayDeque q = new ArrayDeque(Arrays.asList(ints));
+ new ArrayDeque(Arrays.asList(ints));
shouldThrow();
} catch (NullPointerException success) {}
}
@@ -68,7 +79,7 @@
Integer[] ints = new Integer[SIZE];
for (int i = 0; i < SIZE-1; ++i)
ints[i] = new Integer(i);
- ArrayDeque q = new ArrayDeque(Arrays.asList(ints));
+ new ArrayDeque(Arrays.asList(ints));
shouldThrow();
} catch (NullPointerException success) {}
}
@@ -386,13 +397,13 @@
*/
public void testRemoveElement() {
ArrayDeque q = populatedDeque(SIZE);
- for (int i = 1; i < SIZE; i+=2) {
+ for (int i = 1; i < SIZE; i += 2) {
assertTrue(q.contains(i));
assertTrue(q.remove(i));
assertFalse(q.contains(i));
assertTrue(q.contains(i-1));
}
- for (int i = 0; i < SIZE; i+=2) {
+ for (int i = 0; i < SIZE; i += 2) {
assertTrue(q.contains(i));
assertTrue(q.remove(i));
assertFalse(q.contains(i));
@@ -525,10 +536,10 @@
*/
public void testRemoveFirstOccurrence() {
ArrayDeque q = populatedDeque(SIZE);
- for (int i = 1; i < SIZE; i+=2) {
+ for (int i = 1; i < SIZE; i += 2) {
assertTrue(q.removeFirstOccurrence(new Integer(i)));
}
- for (int i = 0; i < SIZE; i+=2) {
+ for (int i = 0; i < SIZE; i += 2) {
assertTrue(q.removeFirstOccurrence(new Integer(i)));
assertFalse(q.removeFirstOccurrence(new Integer(i+1)));
}
@@ -540,10 +551,10 @@
*/
public void testRemoveLastOccurrence() {
ArrayDeque q = populatedDeque(SIZE);
- for (int i = 1; i < SIZE; i+=2) {
+ for (int i = 1; i < SIZE; i += 2) {
assertTrue(q.removeLastOccurrence(new Integer(i)));
}
- for (int i = 0; i < SIZE; i+=2) {
+ for (int i = 0; i < SIZE; i += 2) {
assertTrue(q.removeLastOccurrence(new Integer(i)));
assertFalse(q.removeLastOccurrence(new Integer(i+1)));
}
@@ -735,13 +746,21 @@
*/
public void testIterator() {
ArrayDeque q = populatedDeque(SIZE);
- int i = 0;
Iterator it = q.iterator();
- while (it.hasNext()) {
+ int i;
+ for (i = 0; it.hasNext(); i++)
assertTrue(q.contains(it.next()));
- ++i;
- }
assertEquals(i, SIZE);
+ assertIteratorExhausted(it);
+ }
+
+ /**
+ * iterator of empty collection has no elements
+ */
+ public void testEmptyIterator() {
+ Deque c = new ArrayDeque();
+ assertIteratorExhausted(c.iterator());
+ assertIteratorExhausted(c.descendingIterator());
}
/**
@@ -885,4 +904,21 @@
assertTrue(y.isEmpty());
}
+ /**
+ * remove(null), contains(null) always return false
+ */
+ public void testNeverContainsNull() {
+ Deque<?>[] qs = {
+ new ArrayDeque<Object>(),
+ populatedDeque(2),
+ };
+
+ for (Deque<?> q : qs) {
+ assertFalse(q.contains(null));
+ assertFalse(q.remove(null));
+ assertFalse(q.removeFirstOccurrence(null));
+ assertFalse(q.removeLastOccurrence(null));
+ }
+ }
+
}
diff --git a/jsr166-tests/src/test/java/jsr166/AtomicBooleanTest.java b/jsr166-tests/src/test/java/jsr166/AtomicBooleanTest.java
index 7a50120..bfe3fc6 100644
--- a/jsr166-tests/src/test/java/jsr166/AtomicBooleanTest.java
+++ b/jsr166-tests/src/test/java/jsr166/AtomicBooleanTest.java
@@ -8,10 +8,21 @@
package jsr166;
-import junit.framework.*;
import java.util.concurrent.atomic.AtomicBoolean;
+import junit.framework.Test;
+import junit.framework.TestSuite;
+
public class AtomicBooleanTest extends JSR166TestCase {
+ // android-note: Removed because the CTS runner does a bad job of
+ // retrying tests that have suite() declarations.
+ //
+ // public static void main(String[] args) {
+ // main(suite(), args);
+ // }
+ // public static Test suite() {
+ // return new TestSuite(...);
+ // }
/**
* constructor initializes to given value
@@ -91,11 +102,11 @@
*/
public void testWeakCompareAndSet() {
AtomicBoolean ai = new AtomicBoolean(true);
- while (!ai.weakCompareAndSet(true, false));
+ do {} while (!ai.weakCompareAndSet(true, false));
assertFalse(ai.get());
- while (!ai.weakCompareAndSet(false, false));
+ do {} while (!ai.weakCompareAndSet(false, false));
assertFalse(ai.get());
- while (!ai.weakCompareAndSet(false, true));
+ do {} while (!ai.weakCompareAndSet(false, true));
assertTrue(ai.get());
}
diff --git a/jsr166-tests/src/test/java/jsr166/AtomicIntegerArrayTest.java b/jsr166-tests/src/test/java/jsr166/AtomicIntegerArrayTest.java
index e81a107..670b9ce 100644
--- a/jsr166-tests/src/test/java/jsr166/AtomicIntegerArrayTest.java
+++ b/jsr166-tests/src/test/java/jsr166/AtomicIntegerArrayTest.java
@@ -8,11 +8,22 @@
package jsr166;
-import junit.framework.*;
import java.util.Arrays;
import java.util.concurrent.atomic.AtomicIntegerArray;
+import junit.framework.Test;
+import junit.framework.TestSuite;
+
public class AtomicIntegerArrayTest extends JSR166TestCase {
+ // android-note: Removed because the CTS runner does a bad job of
+ // retrying tests that have suite() declarations.
+ //
+ // public static void main(String[] args) {
+ // main(suite(), args);
+ // }
+ // public static Test suite() {
+ // return new TestSuite(...);
+ // }
/**
* constructor creates array of given size with all elements zero
@@ -29,7 +40,7 @@
public void testConstructor2NPE() {
try {
int[] a = null;
- AtomicIntegerArray aa = new AtomicIntegerArray(a);
+ new AtomicIntegerArray(a);
shouldThrow();
} catch (NullPointerException success) {}
}
@@ -157,10 +168,10 @@
AtomicIntegerArray aa = new AtomicIntegerArray(SIZE);
for (int i = 0; i < SIZE; i++) {
aa.set(i, 1);
- while (!aa.weakCompareAndSet(i, 1, 2));
- while (!aa.weakCompareAndSet(i, 2, -4));
+ do {} while (!aa.weakCompareAndSet(i, 1, 2));
+ do {} while (!aa.weakCompareAndSet(i, 2, -4));
assertEquals(-4, aa.get(i));
- while (!aa.weakCompareAndSet(i, -4, 7));
+ do {} while (!aa.weakCompareAndSet(i, -4, 7));
assertEquals(7, aa.get(i));
}
}
@@ -267,8 +278,6 @@
}
}
- static final int COUNTDOWN = 100000;
-
class Counter extends CheckedRunnable {
final AtomicIntegerArray aa;
volatile int counts;
@@ -297,8 +306,9 @@
*/
public void testCountingInMultipleThreads() throws InterruptedException {
final AtomicIntegerArray aa = new AtomicIntegerArray(SIZE);
+ int countdown = 10000;
for (int i = 0; i < SIZE; i++)
- aa.set(i, COUNTDOWN);
+ aa.set(i, countdown);
Counter c1 = new Counter(aa);
Counter c2 = new Counter(aa);
Thread t1 = new Thread(c1);
@@ -307,7 +317,7 @@
t2.start();
t1.join();
t2.join();
- assertEquals(c1.counts+c2.counts, SIZE * COUNTDOWN);
+ assertEquals(c1.counts+c2.counts, SIZE * countdown);
}
/**
diff --git a/jsr166-tests/src/test/java/jsr166/AtomicIntegerFieldUpdaterTest.java b/jsr166-tests/src/test/java/jsr166/AtomicIntegerFieldUpdaterTest.java
index f0c1ae6..ef75b46 100644
--- a/jsr166-tests/src/test/java/jsr166/AtomicIntegerFieldUpdaterTest.java
+++ b/jsr166-tests/src/test/java/jsr166/AtomicIntegerFieldUpdaterTest.java
@@ -8,13 +8,24 @@
package jsr166;
-import junit.framework.*;
import java.util.concurrent.atomic.AtomicIntegerFieldUpdater;
+import junit.framework.Test;
+import junit.framework.TestSuite;
+
public class AtomicIntegerFieldUpdaterTest extends JSR166TestCase {
volatile int x = 0;
int w;
long z;
+ // android-note: Removed because the CTS runner does a bad job of
+ // retrying tests that have suite() declarations.
+ //
+ // public static void main(String[] args) {
+ // main(suite(), args);
+ // }
+ // public static Test suite() {
+ // return new TestSuite(...);
+ // }
AtomicIntegerFieldUpdater<AtomicIntegerFieldUpdaterTest> updaterFor(String fieldName) {
return AtomicIntegerFieldUpdater.newUpdater
@@ -127,10 +138,10 @@
AtomicIntegerFieldUpdater<AtomicIntegerFieldUpdaterTest> a;
a = updaterFor("x");
x = 1;
- while (!a.weakCompareAndSet(this, 1, 2));
- while (!a.weakCompareAndSet(this, 2, -4));
+ do {} while (!a.weakCompareAndSet(this, 1, 2));
+ do {} while (!a.weakCompareAndSet(this, 2, -4));
assertEquals(-4, a.get(this));
- while (!a.weakCompareAndSet(this, -4, 7));
+ do {} while (!a.weakCompareAndSet(this, -4, 7));
assertEquals(7, a.get(this));
}
diff --git a/jsr166-tests/src/test/java/jsr166/AtomicIntegerTest.java b/jsr166-tests/src/test/java/jsr166/AtomicIntegerTest.java
index 2afaa73..cf73810 100644
--- a/jsr166-tests/src/test/java/jsr166/AtomicIntegerTest.java
+++ b/jsr166-tests/src/test/java/jsr166/AtomicIntegerTest.java
@@ -8,10 +8,21 @@
package jsr166;
-import junit.framework.*;
import java.util.concurrent.atomic.AtomicInteger;
+import junit.framework.Test;
+import junit.framework.TestSuite;
+
public class AtomicIntegerTest extends JSR166TestCase {
+ // android-note: Removed because the CTS runner does a bad job of
+ // retrying tests that have suite() declarations.
+ //
+ // public static void main(String[] args) {
+ // main(suite(), args);
+ // }
+ // public static Test suite() {
+ // return new TestSuite(...);
+ // }
final int[] VALUES = {
Integer.MIN_VALUE, -1, 0, 1, 42, Integer.MAX_VALUE,
@@ -96,10 +107,10 @@
*/
public void testWeakCompareAndSet() {
AtomicInteger ai = new AtomicInteger(1);
- while (!ai.weakCompareAndSet(1, 2));
- while (!ai.weakCompareAndSet(2, -4));
+ do {} while (!ai.weakCompareAndSet(1, 2));
+ do {} while (!ai.weakCompareAndSet(2, -4));
assertEquals(-4, ai.get());
- while (!ai.weakCompareAndSet(-4, 7));
+ do {} while (!ai.weakCompareAndSet(-4, 7));
assertEquals(7, ai.get());
}
diff --git a/jsr166-tests/src/test/java/jsr166/AtomicLongArrayTest.java b/jsr166-tests/src/test/java/jsr166/AtomicLongArrayTest.java
index 53be5dc..08df01e 100644
--- a/jsr166-tests/src/test/java/jsr166/AtomicLongArrayTest.java
+++ b/jsr166-tests/src/test/java/jsr166/AtomicLongArrayTest.java
@@ -8,11 +8,22 @@
package jsr166;
-import junit.framework.*;
import java.util.Arrays;
import java.util.concurrent.atomic.AtomicLongArray;
+import junit.framework.Test;
+import junit.framework.TestSuite;
+
public class AtomicLongArrayTest extends JSR166TestCase {
+ // android-note: Removed because the CTS runner does a bad job of
+ // retrying tests that have suite() declarations.
+ //
+ // public static void main(String[] args) {
+ // main(suite(), args);
+ // }
+ // public static Test suite() {
+ // return new TestSuite(...);
+ // }
/**
* constructor creates array of given size with all elements zero
@@ -29,7 +40,7 @@
public void testConstructor2NPE() {
try {
long[] a = null;
- AtomicLongArray aa = new AtomicLongArray(a);
+ new AtomicLongArray(a);
shouldThrow();
} catch (NullPointerException success) {}
}
@@ -157,10 +168,10 @@
AtomicLongArray aa = new AtomicLongArray(SIZE);
for (int i = 0; i < SIZE; i++) {
aa.set(i, 1);
- while (!aa.weakCompareAndSet(i, 1, 2));
- while (!aa.weakCompareAndSet(i, 2, -4));
+ do {} while (!aa.weakCompareAndSet(i, 1, 2));
+ do {} while (!aa.weakCompareAndSet(i, 2, -4));
assertEquals(-4, aa.get(i));
- while (!aa.weakCompareAndSet(i, -4, 7));
+ do {} while (!aa.weakCompareAndSet(i, -4, 7));
assertEquals(7, aa.get(i));
}
}
@@ -267,8 +278,6 @@
}
}
- static final long COUNTDOWN = 100000;
-
class Counter extends CheckedRunnable {
final AtomicLongArray aa;
volatile long counts;
@@ -297,8 +306,9 @@
*/
public void testCountingInMultipleThreads() throws InterruptedException {
final AtomicLongArray aa = new AtomicLongArray(SIZE);
+ long countdown = 10000;
for (int i = 0; i < SIZE; i++)
- aa.set(i, COUNTDOWN);
+ aa.set(i, countdown);
Counter c1 = new Counter(aa);
Counter c2 = new Counter(aa);
Thread t1 = new Thread(c1);
@@ -307,7 +317,7 @@
t2.start();
t1.join();
t2.join();
- assertEquals(c1.counts+c2.counts, SIZE * COUNTDOWN);
+ assertEquals(c1.counts+c2.counts, SIZE * countdown);
}
/**
diff --git a/jsr166-tests/src/test/java/jsr166/AtomicLongFieldUpdaterTest.java b/jsr166-tests/src/test/java/jsr166/AtomicLongFieldUpdaterTest.java
index c9374e0..204f814 100644
--- a/jsr166-tests/src/test/java/jsr166/AtomicLongFieldUpdaterTest.java
+++ b/jsr166-tests/src/test/java/jsr166/AtomicLongFieldUpdaterTest.java
@@ -8,14 +8,26 @@
package jsr166;
-import junit.framework.*;
import java.util.concurrent.atomic.AtomicLongFieldUpdater;
+import junit.framework.Test;
+import junit.framework.TestSuite;
+
public class AtomicLongFieldUpdaterTest extends JSR166TestCase {
volatile long x = 0;
int z;
long w;
+ // android-note: Removed because the CTS runner does a bad job of
+ // retrying tests that have suite() declarations.
+ //
+ // public static void main(String[] args) {
+ // main(suite(), args);
+ // }
+ // public static Test suite() {
+ // return new TestSuite(...);
+ // }
+
AtomicLongFieldUpdater<AtomicLongFieldUpdaterTest> updaterFor(String fieldName) {
return AtomicLongFieldUpdater.newUpdater
(AtomicLongFieldUpdaterTest.class, fieldName);
@@ -127,10 +139,10 @@
AtomicLongFieldUpdater<AtomicLongFieldUpdaterTest> a;
a = updaterFor("x");
x = 1;
- while (!a.weakCompareAndSet(this, 1, 2));
- while (!a.weakCompareAndSet(this, 2, -4));
+ do {} while (!a.weakCompareAndSet(this, 1, 2));
+ do {} while (!a.weakCompareAndSet(this, 2, -4));
assertEquals(-4, a.get(this));
- while (!a.weakCompareAndSet(this, -4, 7));
+ do {} while (!a.weakCompareAndSet(this, -4, 7));
assertEquals(7, a.get(this));
}
diff --git a/jsr166-tests/src/test/java/jsr166/AtomicLongTest.java b/jsr166-tests/src/test/java/jsr166/AtomicLongTest.java
index d300367..b9c1722 100644
--- a/jsr166-tests/src/test/java/jsr166/AtomicLongTest.java
+++ b/jsr166-tests/src/test/java/jsr166/AtomicLongTest.java
@@ -8,10 +8,21 @@
package jsr166;
-import junit.framework.*;
import java.util.concurrent.atomic.AtomicLong;
+import junit.framework.Test;
+import junit.framework.TestSuite;
+
public class AtomicLongTest extends JSR166TestCase {
+ // android-note: Removed because the CTS runner does a bad job of
+ // retrying tests that have suite() declarations.
+ //
+ // public static void main(String[] args) {
+ // main(suite(), args);
+ // }
+ // public static Test suite() {
+ // return new TestSuite(...);
+ // }
final long[] VALUES = {
Long.MIN_VALUE,
@@ -98,10 +109,10 @@
*/
public void testWeakCompareAndSet() {
AtomicLong ai = new AtomicLong(1);
- while (!ai.weakCompareAndSet(1, 2));
- while (!ai.weakCompareAndSet(2, -4));
+ do {} while (!ai.weakCompareAndSet(1, 2));
+ do {} while (!ai.weakCompareAndSet(2, -4));
assertEquals(-4, ai.get());
- while (!ai.weakCompareAndSet(-4, 7));
+ do {} while (!ai.weakCompareAndSet(-4, 7));
assertEquals(7, ai.get());
}
diff --git a/jsr166-tests/src/test/java/jsr166/AtomicMarkableReferenceTest.java b/jsr166-tests/src/test/java/jsr166/AtomicMarkableReferenceTest.java
index fd1f2f1..61b6b1b 100644
--- a/jsr166-tests/src/test/java/jsr166/AtomicMarkableReferenceTest.java
+++ b/jsr166-tests/src/test/java/jsr166/AtomicMarkableReferenceTest.java
@@ -8,10 +8,21 @@
package jsr166;
-import junit.framework.*;
import java.util.concurrent.atomic.AtomicMarkableReference;
+import junit.framework.Test;
+import junit.framework.TestSuite;
+
public class AtomicMarkableReferenceTest extends JSR166TestCase {
+ // android-note: Removed because the CTS runner does a bad job of
+ // retrying tests that have suite() declarations.
+ //
+ // public static void main(String[] args) {
+ // main(suite(), args);
+ // }
+ // public static Test suite() {
+ // return new TestSuite(...);
+ // }
/**
* constructor initializes to given reference and mark
@@ -135,11 +146,11 @@
assertFalse(ai.isMarked());
assertFalse(mark[0]);
- while (!ai.weakCompareAndSet(one, two, false, false));
+ do {} while (!ai.weakCompareAndSet(one, two, false, false));
assertSame(two, ai.get(mark));
assertFalse(mark[0]);
- while (!ai.weakCompareAndSet(two, m3, false, true));
+ do {} while (!ai.weakCompareAndSet(two, m3, false, true));
assertSame(m3, ai.get(mark));
assertTrue(mark[0]);
}
diff --git a/jsr166-tests/src/test/java/jsr166/AtomicReferenceArrayTest.java b/jsr166-tests/src/test/java/jsr166/AtomicReferenceArrayTest.java
index 0a4f3d9..1df2f9f 100644
--- a/jsr166-tests/src/test/java/jsr166/AtomicReferenceArrayTest.java
+++ b/jsr166-tests/src/test/java/jsr166/AtomicReferenceArrayTest.java
@@ -8,11 +8,22 @@
package jsr166;
-import junit.framework.*;
import java.util.Arrays;
import java.util.concurrent.atomic.AtomicReferenceArray;
+import junit.framework.Test;
+import junit.framework.TestSuite;
+
public class AtomicReferenceArrayTest extends JSR166TestCase {
+ // android-note: Removed because the CTS runner does a bad job of
+ // retrying tests that have suite() declarations.
+ //
+ // public static void main(String[] args) {
+ // main(suite(), args);
+ // }
+ // public static Test suite() {
+ // return new TestSuite(...);
+ // }
/**
* constructor creates array of given size with all elements null
@@ -30,7 +41,7 @@
public void testConstructor2NPE() {
try {
Integer[] a = null;
- AtomicReferenceArray<Integer> aa = new AtomicReferenceArray<Integer>(a);
+ new AtomicReferenceArray<Integer>(a);
shouldThrow();
} catch (NullPointerException success) {}
}
@@ -165,10 +176,10 @@
AtomicReferenceArray aa = new AtomicReferenceArray(SIZE);
for (int i = 0; i < SIZE; i++) {
aa.set(i, one);
- while (!aa.weakCompareAndSet(i, one, two));
- while (!aa.weakCompareAndSet(i, two, m4));
+ do {} while (!aa.weakCompareAndSet(i, one, two));
+ do {} while (!aa.weakCompareAndSet(i, two, m4));
assertSame(m4, aa.get(i));
- while (!aa.weakCompareAndSet(i, m4, seven));
+ do {} while (!aa.weakCompareAndSet(i, m4, seven));
assertSame(seven, aa.get(i));
}
}
diff --git a/jsr166-tests/src/test/java/jsr166/AtomicReferenceFieldUpdaterTest.java b/jsr166-tests/src/test/java/jsr166/AtomicReferenceFieldUpdaterTest.java
index 271c7b7..4b0d946 100644
--- a/jsr166-tests/src/test/java/jsr166/AtomicReferenceFieldUpdaterTest.java
+++ b/jsr166-tests/src/test/java/jsr166/AtomicReferenceFieldUpdaterTest.java
@@ -8,15 +8,27 @@
package jsr166;
-import junit.framework.*;
import java.util.concurrent.atomic.AtomicReferenceFieldUpdater;
+import junit.framework.Test;
+import junit.framework.TestSuite;
+
public class AtomicReferenceFieldUpdaterTest extends JSR166TestCase {
volatile Integer x = null;
Object z;
Integer w;
volatile int i;
+ // android-note: Removed because the CTS runner does a bad job of
+ // retrying tests that have suite() declarations.
+ //
+ // public static void main(String[] args) {
+ // main(suite(), args);
+ // }
+ // public static Test suite() {
+ // return new TestSuite(...);
+ // }
+
AtomicReferenceFieldUpdater<AtomicReferenceFieldUpdaterTest, Integer> updaterFor(String fieldName) {
return AtomicReferenceFieldUpdater.newUpdater
(AtomicReferenceFieldUpdaterTest.class, Integer.class, fieldName);
@@ -68,7 +80,7 @@
* get returns the last value set or assigned
*/
public void testGetSet() {
- AtomicReferenceFieldUpdater<AtomicReferenceFieldUpdaterTest, Integer>a;
+ AtomicReferenceFieldUpdater<AtomicReferenceFieldUpdaterTest, Integer> a;
a = updaterFor("x");
x = one;
assertSame(one, a.get(this));
@@ -82,7 +94,7 @@
* get returns the last value lazySet by same thread
*/
public void testGetLazySet() {
- AtomicReferenceFieldUpdater<AtomicReferenceFieldUpdaterTest, Integer>a;
+ AtomicReferenceFieldUpdater<AtomicReferenceFieldUpdaterTest, Integer> a;
a = updaterFor("x");
x = one;
assertSame(one, a.get(this));
@@ -96,7 +108,7 @@
* compareAndSet succeeds in changing value if equal to expected else fails
*/
public void testCompareAndSet() {
- AtomicReferenceFieldUpdater<AtomicReferenceFieldUpdaterTest, Integer>a;
+ AtomicReferenceFieldUpdater<AtomicReferenceFieldUpdaterTest, Integer> a;
a = updaterFor("x");
x = one;
assertTrue(a.compareAndSet(this, one, two));
@@ -114,7 +126,7 @@
*/
public void testCompareAndSetInMultipleThreads() throws Exception {
x = one;
- final AtomicReferenceFieldUpdater<AtomicReferenceFieldUpdaterTest, Integer>a;
+ final AtomicReferenceFieldUpdater<AtomicReferenceFieldUpdaterTest, Integer> a;
a = updaterFor("x");
Thread t = new Thread(new CheckedRunnable() {
@@ -135,13 +147,13 @@
* to expected
*/
public void testWeakCompareAndSet() {
- AtomicReferenceFieldUpdater<AtomicReferenceFieldUpdaterTest, Integer>a;
+ AtomicReferenceFieldUpdater<AtomicReferenceFieldUpdaterTest, Integer> a;
a = updaterFor("x");
x = one;
- while (!a.weakCompareAndSet(this, one, two));
- while (!a.weakCompareAndSet(this, two, m4));
+ do {} while (!a.weakCompareAndSet(this, one, two));
+ do {} while (!a.weakCompareAndSet(this, two, m4));
assertSame(m4, a.get(this));
- while (!a.weakCompareAndSet(this, m4, seven));
+ do {} while (!a.weakCompareAndSet(this, m4, seven));
assertSame(seven, a.get(this));
}
@@ -149,7 +161,7 @@
* getAndSet returns previous value and sets to given value
*/
public void testGetAndSet() {
- AtomicReferenceFieldUpdater<AtomicReferenceFieldUpdaterTest, Integer>a;
+ AtomicReferenceFieldUpdater<AtomicReferenceFieldUpdaterTest, Integer> a;
a = updaterFor("x");
x = one;
assertSame(one, a.getAndSet(this, zero));
diff --git a/jsr166-tests/src/test/java/jsr166/AtomicReferenceTest.java b/jsr166-tests/src/test/java/jsr166/AtomicReferenceTest.java
index 8032546..457182f 100644
--- a/jsr166-tests/src/test/java/jsr166/AtomicReferenceTest.java
+++ b/jsr166-tests/src/test/java/jsr166/AtomicReferenceTest.java
@@ -8,10 +8,21 @@
package jsr166;
-import junit.framework.*;
import java.util.concurrent.atomic.AtomicReference;
+import junit.framework.Test;
+import junit.framework.TestSuite;
+
public class AtomicReferenceTest extends JSR166TestCase {
+ // android-note: Removed because the CTS runner does a bad job of
+ // retrying tests that have suite() declarations.
+ //
+ // public static void main(String[] args) {
+ // main(suite(), args);
+ // }
+ // public static Test suite() {
+ // return new TestSuite(...);
+ // }
/**
* constructor initializes to given value
@@ -92,10 +103,10 @@
*/
public void testWeakCompareAndSet() {
AtomicReference ai = new AtomicReference(one);
- while (!ai.weakCompareAndSet(one, two));
- while (!ai.weakCompareAndSet(two, m4));
+ do {} while (!ai.weakCompareAndSet(one, two));
+ do {} while (!ai.weakCompareAndSet(two, m4));
assertSame(m4, ai.get());
- while (!ai.weakCompareAndSet(m4, seven));
+ do {} while (!ai.weakCompareAndSet(m4, seven));
assertSame(seven, ai.get());
}
diff --git a/jsr166-tests/src/test/java/jsr166/AtomicStampedReferenceTest.java b/jsr166-tests/src/test/java/jsr166/AtomicStampedReferenceTest.java
index 3e6445e..b3ff06a 100644
--- a/jsr166-tests/src/test/java/jsr166/AtomicStampedReferenceTest.java
+++ b/jsr166-tests/src/test/java/jsr166/AtomicStampedReferenceTest.java
@@ -8,10 +8,21 @@
package jsr166;
-import junit.framework.*;
import java.util.concurrent.atomic.AtomicStampedReference;
+import junit.framework.Test;
+import junit.framework.TestSuite;
+
public class AtomicStampedReferenceTest extends JSR166TestCase {
+ // android-note: Removed because the CTS runner does a bad job of
+ // retrying tests that have suite() declarations.
+ //
+ // public static void main(String[] args) {
+ // main(suite(), args);
+ // }
+ // public static Test suite() {
+ // return new TestSuite(...);
+ // }
/**
* constructor initializes to given reference and stamp
@@ -135,11 +146,11 @@
assertEquals(0, ai.getStamp());
assertEquals(0, mark[0]);
- while (!ai.weakCompareAndSet(one, two, 0, 0));
+ do {} while (!ai.weakCompareAndSet(one, two, 0, 0));
assertSame(two, ai.get(mark));
assertEquals(0, mark[0]);
- while (!ai.weakCompareAndSet(two, m3, 0, 1));
+ do {} while (!ai.weakCompareAndSet(two, m3, 0, 1));
assertSame(m3, ai.get(mark));
assertEquals(1, mark[0]);
}
diff --git a/jsr166-tests/src/test/java/jsr166/BlockingQueueTest.java b/jsr166-tests/src/test/java/jsr166/BlockingQueueTest.java
index 1ed7559..db0f03d 100644
--- a/jsr166-tests/src/test/java/jsr166/BlockingQueueTest.java
+++ b/jsr166-tests/src/test/java/jsr166/BlockingQueueTest.java
@@ -9,14 +9,17 @@
package jsr166;
-import junit.framework.*;
+import static java.util.concurrent.TimeUnit.MILLISECONDS;
+
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Queue;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.CountDownLatch;
-import static java.util.concurrent.TimeUnit.MILLISECONDS;
+
+import junit.framework.Test;
+import junit.framework.TestSuite;
/**
* Contains "contract" tests applicable to all BlockingQueue implementations.
@@ -32,6 +35,15 @@
* instances.
*/
+ /** Like suite(), but non-static */
+ // android-note: Explicitly instantiated.
+ //
+ // public Test testSuite() {
+ // // TODO: filter the returned tests using the configuration
+ // // information provided by the subclass via protected methods.
+ // return new TestSuite(this.getClass());
+ // }
+
//----------------------------------------------------------------
// Configuration methods
//----------------------------------------------------------------
@@ -335,7 +347,7 @@
checkEmpty(q);
for (int i = 0; i < size; i++)
q.add(elts[i] = makeElement(i));
- for (int i = 1; i < size; i+=2) {
+ for (int i = 1; i < size; i += 2) {
for (int pass = 0; pass < 2; pass++) {
assertEquals((pass == 0), q.contains(elts[i]));
assertEquals((pass == 0), q.remove(elts[i]));
@@ -347,7 +359,7 @@
}
if (size > 0)
assertTrue(q.contains(elts[0]));
- for (int i = size-2; i >= 0; i-=2) {
+ for (int i = size-2; i >= 0; i -= 2) {
assertTrue(q.contains(elts[i]));
assertFalse(q.contains(elts[i+1]));
assertTrue(q.remove(elts[i]));
diff --git a/jsr166-tests/src/test/java/jsr166/ConcurrentHashMapTest.java b/jsr166-tests/src/test/java/jsr166/ConcurrentHashMapTest.java
index 5d9e2ac..4650f41 100644
--- a/jsr166-tests/src/test/java/jsr166/ConcurrentHashMapTest.java
+++ b/jsr166-tests/src/test/java/jsr166/ConcurrentHashMapTest.java
@@ -8,17 +8,36 @@
package jsr166;
-import junit.framework.*;
-import java.util.*;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.Enumeration;
+import java.util.Iterator;
+import java.util.Map;
+import java.util.Random;
+import java.util.Set;
import java.util.concurrent.ConcurrentHashMap;
+import junit.framework.Test;
+import junit.framework.TestSuite;
+
public class ConcurrentHashMapTest extends JSR166TestCase {
+ // android-note: Removed because the CTS runner does a bad job of
+ // retrying tests that have suite() declarations.
+ //
+ // public static void main(String[] args) {
+ // main(suite(), args);
+ // }
+ // public static Test suite() {
+ // return new TestSuite(...);
+ // }
/**
* Returns a new map from Integers 1-5 to Strings "A"-"E".
*/
- private static ConcurrentHashMap map5() {
- ConcurrentHashMap map = new ConcurrentHashMap(5);
+ private static ConcurrentHashMap<Integer, String> map5() {
+ ConcurrentHashMap map = new ConcurrentHashMap<Integer, String>(5);
assertTrue(map.isEmpty());
map.put(one, "A");
map.put(two, "B");
@@ -30,12 +49,15 @@
return map;
}
+ /** Re-implement Integer.compare for old java versions */
+ static int compare(int x, int y) { return x < y ? -1 : x > y ? 1 : 0; }
+
// classes for testing Comparable fallbacks
static class BI implements Comparable<BI> {
private final int value;
BI(int value) { this.value = value; }
public int compareTo(BI other) {
- return Integer.compare(value, other.value);
+ return compare(value, other.value);
}
public boolean equals(Object x) {
return (x instanceof BI) && ((BI)x).value == value;
@@ -59,12 +81,9 @@
static class LexicographicList<E extends Comparable<E>> extends ArrayList<E>
implements Comparable<LexicographicList<E>> {
- static long total;
- static long n;
LexicographicList(Collection<E> c) { super(c); }
LexicographicList(E e) { super(Collections.singleton(e)); }
public int compareTo(LexicographicList<E> other) {
- long start = System.currentTimeMillis();
int common = Math.min(size(), other.size());
int r = 0;
for (int i = 0; i < common; i++) {
@@ -72,25 +91,40 @@
break;
}
if (r == 0)
- r = Integer.compare(size(), other.size());
- total += System.currentTimeMillis() - start;
- n++;
+ r = compare(size(), other.size());
return r;
}
private static final long serialVersionUID = 0;
}
+ static class CollidingObject {
+ final String value;
+ CollidingObject(final String value) { this.value = value; }
+ public int hashCode() { return this.value.hashCode() & 1; }
+ public boolean equals(final Object obj) {
+ return (obj instanceof CollidingObject) && ((CollidingObject)obj).value.equals(value);
+ }
+ }
+
+ static class ComparableCollidingObject extends CollidingObject implements Comparable<ComparableCollidingObject> {
+ ComparableCollidingObject(final String value) { super(value); }
+ public int compareTo(final ComparableCollidingObject o) {
+ return value.compareTo(o.value);
+ }
+ }
+
/**
* Inserted elements that are subclasses of the same Comparable
* class are found.
*/
public void testComparableFamily() {
+ int size = 500; // makes measured test run time -> 60ms
ConcurrentHashMap<BI, Boolean> m =
new ConcurrentHashMap<BI, Boolean>();
- for (int i = 0; i < 1000; i++) {
+ for (int i = 0; i < size; i++) {
assertTrue(m.put(new CI(i), true) == null);
}
- for (int i = 0; i < 1000; i++) {
+ for (int i = 0; i < size; i++) {
assertTrue(m.containsKey(new CI(i)));
assertTrue(m.containsKey(new DI(i)));
}
@@ -100,24 +134,25 @@
* Elements of classes with erased generic type parameters based
* on Comparable can be inserted and found.
*/
- public void testGenericComparable() {
- ConcurrentHashMap<Object, Boolean> m =
- new ConcurrentHashMap<Object, Boolean>();
- for (int i = 0; i < 1000; i++) {
- BI bi = new BI(i);
- BS bs = new BS(String.valueOf(i));
- LexicographicList<BI> bis = new LexicographicList<BI>(bi);
- LexicographicList<BS> bss = new LexicographicList<BS>(bs);
- assertTrue(m.putIfAbsent(bis, true) == null);
- assertTrue(m.containsKey(bis));
- if (m.putIfAbsent(bss, true) == null)
- assertTrue(m.containsKey(bss));
- assertTrue(m.containsKey(bis));
- }
- for (int i = 0; i < 1000; i++) {
- assertTrue(m.containsKey(new ArrayList(Collections.singleton(new BI(i)))));
- }
- }
+ public void testGenericComparable() {
+ int size = 120; // makes measured test run time -> 60ms
+ ConcurrentHashMap<Object, Boolean> m =
+ new ConcurrentHashMap<Object, Boolean>();
+ for (int i = 0; i < size; i++) {
+ BI bi = new BI(i);
+ BS bs = new BS(String.valueOf(i));
+ LexicographicList<BI> bis = new LexicographicList<BI>(bi);
+ LexicographicList<BS> bss = new LexicographicList<BS>(bs);
+ assertTrue(m.putIfAbsent(bis, true) == null);
+ assertTrue(m.containsKey(bis));
+ if (m.putIfAbsent(bss, true) == null)
+ assertTrue(m.containsKey(bss));
+ assertTrue(m.containsKey(bis));
+ }
+ for (int i = 0; i < size; i++) {
+ assertTrue(m.containsKey(Collections.singletonList(new BI(i))));
+ }
+ }
/**
* Elements of non-comparable classes equal to those of classes
@@ -125,19 +160,55 @@
* inserted and found.
*/
public void testGenericComparable2() {
+ int size = 500; // makes measured test run time -> 60ms
ConcurrentHashMap<Object, Boolean> m =
new ConcurrentHashMap<Object, Boolean>();
- for (int i = 0; i < 1000; i++) {
- m.put(new ArrayList(Collections.singleton(new BI(i))), true);
+ for (int i = 0; i < size; i++) {
+ m.put(Collections.singletonList(new BI(i)), true);
}
- for (int i = 0; i < 1000; i++) {
+ for (int i = 0; i < size; i++) {
LexicographicList<BI> bis = new LexicographicList<BI>(new BI(i));
assertTrue(m.containsKey(bis));
}
}
/**
+ * Mixtures of instances of comparable and non-comparable classes
+ * can be inserted and found.
+ */
+ public void testMixedComparable() {
+ int size = 1200; // makes measured test run time -> 35ms
+ ConcurrentHashMap<Object, Object> map =
+ new ConcurrentHashMap<Object, Object>();
+ Random rng = new Random();
+ for (int i = 0; i < size; i++) {
+ Object x;
+ switch (rng.nextInt(4)) {
+ case 0:
+ x = new Object();
+ break;
+ case 1:
+ x = new CollidingObject(Integer.toString(i));
+ break;
+ default:
+ x = new ComparableCollidingObject(Integer.toString(i));
+ }
+ assertNull(map.put(x, x));
+ }
+ int count = 0;
+ for (Object k : map.keySet()) {
+ assertEquals(map.get(k), k);
+ ++count;
+ }
+ assertEquals(count, size);
+ assertEquals(map.size(), size);
+ for (Object k : map.keySet()) {
+ assertEquals(map.put(k, k), k);
+ }
+ }
+
+ /**
* clear removes all pairs
*/
public void testClear() {
@@ -160,6 +231,17 @@
}
/**
+ * hashCode() equals sum of each key.hashCode ^ value.hashCode
+ */
+ public void testHashCode() {
+ ConcurrentHashMap<Integer,String> map = map5();
+ int sum = 0;
+ for (Map.Entry<Integer,String> e : map.entrySet())
+ sum += e.getKey().hashCode() ^ e.getValue().hashCode();
+ assertEquals(sum, map.hashCode());
+ }
+
+ /**
* contains returns true for contained value
*/
public void testContains() {
@@ -210,6 +292,7 @@
assertEquals("A", (String)map.get(one));
ConcurrentHashMap empty = new ConcurrentHashMap();
assertNull(map.get("anything"));
+ assertNull(empty.get("anything"));
}
/**
@@ -443,29 +526,9 @@
// Exception tests
/**
- * Cannot create with negative capacity
- */
- public void testConstructor1() {
- try {
- new ConcurrentHashMap(-1,0,1);
- shouldThrow();
- } catch (IllegalArgumentException success) {}
- }
-
- /**
- * Cannot create with negative concurrency level
- */
- public void testConstructor2() {
- try {
- new ConcurrentHashMap(1,0,-1);
- shouldThrow();
- } catch (IllegalArgumentException success) {}
- }
-
- /**
* Cannot create with only negative capacity
*/
- public void testConstructor3() {
+ public void testConstructor1() {
try {
new ConcurrentHashMap(-1);
shouldThrow();
@@ -473,11 +536,71 @@
}
/**
+ * Constructor (initialCapacity, loadFactor) throws
+ * IllegalArgumentException if either argument is negative
+ */
+ public void testConstructor2() {
+ try {
+ new ConcurrentHashMap(-1, .75f);
+ shouldThrow();
+ } catch (IllegalArgumentException success) {}
+
+ try {
+ new ConcurrentHashMap(16, -1);
+ shouldThrow();
+ } catch (IllegalArgumentException success) {}
+ }
+
+ /**
+ * Constructor (initialCapacity, loadFactor, concurrencyLevel)
+ * throws IllegalArgumentException if any argument is negative
+ */
+ public void testConstructor3() {
+ try {
+ new ConcurrentHashMap(-1, .75f, 1);
+ shouldThrow();
+ } catch (IllegalArgumentException success) {}
+
+ try {
+ new ConcurrentHashMap(16, -1, 1);
+ shouldThrow();
+ } catch (IllegalArgumentException success) {}
+
+ try {
+ new ConcurrentHashMap(16, .75f, -1);
+ shouldThrow();
+ } catch (IllegalArgumentException success) {}
+ }
+
+ /**
+ * ConcurrentHashMap(map) throws NullPointerException if the given
+ * map is null
+ */
+ public void testConstructor4() {
+ try {
+ new ConcurrentHashMap(null);
+ shouldThrow();
+ } catch (NullPointerException success) {}
+ }
+
+ /**
+ * ConcurrentHashMap(map) creates a new map with the same mappings
+ * as the given map
+ */
+ public void testConstructor5() {
+ ConcurrentHashMap map1 = map5();
+ ConcurrentHashMap map2 = new ConcurrentHashMap(map5());
+ assertTrue(map2.equals(map1));
+ map2.put(one, "F");
+ assertFalse(map2.equals(map1));
+ }
+
+ /**
* get(null) throws NPE
*/
public void testGet_NullPointerException() {
+ ConcurrentHashMap c = new ConcurrentHashMap(5);
try {
- ConcurrentHashMap c = new ConcurrentHashMap(5);
c.get(null);
shouldThrow();
} catch (NullPointerException success) {}
@@ -487,8 +610,8 @@
* containsKey(null) throws NPE
*/
public void testContainsKey_NullPointerException() {
+ ConcurrentHashMap c = new ConcurrentHashMap(5);
try {
- ConcurrentHashMap c = new ConcurrentHashMap(5);
c.containsKey(null);
shouldThrow();
} catch (NullPointerException success) {}
@@ -498,8 +621,8 @@
* containsValue(null) throws NPE
*/
public void testContainsValue_NullPointerException() {
+ ConcurrentHashMap c = new ConcurrentHashMap(5);
try {
- ConcurrentHashMap c = new ConcurrentHashMap(5);
c.containsValue(null);
shouldThrow();
} catch (NullPointerException success) {}
@@ -509,8 +632,8 @@
* contains(null) throws NPE
*/
public void testContains_NullPointerException() {
+ ConcurrentHashMap c = new ConcurrentHashMap(5);
try {
- ConcurrentHashMap c = new ConcurrentHashMap(5);
c.contains(null);
shouldThrow();
} catch (NullPointerException success) {}
@@ -520,8 +643,8 @@
* put(null,x) throws NPE
*/
public void testPut1_NullPointerException() {
+ ConcurrentHashMap c = new ConcurrentHashMap(5);
try {
- ConcurrentHashMap c = new ConcurrentHashMap(5);
c.put(null, "whatever");
shouldThrow();
} catch (NullPointerException success) {}
@@ -531,8 +654,8 @@
* put(x, null) throws NPE
*/
public void testPut2_NullPointerException() {
+ ConcurrentHashMap c = new ConcurrentHashMap(5);
try {
- ConcurrentHashMap c = new ConcurrentHashMap(5);
c.put("whatever", null);
shouldThrow();
} catch (NullPointerException success) {}
@@ -542,8 +665,8 @@
* putIfAbsent(null, x) throws NPE
*/
public void testPutIfAbsent1_NullPointerException() {
+ ConcurrentHashMap c = new ConcurrentHashMap(5);
try {
- ConcurrentHashMap c = new ConcurrentHashMap(5);
c.putIfAbsent(null, "whatever");
shouldThrow();
} catch (NullPointerException success) {}
@@ -553,8 +676,8 @@
* replace(null, x) throws NPE
*/
public void testReplace_NullPointerException() {
+ ConcurrentHashMap c = new ConcurrentHashMap(5);
try {
- ConcurrentHashMap c = new ConcurrentHashMap(5);
c.replace(null, "whatever");
shouldThrow();
} catch (NullPointerException success) {}
@@ -564,8 +687,8 @@
* replace(null, x, y) throws NPE
*/
public void testReplaceValue_NullPointerException() {
+ ConcurrentHashMap c = new ConcurrentHashMap(5);
try {
- ConcurrentHashMap c = new ConcurrentHashMap(5);
c.replace(null, one, "whatever");
shouldThrow();
} catch (NullPointerException success) {}
@@ -575,8 +698,8 @@
* putIfAbsent(x, null) throws NPE
*/
public void testPutIfAbsent2_NullPointerException() {
+ ConcurrentHashMap c = new ConcurrentHashMap(5);
try {
- ConcurrentHashMap c = new ConcurrentHashMap(5);
c.putIfAbsent("whatever", null);
shouldThrow();
} catch (NullPointerException success) {}
@@ -586,8 +709,8 @@
* replace(x, null) throws NPE
*/
public void testReplace2_NullPointerException() {
+ ConcurrentHashMap c = new ConcurrentHashMap(5);
try {
- ConcurrentHashMap c = new ConcurrentHashMap(5);
c.replace("whatever", null);
shouldThrow();
} catch (NullPointerException success) {}
@@ -597,8 +720,8 @@
* replace(x, null, y) throws NPE
*/
public void testReplaceValue2_NullPointerException() {
+ ConcurrentHashMap c = new ConcurrentHashMap(5);
try {
- ConcurrentHashMap c = new ConcurrentHashMap(5);
c.replace("whatever", null, "A");
shouldThrow();
} catch (NullPointerException success) {}
@@ -608,8 +731,8 @@
* replace(x, y, null) throws NPE
*/
public void testReplaceValue3_NullPointerException() {
+ ConcurrentHashMap c = new ConcurrentHashMap(5);
try {
- ConcurrentHashMap c = new ConcurrentHashMap(5);
c.replace("whatever", one, null);
shouldThrow();
} catch (NullPointerException success) {}
@@ -619,9 +742,9 @@
* remove(null) throws NPE
*/
public void testRemove1_NullPointerException() {
+ ConcurrentHashMap c = new ConcurrentHashMap(5);
+ c.put("sadsdf", "asdads");
try {
- ConcurrentHashMap c = new ConcurrentHashMap(5);
- c.put("sadsdf", "asdads");
c.remove(null);
shouldThrow();
} catch (NullPointerException success) {}
@@ -631,9 +754,9 @@
* remove(null, x) throws NPE
*/
public void testRemove2_NullPointerException() {
+ ConcurrentHashMap c = new ConcurrentHashMap(5);
+ c.put("sadsdf", "asdads");
try {
- ConcurrentHashMap c = new ConcurrentHashMap(5);
- c.put("sadsdf", "asdads");
c.remove(null, "whatever");
shouldThrow();
} catch (NullPointerException success) {}
diff --git a/jsr166-tests/src/test/java/jsr166/ConcurrentLinkedDequeTest.java b/jsr166-tests/src/test/java/jsr166/ConcurrentLinkedDequeTest.java
index f5b8318..c445957 100644
--- a/jsr166-tests/src/test/java/jsr166/ConcurrentLinkedDequeTest.java
+++ b/jsr166-tests/src/test/java/jsr166/ConcurrentLinkedDequeTest.java
@@ -8,17 +8,30 @@
package jsr166;
-import junit.framework.*;
import java.util.Arrays;
import java.util.Collection;
+import java.util.Deque;
import java.util.Iterator;
import java.util.NoSuchElementException;
import java.util.Queue;
import java.util.Random;
import java.util.concurrent.ConcurrentLinkedDeque;
+import junit.framework.Test;
+import junit.framework.TestSuite;
+
public class ConcurrentLinkedDequeTest extends JSR166TestCase {
+ // android-note: Removed because the CTS runner does a bad job of
+ // retrying tests that have suite() declarations.
+ //
+ // public static void main(String[] args) {
+ // main(suite(), args);
+ // }
+ // public static Test suite() {
+ // return new TestSuite(...);
+ // }
+
/**
* Returns a new deque of given size containing consecutive
* Integers 0 ... n.
@@ -46,7 +59,7 @@
*/
public void testConstructor3() {
try {
- ConcurrentLinkedDeque q = new ConcurrentLinkedDeque((Collection)null);
+ new ConcurrentLinkedDeque((Collection)null);
shouldThrow();
} catch (NullPointerException success) {}
}
@@ -57,7 +70,7 @@
public void testConstructor4() {
try {
Integer[] ints = new Integer[SIZE];
- ConcurrentLinkedDeque q = new ConcurrentLinkedDeque(Arrays.asList(ints));
+ new ConcurrentLinkedDeque(Arrays.asList(ints));
shouldThrow();
} catch (NullPointerException success) {}
}
@@ -70,7 +83,7 @@
Integer[] ints = new Integer[SIZE];
for (int i = 0; i < SIZE-1; ++i)
ints[i] = new Integer(i);
- ConcurrentLinkedDeque q = new ConcurrentLinkedDeque(Arrays.asList(ints));
+ new ConcurrentLinkedDeque(Arrays.asList(ints));
shouldThrow();
} catch (NullPointerException success) {}
}
@@ -428,13 +441,13 @@
*/
public void testRemoveElement() {
ConcurrentLinkedDeque q = populatedDeque(SIZE);
- for (int i = 1; i < SIZE; i+=2) {
+ for (int i = 1; i < SIZE; i += 2) {
assertTrue(q.contains(i));
assertTrue(q.remove(i));
assertFalse(q.contains(i));
assertTrue(q.contains(i-1));
}
- for (int i = 0; i < SIZE; i+=2) {
+ for (int i = 0; i < SIZE; i += 2) {
assertTrue(q.contains(i));
assertTrue(q.remove(i));
assertFalse(q.contains(i));
@@ -538,10 +551,10 @@
*/
public void testRemoveFirstOccurrence() {
ConcurrentLinkedDeque q = populatedDeque(SIZE);
- for (int i = 1; i < SIZE; i+=2) {
+ for (int i = 1; i < SIZE; i += 2) {
assertTrue(q.removeFirstOccurrence(new Integer(i)));
}
- for (int i = 0; i < SIZE; i+=2) {
+ for (int i = 0; i < SIZE; i += 2) {
assertTrue(q.removeFirstOccurrence(new Integer(i)));
assertFalse(q.removeFirstOccurrence(new Integer(i+1)));
}
@@ -553,10 +566,10 @@
*/
public void testRemoveLastOccurrence() {
ConcurrentLinkedDeque q = populatedDeque(SIZE);
- for (int i = 1; i < SIZE; i+=2) {
+ for (int i = 1; i < SIZE; i += 2) {
assertTrue(q.removeLastOccurrence(new Integer(i)));
}
- for (int i = 0; i < SIZE; i+=2) {
+ for (int i = 0; i < SIZE; i += 2) {
assertTrue(q.removeLastOccurrence(new Integer(i)));
assertFalse(q.removeLastOccurrence(new Integer(i+1)));
}
@@ -632,8 +645,8 @@
assertTrue(q.removeAll(p));
assertEquals(SIZE-i, q.size());
for (int j = 0; j < i; ++j) {
- Integer I = (Integer)(p.remove());
- assertFalse(q.contains(I));
+ Integer x = (Integer)(p.remove());
+ assertFalse(q.contains(x));
}
}
}
@@ -687,13 +700,21 @@
*/
public void testIterator() {
ConcurrentLinkedDeque q = populatedDeque(SIZE);
- int i = 0;
Iterator it = q.iterator();
- while (it.hasNext()) {
+ int i;
+ for (i = 0; it.hasNext(); i++)
assertTrue(q.contains(it.next()));
- ++i;
- }
assertEquals(i, SIZE);
+ assertIteratorExhausted(it);
+ }
+
+ /**
+ * iterator of empty collection has no elements
+ */
+ public void testEmptyIterator() {
+ Deque c = new ConcurrentLinkedDeque();
+ assertIteratorExhausted(c.iterator());
+ assertIteratorExhausted(c.descendingIterator());
}
/**
@@ -855,4 +876,30 @@
assertTrue(y.isEmpty());
}
+ /**
+ * contains(null) always return false.
+ * remove(null) always throws NullPointerException.
+ */
+ public void testNeverContainsNull() {
+ Deque<?>[] qs = {
+ new ConcurrentLinkedDeque<Object>(),
+ populatedDeque(2),
+ };
+
+ for (Deque<?> q : qs) {
+ assertFalse(q.contains(null));
+ try {
+ assertFalse(q.remove(null));
+ shouldThrow();
+ } catch (NullPointerException success) {}
+ try {
+ assertFalse(q.removeFirstOccurrence(null));
+ shouldThrow();
+ } catch (NullPointerException success) {}
+ try {
+ assertFalse(q.removeLastOccurrence(null));
+ shouldThrow();
+ } catch (NullPointerException success) {}
+ }
+ }
}
diff --git a/jsr166-tests/src/test/java/jsr166/ConcurrentLinkedQueueTest.java b/jsr166-tests/src/test/java/jsr166/ConcurrentLinkedQueueTest.java
index 7924034..d3f5b1f 100644
--- a/jsr166-tests/src/test/java/jsr166/ConcurrentLinkedQueueTest.java
+++ b/jsr166-tests/src/test/java/jsr166/ConcurrentLinkedQueueTest.java
@@ -8,7 +8,6 @@
package jsr166;
-import junit.framework.*;
import java.util.Arrays;
import java.util.Collection;
import java.util.Iterator;
@@ -16,8 +15,21 @@
import java.util.Queue;
import java.util.concurrent.ConcurrentLinkedQueue;
+import junit.framework.Test;
+import junit.framework.TestSuite;
+
public class ConcurrentLinkedQueueTest extends JSR166TestCase {
+ // android-note: Removed because the CTS runner does a bad job of
+ // retrying tests that have suite() declarations.
+ //
+ // public static void main(String[] args) {
+ // main(suite(), args);
+ // }
+ // public static Test suite() {
+ // return new TestSuite(...);
+ // }
+
/**
* Returns a new queue of given size containing consecutive
* Integers 0 ... n.
@@ -44,7 +56,7 @@
*/
public void testConstructor3() {
try {
- ConcurrentLinkedQueue q = new ConcurrentLinkedQueue((Collection)null);
+ new ConcurrentLinkedQueue((Collection)null);
shouldThrow();
} catch (NullPointerException success) {}
}
@@ -55,7 +67,7 @@
public void testConstructor4() {
try {
Integer[] ints = new Integer[SIZE];
- ConcurrentLinkedQueue q = new ConcurrentLinkedQueue(Arrays.asList(ints));
+ new ConcurrentLinkedQueue(Arrays.asList(ints));
shouldThrow();
} catch (NullPointerException success) {}
}
@@ -68,7 +80,7 @@
Integer[] ints = new Integer[SIZE];
for (int i = 0; i < SIZE-1; ++i)
ints[i] = new Integer(i);
- ConcurrentLinkedQueue q = new ConcurrentLinkedQueue(Arrays.asList(ints));
+ new ConcurrentLinkedQueue(Arrays.asList(ints));
shouldThrow();
} catch (NullPointerException success) {}
}
@@ -279,13 +291,13 @@
*/
public void testRemoveElement() {
ConcurrentLinkedQueue q = populatedQueue(SIZE);
- for (int i = 1; i < SIZE; i+=2) {
+ for (int i = 1; i < SIZE; i += 2) {
assertTrue(q.contains(i));
assertTrue(q.remove(i));
assertFalse(q.contains(i));
assertTrue(q.contains(i-1));
}
- for (int i = 0; i < SIZE; i+=2) {
+ for (int i = 0; i < SIZE; i += 2) {
assertTrue(q.contains(i));
assertTrue(q.remove(i));
assertFalse(q.contains(i));
@@ -364,8 +376,8 @@
assertTrue(q.removeAll(p));
assertEquals(SIZE-i, q.size());
for (int j = 0; j < i; ++j) {
- Integer I = (Integer)(p.remove());
- assertFalse(q.contains(I));
+ Integer x = (Integer)(p.remove());
+ assertFalse(q.contains(x));
}
}
}
@@ -419,13 +431,19 @@
*/
public void testIterator() {
ConcurrentLinkedQueue q = populatedQueue(SIZE);
- int i = 0;
Iterator it = q.iterator();
- while (it.hasNext()) {
+ int i;
+ for (i = 0; it.hasNext(); i++)
assertTrue(q.contains(it.next()));
- ++i;
- }
assertEquals(i, SIZE);
+ assertIteratorExhausted(it);
+ }
+
+ /**
+ * iterator of empty collection has no elements
+ */
+ public void testEmptyIterator() {
+ assertIteratorExhausted(new ConcurrentLinkedQueue().iterator());
}
/**
@@ -508,4 +526,18 @@
assertTrue(y.isEmpty());
}
+ /**
+ * remove(null), contains(null) always return false
+ */
+ public void testNeverContainsNull() {
+ Collection<?>[] qs = {
+ new ConcurrentLinkedQueue<Object>(),
+ populatedQueue(2),
+ };
+
+ for (Collection<?> q : qs) {
+ assertFalse(q.contains(null));
+ assertFalse(q.remove(null));
+ }
+ }
}
diff --git a/jsr166-tests/src/test/java/jsr166/ConcurrentSkipListMapTest.java b/jsr166-tests/src/test/java/jsr166/ConcurrentSkipListMapTest.java
index 4359287..0aadd23 100644
--- a/jsr166-tests/src/test/java/jsr166/ConcurrentSkipListMapTest.java
+++ b/jsr166-tests/src/test/java/jsr166/ConcurrentSkipListMapTest.java
@@ -6,11 +6,32 @@
package jsr166;
-import junit.framework.*;
-import java.util.*;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.BitSet;
+import java.util.Collection;
+import java.util.Iterator;
+import java.util.Map;
+import java.util.NavigableMap;
+import java.util.NavigableSet;
+import java.util.NoSuchElementException;
+import java.util.Random;
+import java.util.Set;
import java.util.concurrent.ConcurrentSkipListMap;
+import junit.framework.Test;
+import junit.framework.TestSuite;
+
public class ConcurrentSkipListMapTest extends JSR166TestCase {
+ // android-note: Removed because the CTS runner does a bad job of
+ // retrying tests that have suite() declarations.
+ //
+ // public static void main(String[] args) {
+ // main(suite(), args);
+ // }
+ // public static Test suite() {
+ // return new TestSuite(...);
+ // }
/**
* Returns a new map from Integers 1-5 to Strings "A"-"E".
@@ -678,8 +699,8 @@
* get(null) of nonempty map throws NPE
*/
public void testGet_NullPointerException() {
+ ConcurrentSkipListMap c = map5();
try {
- ConcurrentSkipListMap c = map5();
c.get(null);
shouldThrow();
} catch (NullPointerException success) {}
@@ -689,8 +710,8 @@
* containsKey(null) of nonempty map throws NPE
*/
public void testContainsKey_NullPointerException() {
+ ConcurrentSkipListMap c = map5();
try {
- ConcurrentSkipListMap c = map5();
c.containsKey(null);
shouldThrow();
} catch (NullPointerException success) {}
@@ -700,8 +721,8 @@
* containsValue(null) throws NPE
*/
public void testContainsValue_NullPointerException() {
+ ConcurrentSkipListMap c = new ConcurrentSkipListMap();
try {
- ConcurrentSkipListMap c = new ConcurrentSkipListMap();
c.containsValue(null);
shouldThrow();
} catch (NullPointerException success) {}
@@ -711,8 +732,8 @@
* put(null,x) throws NPE
*/
public void testPut1_NullPointerException() {
+ ConcurrentSkipListMap c = map5();
try {
- ConcurrentSkipListMap c = map5();
c.put(null, "whatever");
shouldThrow();
} catch (NullPointerException success) {}
@@ -722,8 +743,8 @@
* putIfAbsent(null, x) throws NPE
*/
public void testPutIfAbsent1_NullPointerException() {
+ ConcurrentSkipListMap c = map5();
try {
- ConcurrentSkipListMap c = map5();
c.putIfAbsent(null, "whatever");
shouldThrow();
} catch (NullPointerException success) {}
@@ -733,8 +754,8 @@
* replace(null, x) throws NPE
*/
public void testReplace_NullPointerException() {
+ ConcurrentSkipListMap c = map5();
try {
- ConcurrentSkipListMap c = map5();
c.replace(null, "whatever");
shouldThrow();
} catch (NullPointerException success) {}
@@ -744,8 +765,8 @@
* replace(null, x, y) throws NPE
*/
public void testReplaceValue_NullPointerException() {
+ ConcurrentSkipListMap c = map5();
try {
- ConcurrentSkipListMap c = map5();
c.replace(null, one, "whatever");
shouldThrow();
} catch (NullPointerException success) {}
@@ -755,9 +776,9 @@
* remove(null) throws NPE
*/
public void testRemove1_NullPointerException() {
+ ConcurrentSkipListMap c = new ConcurrentSkipListMap();
+ c.put("sadsdf", "asdads");
try {
- ConcurrentSkipListMap c = new ConcurrentSkipListMap();
- c.put("sadsdf", "asdads");
c.remove(null);
shouldThrow();
} catch (NullPointerException success) {}
@@ -767,9 +788,9 @@
* remove(null, x) throws NPE
*/
public void testRemove2_NullPointerException() {
+ ConcurrentSkipListMap c = new ConcurrentSkipListMap();
+ c.put("sadsdf", "asdads");
try {
- ConcurrentSkipListMap c = new ConcurrentSkipListMap();
- c.put("sadsdf", "asdads");
c.remove(null, "whatever");
shouldThrow();
} catch (NullPointerException success) {}
@@ -1014,7 +1035,7 @@
// Add entries till we're back to original size
while (map.size() < size) {
int key = min + rnd.nextInt(rangeSize);
- assertTrue(key >= min && key<= max);
+ assertTrue(key >= min && key <= max);
put(map, key);
}
}
@@ -1039,7 +1060,7 @@
// Add entries till we're back to original size
while (map.size() < size) {
int key = min - 5 + rnd.nextInt(rangeSize + 10);
- if (key >= min && key<= max) {
+ if (key >= min && key <= max) {
put(map, key);
} else {
try {
diff --git a/jsr166-tests/src/test/java/jsr166/ConcurrentSkipListSetTest.java b/jsr166-tests/src/test/java/jsr166/ConcurrentSkipListSetTest.java
index 1fd3c5f..41f8835 100644
--- a/jsr166-tests/src/test/java/jsr166/ConcurrentSkipListSetTest.java
+++ b/jsr166-tests/src/test/java/jsr166/ConcurrentSkipListSetTest.java
@@ -6,7 +6,6 @@
package jsr166;
-import junit.framework.*;
import java.util.Arrays;
import java.util.BitSet;
import java.util.Collection;
@@ -19,7 +18,19 @@
import java.util.SortedSet;
import java.util.concurrent.ConcurrentSkipListSet;
+import junit.framework.Test;
+import junit.framework.TestSuite;
+
public class ConcurrentSkipListSetTest extends JSR166TestCase {
+ // android-note: Removed because the CTS runner does a bad job of
+ // retrying tests that have suite() declarations.
+ //
+ // public static void main(String[] args) {
+ // main(suite(), args);
+ // }
+ // public static Test suite() {
+ // return new TestSuite(...);
+ // }
static class MyReverseComparator implements Comparator {
public int compare(Object x, Object y) {
@@ -35,9 +46,9 @@
ConcurrentSkipListSet<Integer> q =
new ConcurrentSkipListSet<Integer>();
assertTrue(q.isEmpty());
- for (int i = n-1; i >= 0; i-=2)
+ for (int i = n-1; i >= 0; i -= 2)
assertTrue(q.add(new Integer(i)));
- for (int i = (n & 1); i < n; i+=2)
+ for (int i = (n & 1); i < n; i += 2)
assertTrue(q.add(new Integer(i)));
assertFalse(q.isEmpty());
assertEquals(n, q.size());
@@ -71,7 +82,7 @@
*/
public void testConstructor3() {
try {
- ConcurrentSkipListSet q = new ConcurrentSkipListSet((Collection)null);
+ new ConcurrentSkipListSet((Collection)null);
shouldThrow();
} catch (NullPointerException success) {}
}
@@ -82,7 +93,7 @@
public void testConstructor4() {
try {
Integer[] ints = new Integer[SIZE];
- ConcurrentSkipListSet q = new ConcurrentSkipListSet(Arrays.asList(ints));
+ new ConcurrentSkipListSet(Arrays.asList(ints));
shouldThrow();
} catch (NullPointerException success) {}
}
@@ -95,7 +106,7 @@
Integer[] ints = new Integer[SIZE];
for (int i = 0; i < SIZE-1; ++i)
ints[i] = new Integer(i);
- ConcurrentSkipListSet q = new ConcurrentSkipListSet(Arrays.asList(ints));
+ new ConcurrentSkipListSet(Arrays.asList(ints));
shouldThrow();
} catch (NullPointerException success) {}
}
@@ -160,8 +171,8 @@
* add(null) throws NPE
*/
public void testAddNull() {
+ ConcurrentSkipListSet q = new ConcurrentSkipListSet();
try {
- ConcurrentSkipListSet q = new ConcurrentSkipListSet();
q.add(null);
shouldThrow();
} catch (NullPointerException success) {}
@@ -189,9 +200,8 @@
* Add of non-Comparable throws CCE
*/
public void testAddNonComparable() {
+ ConcurrentSkipListSet q = new ConcurrentSkipListSet();
try {
- ConcurrentSkipListSet q = new ConcurrentSkipListSet();
- q.add(new Object());
q.add(new Object());
q.add(new Object());
shouldThrow();
@@ -202,8 +212,8 @@
* addAll(null) throws NPE
*/
public void testAddAll1() {
+ ConcurrentSkipListSet q = new ConcurrentSkipListSet();
try {
- ConcurrentSkipListSet q = new ConcurrentSkipListSet();
q.addAll(null);
shouldThrow();
} catch (NullPointerException success) {}
@@ -213,9 +223,9 @@
* addAll of a collection with null elements throws NPE
*/
public void testAddAll2() {
+ ConcurrentSkipListSet q = new ConcurrentSkipListSet();
+ Integer[] ints = new Integer[SIZE];
try {
- ConcurrentSkipListSet q = new ConcurrentSkipListSet();
- Integer[] ints = new Integer[SIZE];
q.addAll(Arrays.asList(ints));
shouldThrow();
} catch (NullPointerException success) {}
@@ -226,11 +236,11 @@
* possibly adding some elements
*/
public void testAddAll3() {
+ ConcurrentSkipListSet q = new ConcurrentSkipListSet();
+ Integer[] ints = new Integer[SIZE];
+ for (int i = 0; i < SIZE-1; ++i)
+ ints[i] = new Integer(i);
try {
- ConcurrentSkipListSet q = new ConcurrentSkipListSet();
- Integer[] ints = new Integer[SIZE];
- for (int i = 0; i < SIZE-1; ++i)
- ints[i] = new Integer(i);
q.addAll(Arrays.asList(ints));
shouldThrow();
} catch (NullPointerException success) {}
@@ -278,13 +288,13 @@
*/
public void testRemoveElement() {
ConcurrentSkipListSet q = populatedSet(SIZE);
- for (int i = 1; i < SIZE; i+=2) {
+ for (int i = 1; i < SIZE; i += 2) {
assertTrue(q.contains(i));
assertTrue(q.remove(i));
assertFalse(q.contains(i));
assertTrue(q.contains(i-1));
}
- for (int i = 0; i < SIZE; i+=2) {
+ for (int i = 0; i < SIZE; i += 2) {
assertTrue(q.contains(i));
assertTrue(q.remove(i));
assertFalse(q.contains(i));
@@ -363,8 +373,8 @@
assertTrue(q.removeAll(p));
assertEquals(SIZE-i, q.size());
for (int j = 0; j < i; ++j) {
- Integer I = (Integer)(p.pollFirst());
- assertFalse(q.contains(I));
+ Integer x = (Integer)(p.pollFirst());
+ assertFalse(q.contains(x));
}
}
}
@@ -467,27 +477,21 @@
*/
public void testIterator() {
ConcurrentSkipListSet q = populatedSet(SIZE);
- int i = 0;
Iterator it = q.iterator();
- while (it.hasNext()) {
+ int i;
+ for (i = 0; it.hasNext(); i++)
assertTrue(q.contains(it.next()));
- ++i;
- }
assertEquals(i, SIZE);
+ assertIteratorExhausted(it);
}
/**
* iterator of empty set has no elements
*/
public void testEmptyIterator() {
- ConcurrentSkipListSet q = new ConcurrentSkipListSet();
- int i = 0;
- Iterator it = q.iterator();
- while (it.hasNext()) {
- assertTrue(q.contains(it.next()));
- ++i;
- }
- assertEquals(0, i);
+ NavigableSet s = new ConcurrentSkipListSet();
+ assertIteratorExhausted(s.iterator());
+ assertIteratorExhausted(s.descendingSet().iterator());
}
/**
@@ -726,7 +730,7 @@
// Add entries till we're back to original size
while (set.size() < size) {
int element = min + rnd.nextInt(rangeSize);
- assertTrue(element >= min && element<= max);
+ assertTrue(element >= min && element <= max);
put(set, element, bs);
}
}
@@ -752,7 +756,7 @@
// Add entries till we're back to original size
while (set.size() < size) {
int element = min - 5 + rnd.nextInt(rangeSize + 10);
- if (element >= min && element<= max) {
+ if (element >= min && element <= max) {
put(set, element, bs);
} else {
try {
diff --git a/jsr166-tests/src/test/java/jsr166/ConcurrentSkipListSubMapTest.java b/jsr166-tests/src/test/java/jsr166/ConcurrentSkipListSubMapTest.java
index 7247657..5315bcb 100644
--- a/jsr166-tests/src/test/java/jsr166/ConcurrentSkipListSubMapTest.java
+++ b/jsr166-tests/src/test/java/jsr166/ConcurrentSkipListSubMapTest.java
@@ -6,12 +6,30 @@
package jsr166;
-import junit.framework.*;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.Iterator;
+import java.util.Map;
+import java.util.NavigableMap;
+import java.util.Set;
+import java.util.SortedMap;
import java.util.concurrent.ConcurrentNavigableMap;
import java.util.concurrent.ConcurrentSkipListMap;
-import java.util.*;
+
+import junit.framework.Test;
+import junit.framework.TestSuite;
public class ConcurrentSkipListSubMapTest extends JSR166TestCase {
+ // android-note: Removed because the CTS runner does a bad job of
+ // retrying tests that have suite() declarations.
+ //
+ // public static void main(String[] args) {
+ // main(suite(), args);
+ // }
+ // public static Test suite() {
+ // return new TestSuite(...);
+ // }
/**
* Returns a new map from Integers 1-5 to Strings "A"-"E".
diff --git a/jsr166-tests/src/test/java/jsr166/ConcurrentSkipListSubSetTest.java b/jsr166-tests/src/test/java/jsr166/ConcurrentSkipListSubSetTest.java
index 43c1759..f1c4aae 100644
--- a/jsr166-tests/src/test/java/jsr166/ConcurrentSkipListSubSetTest.java
+++ b/jsr166-tests/src/test/java/jsr166/ConcurrentSkipListSubSetTest.java
@@ -6,20 +6,26 @@
package jsr166;
-import junit.framework.*;
import java.util.Arrays;
-import java.util.BitSet;
-import java.util.Collection;
import java.util.Comparator;
import java.util.Iterator;
import java.util.NavigableSet;
-import java.util.NoSuchElementException;
-import java.util.Random;
-import java.util.Set;
import java.util.SortedSet;
import java.util.concurrent.ConcurrentSkipListSet;
+import junit.framework.Test;
+import junit.framework.TestSuite;
+
public class ConcurrentSkipListSubSetTest extends JSR166TestCase {
+ // android-note: Removed because the CTS runner does a bad job of
+ // retrying tests that have suite() declarations.
+ //
+ // public static void main(String[] args) {
+ // main(suite(), args);
+ // }
+ // public static Test suite() {
+ // return new TestSuite(...);
+ // }
static class MyReverseComparator implements Comparator {
public int compare(Object x, Object y) {
@@ -36,9 +42,9 @@
new ConcurrentSkipListSet<Integer>();
assertTrue(q.isEmpty());
- for (int i = n-1; i >= 0; i-=2)
+ for (int i = n-1; i >= 0; i -= 2)
assertTrue(q.add(new Integer(i)));
- for (int i = (n & 1); i < n; i+=2)
+ for (int i = (n & 1); i < n; i += 2)
assertTrue(q.add(new Integer(i)));
assertTrue(q.add(new Integer(-n)));
assertTrue(q.add(new Integer(n)));
@@ -134,8 +140,8 @@
* add(null) throws NPE
*/
public void testAddNull() {
+ NavigableSet q = set0();
try {
- NavigableSet q = set0();
q.add(null);
shouldThrow();
} catch (NullPointerException success) {}
@@ -162,9 +168,8 @@
* Add of non-Comparable throws CCE
*/
public void testAddNonComparable() {
+ NavigableSet q = set0();
try {
- NavigableSet q = set0();
- q.add(new Object());
q.add(new Object());
q.add(new Object());
shouldThrow();
@@ -175,8 +180,8 @@
* addAll(null) throws NPE
*/
public void testAddAll1() {
+ NavigableSet q = set0();
try {
- NavigableSet q = set0();
q.addAll(null);
shouldThrow();
} catch (NullPointerException success) {}
@@ -186,9 +191,9 @@
* addAll of a collection with null elements throws NPE
*/
public void testAddAll2() {
+ NavigableSet q = set0();
+ Integer[] ints = new Integer[SIZE];
try {
- NavigableSet q = set0();
- Integer[] ints = new Integer[SIZE];
q.addAll(Arrays.asList(ints));
shouldThrow();
} catch (NullPointerException success) {}
@@ -199,11 +204,11 @@
* possibly adding some elements
*/
public void testAddAll3() {
+ NavigableSet q = set0();
+ Integer[] ints = new Integer[SIZE];
+ for (int i = 0; i < SIZE-1; ++i)
+ ints[i] = new Integer(i+SIZE);
try {
- NavigableSet q = set0();
- Integer[] ints = new Integer[SIZE];
- for (int i = 0; i < SIZE-1; ++i)
- ints[i] = new Integer(i+SIZE);
q.addAll(Arrays.asList(ints));
shouldThrow();
} catch (NullPointerException success) {}
@@ -240,13 +245,13 @@
*/
public void testRemoveElement() {
NavigableSet q = populatedSet(SIZE);
- for (int i = 1; i < SIZE; i+=2) {
+ for (int i = 1; i < SIZE; i += 2) {
assertTrue(q.contains(i));
assertTrue(q.remove(i));
assertFalse(q.contains(i));
assertTrue(q.contains(i-1));
}
- for (int i = 0; i < SIZE; i+=2) {
+ for (int i = 0; i < SIZE; i += 2) {
assertTrue(q.contains(i));
assertTrue(q.remove(i));
assertFalse(q.contains(i));
@@ -325,8 +330,8 @@
assertTrue(q.removeAll(p));
assertEquals(SIZE-i, q.size());
for (int j = 0; j < i; ++j) {
- Integer I = (Integer)(p.pollFirst());
- assertFalse(q.contains(I));
+ Integer x = (Integer)(p.pollFirst());
+ assertFalse(q.contains(x));
}
}
}
@@ -430,27 +435,19 @@
*/
public void testIterator() {
NavigableSet q = populatedSet(SIZE);
- int i = 0;
Iterator it = q.iterator();
- while (it.hasNext()) {
+ int i;
+ for (i = 0; it.hasNext(); i++)
assertTrue(q.contains(it.next()));
- ++i;
- }
assertEquals(i, SIZE);
+ assertIteratorExhausted(it);
}
/**
* iterator of empty set has no elements
*/
public void testEmptyIterator() {
- NavigableSet q = set0();
- int i = 0;
- Iterator it = q.iterator();
- while (it.hasNext()) {
- assertTrue(q.contains(it.next()));
- ++i;
- }
- assertEquals(0, i);
+ assertIteratorExhausted(set0().iterator());
}
/**
@@ -639,8 +636,8 @@
* add(null) throws NPE
*/
public void testDescendingAddNull() {
+ NavigableSet q = dset0();
try {
- NavigableSet q = dset0();
q.add(null);
shouldThrow();
} catch (NullPointerException success) {}
@@ -667,9 +664,8 @@
* Add of non-Comparable throws CCE
*/
public void testDescendingAddNonComparable() {
+ NavigableSet q = dset0();
try {
- NavigableSet q = dset0();
- q.add(new Object());
q.add(new Object());
q.add(new Object());
shouldThrow();
@@ -680,8 +676,8 @@
* addAll(null) throws NPE
*/
public void testDescendingAddAll1() {
+ NavigableSet q = dset0();
try {
- NavigableSet q = dset0();
q.addAll(null);
shouldThrow();
} catch (NullPointerException success) {}
@@ -691,9 +687,9 @@
* addAll of a collection with null elements throws NPE
*/
public void testDescendingAddAll2() {
+ NavigableSet q = dset0();
+ Integer[] ints = new Integer[SIZE];
try {
- NavigableSet q = dset0();
- Integer[] ints = new Integer[SIZE];
q.addAll(Arrays.asList(ints));
shouldThrow();
} catch (NullPointerException success) {}
@@ -704,11 +700,11 @@
* possibly adding some elements
*/
public void testDescendingAddAll3() {
+ NavigableSet q = dset0();
+ Integer[] ints = new Integer[SIZE];
+ for (int i = 0; i < SIZE-1; ++i)
+ ints[i] = new Integer(i+SIZE);
try {
- NavigableSet q = dset0();
- Integer[] ints = new Integer[SIZE];
- for (int i = 0; i < SIZE-1; ++i)
- ints[i] = new Integer(i+SIZE);
q.addAll(Arrays.asList(ints));
shouldThrow();
} catch (NullPointerException success) {}
@@ -745,10 +741,10 @@
*/
public void testDescendingRemoveElement() {
NavigableSet q = populatedSet(SIZE);
- for (int i = 1; i < SIZE; i+=2) {
+ for (int i = 1; i < SIZE; i += 2) {
assertTrue(q.remove(new Integer(i)));
}
- for (int i = 0; i < SIZE; i+=2) {
+ for (int i = 0; i < SIZE; i += 2 ) {
assertTrue(q.remove(new Integer(i)));
assertFalse(q.remove(new Integer(i+1)));
}
@@ -824,8 +820,8 @@
assertTrue(q.removeAll(p));
assertEquals(SIZE-i, q.size());
for (int j = 0; j < i; ++j) {
- Integer I = (Integer)(p.pollFirst());
- assertFalse(q.contains(I));
+ Integer x = (Integer)(p.pollFirst());
+ assertFalse(q.contains(x));
}
}
}
diff --git a/jsr166-tests/src/test/java/jsr166/CopyOnWriteArrayListTest.java b/jsr166-tests/src/test/java/jsr166/CopyOnWriteArrayListTest.java
index 6bef8be..658268a 100644
--- a/jsr166-tests/src/test/java/jsr166/CopyOnWriteArrayListTest.java
+++ b/jsr166-tests/src/test/java/jsr166/CopyOnWriteArrayListTest.java
@@ -8,7 +8,6 @@
package jsr166;
-import junit.framework.*;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
@@ -18,11 +17,23 @@
import java.util.List;
import java.util.ListIterator;
import java.util.NoSuchElementException;
-import java.util.Vector;
import java.util.concurrent.CopyOnWriteArrayList;
+import junit.framework.Test;
+import junit.framework.TestSuite;
+
public class CopyOnWriteArrayListTest extends JSR166TestCase {
+ // android-note: Removed because the CTS runner does a bad job of
+ // retrying tests that have suite() declarations.
+ //
+ // public static void main(String[] args) {
+ // main(suite(), args);
+ // }
+ // public static Test suite() {
+ // return new TestSuite(...);
+ // }
+
static CopyOnWriteArrayList<Integer> populatedArray(int n) {
CopyOnWriteArrayList<Integer> a = new CopyOnWriteArrayList<Integer>();
assertTrue(a.isEmpty());
@@ -76,16 +87,14 @@
}
/**
- * addAll adds each element from the given collection
+ * addAll adds each element from the given collection, including duplicates
*/
public void testAddAll() {
CopyOnWriteArrayList full = populatedArray(3);
- Vector v = new Vector();
- v.add(three);
- v.add(four);
- v.add(five);
- full.addAll(v);
+ assertTrue(full.addAll(Arrays.asList(three, four, five)));
assertEquals(6, full.size());
+ assertTrue(full.addAll(Arrays.asList(three, four, five)));
+ assertEquals(9, full.size());
}
/**
@@ -94,11 +103,10 @@
*/
public void testAddAllAbsent() {
CopyOnWriteArrayList full = populatedArray(3);
- Vector v = new Vector();
- v.add(three);
- v.add(four);
- v.add(one); // will not add this element
- full.addAllAbsent(v);
+ // "one" is duplicate and will not be added
+ assertEquals(2, full.addAllAbsent(Arrays.asList(three, four, one)));
+ assertEquals(5, full.size());
+ assertEquals(0, full.addAllAbsent(Arrays.asList(three, four, one)));
assertEquals(5, full.size());
}
@@ -188,12 +196,11 @@
*/
public void testContainsAll() {
CopyOnWriteArrayList full = populatedArray(3);
- Vector v = new Vector();
- v.add(one);
- v.add(two);
- assertTrue(full.containsAll(v));
- v.add(six);
- assertFalse(full.containsAll(v));
+ assertTrue(full.containsAll(Arrays.asList()));
+ assertTrue(full.containsAll(Arrays.asList(one)));
+ assertTrue(full.containsAll(Arrays.asList(one, two)));
+ assertFalse(full.containsAll(Arrays.asList(one, two, six)));
+ assertFalse(full.containsAll(Arrays.asList(six)));
}
/**
@@ -256,11 +263,15 @@
assertTrue(it.hasNext());
assertEquals(elements[j], it.next());
}
- assertFalse(it.hasNext());
- try {
- it.next();
- shouldThrow();
- } catch (NoSuchElementException success) {}
+ assertIteratorExhausted(it);
+ }
+
+ /**
+ * iterator of empty collection has no elements
+ */
+ public void testEmptyIterator() {
+ Collection c = new CopyOnWriteArrayList();
+ assertIteratorExhausted(c.iterator());
}
/**
@@ -375,10 +386,9 @@
*/
public void testRemoveAll() {
CopyOnWriteArrayList full = populatedArray(3);
- Vector v = new Vector();
- v.add(one);
- v.add(two);
- full.removeAll(v);
+ assertTrue(full.removeAll(Arrays.asList(one, two)));
+ assertEquals(1, full.size());
+ assertFalse(full.removeAll(Arrays.asList(one, two)));
assertEquals(1, full.size());
}
@@ -494,10 +504,10 @@
* can not store the objects inside the list
*/
public void testToArray_ArrayStoreException() {
+ CopyOnWriteArrayList c = new CopyOnWriteArrayList();
+ c.add("zfasdfsdf");
+ c.add("asdadasd");
try {
- CopyOnWriteArrayList c = new CopyOnWriteArrayList();
- c.add("zfasdfsdf");
- c.add("asdadasd");
c.toArray(new Long[5]);
shouldThrow();
} catch (ArrayStoreException success) {}
@@ -507,167 +517,196 @@
* get throws an IndexOutOfBoundsException on a negative index
*/
public void testGet1_IndexOutOfBoundsException() {
- try {
- CopyOnWriteArrayList c = new CopyOnWriteArrayList();
- c.get(-1);
- shouldThrow();
- } catch (IndexOutOfBoundsException success) {}
+ CopyOnWriteArrayList c = populatedArray(5);
+ List[] lists = { c, c.subList(1, c.size() - 1) };
+ for (List list : lists) {
+ try {
+ list.get(-1);
+ shouldThrow();
+ } catch (IndexOutOfBoundsException success) {}
+ }
}
/**
* get throws an IndexOutOfBoundsException on a too high index
*/
public void testGet2_IndexOutOfBoundsException() {
- try {
- CopyOnWriteArrayList c = new CopyOnWriteArrayList();
- c.add("asdasd");
- c.add("asdad");
- c.get(100);
- shouldThrow();
- } catch (IndexOutOfBoundsException success) {}
+ CopyOnWriteArrayList c = populatedArray(5);
+ List[] lists = { c, c.subList(1, c.size() - 1) };
+ for (List list : lists) {
+ try {
+ list.get(list.size());
+ shouldThrow();
+ } catch (IndexOutOfBoundsException success) {}
+ }
}
/**
* set throws an IndexOutOfBoundsException on a negative index
*/
public void testSet1_IndexOutOfBoundsException() {
- try {
- CopyOnWriteArrayList c = new CopyOnWriteArrayList();
- c.set(-1,"qwerty");
- shouldThrow();
- } catch (IndexOutOfBoundsException success) {}
+ CopyOnWriteArrayList c = populatedArray(5);
+ List[] lists = { c, c.subList(1, c.size() - 1) };
+ for (List list : lists) {
+ try {
+ list.set(-1, "qwerty");
+ shouldThrow();
+ } catch (IndexOutOfBoundsException success) {}
+ }
}
/**
* set throws an IndexOutOfBoundsException on a too high index
*/
public void testSet2() {
- try {
- CopyOnWriteArrayList c = new CopyOnWriteArrayList();
- c.add("asdasd");
- c.add("asdad");
- c.set(100, "qwerty");
- shouldThrow();
- } catch (IndexOutOfBoundsException success) {}
+ CopyOnWriteArrayList c = populatedArray(5);
+ List[] lists = { c, c.subList(1, c.size() - 1) };
+ for (List list : lists) {
+ try {
+ list.set(list.size(), "qwerty");
+ shouldThrow();
+ } catch (IndexOutOfBoundsException success) {}
+ }
}
/**
* add throws an IndexOutOfBoundsException on a negative index
*/
public void testAdd1_IndexOutOfBoundsException() {
- try {
- CopyOnWriteArrayList c = new CopyOnWriteArrayList();
- c.add(-1,"qwerty");
- shouldThrow();
- } catch (IndexOutOfBoundsException success) {}
+ CopyOnWriteArrayList c = populatedArray(5);
+ List[] lists = { c, c.subList(1, c.size() - 1) };
+ for (List list : lists) {
+ try {
+ list.add(-1, "qwerty");
+ shouldThrow();
+ } catch (IndexOutOfBoundsException success) {}
+ }
}
/**
* add throws an IndexOutOfBoundsException on a too high index
*/
public void testAdd2_IndexOutOfBoundsException() {
- try {
- CopyOnWriteArrayList c = new CopyOnWriteArrayList();
- c.add("asdasd");
- c.add("asdasdasd");
- c.add(100, "qwerty");
- shouldThrow();
- } catch (IndexOutOfBoundsException success) {}
+ CopyOnWriteArrayList c = populatedArray(5);
+ List[] lists = { c, c.subList(1, c.size() - 1) };
+ for (List list : lists) {
+ try {
+ list.add(list.size() + 1, "qwerty");
+ shouldThrow();
+ } catch (IndexOutOfBoundsException success) {}
+ }
}
/**
* remove throws an IndexOutOfBoundsException on a negative index
*/
public void testRemove1_IndexOutOfBounds() {
- try {
- CopyOnWriteArrayList c = new CopyOnWriteArrayList();
- c.remove(-1);
- shouldThrow();
- } catch (IndexOutOfBoundsException success) {}
+ CopyOnWriteArrayList c = populatedArray(5);
+ List[] lists = { c, c.subList(1, c.size() - 1) };
+ for (List list : lists) {
+ try {
+ list.remove(-1);
+ shouldThrow();
+ } catch (IndexOutOfBoundsException success) {}
+ }
}
/**
* remove throws an IndexOutOfBoundsException on a too high index
*/
public void testRemove2_IndexOutOfBounds() {
- try {
- CopyOnWriteArrayList c = new CopyOnWriteArrayList();
- c.add("asdasd");
- c.add("adasdasd");
- c.remove(100);
- shouldThrow();
- } catch (IndexOutOfBoundsException success) {}
+ CopyOnWriteArrayList c = populatedArray(5);
+ List[] lists = { c, c.subList(1, c.size() - 1) };
+ for (List list : lists) {
+ try {
+ list.remove(list.size());
+ shouldThrow();
+ } catch (IndexOutOfBoundsException success) {}
+ }
}
/**
* addAll throws an IndexOutOfBoundsException on a negative index
*/
public void testAddAll1_IndexOutOfBoundsException() {
- try {
- CopyOnWriteArrayList c = new CopyOnWriteArrayList();
- c.addAll(-1,new LinkedList());
- shouldThrow();
- } catch (IndexOutOfBoundsException success) {}
+ CopyOnWriteArrayList c = populatedArray(5);
+ List[] lists = { c, c.subList(1, c.size() - 1) };
+ for (List list : lists) {
+ try {
+ list.addAll(-1, new LinkedList());
+ shouldThrow();
+ } catch (IndexOutOfBoundsException success) {}
+ }
}
/**
* addAll throws an IndexOutOfBoundsException on a too high index
*/
public void testAddAll2_IndexOutOfBoundsException() {
- try {
- CopyOnWriteArrayList c = new CopyOnWriteArrayList();
- c.add("asdasd");
- c.add("asdasdasd");
- c.addAll(100, new LinkedList());
- shouldThrow();
- } catch (IndexOutOfBoundsException success) {}
+ CopyOnWriteArrayList c = populatedArray(5);
+ List[] lists = { c, c.subList(1, c.size() - 1) };
+ for (List list : lists) {
+ try {
+ list.addAll(list.size() + 1, new LinkedList());
+ shouldThrow();
+ } catch (IndexOutOfBoundsException success) {}
+ }
}
/**
* listIterator throws an IndexOutOfBoundsException on a negative index
*/
public void testListIterator1_IndexOutOfBoundsException() {
- try {
- CopyOnWriteArrayList c = new CopyOnWriteArrayList();
- c.listIterator(-1);
- shouldThrow();
- } catch (IndexOutOfBoundsException success) {}
+ CopyOnWriteArrayList c = populatedArray(5);
+ List[] lists = { c, c.subList(1, c.size() - 1) };
+ for (List list : lists) {
+ try {
+ list.listIterator(-1);
+ shouldThrow();
+ } catch (IndexOutOfBoundsException success) {}
+ }
}
/**
* listIterator throws an IndexOutOfBoundsException on a too high index
*/
public void testListIterator2_IndexOutOfBoundsException() {
- try {
- CopyOnWriteArrayList c = new CopyOnWriteArrayList();
- c.add("adasd");
- c.add("asdasdas");
- c.listIterator(100);
- shouldThrow();
- } catch (IndexOutOfBoundsException success) {}
+ CopyOnWriteArrayList c = populatedArray(5);
+ List[] lists = { c, c.subList(1, c.size() - 1) };
+ for (List list : lists) {
+ try {
+ list.listIterator(list.size() + 1);
+ shouldThrow();
+ } catch (IndexOutOfBoundsException success) {}
+ }
}
/**
* subList throws an IndexOutOfBoundsException on a negative index
*/
public void testSubList1_IndexOutOfBoundsException() {
- try {
- CopyOnWriteArrayList c = new CopyOnWriteArrayList();
- c.subList(-1,100);
- shouldThrow();
- } catch (IndexOutOfBoundsException success) {}
+ CopyOnWriteArrayList c = populatedArray(5);
+ List[] lists = { c, c.subList(1, c.size() - 1) };
+ for (List list : lists) {
+ try {
+ list.subList(-1, list.size());
+ shouldThrow();
+ } catch (IndexOutOfBoundsException success) {}
+ }
}
/**
* subList throws an IndexOutOfBoundsException on a too high index
*/
public void testSubList2_IndexOutOfBoundsException() {
- try {
- CopyOnWriteArrayList c = new CopyOnWriteArrayList();
- c.add("asdasd");
- c.subList(1,100);
- shouldThrow();
- } catch (IndexOutOfBoundsException success) {}
+ CopyOnWriteArrayList c = populatedArray(5);
+ List[] lists = { c, c.subList(1, c.size() - 1) };
+ for (List list : lists) {
+ try {
+ list.subList(0, list.size() + 1);
+ shouldThrow();
+ } catch (IndexOutOfBoundsException success) {}
+ }
}
/**
@@ -675,11 +714,14 @@
* is lower then the first
*/
public void testSubList3_IndexOutOfBoundsException() {
- try {
- CopyOnWriteArrayList c = new CopyOnWriteArrayList();
- c.subList(3,1);
- shouldThrow();
- } catch (IndexOutOfBoundsException success) {}
+ CopyOnWriteArrayList c = populatedArray(5);
+ List[] lists = { c, c.subList(1, c.size() - 1) };
+ for (List list : lists) {
+ try {
+ list.subList(list.size() - 1, 1);
+ shouldThrow();
+ } catch (IndexOutOfBoundsException success) {}
+ }
}
/**
diff --git a/jsr166-tests/src/test/java/jsr166/CopyOnWriteArraySetTest.java b/jsr166-tests/src/test/java/jsr166/CopyOnWriteArraySetTest.java
index feb283f..2810802 100644
--- a/jsr166-tests/src/test/java/jsr166/CopyOnWriteArraySetTest.java
+++ b/jsr166-tests/src/test/java/jsr166/CopyOnWriteArraySetTest.java
@@ -8,7 +8,6 @@
package jsr166;
-import junit.framework.*;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
@@ -16,17 +15,28 @@
import java.util.Iterator;
import java.util.NoSuchElementException;
import java.util.Set;
-import java.util.Vector;
import java.util.concurrent.CopyOnWriteArraySet;
+import junit.framework.Test;
+import junit.framework.TestSuite;
+
public class CopyOnWriteArraySetTest extends JSR166TestCase {
+ // android-note: Removed because the CTS runner does a bad job of
+ // retrying tests that have suite() declarations.
+ //
+ // public static void main(String[] args) {
+ // main(suite(), args);
+ // }
+ // public static Test suite() {
+ // return new TestSuite(...);
+ // }
static CopyOnWriteArraySet<Integer> populatedSet(int n) {
CopyOnWriteArraySet<Integer> a = new CopyOnWriteArraySet<Integer>();
assertTrue(a.isEmpty());
for (int i = 0; i < n; i++)
a.add(i);
- assertFalse(a.isEmpty());
+ assertEquals(n == 0, a.isEmpty());
assertEquals(n, a.size());
return a;
}
@@ -62,29 +72,25 @@
}
/**
- * addAll adds each element from the given collection
+ * addAll adds each non-duplicate element from the given collection
*/
public void testAddAll() {
- CopyOnWriteArraySet full = populatedSet(3);
- Vector v = new Vector();
- v.add(three);
- v.add(four);
- v.add(five);
- full.addAll(v);
+ Set full = populatedSet(3);
+ assertTrue(full.addAll(Arrays.asList(three, four, five)));
+ assertEquals(6, full.size());
+ assertFalse(full.addAll(Arrays.asList(three, four, five)));
assertEquals(6, full.size());
}
/**
- * addAll adds each element from the given collection that did not
- * already exist in the set
+ * addAll adds each non-duplicate element from the given collection
*/
public void testAddAll2() {
- CopyOnWriteArraySet full = populatedSet(3);
- Vector v = new Vector();
- v.add(three);
- v.add(four);
- v.add(one); // will not add this element
- full.addAll(v);
+ Set full = populatedSet(3);
+ // "one" is duplicate and will not be added
+ assertTrue(full.addAll(Arrays.asList(three, four, one)));
+ assertEquals(5, full.size());
+ assertFalse(full.addAll(Arrays.asList(three, four, one)));
assertEquals(5, full.size());
}
@@ -92,7 +98,7 @@
* add will not add the element if it already exists in the set
*/
public void testAdd2() {
- CopyOnWriteArraySet full = populatedSet(3);
+ Set full = populatedSet(3);
full.add(one);
assertEquals(3, full.size());
}
@@ -101,7 +107,7 @@
* add adds the element when it does not exist in the set
*/
public void testAdd3() {
- CopyOnWriteArraySet full = populatedSet(3);
+ Set full = populatedSet(3);
full.add(three);
assertTrue(full.contains(three));
}
@@ -110,16 +116,17 @@
* clear removes all elements from the set
*/
public void testClear() {
- CopyOnWriteArraySet full = populatedSet(3);
+ Collection full = populatedSet(3);
full.clear();
assertEquals(0, full.size());
+ assertTrue(full.isEmpty());
}
/**
* contains returns true for added elements
*/
public void testContains() {
- CopyOnWriteArraySet full = populatedSet(3);
+ Collection full = populatedSet(3);
assertTrue(full.contains(one));
assertFalse(full.contains(five));
}
@@ -146,23 +153,20 @@
* containsAll returns true for collections with subset of elements
*/
public void testContainsAll() {
- CopyOnWriteArraySet full = populatedSet(3);
- Vector v = new Vector();
- v.add(one);
- v.add(two);
- assertTrue(full.containsAll(v));
- v.add(six);
- assertFalse(full.containsAll(v));
+ Collection full = populatedSet(3);
+ assertTrue(full.containsAll(Arrays.asList()));
+ assertTrue(full.containsAll(Arrays.asList(one)));
+ assertTrue(full.containsAll(Arrays.asList(one, two)));
+ assertFalse(full.containsAll(Arrays.asList(one, two, six)));
+ assertFalse(full.containsAll(Arrays.asList(six)));
}
/**
* isEmpty is true when empty, else false
*/
public void testIsEmpty() {
- CopyOnWriteArraySet empty = new CopyOnWriteArraySet();
- CopyOnWriteArraySet full = populatedSet(3);
- assertTrue(empty.isEmpty());
- assertFalse(full.isEmpty());
+ assertTrue(populatedSet(0).isEmpty());
+ assertFalse(populatedSet(3).isEmpty());
}
/**
@@ -188,18 +192,21 @@
assertTrue(it.hasNext());
assertEquals(elements[j], it.next());
}
- assertFalse(it.hasNext());
- try {
- it.next();
- shouldThrow();
- } catch (NoSuchElementException success) {}
+ assertIteratorExhausted(it);
+ }
+
+ /**
+ * iterator of empty collection has no elements
+ */
+ public void testEmptyIterator() {
+ assertIteratorExhausted(new CopyOnWriteArraySet().iterator());
}
/**
* iterator remove is unsupported
*/
public void testIteratorRemove() {
- CopyOnWriteArraySet full = populatedSet(3);
+ Collection full = populatedSet(3);
Iterator it = full.iterator();
it.next();
try {
@@ -213,7 +220,7 @@
*/
public void testToString() {
assertEquals("[]", new CopyOnWriteArraySet().toString());
- CopyOnWriteArraySet full = populatedSet(3);
+ Collection full = populatedSet(3);
String s = full.toString();
for (int i = 0; i < 3; ++i)
assertTrue(s.contains(String.valueOf(i)));
@@ -225,11 +232,10 @@
* removeAll removes all elements from the given collection
*/
public void testRemoveAll() {
- CopyOnWriteArraySet full = populatedSet(3);
- Vector v = new Vector();
- v.add(one);
- v.add(two);
- full.removeAll(v);
+ Set full = populatedSet(3);
+ assertTrue(full.removeAll(Arrays.asList(one, two)));
+ assertEquals(1, full.size());
+ assertFalse(full.removeAll(Arrays.asList(one, two)));
assertEquals(1, full.size());
}
@@ -237,7 +243,7 @@
* remove removes an element
*/
public void testRemove() {
- CopyOnWriteArraySet full = populatedSet(3);
+ Collection full = populatedSet(3);
full.remove(one);
assertFalse(full.contains(one));
assertEquals(2, full.size());
@@ -247,8 +253,8 @@
* size returns the number of elements
*/
public void testSize() {
- CopyOnWriteArraySet empty = new CopyOnWriteArraySet();
- CopyOnWriteArraySet full = populatedSet(3);
+ Collection empty = new CopyOnWriteArraySet();
+ Collection full = populatedSet(3);
assertEquals(3, full.size());
assertEquals(0, empty.size());
}
diff --git a/jsr166-tests/src/test/java/jsr166/CountDownLatchTest.java b/jsr166-tests/src/test/java/jsr166/CountDownLatchTest.java
index bc2aecf..da1ebb4 100644
--- a/jsr166-tests/src/test/java/jsr166/CountDownLatchTest.java
+++ b/jsr166-tests/src/test/java/jsr166/CountDownLatchTest.java
@@ -8,12 +8,23 @@
package jsr166;
-import junit.framework.*;
-import java.util.*;
-import java.util.concurrent.CountDownLatch;
import static java.util.concurrent.TimeUnit.MILLISECONDS;
+import java.util.concurrent.CountDownLatch;
+
+import junit.framework.Test;
+import junit.framework.TestSuite;
+
public class CountDownLatchTest extends JSR166TestCase {
+ // android-note: Removed because the CTS runner does a bad job of
+ // retrying tests that have suite() declarations.
+ //
+ // public static void main(String[] args) {
+ // main(suite(), args);
+ // }
+ // public static Test suite() {
+ // return new TestSuite(...);
+ // }
/**
* negative constructor argument throws IAE
diff --git a/jsr166-tests/src/test/java/jsr166/CountedCompleterTest.java b/jsr166-tests/src/test/java/jsr166/CountedCompleterTest.java
index 2f8665b..80d7b3b 100644
--- a/jsr166-tests/src/test/java/jsr166/CountedCompleterTest.java
+++ b/jsr166-tests/src/test/java/jsr166/CountedCompleterTest.java
@@ -6,25 +6,34 @@
package jsr166;
-import java.util.concurrent.ExecutionException;
-import java.util.concurrent.CancellationException;
-import java.util.concurrent.ForkJoinPool;
-import java.util.concurrent.ForkJoinTask;
-import java.util.concurrent.CountedCompleter;
-import java.util.concurrent.ForkJoinWorkerThread;
-import java.util.concurrent.RecursiveAction;
-import java.util.concurrent.TimeUnit;
-import java.util.concurrent.TimeoutException;
-import java.util.concurrent.atomic.AtomicInteger;
-import java.util.concurrent.atomic.AtomicIntegerFieldUpdater;
-import java.util.concurrent.atomic.AtomicReference;
import static java.util.concurrent.TimeUnit.MILLISECONDS;
import static java.util.concurrent.TimeUnit.SECONDS;
+
import java.util.HashSet;
-import junit.framework.*;
+import java.util.concurrent.CancellationException;
+import java.util.concurrent.CountedCompleter;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.ForkJoinPool;
+import java.util.concurrent.ForkJoinTask;
+import java.util.concurrent.TimeoutException;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.concurrent.atomic.AtomicReference;
+
+import junit.framework.Test;
+import junit.framework.TestSuite;
public class CountedCompleterTest extends JSR166TestCase {
+ // android-note: Removed because the CTS runner does a bad job of
+ // retrying tests that have suite() declarations.
+ //
+ // public static void main(String[] args) {
+ // main(suite(), args);
+ // }
+ // public static Test suite() {
+ // return new TestSuite(...);
+ // }
+
// Runs with "mainPool" use > 1 thread. singletonPool tests use 1
static final int mainPoolSize =
Math.max(2, Runtime.getRuntime().availableProcessors());
@@ -193,8 +202,8 @@
try {
a.invoke();
shouldThrow();
- } catch (Throwable ex) {
- assertSame(t, ex);
+ } catch (Throwable success) {
+ assertSame(t, success);
}
}
@@ -494,8 +503,9 @@
// Invocation tests use some interdependent task classes
// to better test propagation etc
-
- // Version of Fibonacci with different classes for left vs right forks
+ /**
+ * Version of Fibonacci with different classes for left vs right forks
+ */
abstract class CCF extends CheckedCC {
int number;
int rnumber;
@@ -1131,7 +1141,7 @@
}
/**
- * invokeAll(collection) throws exception if any task does
+ * invokeAll(collection) throws exception if any task does
*/
public void testAbnormalInvokeAllCollection() {
ForkJoinTask a = new CheckedRecursiveAction() {
@@ -1796,7 +1806,7 @@
}
/**
- * invokeAll(collection) throws exception if any task does
+ * invokeAll(collection) throws exception if any task does
*/
public void testAbnormalInvokeAllCollectionSingleton() {
ForkJoinTask a = new CheckedRecursiveAction() {
diff --git a/jsr166-tests/src/test/java/jsr166/CyclicBarrierTest.java b/jsr166-tests/src/test/java/jsr166/CyclicBarrierTest.java
index 3239030..a9d8c54 100644
--- a/jsr166-tests/src/test/java/jsr166/CyclicBarrierTest.java
+++ b/jsr166-tests/src/test/java/jsr166/CyclicBarrierTest.java
@@ -8,16 +8,27 @@
package jsr166;
-import junit.framework.*;
-import java.util.*;
+import static java.util.concurrent.TimeUnit.MILLISECONDS;
+
import java.util.concurrent.BrokenBarrierException;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.CyclicBarrier;
import java.util.concurrent.TimeoutException;
import java.util.concurrent.atomic.AtomicBoolean;
-import static java.util.concurrent.TimeUnit.MILLISECONDS;
+
+import junit.framework.Test;
+import junit.framework.TestSuite;
public class CyclicBarrierTest extends JSR166TestCase {
+ // android-note: Removed because the CTS runner does a bad job of
+ // retrying tests that have suite() declarations.
+ //
+ // public static void main(String[] args) {
+ // main(suite(), args);
+ // }
+ // public static Test suite() {
+ // return new TestSuite(...);
+ // }
private volatile int countAction;
private class MyAction implements Runnable {
diff --git a/jsr166-tests/src/test/java/jsr166/DelayQueueTest.java b/jsr166-tests/src/test/java/jsr166/DelayQueueTest.java
index dc221ab..7619b48 100644
--- a/jsr166-tests/src/test/java/jsr166/DelayQueueTest.java
+++ b/jsr166-tests/src/test/java/jsr166/DelayQueueTest.java
@@ -8,9 +8,11 @@
package jsr166;
-import junit.framework.*;
-import java.util.Arrays;
+import static java.util.concurrent.TimeUnit.MILLISECONDS;
+
import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collection;
import java.util.Iterator;
import java.util.NoSuchElementException;
import java.util.concurrent.BlockingQueue;
@@ -20,10 +22,33 @@
import java.util.concurrent.Executors;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.TimeUnit;
-import static java.util.concurrent.TimeUnit.MILLISECONDS;
+import junit.framework.Test;
+
+// android-changed: Extend BlockingQueueTest directly.
public class DelayQueueTest extends BlockingQueueTest {
+ // android-changed: Extend BlockingQueueTest directly instead of creating
+ // an inner class and its associated suite.
+ //
+ // public static class Generic extends BlockingQueueTest {
+ // protected BlockingQueue emptyCollection() {
+ // return new DelayQueue();
+ // }
+ // protected PDelay makeElement(int i) {
+ // return new PDelay(i);
+ // }
+ // }
+ //
+ // public static void main(String[] args) {
+ // main(suite(), args);
+ // }
+ //
+ // public static Test suite() {
+ // return newTestSuite(DelayQueueTest.class,
+ // new Generic().testSuite());
+ // }
+
protected BlockingQueue emptyCollection() {
return new DelayQueue();
}
@@ -32,8 +57,6 @@
return new PDelay(i);
}
- private static final int NOCAP = Integer.MAX_VALUE;
-
/**
* A delayed implementation for testing.
* Most tests use Pseudodelays, where delays are all elapsed
@@ -115,12 +138,12 @@
private DelayQueue<PDelay> populatedQueue(int n) {
DelayQueue<PDelay> q = new DelayQueue<PDelay>();
assertTrue(q.isEmpty());
- for (int i = n-1; i >= 0; i-=2)
+ for (int i = n-1; i >= 0; i -= 2)
assertTrue(q.offer(new PDelay(i)));
- for (int i = (n & 1); i < n; i+=2)
+ for (int i = (n & 1); i < n; i += 2)
assertTrue(q.offer(new PDelay(i)));
assertFalse(q.isEmpty());
- assertEquals(NOCAP, q.remainingCapacity());
+ assertEquals(Integer.MAX_VALUE, q.remainingCapacity());
assertEquals(n, q.size());
return q;
}
@@ -129,7 +152,7 @@
* A new queue has unbounded capacity
*/
public void testConstructor1() {
- assertEquals(NOCAP, new DelayQueue().remainingCapacity());
+ assertEquals(Integer.MAX_VALUE, new DelayQueue().remainingCapacity());
}
/**
@@ -137,7 +160,7 @@
*/
public void testConstructor3() {
try {
- DelayQueue q = new DelayQueue(null);
+ new DelayQueue(null);
shouldThrow();
} catch (NullPointerException success) {}
}
@@ -148,7 +171,7 @@
public void testConstructor4() {
try {
PDelay[] ints = new PDelay[SIZE];
- DelayQueue q = new DelayQueue(Arrays.asList(ints));
+ new DelayQueue(Arrays.asList(ints));
shouldThrow();
} catch (NullPointerException success) {}
}
@@ -161,7 +184,7 @@
PDelay[] ints = new PDelay[SIZE];
for (int i = 0; i < SIZE-1; ++i)
ints[i] = new PDelay(i);
- DelayQueue q = new DelayQueue(Arrays.asList(ints));
+ new DelayQueue(Arrays.asList(ints));
shouldThrow();
} catch (NullPointerException success) {}
}
@@ -184,7 +207,7 @@
public void testEmpty() {
DelayQueue q = new DelayQueue();
assertTrue(q.isEmpty());
- assertEquals(NOCAP, q.remainingCapacity());
+ assertEquals(Integer.MAX_VALUE, q.remainingCapacity());
q.add(new PDelay(1));
assertFalse(q.isEmpty());
q.add(new PDelay(2));
@@ -194,20 +217,19 @@
}
/**
- * remainingCapacity does not change when elements added or removed,
- * but size does
+ * remainingCapacity() always returns Integer.MAX_VALUE
*/
public void testRemainingCapacity() {
- DelayQueue q = populatedQueue(SIZE);
+ BlockingQueue q = populatedQueue(SIZE);
for (int i = 0; i < SIZE; ++i) {
- assertEquals(NOCAP, q.remainingCapacity());
+ assertEquals(Integer.MAX_VALUE, q.remainingCapacity());
assertEquals(SIZE-i, q.size());
- q.remove();
+ assertTrue(q.remove() instanceof PDelay);
}
for (int i = 0; i < SIZE; ++i) {
- assertEquals(NOCAP, q.remainingCapacity());
+ assertEquals(Integer.MAX_VALUE, q.remainingCapacity());
assertEquals(i, q.size());
- q.add(new PDelay(i));
+ assertTrue(q.add(new PDelay(i)));
}
}
@@ -278,9 +300,9 @@
public void testPut() {
DelayQueue q = new DelayQueue();
for (int i = 0; i < SIZE; ++i) {
- PDelay I = new PDelay(i);
- q.put(I);
- assertTrue(q.contains(I));
+ PDelay x = new PDelay(i);
+ q.put(x);
+ assertTrue(q.contains(x));
}
assertEquals(SIZE, q.size());
}
@@ -324,7 +346,7 @@
public void testTake() throws InterruptedException {
DelayQueue q = populatedQueue(SIZE);
for (int i = 0; i < SIZE; ++i) {
- assertEquals(new PDelay(i), ((PDelay)q.take()));
+ assertEquals(new PDelay(i), q.take());
}
}
@@ -367,7 +389,7 @@
public void testPoll() {
DelayQueue q = populatedQueue(SIZE);
for (int i = 0; i < SIZE; ++i) {
- assertEquals(new PDelay(i), ((PDelay)q.poll()));
+ assertEquals(new PDelay(i), q.poll());
}
assertNull(q.poll());
}
@@ -378,7 +400,7 @@
public void testTimedPoll0() throws InterruptedException {
DelayQueue q = populatedQueue(SIZE);
for (int i = 0; i < SIZE; ++i) {
- assertEquals(new PDelay(i), ((PDelay)q.poll(0, MILLISECONDS)));
+ assertEquals(new PDelay(i), q.poll(0, MILLISECONDS));
}
assertNull(q.poll(0, MILLISECONDS));
}
@@ -390,7 +412,7 @@
DelayQueue q = populatedQueue(SIZE);
for (int i = 0; i < SIZE; ++i) {
long startTime = System.nanoTime();
- assertEquals(new PDelay(i), ((PDelay)q.poll(LONG_DELAY_MS, MILLISECONDS)));
+ assertEquals(new PDelay(i), q.poll(LONG_DELAY_MS, MILLISECONDS));
assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
}
long startTime = System.nanoTime();
@@ -439,8 +461,8 @@
public void testPeek() {
DelayQueue q = populatedQueue(SIZE);
for (int i = 0; i < SIZE; ++i) {
- assertEquals(new PDelay(i), ((PDelay)q.peek()));
- assertEquals(new PDelay(i), ((PDelay)q.poll()));
+ assertEquals(new PDelay(i), q.peek());
+ assertEquals(new PDelay(i), q.poll());
if (q.isEmpty())
assertNull(q.peek());
else
@@ -455,7 +477,7 @@
public void testElement() {
DelayQueue q = populatedQueue(SIZE);
for (int i = 0; i < SIZE; ++i) {
- assertEquals(new PDelay(i), ((PDelay)q.element()));
+ assertEquals(new PDelay(i), q.element());
q.poll();
}
try {
@@ -470,7 +492,7 @@
public void testRemove() {
DelayQueue q = populatedQueue(SIZE);
for (int i = 0; i < SIZE; ++i) {
- assertEquals(new PDelay(i), ((PDelay)q.remove()));
+ assertEquals(new PDelay(i), q.remove());
}
try {
q.remove();
@@ -498,7 +520,7 @@
q.clear();
assertTrue(q.isEmpty());
assertEquals(0, q.size());
- assertEquals(NOCAP, q.remainingCapacity());
+ assertEquals(Integer.MAX_VALUE, q.remainingCapacity());
PDelay x = new PDelay(1);
q.add(x);
assertFalse(q.isEmpty());
@@ -550,8 +572,8 @@
assertTrue(q.removeAll(p));
assertEquals(SIZE-i, q.size());
for (int j = 0; j < i; ++j) {
- PDelay I = (PDelay)(p.remove());
- assertFalse(q.contains(I));
+ PDelay x = (PDelay)(p.remove());
+ assertFalse(q.contains(x));
}
}
}
@@ -603,6 +625,14 @@
++i;
}
assertEquals(i, SIZE);
+ assertIteratorExhausted(it);
+ }
+
+ /**
+ * iterator of empty collection has no elements
+ */
+ public void testEmptyIterator() {
+ assertIteratorExhausted(new DelayQueue().iterator());
}
/**
@@ -763,4 +793,12 @@
}
}
+ /**
+ * remove(null), contains(null) always return false
+ */
+ public void testNeverContainsNull() {
+ Collection<?> q = populatedQueue(SIZE);
+ assertFalse(q.contains(null));
+ assertFalse(q.remove(null));
+ }
}
diff --git a/jsr166-tests/src/test/java/jsr166/EntryTest.java b/jsr166-tests/src/test/java/jsr166/EntryTest.java
index 4387a53..d141a84 100644
--- a/jsr166-tests/src/test/java/jsr166/EntryTest.java
+++ b/jsr166-tests/src/test/java/jsr166/EntryTest.java
@@ -6,10 +6,22 @@
package jsr166;
-import junit.framework.*;
-import java.util.*;
+import java.util.AbstractMap;
+import java.util.Map;
+
+import junit.framework.Test;
+import junit.framework.TestSuite;
public class EntryTest extends JSR166TestCase {
+ // android-note: Removed because the CTS runner does a bad job of
+ // retrying tests that have suite() declarations.
+ //
+ // public static void main(String[] args) {
+ // main(suite(), args);
+ // }
+ // public static Test suite() {
+ // return new TestSuite(...);
+ // }
static final String k1 = "1";
static final String v1 = "a";
diff --git a/jsr166-tests/src/test/java/jsr166/ExchangerTest.java b/jsr166-tests/src/test/java/jsr166/ExchangerTest.java
index b0f325e..172fccd 100644
--- a/jsr166-tests/src/test/java/jsr166/ExchangerTest.java
+++ b/jsr166-tests/src/test/java/jsr166/ExchangerTest.java
@@ -8,15 +8,27 @@
package jsr166;
-import junit.framework.*;
-import java.util.*;
+import static java.util.concurrent.TimeUnit.MILLISECONDS;
+
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.Exchanger;
import java.util.concurrent.TimeoutException;
-import static java.util.concurrent.TimeUnit.MILLISECONDS;
+
+import junit.framework.Test;
+import junit.framework.TestSuite;
public class ExchangerTest extends JSR166TestCase {
+ // android-note: Removed because the CTS runner does a bad job of
+ // retrying tests that have suite() declarations.
+ //
+ // public static void main(String[] args) {
+ // main(suite(), args);
+ // }
+ // public static Test suite() {
+ // return new TestSuite(...);
+ // }
+
/**
* exchange exchanges objects across two threads
*/
diff --git a/jsr166-tests/src/test/java/jsr166/ExecutorCompletionServiceTest.java b/jsr166-tests/src/test/java/jsr166/ExecutorCompletionServiceTest.java
index eced0ba..e988cc6 100644
--- a/jsr166-tests/src/test/java/jsr166/ExecutorCompletionServiceTest.java
+++ b/jsr166-tests/src/test/java/jsr166/ExecutorCompletionServiceTest.java
@@ -8,30 +8,40 @@
package jsr166;
-import junit.framework.*;
-import java.util.*;
+import static java.util.concurrent.TimeUnit.MILLISECONDS;
+
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutorCompletionService;
-import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
+import java.util.concurrent.ExecutorService;
import java.util.concurrent.Future;
import java.util.concurrent.FutureTask;
import java.util.concurrent.RunnableFuture;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
-import static java.util.concurrent.TimeUnit.MILLISECONDS;
import java.util.concurrent.atomic.AtomicBoolean;
-import java.security.*;
+
+import junit.framework.Test;
+import junit.framework.TestSuite;
public class ExecutorCompletionServiceTest extends JSR166TestCase {
+ // android-note: Removed because the CTS runner does a bad job of
+ // retrying tests that have suite() declarations.
+ //
+ // public static void main(String[] args) {
+ // main(suite(), args);
+ // }
+ // public static Test suite() {
+ // return new TestSuite(...);
+ // }
/**
* Creating a new ECS with null Executor throw NPE
*/
public void testConstructorNPE() {
try {
- ExecutorCompletionService ecs = new ExecutorCompletionService(null);
+ new ExecutorCompletionService(null);
shouldThrow();
} catch (NullPointerException success) {}
}
@@ -42,7 +52,7 @@
public void testConstructorNPE2() {
try {
ExecutorService e = Executors.newCachedThreadPool();
- ExecutorCompletionService ecs = new ExecutorCompletionService(e, null);
+ new ExecutorCompletionService(e, null);
shouldThrow();
} catch (NullPointerException success) {}
}
diff --git a/jsr166-tests/src/test/java/jsr166/ExecutorsTest.java b/jsr166-tests/src/test/java/jsr166/ExecutorsTest.java
index 18c0975..2518e63 100644
--- a/jsr166-tests/src/test/java/jsr166/ExecutorsTest.java
+++ b/jsr166-tests/src/test/java/jsr166/ExecutorsTest.java
@@ -8,13 +8,36 @@
package jsr166;
-import junit.framework.*;
-import java.util.*;
-import java.util.concurrent.*;
import static java.util.concurrent.TimeUnit.MILLISECONDS;
-import java.security.*;
+
+import java.security.AccessControlContext;
+import java.security.AccessControlException;
+import java.security.AccessController;
+import java.security.PrivilegedAction;
+import java.security.PrivilegedExceptionAction;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.concurrent.Callable;
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.Executors;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Future;
+import java.util.concurrent.ScheduledExecutorService;
+import java.util.concurrent.ThreadPoolExecutor;
+
+import junit.framework.Test;
+import junit.framework.TestSuite;
public class ExecutorsTest extends JSR166TestCase {
+ // android-note: Removed because the CTS runner does a bad job of
+ // retrying tests that have suite() declarations.
+ //
+ // public static void main(String[] args) {
+ // main(suite(), args);
+ // }
+ // public static Test suite() {
+ // return new TestSuite(...);
+ // }
/**
* A newCachedThreadPool can execute runnables
@@ -267,7 +290,6 @@
for (final ExecutorService executor : executors) {
threads.add(newStartedThread(new CheckedRunnable() {
public void realRun() {
- long startTime = System.nanoTime();
Future future = executor.submit(sleeper);
assertFutureTimesOut(future);
}}));
@@ -328,7 +350,7 @@
public void realRun() throws Exception {
final ThreadGroup egroup = Thread.currentThread().getThreadGroup();
final ClassLoader thisccl = Thread.currentThread().getContextClassLoader();
- // final AccessControlContext thisacc = AccessController.getContext(); // Android removed
+ final AccessControlContext thisacc = AccessController.getContext();
Runnable r = new CheckedRunnable() {
public void realRun() {
Thread current = Thread.currentThread();
@@ -343,7 +365,7 @@
String name = current.getName();
assertTrue(name.endsWith("thread-1"));
assertSame(thisccl, current.getContextClassLoader());
- // assertEquals(thisacc, AccessController.getContext()); // Android removed
+ assertEquals(thisacc, AccessController.getContext());
done.countDown();
}};
ExecutorService e = Executors.newSingleThreadExecutor(Executors.privilegedThreadFactory());
diff --git a/jsr166-tests/src/test/java/jsr166/ForkJoinPoolTest.java b/jsr166-tests/src/test/java/jsr166/ForkJoinPoolTest.java
index 8416198..09a3511 100644
--- a/jsr166-tests/src/test/java/jsr166/ForkJoinPoolTest.java
+++ b/jsr166-tests/src/test/java/jsr166/ForkJoinPoolTest.java
@@ -6,34 +6,42 @@
package jsr166;
-import junit.framework.*;
+import static java.util.concurrent.TimeUnit.MILLISECONDS;
+import static java.util.concurrent.TimeUnit.NANOSECONDS;
+
+import java.security.PrivilegedAction;
+import java.security.PrivilegedExceptionAction;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
+import java.util.concurrent.Callable;
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.ExecutionException;
import java.util.concurrent.Executors;
import java.util.concurrent.ExecutorService;
-import java.util.concurrent.AbstractExecutorService;
-import java.util.concurrent.CountDownLatch;
-import java.util.concurrent.Callable;
-import java.util.concurrent.Future;
-import java.util.concurrent.ExecutionException;
-import java.util.concurrent.CancellationException;
-import java.util.concurrent.RejectedExecutionException;
import java.util.concurrent.ForkJoinPool;
import java.util.concurrent.ForkJoinTask;
import java.util.concurrent.ForkJoinWorkerThread;
+import java.util.concurrent.Future;
import java.util.concurrent.RecursiveTask;
-import java.util.concurrent.TimeUnit;
+import java.util.concurrent.RejectedExecutionException;
import java.util.concurrent.atomic.AtomicBoolean;
import java.util.concurrent.locks.ReentrantLock;
-import static java.util.concurrent.TimeUnit.MILLISECONDS;
-import static java.util.concurrent.TimeUnit.NANOSECONDS;
-import java.security.AccessControlException;
-import java.security.Policy;
-import java.security.PrivilegedAction;
-import java.security.PrivilegedExceptionAction;
+
+import junit.framework.AssertionFailedError;
+import junit.framework.Test;
+import junit.framework.TestSuite;
public class ForkJoinPoolTest extends JSR166TestCase {
+ // android-note: Removed because the CTS runner does a bad job of
+ // retrying tests that have suite() declarations.
+ //
+ // public static void main(String[] args) {
+ // main(suite(), args);
+ // }
+ // public static Test suite() {
+ // return new TestSuite(...);
+ // }
/*
* Testing coverage notes:
@@ -103,7 +111,7 @@
static final class FibTask extends RecursiveTask<Integer> {
final int number;
FibTask(int n) { number = n; }
- public Integer compute() {
+ protected Integer compute() {
int n = number;
if (n <= 1)
return n;
@@ -131,7 +139,7 @@
this.locker = locker;
this.lock = lock;
}
- public Integer compute() {
+ protected Integer compute() {
int n;
LockingFibTask f1 = null;
LockingFibTask f2 = null;
@@ -414,11 +422,10 @@
ExecutorService e = new ForkJoinPool(1);
try {
final AtomicBoolean done = new AtomicBoolean(false);
- CheckedRunnable task = new CheckedRunnable() {
+ Future<?> future = e.submit(new CheckedRunnable() {
public void realRun() {
done.set(true);
- }};
- Future<?> future = e.submit(task);
+ }});
assertNull(future.get());
assertNull(future.get(0, MILLISECONDS));
assertTrue(done.get());
diff --git a/jsr166-tests/src/test/java/jsr166/ForkJoinTaskTest.java b/jsr166-tests/src/test/java/jsr166/ForkJoinTaskTest.java
index 080fd9c..3c1fcb7 100644
--- a/jsr166-tests/src/test/java/jsr166/ForkJoinTaskTest.java
+++ b/jsr166-tests/src/test/java/jsr166/ForkJoinTaskTest.java
@@ -6,22 +6,33 @@
package jsr166;
-import java.util.concurrent.ExecutionException;
-import java.util.concurrent.CancellationException;
-import java.util.concurrent.ForkJoinPool;
-import java.util.concurrent.ForkJoinTask;
-import java.util.concurrent.ForkJoinWorkerThread;
-import java.util.concurrent.RecursiveAction;
-import java.util.concurrent.TimeUnit;
-import java.util.concurrent.TimeoutException;
-import java.util.concurrent.atomic.AtomicIntegerFieldUpdater;
import static java.util.concurrent.TimeUnit.MILLISECONDS;
import static java.util.concurrent.TimeUnit.SECONDS;
+
import java.util.HashSet;
-import junit.framework.*;
+import java.util.concurrent.CancellationException;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.ForkJoinPool;
+import java.util.concurrent.ForkJoinTask;
+import java.util.concurrent.RecursiveAction;
+import java.util.concurrent.TimeoutException;
+import java.util.concurrent.atomic.AtomicIntegerFieldUpdater;
+
+import junit.framework.Test;
+import junit.framework.TestSuite;
public class ForkJoinTaskTest extends JSR166TestCase {
+ // android-note: Removed because the CTS runner does a bad job of
+ // retrying tests that have suite() declarations.
+ //
+ // public static void main(String[] args) {
+ // main(suite(), args);
+ // }
+ // public static Test suite() {
+ // return new TestSuite(...);
+ // }
+
// Runs with "mainPool" use > 1 thread. singletonPool tests use 1
static final int mainPoolSize =
Math.max(2, Runtime.getRuntime().availableProcessors());
@@ -913,7 +924,7 @@
}
/**
- * invokeAll(collection) throws exception if any task does
+ * invokeAll(collection) throws exception if any task does
*/
public void testAbnormalInvokeAllCollection() {
RecursiveAction a = new CheckedRecursiveAction() {
@@ -1580,7 +1591,7 @@
}
/**
- * invokeAll(collection) throws exception if any task does
+ * invokeAll(collection) throws exception if any task does
*/
public void testAbnormalInvokeAllCollectionSingleton() {
RecursiveAction a = new CheckedRecursiveAction() {
@@ -1602,4 +1613,21 @@
testInvokeOnPool(singletonPool(), a);
}
+ /**
+ * ForkJoinTask.quietlyComplete returns when task completes
+ * normally without setting a value. The most recent value
+ * established by setRawResult(V) (or null by default) is returned
+ * from invoke.
+ */
+ public void testQuietlyComplete() {
+ RecursiveAction a = new CheckedRecursiveAction() {
+ protected void realCompute() {
+ AsyncFib f = new AsyncFib(8);
+ f.quietlyComplete();
+ assertEquals(8, f.number);
+ checkCompletedNormally(f);
+ }};
+ testInvokeOnPool(mainPool(), a);
+ }
+
}
diff --git a/jsr166-tests/src/test/java/jsr166/FutureTaskTest.java b/jsr166-tests/src/test/java/jsr166/FutureTaskTest.java
index baab79e..a5d8c46 100644
--- a/jsr166-tests/src/test/java/jsr166/FutureTaskTest.java
+++ b/jsr166-tests/src/test/java/jsr166/FutureTaskTest.java
@@ -8,21 +8,39 @@
package jsr166;
-import junit.framework.*;
+import static java.util.concurrent.TimeUnit.MILLISECONDS;
+import static java.util.concurrent.TimeUnit.NANOSECONDS;
+import static java.util.concurrent.TimeUnit.SECONDS;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.NoSuchElementException;
import java.util.concurrent.Callable;
import java.util.concurrent.CancellationException;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutionException;
+import java.util.concurrent.Executors;
+import java.util.concurrent.ExecutorService;
import java.util.concurrent.Future;
import java.util.concurrent.FutureTask;
import java.util.concurrent.TimeoutException;
import java.util.concurrent.atomic.AtomicInteger;
-import static java.util.concurrent.TimeUnit.MILLISECONDS;
-import static java.util.concurrent.TimeUnit.SECONDS;
-import java.util.*;
+
+import junit.framework.Test;
+import junit.framework.TestSuite;
public class FutureTaskTest extends JSR166TestCase {
+ // android-note: Removed because the CTS runner does a bad job of
+ // retrying tests that have suite() declarations.
+ //
+ // public static void main(String[] args) {
+ // main(suite(), args);
+ // }
+ // public static Test suite() {
+ // return new TestSuite(...);
+ // }
+
void checkIsDone(Future<?> f) {
assertTrue(f.isDone());
assertFalse(f.cancel(false));
@@ -122,7 +140,7 @@
pf.set(new Object());
pf.setException(new Error());
for (boolean mayInterruptIfRunning : new boolean[] { true, false }) {
- pf.cancel(true);
+ pf.cancel(mayInterruptIfRunning);
}
}
@@ -473,8 +491,8 @@
final PublicFutureTask task =
new PublicFutureTask(new Runnable() {
public void run() {
+ pleaseCancel.countDown();
try {
- pleaseCancel.countDown();
delay(LONG_DELAY_MS);
threadShouldThrow();
} catch (InterruptedException success) {
@@ -796,4 +814,31 @@
}
}
+ /**
+ * timed get with most negative timeout works correctly (i.e. no
+ * underflow bug)
+ */
+ public void testGet_NegativeInfinityTimeout() throws Exception {
+ final ExecutorService pool = Executors.newFixedThreadPool(10);
+ final Runnable nop = new Runnable() { public void run() {}};
+ final FutureTask<Void> task = new FutureTask<>(nop, null);
+ final List<Future<?>> futures = new ArrayList<>();
+ Runnable r = new Runnable() { public void run() {
+ for (long timeout : new long[] { 0L, -1L, Long.MIN_VALUE }) {
+ try {
+ task.get(timeout, NANOSECONDS);
+ shouldThrow();
+ } catch (TimeoutException success) {
+ } catch (Throwable fail) {threadUnexpectedException(fail);}}}};
+ for (int i = 0; i < 10; i++)
+ futures.add(pool.submit(r));
+ try {
+ joinPool(pool);
+ for (Future<?> future : futures)
+ checkCompletedNormally(future, null);
+ } finally {
+ task.run(); // last resort to help terminate
+ }
+ }
+
}
diff --git a/jsr166-tests/src/test/java/jsr166/JSR166TestCase.java b/jsr166-tests/src/test/java/jsr166/JSR166TestCase.java
index d9bf255..d07d936 100644
--- a/jsr166-tests/src/test/java/jsr166/JSR166TestCase.java
+++ b/jsr166-tests/src/test/java/jsr166/JSR166TestCase.java
@@ -8,24 +8,14 @@
package jsr166;
-import junit.framework.*;
+import static java.util.concurrent.TimeUnit.MILLISECONDS;
+import static java.util.concurrent.TimeUnit.NANOSECONDS;
+
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.lang.reflect.Method;
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.Date;
-import java.util.Enumeration;
-import java.util.List;
-import java.util.NoSuchElementException;
-import java.util.PropertyPermission;
-import java.util.concurrent.*;
-import java.util.concurrent.atomic.AtomicBoolean;
-import java.util.concurrent.atomic.AtomicReference;
-import static java.util.concurrent.TimeUnit.MILLISECONDS;
-import static java.util.concurrent.TimeUnit.NANOSECONDS;
import java.security.CodeSource;
import java.security.Permission;
import java.security.PermissionCollection;
@@ -33,6 +23,34 @@
import java.security.Policy;
import java.security.ProtectionDomain;
import java.security.SecurityPermission;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Date;
+import java.util.Enumeration;
+import java.util.Iterator;
+import java.util.List;
+import java.util.NoSuchElementException;
+import java.util.PropertyPermission;
+import java.util.concurrent.BlockingQueue;
+import java.util.concurrent.Callable;
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.CyclicBarrier;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Future;
+import java.util.concurrent.RecursiveAction;
+import java.util.concurrent.RecursiveTask;
+import java.util.concurrent.RejectedExecutionHandler;
+import java.util.concurrent.Semaphore;
+import java.util.concurrent.ThreadFactory;
+import java.util.concurrent.ThreadPoolExecutor;
+import java.util.concurrent.TimeoutException;
+import java.util.concurrent.atomic.AtomicReference;
+import java.util.regex.Pattern;
+
+import junit.framework.AssertionFailedError;
+import junit.framework.Test;
+import junit.framework.TestCase;
+import junit.framework.TestSuite;
/**
* Base class for JSR166 Junit TCK tests. Defines some constants,
@@ -108,6 +126,7 @@
* </ul>
*/
public class JSR166TestCase extends TestCase {
+ // Delays for timing-dependent tests, in milliseconds.
protected static final boolean expensiveTests = false;
@@ -116,7 +135,6 @@
public static long MEDIUM_DELAY_MS;
public static long LONG_DELAY_MS;
-
/**
* Returns the shortest timed delay. This could
* be reimplemented to use for example a Property.
@@ -204,7 +222,7 @@
}
/**
- * Find missing try { ... } finally { joinPool(e); }
+ * Finds missing try { ... } finally { joinPool(e); }
*/
void checkForkJoinPoolThreadLeaks() throws InterruptedException {
Thread[] survivors = new Thread[5];
@@ -302,11 +320,11 @@
public void threadAssertEquals(Object x, Object y) {
try {
assertEquals(x, y);
- } catch (AssertionFailedError t) {
- threadRecordFailure(t);
- throw t;
- } catch (Throwable t) {
- threadUnexpectedException(t);
+ } catch (AssertionFailedError fail) {
+ threadRecordFailure(fail);
+ throw fail;
+ } catch (Throwable fail) {
+ threadUnexpectedException(fail);
}
}
@@ -318,9 +336,9 @@
public void threadAssertSame(Object x, Object y) {
try {
assertSame(x, y);
- } catch (AssertionFailedError t) {
- threadRecordFailure(t);
- throw t;
+ } catch (AssertionFailedError fail) {
+ threadRecordFailure(fail);
+ throw fail;
}
}
@@ -385,16 +403,23 @@
void joinPool(ExecutorService exec) {
try {
exec.shutdown();
- assertTrue("ExecutorService did not terminate in a timely manner",
- exec.awaitTermination(2 * LONG_DELAY_MS, MILLISECONDS));
+ if (!exec.awaitTermination(2 * LONG_DELAY_MS, MILLISECONDS))
+ fail("ExecutorService " + exec +
+ " did not terminate in a timely manner");
} catch (SecurityException ok) {
// Allowed in case test doesn't have privs
- } catch (InterruptedException ie) {
+ } catch (InterruptedException fail) {
fail("Unexpected InterruptedException");
}
}
/**
+ * A debugging tool to print all stack traces, as jstack does.
+ */
+ static void printAllStackTraces() {
+ }
+
+ /**
* Checks that thread does not terminate within the default
* millisecond delay of {@code timeoutMillis()}.
*/
@@ -410,7 +435,7 @@
// No need to optimize the failing case via Thread.join.
delay(millis);
assertTrue(thread.isAlive());
- } catch (InterruptedException ie) {
+ } catch (InterruptedException fail) {
fail("Unexpected InterruptedException");
}
}
@@ -432,7 +457,7 @@
delay(millis);
for (Thread thread : threads)
assertTrue(thread.isAlive());
- } catch (InterruptedException ie) {
+ } catch (InterruptedException fail) {
fail("Unexpected InterruptedException");
}
}
@@ -454,8 +479,8 @@
future.get(timeoutMillis, MILLISECONDS);
shouldThrow();
} catch (TimeoutException success) {
- } catch (Exception e) {
- threadUnexpectedException(e);
+ } catch (Exception fail) {
+ threadUnexpectedException(fail);
} finally { future.cancel(true); }
assertTrue(millisElapsedSince(startTime) >= timeoutMillis);
}
@@ -499,24 +524,53 @@
public static final Integer m6 = new Integer(-6);
public static final Integer m10 = new Integer(-10);
-
/**
- * android-changed
- * Android does not use a SecurityManager. This will simply execute
- * the runnable ingoring permisions.
+ * Runs Runnable r with a security policy that permits precisely
+ * the specified permissions. If there is no current security
+ * manager, the runnable is run twice, both with and without a
+ * security manager. We require that any security manager permit
+ * getPolicy/setPolicy.
*/
public void runWithPermissions(Runnable r, Permission... permissions) {
- r.run();
+ SecurityManager sm = System.getSecurityManager();
+ if (sm == null) {
+ r.run();
+ }
+ runWithSecurityManagerWithPermissions(r, permissions);
}
/**
- * android-changed
- * Android does not use a SecurityManager. This will simply execute
- * the runnable ingoring permisions.
+ * Runs Runnable r with a security policy that permits precisely
+ * the specified permissions. If there is no current security
+ * manager, a temporary one is set for the duration of the
+ * Runnable. We require that any security manager permit
+ * getPolicy/setPolicy.
*/
public void runWithSecurityManagerWithPermissions(Runnable r,
Permission... permissions) {
- r.run();
+ SecurityManager sm = System.getSecurityManager();
+ if (sm == null) {
+ Policy savedPolicy = Policy.getPolicy();
+ try {
+ Policy.setPolicy(permissivePolicy());
+ System.setSecurityManager(new SecurityManager());
+ runWithSecurityManagerWithPermissions(r, permissions);
+ } finally {
+ System.setSecurityManager(null);
+ Policy.setPolicy(savedPolicy);
+ }
+ } else {
+ Policy savedPolicy = Policy.getPolicy();
+ AdjustablePolicy policy = new AdjustablePolicy(permissions);
+ Policy.setPolicy(policy);
+
+ try {
+ r.run();
+ } finally {
+ policy.addPermission(new SecurityPermission("setPolicy"));
+ Policy.setPolicy(savedPolicy);
+ }
+ }
}
/**
@@ -582,10 +636,10 @@
void sleep(long millis) {
try {
delay(millis);
- } catch (InterruptedException ie) {
+ } catch (InterruptedException fail) {
AssertionFailedError afe =
new AssertionFailedError("Unexpected InterruptedException");
- afe.initCause(ie);
+ afe.initCause(fail);
throw afe;
}
}
@@ -623,12 +677,42 @@
/**
* Returns the number of milliseconds since time given by
* startNanoTime, which must have been previously returned from a
- * call to {@link System.nanoTime()}.
+ * call to {@link System#nanoTime()}.
*/
- long millisElapsedSince(long startNanoTime) {
+ static long millisElapsedSince(long startNanoTime) {
return NANOSECONDS.toMillis(System.nanoTime() - startNanoTime);
}
+// void assertTerminatesPromptly(long timeoutMillis, Runnable r) {
+// long startTime = System.nanoTime();
+// try {
+// r.run();
+// } catch (Throwable fail) { threadUnexpectedException(fail); }
+// if (millisElapsedSince(startTime) > timeoutMillis/2)
+// throw new AssertionFailedError("did not return promptly");
+// }
+
+// void assertTerminatesPromptly(Runnable r) {
+// assertTerminatesPromptly(LONG_DELAY_MS/2, r);
+// }
+
+ /**
+ * Checks that timed f.get() returns the expected value, and does not
+ * wait for the timeout to elapse before returning.
+ */
+ <T> void checkTimedGet(Future<T> f, T expectedValue, long timeoutMillis) {
+ long startTime = System.nanoTime();
+ try {
+ assertEquals(expectedValue, f.get(timeoutMillis, MILLISECONDS));
+ } catch (Throwable fail) { threadUnexpectedException(fail); }
+ if (millisElapsedSince(startTime) > timeoutMillis/2)
+ throw new AssertionFailedError("timed get did not return promptly");
+ }
+
+ <T> void checkTimedGet(Future<T> f, T expectedValue) {
+ checkTimedGet(f, expectedValue, LONG_DELAY_MS);
+ }
+
/**
* Returns a new started daemon Thread running the given runnable.
*/
@@ -647,8 +731,8 @@
void awaitTermination(Thread t, long timeoutMillis) {
try {
t.join(timeoutMillis);
- } catch (InterruptedException ie) {
- threadUnexpectedException(ie);
+ } catch (InterruptedException fail) {
+ threadUnexpectedException(fail);
} finally {
if (t.getState() != Thread.State.TERMINATED) {
t.interrupt();
@@ -674,8 +758,8 @@
public final void run() {
try {
realRun();
- } catch (Throwable t) {
- threadUnexpectedException(t);
+ } catch (Throwable fail) {
+ threadUnexpectedException(fail);
}
}
}
@@ -729,8 +813,8 @@
threadShouldThrow("InterruptedException");
} catch (InterruptedException success) {
threadAssertFalse(Thread.interrupted());
- } catch (Throwable t) {
- threadUnexpectedException(t);
+ } catch (Throwable fail) {
+ threadUnexpectedException(fail);
}
}
}
@@ -741,8 +825,8 @@
public final T call() {
try {
return realCall();
- } catch (Throwable t) {
- threadUnexpectedException(t);
+ } catch (Throwable fail) {
+ threadUnexpectedException(fail);
return null;
}
}
@@ -759,8 +843,8 @@
return result;
} catch (InterruptedException success) {
threadAssertFalse(Thread.interrupted());
- } catch (Throwable t) {
- threadUnexpectedException(t);
+ } catch (Throwable fail) {
+ threadUnexpectedException(fail);
}
return null;
}
@@ -800,16 +884,16 @@
public void await(CountDownLatch latch) {
try {
assertTrue(latch.await(LONG_DELAY_MS, MILLISECONDS));
- } catch (Throwable t) {
- threadUnexpectedException(t);
+ } catch (Throwable fail) {
+ threadUnexpectedException(fail);
}
}
public void await(Semaphore semaphore) {
try {
assertTrue(semaphore.tryAcquire(LONG_DELAY_MS, MILLISECONDS));
- } catch (Throwable t) {
- threadUnexpectedException(t);
+ } catch (Throwable fail) {
+ threadUnexpectedException(fail);
}
}
@@ -1003,8 +1087,8 @@
@Override protected final void compute() {
try {
realCompute();
- } catch (Throwable t) {
- threadUnexpectedException(t);
+ } catch (Throwable fail) {
+ threadUnexpectedException(fail);
}
}
}
@@ -1018,8 +1102,8 @@
@Override protected final T compute() {
try {
return realCompute();
- } catch (Throwable t) {
- threadUnexpectedException(t);
+ } catch (Throwable fail) {
+ threadUnexpectedException(fail);
return null;
}
}
@@ -1043,12 +1127,12 @@
public int await() {
try {
return super.await(2 * LONG_DELAY_MS, MILLISECONDS);
- } catch (TimeoutException e) {
+ } catch (TimeoutException timedOut) {
throw new AssertionFailedError("timed out");
- } catch (Exception e) {
+ } catch (Exception fail) {
AssertionFailedError afe =
- new AssertionFailedError("Unexpected exception: " + e);
- afe.initCause(e);
+ new AssertionFailedError("Unexpected exception: " + fail);
+ afe.initCause(fail);
throw afe;
}
}
@@ -1076,9 +1160,7 @@
q.remove();
shouldThrow();
} catch (NoSuchElementException success) {}
- } catch (InterruptedException ie) {
- threadUnexpectedException(ie);
- }
+ } catch (InterruptedException fail) { threadUnexpectedException(fail); }
}
void assertSerialEquals(Object x, Object y) {
@@ -1097,8 +1179,8 @@
oos.flush();
oos.close();
return bos.toByteArray();
- } catch (Throwable t) {
- threadUnexpectedException(t);
+ } catch (Throwable fail) {
+ threadUnexpectedException(fail);
return new byte[0];
}
}
@@ -1111,8 +1193,8 @@
T clone = (T) ois.readObject();
assertSame(o.getClass(), clone.getClass());
return clone;
- } catch (Throwable t) {
- threadUnexpectedException(t);
+ } catch (Throwable fail) {
+ threadUnexpectedException(fail);
return null;
}
}
@@ -1137,4 +1219,12 @@
shouldThrow(expectedExceptionClass.getName());
}
}
+
+ public void assertIteratorExhausted(Iterator<?> it) {
+ try {
+ it.next();
+ shouldThrow();
+ } catch (NoSuchElementException success) {}
+ assertFalse(it.hasNext());
+ }
}
diff --git a/jsr166-tests/src/test/java/jsr166/LinkedBlockingDequeTest.java b/jsr166-tests/src/test/java/jsr166/LinkedBlockingDequeTest.java
index 4016f6d..62802bb 100644
--- a/jsr166-tests/src/test/java/jsr166/LinkedBlockingDequeTest.java
+++ b/jsr166-tests/src/test/java/jsr166/LinkedBlockingDequeTest.java
@@ -6,10 +6,12 @@
package jsr166;
-import junit.framework.*;
-import java.util.Arrays;
+import static java.util.concurrent.TimeUnit.MILLISECONDS;
+
import java.util.ArrayList;
+import java.util.Arrays;
import java.util.Collection;
+import java.util.Deque;
import java.util.Iterator;
import java.util.NoSuchElementException;
import java.util.Queue;
@@ -19,10 +21,36 @@
import java.util.concurrent.Executors;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.LinkedBlockingDeque;
-import static java.util.concurrent.TimeUnit.MILLISECONDS;
+
+import junit.framework.Test;
public class LinkedBlockingDequeTest extends JSR166TestCase {
+ // android-note: These tests have been moved into their own separate
+ // classes to work around CTS issues.
+ //
+ // public static class Unbounded extends BlockingQueueTest {
+ // protected BlockingQueue emptyCollection() {
+ // return new LinkedBlockingDeque();
+ // }
+ // }
+ //
+ // public static class Bounded extends BlockingQueueTest {
+ // protected BlockingQueue emptyCollection() {
+ // return new LinkedBlockingDeque(SIZE);
+ // }
+ // }
+ //
+ // public static void main(String[] args) {
+ // main(suite(), args);
+ // }
+ //
+ // public static Test suite() {
+ // return newTestSuite(LinkedBlockingDequeTest.class,
+ // new Unbounded().testSuite(),
+ // new Bounded().testSuite());
+ // }
+
/**
* Returns a new deque of given size containing consecutive
* Integers 0 ... n.
@@ -253,10 +281,10 @@
*/
public void testRemoveFirstOccurrence() {
LinkedBlockingDeque q = populatedDeque(SIZE);
- for (int i = 1; i < SIZE; i+=2) {
+ for (int i = 1; i < SIZE; i += 2) {
assertTrue(q.removeFirstOccurrence(new Integer(i)));
}
- for (int i = 0; i < SIZE; i+=2) {
+ for (int i = 0; i < SIZE; i += 2) {
assertTrue(q.removeFirstOccurrence(new Integer(i)));
assertFalse(q.removeFirstOccurrence(new Integer(i+1)));
}
@@ -268,10 +296,10 @@
*/
public void testRemoveLastOccurrence() {
LinkedBlockingDeque q = populatedDeque(SIZE);
- for (int i = 1; i < SIZE; i+=2) {
+ for (int i = 1; i < SIZE; i += 2) {
assertTrue(q.removeLastOccurrence(new Integer(i)));
}
- for (int i = 0; i < SIZE; i+=2) {
+ for (int i = 0; i < SIZE; i += 2) {
assertTrue(q.removeLastOccurrence(new Integer(i)));
assertFalse(q.removeLastOccurrence(new Integer(i+1)));
}
@@ -384,16 +412,16 @@
* remainingCapacity decreases on add, increases on remove
*/
public void testRemainingCapacity() {
- LinkedBlockingDeque q = populatedDeque(SIZE);
+ BlockingQueue q = populatedDeque(SIZE);
for (int i = 0; i < SIZE; ++i) {
assertEquals(i, q.remainingCapacity());
- assertEquals(SIZE-i, q.size());
- q.remove();
+ assertEquals(SIZE, q.size() + q.remainingCapacity());
+ assertEquals(i, q.remove());
}
for (int i = 0; i < SIZE; ++i) {
assertEquals(SIZE-i, q.remainingCapacity());
- assertEquals(i, q.size());
- q.add(new Integer(i));
+ assertEquals(SIZE, q.size() + q.remainingCapacity());
+ assertTrue(q.add(i));
}
}
@@ -415,9 +443,9 @@
try {
LinkedBlockingDeque q = new LinkedBlockingDeque(SIZE);
for (int i = 0; i < SIZE; ++i) {
- Integer I = new Integer(i);
- q.push(I);
- assertEquals(I, q.peek());
+ Integer x = new Integer(i);
+ q.push(x);
+ assertEquals(x, q.peek());
}
assertEquals(0, q.remainingCapacity());
q.push(new Integer(SIZE));
@@ -535,9 +563,9 @@
public void testPut() throws InterruptedException {
LinkedBlockingDeque q = new LinkedBlockingDeque(SIZE);
for (int i = 0; i < SIZE; ++i) {
- Integer I = new Integer(i);
- q.put(I);
- assertTrue(q.contains(I));
+ Integer x = new Integer(i);
+ q.put(x);
+ assertTrue(q.contains(x));
}
assertEquals(0, q.remainingCapacity());
}
@@ -767,9 +795,9 @@
public void testPutFirst() throws InterruptedException {
LinkedBlockingDeque q = new LinkedBlockingDeque(SIZE);
for (int i = 0; i < SIZE; ++i) {
- Integer I = new Integer(i);
- q.putFirst(I);
- assertTrue(q.contains(I));
+ Integer x = new Integer(i);
+ q.putFirst(x);
+ assertTrue(q.contains(x));
}
assertEquals(0, q.remainingCapacity());
}
@@ -1114,9 +1142,9 @@
public void testPutLast() throws InterruptedException {
LinkedBlockingDeque q = new LinkedBlockingDeque(SIZE);
for (int i = 0; i < SIZE; ++i) {
- Integer I = new Integer(i);
- q.putLast(I);
- assertTrue(q.contains(I));
+ Integer x = new Integer(i);
+ q.putLast(x);
+ assertTrue(q.contains(x));
}
assertEquals(0, q.remainingCapacity());
}
@@ -1450,8 +1478,8 @@
assertTrue(q.removeAll(p));
assertEquals(SIZE-i, q.size());
for (int j = 0; j < i; ++j) {
- Integer I = (Integer)(p.remove());
- assertFalse(q.contains(I));
+ Integer x = (Integer)(p.remove());
+ assertFalse(q.contains(x));
}
}
}
@@ -1495,9 +1523,26 @@
public void testIterator() throws InterruptedException {
LinkedBlockingDeque q = populatedDeque(SIZE);
Iterator it = q.iterator();
- while (it.hasNext()) {
+ int i;
+ for (i = 0; it.hasNext(); i++)
+ assertTrue(q.contains(it.next()));
+ assertEquals(i, SIZE);
+ assertIteratorExhausted(it);
+
+ it = q.iterator();
+ for (i = 0; it.hasNext(); i++)
assertEquals(it.next(), q.take());
- }
+ assertEquals(i, SIZE);
+ assertIteratorExhausted(it);
+ }
+
+ /**
+ * iterator of empty collection has no elements
+ */
+ public void testEmptyIterator() {
+ Deque c = new LinkedBlockingDeque();
+ assertIteratorExhausted(c.iterator());
+ assertIteratorExhausted(c.descendingIterator());
}
/**
@@ -1750,7 +1795,24 @@
assertEquals(SIZE-k, q.size());
for (int j = 0; j < k; ++j)
assertEquals(l.get(j), new Integer(j));
- while (q.poll() != null) ;
+ do {} while (q.poll() != null);
+ }
+ }
+
+ /**
+ * remove(null), contains(null) always return false
+ */
+ public void testNeverContainsNull() {
+ Deque<?>[] qs = {
+ new LinkedBlockingDeque<Object>(),
+ populatedDeque(2),
+ };
+
+ for (Deque<?> q : qs) {
+ assertFalse(q.contains(null));
+ assertFalse(q.remove(null));
+ assertFalse(q.removeFirstOccurrence(null));
+ assertFalse(q.removeLastOccurrence(null));
}
}
diff --git a/jsr166-tests/src/test/java/jsr166/LinkedBlockingQueueTest.java b/jsr166-tests/src/test/java/jsr166/LinkedBlockingQueueTest.java
index fe0b871..bd37b2a 100644
--- a/jsr166-tests/src/test/java/jsr166/LinkedBlockingQueueTest.java
+++ b/jsr166-tests/src/test/java/jsr166/LinkedBlockingQueueTest.java
@@ -8,22 +8,49 @@
package jsr166;
-import junit.framework.*;
-import java.util.Arrays;
+import static java.util.concurrent.TimeUnit.MILLISECONDS;
+
import java.util.ArrayList;
+import java.util.Arrays;
import java.util.Collection;
import java.util.Iterator;
import java.util.NoSuchElementException;
import java.util.Queue;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.CountDownLatch;
-import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.Executors;
import java.util.concurrent.ExecutorService;
-import static java.util.concurrent.TimeUnit.MILLISECONDS;
+import java.util.concurrent.LinkedBlockingQueue;
+
+import junit.framework.Test;
public class LinkedBlockingQueueTest extends JSR166TestCase {
+ // android-note: These tests have been moved into their own separate
+ // classes to work around CTS issues.
+ //
+ // public static class Unbounded extends BlockingQueueTest {
+ // protected BlockingQueue emptyCollection() {
+ // return new LinkedBlockingQueue();
+ // }
+ // }
+ //
+ // public static class Bounded extends BlockingQueueTest {
+ // protected BlockingQueue emptyCollection() {
+ // return new LinkedBlockingQueue(SIZE);
+ // }
+ // }
+ //
+ // public static void main(String[] args) {
+ // main(suite(), args);
+ // }
+ //
+ // public static Test suite() {
+ // return newTestSuite(LinkedBlockingQueueTest.class,
+ // new Unbounded().testSuite(),
+ // new Bounded().testSuite());
+ // }
+
/**
* Returns a new queue of given size containing consecutive
* Integers 0 ... n.
@@ -126,16 +153,16 @@
* remainingCapacity decreases on add, increases on remove
*/
public void testRemainingCapacity() {
- LinkedBlockingQueue q = populatedQueue(SIZE);
+ BlockingQueue q = populatedQueue(SIZE);
for (int i = 0; i < SIZE; ++i) {
assertEquals(i, q.remainingCapacity());
- assertEquals(SIZE-i, q.size());
- q.remove();
+ assertEquals(SIZE, q.size() + q.remainingCapacity());
+ assertEquals(i, q.remove());
}
for (int i = 0; i < SIZE; ++i) {
assertEquals(SIZE-i, q.remainingCapacity());
- assertEquals(i, q.size());
- q.add(new Integer(i));
+ assertEquals(SIZE, q.size() + q.remainingCapacity());
+ assertTrue(q.add(i));
}
}
@@ -225,9 +252,9 @@
public void testPut() throws InterruptedException {
LinkedBlockingQueue q = new LinkedBlockingQueue(SIZE);
for (int i = 0; i < SIZE; ++i) {
- Integer I = new Integer(i);
- q.put(I);
- assertTrue(q.contains(I));
+ Integer x = new Integer(i);
+ q.put(x);
+ assertTrue(q.contains(x));
}
assertEquals(0, q.remainingCapacity());
}
@@ -567,8 +594,8 @@
assertTrue(q.removeAll(p));
assertEquals(SIZE-i, q.size());
for (int j = 0; j < i; ++j) {
- Integer I = (Integer)(p.remove());
- assertFalse(q.contains(I));
+ Integer x = (Integer)(p.remove());
+ assertFalse(q.contains(x));
}
}
}
@@ -612,9 +639,24 @@
public void testIterator() throws InterruptedException {
LinkedBlockingQueue q = populatedQueue(SIZE);
Iterator it = q.iterator();
- while (it.hasNext()) {
+ int i;
+ for (i = 0; it.hasNext(); i++)
+ assertTrue(q.contains(it.next()));
+ assertEquals(i, SIZE);
+ assertIteratorExhausted(it);
+
+ it = q.iterator();
+ for (i = 0; it.hasNext(); i++)
assertEquals(it.next(), q.take());
- }
+ assertEquals(i, SIZE);
+ assertIteratorExhausted(it);
+ }
+
+ /**
+ * iterator of empty collection has no elements
+ */
+ public void testEmptyIterator() {
+ assertIteratorExhausted(new LinkedBlockingQueue().iterator());
}
/**
@@ -805,7 +847,22 @@
assertEquals(SIZE-k, q.size());
for (int j = 0; j < k; ++j)
assertEquals(l.get(j), new Integer(j));
- while (q.poll() != null) ;
+ do {} while (q.poll() != null);
+ }
+ }
+
+ /**
+ * remove(null), contains(null) always return false
+ */
+ public void testNeverContainsNull() {
+ Collection<?>[] qs = {
+ new LinkedBlockingQueue<Object>(),
+ populatedQueue(2),
+ };
+
+ for (Collection<?> q : qs) {
+ assertFalse(q.contains(null));
+ assertFalse(q.remove(null));
}
}
diff --git a/jsr166-tests/src/test/java/jsr166/LinkedListTest.java b/jsr166-tests/src/test/java/jsr166/LinkedListTest.java
index 5b09100..9d9481d 100644
--- a/jsr166-tests/src/test/java/jsr166/LinkedListTest.java
+++ b/jsr166-tests/src/test/java/jsr166/LinkedListTest.java
@@ -8,14 +8,25 @@
package jsr166;
-import junit.framework.*;
import java.util.Arrays;
import java.util.Collection;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.NoSuchElementException;
+import junit.framework.Test;
+import junit.framework.TestSuite;
+
public class LinkedListTest extends JSR166TestCase {
+ // android-note: Removed because the CTS runner does a bad job of
+ // retrying tests that have suite() declarations.
+ //
+ // public static void main(String[] args) {
+ // main(suite(), args);
+ // }
+ // public static Test suite() {
+ // return new TestSuite(...);
+ // }
/**
* Returns a new queue of given size containing consecutive
@@ -43,7 +54,7 @@
*/
public void testConstructor3() {
try {
- LinkedList q = new LinkedList((Collection)null);
+ new LinkedList((Collection)null);
shouldThrow();
} catch (NullPointerException success) {}
}
@@ -230,13 +241,13 @@
*/
public void testRemoveElement() {
LinkedList q = populatedQueue(SIZE);
- for (int i = 1; i < SIZE; i+=2) {
+ for (int i = 1; i < SIZE; i += 2) {
assertTrue(q.contains(i));
assertTrue(q.remove((Integer)i));
assertFalse(q.contains(i));
assertTrue(q.contains(i-1));
}
- for (int i = 0; i < SIZE; i+=2) {
+ for (int i = 0; i < SIZE; i += 2) {
assertTrue(q.contains(i));
assertTrue(q.remove((Integer)i));
assertFalse(q.contains(i));
@@ -315,8 +326,8 @@
assertTrue(q.removeAll(p));
assertEquals(SIZE-i, q.size());
for (int j = 0; j < i; ++j) {
- Integer I = (Integer)(p.remove());
- assertFalse(q.contains(I));
+ Integer x = (Integer)(p.remove());
+ assertFalse(q.contains(x));
}
}
}
@@ -372,13 +383,19 @@
*/
public void testIterator() {
LinkedList q = populatedQueue(SIZE);
- int i = 0;
Iterator it = q.iterator();
- while (it.hasNext()) {
+ int i;
+ for (i = 0; it.hasNext(); i++)
assertTrue(q.contains(it.next()));
- ++i;
- }
assertEquals(i, SIZE);
+ assertIteratorExhausted(it);
+ }
+
+ /**
+ * iterator of empty collection has no elements
+ */
+ public void testEmptyIterator() {
+ assertIteratorExhausted(new LinkedList().iterator());
}
/**
@@ -599,10 +616,10 @@
*/
public void testRemoveFirstOccurrence() {
LinkedList q = populatedQueue(SIZE);
- for (int i = 1; i < SIZE; i+=2) {
+ for (int i = 1; i < SIZE; i += 2) {
assertTrue(q.removeFirstOccurrence(new Integer(i)));
}
- for (int i = 0; i < SIZE; i+=2) {
+ for (int i = 0; i < SIZE; i += 2) {
assertTrue(q.removeFirstOccurrence(new Integer(i)));
assertFalse(q.removeFirstOccurrence(new Integer(i+1)));
}
@@ -614,10 +631,10 @@
*/
public void testRemoveLastOccurrence() {
LinkedList q = populatedQueue(SIZE);
- for (int i = 1; i < SIZE; i+=2) {
+ for (int i = 1; i < SIZE; i += 2) {
assertTrue(q.removeLastOccurrence(new Integer(i)));
}
- for (int i = 0; i < SIZE; i+=2) {
+ for (int i = 0; i < SIZE; i += 2) {
assertTrue(q.removeLastOccurrence(new Integer(i)));
assertFalse(q.removeLastOccurrence(new Integer(i+1)));
}
diff --git a/jsr166-tests/src/test/java/jsr166/LinkedTransferQueueTest.java b/jsr166-tests/src/test/java/jsr166/LinkedTransferQueueTest.java
index 94427df..f5893ec 100644
--- a/jsr166-tests/src/test/java/jsr166/LinkedTransferQueueTest.java
+++ b/jsr166-tests/src/test/java/jsr166/LinkedTransferQueueTest.java
@@ -7,9 +7,10 @@
package jsr166;
-import junit.framework.*;
-import java.util.Arrays;
+import static java.util.concurrent.TimeUnit.MILLISECONDS;
+
import java.util.ArrayList;
+import java.util.Arrays;
import java.util.Collection;
import java.util.Iterator;
import java.util.List;
@@ -20,12 +21,30 @@
import java.util.concurrent.Executors;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.LinkedTransferQueue;
-import static java.util.concurrent.TimeUnit.MILLISECONDS;
-import static java.util.concurrent.TimeUnit.NANOSECONDS;
+
+import junit.framework.Test;
@SuppressWarnings({"unchecked", "rawtypes"})
+// android-changed: Extend BlockingQueueTest directly.
public class LinkedTransferQueueTest extends BlockingQueueTest {
+ // android-changed: Extend BlockingQueueTest directly.
+ //
+ // public static class Generic extends BlockingQueueTest {
+ // protected BlockingQueue emptyCollection() {
+ // return new LinkedTransferQueue();
+ // }
+ // }
+ //
+ // public static void main(String[] args) {
+ // main(suite(), args);
+ // }
+ //
+ // public static Test suite() {
+ // return newTestSuite(LinkedTransferQueueTest.class,
+ // new Generic().testSuite());
+ // }
+
protected BlockingQueue emptyCollection() {
return new LinkedTransferQueue();
}
@@ -105,16 +124,16 @@
* remainingCapacity() always returns Integer.MAX_VALUE
*/
public void testRemainingCapacity() {
- LinkedTransferQueue<Integer> q = populatedQueue(SIZE);
+ BlockingQueue q = populatedQueue(SIZE);
for (int i = 0; i < SIZE; ++i) {
assertEquals(Integer.MAX_VALUE, q.remainingCapacity());
assertEquals(SIZE - i, q.size());
- q.remove();
+ assertEquals(i, q.remove());
}
for (int i = 0; i < SIZE; ++i) {
assertEquals(Integer.MAX_VALUE, q.remainingCapacity());
assertEquals(i, q.size());
- q.add(i);
+ assertTrue(q.add(i));
}
}
@@ -490,11 +509,24 @@
public void testIterator() throws InterruptedException {
LinkedTransferQueue q = populatedQueue(SIZE);
Iterator it = q.iterator();
- int i = 0;
- while (it.hasNext()) {
- assertEquals(it.next(), i++);
- }
+ int i;
+ for (i = 0; it.hasNext(); i++)
+ assertTrue(q.contains(it.next()));
assertEquals(i, SIZE);
+ assertIteratorExhausted(it);
+
+ it = q.iterator();
+ for (i = 0; it.hasNext(); i++)
+ assertEquals(it.next(), q.take());
+ assertEquals(i, SIZE);
+ assertIteratorExhausted(it);
+ }
+
+ /**
+ * iterator of empty collection has no elements
+ */
+ public void testEmptyIterator() {
+ assertIteratorExhausted(new LinkedTransferQueue().iterator());
}
/**
@@ -687,8 +719,7 @@
assertEquals(SIZE - k, q.size());
for (int j = 0; j < k; ++j)
assertEquals(j, l.get(j));
- while (q.poll() != null)
- ;
+ do {} while (q.poll() != null);
}
}
@@ -1004,4 +1035,19 @@
assertFalse(q.isEmpty());
return q;
}
+
+ /**
+ * remove(null), contains(null) always return false
+ */
+ public void testNeverContainsNull() {
+ Collection<?>[] qs = {
+ new LinkedTransferQueue<Object>(),
+ populatedQueue(2),
+ };
+
+ for (Collection<?> q : qs) {
+ assertFalse(q.contains(null));
+ assertFalse(q.remove(null));
+ }
+ }
}
diff --git a/jsr166-tests/src/test/java/jsr166/LockSupportTest.java b/jsr166-tests/src/test/java/jsr166/LockSupportTest.java
index 051de35..8347b08 100644
--- a/jsr166-tests/src/test/java/jsr166/LockSupportTest.java
+++ b/jsr166-tests/src/test/java/jsr166/LockSupportTest.java
@@ -9,13 +9,25 @@
package jsr166;
-import junit.framework.*;
+import static java.util.concurrent.TimeUnit.MILLISECONDS;
+
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.atomic.AtomicBoolean;
import java.util.concurrent.locks.LockSupport;
-import static java.util.concurrent.TimeUnit.MILLISECONDS;
+
+import junit.framework.Test;
+import junit.framework.TestSuite;
public class LockSupportTest extends JSR166TestCase {
+ // android-note: Removed because the CTS runner does a bad job of
+ // retrying tests that have suite() declarations.
+ //
+ // public static void main(String[] args) {
+ // main(suite(), args);
+ // }
+ // public static Test suite() {
+ // return new TestSuite(...);
+ // }
/**
* Returns the blocker object used by tests in this file.
diff --git a/jsr166-tests/src/test/java/jsr166/PhaserTest.java b/jsr166-tests/src/test/java/jsr166/PhaserTest.java
index 3889c1f..42d72f4 100644
--- a/jsr166-tests/src/test/java/jsr166/PhaserTest.java
+++ b/jsr166-tests/src/test/java/jsr166/PhaserTest.java
@@ -7,19 +7,30 @@
package jsr166;
-import junit.framework.*;
+import static java.util.concurrent.TimeUnit.MILLISECONDS;
+
import java.util.ArrayList;
import java.util.List;
-import java.util.concurrent.Phaser;
import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.Phaser;
import java.util.concurrent.TimeoutException;
-import static java.util.concurrent.TimeUnit.MILLISECONDS;
-import static java.util.concurrent.TimeUnit.NANOSECONDS;
-import java.util.concurrent.atomic.AtomicBoolean;
import java.util.concurrent.atomic.AtomicInteger;
+import junit.framework.Test;
+import junit.framework.TestSuite;
+
public class PhaserTest extends JSR166TestCase {
+ // android-note: Removed because the CTS runner does a bad job of
+ // retrying tests that have suite() declarations.
+ //
+ // public static void main(String[] args) {
+ // main(suite(), args);
+ // }
+ // public static Test suite() {
+ // return new TestSuite(...);
+ // }
+
private static final int maxParties = 65535;
/** Checks state of unterminated phaser. */
diff --git a/jsr166-tests/src/test/java/jsr166/PriorityBlockingQueueTest.java b/jsr166-tests/src/test/java/jsr166/PriorityBlockingQueueTest.java
index 89d6d24..64c3b3a 100644
--- a/jsr166-tests/src/test/java/jsr166/PriorityBlockingQueueTest.java
+++ b/jsr166-tests/src/test/java/jsr166/PriorityBlockingQueueTest.java
@@ -8,24 +8,49 @@
package jsr166;
-import junit.framework.*;
-import java.util.Arrays;
+import static java.util.concurrent.TimeUnit.MILLISECONDS;
+
import java.util.ArrayList;
+import java.util.Arrays;
import java.util.Collection;
import java.util.Comparator;
import java.util.Iterator;
import java.util.NoSuchElementException;
import java.util.Queue;
-import java.util.concurrent.PriorityBlockingQueue;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.Executors;
import java.util.concurrent.ExecutorService;
-import static java.util.concurrent.TimeUnit.MILLISECONDS;
+import java.util.concurrent.PriorityBlockingQueue;
+
+import junit.framework.Test;
public class PriorityBlockingQueueTest extends JSR166TestCase {
- private static final int NOCAP = Integer.MAX_VALUE;
+ // android-note: These tests have been moved into their own separate
+ // classes to work around CTS issues.
+ //
+ // public static class Generic extends BlockingQueueTest {
+ // protected BlockingQueue emptyCollection() {
+ // return new PriorityBlockingQueue();
+ // }
+ // }
+ //
+ // public static class InitialCapacity extends BlockingQueueTest {
+ // protected BlockingQueue emptyCollection() {
+ // return new PriorityBlockingQueue(SIZE);
+ // }
+ // }
+ //
+ // public static void main(String[] args) {
+ // main(suite(), args);
+ // }
+ //
+ // public static Test suite() {
+ // return newTestSuite(PriorityBlockingQueueTest.class,
+ // new Generic().testSuite(),
+ // new InitialCapacity().testSuite());
+ // }
/** Sample Comparator */
static class MyReverseComparator implements Comparator {
@@ -42,12 +67,12 @@
PriorityBlockingQueue<Integer> q =
new PriorityBlockingQueue<Integer>(n);
assertTrue(q.isEmpty());
- for (int i = n-1; i >= 0; i-=2)
+ for (int i = n-1; i >= 0; i -= 2)
assertTrue(q.offer(new Integer(i)));
- for (int i = (n & 1); i < n; i+=2)
+ for (int i = (n & 1); i < n; i += 2)
assertTrue(q.offer(new Integer(i)));
assertFalse(q.isEmpty());
- assertEquals(NOCAP, q.remainingCapacity());
+ assertEquals(Integer.MAX_VALUE, q.remainingCapacity());
assertEquals(n, q.size());
return q;
}
@@ -56,7 +81,8 @@
* A new queue has unbounded capacity
*/
public void testConstructor1() {
- assertEquals(NOCAP, new PriorityBlockingQueue(SIZE).remainingCapacity());
+ assertEquals(Integer.MAX_VALUE,
+ new PriorityBlockingQueue(SIZE).remainingCapacity());
}
/**
@@ -137,7 +163,7 @@
public void testEmpty() {
PriorityBlockingQueue q = new PriorityBlockingQueue(2);
assertTrue(q.isEmpty());
- assertEquals(NOCAP, q.remainingCapacity());
+ assertEquals(Integer.MAX_VALUE, q.remainingCapacity());
q.add(one);
assertFalse(q.isEmpty());
q.add(two);
@@ -147,20 +173,19 @@
}
/**
- * remainingCapacity does not change when elements added or removed,
- * but size does
+ * remainingCapacity() always returns Integer.MAX_VALUE
*/
public void testRemainingCapacity() {
- PriorityBlockingQueue q = populatedQueue(SIZE);
+ BlockingQueue q = populatedQueue(SIZE);
for (int i = 0; i < SIZE; ++i) {
- assertEquals(NOCAP, q.remainingCapacity());
- assertEquals(SIZE-i, q.size());
- q.remove();
+ assertEquals(Integer.MAX_VALUE, q.remainingCapacity());
+ assertEquals(SIZE - i, q.size());
+ assertEquals(i, q.remove());
}
for (int i = 0; i < SIZE; ++i) {
- assertEquals(NOCAP, q.remainingCapacity());
+ assertEquals(Integer.MAX_VALUE, q.remainingCapacity());
assertEquals(i, q.size());
- q.add(new Integer(i));
+ assertTrue(q.add(i));
}
}
@@ -177,9 +202,8 @@
* Offer of non-Comparable throws CCE
*/
public void testOfferNonComparable() {
+ PriorityBlockingQueue q = new PriorityBlockingQueue(1);
try {
- PriorityBlockingQueue q = new PriorityBlockingQueue(1);
- q.offer(new Object());
q.offer(new Object());
q.offer(new Object());
shouldThrow();
@@ -244,9 +268,9 @@
public void testPut() {
PriorityBlockingQueue q = new PriorityBlockingQueue(SIZE);
for (int i = 0; i < SIZE; ++i) {
- Integer I = new Integer(i);
- q.put(I);
- assertTrue(q.contains(I));
+ Integer x = new Integer(i);
+ q.put(x);
+ assertTrue(q.contains(x));
}
assertEquals(SIZE, q.size());
}
@@ -508,8 +532,8 @@
assertTrue(q.removeAll(p));
assertEquals(SIZE-i, q.size());
for (int j = 0; j < i; ++j) {
- Integer I = (Integer)(p.remove());
- assertFalse(q.contains(I));
+ Integer x = (Integer)(p.remove());
+ assertFalse(q.contains(x));
}
}
}
@@ -554,13 +578,19 @@
*/
public void testIterator() {
PriorityBlockingQueue q = populatedQueue(SIZE);
- int i = 0;
Iterator it = q.iterator();
- while (it.hasNext()) {
+ int i;
+ for (i = 0; it.hasNext(); i++)
assertTrue(q.contains(it.next()));
- ++i;
- }
assertEquals(i, SIZE);
+ assertIteratorExhausted(it);
+ }
+
+ /**
+ * iterator of empty collection has no elements
+ */
+ public void testEmptyIterator() {
+ assertIteratorExhausted(new PriorityBlockingQueue().iterator());
}
/**
@@ -692,7 +722,22 @@
assertEquals(SIZE-k, q.size());
for (int j = 0; j < k; ++j)
assertEquals(l.get(j), new Integer(j));
- while (q.poll() != null) ;
+ do {} while (q.poll() != null);
+ }
+ }
+
+ /**
+ * remove(null), contains(null) always return false
+ */
+ public void testNeverContainsNull() {
+ Collection<?>[] qs = {
+ new PriorityBlockingQueue<Object>(),
+ populatedQueue(2),
+ };
+
+ for (Collection<?> q : qs) {
+ assertFalse(q.contains(null));
+ assertFalse(q.remove(null));
}
}
diff --git a/jsr166-tests/src/test/java/jsr166/PriorityQueueTest.java b/jsr166-tests/src/test/java/jsr166/PriorityQueueTest.java
index 2b237dd..88cdd37 100644
--- a/jsr166-tests/src/test/java/jsr166/PriorityQueueTest.java
+++ b/jsr166-tests/src/test/java/jsr166/PriorityQueueTest.java
@@ -8,7 +8,6 @@
package jsr166;
-import junit.framework.*;
import java.util.Arrays;
import java.util.Collection;
import java.util.Comparator;
@@ -17,7 +16,19 @@
import java.util.PriorityQueue;
import java.util.Queue;
+import junit.framework.Test;
+import junit.framework.TestSuite;
+
public class PriorityQueueTest extends JSR166TestCase {
+ // android-note: Removed because the CTS runner does a bad job of
+ // retrying tests that have suite() declarations.
+ //
+ // public static void main(String[] args) {
+ // main(suite(), args);
+ // }
+ // public static Test suite() {
+ // return new TestSuite(...);
+ // }
static class MyReverseComparator implements Comparator {
public int compare(Object x, Object y) {
@@ -32,9 +43,9 @@
private PriorityQueue<Integer> populatedQueue(int n) {
PriorityQueue<Integer> q = new PriorityQueue<Integer>(n);
assertTrue(q.isEmpty());
- for (int i = n-1; i >= 0; i-=2)
+ for (int i = n-1; i >= 0; i -= 2)
assertTrue(q.offer(new Integer(i)));
- for (int i = (n & 1); i < n; i+=2)
+ for (int i = (n & 1); i < n; i += 2)
assertTrue(q.offer(new Integer(i)));
assertFalse(q.isEmpty());
assertEquals(n, q.size());
@@ -53,7 +64,7 @@
*/
public void testConstructor2() {
try {
- PriorityQueue q = new PriorityQueue(0);
+ new PriorityQueue(0);
shouldThrow();
} catch (IllegalArgumentException success) {}
}
@@ -63,7 +74,7 @@
*/
public void testConstructor3() {
try {
- PriorityQueue q = new PriorityQueue((Collection)null);
+ new PriorityQueue((Collection)null);
shouldThrow();
} catch (NullPointerException success) {}
}
@@ -74,7 +85,7 @@
public void testConstructor4() {
try {
Integer[] ints = new Integer[SIZE];
- PriorityQueue q = new PriorityQueue(Arrays.asList(ints));
+ new PriorityQueue(Arrays.asList(ints));
shouldThrow();
} catch (NullPointerException success) {}
}
@@ -87,7 +98,7 @@
Integer[] ints = new Integer[SIZE];
for (int i = 0; i < SIZE-1; ++i)
ints[i] = new Integer(i);
- PriorityQueue q = new PriorityQueue(Arrays.asList(ints));
+ new PriorityQueue(Arrays.asList(ints));
shouldThrow();
} catch (NullPointerException success) {}
}
@@ -183,9 +194,8 @@
* Offer of non-Comparable throws CCE
*/
public void testOfferNonComparable() {
+ PriorityQueue q = new PriorityQueue(1);
try {
- PriorityQueue q = new PriorityQueue(1);
- q.offer(new Object());
q.offer(new Object());
q.offer(new Object());
shouldThrow();
@@ -315,13 +325,13 @@
*/
public void testRemoveElement() {
PriorityQueue q = populatedQueue(SIZE);
- for (int i = 1; i < SIZE; i+=2) {
+ for (int i = 1; i < SIZE; i += 2) {
assertTrue(q.contains(i));
assertTrue(q.remove(i));
assertFalse(q.contains(i));
assertTrue(q.contains(i-1));
}
- for (int i = 0; i < SIZE; i+=2) {
+ for (int i = 0; i < SIZE; i += 2) {
assertTrue(q.contains(i));
assertTrue(q.remove(i));
assertFalse(q.contains(i));
@@ -400,8 +410,8 @@
assertTrue(q.removeAll(p));
assertEquals(SIZE-i, q.size());
for (int j = 0; j < i; ++j) {
- Integer I = (Integer)(p.remove());
- assertFalse(q.contains(I));
+ Integer x = (Integer)(p.remove());
+ assertFalse(q.contains(x));
}
}
}
@@ -435,13 +445,19 @@
*/
public void testIterator() {
PriorityQueue q = populatedQueue(SIZE);
- int i = 0;
Iterator it = q.iterator();
- while (it.hasNext()) {
+ int i;
+ for (i = 0; it.hasNext(); i++)
assertTrue(q.contains(it.next()));
- ++i;
- }
assertEquals(i, SIZE);
+ assertIteratorExhausted(it);
+ }
+
+ /**
+ * iterator of empty collection has no elements
+ */
+ public void testEmptyIterator() {
+ assertIteratorExhausted(new PriorityQueue().iterator());
}
/**
diff --git a/jsr166-tests/src/test/java/jsr166/RecursiveActionTest.java b/jsr166-tests/src/test/java/jsr166/RecursiveActionTest.java
index ad61a2e..1c3bba8 100644
--- a/jsr166-tests/src/test/java/jsr166/RecursiveActionTest.java
+++ b/jsr166-tests/src/test/java/jsr166/RecursiveActionTest.java
@@ -6,23 +6,35 @@
package jsr166;
-import junit.framework.*;
+import static java.util.concurrent.TimeUnit.SECONDS;
+
+import java.util.Arrays;
+import java.util.HashSet;
import java.util.concurrent.CancellationException;
-import java.util.concurrent.SynchronousQueue;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ForkJoinPool;
import java.util.concurrent.ForkJoinTask;
import java.util.concurrent.ForkJoinWorkerThread;
import java.util.concurrent.RecursiveAction;
+import java.util.concurrent.SynchronousQueue;
import java.util.concurrent.ThreadLocalRandom;
-import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;
-import static java.util.concurrent.TimeUnit.SECONDS;
-import java.util.Arrays;
-import java.util.HashSet;
+
+import junit.framework.Test;
+import junit.framework.TestSuite;
public class RecursiveActionTest extends JSR166TestCase {
+ // android-note: Removed because the CTS runner does a bad job of
+ // retrying tests that have suite() declarations.
+ //
+ // public static void main(String[] args) {
+ // main(suite(), args);
+ // }
+ // public static Test suite() {
+ // return new TestSuite(...);
+ // }
+
private static ForkJoinPool mainPool() {
return new ForkJoinPool();
}
@@ -496,6 +508,8 @@
FibAction f = new FibAction(8);
assertSame(f, f.fork());
helpQuiesce();
+ while (!f.isDone()) // wait out race
+ ;
assertEquals(21, f.result);
assertEquals(0, getQueuedTaskCount());
checkCompletedNormally(f);
@@ -581,7 +595,7 @@
FailingFibAction f = new FailingFibAction(8);
assertSame(f, f.fork());
try {
- f.get(5L, TimeUnit.SECONDS);
+ f.get(5L, SECONDS);
shouldThrow();
} catch (ExecutionException success) {
Throwable cause = success.getCause();
diff --git a/jsr166-tests/src/test/java/jsr166/RecursiveTaskTest.java b/jsr166-tests/src/test/java/jsr166/RecursiveTaskTest.java
index 48b6470..7783370 100644
--- a/jsr166-tests/src/test/java/jsr166/RecursiveTaskTest.java
+++ b/jsr166-tests/src/test/java/jsr166/RecursiveTaskTest.java
@@ -6,20 +6,31 @@
package jsr166;
-import junit.framework.*;
+import static java.util.concurrent.TimeUnit.SECONDS;
+
+import java.util.HashSet;
import java.util.concurrent.CancellationException;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ForkJoinPool;
import java.util.concurrent.ForkJoinTask;
-import java.util.concurrent.ForkJoinWorkerThread;
import java.util.concurrent.RecursiveTask;
-import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;
-import static java.util.concurrent.TimeUnit.SECONDS;
-import java.util.HashSet;
+
+import junit.framework.Test;
+import junit.framework.TestSuite;
public class RecursiveTaskTest extends JSR166TestCase {
+ // android-note: Removed because the CTS runner does a bad job of
+ // retrying tests that have suite() declarations.
+ //
+ // public static void main(String[] args) {
+ // main(suite(), args);
+ // }
+ // public static Test suite() {
+ // return new TestSuite(...);
+ // }
+
private static ForkJoinPool mainPool() {
return new ForkJoinPool();
}
diff --git a/jsr166-tests/src/test/java/jsr166/ReentrantLockTest.java b/jsr166-tests/src/test/java/jsr166/ReentrantLockTest.java
index 6fe8122..17eaf76 100644
--- a/jsr166-tests/src/test/java/jsr166/ReentrantLockTest.java
+++ b/jsr166-tests/src/test/java/jsr166/ReentrantLockTest.java
@@ -8,34 +8,48 @@
package jsr166;
-import junit.framework.*;
-import java.util.concurrent.locks.Condition;
-import java.util.concurrent.locks.ReentrantLock;
+import static java.util.concurrent.TimeUnit.MILLISECONDS;
+
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.HashSet;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.CyclicBarrier;
-import static java.util.concurrent.TimeUnit.MILLISECONDS;
-import java.util.*;
+import java.util.concurrent.locks.Condition;
+import java.util.concurrent.locks.ReentrantLock;
+
+import junit.framework.AssertionFailedError;
+import junit.framework.Test;
+import junit.framework.TestSuite;
public class ReentrantLockTest extends JSR166TestCase {
-
+ // android-note: Removed because the CTS runner does a bad job of
+ // retrying tests that have suite() declarations.
+ //
+ // public static void main(String[] args) {
+ // main(suite(), args);
+ // }
+ // public static Test suite() {
+ // return new TestSuite(...);
+ // }
/**
- * A runnable calling lockInterruptibly
+ * A checked runnable calling lockInterruptibly
*/
class InterruptibleLockRunnable extends CheckedRunnable {
final ReentrantLock lock;
- InterruptibleLockRunnable(ReentrantLock l) { lock = l; }
+ InterruptibleLockRunnable(ReentrantLock lock) { this.lock = lock; }
public void realRun() throws InterruptedException {
lock.lockInterruptibly();
}
}
/**
- * A runnable calling lockInterruptibly that expects to be
+ * A checked runnable calling lockInterruptibly that expects to be
* interrupted
*/
class InterruptedLockRunnable extends CheckedInterruptedRunnable {
final ReentrantLock lock;
- InterruptedLockRunnable(ReentrantLock l) { lock = l; }
+ InterruptedLockRunnable(ReentrantLock lock) { this.lock = lock; }
public void realRun() throws InterruptedException {
lock.lockInterruptibly();
}
@@ -133,7 +147,7 @@
lock.unlock();
}
- enum AwaitMethod { await, awaitTimed, awaitNanos, awaitUntil };
+ enum AwaitMethod { await, awaitTimed, awaitNanos, awaitUntil }
/**
* Awaits condition using the specified AwaitMethod.
@@ -156,6 +170,8 @@
case awaitUntil:
assertTrue(c.awaitUntil(delayedDate(timeoutMillis)));
break;
+ default:
+ throw new AssertionError();
}
}
@@ -448,9 +464,7 @@
barrier.await();
awaitTermination(t);
assertFalse(lock.isLocked());
- } catch (Exception e) {
- threadUnexpectedException(e);
- }
+ } catch (Exception fail) { threadUnexpectedException(fail); }
}
/**
@@ -462,9 +476,7 @@
final PublicReentrantLock lock = new PublicReentrantLock(fair);
try {
lock.lockInterruptibly();
- } catch (InterruptedException ie) {
- threadUnexpectedException(ie);
- }
+ } catch (InterruptedException fail) { threadUnexpectedException(fail); }
assertLockedByMoi(lock);
Thread t = newStartedThread(new InterruptedLockRunnable(lock));
waitForQueuedThread(lock, t);
@@ -525,9 +537,7 @@
assertTrue(nanosRemaining <= 0);
assertTrue(millisElapsedSince(startTime) >= timeoutMillis);
lock.unlock();
- } catch (InterruptedException e) {
- threadUnexpectedException(e);
- }
+ } catch (InterruptedException fail) { threadUnexpectedException(fail); }
}
/**
@@ -545,9 +555,7 @@
assertFalse(c.await(timeoutMillis, MILLISECONDS));
assertTrue(millisElapsedSince(startTime) >= timeoutMillis);
lock.unlock();
- } catch (InterruptedException e) {
- threadUnexpectedException(e);
- }
+ } catch (InterruptedException fail) { threadUnexpectedException(fail); }
}
/**
@@ -566,9 +574,7 @@
assertFalse(c.awaitUntil(new java.util.Date(d.getTime() + timeoutMillis)));
assertTrue(millisElapsedSince(startTime) >= timeoutMillis);
lock.unlock();
- } catch (InterruptedException e) {
- threadUnexpectedException(e);
- }
+ } catch (InterruptedException fail) { threadUnexpectedException(fail); }
}
/**
diff --git a/jsr166-tests/src/test/java/jsr166/ReentrantReadWriteLockTest.java b/jsr166-tests/src/test/java/jsr166/ReentrantReadWriteLockTest.java
index 2be27d2..7ef8ea3 100644
--- a/jsr166-tests/src/test/java/jsr166/ReentrantReadWriteLockTest.java
+++ b/jsr166-tests/src/test/java/jsr166/ReentrantReadWriteLockTest.java
@@ -8,16 +8,31 @@
package jsr166;
-import junit.framework.*;
+import static java.util.concurrent.TimeUnit.MILLISECONDS;
+
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.HashSet;
+import java.util.concurrent.CountDownLatch;
import java.util.concurrent.atomic.AtomicBoolean;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantReadWriteLock;
-import java.util.concurrent.CountDownLatch;
-import static java.util.concurrent.TimeUnit.MILLISECONDS;
-import java.util.*;
+
+import junit.framework.AssertionFailedError;
+import junit.framework.Test;
+import junit.framework.TestSuite;
public class ReentrantReadWriteLockTest extends JSR166TestCase {
+ // android-note: Removed because the CTS runner does a bad job of
+ // retrying tests that have suite() declarations.
+ //
+ // public static void main(String[] args) {
+ // main(suite(), args);
+ // }
+ // public static Test suite() {
+ // return new TestSuite(...);
+ // }
/**
* A runnable calling lockInterruptibly
@@ -142,7 +157,7 @@
lock.writeLock().unlock();
}
- enum AwaitMethod { await, awaitTimed, awaitNanos, awaitUntil };
+ enum AwaitMethod { await, awaitTimed, awaitNanos, awaitUntil }
/**
* Awaits condition using the specified AwaitMethod.
@@ -164,6 +179,8 @@
java.util.Date d = new java.util.Date();
assertTrue(c.awaitUntil(new java.util.Date(d.getTime() + 2 * LONG_DELAY_MS)));
break;
+ default:
+ throw new AssertionError();
}
}
@@ -818,9 +835,7 @@
new PublicReentrantReadWriteLock(fair);
try {
lock.writeLock().lockInterruptibly();
- } catch (InterruptedException ie) {
- threadUnexpectedException(ie);
- }
+ } catch (InterruptedException fail) { threadUnexpectedException(fail); }
Thread t = newStartedThread(new CheckedInterruptedRunnable() {
public void realRun() throws InterruptedException {
lock.writeLock().lockInterruptibly();
@@ -845,9 +860,7 @@
lock.readLock().lockInterruptibly();
lock.readLock().unlock();
lock.writeLock().lockInterruptibly();
- } catch (InterruptedException ie) {
- threadUnexpectedException(ie);
- }
+ } catch (InterruptedException fail) { threadUnexpectedException(fail); }
Thread t = newStartedThread(new CheckedInterruptedRunnable() {
public void realRun() throws InterruptedException {
lock.readLock().lockInterruptibly();
@@ -873,7 +886,9 @@
await(c, awaitMethod);
shouldThrow();
} catch (IllegalMonitorStateException success) {
- } catch (InterruptedException e) { threadUnexpectedException(e); }
+ } catch (InterruptedException fail) {
+ threadUnexpectedException(fail);
+ }
assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
}
}
@@ -924,9 +939,7 @@
assertTrue(nanosRemaining <= 0);
assertTrue(millisElapsedSince(startTime) >= timeoutMillis);
lock.writeLock().unlock();
- } catch (InterruptedException e) {
- threadUnexpectedException(e);
- }
+ } catch (InterruptedException fail) { threadUnexpectedException(fail); }
}
/**
@@ -945,9 +958,7 @@
assertFalse(c.await(timeoutMillis, MILLISECONDS));
assertTrue(millisElapsedSince(startTime) >= timeoutMillis);
lock.writeLock().unlock();
- } catch (InterruptedException e) {
- threadUnexpectedException(e);
- }
+ } catch (InterruptedException fail) { threadUnexpectedException(fail); }
}
/**
@@ -967,9 +978,7 @@
assertFalse(c.awaitUntil(new java.util.Date(d.getTime() + timeoutMillis)));
assertTrue(millisElapsedSince(startTime) >= timeoutMillis);
lock.writeLock().unlock();
- } catch (InterruptedException e) {
- threadUnexpectedException(e);
- }
+ } catch (InterruptedException fail) { threadUnexpectedException(fail); }
}
/**
diff --git a/jsr166-tests/src/test/java/jsr166/ScheduledExecutorSubclassTest.java b/jsr166-tests/src/test/java/jsr166/ScheduledExecutorSubclassTest.java
index b72ad02..a93feea 100644
--- a/jsr166-tests/src/test/java/jsr166/ScheduledExecutorSubclassTest.java
+++ b/jsr166-tests/src/test/java/jsr166/ScheduledExecutorSubclassTest.java
@@ -6,13 +6,42 @@
package jsr166;
-import junit.framework.*;
-import java.util.*;
-import java.util.concurrent.*;
import static java.util.concurrent.TimeUnit.MILLISECONDS;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.concurrent.BlockingQueue;
+import java.util.concurrent.Callable;
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.Delayed;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.Executors;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Future;
+import java.util.concurrent.RejectedExecutionException;
+import java.util.concurrent.RejectedExecutionHandler;
+import java.util.concurrent.RunnableScheduledFuture;
+import java.util.concurrent.ScheduledFuture;
+import java.util.concurrent.ScheduledThreadPoolExecutor;
+import java.util.concurrent.ThreadFactory;
+import java.util.concurrent.ThreadPoolExecutor;
+import java.util.concurrent.TimeoutException;
+import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicInteger;
+import junit.framework.Test;
+import junit.framework.TestSuite;
+
public class ScheduledExecutorSubclassTest extends JSR166TestCase {
+ // android-note: Removed because the CTS runner does a bad job of
+ // retrying tests that have suite() declarations.
+ //
+ // public static void main(String[] args) {
+ // main(suite(), args);
+ // }
+ // public static Test suite() {
+ // return new TestSuite(...);
+ // }
static class CustomTask<V> implements RunnableScheduledFuture<V> {
RunnableScheduledFuture<V> task;
@@ -189,17 +218,27 @@
*/
public void testFixedRateSequence() throws InterruptedException {
CustomExecutor p = new CustomExecutor(1);
- RunnableCounter counter = new RunnableCounter();
- ScheduledFuture h =
- p.scheduleAtFixedRate(counter, 0, 1, MILLISECONDS);
- delay(SMALL_DELAY_MS);
- h.cancel(true);
- int c = counter.count.get();
- // By time scaling conventions, we must have at least
- // an execution per SHORT delay, but no more than one SHORT more
- assertTrue(c >= SMALL_DELAY_MS / SHORT_DELAY_MS);
- assertTrue(c <= SMALL_DELAY_MS + SHORT_DELAY_MS);
- joinPool(p);
+ try {
+ for (int delay = 1; delay <= LONG_DELAY_MS; delay *= 3) {
+ long startTime = System.nanoTime();
+ int cycles = 10;
+ final CountDownLatch done = new CountDownLatch(cycles);
+ Runnable task = new CheckedRunnable() {
+ public void realRun() { done.countDown(); }};
+ ScheduledFuture h =
+ p.scheduleAtFixedRate(task, 0, delay, MILLISECONDS);
+ done.await();
+ h.cancel(true);
+ double normalizedTime =
+ (double) millisElapsedSince(startTime) / delay;
+ if (normalizedTime >= cycles - 1 &&
+ normalizedTime <= cycles)
+ return;
+ }
+ throw new AssertionError("unexpected execution rate");
+ } finally {
+ joinPool(p);
+ }
}
/**
@@ -207,15 +246,27 @@
*/
public void testFixedDelaySequence() throws InterruptedException {
CustomExecutor p = new CustomExecutor(1);
- RunnableCounter counter = new RunnableCounter();
- ScheduledFuture h =
- p.scheduleWithFixedDelay(counter, 0, 1, MILLISECONDS);
- delay(SMALL_DELAY_MS);
- h.cancel(true);
- int c = counter.count.get();
- assertTrue(c >= SMALL_DELAY_MS / SHORT_DELAY_MS);
- assertTrue(c <= SMALL_DELAY_MS + SHORT_DELAY_MS);
- joinPool(p);
+ try {
+ for (int delay = 1; delay <= LONG_DELAY_MS; delay *= 3) {
+ long startTime = System.nanoTime();
+ int cycles = 10;
+ final CountDownLatch done = new CountDownLatch(cycles);
+ Runnable task = new CheckedRunnable() {
+ public void realRun() { done.countDown(); }};
+ ScheduledFuture h =
+ p.scheduleWithFixedDelay(task, 0, delay, MILLISECONDS);
+ done.await();
+ h.cancel(true);
+ double normalizedTime =
+ (double) millisElapsedSince(startTime) / delay;
+ if (normalizedTime >= cycles - 1 &&
+ normalizedTime <= cycles)
+ return;
+ }
+ throw new AssertionError("unexpected execution rate");
+ } finally {
+ joinPool(p);
+ }
}
/**
diff --git a/jsr166-tests/src/test/java/jsr166/ScheduledExecutorTest.java b/jsr166-tests/src/test/java/jsr166/ScheduledExecutorTest.java
index 4eea2c9..a2e83d0 100644
--- a/jsr166-tests/src/test/java/jsr166/ScheduledExecutorTest.java
+++ b/jsr166-tests/src/test/java/jsr166/ScheduledExecutorTest.java
@@ -8,13 +8,37 @@
package jsr166;
-import junit.framework.*;
-import java.util.*;
-import java.util.concurrent.*;
import static java.util.concurrent.TimeUnit.MILLISECONDS;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.concurrent.BlockingQueue;
+import java.util.concurrent.Callable;
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.Executors;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Future;
+import java.util.concurrent.RejectedExecutionException;
+import java.util.concurrent.ScheduledFuture;
+import java.util.concurrent.ScheduledThreadPoolExecutor;
+import java.util.concurrent.ThreadFactory;
+import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.atomic.AtomicInteger;
+import junit.framework.Test;
+import junit.framework.TestSuite;
+
public class ScheduledExecutorTest extends JSR166TestCase {
+ // android-note: Removed because the CTS runner does a bad job of
+ // retrying tests that have suite() declarations.
+ //
+ // public static void main(String[] args) {
+ // main(suite(), args);
+ // }
+ // public static Test suite() {
+ // return new TestSuite(...);
+ // }
/**
* execute successfully executes a runnable
@@ -137,17 +161,27 @@
*/
public void testFixedRateSequence() throws InterruptedException {
ScheduledThreadPoolExecutor p = new ScheduledThreadPoolExecutor(1);
- RunnableCounter counter = new RunnableCounter();
- ScheduledFuture h =
- p.scheduleAtFixedRate(counter, 0, 1, MILLISECONDS);
- delay(SMALL_DELAY_MS);
- h.cancel(true);
- int c = counter.count.get();
- // By time scaling conventions, we must have at least
- // an execution per SHORT delay, but no more than one SHORT more
- assertTrue(c >= SMALL_DELAY_MS / SHORT_DELAY_MS);
- assertTrue(c <= SMALL_DELAY_MS + SHORT_DELAY_MS);
- joinPool(p);
+ try {
+ for (int delay = 1; delay <= LONG_DELAY_MS; delay *= 3) {
+ long startTime = System.nanoTime();
+ int cycles = 10;
+ final CountDownLatch done = new CountDownLatch(cycles);
+ Runnable task = new CheckedRunnable() {
+ public void realRun() { done.countDown(); }};
+ ScheduledFuture h =
+ p.scheduleAtFixedRate(task, 0, delay, MILLISECONDS);
+ done.await();
+ h.cancel(true);
+ double normalizedTime =
+ (double) millisElapsedSince(startTime) / delay;
+ if (normalizedTime >= cycles - 1 &&
+ normalizedTime <= cycles)
+ return;
+ }
+ throw new AssertionError("unexpected execution rate");
+ } finally {
+ joinPool(p);
+ }
}
/**
@@ -155,15 +189,27 @@
*/
public void testFixedDelaySequence() throws InterruptedException {
ScheduledThreadPoolExecutor p = new ScheduledThreadPoolExecutor(1);
- RunnableCounter counter = new RunnableCounter();
- ScheduledFuture h =
- p.scheduleWithFixedDelay(counter, 0, 1, MILLISECONDS);
- delay(SMALL_DELAY_MS);
- h.cancel(true);
- int c = counter.count.get();
- assertTrue(c >= SMALL_DELAY_MS / SHORT_DELAY_MS);
- assertTrue(c <= SMALL_DELAY_MS + SHORT_DELAY_MS);
- joinPool(p);
+ try {
+ for (int delay = 1; delay <= LONG_DELAY_MS; delay *= 3) {
+ long startTime = System.nanoTime();
+ int cycles = 10;
+ final CountDownLatch done = new CountDownLatch(cycles);
+ Runnable task = new CheckedRunnable() {
+ public void realRun() { done.countDown(); }};
+ ScheduledFuture h =
+ p.scheduleWithFixedDelay(task, 0, delay, MILLISECONDS);
+ done.await();
+ h.cancel(true);
+ double normalizedTime =
+ (double) millisElapsedSince(startTime) / delay;
+ if (normalizedTime >= cycles - 1 &&
+ normalizedTime <= cycles)
+ return;
+ }
+ throw new AssertionError("unexpected execution rate");
+ } finally {
+ joinPool(p);
+ }
}
/**
diff --git a/jsr166-tests/src/test/java/jsr166/SemaphoreTest.java b/jsr166-tests/src/test/java/jsr166/SemaphoreTest.java
index f303285..db4f4b4 100644
--- a/jsr166-tests/src/test/java/jsr166/SemaphoreTest.java
+++ b/jsr166-tests/src/test/java/jsr166/SemaphoreTest.java
@@ -8,14 +8,26 @@
package jsr166;
-import junit.framework.*;
-import java.util.*;
-import java.util.concurrent.CountDownLatch;
-import java.util.concurrent.Semaphore;
import static java.util.concurrent.TimeUnit.MILLISECONDS;
-public class SemaphoreTest extends JSR166TestCase {
+import java.util.Collection;
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.Semaphore;
+import junit.framework.AssertionFailedError;
+import junit.framework.Test;
+import junit.framework.TestSuite;
+
+public class SemaphoreTest extends JSR166TestCase {
+ // android-note: Removed because the CTS runner does a bad job of
+ // retrying tests that have suite() declarations.
+ //
+ // public static void main(String[] args) {
+ // main(suite(), args);
+ // }
+ // public static Test suite() {
+ // return new TestSuite(...);
+ // }
/**
* Subclass to expose protected methods
*/
@@ -608,7 +620,7 @@
assertTrue(t2.isAlive());
s.release();
awaitTermination(t2);
- }
+ }
/**
* toString indicates current number of permits
diff --git a/jsr166-tests/src/test/java/jsr166/SynchronousQueueTest.java b/jsr166-tests/src/test/java/jsr166/SynchronousQueueTest.java
index bd030cf..605a955 100644
--- a/jsr166-tests/src/test/java/jsr166/SynchronousQueueTest.java
+++ b/jsr166-tests/src/test/java/jsr166/SynchronousQueueTest.java
@@ -8,22 +8,48 @@
package jsr166;
-import junit.framework.*;
-import java.util.Arrays;
+import static java.util.concurrent.TimeUnit.MILLISECONDS;
+
import java.util.ArrayList;
+import java.util.Arrays;
import java.util.Collection;
import java.util.Iterator;
import java.util.NoSuchElementException;
-import java.util.Queue;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.Executors;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.SynchronousQueue;
-import static java.util.concurrent.TimeUnit.MILLISECONDS;
+
+import junit.framework.Test;
public class SynchronousQueueTest extends JSR166TestCase {
+ // android-note: These tests have been moved into their own separate
+ // classes to work around CTS issues.
+ //
+ // public static class Fair extends BlockingQueueTest {
+ // protected BlockingQueue emptyCollection() {
+ // return new SynchronousQueue(true);
+ // }
+ // }
+ //
+ // public static class NonFair extends BlockingQueueTest {
+ // protected BlockingQueue emptyCollection() {
+ // return new SynchronousQueue(false);
+ // }
+ // }
+ //
+ // public static void main(String[] args) {
+ // main(suite(), args);
+ // }
+ //
+ // public static Test suite() {
+ // return newTestSuite(SynchronousQueueTest.class,
+ // new Fair().testSuite(),
+ // new NonFair().testSuite());
+ // }
+
/**
* Any SynchronousQueue is both empty and full
*/
@@ -402,7 +428,7 @@
public void testToArray_null(boolean fair) {
final SynchronousQueue q = new SynchronousQueue(fair);
try {
- Object o[] = q.toArray(null);
+ Object[] o = q.toArray(null);
shouldThrow();
} catch (NullPointerException success) {}
}
@@ -413,13 +439,7 @@
public void testIterator() { testIterator(false); }
public void testIterator_fair() { testIterator(true); }
public void testIterator(boolean fair) {
- final SynchronousQueue q = new SynchronousQueue(fair);
- Iterator it = q.iterator();
- assertFalse(it.hasNext());
- try {
- Object x = it.next();
- shouldThrow();
- } catch (NoSuchElementException success) {}
+ assertIteratorExhausted(new SynchronousQueue(fair).iterator());
}
/**
@@ -586,4 +606,13 @@
awaitTermination(t2);
}
+ /**
+ * remove(null), contains(null) always return false
+ */
+ public void testNeverContainsNull() {
+ Collection<?> q = new SynchronousQueue();
+ assertFalse(q.contains(null));
+ assertFalse(q.remove(null));
+ }
+
}
diff --git a/jsr166-tests/src/test/java/jsr166/SystemTest.java b/jsr166-tests/src/test/java/jsr166/SystemTest.java
index 32caec2..6918374 100644
--- a/jsr166-tests/src/test/java/jsr166/SystemTest.java
+++ b/jsr166-tests/src/test/java/jsr166/SystemTest.java
@@ -8,9 +8,19 @@
package jsr166;
-import junit.framework.*;
+import junit.framework.Test;
+import junit.framework.TestSuite;
public class SystemTest extends JSR166TestCase {
+ // android-note: Removed because the CTS runner does a bad job of
+ // retrying tests that have suite() declarations.
+ //
+ // public static void main(String[] args) {
+ // main(suite(), args);
+ // }
+ // public static Test suite() {
+ // return new TestSuite(...);
+ // }
/**
* Worst case rounding for millisecs; set for 60 cycle millis clock.
diff --git a/jsr166-tests/src/test/java/jsr166/ThreadLocalRandomTest.java b/jsr166-tests/src/test/java/jsr166/ThreadLocalRandomTest.java
index 665a2b7..4ae141d 100644
--- a/jsr166-tests/src/test/java/jsr166/ThreadLocalRandomTest.java
+++ b/jsr166-tests/src/test/java/jsr166/ThreadLocalRandomTest.java
@@ -6,14 +6,25 @@
package jsr166;
-import junit.framework.*;
-import java.util.*;
import java.util.concurrent.ThreadLocalRandom;
import java.util.concurrent.atomic.AtomicLong;
import java.util.concurrent.atomic.AtomicReference;
+import junit.framework.Test;
+import junit.framework.TestSuite;
+
public class ThreadLocalRandomTest extends JSR166TestCase {
+ // android-note: Removed because the CTS runner does a bad job of
+ // retrying tests that have suite() declarations.
+ //
+ // public static void main(String[] args) {
+ // main(suite(), args);
+ // }
+ // public static Test suite() {
+ // return new TestSuite(...);
+ // }
+
/*
* Testing coverage notes:
*
@@ -23,15 +34,18 @@
* across multiples of primes.
*/
- //
+ // max numbers of calls to detect getting stuck on one value
static final int NCALLS = 10000;
// max sampled int bound
static final int MAX_INT_BOUND = (1 << 28);
- // Max sampled long bound
+ // max sampled long bound
static final long MAX_LONG_BOUND = (1L << 42);
+ // Number of replications for other checks
+ static final int REPS = 20;
+
/**
* setSeed throws UnsupportedOperationException
*/
@@ -43,7 +57,7 @@
}
/**
- * Repeated calls to nextInt produce at least one different result
+ * Repeated calls to nextInt produce at least two distinct results
*/
public void testNextInt() {
int f = ThreadLocalRandom.current().nextInt();
@@ -54,7 +68,7 @@
}
/**
- * Repeated calls to nextLong produce at least one different result
+ * Repeated calls to nextLong produce at least two distinct results
*/
public void testNextLong() {
long f = ThreadLocalRandom.current().nextLong();
@@ -65,7 +79,7 @@
}
/**
- * Repeated calls to nextBoolean produce at least one different result
+ * Repeated calls to nextBoolean produce at least two distinct results
*/
public void testNextBoolean() {
boolean f = ThreadLocalRandom.current().nextBoolean();
@@ -76,7 +90,7 @@
}
/**
- * Repeated calls to nextFloat produce at least one different result
+ * Repeated calls to nextFloat produce at least two distinct results
*/
public void testNextFloat() {
float f = ThreadLocalRandom.current().nextFloat();
@@ -87,18 +101,18 @@
}
/**
- * Repeated calls to nextDouble produce at least one different result
+ * Repeated calls to nextDouble produce at least two distinct results
*/
public void testNextDouble() {
double f = ThreadLocalRandom.current().nextDouble();
- double i = 0;
+ int i = 0;
while (i < NCALLS && ThreadLocalRandom.current().nextDouble() == f)
++i;
assertTrue(i < NCALLS);
}
/**
- * Repeated calls to nextGaussian produce at least one different result
+ * Repeated calls to nextGaussian produce at least two distinct results
*/
public void testNextGaussian() {
double f = ThreadLocalRandom.current().nextGaussian();
@@ -109,28 +123,39 @@
}
/**
- * nextInt(negative) throws IllegalArgumentException;
+ * nextInt(non-positive) throws IllegalArgumentException
*/
- public void testNextIntBoundedNeg() {
- try {
- int f = ThreadLocalRandom.current().nextInt(-17);
- shouldThrow();
- } catch (IllegalArgumentException success) {}
+ public void testNextIntBoundNonPositive() {
+ ThreadLocalRandom rnd = ThreadLocalRandom.current();
+ for (int bound : new int[] { 0, -17, Integer.MIN_VALUE }) {
+ try {
+ rnd.nextInt(bound);
+ shouldThrow();
+ } catch (IllegalArgumentException success) {}
+ }
}
/**
- * nextInt(least >= bound) throws IllegalArgumentException;
+ * nextInt(least >= bound) throws IllegalArgumentException
*/
public void testNextIntBadBounds() {
- try {
- int f = ThreadLocalRandom.current().nextInt(17, 2);
- shouldThrow();
- } catch (IllegalArgumentException success) {}
+ int[][] badBoundss = {
+ { 17, 2 },
+ { -42, -42 },
+ { Integer.MAX_VALUE, Integer.MIN_VALUE },
+ };
+ ThreadLocalRandom rnd = ThreadLocalRandom.current();
+ for (int[] badBounds : badBoundss) {
+ try {
+ rnd.nextInt(badBounds[0], badBounds[1]);
+ shouldThrow();
+ } catch (IllegalArgumentException success) {}
+ }
}
/**
* nextInt(bound) returns 0 <= value < bound;
- * repeated calls produce at least one different result
+ * repeated calls produce at least two distinct results
*/
public void testNextIntBounded() {
// sample bound space across prime number increments
@@ -150,7 +175,7 @@
/**
* nextInt(least, bound) returns least <= value < bound;
- * repeated calls produce at least one different result
+ * repeated calls produce at least two distinct results
*/
public void testNextIntBounded2() {
for (int least = -15485863; least < MAX_INT_BOUND; least += 524959) {
@@ -170,28 +195,39 @@
}
/**
- * nextLong(negative) throws IllegalArgumentException;
+ * nextLong(non-positive) throws IllegalArgumentException
*/
- public void testNextLongBoundedNeg() {
- try {
- long f = ThreadLocalRandom.current().nextLong(-17);
- shouldThrow();
- } catch (IllegalArgumentException success) {}
+ public void testNextLongBoundNonPositive() {
+ ThreadLocalRandom rnd = ThreadLocalRandom.current();
+ for (long bound : new long[] { 0L, -17L, Long.MIN_VALUE }) {
+ try {
+ rnd.nextLong(bound);
+ shouldThrow();
+ } catch (IllegalArgumentException success) {}
+ }
}
/**
- * nextLong(least >= bound) throws IllegalArgumentException;
+ * nextLong(least >= bound) throws IllegalArgumentException
*/
public void testNextLongBadBounds() {
- try {
- long f = ThreadLocalRandom.current().nextLong(17, 2);
- shouldThrow();
- } catch (IllegalArgumentException success) {}
+ long[][] badBoundss = {
+ { 17L, 2L },
+ { -42L, -42L },
+ { Long.MAX_VALUE, Long.MIN_VALUE },
+ };
+ ThreadLocalRandom rnd = ThreadLocalRandom.current();
+ for (long[] badBounds : badBoundss) {
+ try {
+ rnd.nextLong(badBounds[0], badBounds[1]);
+ shouldThrow();
+ } catch (IllegalArgumentException success) {}
+ }
}
/**
* nextLong(bound) returns 0 <= value < bound;
- * repeated calls produce at least one different result
+ * repeated calls produce at least two distinct results
*/
public void testNextLongBounded() {
for (long bound = 2; bound < MAX_LONG_BOUND; bound += 15485863) {
@@ -210,7 +246,7 @@
/**
* nextLong(least, bound) returns least <= value < bound;
- * repeated calls produce at least one different result
+ * repeated calls produce at least two distinct results
*/
public void testNextLongBounded2() {
for (long least = -86028121; least < MAX_LONG_BOUND; least += 982451653L) {
@@ -230,8 +266,28 @@
}
/**
+ * nextDouble(non-positive) throws IllegalArgumentException
+ */
+ public void testNextDoubleBoundNonPositive() {
+ ThreadLocalRandom rnd = ThreadLocalRandom.current();
+ double[] badBounds = {
+ 0.0d,
+ -17.0d,
+ -Double.MIN_VALUE,
+ Double.NEGATIVE_INFINITY,
+ Double.NaN,
+ };
+ for (double bound : badBounds) {
+ try {
+ rnd.nextDouble(bound);
+ shouldThrow();
+ } catch (IllegalArgumentException success) {}
+ }
+ }
+
+ /**
* nextDouble(least, bound) returns least <= value < bound;
- * repeated calls produce at least one different result
+ * repeated calls produce at least two distinct results
*/
public void testNextDoubleBounded2() {
for (double least = 0.0001; least < 1.0e20; least *= 8) {
@@ -263,7 +319,7 @@
long firstRand = 0;
ThreadLocalRandom firstThreadLocalRandom = null;
- final CheckedRunnable getRandomState = new CheckedRunnable() {
+ Runnable getRandomState = new CheckedRunnable() {
public void realRun() {
ThreadLocalRandom current = ThreadLocalRandom.current();
assertSame(current, ThreadLocalRandom.current());
diff --git a/jsr166-tests/src/test/java/jsr166/ThreadLocalTest.java b/jsr166-tests/src/test/java/jsr166/ThreadLocalTest.java
index 885c2b2..7f5f072 100644
--- a/jsr166-tests/src/test/java/jsr166/ThreadLocalTest.java
+++ b/jsr166-tests/src/test/java/jsr166/ThreadLocalTest.java
@@ -8,10 +8,19 @@
package jsr166;
-import junit.framework.*;
-import java.util.concurrent.Semaphore;
+import junit.framework.Test;
+import junit.framework.TestSuite;
public class ThreadLocalTest extends JSR166TestCase {
+ // android-note: Removed because the CTS runner does a bad job of
+ // retrying tests that have suite() declarations.
+ //
+ // public static void main(String[] args) {
+ // main(suite(), args);
+ // }
+ // public static Test suite() {
+ // return new TestSuite(...);
+ // }
static ThreadLocal<Integer> tl = new ThreadLocal<Integer>() {
public Integer initialValue() {
@@ -85,7 +94,7 @@
*/
public void testGenericITL() throws InterruptedException {
final int threadCount = 10;
- final int x[] = new int[threadCount];
+ final int[] x = new int[threadCount];
Thread progenitor = new ITLThread(x);
progenitor.start();
progenitor.join();
diff --git a/jsr166-tests/src/test/java/jsr166/ThreadPoolExecutorSubclassTest.java b/jsr166-tests/src/test/java/jsr166/ThreadPoolExecutorSubclassTest.java
index f16f422..5f38d39 100644
--- a/jsr166-tests/src/test/java/jsr166/ThreadPoolExecutorSubclassTest.java
+++ b/jsr166-tests/src/test/java/jsr166/ThreadPoolExecutorSubclassTest.java
@@ -8,14 +8,44 @@
package jsr166;
-import junit.framework.*;
-import java.util.concurrent.*;
import static java.util.concurrent.TimeUnit.MILLISECONDS;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.concurrent.ArrayBlockingQueue;
+import java.util.concurrent.BlockingQueue;
+import java.util.concurrent.Callable;
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.Executors;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Future;
+import java.util.concurrent.FutureTask;
+import java.util.concurrent.LinkedBlockingQueue;
+import java.util.concurrent.RejectedExecutionException;
+import java.util.concurrent.RejectedExecutionHandler;
+import java.util.concurrent.RunnableFuture;
+import java.util.concurrent.SynchronousQueue;
+import java.util.concurrent.ThreadFactory;
+import java.util.concurrent.ThreadPoolExecutor;
+import java.util.concurrent.TimeoutException;
+import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.ReentrantLock;
-import java.util.*;
+
+import junit.framework.Test;
+import junit.framework.TestSuite;
public class ThreadPoolExecutorSubclassTest extends JSR166TestCase {
+ // android-note: Removed because the CTS runner does a bad job of
+ // retrying tests that have suite() declarations.
+ //
+ // public static void main(String[] args) {
+ // main(suite(), args);
+ // }
+ // public static Test suite() {
+ // return new TestSuite(...);
+ // }
static class CustomTask<V> implements RunnableFuture<V> {
final Callable<V> callable;
@@ -33,7 +63,7 @@
CustomTask(final Runnable r, final V res) {
if (r == null) throw new NullPointerException();
callable = new Callable<V>() {
- public V call() throws Exception { r.run(); return res; }};
+ public V call() throws Exception { r.run(); return res; }};
}
public boolean isDone() {
lock.lock(); try { return done; } finally { lock.unlock() ; }
@@ -1244,11 +1274,10 @@
CustomTPE p = new CustomTPE();
try {
final CountDownLatch done = new CountDownLatch(1);
- final CheckedRunnable task = new CheckedRunnable() {
+ p.execute(new CheckedRunnable() {
public void realRun() {
done.countDown();
- }};
- p.execute(task);
+ }});
await(p.afterCalled);
assertEquals(0, done.getCount());
assertTrue(p.afterCalled());
diff --git a/jsr166-tests/src/test/java/jsr166/ThreadPoolExecutorTest.java b/jsr166-tests/src/test/java/jsr166/ThreadPoolExecutorTest.java
index 55f769b..52a7002 100644
--- a/jsr166-tests/src/test/java/jsr166/ThreadPoolExecutorTest.java
+++ b/jsr166-tests/src/test/java/jsr166/ThreadPoolExecutorTest.java
@@ -8,13 +8,41 @@
package jsr166;
-import junit.framework.*;
-import java.util.concurrent.*;
import static java.util.concurrent.TimeUnit.MILLISECONDS;
import static java.util.concurrent.TimeUnit.NANOSECONDS;
-import java.util.*;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.concurrent.ArrayBlockingQueue;
+import java.util.concurrent.BlockingQueue;
+import java.util.concurrent.Callable;
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.Executors;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Future;
+import java.util.concurrent.FutureTask;
+import java.util.concurrent.LinkedBlockingQueue;
+import java.util.concurrent.RejectedExecutionException;
+import java.util.concurrent.RejectedExecutionHandler;
+import java.util.concurrent.SynchronousQueue;
+import java.util.concurrent.ThreadFactory;
+import java.util.concurrent.ThreadPoolExecutor;
+import java.util.concurrent.TimeUnit;
+
+import junit.framework.Test;
+import junit.framework.TestSuite;
public class ThreadPoolExecutorTest extends JSR166TestCase {
+ // android-note: Removed because the CTS runner does a bad job of
+ // retrying tests that have suite() declarations.
+ //
+ // public static void main(String[] args) {
+ // main(suite(), args);
+ // }
+ // public static Test suite() {
+ // return new TestSuite(...);
+ // }
static class ExtendedTPE extends ThreadPoolExecutor {
final CountDownLatch beforeCalled = new CountDownLatch(1);
@@ -1371,11 +1399,10 @@
ExtendedTPE p = new ExtendedTPE();
try {
final CountDownLatch done = new CountDownLatch(1);
- final CheckedRunnable task = new CheckedRunnable() {
+ p.execute(new CheckedRunnable() {
public void realRun() {
done.countDown();
- }};
- p.execute(task);
+ }});
await(p.afterCalled);
assertEquals(0, done.getCount());
assertTrue(p.afterCalled());
diff --git a/jsr166-tests/src/test/java/jsr166/ThreadTest.java b/jsr166-tests/src/test/java/jsr166/ThreadTest.java
index 12c2f8a..2652201 100644
--- a/jsr166-tests/src/test/java/jsr166/ThreadTest.java
+++ b/jsr166-tests/src/test/java/jsr166/ThreadTest.java
@@ -8,9 +8,19 @@
package jsr166;
-import junit.framework.*;
+import junit.framework.Test;
+import junit.framework.TestSuite;
public class ThreadTest extends JSR166TestCase {
+ // android-note: Removed because the CTS runner does a bad job of
+ // retrying tests that have suite() declarations.
+ //
+ // public static void main(String[] args) {
+ // main(suite(), args);
+ // }
+ // public static Test suite() {
+ // return new TestSuite(...);
+ // }
static class MyHandler implements Thread.UncaughtExceptionHandler {
public void uncaughtException(Thread t, Throwable e) {
@@ -28,11 +38,14 @@
Thread current = Thread.currentThread();
ThreadGroup tg = current.getThreadGroup();
MyHandler eh = new MyHandler();
- assertEquals(tg, current.getUncaughtExceptionHandler());
+ assertSame(tg, current.getUncaughtExceptionHandler());
current.setUncaughtExceptionHandler(eh);
- assertEquals(eh, current.getUncaughtExceptionHandler());
- current.setUncaughtExceptionHandler(null);
- assertEquals(tg, current.getUncaughtExceptionHandler());
+ try {
+ assertSame(eh, current.getUncaughtExceptionHandler());
+ } finally {
+ current.setUncaughtExceptionHandler(null);
+ }
+ assertSame(tg, current.getUncaughtExceptionHandler());
}
/**
@@ -40,24 +53,23 @@
* setDefaultUncaughtExceptionHandler.
*/
public void testGetAndSetDefaultUncaughtExceptionHandler() {
- // BEGIN android-remove (when running as cts the RuntimeInit will
- // set a default handler)
- // assertEquals(null, Thread.getDefaultUncaughtExceptionHandler());
- // END android-remove
-
+ assertEquals(null, Thread.getDefaultUncaughtExceptionHandler());
// failure due to securityException is OK.
// Would be nice to explicitly test both ways, but cannot yet.
+ Thread.UncaughtExceptionHandler defaultHandler
+ = Thread.getDefaultUncaughtExceptionHandler();
+ MyHandler eh = new MyHandler();
try {
- Thread current = Thread.currentThread();
- ThreadGroup tg = current.getThreadGroup();
- MyHandler eh = new MyHandler();
Thread.setDefaultUncaughtExceptionHandler(eh);
- assertEquals(eh, Thread.getDefaultUncaughtExceptionHandler());
- Thread.setDefaultUncaughtExceptionHandler(null);
+ try {
+ assertSame(eh, Thread.getDefaultUncaughtExceptionHandler());
+ } finally {
+ Thread.setDefaultUncaughtExceptionHandler(defaultHandler);
+ }
+ } catch (SecurityException ok) {
+ assertNotNull(System.getSecurityManager());
}
- catch (SecurityException ok) {
- }
- assertEquals(null, Thread.getDefaultUncaughtExceptionHandler());
+ assertSame(defaultHandler, Thread.getDefaultUncaughtExceptionHandler());
}
// How to test actually using UEH within junit?
diff --git a/jsr166-tests/src/test/java/jsr166/TimeUnitTest.java b/jsr166-tests/src/test/java/jsr166/TimeUnitTest.java
index 7fa9e1a..2c9529b 100644
--- a/jsr166-tests/src/test/java/jsr166/TimeUnitTest.java
+++ b/jsr166-tests/src/test/java/jsr166/TimeUnitTest.java
@@ -8,11 +8,30 @@
package jsr166;
-import junit.framework.*;
+import static java.util.concurrent.TimeUnit.DAYS;
+import static java.util.concurrent.TimeUnit.HOURS;
+import static java.util.concurrent.TimeUnit.MICROSECONDS;
+import static java.util.concurrent.TimeUnit.MILLISECONDS;
+import static java.util.concurrent.TimeUnit.MINUTES;
+import static java.util.concurrent.TimeUnit.NANOSECONDS;
+import static java.util.concurrent.TimeUnit.SECONDS;
+
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.TimeUnit;
+import junit.framework.Test;
+import junit.framework.TestSuite;
+
public class TimeUnitTest extends JSR166TestCase {
+ // android-note: Removed because the CTS runner does a bad job of
+ // retrying tests that have suite() declarations.
+ //
+ // public static void main(String[] args) {
+ // main(suite(), args);
+ // }
+ // public static Test suite() {
+ // return new TestSuite(...);
+ // }
// (loops to 88888 check increments at all time divisions.)
@@ -22,92 +41,64 @@
public void testConvert() {
for (long t = 0; t < 88888; ++t) {
assertEquals(t*60*60*24,
- TimeUnit.SECONDS.convert(t,
- TimeUnit.DAYS));
+ SECONDS.convert(t, DAYS));
assertEquals(t*60*60,
- TimeUnit.SECONDS.convert(t,
- TimeUnit.HOURS));
+ SECONDS.convert(t, HOURS));
assertEquals(t*60,
- TimeUnit.SECONDS.convert(t,
- TimeUnit.MINUTES));
+ SECONDS.convert(t, MINUTES));
assertEquals(t,
- TimeUnit.SECONDS.convert(t,
- TimeUnit.SECONDS));
+ SECONDS.convert(t, SECONDS));
assertEquals(t,
- TimeUnit.SECONDS.convert(1000L*t,
- TimeUnit.MILLISECONDS));
+ SECONDS.convert(1000L*t, MILLISECONDS));
assertEquals(t,
- TimeUnit.SECONDS.convert(1000000L*t,
- TimeUnit.MICROSECONDS));
+ SECONDS.convert(1000000L*t, MICROSECONDS));
assertEquals(t,
- TimeUnit.SECONDS.convert(1000000000L*t,
- TimeUnit.NANOSECONDS));
+ SECONDS.convert(1000000000L*t, NANOSECONDS));
assertEquals(1000L*t*60*60*24,
- TimeUnit.MILLISECONDS.convert(t,
- TimeUnit.DAYS));
+ MILLISECONDS.convert(t, DAYS));
assertEquals(1000L*t*60*60,
- TimeUnit.MILLISECONDS.convert(t,
- TimeUnit.HOURS));
+ MILLISECONDS.convert(t, HOURS));
assertEquals(1000L*t*60,
- TimeUnit.MILLISECONDS.convert(t,
- TimeUnit.MINUTES));
+ MILLISECONDS.convert(t, MINUTES));
assertEquals(1000L*t,
- TimeUnit.MILLISECONDS.convert(t,
- TimeUnit.SECONDS));
+ MILLISECONDS.convert(t, SECONDS));
assertEquals(t,
- TimeUnit.MILLISECONDS.convert(t,
- TimeUnit.MILLISECONDS));
+ MILLISECONDS.convert(t, MILLISECONDS));
assertEquals(t,
- TimeUnit.MILLISECONDS.convert(1000L*t,
- TimeUnit.MICROSECONDS));
+ MILLISECONDS.convert(1000L*t, MICROSECONDS));
assertEquals(t,
- TimeUnit.MILLISECONDS.convert(1000000L*t,
- TimeUnit.NANOSECONDS));
+ MILLISECONDS.convert(1000000L*t, NANOSECONDS));
assertEquals(1000000L*t*60*60*24,
- TimeUnit.MICROSECONDS.convert(t,
- TimeUnit.DAYS));
+ MICROSECONDS.convert(t, DAYS));
assertEquals(1000000L*t*60*60,
- TimeUnit.MICROSECONDS.convert(t,
- TimeUnit.HOURS));
+ MICROSECONDS.convert(t, HOURS));
assertEquals(1000000L*t*60,
- TimeUnit.MICROSECONDS.convert(t,
- TimeUnit.MINUTES));
+ MICROSECONDS.convert(t, MINUTES));
assertEquals(1000000L*t,
- TimeUnit.MICROSECONDS.convert(t,
- TimeUnit.SECONDS));
+ MICROSECONDS.convert(t, SECONDS));
assertEquals(1000L*t,
- TimeUnit.MICROSECONDS.convert(t,
- TimeUnit.MILLISECONDS));
+ MICROSECONDS.convert(t, MILLISECONDS));
assertEquals(t,
- TimeUnit.MICROSECONDS.convert(t,
- TimeUnit.MICROSECONDS));
+ MICROSECONDS.convert(t, MICROSECONDS));
assertEquals(t,
- TimeUnit.MICROSECONDS.convert(1000L*t,
- TimeUnit.NANOSECONDS));
+ MICROSECONDS.convert(1000L*t, NANOSECONDS));
assertEquals(1000000000L*t*60*60*24,
- TimeUnit.NANOSECONDS.convert(t,
- TimeUnit.DAYS));
+ NANOSECONDS.convert(t, DAYS));
assertEquals(1000000000L*t*60*60,
- TimeUnit.NANOSECONDS.convert(t,
- TimeUnit.HOURS));
+ NANOSECONDS.convert(t, HOURS));
assertEquals(1000000000L*t*60,
- TimeUnit.NANOSECONDS.convert(t,
- TimeUnit.MINUTES));
+ NANOSECONDS.convert(t, MINUTES));
assertEquals(1000000000L*t,
- TimeUnit.NANOSECONDS.convert(t,
- TimeUnit.SECONDS));
+ NANOSECONDS.convert(t, SECONDS));
assertEquals(1000000L*t,
- TimeUnit.NANOSECONDS.convert(t,
- TimeUnit.MILLISECONDS));
+ NANOSECONDS.convert(t, MILLISECONDS));
assertEquals(1000L*t,
- TimeUnit.NANOSECONDS.convert(t,
- TimeUnit.MICROSECONDS));
+ NANOSECONDS.convert(t, MICROSECONDS));
assertEquals(t,
- TimeUnit.NANOSECONDS.convert(t,
- TimeUnit.NANOSECONDS));
+ NANOSECONDS.convert(t, NANOSECONDS));
}
}
@@ -118,19 +109,19 @@
public void testToNanos() {
for (long t = 0; t < 88888; ++t) {
assertEquals(t*1000000000L*60*60*24,
- TimeUnit.DAYS.toNanos(t));
+ DAYS.toNanos(t));
assertEquals(t*1000000000L*60*60,
- TimeUnit.HOURS.toNanos(t));
+ HOURS.toNanos(t));
assertEquals(t*1000000000L*60,
- TimeUnit.MINUTES.toNanos(t));
+ MINUTES.toNanos(t));
assertEquals(1000000000L*t,
- TimeUnit.SECONDS.toNanos(t));
+ SECONDS.toNanos(t));
assertEquals(1000000L*t,
- TimeUnit.MILLISECONDS.toNanos(t));
+ MILLISECONDS.toNanos(t));
assertEquals(1000L*t,
- TimeUnit.MICROSECONDS.toNanos(t));
+ MICROSECONDS.toNanos(t));
assertEquals(t,
- TimeUnit.NANOSECONDS.toNanos(t));
+ NANOSECONDS.toNanos(t));
}
}
@@ -141,19 +132,19 @@
public void testToMicros() {
for (long t = 0; t < 88888; ++t) {
assertEquals(t*1000000L*60*60*24,
- TimeUnit.DAYS.toMicros(t));
+ DAYS.toMicros(t));
assertEquals(t*1000000L*60*60,
- TimeUnit.HOURS.toMicros(t));
+ HOURS.toMicros(t));
assertEquals(t*1000000L*60,
- TimeUnit.MINUTES.toMicros(t));
+ MINUTES.toMicros(t));
assertEquals(1000000L*t,
- TimeUnit.SECONDS.toMicros(t));
+ SECONDS.toMicros(t));
assertEquals(1000L*t,
- TimeUnit.MILLISECONDS.toMicros(t));
+ MILLISECONDS.toMicros(t));
assertEquals(t,
- TimeUnit.MICROSECONDS.toMicros(t));
+ MICROSECONDS.toMicros(t));
assertEquals(t,
- TimeUnit.NANOSECONDS.toMicros(t*1000L));
+ NANOSECONDS.toMicros(t*1000L));
}
}
@@ -164,19 +155,19 @@
public void testToMillis() {
for (long t = 0; t < 88888; ++t) {
assertEquals(t*1000L*60*60*24,
- TimeUnit.DAYS.toMillis(t));
+ DAYS.toMillis(t));
assertEquals(t*1000L*60*60,
- TimeUnit.HOURS.toMillis(t));
+ HOURS.toMillis(t));
assertEquals(t*1000L*60,
- TimeUnit.MINUTES.toMillis(t));
+ MINUTES.toMillis(t));
assertEquals(1000L*t,
- TimeUnit.SECONDS.toMillis(t));
+ SECONDS.toMillis(t));
assertEquals(t,
- TimeUnit.MILLISECONDS.toMillis(t));
+ MILLISECONDS.toMillis(t));
assertEquals(t,
- TimeUnit.MICROSECONDS.toMillis(t*1000L));
+ MICROSECONDS.toMillis(t*1000L));
assertEquals(t,
- TimeUnit.NANOSECONDS.toMillis(t*1000000L));
+ NANOSECONDS.toMillis(t*1000000L));
}
}
@@ -187,19 +178,19 @@
public void testToSeconds() {
for (long t = 0; t < 88888; ++t) {
assertEquals(t*60*60*24,
- TimeUnit.DAYS.toSeconds(t));
+ DAYS.toSeconds(t));
assertEquals(t*60*60,
- TimeUnit.HOURS.toSeconds(t));
+ HOURS.toSeconds(t));
assertEquals(t*60,
- TimeUnit.MINUTES.toSeconds(t));
+ MINUTES.toSeconds(t));
assertEquals(t,
- TimeUnit.SECONDS.toSeconds(t));
+ SECONDS.toSeconds(t));
assertEquals(t,
- TimeUnit.MILLISECONDS.toSeconds(t*1000L));
+ MILLISECONDS.toSeconds(t*1000L));
assertEquals(t,
- TimeUnit.MICROSECONDS.toSeconds(t*1000000L));
+ MICROSECONDS.toSeconds(t*1000000L));
assertEquals(t,
- TimeUnit.NANOSECONDS.toSeconds(t*1000000000L));
+ NANOSECONDS.toSeconds(t*1000000000L));
}
}
@@ -210,19 +201,19 @@
public void testToMinutes() {
for (long t = 0; t < 88888; ++t) {
assertEquals(t*60*24,
- TimeUnit.DAYS.toMinutes(t));
+ DAYS.toMinutes(t));
assertEquals(t*60,
- TimeUnit.HOURS.toMinutes(t));
+ HOURS.toMinutes(t));
assertEquals(t,
- TimeUnit.MINUTES.toMinutes(t));
+ MINUTES.toMinutes(t));
assertEquals(t,
- TimeUnit.SECONDS.toMinutes(t*60));
+ SECONDS.toMinutes(t*60));
assertEquals(t,
- TimeUnit.MILLISECONDS.toMinutes(t*1000L*60));
+ MILLISECONDS.toMinutes(t*1000L*60));
assertEquals(t,
- TimeUnit.MICROSECONDS.toMinutes(t*1000000L*60));
+ MICROSECONDS.toMinutes(t*1000000L*60));
assertEquals(t,
- TimeUnit.NANOSECONDS.toMinutes(t*1000000000L*60));
+ NANOSECONDS.toMinutes(t*1000000000L*60));
}
}
@@ -233,19 +224,19 @@
public void testToHours() {
for (long t = 0; t < 88888; ++t) {
assertEquals(t*24,
- TimeUnit.DAYS.toHours(t));
+ DAYS.toHours(t));
assertEquals(t,
- TimeUnit.HOURS.toHours(t));
+ HOURS.toHours(t));
assertEquals(t,
- TimeUnit.MINUTES.toHours(t*60));
+ MINUTES.toHours(t*60));
assertEquals(t,
- TimeUnit.SECONDS.toHours(t*60*60));
+ SECONDS.toHours(t*60*60));
assertEquals(t,
- TimeUnit.MILLISECONDS.toHours(t*1000L*60*60));
+ MILLISECONDS.toHours(t*1000L*60*60));
assertEquals(t,
- TimeUnit.MICROSECONDS.toHours(t*1000000L*60*60));
+ MICROSECONDS.toHours(t*1000000L*60*60));
assertEquals(t,
- TimeUnit.NANOSECONDS.toHours(t*1000000000L*60*60));
+ NANOSECONDS.toHours(t*1000000000L*60*60));
}
}
@@ -256,19 +247,19 @@
public void testToDays() {
for (long t = 0; t < 88888; ++t) {
assertEquals(t,
- TimeUnit.DAYS.toDays(t));
+ DAYS.toDays(t));
assertEquals(t,
- TimeUnit.HOURS.toDays(t*24));
+ HOURS.toDays(t*24));
assertEquals(t,
- TimeUnit.MINUTES.toDays(t*60*24));
+ MINUTES.toDays(t*60*24));
assertEquals(t,
- TimeUnit.SECONDS.toDays(t*60*60*24));
+ SECONDS.toDays(t*60*60*24));
assertEquals(t,
- TimeUnit.MILLISECONDS.toDays(t*1000L*60*60*24));
+ MILLISECONDS.toDays(t*1000L*60*60*24));
assertEquals(t,
- TimeUnit.MICROSECONDS.toDays(t*1000000L*60*60*24));
+ MICROSECONDS.toDays(t*1000000L*60*60*24));
assertEquals(t,
- TimeUnit.NANOSECONDS.toDays(t*1000000000L*60*60*24));
+ NANOSECONDS.toDays(t*1000000000L*60*60*24));
}
}
@@ -278,29 +269,21 @@
*/
public void testConvertSaturate() {
assertEquals(Long.MAX_VALUE,
- TimeUnit.NANOSECONDS.convert(Long.MAX_VALUE / 2,
- TimeUnit.SECONDS));
+ NANOSECONDS.convert(Long.MAX_VALUE / 2, SECONDS));
assertEquals(Long.MIN_VALUE,
- TimeUnit.NANOSECONDS.convert(-Long.MAX_VALUE / 4,
- TimeUnit.SECONDS));
+ NANOSECONDS.convert(-Long.MAX_VALUE / 4, SECONDS));
assertEquals(Long.MAX_VALUE,
- TimeUnit.NANOSECONDS.convert(Long.MAX_VALUE / 2,
- TimeUnit.MINUTES));
+ NANOSECONDS.convert(Long.MAX_VALUE / 2, MINUTES));
assertEquals(Long.MIN_VALUE,
- TimeUnit.NANOSECONDS.convert(-Long.MAX_VALUE / 4,
- TimeUnit.MINUTES));
+ NANOSECONDS.convert(-Long.MAX_VALUE / 4, MINUTES));
assertEquals(Long.MAX_VALUE,
- TimeUnit.NANOSECONDS.convert(Long.MAX_VALUE / 2,
- TimeUnit.HOURS));
+ NANOSECONDS.convert(Long.MAX_VALUE / 2, HOURS));
assertEquals(Long.MIN_VALUE,
- TimeUnit.NANOSECONDS.convert(-Long.MAX_VALUE / 4,
- TimeUnit.HOURS));
+ NANOSECONDS.convert(-Long.MAX_VALUE / 4, HOURS));
assertEquals(Long.MAX_VALUE,
- TimeUnit.NANOSECONDS.convert(Long.MAX_VALUE / 2,
- TimeUnit.DAYS));
+ NANOSECONDS.convert(Long.MAX_VALUE / 2, DAYS));
assertEquals(Long.MIN_VALUE,
- TimeUnit.NANOSECONDS.convert(-Long.MAX_VALUE / 4,
- TimeUnit.DAYS));
+ NANOSECONDS.convert(-Long.MAX_VALUE / 4, DAYS));
}
/**
@@ -309,23 +292,23 @@
*/
public void testToNanosSaturate() {
assertEquals(Long.MAX_VALUE,
- TimeUnit.MILLISECONDS.toNanos(Long.MAX_VALUE / 2));
+ MILLISECONDS.toNanos(Long.MAX_VALUE / 2));
assertEquals(Long.MIN_VALUE,
- TimeUnit.MILLISECONDS.toNanos(-Long.MAX_VALUE / 3));
+ MILLISECONDS.toNanos(-Long.MAX_VALUE / 3));
}
/**
* toString returns name of unit
*/
public void testToString() {
- assertEquals("SECONDS", TimeUnit.SECONDS.toString());
+ assertEquals("SECONDS", SECONDS.toString());
}
/**
* name returns name of unit
*/
public void testName() {
- assertEquals("SECONDS", TimeUnit.SECONDS.name());
+ assertEquals("SECONDS", SECONDS.name());
}
/**
@@ -336,7 +319,7 @@
Thread t = newStartedThread(new CheckedRunnable() {
public void realRun() throws InterruptedException {
Object o = new Object();
- TimeUnit tu = TimeUnit.MILLISECONDS;
+ TimeUnit tu = MILLISECONDS;
try {
tu.timedWait(o, LONG_DELAY_MS);
@@ -355,7 +338,7 @@
Thread t = newStartedThread(new CheckedRunnable() {
public void realRun() throws InterruptedException {
Object o = new Object();
- TimeUnit tu = TimeUnit.MILLISECONDS;
+ TimeUnit tu = MILLISECONDS;
Thread.currentThread().interrupt();
try {
@@ -393,7 +376,7 @@
}});
final Thread t = newStartedThread(new CheckedRunnable() {
public void realRun() throws InterruptedException {
- TimeUnit tu = TimeUnit.MILLISECONDS;
+ TimeUnit tu = MILLISECONDS;
Thread.currentThread().interrupt();
try {
tu.timedJoin(s, LONG_DELAY_MS);
@@ -424,7 +407,7 @@
final CountDownLatch pleaseInterrupt = new CountDownLatch(1);
Thread t = newStartedThread(new CheckedRunnable() {
public void realRun() throws InterruptedException {
- TimeUnit tu = TimeUnit.MILLISECONDS;
+ TimeUnit tu = MILLISECONDS;
Thread.currentThread().interrupt();
try {
tu.sleep(LONG_DELAY_MS);
@@ -450,7 +433,7 @@
* a deserialized serialized unit is the same instance
*/
public void testSerialization() throws Exception {
- TimeUnit x = TimeUnit.MILLISECONDS;
+ TimeUnit x = MILLISECONDS;
assertSame(x, serialClone(x));
}
diff --git a/jsr166-tests/src/test/java/jsr166/TreeMapTest.java b/jsr166-tests/src/test/java/jsr166/TreeMapTest.java
index 87baa1a..afc73de 100644
--- a/jsr166-tests/src/test/java/jsr166/TreeMapTest.java
+++ b/jsr166-tests/src/test/java/jsr166/TreeMapTest.java
@@ -6,10 +6,31 @@
package jsr166;
-import junit.framework.*;
-import java.util.*;
+import java.util.Arrays;
+import java.util.BitSet;
+import java.util.Collection;
+import java.util.Iterator;
+import java.util.Map;
+import java.util.NavigableMap;
+import java.util.NavigableSet;
+import java.util.NoSuchElementException;
+import java.util.Random;
+import java.util.Set;
+import java.util.TreeMap;
+
+import junit.framework.Test;
+import junit.framework.TestSuite;
public class TreeMapTest extends JSR166TestCase {
+ // android-note: Removed because the CTS runner does a bad job of
+ // retrying tests that have suite() declarations.
+ //
+ // public static void main(String[] args) {
+ // main(suite(), args);
+ // }
+ // public static Test suite() {
+ // return new TestSuite(...);
+ // }
/**
* Returns a new map from Integers 1-5 to Strings "A"-"E".
@@ -559,8 +580,8 @@
* get(null) of nonempty map throws NPE
*/
public void testGet_NullPointerException() {
+ TreeMap c = map5();
try {
- TreeMap c = map5();
c.get(null);
shouldThrow();
} catch (NullPointerException success) {}
@@ -570,8 +591,8 @@
* containsKey(null) of nonempty map throws NPE
*/
public void testContainsKey_NullPointerException() {
+ TreeMap c = map5();
try {
- TreeMap c = map5();
c.containsKey(null);
shouldThrow();
} catch (NullPointerException success) {}
@@ -581,9 +602,9 @@
* remove(null) throws NPE for nonempty map
*/
public void testRemove1_NullPointerException() {
+ TreeMap c = new TreeMap();
+ c.put("sadsdf", "asdads");
try {
- TreeMap c = new TreeMap();
- c.put("sadsdf", "asdads");
c.remove(null);
shouldThrow();
} catch (NullPointerException success) {}
@@ -819,7 +840,7 @@
// Add entries till we're back to original size
while (map.size() < size) {
int key = min + rnd.nextInt(rangeSize);
- assertTrue(key >= min && key<= max);
+ assertTrue(key >= min && key <= max);
put(map, key);
}
}
@@ -844,7 +865,7 @@
// Add entries till we're back to original size
while (map.size() < size) {
int key = min - 5 + rnd.nextInt(rangeSize + 10);
- if (key >= min && key<= max) {
+ if (key >= min && key <= max) {
put(map, key);
} else {
try {
diff --git a/jsr166-tests/src/test/java/jsr166/TreeSetTest.java b/jsr166-tests/src/test/java/jsr166/TreeSetTest.java
index 2957019..a935637 100644
--- a/jsr166-tests/src/test/java/jsr166/TreeSetTest.java
+++ b/jsr166-tests/src/test/java/jsr166/TreeSetTest.java
@@ -6,7 +6,6 @@
package jsr166;
-import junit.framework.*;
import java.util.Arrays;
import java.util.BitSet;
import java.util.Collection;
@@ -19,7 +18,19 @@
import java.util.SortedSet;
import java.util.TreeSet;
+import junit.framework.Test;
+import junit.framework.TestSuite;
+
public class TreeSetTest extends JSR166TestCase {
+ // android-note: Removed because the CTS runner does a bad job of
+ // retrying tests that have suite() declarations.
+ //
+ // public static void main(String[] args) {
+ // main(suite(), args);
+ // }
+ // public static Test suite() {
+ // return new TestSuite(...);
+ // }
static class MyReverseComparator implements Comparator {
public int compare(Object x, Object y) {
@@ -39,9 +50,9 @@
private TreeSet<Integer> populatedSet(int n) {
TreeSet<Integer> q = new TreeSet<Integer>();
assertTrue(q.isEmpty());
- for (int i = n-1; i >= 0; i-=2)
+ for (int i = n-1; i >= 0; i -= 2)
assertTrue(q.add(new Integer(i)));
- for (int i = (n & 1); i < n; i+=2)
+ for (int i = (n & 1); i < n; i += 2)
assertTrue(q.add(new Integer(i)));
assertFalse(q.isEmpty());
assertEquals(n, q.size());
@@ -75,7 +86,7 @@
*/
public void testConstructor3() {
try {
- TreeSet q = new TreeSet((Collection)null);
+ new TreeSet((Collection)null);
shouldThrow();
} catch (NullPointerException success) {}
}
@@ -86,7 +97,7 @@
public void testConstructor4() {
try {
Integer[] ints = new Integer[SIZE];
- TreeSet q = new TreeSet(Arrays.asList(ints));
+ new TreeSet(Arrays.asList(ints));
shouldThrow();
} catch (NullPointerException success) {}
}
@@ -99,7 +110,7 @@
Integer[] ints = new Integer[SIZE];
for (int i = 0; i < SIZE-1; ++i)
ints[i] = new Integer(i);
- TreeSet q = new TreeSet(Arrays.asList(ints));
+ new TreeSet(Arrays.asList(ints));
shouldThrow();
} catch (NullPointerException success) {}
}
@@ -164,8 +175,8 @@
* add(null) throws NPE if nonempty
*/
public void testAddNull() {
+ TreeSet q = populatedSet(SIZE);
try {
- TreeSet q = populatedSet(SIZE);
q.add(null);
shouldThrow();
} catch (NullPointerException success) {}
@@ -193,9 +204,8 @@
* Add of non-Comparable throws CCE
*/
public void testAddNonComparable() {
+ TreeSet q = new TreeSet();
try {
- TreeSet q = new TreeSet();
- q.add(new Object());
q.add(new Object());
q.add(new Object());
shouldThrow();
@@ -206,8 +216,8 @@
* addAll(null) throws NPE
*/
public void testAddAll1() {
+ TreeSet q = new TreeSet();
try {
- TreeSet q = new TreeSet();
q.addAll(null);
shouldThrow();
} catch (NullPointerException success) {}
@@ -217,9 +227,9 @@
* addAll of a collection with null elements throws NPE
*/
public void testAddAll2() {
+ TreeSet q = new TreeSet();
+ Integer[] ints = new Integer[SIZE];
try {
- TreeSet q = new TreeSet();
- Integer[] ints = new Integer[SIZE];
q.addAll(Arrays.asList(ints));
shouldThrow();
} catch (NullPointerException success) {}
@@ -230,11 +240,11 @@
* possibly adding some elements
*/
public void testAddAll3() {
+ TreeSet q = new TreeSet();
+ Integer[] ints = new Integer[SIZE];
+ for (int i = 0; i < SIZE-1; ++i)
+ ints[i] = new Integer(i);
try {
- TreeSet q = new TreeSet();
- Integer[] ints = new Integer[SIZE];
- for (int i = 0; i < SIZE-1; ++i)
- ints[i] = new Integer(i);
q.addAll(Arrays.asList(ints));
shouldThrow();
} catch (NullPointerException success) {}
@@ -282,13 +292,13 @@
*/
public void testRemoveElement() {
TreeSet q = populatedSet(SIZE);
- for (int i = 1; i < SIZE; i+=2) {
+ for (int i = 1; i < SIZE; i += 2) {
assertTrue(q.contains(i));
assertTrue(q.remove(i));
assertFalse(q.contains(i));
assertTrue(q.contains(i-1));
}
- for (int i = 0; i < SIZE; i+=2) {
+ for (int i = 0; i < SIZE; i += 2) {
assertTrue(q.contains(i));
assertTrue(q.remove(i));
assertFalse(q.contains(i));
@@ -367,8 +377,8 @@
assertTrue(q.removeAll(p));
assertEquals(SIZE-i, q.size());
for (int j = 0; j < i; ++j) {
- Integer I = (Integer)(p.pollFirst());
- assertFalse(q.contains(I));
+ Integer x = (Integer)(p.pollFirst());
+ assertFalse(q.contains(x));
}
}
}
@@ -472,27 +482,19 @@
*/
public void testIterator() {
TreeSet q = populatedSet(SIZE);
- int i = 0;
Iterator it = q.iterator();
- while (it.hasNext()) {
+ int i;
+ for (i = 0; it.hasNext(); i++)
assertTrue(q.contains(it.next()));
- ++i;
- }
assertEquals(i, SIZE);
+ assertIteratorExhausted(it);
}
/**
* iterator of empty set has no elements
*/
public void testEmptyIterator() {
- TreeSet q = new TreeSet();
- int i = 0;
- Iterator it = q.iterator();
- while (it.hasNext()) {
- assertTrue(q.contains(it.next()));
- ++i;
- }
- assertEquals(0, i);
+ assertIteratorExhausted(new TreeSet().iterator());
}
/**
@@ -732,7 +734,7 @@
// Add entries till we're back to original size
while (set.size() < size) {
int element = min + rnd.nextInt(rangeSize);
- assertTrue(element >= min && element<= max);
+ assertTrue(element >= min && element <= max);
put(set, element);
}
}
@@ -757,7 +759,7 @@
// Add entries till we're back to original size
while (set.size() < size) {
int element = min - 5 + rnd.nextInt(rangeSize + 10);
- if (element >= min && element<= max) {
+ if (element >= min && element <= max) {
put(set, element);
} else {
try {
diff --git a/jsr166-tests/src/test/java/jsr166/TreeSubMapTest.java b/jsr166-tests/src/test/java/jsr166/TreeSubMapTest.java
index 17201f3..18a9e37 100644
--- a/jsr166-tests/src/test/java/jsr166/TreeSubMapTest.java
+++ b/jsr166-tests/src/test/java/jsr166/TreeSubMapTest.java
@@ -6,10 +6,29 @@
package jsr166;
-import junit.framework.*;
-import java.util.*;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.Iterator;
+import java.util.Map;
+import java.util.NavigableMap;
+import java.util.Set;
+import java.util.SortedMap;
+import java.util.TreeMap;
+
+import junit.framework.Test;
+import junit.framework.TestSuite;
public class TreeSubMapTest extends JSR166TestCase {
+ // android-note: Removed because the CTS runner does a bad job of
+ // retrying tests that have suite() declarations.
+ //
+ // public static void main(String[] args) {
+ // main(suite(), args);
+ // }
+ // public static Test suite() {
+ // return new TestSuite(...);
+ // }
/**
* Returns a new map from Integers 1-5 to Strings "A"-"E".
@@ -378,8 +397,8 @@
* get(null) of nonempty map throws NPE
*/
public void testGet_NullPointerException() {
+ NavigableMap c = map5();
try {
- NavigableMap c = map5();
c.get(null);
shouldThrow();
} catch (NullPointerException success) {}
@@ -389,8 +408,8 @@
* containsKey(null) of nonempty map throws NPE
*/
public void testContainsKey_NullPointerException() {
+ NavigableMap c = map5();
try {
- NavigableMap c = map5();
c.containsKey(null);
shouldThrow();
} catch (NullPointerException success) {}
@@ -400,8 +419,8 @@
* put(null,x) throws NPE
*/
public void testPut1_NullPointerException() {
+ NavigableMap c = map5();
try {
- NavigableMap c = map5();
c.put(null, "whatever");
shouldThrow();
} catch (NullPointerException success) {}
@@ -411,8 +430,8 @@
* remove(null) throws NPE
*/
public void testRemove1_NullPointerException() {
+ NavigableMap c = map5();
try {
- NavigableMap c = map5();
c.remove(null);
shouldThrow();
} catch (NullPointerException success) {}
@@ -927,8 +946,8 @@
* get(null) of nonempty map throws NPE
*/
public void testDescendingGet_NullPointerException() {
+ NavigableMap c = dmap5();
try {
- NavigableMap c = dmap5();
c.get(null);
shouldThrow();
} catch (NullPointerException success) {}
@@ -938,8 +957,8 @@
* put(null,x) throws NPE
*/
public void testDescendingPut1_NullPointerException() {
+ NavigableMap c = dmap5();
try {
- NavigableMap c = dmap5();
c.put(null, "whatever");
shouldThrow();
} catch (NullPointerException success) {}
diff --git a/jsr166-tests/src/test/java/jsr166/TreeSubSetTest.java b/jsr166-tests/src/test/java/jsr166/TreeSubSetTest.java
index ba61748..5398c4e 100644
--- a/jsr166-tests/src/test/java/jsr166/TreeSubSetTest.java
+++ b/jsr166-tests/src/test/java/jsr166/TreeSubSetTest.java
@@ -6,16 +6,27 @@
package jsr166;
-import junit.framework.*;
import java.util.Arrays;
import java.util.Comparator;
import java.util.Iterator;
import java.util.NavigableSet;
-import java.util.SortedSet;
import java.util.Set;
+import java.util.SortedSet;
import java.util.TreeSet;
+import junit.framework.Test;
+import junit.framework.TestSuite;
+
public class TreeSubSetTest extends JSR166TestCase {
+ // android-note: Removed because the CTS runner does a bad job of
+ // retrying tests that have suite() declarations.
+ //
+ // public static void main(String[] args) {
+ // main(suite(), args);
+ // }
+ // public static Test suite() {
+ // return new TestSuite(...);
+ // }
static class MyReverseComparator implements Comparator {
public int compare(Object x, Object y) {
@@ -31,9 +42,9 @@
TreeSet<Integer> q = new TreeSet<Integer>();
assertTrue(q.isEmpty());
- for (int i = n-1; i >= 0; i-=2)
+ for (int i = n-1; i >= 0; i -= 2)
assertTrue(q.add(new Integer(i)));
- for (int i = (n & 1); i < n; i+=2)
+ for (int i = (n & 1); i < n; i += 2)
assertTrue(q.add(new Integer(i)));
assertTrue(q.add(new Integer(-n)));
assertTrue(q.add(new Integer(n)));
@@ -126,8 +137,8 @@
* add(null) throws NPE
*/
public void testAddNull() {
+ NavigableSet q = set0();
try {
- NavigableSet q = set0();
q.add(null);
shouldThrow();
} catch (NullPointerException success) {}
@@ -154,9 +165,8 @@
* Add of non-Comparable throws CCE
*/
public void testAddNonComparable() {
+ NavigableSet q = set0();
try {
- NavigableSet q = set0();
- q.add(new Object());
q.add(new Object());
q.add(new Object());
shouldThrow();
@@ -167,8 +177,8 @@
* addAll(null) throws NPE
*/
public void testAddAll1() {
+ NavigableSet q = set0();
try {
- NavigableSet q = set0();
q.addAll(null);
shouldThrow();
} catch (NullPointerException success) {}
@@ -178,9 +188,9 @@
* addAll of a collection with null elements throws NPE
*/
public void testAddAll2() {
+ NavigableSet q = set0();
+ Integer[] ints = new Integer[SIZE];
try {
- NavigableSet q = set0();
- Integer[] ints = new Integer[SIZE];
q.addAll(Arrays.asList(ints));
shouldThrow();
} catch (NullPointerException success) {}
@@ -191,11 +201,11 @@
* possibly adding some elements
*/
public void testAddAll3() {
+ NavigableSet q = set0();
+ Integer[] ints = new Integer[SIZE];
+ for (int i = 0; i < SIZE-1; ++i)
+ ints[i] = new Integer(i+SIZE);
try {
- NavigableSet q = set0();
- Integer[] ints = new Integer[SIZE];
- for (int i = 0; i < SIZE-1; ++i)
- ints[i] = new Integer(i+SIZE);
q.addAll(Arrays.asList(ints));
shouldThrow();
} catch (NullPointerException success) {}
@@ -232,13 +242,13 @@
*/
public void testRemoveElement() {
NavigableSet q = populatedSet(SIZE);
- for (int i = 1; i < SIZE; i+=2) {
+ for (int i = 1; i < SIZE; i += 2) {
assertTrue(q.contains(i));
assertTrue(q.remove(i));
assertFalse(q.contains(i));
assertTrue(q.contains(i-1));
}
- for (int i = 0; i < SIZE; i+=2) {
+ for (int i = 0; i < SIZE; i += 2) {
assertTrue(q.contains(i));
assertTrue(q.remove(i));
assertFalse(q.contains(i));
@@ -317,8 +327,8 @@
assertTrue(q.removeAll(p));
assertEquals(SIZE-i, q.size());
for (int j = 0; j < i; ++j) {
- Integer I = (Integer)(p.pollFirst());
- assertFalse(q.contains(I));
+ Integer x = (Integer)(p.pollFirst());
+ assertFalse(q.contains(x));
}
}
}
@@ -422,27 +432,19 @@
*/
public void testIterator() {
NavigableSet q = populatedSet(SIZE);
- int i = 0;
Iterator it = q.iterator();
- while (it.hasNext()) {
+ int i;
+ for (i = 0; it.hasNext(); i++)
assertTrue(q.contains(it.next()));
- ++i;
- }
assertEquals(i, SIZE);
+ assertIteratorExhausted(it);
}
/**
* iterator of empty set has no elements
*/
public void testEmptyIterator() {
- NavigableSet q = set0();
- int i = 0;
- Iterator it = q.iterator();
- while (it.hasNext()) {
- assertTrue(q.contains(it.next()));
- ++i;
- }
- assertEquals(0, i);
+ assertIteratorExhausted(set0().iterator());
}
/**
@@ -648,9 +650,8 @@
* Add of non-Comparable throws CCE
*/
public void testDescendingAddNonComparable() {
+ NavigableSet q = dset0();
try {
- NavigableSet q = dset0();
- q.add(new Object());
q.add(new Object());
q.add(new Object());
shouldThrow();
@@ -661,8 +662,8 @@
* addAll(null) throws NPE
*/
public void testDescendingAddAll1() {
+ NavigableSet q = dset0();
try {
- NavigableSet q = dset0();
q.addAll(null);
shouldThrow();
} catch (NullPointerException success) {}
@@ -672,9 +673,9 @@
* addAll of a collection with null elements throws NPE
*/
public void testDescendingAddAll2() {
+ NavigableSet q = dset0();
+ Integer[] ints = new Integer[SIZE];
try {
- NavigableSet q = dset0();
- Integer[] ints = new Integer[SIZE];
q.addAll(Arrays.asList(ints));
shouldThrow();
} catch (NullPointerException success) {}
@@ -685,11 +686,11 @@
* possibly adding some elements
*/
public void testDescendingAddAll3() {
+ NavigableSet q = dset0();
+ Integer[] ints = new Integer[SIZE];
+ for (int i = 0; i < SIZE-1; ++i)
+ ints[i] = new Integer(i+SIZE);
try {
- NavigableSet q = dset0();
- Integer[] ints = new Integer[SIZE];
- for (int i = 0; i < SIZE-1; ++i)
- ints[i] = new Integer(i+SIZE);
q.addAll(Arrays.asList(ints));
shouldThrow();
} catch (NullPointerException success) {}
@@ -726,10 +727,10 @@
*/
public void testDescendingRemoveElement() {
NavigableSet q = populatedSet(SIZE);
- for (int i = 1; i < SIZE; i+=2) {
+ for (int i = 1; i < SIZE; i += 2) {
assertTrue(q.remove(new Integer(i)));
}
- for (int i = 0; i < SIZE; i+=2) {
+ for (int i = 0; i < SIZE; i += 2) {
assertTrue(q.remove(new Integer(i)));
assertFalse(q.remove(new Integer(i+1)));
}
@@ -805,8 +806,8 @@
assertTrue(q.removeAll(p));
assertEquals(SIZE-i, q.size());
for (int j = 0; j < i; ++j) {
- Integer I = (Integer)(p.pollFirst());
- assertFalse(q.contains(I));
+ Integer x = (Integer)(p.pollFirst());
+ assertFalse(q.contains(x));
}
}
}