66 |
|
import java.util.Collection; |
67 |
|
import java.util.Collections; |
68 |
|
import java.util.Date; |
69 |
+ |
import java.util.Deque; |
70 |
|
import java.util.Enumeration; |
71 |
+ |
import java.util.HashSet; |
72 |
|
import java.util.Iterator; |
73 |
|
import java.util.List; |
74 |
|
import java.util.NoSuchElementException; |
75 |
|
import java.util.PropertyPermission; |
76 |
+ |
import java.util.Set; |
77 |
|
import java.util.concurrent.BlockingQueue; |
78 |
|
import java.util.concurrent.Callable; |
79 |
|
import java.util.concurrent.CountDownLatch; |
421 |
|
for (String testClassName : testClassNames) { |
422 |
|
try { |
423 |
|
Class<?> testClass = Class.forName(testClassName); |
424 |
< |
Method m = testClass.getDeclaredMethod("suite", |
422 |
< |
new Class<?>[0]); |
424 |
> |
Method m = testClass.getDeclaredMethod("suite"); |
425 |
|
suite.addTest(newTestSuite((Test)m.invoke(null))); |
426 |
< |
} catch (Exception e) { |
427 |
< |
throw new Error("Missing test class", e); |
426 |
> |
} catch (ReflectiveOperationException e) { |
427 |
> |
throw new AssertionError("Missing test class", e); |
428 |
|
} |
429 |
|
} |
430 |
|
} |
451 |
|
public static boolean atLeastJava8() { return JAVA_CLASS_VERSION >= 52.0; } |
452 |
|
public static boolean atLeastJava9() { return JAVA_CLASS_VERSION >= 53.0; } |
453 |
|
public static boolean atLeastJava10() { return JAVA_CLASS_VERSION >= 54.0; } |
454 |
+ |
public static boolean atLeastJava11() { return JAVA_CLASS_VERSION >= 55.0; } |
455 |
|
|
456 |
|
/** |
457 |
|
* Collects all JSR166 unit tests as one suite. |
602 |
|
for (String methodName : testMethodNames(testClass)) |
603 |
|
suite.addTest((Test) c.newInstance(data, methodName)); |
604 |
|
return suite; |
605 |
< |
} catch (Exception e) { |
606 |
< |
throw new Error(e); |
605 |
> |
} catch (ReflectiveOperationException e) { |
606 |
> |
throw new AssertionError(e); |
607 |
|
} |
608 |
|
} |
609 |
|
|
619 |
|
if (atLeastJava8()) { |
620 |
|
String name = testClass.getName(); |
621 |
|
String name8 = name.replaceAll("Test$", "8Test"); |
622 |
< |
if (name.equals(name8)) throw new Error(name); |
622 |
> |
if (name.equals(name8)) throw new AssertionError(name); |
623 |
|
try { |
624 |
|
return (Test) |
625 |
|
Class.forName(name8) |
626 |
< |
.getMethod("testSuite", new Class[] { dataClass }) |
626 |
> |
.getMethod("testSuite", dataClass) |
627 |
|
.invoke(null, data); |
628 |
< |
} catch (Exception e) { |
629 |
< |
throw new Error(e); |
628 |
> |
} catch (ReflectiveOperationException e) { |
629 |
> |
throw new AssertionError(e); |
630 |
|
} |
631 |
|
} else { |
632 |
|
return new TestSuite(); |
1092 |
|
for (long retries = LONG_DELAY_MS * 3 / 4; retries-->0; ) { |
1093 |
|
try { delay(1); } |
1094 |
|
catch (InterruptedException fail) { |
1095 |
< |
fail("Unexpected InterruptedException"); |
1095 |
> |
throw new AssertionError("Unexpected InterruptedException", fail); |
1096 |
|
} |
1097 |
|
Thread.State s = thread.getState(); |
1098 |
|
if (s == expected) |
1388 |
|
*/ |
1389 |
|
<T> void checkTimedGet(Future<T> f, T expectedValue, long timeoutMillis) { |
1390 |
|
long startTime = System.nanoTime(); |
1391 |
+ |
T actual = null; |
1392 |
|
try { |
1393 |
< |
assertEquals(expectedValue, f.get(timeoutMillis, MILLISECONDS)); |
1393 |
> |
actual = f.get(timeoutMillis, MILLISECONDS); |
1394 |
|
} catch (Throwable fail) { threadUnexpectedException(fail); } |
1395 |
+ |
assertEquals(expectedValue, actual); |
1396 |
|
if (millisElapsedSince(startTime) > timeoutMillis/2) |
1397 |
|
throw new AssertionError("timed get did not return promptly"); |
1398 |
|
} |
1452 |
|
} |
1453 |
|
} |
1454 |
|
|
1450 |
– |
public abstract class RunnableShouldThrow implements Runnable { |
1451 |
– |
protected abstract void realRun() throws Throwable; |
1452 |
– |
|
1453 |
– |
final Class<?> exceptionClass; |
1454 |
– |
|
1455 |
– |
<T extends Throwable> RunnableShouldThrow(Class<T> exceptionClass) { |
1456 |
– |
this.exceptionClass = exceptionClass; |
1457 |
– |
} |
1458 |
– |
|
1459 |
– |
public final void run() { |
1460 |
– |
try { |
1461 |
– |
realRun(); |
1462 |
– |
threadShouldThrow(exceptionClass.getSimpleName()); |
1463 |
– |
} catch (Throwable t) { |
1464 |
– |
if (! exceptionClass.isInstance(t)) |
1465 |
– |
threadUnexpectedException(t); |
1466 |
– |
} |
1467 |
– |
} |
1468 |
– |
} |
1469 |
– |
|
1455 |
|
public abstract class ThreadShouldThrow extends Thread { |
1456 |
|
protected abstract void realRun() throws Throwable; |
1457 |
|
|
2057 |
|
assertEquals(savedCompletedTaskCount, p.getCompletedTaskCount()); |
2058 |
|
assertEquals(savedQueueSize, p.getQueue().size()); |
2059 |
|
} |
2060 |
+ |
|
2061 |
+ |
void assertCollectionsEquals(Collection<?> x, Collection<?> y) { |
2062 |
+ |
assertEquals(x, y); |
2063 |
+ |
assertEquals(y, x); |
2064 |
+ |
assertEquals(x.isEmpty(), y.isEmpty()); |
2065 |
+ |
assertEquals(x.size(), y.size()); |
2066 |
+ |
if (x instanceof List) { |
2067 |
+ |
assertEquals(x.toString(), y.toString()); |
2068 |
+ |
} |
2069 |
+ |
if (x instanceof List || x instanceof Set) { |
2070 |
+ |
assertEquals(x.hashCode(), y.hashCode()); |
2071 |
+ |
} |
2072 |
+ |
if (x instanceof List || x instanceof Deque) { |
2073 |
+ |
assertTrue(Arrays.equals(x.toArray(), y.toArray())); |
2074 |
+ |
assertTrue(Arrays.equals(x.toArray(new Object[0]), |
2075 |
+ |
y.toArray(new Object[0]))); |
2076 |
+ |
} |
2077 |
+ |
} |
2078 |
+ |
|
2079 |
+ |
/** |
2080 |
+ |
* A weaker form of assertCollectionsEquals which does not insist |
2081 |
+ |
* that the two collections satisfy Object#equals(Object), since |
2082 |
+ |
* they may use identity semantics as Deques do. |
2083 |
+ |
*/ |
2084 |
+ |
void assertCollectionsEquivalent(Collection<?> x, Collection<?> y) { |
2085 |
+ |
if (x instanceof List || x instanceof Set) |
2086 |
+ |
assertCollectionsEquals(x, y); |
2087 |
+ |
else { |
2088 |
+ |
assertEquals(x.isEmpty(), y.isEmpty()); |
2089 |
+ |
assertEquals(x.size(), y.size()); |
2090 |
+ |
assertEquals(new HashSet(x), new HashSet(y)); |
2091 |
+ |
if (x instanceof Deque) { |
2092 |
+ |
assertTrue(Arrays.equals(x.toArray(), y.toArray())); |
2093 |
+ |
assertTrue(Arrays.equals(x.toArray(new Object[0]), |
2094 |
+ |
y.toArray(new Object[0]))); |
2095 |
+ |
} |
2096 |
+ |
} |
2097 |
+ |
} |
2098 |
|
} |