73 |
|
public void run() { |
74 |
|
try { |
75 |
|
sync.acquireInterruptibly(1); |
76 |
< |
} catch (InterruptedException success){} |
76 |
> |
} catch (InterruptedException success) {} |
77 |
|
} |
78 |
|
} |
79 |
|
|
89 |
|
try { |
90 |
|
sync.acquireInterruptibly(1); |
91 |
|
threadShouldThrow(); |
92 |
< |
} catch (InterruptedException success){} |
92 |
> |
} catch (InterruptedException success) {} |
93 |
|
} |
94 |
|
} |
95 |
|
|
146 |
|
assertFalse(sync.hasQueuedThreads()); |
147 |
|
t1.join(); |
148 |
|
t2.join(); |
149 |
< |
} catch (Exception e){ |
149 |
> |
} catch (Exception e) { |
150 |
|
unexpectedException(); |
151 |
|
} |
152 |
|
} |
192 |
|
assertFalse(sync.isQueued(t2)); |
193 |
|
t1.join(); |
194 |
|
t2.join(); |
195 |
< |
} catch (Exception e){ |
195 |
> |
} catch (Exception e) { |
196 |
|
unexpectedException(); |
197 |
|
} |
198 |
|
} |
222 |
|
assertNull(sync.getFirstQueuedThread()); |
223 |
|
t1.join(); |
224 |
|
t2.join(); |
225 |
< |
} catch (Exception e){ |
225 |
> |
} catch (Exception e) { |
226 |
|
unexpectedException(); |
227 |
|
} |
228 |
|
} |
252 |
|
assertTrue(sync.hasContended()); |
253 |
|
t1.join(); |
254 |
|
t2.join(); |
255 |
< |
} catch (Exception e){ |
255 |
> |
} catch (Exception e) { |
256 |
|
unexpectedException(); |
257 |
|
} |
258 |
|
} |
284 |
|
assertTrue(sync.getQueuedThreads().isEmpty()); |
285 |
|
t1.join(); |
286 |
|
t2.join(); |
287 |
< |
} catch (Exception e){ |
287 |
> |
} catch (Exception e) { |
288 |
|
unexpectedException(); |
289 |
|
} |
290 |
|
} |
316 |
|
assertTrue(sync.getExclusiveQueuedThreads().isEmpty()); |
317 |
|
t1.join(); |
318 |
|
t2.join(); |
319 |
< |
} catch (Exception e){ |
319 |
> |
} catch (Exception e) { |
320 |
|
unexpectedException(); |
321 |
|
} |
322 |
|
} |
346 |
|
assertTrue(sync.getSharedQueuedThreads().isEmpty()); |
347 |
|
t1.join(); |
348 |
|
t2.join(); |
349 |
< |
} catch (Exception e){ |
349 |
> |
} catch (Exception e) { |
350 |
|
unexpectedException(); |
351 |
|
} |
352 |
|
} |
362 |
|
try { |
363 |
|
sync.tryAcquireNanos(1, MEDIUM_DELAY_MS * 1000 * 1000); |
364 |
|
threadShouldThrow(); |
365 |
< |
} catch (InterruptedException success){} |
365 |
> |
} catch (InterruptedException success) {} |
366 |
|
} |
367 |
|
}); |
368 |
|
try { |
369 |
|
t.start(); |
370 |
|
t.interrupt(); |
371 |
< |
} catch (Exception e){ |
371 |
> |
} catch (Exception e) { |
372 |
|
unexpectedException(); |
373 |
|
} |
374 |
|
} |
389 |
|
t.start(); |
390 |
|
t.join(); |
391 |
|
sync.release(1); |
392 |
< |
} catch (Exception e){ |
392 |
> |
} catch (Exception e) { |
393 |
|
unexpectedException(); |
394 |
|
} |
395 |
|
} |
413 |
|
t.start(); |
414 |
|
t.join(); |
415 |
|
sync.release(1); |
416 |
< |
} catch (Exception e){ |
416 |
> |
} catch (Exception e) { |
417 |
|
unexpectedException(); |
418 |
|
} |
419 |
|
} |
446 |
|
assertTrue(sync.isHeldExclusively()); |
447 |
|
t.join(); |
448 |
|
assertFalse(sync.isHeldExclusively()); |
449 |
< |
} catch (Exception e){ |
449 |
> |
} catch (Exception e) { |
450 |
|
unexpectedException(); |
451 |
|
} |
452 |
|
} |
466 |
|
Thread.sleep(SHORT_DELAY_MS); |
467 |
|
sync.release(1); |
468 |
|
t.join(); |
469 |
< |
} catch (Exception e){ |
469 |
> |
} catch (Exception e) { |
470 |
|
unexpectedException(); |
471 |
|
} |
472 |
|
} |
487 |
|
t.interrupt(); |
488 |
|
assertTrue(sync.isHeldExclusively()); |
489 |
|
t.join(); |
490 |
< |
} catch (Exception e){ |
490 |
> |
} catch (Exception e) { |
491 |
|
unexpectedException(); |
492 |
|
} |
493 |
|
} |
671 |
|
*/ |
672 |
|
public void testHasWaitersIAE() { |
673 |
|
final Mutex sync = new Mutex(); |
674 |
< |
final AbstractQueuedSynchronizer.ConditionObject c = (sync.newCondition()); |
674 |
> |
final AbstractQueuedSynchronizer.ConditionObject c = sync.newCondition(); |
675 |
|
final Mutex sync2 = new Mutex(); |
676 |
|
try { |
677 |
|
sync2.hasWaiters(c); |
687 |
|
*/ |
688 |
|
public void testHasWaitersIMSE() { |
689 |
|
final Mutex sync = new Mutex(); |
690 |
< |
final AbstractQueuedSynchronizer.ConditionObject c = (sync.newCondition()); |
690 |
> |
final AbstractQueuedSynchronizer.ConditionObject c = sync.newCondition(); |
691 |
|
try { |
692 |
|
sync.hasWaiters(c); |
693 |
|
shouldThrow(); |
703 |
|
*/ |
704 |
|
public void testGetWaitQueueLengthIAE() { |
705 |
|
final Mutex sync = new Mutex(); |
706 |
< |
final AbstractQueuedSynchronizer.ConditionObject c = (sync.newCondition()); |
706 |
> |
final AbstractQueuedSynchronizer.ConditionObject c = sync.newCondition(); |
707 |
|
final Mutex sync2 = new Mutex(); |
708 |
|
try { |
709 |
|
sync2.getWaitQueueLength(c); |
719 |
|
*/ |
720 |
|
public void testGetWaitQueueLengthIMSE() { |
721 |
|
final Mutex sync = new Mutex(); |
722 |
< |
final AbstractQueuedSynchronizer.ConditionObject c = (sync.newCondition()); |
722 |
> |
final AbstractQueuedSynchronizer.ConditionObject c = sync.newCondition(); |
723 |
|
try { |
724 |
|
sync.getWaitQueueLength(c); |
725 |
|
shouldThrow(); |
735 |
|
*/ |
736 |
|
public void testGetWaitingThreadsIAE() { |
737 |
|
final Mutex sync = new Mutex(); |
738 |
< |
final AbstractQueuedSynchronizer.ConditionObject c = (sync.newCondition()); |
738 |
> |
final AbstractQueuedSynchronizer.ConditionObject c = sync.newCondition(); |
739 |
|
final Mutex sync2 = new Mutex(); |
740 |
|
try { |
741 |
|
sync2.getWaitingThreads(c); |
751 |
|
*/ |
752 |
|
public void testGetWaitingThreadsIMSE() { |
753 |
|
final Mutex sync = new Mutex(); |
754 |
< |
final AbstractQueuedSynchronizer.ConditionObject c = (sync.newCondition()); |
754 |
> |
final AbstractQueuedSynchronizer.ConditionObject c = sync.newCondition(); |
755 |
|
try { |
756 |
|
sync.getWaitingThreads(c); |
757 |
|
shouldThrow(); |
1134 |
|
ObjectInputStream in = new ObjectInputStream(new BufferedInputStream(bin)); |
1135 |
|
Mutex r = (Mutex) in.readObject(); |
1136 |
|
assertTrue(r.isHeldExclusively()); |
1137 |
< |
} catch (Exception e){ |
1137 |
> |
} catch (Exception e) { |
1138 |
|
e.printStackTrace(); |
1139 |
|
unexpectedException(); |
1140 |
|
} |
1175 |
|
threadAssertFalse(l.isSignalled()); |
1176 |
|
l.acquireSharedInterruptibly(0); |
1177 |
|
threadAssertTrue(l.isSignalled()); |
1178 |
< |
} catch (InterruptedException e){ |
1178 |
> |
} catch (InterruptedException e) { |
1179 |
|
threadUnexpectedException(); |
1180 |
|
} |
1181 |
|
} |
1187 |
|
l.releaseShared(0); |
1188 |
|
assertTrue(l.isSignalled()); |
1189 |
|
t.join(); |
1190 |
< |
} catch (InterruptedException e){ |
1190 |
> |
} catch (InterruptedException e) { |
1191 |
|
unexpectedException(); |
1192 |
|
} |
1193 |
|
} |
1206 |
|
threadAssertTrue(l.tryAcquireSharedNanos(0, MEDIUM_DELAY_MS* 1000 * 1000)); |
1207 |
|
threadAssertTrue(l.isSignalled()); |
1208 |
|
|
1209 |
< |
} catch (InterruptedException e){ |
1209 |
> |
} catch (InterruptedException e) { |
1210 |
|
threadUnexpectedException(); |
1211 |
|
} |
1212 |
|
} |
1218 |
|
l.releaseShared(0); |
1219 |
|
assertTrue(l.isSignalled()); |
1220 |
|
t.join(); |
1221 |
< |
} catch (InterruptedException e){ |
1221 |
> |
} catch (InterruptedException e) { |
1222 |
|
unexpectedException(); |
1223 |
|
} |
1224 |
|
} |
1234 |
|
threadAssertFalse(l.isSignalled()); |
1235 |
|
l.acquireSharedInterruptibly(0); |
1236 |
|
threadShouldThrow(); |
1237 |
< |
} catch (InterruptedException success){} |
1237 |
> |
} catch (InterruptedException success) {} |
1238 |
|
} |
1239 |
|
}); |
1240 |
|
t.start(); |
1242 |
|
assertFalse(l.isSignalled()); |
1243 |
|
t.interrupt(); |
1244 |
|
t.join(); |
1245 |
< |
} catch (InterruptedException e){ |
1245 |
> |
} catch (InterruptedException e) { |
1246 |
|
unexpectedException(); |
1247 |
|
} |
1248 |
|
} |
1258 |
|
threadAssertFalse(l.isSignalled()); |
1259 |
|
l.tryAcquireSharedNanos(0, SMALL_DELAY_MS* 1000 * 1000); |
1260 |
|
threadShouldThrow(); |
1261 |
< |
} catch (InterruptedException success){} |
1261 |
> |
} catch (InterruptedException success) {} |
1262 |
|
} |
1263 |
|
}); |
1264 |
|
t.start(); |
1267 |
|
assertFalse(l.isSignalled()); |
1268 |
|
t.interrupt(); |
1269 |
|
t.join(); |
1270 |
< |
} catch (InterruptedException e){ |
1270 |
> |
} catch (InterruptedException e) { |
1271 |
|
unexpectedException(); |
1272 |
|
} |
1273 |
|
} |
1282 |
|
try { |
1283 |
|
threadAssertFalse(l.isSignalled()); |
1284 |
|
threadAssertFalse(l.tryAcquireSharedNanos(0, SMALL_DELAY_MS* 1000 * 1000)); |
1285 |
< |
} catch (InterruptedException ie){ |
1285 |
> |
} catch (InterruptedException ie) { |
1286 |
|
threadUnexpectedException(); |
1287 |
|
} |
1288 |
|
} |
1292 |
|
Thread.sleep(SHORT_DELAY_MS); |
1293 |
|
assertFalse(l.isSignalled()); |
1294 |
|
t.join(); |
1295 |
< |
} catch (InterruptedException e){ |
1295 |
> |
} catch (InterruptedException e) { |
1296 |
|
unexpectedException(); |
1297 |
|
} |
1298 |
|
} |