jdk-sandbox: comparison test/jdk/java/util/concurrent/tck/JSR166TestCase.java

equal deleted inserted replaced

-:a5a2e4770524
+:21efc1774302
 import java.util.concurrent.TimeoutException;
 import java.util.concurrent.atomic.AtomicBoolean;
 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.TestResult;
 import junit.framework.TestSuite;
 public static void addNamedTestClasses(TestSuite suite,
 String... testClassNames) {
 for (String testClassName : testClassNames) {
 try {
 Class<?> testClass = Class.forName(testClassName);
-Method m = testClass.getDeclaredMethod("suite",
+Method m = testClass.getDeclaredMethod("suite");
-new Class<?>[0]);
 suite.addTest(newTestSuite((Test)m.invoke(null)));
-} catch (Exception e) {
+} catch (ReflectiveOperationException e) {
-throw new Error("Missing test class", e);
+throw new AssertionError("Missing test class", e);
 }
 }
 }
 public static final double JAVA_CLASS_VERSION;
 Constructor c =
 testClass.getDeclaredConstructor(dataClass, String.class);
 for (String methodName : testMethodNames(testClass))
 suite.addTest((Test) c.newInstance(data, methodName));
 return suite;
-} catch (Exception e) {
+} catch (ReflectiveOperationException e) {
-throw new Error(e);
+throw new AssertionError(e);
 }
 }
 /**
 * Returns junit-style testSuite for the jdk8 extension of the
 Class<ExtraData> dataClass,
 ExtraData data) {
 if (atLeastJava8()) {
 String name = testClass.getName();
 String name8 = name.replaceAll("Test$", "8Test");
-if (name.equals(name8)) throw new Error(name);
+if (name.equals(name8)) throw new AssertionError(name);
 try {
 return (Test)
 Class.forName(name8)
-.getMethod("testSuite", new Class[] { dataClass })
+.getMethod("testSuite", dataClass)
 .invoke(null, data);
-} catch (Exception e) {
+} catch (ReflectiveOperationException e) {
-throw new Error(e);
+throw new AssertionError(e);
 }
 } else {
 return new TestSuite();
 }
 }
 void tearDownFail(String format, Object... args) {
 String msg = toString() + ": " + String.format(format, args);
 System.err.println(msg);
 dumpTestThreads();
-throw new AssertionFailedError(msg);
+throw new AssertionError(msg);
 }
 /**
 * Extra checks that get done for all test cases.
 *
 throw (Error) t;
 else if (t instanceof RuntimeException)
 throw (RuntimeException) t;
 else if (t instanceof Exception)
 throw (Exception) t;
-else {
+else
-AssertionFailedError afe =
+throw new AssertionError(t.toString(), t);
-new AssertionFailedError(t.toString());
-afe.initCause(t);
-throw afe;
-}
 }
 if (Thread.interrupted())
 tearDownFail("interrupt status set in main thread");
 tearDownFail("ForkJoin common pool thread stuck");
 }
 /**
 * Just like fail(reason), but additionally recording (using
-* threadRecordFailure) any AssertionFailedError thrown, so that
+* threadRecordFailure) any AssertionError thrown, so that the
-* the current testcase will fail.
+* current testcase will fail.
 */
 public void threadFail(String reason) {
 try {
 fail(reason);
-} catch (AssertionFailedError t) {
+} catch (AssertionError fail) {
-threadRecordFailure(t);
+threadRecordFailure(fail);
-throw t;
+throw fail;
 }
 }
 /**
 * Just like assertTrue(b), but additionally recording (using
-* threadRecordFailure) any AssertionFailedError thrown, so that
+* threadRecordFailure) any AssertionError thrown, so that the
-* the current testcase will fail.
+* current testcase will fail.
 */
 public void threadAssertTrue(boolean b) {
 try {
 assertTrue(b);
-} catch (AssertionFailedError t) {
+} catch (AssertionError fail) {
-threadRecordFailure(t);
+threadRecordFailure(fail);
-throw t;
+throw fail;
 }
 }
 /**
 * Just like assertFalse(b), but additionally recording (using
-* threadRecordFailure) any AssertionFailedError thrown, so that
+* threadRecordFailure) any AssertionError thrown, so that the
-* the current testcase will fail.
+* current testcase will fail.
 */
 public void threadAssertFalse(boolean b) {
 try {
 assertFalse(b);
-} catch (AssertionFailedError t) {
+} catch (AssertionError fail) {
-threadRecordFailure(t);
+threadRecordFailure(fail);
-throw t;
+throw fail;
 }
 }
 /**
 * Just like assertNull(x), but additionally recording (using
-* threadRecordFailure) any AssertionFailedError thrown, so that
+* threadRecordFailure) any AssertionError thrown, so that the
-* the current testcase will fail.
+* current testcase will fail.
 */
 public void threadAssertNull(Object x) {
 try {
 assertNull(x);
-} catch (AssertionFailedError t) {
+} catch (AssertionError fail) {
-threadRecordFailure(t);
+threadRecordFailure(fail);
-throw t;
+throw fail;
 }
 }
 /**
 * Just like assertEquals(x, y), but additionally recording (using
-* threadRecordFailure) any AssertionFailedError thrown, so that
+* threadRecordFailure) any AssertionError thrown, so that the
-* the current testcase will fail.
+* current testcase will fail.
 */
 public void threadAssertEquals(long x, long y) {
 try {
 assertEquals(x, y);
-} catch (AssertionFailedError t) {
+} catch (AssertionError fail) {
-threadRecordFailure(t);
+threadRecordFailure(fail);
-throw t;
+throw fail;
 }
 }
 /**
 * Just like assertEquals(x, y), but additionally recording (using
-* threadRecordFailure) any AssertionFailedError thrown, so that
+* threadRecordFailure) any AssertionError thrown, so that the
-* the current testcase will fail.
+* current testcase will fail.
 */
 public void threadAssertEquals(Object x, Object y) {
 try {
 assertEquals(x, y);
-} catch (AssertionFailedError fail) {
+} catch (AssertionError fail) {
 threadRecordFailure(fail);
 throw fail;
 } catch (Throwable fail) {
 threadUnexpectedException(fail);
 }
 }
 /**
 * Just like assertSame(x, y), but additionally recording (using
-* threadRecordFailure) any AssertionFailedError thrown, so that
+* threadRecordFailure) any AssertionError thrown, so that the
-* the current testcase will fail.
+* current testcase will fail.
 */
 public void threadAssertSame(Object x, Object y) {
 try {
 assertSame(x, y);
-} catch (AssertionFailedError fail) {
+} catch (AssertionError fail) {
 threadRecordFailure(fail);
 throw fail;
 }
 }
 threadFail("should throw " + exceptionName);
 }
 /**
 * Records the given exception using {@link #threadRecordFailure},
-* then rethrows the exception, wrapping it in an
+* then rethrows the exception, wrapping it in an AssertionError
-* AssertionFailedError if necessary.
+* if necessary.
 */
 public void threadUnexpectedException(Throwable t) {
 threadRecordFailure(t);
 t.printStackTrace();
 if (t instanceof RuntimeException)
 throw (RuntimeException) t;
 else if (t instanceof Error)
 throw (Error) t;
-else {
+else
-AssertionFailedError afe =
+throw new AssertionError("unexpected exception: " + t, t);
-new AssertionFailedError("unexpected exception: " + t);
-afe.initCause(t);
-throw afe;
-}
 }
 /**
 * Delays, via Thread.sleep, for the given millisecond delay, but
 * if the sleep is shorter than specified, may re-sleep or yield
 // always sleep at least 1 ms, with high probability avoiding
 // transitory states
 for (long retries = LONG_DELAY_MS * 3 / 4; retries-->0; ) {
 try { delay(1); }
 catch (InterruptedException fail) {
-fail("Unexpected InterruptedException");
+throw new AssertionError("Unexpected InterruptedException", fail);
 }
 Thread.State s = thread.getState();
 if (s == expected)
 return;
 else if (s == Thread.State.TERMINATED)
 new java.io.FilePermission("<<ALL FILES>>", "read"));
 }
 /**
 * Sleeps until the given time has elapsed.
-* Throws AssertionFailedError if interrupted.
+* Throws AssertionError if interrupted.
 */
 static void sleep(long millis) {
 try {
 delay(millis);
 } catch (InterruptedException fail) {
-AssertionFailedError afe =
+throw new AssertionError("Unexpected InterruptedException", fail);
-new AssertionFailedError("Unexpected InterruptedException");
-afe.initCause(fail);
-throw afe;
 }
 }
 /**
 * Spin-waits up to the specified number of milliseconds for the given
 //         long startTime = System.nanoTime();
 //         try {
 //             r.run();
 //         } catch (Throwable fail) { threadUnexpectedException(fail); }
 //         if (millisElapsedSince(startTime) > timeoutMillis/2)
-//             throw new AssertionFailedError("did not return promptly");
+//             throw new AssertionError("did not return promptly");
 //     }
 //     void assertTerminatesPromptly(Runnable r) {
 //         assertTerminatesPromptly(LONG_DELAY_MS/2, r);
 //     }
 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");
+throw new AssertionError("timed get did not return promptly");
 }
 <T> void checkTimedGet(Future<T> f, T expectedValue) {
 checkTimedGet(f, expectedValue, LONG_DELAY_MS);
 }
 //      */
 //     public void await(AtomicBoolean flag, long timeoutMillis) {
 //         long startTime = System.nanoTime();
 //         while (!flag.get()) {
 //             if (millisElapsedSince(startTime) > timeoutMillis)
-//                 throw new AssertionFailedError("timed out");
+//                 throw new AssertionError("timed out");
 //             Thread.yield();
 //         }
 //     }
 public static class NPETask implements Callable<String> {
 ThreadPoolExecutor executor) {}
 }
 /**
 * A CyclicBarrier that uses timed await and fails with
-* AssertionFailedErrors instead of throwing checked exceptions.
+* AssertionErrors instead of throwing checked exceptions.
 */
 public static class CheckedBarrier extends CyclicBarrier {
 public CheckedBarrier(int parties) { super(parties); }
 public int await() {
 try {
 return super.await(2 * LONG_DELAY_MS, MILLISECONDS);
 } catch (TimeoutException timedOut) {
-throw new AssertionFailedError("timed out");
+throw new AssertionError("timed out");
 } catch (Exception fail) {
-AssertionFailedError afe =
+throw new AssertionError("Unexpected exception: " + fail, fail);
-new AssertionFailedError("Unexpected exception: " + fail);
-afe.initCause(fail);
-throw afe;
 }
 }
 }
 void checkEmpty(BlockingQueue q) {
 for (Runnable throwingAction : throwingActions) {
 boolean threw = false;
 try { throwingAction.run(); }
 catch (Throwable t) {
 threw = true;
-if (!expectedExceptionClass.isInstance(t)) {
+if (!expectedExceptionClass.isInstance(t))
-AssertionFailedError afe =
+throw new AssertionError(
-new AssertionFailedError
+"Expected " + expectedExceptionClass.getName() +
-("Expected " + expectedExceptionClass.getName() +
+", got " + t.getClass().getName(),
-", got " + t.getClass().getName());
+t);
-afe.initCause(t);
-threadUnexpectedException(afe);
-}
 }
 if (!threw)
 shouldThrow(expectedExceptionClass.getName());
 }
 }

changeset 48843	21efc1774302
parent 48541	946e34c2dec9
child 49564	260bf39376a4