99 |
|
import java.util.concurrent.atomic.AtomicReference; |
100 |
|
import java.util.regex.Pattern; |
101 |
|
|
102 |
– |
import junit.framework.AssertionFailedError; |
102 |
|
import junit.framework.Test; |
103 |
|
import junit.framework.TestCase; |
104 |
|
import junit.framework.TestResult; |
732 |
|
String msg = toString() + ": " + String.format(format, args); |
733 |
|
System.err.println(msg); |
734 |
|
dumpTestThreads(); |
735 |
< |
throw new AssertionFailedError(msg); |
735 |
> |
throw new AssertionError(msg); |
736 |
|
} |
737 |
|
|
738 |
|
/** |
753 |
|
throw (RuntimeException) t; |
754 |
|
else if (t instanceof Exception) |
755 |
|
throw (Exception) t; |
756 |
< |
else { |
757 |
< |
AssertionFailedError afe = |
759 |
< |
new AssertionFailedError(t.toString()); |
760 |
< |
afe.initCause(t); |
761 |
< |
throw afe; |
762 |
< |
} |
756 |
> |
else |
757 |
> |
throw new AssertionError(t.toString(), t); |
758 |
|
} |
759 |
|
|
760 |
|
if (Thread.interrupted()) |
788 |
|
|
789 |
|
/** |
790 |
|
* Just like fail(reason), but additionally recording (using |
791 |
< |
* threadRecordFailure) any AssertionFailedError thrown, so that |
792 |
< |
* the current testcase will fail. |
791 |
> |
* threadRecordFailure) any AssertionError thrown, so that the |
792 |
> |
* current testcase will fail. |
793 |
|
*/ |
794 |
|
public void threadFail(String reason) { |
795 |
|
try { |
796 |
|
fail(reason); |
797 |
< |
} catch (AssertionFailedError t) { |
798 |
< |
threadRecordFailure(t); |
799 |
< |
throw t; |
797 |
> |
} catch (AssertionError fail) { |
798 |
> |
threadRecordFailure(fail); |
799 |
> |
throw fail; |
800 |
|
} |
801 |
|
} |
802 |
|
|
803 |
|
/** |
804 |
|
* Just like assertTrue(b), but additionally recording (using |
805 |
< |
* threadRecordFailure) any AssertionFailedError thrown, so that |
806 |
< |
* the current testcase will fail. |
805 |
> |
* threadRecordFailure) any AssertionError thrown, so that the |
806 |
> |
* current testcase will fail. |
807 |
|
*/ |
808 |
|
public void threadAssertTrue(boolean b) { |
809 |
|
try { |
810 |
|
assertTrue(b); |
811 |
< |
} catch (AssertionFailedError t) { |
812 |
< |
threadRecordFailure(t); |
813 |
< |
throw t; |
811 |
> |
} catch (AssertionError fail) { |
812 |
> |
threadRecordFailure(fail); |
813 |
> |
throw fail; |
814 |
|
} |
815 |
|
} |
816 |
|
|
817 |
|
/** |
818 |
|
* Just like assertFalse(b), but additionally recording (using |
819 |
< |
* threadRecordFailure) any AssertionFailedError thrown, so that |
820 |
< |
* the current testcase will fail. |
819 |
> |
* threadRecordFailure) any AssertionError thrown, so that the |
820 |
> |
* current testcase will fail. |
821 |
|
*/ |
822 |
|
public void threadAssertFalse(boolean b) { |
823 |
|
try { |
824 |
|
assertFalse(b); |
825 |
< |
} catch (AssertionFailedError t) { |
826 |
< |
threadRecordFailure(t); |
827 |
< |
throw t; |
825 |
> |
} catch (AssertionError fail) { |
826 |
> |
threadRecordFailure(fail); |
827 |
> |
throw fail; |
828 |
|
} |
829 |
|
} |
830 |
|
|
831 |
|
/** |
832 |
|
* Just like assertNull(x), but additionally recording (using |
833 |
< |
* threadRecordFailure) any AssertionFailedError thrown, so that |
834 |
< |
* the current testcase will fail. |
833 |
> |
* threadRecordFailure) any AssertionError thrown, so that the |
834 |
> |
* current testcase will fail. |
835 |
|
*/ |
836 |
|
public void threadAssertNull(Object x) { |
837 |
|
try { |
838 |
|
assertNull(x); |
839 |
< |
} catch (AssertionFailedError t) { |
840 |
< |
threadRecordFailure(t); |
841 |
< |
throw t; |
839 |
> |
} catch (AssertionError fail) { |
840 |
> |
threadRecordFailure(fail); |
841 |
> |
throw fail; |
842 |
|
} |
843 |
|
} |
844 |
|
|
845 |
|
/** |
846 |
|
* Just like assertEquals(x, y), but additionally recording (using |
847 |
< |
* threadRecordFailure) any AssertionFailedError thrown, so that |
848 |
< |
* the current testcase will fail. |
847 |
> |
* threadRecordFailure) any AssertionError thrown, so that the |
848 |
> |
* current testcase will fail. |
849 |
|
*/ |
850 |
|
public void threadAssertEquals(long x, long y) { |
851 |
|
try { |
852 |
|
assertEquals(x, y); |
853 |
< |
} catch (AssertionFailedError t) { |
854 |
< |
threadRecordFailure(t); |
855 |
< |
throw t; |
853 |
> |
} catch (AssertionError fail) { |
854 |
> |
threadRecordFailure(fail); |
855 |
> |
throw fail; |
856 |
|
} |
857 |
|
} |
858 |
|
|
859 |
|
/** |
860 |
|
* Just like assertEquals(x, y), but additionally recording (using |
861 |
< |
* threadRecordFailure) any AssertionFailedError thrown, so that |
862 |
< |
* the current testcase will fail. |
861 |
> |
* threadRecordFailure) any AssertionError thrown, so that the |
862 |
> |
* current testcase will fail. |
863 |
|
*/ |
864 |
|
public void threadAssertEquals(Object x, Object y) { |
865 |
|
try { |
866 |
|
assertEquals(x, y); |
867 |
< |
} catch (AssertionFailedError fail) { |
867 |
> |
} catch (AssertionError fail) { |
868 |
|
threadRecordFailure(fail); |
869 |
|
throw fail; |
870 |
|
} catch (Throwable fail) { |
874 |
|
|
875 |
|
/** |
876 |
|
* Just like assertSame(x, y), but additionally recording (using |
877 |
< |
* threadRecordFailure) any AssertionFailedError thrown, so that |
878 |
< |
* the current testcase will fail. |
877 |
> |
* threadRecordFailure) any AssertionError thrown, so that the |
878 |
> |
* current testcase will fail. |
879 |
|
*/ |
880 |
|
public void threadAssertSame(Object x, Object y) { |
881 |
|
try { |
882 |
|
assertSame(x, y); |
883 |
< |
} catch (AssertionFailedError fail) { |
883 |
> |
} catch (AssertionError fail) { |
884 |
|
threadRecordFailure(fail); |
885 |
|
throw fail; |
886 |
|
} |
902 |
|
|
903 |
|
/** |
904 |
|
* Records the given exception using {@link #threadRecordFailure}, |
905 |
< |
* then rethrows the exception, wrapping it in an |
906 |
< |
* AssertionFailedError if necessary. |
905 |
> |
* then rethrows the exception, wrapping it in an AssertionError |
906 |
> |
* if necessary. |
907 |
|
*/ |
908 |
|
public void threadUnexpectedException(Throwable t) { |
909 |
|
threadRecordFailure(t); |
912 |
|
throw (RuntimeException) t; |
913 |
|
else if (t instanceof Error) |
914 |
|
throw (Error) t; |
915 |
< |
else { |
916 |
< |
AssertionFailedError afe = |
922 |
< |
new AssertionFailedError("unexpected exception: " + t); |
923 |
< |
afe.initCause(t); |
924 |
< |
throw afe; |
925 |
< |
} |
915 |
> |
else |
916 |
> |
throw new AssertionError("unexpected exception: " + t, t); |
917 |
|
} |
918 |
|
|
919 |
|
/** |
1275 |
|
|
1276 |
|
/** |
1277 |
|
* Sleeps until the given time has elapsed. |
1278 |
< |
* Throws AssertionFailedError if interrupted. |
1278 |
> |
* Throws AssertionError if interrupted. |
1279 |
|
*/ |
1280 |
|
static void sleep(long millis) { |
1281 |
|
try { |
1282 |
|
delay(millis); |
1283 |
|
} catch (InterruptedException fail) { |
1284 |
< |
AssertionFailedError afe = |
1294 |
< |
new AssertionFailedError("Unexpected InterruptedException"); |
1295 |
< |
afe.initCause(fail); |
1296 |
< |
throw afe; |
1284 |
> |
throw new AssertionError("Unexpected InterruptedException", fail); |
1285 |
|
} |
1286 |
|
} |
1287 |
|
|
1372 |
|
// r.run(); |
1373 |
|
// } catch (Throwable fail) { threadUnexpectedException(fail); } |
1374 |
|
// if (millisElapsedSince(startTime) > timeoutMillis/2) |
1375 |
< |
// throw new AssertionFailedError("did not return promptly"); |
1375 |
> |
// throw new AssertionError("did not return promptly"); |
1376 |
|
// } |
1377 |
|
|
1378 |
|
// void assertTerminatesPromptly(Runnable r) { |
1389 |
|
assertEquals(expectedValue, f.get(timeoutMillis, MILLISECONDS)); |
1390 |
|
} catch (Throwable fail) { threadUnexpectedException(fail); } |
1391 |
|
if (millisElapsedSince(startTime) > timeoutMillis/2) |
1392 |
< |
throw new AssertionFailedError("timed get did not return promptly"); |
1392 |
> |
throw new AssertionError("timed get did not return promptly"); |
1393 |
|
} |
1394 |
|
|
1395 |
|
<T> void checkTimedGet(Future<T> f, T expectedValue) { |
1631 |
|
// long startTime = System.nanoTime(); |
1632 |
|
// while (!flag.get()) { |
1633 |
|
// if (millisElapsedSince(startTime) > timeoutMillis) |
1634 |
< |
// throw new AssertionFailedError("timed out"); |
1634 |
> |
// throw new AssertionError("timed out"); |
1635 |
|
// Thread.yield(); |
1636 |
|
// } |
1637 |
|
// } |
1718 |
|
|
1719 |
|
/** |
1720 |
|
* A CyclicBarrier that uses timed await and fails with |
1721 |
< |
* AssertionFailedErrors instead of throwing checked exceptions. |
1721 |
> |
* AssertionErrors instead of throwing checked exceptions. |
1722 |
|
*/ |
1723 |
|
public static class CheckedBarrier extends CyclicBarrier { |
1724 |
|
public CheckedBarrier(int parties) { super(parties); } |
1727 |
|
try { |
1728 |
|
return super.await(2 * LONG_DELAY_MS, MILLISECONDS); |
1729 |
|
} catch (TimeoutException timedOut) { |
1730 |
< |
throw new AssertionFailedError("timed out"); |
1730 |
> |
throw new AssertionError("timed out"); |
1731 |
|
} catch (Exception fail) { |
1732 |
< |
AssertionFailedError afe = |
1745 |
< |
new AssertionFailedError("Unexpected exception: " + fail); |
1746 |
< |
afe.initCause(fail); |
1747 |
< |
throw afe; |
1732 |
> |
throw new AssertionError("Unexpected exception: " + fail, fail); |
1733 |
|
} |
1734 |
|
} |
1735 |
|
} |
1852 |
|
try { throwingAction.run(); } |
1853 |
|
catch (Throwable t) { |
1854 |
|
threw = true; |
1855 |
< |
if (!expectedExceptionClass.isInstance(t)) { |
1856 |
< |
AssertionFailedError afe = |
1857 |
< |
new AssertionFailedError |
1858 |
< |
("Expected " + expectedExceptionClass.getName() + |
1859 |
< |
", got " + t.getClass().getName()); |
1875 |
< |
afe.initCause(t); |
1876 |
< |
threadUnexpectedException(afe); |
1877 |
< |
} |
1855 |
> |
if (!expectedExceptionClass.isInstance(t)) |
1856 |
> |
throw new AssertionError( |
1857 |
> |
"Expected " + expectedExceptionClass.getName() + |
1858 |
> |
", got " + t.getClass().getName(), |
1859 |
> |
t); |
1860 |
|
} |
1861 |
|
if (!threw) |
1862 |
|
shouldThrow(expectedExceptionClass.getName()); |