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.125 by jsr166, Thu Jan 15 18:58:07 2015 UTC vs.
Revision 1.132 by jsr166, Mon Apr 27 06:01:31 2015 UTC

# Line 27 | Line 27 | import java.util.ArrayList;
27   import java.util.Arrays;
28   import java.util.Date;
29   import java.util.Enumeration;
30 + import java.util.Iterator;
31   import java.util.List;
32   import java.util.NoSuchElementException;
33   import java.util.PropertyPermission;
# Line 49 | Line 50 | import java.util.regex.Pattern;
50   import junit.framework.AssertionFailedError;
51   import junit.framework.Test;
52   import junit.framework.TestCase;
53 + import junit.framework.TestResult;
54   import junit.framework.TestSuite;
55  
56   /**
# Line 159 | Line 161 | public class JSR166TestCase extends Test
161          Integer.getInteger("jsr166.runsPerTest", 1);
162  
163      /**
164 +     * The number of repetitions of the test suite (for finding leaks?).
165 +     */
166 +    private static final int suiteRuns =
167 +        Integer.getInteger("jsr166.suiteRuns", 1);
168 +
169 +    /**
170       * A filter for tests to run, matching strings of the form
171       * methodName(className), e.g. "testInvokeAll5(ForkJoinPoolTest)"
172       * Usefully combined with jsr166.runsPerTest.
# Line 197 | Line 205 | public class JSR166TestCase extends Test
205  
206      /**
207       * Runs all JSR166 unit tests using junit.textui.TestRunner.
200 –     * Optional command line arg provides the number of iterations to
201 –     * repeat running the tests.
208       */
209      public static void main(String[] args) {
210 +        main(suite(), args);
211 +    }
212 +
213 +    /**
214 +     * Runs all unit tests in the given test suite.
215 +     * Actual behavior influenced by jsr166.* system properties.
216 +     */
217 +    static void main(Test suite, String[] args) {
218          if (useSecurityManager) {
219              System.err.println("Setting a permissive security manager");
220              Policy.setPolicy(permissivePolicy());
221              System.setSecurityManager(new SecurityManager());
222          }
223 <        int iters = (args.length == 0) ? 1 : Integer.parseInt(args[0]);
224 <
225 <        Test s = suite();
226 <        for (int i = 0; i < iters; ++i) {
213 <            junit.textui.TestRunner.run(s);
223 >        for (int i = 0; i < suiteRuns; i++) {
224 >            TestResult result = junit.textui.TestRunner.run(suite);
225 >            if (!result.wasSuccessful())
226 >                System.exit(1);
227              System.gc();
228              System.runFinalization();
229          }
217 –        System.exit(0);
230      }
231  
232      public static TestSuite newTestSuite(Object... suiteOrClasses) {
# Line 264 | Line 276 | public class JSR166TestCase extends Test
276      public static boolean atLeastJava6() { return JAVA_CLASS_VERSION >= 50.0; }
277      public static boolean atLeastJava7() { return JAVA_CLASS_VERSION >= 51.0; }
278      public static boolean atLeastJava8() { return JAVA_CLASS_VERSION >= 52.0; }
279 <    public static boolean atLeastJava9() {
268 <        // As of 2014-05, java9 still uses 52.0 class file version
269 <        return JAVA_SPECIFICATION_VERSION.startsWith("1.9");
270 <    }
279 >    public static boolean atLeastJava9() { return JAVA_CLASS_VERSION >= 53.0; }
280  
281      /**
282       * Collects all JSR166 unit tests as one suite.
# Line 563 | Line 572 | public class JSR166TestCase extends Test
572      public void threadAssertEquals(Object x, Object y) {
573          try {
574              assertEquals(x, y);
575 <        } catch (AssertionFailedError t) {
576 <            threadRecordFailure(t);
577 <            throw t;
578 <        } catch (Throwable t) {
579 <            threadUnexpectedException(t);
575 >        } catch (AssertionFailedError fail) {
576 >            threadRecordFailure(fail);
577 >            throw fail;
578 >        } catch (Throwable fail) {
579 >            threadUnexpectedException(fail);
580          }
581      }
582  
# Line 579 | Line 588 | public class JSR166TestCase extends Test
588      public void threadAssertSame(Object x, Object y) {
589          try {
590              assertSame(x, y);
591 <        } catch (AssertionFailedError t) {
592 <            threadRecordFailure(t);
593 <            throw t;
591 >        } catch (AssertionFailedError fail) {
592 >            threadRecordFailure(fail);
593 >            throw fail;
594          }
595      }
596  
# Line 651 | Line 660 | public class JSR166TestCase extends Test
660                       " did not terminate in a timely manner");
661          } catch (SecurityException ok) {
662              // Allowed in case test doesn't have privs
663 <        } catch (InterruptedException ie) {
663 >        } catch (InterruptedException fail) {
664              fail("Unexpected InterruptedException");
665          }
666      }
# Line 682 | Line 691 | public class JSR166TestCase extends Test
691              // No need to optimize the failing case via Thread.join.
692              delay(millis);
693              assertTrue(thread.isAlive());
694 <        } catch (InterruptedException ie) {
694 >        } catch (InterruptedException fail) {
695              fail("Unexpected InterruptedException");
696          }
697      }
# Line 704 | Line 713 | public class JSR166TestCase extends Test
713              delay(millis);
714              for (Thread thread : threads)
715                  assertTrue(thread.isAlive());
716 <        } catch (InterruptedException ie) {
716 >        } catch (InterruptedException fail) {
717              fail("Unexpected InterruptedException");
718          }
719      }
# Line 726 | Line 735 | public class JSR166TestCase extends Test
735              future.get(timeoutMillis, MILLISECONDS);
736              shouldThrow();
737          } catch (TimeoutException success) {
738 <        } catch (Exception e) {
739 <            threadUnexpectedException(e);
738 >        } catch (Exception fail) {
739 >            threadUnexpectedException(fail);
740          } finally { future.cancel(true); }
741          assertTrue(millisElapsedSince(startTime) >= timeoutMillis);
742      }
# Line 883 | Line 892 | public class JSR166TestCase extends Test
892      void sleep(long millis) {
893          try {
894              delay(millis);
895 <        } catch (InterruptedException ie) {
895 >        } catch (InterruptedException fail) {
896              AssertionFailedError afe =
897                  new AssertionFailedError("Unexpected InterruptedException");
898 <            afe.initCause(ie);
898 >            afe.initCause(fail);
899              throw afe;
900          }
901      }
# Line 978 | Line 987 | public class JSR166TestCase extends Test
987      void awaitTermination(Thread t, long timeoutMillis) {
988          try {
989              t.join(timeoutMillis);
990 <        } catch (InterruptedException ie) {
991 <            threadUnexpectedException(ie);
990 >        } catch (InterruptedException fail) {
991 >            threadUnexpectedException(fail);
992          } finally {
993              if (t.getState() != Thread.State.TERMINATED) {
994                  t.interrupt();
# Line 1005 | Line 1014 | public class JSR166TestCase extends Test
1014          public final void run() {
1015              try {
1016                  realRun();
1017 <            } catch (Throwable t) {
1018 <                threadUnexpectedException(t);
1017 >            } catch (Throwable fail) {
1018 >                threadUnexpectedException(fail);
1019              }
1020          }
1021      }
# Line 1060 | Line 1069 | public class JSR166TestCase extends Test
1069                  threadShouldThrow("InterruptedException");
1070              } catch (InterruptedException success) {
1071                  threadAssertFalse(Thread.interrupted());
1072 <            } catch (Throwable t) {
1073 <                threadUnexpectedException(t);
1072 >            } catch (Throwable fail) {
1073 >                threadUnexpectedException(fail);
1074              }
1075          }
1076      }
# Line 1072 | Line 1081 | public class JSR166TestCase extends Test
1081          public final T call() {
1082              try {
1083                  return realCall();
1084 <            } catch (Throwable t) {
1085 <                threadUnexpectedException(t);
1084 >            } catch (Throwable fail) {
1085 >                threadUnexpectedException(fail);
1086                  return null;
1087              }
1088          }
# Line 1090 | Line 1099 | public class JSR166TestCase extends Test
1099                  return result;
1100              } catch (InterruptedException success) {
1101                  threadAssertFalse(Thread.interrupted());
1102 <            } catch (Throwable t) {
1103 <                threadUnexpectedException(t);
1102 >            } catch (Throwable fail) {
1103 >                threadUnexpectedException(fail);
1104              }
1105              return null;
1106          }
# Line 1131 | Line 1140 | public class JSR166TestCase extends Test
1140      public void await(CountDownLatch latch) {
1141          try {
1142              assertTrue(latch.await(LONG_DELAY_MS, MILLISECONDS));
1143 <        } catch (Throwable t) {
1144 <            threadUnexpectedException(t);
1143 >        } catch (Throwable fail) {
1144 >            threadUnexpectedException(fail);
1145          }
1146      }
1147  
1148      public void await(Semaphore semaphore) {
1149          try {
1150              assertTrue(semaphore.tryAcquire(LONG_DELAY_MS, MILLISECONDS));
1151 <        } catch (Throwable t) {
1152 <            threadUnexpectedException(t);
1151 >        } catch (Throwable fail) {
1152 >            threadUnexpectedException(fail);
1153          }
1154      }
1155  
# Line 1334 | Line 1343 | public class JSR166TestCase extends Test
1343          @Override protected final void compute() {
1344              try {
1345                  realCompute();
1346 <            } catch (Throwable t) {
1347 <                threadUnexpectedException(t);
1346 >            } catch (Throwable fail) {
1347 >                threadUnexpectedException(fail);
1348              }
1349          }
1350      }
# Line 1349 | Line 1358 | public class JSR166TestCase extends Test
1358          @Override protected final T compute() {
1359              try {
1360                  return realCompute();
1361 <            } catch (Throwable t) {
1362 <                threadUnexpectedException(t);
1361 >            } catch (Throwable fail) {
1362 >                threadUnexpectedException(fail);
1363                  return null;
1364              }
1365          }
# Line 1374 | Line 1383 | public class JSR166TestCase extends Test
1383          public int await() {
1384              try {
1385                  return super.await(2 * LONG_DELAY_MS, MILLISECONDS);
1386 <            } catch (TimeoutException e) {
1386 >            } catch (TimeoutException timedOut) {
1387                  throw new AssertionFailedError("timed out");
1388 <            } catch (Exception e) {
1388 >            } catch (Exception fail) {
1389                  AssertionFailedError afe =
1390 <                    new AssertionFailedError("Unexpected exception: " + e);
1391 <                afe.initCause(e);
1390 >                    new AssertionFailedError("Unexpected exception: " + fail);
1391 >                afe.initCause(fail);
1392                  throw afe;
1393              }
1394          }
# Line 1407 | Line 1416 | public class JSR166TestCase extends Test
1416                  q.remove();
1417                  shouldThrow();
1418              } catch (NoSuchElementException success) {}
1419 <        } catch (InterruptedException ie) {
1411 <            threadUnexpectedException(ie);
1412 <        }
1419 >        } catch (InterruptedException fail) { threadUnexpectedException(fail); }
1420      }
1421  
1422      void assertSerialEquals(Object x, Object y) {
# Line 1428 | Line 1435 | public class JSR166TestCase extends Test
1435              oos.flush();
1436              oos.close();
1437              return bos.toByteArray();
1438 <        } catch (Throwable t) {
1439 <            threadUnexpectedException(t);
1438 >        } catch (Throwable fail) {
1439 >            threadUnexpectedException(fail);
1440              return new byte[0];
1441          }
1442      }
# Line 1442 | Line 1449 | public class JSR166TestCase extends Test
1449              T clone = (T) ois.readObject();
1450              assertSame(o.getClass(), clone.getClass());
1451              return clone;
1452 <        } catch (Throwable t) {
1453 <            threadUnexpectedException(t);
1452 >        } catch (Throwable fail) {
1453 >            threadUnexpectedException(fail);
1454              return null;
1455          }
1456      }
# Line 1468 | Line 1475 | public class JSR166TestCase extends Test
1475                  shouldThrow(expectedExceptionClass.getName());
1476          }
1477      }
1478 +
1479 +    public void assertIteratorExhausted(Iterator<?> it) {
1480 +        try {
1481 +            it.next();
1482 +            shouldThrow();
1483 +        } catch (NoSuchElementException success) {}
1484 +        assertFalse(it.hasNext());
1485 +    }
1486   }

Diff Legend

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