ViewVC Help
View File | Revision Log | Show Annotations | Download File | Root Listing
root/jsr166/jsr166/src/test/tck/JSR166TestCase.java
(Generate patch)

Comparing jsr166/src/test/tck/JSR166TestCase.java (file contents):
Revision 1.238 by jsr166, Mon Dec 11 00:27:08 2017 UTC vs.
Revision 1.243 by jsr166, Thu Apr 5 03:36:54 2018 UTC

# Line 66 | Line 66 | import java.util.Arrays;
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;
# Line 99 | Line 102 | import java.util.concurrent.atomic.Atomi
102   import java.util.concurrent.atomic.AtomicReference;
103   import java.util.regex.Pattern;
104  
102 – import junit.framework.AssertionFailedError;
105   import junit.framework.Test;
106   import junit.framework.TestCase;
107   import junit.framework.TestResult;
# Line 419 | Line 421 | public class JSR166TestCase extends Test
421          for (String testClassName : testClassNames) {
422              try {
423                  Class<?> testClass = Class.forName(testClassName);
424 <                Method m = testClass.getDeclaredMethod("suite",
423 <                                                       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      }
# Line 600 | Line 601 | public class JSR166TestCase extends Test
601              for (String methodName : testMethodNames(testClass))
602                  suite.addTest((Test) c.newInstance(data, methodName));
603              return suite;
604 <        } catch (Exception e) {
605 <            throw new Error(e);
604 >        } catch (ReflectiveOperationException e) {
605 >            throw new AssertionError(e);
606          }
607      }
608  
# Line 617 | Line 618 | public class JSR166TestCase extends Test
618          if (atLeastJava8()) {
619              String name = testClass.getName();
620              String name8 = name.replaceAll("Test$", "8Test");
621 <            if (name.equals(name8)) throw new Error(name);
621 >            if (name.equals(name8)) throw new AssertionError(name);
622              try {
623                  return (Test)
624                      Class.forName(name8)
625 <                    .getMethod("testSuite", new Class[] { dataClass })
625 >                    .getMethod("testSuite", dataClass)
626                      .invoke(null, data);
627 <            } catch (Exception e) {
628 <                throw new Error(e);
627 >            } catch (ReflectiveOperationException e) {
628 >                throw new AssertionError(e);
629              }
630          } else {
631              return new TestSuite();
# Line 733 | Line 734 | public class JSR166TestCase extends Test
734          String msg = toString() + ": " + String.format(format, args);
735          System.err.println(msg);
736          dumpTestThreads();
737 <        throw new AssertionFailedError(msg);
737 >        throw new AssertionError(msg);
738      }
739  
740      /**
# Line 754 | Line 755 | public class JSR166TestCase extends Test
755                  throw (RuntimeException) t;
756              else if (t instanceof Exception)
757                  throw (Exception) t;
758 <            else {
759 <                AssertionFailedError afe =
759 <                    new AssertionFailedError(t.toString());
760 <                afe.initCause(t);
761 <                throw afe;
762 <            }
758 >            else
759 >                throw new AssertionError(t.toString(), t);
760          }
761  
762          if (Thread.interrupted())
# Line 793 | Line 790 | public class JSR166TestCase extends Test
790  
791      /**
792       * Just like fail(reason), but additionally recording (using
793 <     * threadRecordFailure) any AssertionFailedError thrown, so that
794 <     * the current testcase will fail.
793 >     * threadRecordFailure) any AssertionError thrown, so that the
794 >     * current testcase will fail.
795       */
796      public void threadFail(String reason) {
797          try {
798              fail(reason);
799 <        } catch (AssertionFailedError t) {
800 <            threadRecordFailure(t);
801 <            throw t;
799 >        } catch (AssertionError fail) {
800 >            threadRecordFailure(fail);
801 >            throw fail;
802          }
803      }
804  
805      /**
806       * Just like assertTrue(b), but additionally recording (using
807 <     * threadRecordFailure) any AssertionFailedError thrown, so that
808 <     * the current testcase will fail.
807 >     * threadRecordFailure) any AssertionError thrown, so that the
808 >     * current testcase will fail.
809       */
810      public void threadAssertTrue(boolean b) {
811          try {
812              assertTrue(b);
813 <        } catch (AssertionFailedError t) {
814 <            threadRecordFailure(t);
815 <            throw t;
813 >        } catch (AssertionError fail) {
814 >            threadRecordFailure(fail);
815 >            throw fail;
816          }
817      }
818  
819      /**
820       * Just like assertFalse(b), but additionally recording (using
821 <     * threadRecordFailure) any AssertionFailedError thrown, so that
822 <     * the current testcase will fail.
821 >     * threadRecordFailure) any AssertionError thrown, so that the
822 >     * current testcase will fail.
823       */
824      public void threadAssertFalse(boolean b) {
825          try {
826              assertFalse(b);
827 <        } catch (AssertionFailedError t) {
828 <            threadRecordFailure(t);
829 <            throw t;
827 >        } catch (AssertionError fail) {
828 >            threadRecordFailure(fail);
829 >            throw fail;
830          }
831      }
832  
833      /**
834       * Just like assertNull(x), but additionally recording (using
835 <     * threadRecordFailure) any AssertionFailedError thrown, so that
836 <     * the current testcase will fail.
835 >     * threadRecordFailure) any AssertionError thrown, so that the
836 >     * current testcase will fail.
837       */
838      public void threadAssertNull(Object x) {
839          try {
840              assertNull(x);
841 <        } catch (AssertionFailedError t) {
842 <            threadRecordFailure(t);
843 <            throw t;
841 >        } catch (AssertionError fail) {
842 >            threadRecordFailure(fail);
843 >            throw fail;
844          }
845      }
846  
847      /**
848       * Just like assertEquals(x, y), but additionally recording (using
849 <     * threadRecordFailure) any AssertionFailedError thrown, so that
850 <     * the current testcase will fail.
849 >     * threadRecordFailure) any AssertionError thrown, so that the
850 >     * current testcase will fail.
851       */
852      public void threadAssertEquals(long x, long y) {
853          try {
854              assertEquals(x, y);
855 <        } catch (AssertionFailedError t) {
856 <            threadRecordFailure(t);
857 <            throw t;
855 >        } catch (AssertionError fail) {
856 >            threadRecordFailure(fail);
857 >            throw fail;
858          }
859      }
860  
861      /**
862       * Just like assertEquals(x, y), but additionally recording (using
863 <     * threadRecordFailure) any AssertionFailedError thrown, so that
864 <     * the current testcase will fail.
863 >     * threadRecordFailure) any AssertionError thrown, so that the
864 >     * current testcase will fail.
865       */
866      public void threadAssertEquals(Object x, Object y) {
867          try {
868              assertEquals(x, y);
869 <        } catch (AssertionFailedError fail) {
869 >        } catch (AssertionError fail) {
870              threadRecordFailure(fail);
871              throw fail;
872          } catch (Throwable fail) {
# Line 879 | Line 876 | public class JSR166TestCase extends Test
876  
877      /**
878       * Just like assertSame(x, y), but additionally recording (using
879 <     * threadRecordFailure) any AssertionFailedError thrown, so that
880 <     * the current testcase will fail.
879 >     * threadRecordFailure) any AssertionError thrown, so that the
880 >     * current testcase will fail.
881       */
882      public void threadAssertSame(Object x, Object y) {
883          try {
884              assertSame(x, y);
885 <        } catch (AssertionFailedError fail) {
885 >        } catch (AssertionError fail) {
886              threadRecordFailure(fail);
887              throw fail;
888          }
# Line 907 | Line 904 | public class JSR166TestCase extends Test
904  
905      /**
906       * Records the given exception using {@link #threadRecordFailure},
907 <     * then rethrows the exception, wrapping it in an
908 <     * AssertionFailedError if necessary.
907 >     * then rethrows the exception, wrapping it in an AssertionError
908 >     * if necessary.
909       */
910      public void threadUnexpectedException(Throwable t) {
911          threadRecordFailure(t);
# Line 917 | Line 914 | public class JSR166TestCase extends Test
914              throw (RuntimeException) t;
915          else if (t instanceof Error)
916              throw (Error) t;
917 <        else {
918 <            AssertionFailedError afe =
922 <                new AssertionFailedError("unexpected exception: " + t);
923 <            afe.initCause(t);
924 <            throw afe;
925 <        }
917 >        else
918 >            throw new AssertionError("unexpected exception: " + t, t);
919      }
920  
921      /**
# Line 1098 | Line 1091 | public class JSR166TestCase extends Test
1091          for (long retries = LONG_DELAY_MS * 3 / 4; retries-->0; ) {
1092              try { delay(1); }
1093              catch (InterruptedException fail) {
1094 <                fail("Unexpected InterruptedException");
1094 >                throw new AssertionError("Unexpected InterruptedException", fail);
1095              }
1096              Thread.State s = thread.getState();
1097              if (s == expected)
# Line 1284 | Line 1277 | public class JSR166TestCase extends Test
1277  
1278      /**
1279       * Sleeps until the given time has elapsed.
1280 <     * Throws AssertionFailedError if interrupted.
1280 >     * Throws AssertionError if interrupted.
1281       */
1282      static void sleep(long millis) {
1283          try {
1284              delay(millis);
1285          } catch (InterruptedException fail) {
1286 <            AssertionFailedError afe =
1294 <                new AssertionFailedError("Unexpected InterruptedException");
1295 <            afe.initCause(fail);
1296 <            throw afe;
1286 >            throw new AssertionError("Unexpected InterruptedException", fail);
1287          }
1288      }
1289  
# Line 1384 | Line 1374 | public class JSR166TestCase extends Test
1374   //             r.run();
1375   //         } catch (Throwable fail) { threadUnexpectedException(fail); }
1376   //         if (millisElapsedSince(startTime) > timeoutMillis/2)
1377 < //             throw new AssertionFailedError("did not return promptly");
1377 > //             throw new AssertionError("did not return promptly");
1378   //     }
1379  
1380   //     void assertTerminatesPromptly(Runnable r) {
# Line 1401 | Line 1391 | public class JSR166TestCase extends Test
1391              assertEquals(expectedValue, f.get(timeoutMillis, MILLISECONDS));
1392          } catch (Throwable fail) { threadUnexpectedException(fail); }
1393          if (millisElapsedSince(startTime) > timeoutMillis/2)
1394 <            throw new AssertionFailedError("timed get did not return promptly");
1394 >            throw new AssertionError("timed get did not return promptly");
1395      }
1396  
1397      <T> void checkTimedGet(Future<T> f, T expectedValue) {
# Line 1459 | Line 1449 | public class JSR166TestCase extends Test
1449          }
1450      }
1451  
1462 –    public abstract class RunnableShouldThrow implements Runnable {
1463 –        protected abstract void realRun() throws Throwable;
1464 –
1465 –        final Class<?> exceptionClass;
1466 –
1467 –        <T extends Throwable> RunnableShouldThrow(Class<T> exceptionClass) {
1468 –            this.exceptionClass = exceptionClass;
1469 –        }
1470 –
1471 –        public final void run() {
1472 –            try {
1473 –                realRun();
1474 –                threadShouldThrow(exceptionClass.getSimpleName());
1475 –            } catch (Throwable t) {
1476 –                if (! exceptionClass.isInstance(t))
1477 –                    threadUnexpectedException(t);
1478 –            }
1479 –        }
1480 –    }
1481 –
1452      public abstract class ThreadShouldThrow extends Thread {
1453          protected abstract void realRun() throws Throwable;
1454  
# Line 1643 | Line 1613 | public class JSR166TestCase extends Test
1613   //         long startTime = System.nanoTime();
1614   //         while (!flag.get()) {
1615   //             if (millisElapsedSince(startTime) > timeoutMillis)
1616 < //                 throw new AssertionFailedError("timed out");
1616 > //                 throw new AssertionError("timed out");
1617   //             Thread.yield();
1618   //         }
1619   //     }
# Line 1730 | Line 1700 | public class JSR166TestCase extends Test
1700  
1701      /**
1702       * A CyclicBarrier that uses timed await and fails with
1703 <     * AssertionFailedErrors instead of throwing checked exceptions.
1703 >     * AssertionErrors instead of throwing checked exceptions.
1704       */
1705      public static class CheckedBarrier extends CyclicBarrier {
1706          public CheckedBarrier(int parties) { super(parties); }
# Line 1739 | Line 1709 | public class JSR166TestCase extends Test
1709              try {
1710                  return super.await(2 * LONG_DELAY_MS, MILLISECONDS);
1711              } catch (TimeoutException timedOut) {
1712 <                throw new AssertionFailedError("timed out");
1712 >                throw new AssertionError("timed out");
1713              } catch (Exception fail) {
1714 <                AssertionFailedError afe =
1745 <                    new AssertionFailedError("Unexpected exception: " + fail);
1746 <                afe.initCause(fail);
1747 <                throw afe;
1714 >                throw new AssertionError("Unexpected exception: " + fail, fail);
1715              }
1716          }
1717      }
# Line 1867 | Line 1834 | public class JSR166TestCase extends Test
1834              try { throwingAction.run(); }
1835              catch (Throwable t) {
1836                  threw = true;
1837 <                if (!expectedExceptionClass.isInstance(t)) {
1838 <                    AssertionFailedError afe =
1839 <                        new AssertionFailedError
1840 <                        ("Expected " + expectedExceptionClass.getName() +
1841 <                         ", got " + t.getClass().getName());
1875 <                    afe.initCause(t);
1876 <                    threadUnexpectedException(afe);
1877 <                }
1837 >                if (!expectedExceptionClass.isInstance(t))
1838 >                    throw new AssertionError(
1839 >                            "Expected " + expectedExceptionClass.getName() +
1840 >                            ", got " + t.getClass().getName(),
1841 >                            t);
1842              }
1843              if (!threw)
1844                  shouldThrow(expectedExceptionClass.getName());
# Line 2090 | Line 2054 | public class JSR166TestCase extends Test
2054          assertEquals(savedCompletedTaskCount, p.getCompletedTaskCount());
2055          assertEquals(savedQueueSize, p.getQueue().size());
2056      }
2057 +
2058 +    void assertCollectionsEquals(Collection<?> x, Collection<?> y) {
2059 +        assertEquals(x, y);
2060 +        assertEquals(y, x);
2061 +        assertEquals(x.isEmpty(), y.isEmpty());
2062 +        assertEquals(x.size(), y.size());
2063 +        if (x instanceof List) {
2064 +            assertEquals(x.toString(), y.toString());
2065 +        }
2066 +        if (x instanceof List || x instanceof Set) {
2067 +            assertEquals(x.hashCode(), y.hashCode());
2068 +        }
2069 +        if (x instanceof List || x instanceof Deque) {
2070 +            assertTrue(Arrays.equals(x.toArray(), y.toArray()));
2071 +            assertTrue(Arrays.equals(x.toArray(new Object[0]),
2072 +                                     y.toArray(new Object[0])));
2073 +        }
2074 +    }
2075 +
2076 +    /**
2077 +     * A weaker form of assertCollectionsEquals which does not insist
2078 +     * that the two collections satisfy Object#equals(Object), since
2079 +     * they may use identity semantics as Deques do.
2080 +     */
2081 +    void assertCollectionsEquivalent(Collection<?> x, Collection<?> y) {
2082 +        if (x instanceof List || x instanceof Set)
2083 +            assertCollectionsEquals(x, y);
2084 +        else {
2085 +            assertEquals(x.isEmpty(), y.isEmpty());
2086 +            assertEquals(x.size(), y.size());
2087 +            assertEquals(new HashSet(x), new HashSet(y));
2088 +            if (x instanceof Deque) {
2089 +                assertTrue(Arrays.equals(x.toArray(), y.toArray()));
2090 +                assertTrue(Arrays.equals(x.toArray(new Object[0]),
2091 +                                         y.toArray(new Object[0])));
2092 +            }
2093 +        }
2094 +    }
2095   }

Diff Legend

– Removed lines
+ Added lines
< Changed lines
> Changed lines