Parent Directory
| 
Revision Log
Revision 1.25 - (view) (download)
| 1 : | dl | 1.1 | /* |
| 2 : | dl | 1.13 | * Written by Doug Lea with assistance from members of JCP JSR-166 |
| 3 : | * Expert Group and released to the public domain, as explained at | ||
| 4 : | * http://creativecommons.org/licenses/publicdomain | ||
| 5 : | * Other contributors include Andrew Wright, Jeffrey Hayes, | ||
| 6 : | * Pat Fisher, Mike Judd. | ||
| 7 : | dl | 1.1 | */ |
| 8 : | |||
| 9 : | import junit.framework.*; | ||
| 10 : | import java.util.*; | ||
| 11 : | import java.util.concurrent.*; | ||
| 12 : | import java.io.*; | ||
| 13 : | dl | 1.7 | import java.security.*; |
| 14 : | dl | 1.1 | |
| 15 : | /** | ||
| 16 : | dl | 1.5 | * Base class for JSR166 Junit TCK tests. Defines some constants, |
| 17 : | * utility methods and classes, as well as a simple framework for | ||
| 18 : | * helping to make sure that assertions failing in generated threads | ||
| 19 : | * cause the associated test that generated them to itself fail (which | ||
| 20 : | * JUnit doe not otherwise arrange). The rules for creating such | ||
| 21 : | * tests are: | ||
| 22 : | dl | 1.1 | * |
| 23 : | * <ol> | ||
| 24 : | * | ||
| 25 : | * <li> All assertions in code running in generated threads must use | ||
| 26 : | dl | 1.18 | * the forms {@link #threadFail} , {@link #threadAssertTrue} {@link |
| 27 : | * #threadAssertEquals}, or {@link #threadAssertNull}, (not | ||
| 28 : | dl | 1.1 | * <tt>fail</tt>, <tt>assertTrue</tt>, etc.) It is OK (but not |
| 29 : | * particularly recommended) for other code to use these forms too. | ||
| 30 : | * Only the most typically used JUnit assertion methods are defined | ||
| 31 : | * this way, but enough to live with.</li> | ||
| 32 : | * | ||
| 33 : | dl | 1.18 | * <li> If you override {@link #setUp} or {@link #tearDown}, make sure |
| 34 : | dl | 1.1 | * to invoke <tt>super.setUp</tt> and <tt>super.tearDown</tt> within |
| 35 : | * them. These methods are used to clear and check for thread | ||
| 36 : | * assertion failures.</li> | ||
| 37 : | * | ||
| 38 : | dl | 1.6 | * <li>All delays and timeouts must use one of the constants <tt> |
| 39 : | * SHORT_DELAY_MS</tt>, <tt> SMALL_DELAY_MS</tt>, <tt> MEDIUM_DELAY_MS</tt>, | ||
| 40 : | * <tt> LONG_DELAY_MS</tt>. The idea here is that a SHORT is always | ||
| 41 : | dl | 1.5 | * discriminable from zero time, and always allows enough time for the |
| 42 : | * small amounts of computation (creating a thread, calling a few | ||
| 43 : | dl | 1.1 | * methods, etc) needed to reach a timeout point. Similarly, a SMALL |
| 44 : | * is always discriminable as larger than SHORT and smaller than | ||
| 45 : | * MEDIUM. And so on. These constants are set to conservative values, | ||
| 46 : | dl | 1.2 | * but even so, if there is ever any doubt, they can all be increased |
| 47 : | * in one spot to rerun tests on slower platforms</li> | ||
| 48 : | dl | 1.1 | * |
| 49 : | * <li> All threads generated must be joined inside each test case | ||
| 50 : | * method (or <tt>fail</tt> to do so) before returning from the | ||
| 51 : | dl | 1.6 | * method. The <tt> joinPool</tt> method can be used to do this when |
| 52 : | dl | 1.1 | * using Executors.</li> |
| 53 : | * | ||
| 54 : | * </ol> | ||
| 55 : | dl | 1.6 | * |
| 56 : | * <p> <b>Other notes</b> | ||
| 57 : | * <ul> | ||
| 58 : | * | ||
| 59 : | * <li> Usually, there is one testcase method per JSR166 method | ||
| 60 : | * covering "normal" operation, and then as many exception-testing | ||
| 61 : | * methods as there are exceptions the method can throw. Sometimes | ||
| 62 : | * there are multiple tests per JSR166 method when the different | ||
| 63 : | * "normal" behaviors differ significantly. And sometimes testcases | ||
| 64 : | * cover multiple methods when they cannot be tested in | ||
| 65 : | * isolation.</li> | ||
| 66 : | * | ||
| 67 : | * <li> The documentation style for testcases is to provide as javadoc | ||
| 68 : | * a simple sentence or two describing the property that the testcase | ||
| 69 : | * method purports to test. The javadocs do not say anything about how | ||
| 70 : | * the property is tested. To find out, read the code.</li> | ||
| 71 : | * | ||
| 72 : | * <li> These tests are "conformance tests", and do not attempt to | ||
| 73 : | * test throughput, latency, scalability or other performance factors | ||
| 74 : | * (see the separate "jtreg" tests for a set intended to check these | ||
| 75 : | * for the most central aspects of functionality.) So, most tests use | ||
| 76 : | * the smallest sensible numbers of threads, collection sizes, etc | ||
| 77 : | * needed to check basic conformance.</li> | ||
| 78 : | * | ||
| 79 : | * <li>The test classes currently do not declare inclusion in | ||
| 80 : | * any particular package to simplify things for people integrating | ||
| 81 : | * them in TCK test suites.</li> | ||
| 82 : | * | ||
| 83 : | * <li> As a convenience, the <tt>main</tt> of this class (JSR166TestCase) | ||
| 84 : | * runs all JSR166 unit tests.</li> | ||
| 85 : | * | ||
| 86 : | * </ul> | ||
| 87 : | dl | 1.1 | */ |
| 88 : | public class JSR166TestCase extends TestCase { | ||
| 89 : | dl | 1.6 | /** |
| 90 : | * Runs all JSR166 unit tests using junit.textui.TestRunner | ||
| 91 : | */ | ||
| 92 : | public static void main (String[] args) { | ||
| 93 : | dl | 1.16 | int iters = 1; |
| 94 : | if (args.length > 0) | ||
| 95 : | iters = Integer.parseInt(args[0]); | ||
| 96 : | Test s = suite(); | ||
| 97 : | dl | 1.22 | for (int i = 0; i < iters; ++i) { |
| 98 : | dl | 1.16 | junit.textui.TestRunner.run (s); |
| 99 : | dl | 1.22 | System.gc(); |
| 100 : | System.runFinalization(); | ||
| 101 : | } | ||
| 102 : | System.exit(0); | ||
| 103 : | dl | 1.6 | } |
| 104 : | |||
| 105 : | /** | ||
| 106 : | * Collects all JSR166 unit tests as one suite | ||
| 107 : | */ | ||
| 108 : | public static Test suite ( ) { | ||
| 109 : | TestSuite suite = new TestSuite("JSR166 Unit Tests"); | ||
| 110 : | |||
| 111 : | dl | 1.10 | suite.addTest(new TestSuite(AbstractExecutorServiceTest.class)); |
| 112 : | dl | 1.19 | suite.addTest(new TestSuite(AbstractQueueTest.class)); |
| 113 : | dl | 1.14 | suite.addTest(new TestSuite(AbstractQueuedSynchronizerTest.class)); |
| 114 : | dl | 1.25 | suite.addTest(new TestSuite(AbstractQueuedLongSynchronizerTest.class)); |
| 115 : | dl | 1.6 | suite.addTest(new TestSuite(ArrayBlockingQueueTest.class)); |
| 116 : | dl | 1.23 | suite.addTest(new TestSuite(ArrayDequeTest.class)); |
| 117 : | dl | 1.6 | suite.addTest(new TestSuite(AtomicBooleanTest.class)); |
| 118 : | suite.addTest(new TestSuite(AtomicIntegerArrayTest.class)); | ||
| 119 : | suite.addTest(new TestSuite(AtomicIntegerFieldUpdaterTest.class)); | ||
| 120 : | suite.addTest(new TestSuite(AtomicIntegerTest.class)); | ||
| 121 : | suite.addTest(new TestSuite(AtomicLongArrayTest.class)); | ||
| 122 : | suite.addTest(new TestSuite(AtomicLongFieldUpdaterTest.class)); | ||
| 123 : | suite.addTest(new TestSuite(AtomicLongTest.class)); | ||
| 124 : | suite.addTest(new TestSuite(AtomicMarkableReferenceTest.class)); | ||
| 125 : | suite.addTest(new TestSuite(AtomicReferenceArrayTest.class)); | ||
| 126 : | suite.addTest(new TestSuite(AtomicReferenceFieldUpdaterTest.class)); | ||
| 127 : | suite.addTest(new TestSuite(AtomicReferenceTest.class)); | ||
| 128 : | suite.addTest(new TestSuite(AtomicStampedReferenceTest.class)); | ||
| 129 : | suite.addTest(new TestSuite(ConcurrentHashMapTest.class)); | ||
| 130 : | suite.addTest(new TestSuite(ConcurrentLinkedQueueTest.class)); | ||
| 131 : | dl | 1.23 | suite.addTest(new TestSuite(ConcurrentSkipListMapTest.class)); |
| 132 : | suite.addTest(new TestSuite(ConcurrentSkipListSubMapTest.class)); | ||
| 133 : | suite.addTest(new TestSuite(ConcurrentSkipListSetTest.class)); | ||
| 134 : | suite.addTest(new TestSuite(ConcurrentSkipListSubSetTest.class)); | ||
| 135 : | dl | 1.6 | suite.addTest(new TestSuite(CopyOnWriteArrayListTest.class)); |
| 136 : | suite.addTest(new TestSuite(CopyOnWriteArraySetTest.class)); | ||
| 137 : | suite.addTest(new TestSuite(CountDownLatchTest.class)); | ||
| 138 : | suite.addTest(new TestSuite(CyclicBarrierTest.class)); | ||
| 139 : | suite.addTest(new TestSuite(DelayQueueTest.class)); | ||
| 140 : | suite.addTest(new TestSuite(ExchangerTest.class)); | ||
| 141 : | suite.addTest(new TestSuite(ExecutorsTest.class)); | ||
| 142 : | dl | 1.11 | suite.addTest(new TestSuite(ExecutorCompletionServiceTest.class)); |
| 143 : | dl | 1.6 | suite.addTest(new TestSuite(FutureTaskTest.class)); |
| 144 : | dl | 1.23 | suite.addTest(new TestSuite(LinkedBlockingDequeTest.class)); |
| 145 : | dl | 1.6 | suite.addTest(new TestSuite(LinkedBlockingQueueTest.class)); |
| 146 : | suite.addTest(new TestSuite(LinkedListTest.class)); | ||
| 147 : | suite.addTest(new TestSuite(LockSupportTest.class)); | ||
| 148 : | suite.addTest(new TestSuite(PriorityBlockingQueueTest.class)); | ||
| 149 : | suite.addTest(new TestSuite(PriorityQueueTest.class)); | ||
| 150 : | suite.addTest(new TestSuite(ReentrantLockTest.class)); | ||
| 151 : | suite.addTest(new TestSuite(ReentrantReadWriteLockTest.class)); | ||
| 152 : | suite.addTest(new TestSuite(ScheduledExecutorTest.class)); | ||
| 153 : | suite.addTest(new TestSuite(SemaphoreTest.class)); | ||
| 154 : | suite.addTest(new TestSuite(SynchronousQueueTest.class)); | ||
| 155 : | suite.addTest(new TestSuite(SystemTest.class)); | ||
| 156 : | suite.addTest(new TestSuite(ThreadLocalTest.class)); | ||
| 157 : | suite.addTest(new TestSuite(ThreadPoolExecutorTest.class)); | ||
| 158 : | suite.addTest(new TestSuite(ThreadTest.class)); | ||
| 159 : | dl | 1.24 | suite.addTest(new TestSuite(TimeUnitTest.class)); |
| 160 : | dl | 1.23 | suite.addTest(new TestSuite(TreeMapTest.class)); |
| 161 : | suite.addTest(new TestSuite(TreeSetTest.class)); | ||
| 162 : | dl | 1.6 | |
| 163 : | return suite; | ||
| 164 : | } | ||
| 165 : | |||
| 166 : | dl | 1.1 | |
| 167 : | dl | 1.2 | public static long SHORT_DELAY_MS; |
| 168 : | public static long SMALL_DELAY_MS; | ||
| 169 : | public static long MEDIUM_DELAY_MS; | ||
| 170 : | public static long LONG_DELAY_MS; | ||
| 171 : | |||
| 172 : | |||
| 173 : | /** | ||
| 174 : | * Return the shortest timed delay. This could | ||
| 175 : | dl | 1.15 | * be reimplemented to use for example a Property. |
| 176 : | dl | 1.2 | */ |
| 177 : | protected long getShortDelay() { | ||
| 178 : | dl | 1.21 | return 50; |
| 179 : | dl | 1.2 | } |
| 180 : | |||
| 181 : | |||
| 182 : | /** | ||
| 183 : | dl | 1.5 | * Set delays as multiples of SHORT_DELAY. |
| 184 : | dl | 1.2 | */ |
| 185 : | protected void setDelays() { | ||
| 186 : | SHORT_DELAY_MS = getShortDelay(); | ||
| 187 : | SMALL_DELAY_MS = SHORT_DELAY_MS * 5; | ||
| 188 : | MEDIUM_DELAY_MS = SHORT_DELAY_MS * 10; | ||
| 189 : | LONG_DELAY_MS = SHORT_DELAY_MS * 50; | ||
| 190 : | } | ||
| 191 : | |||
| 192 : | dl | 1.1 | /** |
| 193 : | * Flag set true if any threadAssert methods fail | ||
| 194 : | */ | ||
| 195 : | dl | 1.5 | volatile boolean threadFailed; |
| 196 : | dl | 1.1 | |
| 197 : | /** | ||
| 198 : | dl | 1.4 | * Initialize test to indicate that no thread assertions have failed |
| 199 : | dl | 1.1 | */ |
| 200 : | public void setUp() { | ||
| 201 : | dl | 1.2 | setDelays(); |
| 202 : | dl | 1.1 | threadFailed = false; |
| 203 : | } | ||
| 204 : | |||
| 205 : | /** | ||
| 206 : | * Trigger test case failure if any thread assertions have failed | ||
| 207 : | */ | ||
| 208 : | public void tearDown() { | ||
| 209 : | assertFalse(threadFailed); | ||
| 210 : | } | ||
| 211 : | |||
| 212 : | dl | 1.5 | /** |
| 213 : | * Fail, also setting status to indicate current testcase should fail | ||
| 214 : | */ | ||
| 215 : | dl | 1.1 | public void threadFail(String reason) { |
| 216 : | threadFailed = true; | ||
| 217 : | fail(reason); | ||
| 218 : | } | ||
| 219 : | |||
| 220 : | dl | 1.5 | /** |
| 221 : | * If expression not true, set status to indicate current testcase | ||
| 222 : | * should fail | ||
| 223 : | */ | ||
| 224 : | dl | 1.1 | public void threadAssertTrue(boolean b) { |
| 225 : | if (!b) { | ||
| 226 : | threadFailed = true; | ||
| 227 : | assertTrue(b); | ||
| 228 : | } | ||
| 229 : | } | ||
| 230 : | dl | 1.5 | |
| 231 : | /** | ||
| 232 : | * If expression not false, set status to indicate current testcase | ||
| 233 : | * should fail | ||
| 234 : | */ | ||
| 235 : | dl | 1.1 | public void threadAssertFalse(boolean b) { |
| 236 : | if (b) { | ||
| 237 : | threadFailed = true; | ||
| 238 : | assertFalse(b); | ||
| 239 : | } | ||
| 240 : | } | ||
| 241 : | dl | 1.5 | |
| 242 : | /** | ||
| 243 : | * If argument not null, set status to indicate current testcase | ||
| 244 : | * should fail | ||
| 245 : | */ | ||
| 246 : | dl | 1.1 | public void threadAssertNull(Object x) { |
| 247 : | if (x != null) { | ||
| 248 : | threadFailed = true; | ||
| 249 : | assertNull(x); | ||
| 250 : | } | ||
| 251 : | } | ||
| 252 : | dl | 1.5 | |
| 253 : | /** | ||
| 254 : | * If arguments not equal, set status to indicate current testcase | ||
| 255 : | * should fail | ||
| 256 : | */ | ||
| 257 : | dl | 1.1 | public void threadAssertEquals(long x, long y) { |
| 258 : | if (x != y) { | ||
| 259 : | threadFailed = true; | ||
| 260 : | assertEquals(x, y); | ||
| 261 : | } | ||
| 262 : | } | ||
| 263 : | dl | 1.5 | |
| 264 : | /** | ||
| 265 : | * If arguments not equal, set status to indicate current testcase | ||
| 266 : | * should fail | ||
| 267 : | */ | ||
| 268 : | dl | 1.1 | public void threadAssertEquals(Object x, Object y) { |
| 269 : | if (x != y && (x == null || !x.equals(y))) { | ||
| 270 : | threadFailed = true; | ||
| 271 : | assertEquals(x, y); | ||
| 272 : | } | ||
| 273 : | } | ||
| 274 : | |||
| 275 : | dl | 1.5 | /** |
| 276 : | * threadFail with message "should throw exception" | ||
| 277 : | */ | ||
| 278 : | dl | 1.3 | public void threadShouldThrow() { |
| 279 : | threadFailed = true; | ||
| 280 : | fail("should throw exception"); | ||
| 281 : | } | ||
| 282 : | |||
| 283 : | dl | 1.5 | /** |
| 284 : | * threadFail with message "Unexpected exception" | ||
| 285 : | */ | ||
| 286 : | dl | 1.3 | public void threadUnexpectedException() { |
| 287 : | threadFailed = true; | ||
| 288 : | fail("Unexpected exception"); | ||
| 289 : | } | ||
| 290 : | |||
| 291 : | |||
| 292 : | dl | 1.1 | /** |
| 293 : | * Wait out termination of a thread pool or fail doing so | ||
| 294 : | */ | ||
| 295 : | public void joinPool(ExecutorService exec) { | ||
| 296 : | try { | ||
| 297 : | exec.shutdown(); | ||
| 298 : | assertTrue(exec.awaitTermination(LONG_DELAY_MS, TimeUnit.MILLISECONDS)); | ||
| 299 : | dl | 1.22 | } catch(SecurityException ok) { |
| 300 : | // Allowed in case test doesn't have privs | ||
| 301 : | dl | 1.1 | } catch(InterruptedException ie) { |
| 302 : | dl | 1.3 | fail("Unexpected exception"); |
| 303 : | dl | 1.1 | } |
| 304 : | } | ||
| 305 : | |||
| 306 : | dl | 1.5 | |
| 307 : | /** | ||
| 308 : | * fail with message "should throw exception" | ||
| 309 : | */ | ||
| 310 : | dl | 1.3 | public void shouldThrow() { |
| 311 : | fail("Should throw exception"); | ||
| 312 : | } | ||
| 313 : | |||
| 314 : | dl | 1.5 | /** |
| 315 : | * fail with message "Unexpected exception" | ||
| 316 : | */ | ||
| 317 : | dl | 1.3 | public void unexpectedException() { |
| 318 : | fail("Unexpected exception"); | ||
| 319 : | } | ||
| 320 : | dl | 1.1 | |
| 321 : | |||
| 322 : | /** | ||
| 323 : | * The number of elements to place in collections, arrays, etc. | ||
| 324 : | */ | ||
| 325 : | dl | 1.5 | static final int SIZE = 20; |
| 326 : | dl | 1.1 | |
| 327 : | // Some convenient Integer constants | ||
| 328 : | |||
| 329 : | dl | 1.5 | static final Integer zero = new Integer(0); |
| 330 : | static final Integer one = new Integer(1); | ||
| 331 : | static final Integer two = new Integer(2); | ||
| 332 : | static final Integer three = new Integer(3); | ||
| 333 : | static final Integer four = new Integer(4); | ||
| 334 : | static final Integer five = new Integer(5); | ||
| 335 : | static final Integer six = new Integer(6); | ||
| 336 : | static final Integer seven = new Integer(7); | ||
| 337 : | static final Integer eight = new Integer(8); | ||
| 338 : | static final Integer nine = new Integer(9); | ||
| 339 : | static final Integer m1 = new Integer(-1); | ||
| 340 : | static final Integer m2 = new Integer(-2); | ||
| 341 : | static final Integer m3 = new Integer(-3); | ||
| 342 : | static final Integer m4 = new Integer(-4); | ||
| 343 : | static final Integer m5 = new Integer(-5); | ||
| 344 : | static final Integer m10 = new Integer(-10); | ||
| 345 : | dl | 1.7 | |
| 346 : | |||
| 347 : | /** | ||
| 348 : | * A security policy where new permissions can be dynamically added | ||
| 349 : | * or all cleared. | ||
| 350 : | */ | ||
| 351 : | static class AdjustablePolicy extends java.security.Policy { | ||
| 352 : | Permissions perms = new Permissions(); | ||
| 353 : | AdjustablePolicy() { } | ||
| 354 : | void addPermission(Permission perm) { perms.add(perm); } | ||
| 355 : | void clearPermissions() { perms = new Permissions(); } | ||
| 356 : | public PermissionCollection getPermissions(CodeSource cs) { | ||
| 357 : | return perms; | ||
| 358 : | } | ||
| 359 : | public PermissionCollection getPermissions(ProtectionDomain pd) { | ||
| 360 : | return perms; | ||
| 361 : | } | ||
| 362 : | public boolean implies(ProtectionDomain pd, Permission p) { | ||
| 363 : | return perms.implies(p); | ||
| 364 : | } | ||
| 365 : | public void refresh() {} | ||
| 366 : | } | ||
| 367 : | dl | 1.1 | |
| 368 : | |||
| 369 : | // Some convenient Runnable classes | ||
| 370 : | |||
| 371 : | dl | 1.5 | static class NoOpRunnable implements Runnable { |
| 372 : | dl | 1.1 | public void run() {} |
| 373 : | } | ||
| 374 : | |||
| 375 : | dl | 1.5 | static class NoOpCallable implements Callable { |
| 376 : | dl | 1.1 | public Object call() { return Boolean.TRUE; } |
| 377 : | dl | 1.10 | } |
| 378 : | |||
| 379 : | static final String TEST_STRING = "a test string"; | ||
| 380 : | |||
| 381 : | static class StringTask implements Callable<String> { | ||
| 382 : | public String call() { return TEST_STRING; } | ||
| 383 : | } | ||
| 384 : | |||
| 385 : | static class NPETask implements Callable<String> { | ||
| 386 : | public String call() { throw new NullPointerException(); } | ||
| 387 : | } | ||
| 388 : | |||
| 389 : | static class CallableOne implements Callable<Integer> { | ||
| 390 : | public Integer call() { return one; } | ||
| 391 : | dl | 1.1 | } |
| 392 : | |||
| 393 : | dl | 1.5 | class ShortRunnable implements Runnable { |
| 394 : | dl | 1.1 | public void run() { |
| 395 : | try { | ||
| 396 : | Thread.sleep(SHORT_DELAY_MS); | ||
| 397 : | } | ||
| 398 : | catch(Exception e) { | ||
| 399 : | dl | 1.3 | threadUnexpectedException(); |
| 400 : | dl | 1.1 | } |
| 401 : | } | ||
| 402 : | } | ||
| 403 : | |||
| 404 : | dl | 1.5 | class ShortInterruptedRunnable implements Runnable { |
| 405 : | dl | 1.1 | public void run() { |
| 406 : | try { | ||
| 407 : | Thread.sleep(SHORT_DELAY_MS); | ||
| 408 : | dl | 1.3 | threadShouldThrow(); |
| 409 : | dl | 1.1 | } |
| 410 : | catch(InterruptedException success) { | ||
| 411 : | } | ||
| 412 : | } | ||
| 413 : | } | ||
| 414 : | |||
| 415 : | dl | 1.5 | class SmallRunnable implements Runnable { |
| 416 : | dl | 1.1 | public void run() { |
| 417 : | try { | ||
| 418 : | Thread.sleep(SMALL_DELAY_MS); | ||
| 419 : | } | ||
| 420 : | catch(Exception e) { | ||
| 421 : | dl | 1.3 | threadUnexpectedException(); |
| 422 : | dl | 1.1 | } |
| 423 : | } | ||
| 424 : | } | ||
| 425 : | |||
| 426 : | dl | 1.6 | class SmallPossiblyInterruptedRunnable implements Runnable { |
| 427 : | public void run() { | ||
| 428 : | try { | ||
| 429 : | Thread.sleep(SMALL_DELAY_MS); | ||
| 430 : | } | ||
| 431 : | catch(Exception e) { | ||
| 432 : | } | ||
| 433 : | } | ||
| 434 : | } | ||
| 435 : | |||
| 436 : | dl | 1.5 | class SmallCallable implements Callable { |
| 437 : | dl | 1.1 | public Object call() { |
| 438 : | try { | ||
| 439 : | Thread.sleep(SMALL_DELAY_MS); | ||
| 440 : | } | ||
| 441 : | catch(Exception e) { | ||
| 442 : | dl | 1.3 | threadUnexpectedException(); |
| 443 : | dl | 1.1 | } |
| 444 : | return Boolean.TRUE; | ||
| 445 : | } | ||
| 446 : | } | ||
| 447 : | |||
| 448 : | dl | 1.5 | class SmallInterruptedRunnable implements Runnable { |
| 449 : | dl | 1.1 | public void run() { |
| 450 : | try { | ||
| 451 : | Thread.sleep(SMALL_DELAY_MS); | ||
| 452 : | dl | 1.3 | threadShouldThrow(); |
| 453 : | dl | 1.1 | } |
| 454 : | catch(InterruptedException success) { | ||
| 455 : | } | ||
| 456 : | } | ||
| 457 : | } | ||
| 458 : | |||
| 459 : | |||
| 460 : | dl | 1.5 | class MediumRunnable implements Runnable { |
| 461 : | dl | 1.1 | public void run() { |
| 462 : | try { | ||
| 463 : | Thread.sleep(MEDIUM_DELAY_MS); | ||
| 464 : | } | ||
| 465 : | catch(Exception e) { | ||
| 466 : | dl | 1.3 | threadUnexpectedException(); |
| 467 : | dl | 1.1 | } |
| 468 : | } | ||
| 469 : | } | ||
| 470 : | |||
| 471 : | dl | 1.5 | class MediumInterruptedRunnable implements Runnable { |
| 472 : | dl | 1.1 | public void run() { |
| 473 : | try { | ||
| 474 : | Thread.sleep(MEDIUM_DELAY_MS); | ||
| 475 : | dl | 1.3 | threadShouldThrow(); |
| 476 : | dl | 1.1 | } |
| 477 : | catch(InterruptedException success) { | ||
| 478 : | } | ||
| 479 : | } | ||
| 480 : | } | ||
| 481 : | |||
| 482 : | dl | 1.5 | class MediumPossiblyInterruptedRunnable implements Runnable { |
| 483 : | dl | 1.1 | public void run() { |
| 484 : | try { | ||
| 485 : | Thread.sleep(MEDIUM_DELAY_MS); | ||
| 486 : | } | ||
| 487 : | catch(InterruptedException success) { | ||
| 488 : | } | ||
| 489 : | } | ||
| 490 : | } | ||
| 491 : | dl | 1.5 | |
| 492 : | dl | 1.12 | class LongPossiblyInterruptedRunnable implements Runnable { |
| 493 : | public void run() { | ||
| 494 : | try { | ||
| 495 : | Thread.sleep(LONG_DELAY_MS); | ||
| 496 : | } | ||
| 497 : | catch(InterruptedException success) { | ||
| 498 : | } | ||
| 499 : | } | ||
| 500 : | } | ||
| 501 : | |||
| 502 : | dl | 1.5 | /** |
| 503 : | * For use as ThreadFactory in constructors | ||
| 504 : | */ | ||
| 505 : | static class SimpleThreadFactory implements ThreadFactory{ | ||
| 506 : | public Thread newThread(Runnable r){ | ||
| 507 : | return new Thread(r); | ||
| 508 : | } | ||
| 509 : | } | ||
| 510 : | |||
| 511 : | dl | 1.6 | static class TrackedShortRunnable implements Runnable { |
| 512 : | dl | 1.5 | volatile boolean done = false; |
| 513 : | public void run() { | ||
| 514 : | try { | ||
| 515 : | Thread.sleep(SMALL_DELAY_MS); | ||
| 516 : | done = true; | ||
| 517 : | } catch(Exception e){ | ||
| 518 : | } | ||
| 519 : | dl | 1.6 | } |
| 520 : | } | ||
| 521 : | |||
| 522 : | static class TrackedMediumRunnable implements Runnable { | ||
| 523 : | volatile boolean done = false; | ||
| 524 : | public void run() { | ||
| 525 : | try { | ||
| 526 : | Thread.sleep(MEDIUM_DELAY_MS); | ||
| 527 : | done = true; | ||
| 528 : | } catch(Exception e){ | ||
| 529 : | } | ||
| 530 : | } | ||
| 531 : | } | ||
| 532 : | |||
| 533 : | static class TrackedLongRunnable implements Runnable { | ||
| 534 : | volatile boolean done = false; | ||
| 535 : | public void run() { | ||
| 536 : | try { | ||
| 537 : | Thread.sleep(LONG_DELAY_MS); | ||
| 538 : | done = true; | ||
| 539 : | } catch(Exception e){ | ||
| 540 : | } | ||
| 541 : | } | ||
| 542 : | } | ||
| 543 : | |||
| 544 : | static class TrackedNoOpRunnable implements Runnable { | ||
| 545 : | volatile boolean done = false; | ||
| 546 : | public void run() { | ||
| 547 : | done = true; | ||
| 548 : | dl | 1.5 | } |
| 549 : | } | ||
| 550 : | |||
| 551 : | static class TrackedCallable implements Callable { | ||
| 552 : | volatile boolean done = false; | ||
| 553 : | public Object call() { | ||
| 554 : | try { | ||
| 555 : | Thread.sleep(SMALL_DELAY_MS); | ||
| 556 : | done = true; | ||
| 557 : | } catch(Exception e){ | ||
| 558 : | } | ||
| 559 : | return Boolean.TRUE; | ||
| 560 : | } | ||
| 561 : | } | ||
| 562 : | dl | 1.14 | |
| 563 : | dl | 1.5 | |
| 564 : | /** | ||
| 565 : | * For use as RejectedExecutionHandler in constructors | ||
| 566 : | */ | ||
| 567 : | static class NoOpREHandler implements RejectedExecutionHandler{ | ||
| 568 : | public void rejectedExecution(Runnable r, ThreadPoolExecutor executor){} | ||
| 569 : | } | ||
| 570 : | |||
| 571 : | dl | 1.1 | |
| 572 : | } |
| Doug Lea | ViewVC Help |
| Powered by ViewVC 1.0.8 |