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

Comparing jsr166/src/test/tck/AbstractQueuedSynchronizerTest.java (file contents):
Revision 1.59 by jsr166, Mon Nov 27 03:25:42 2017 UTC vs.
Revision 1.67 by jsr166, Tue Aug 13 03:39:46 2019 UTC

# Line 13 | Line 13 | import java.util.ArrayList;
13   import java.util.Arrays;
14   import java.util.Collection;
15   import java.util.HashSet;
16 + import java.util.concurrent.ThreadLocalRandom;
17   import java.util.concurrent.locks.AbstractQueuedSynchronizer;
18   import java.util.concurrent.locks.AbstractQueuedSynchronizer.ConditionObject;
19  
19 – import junit.framework.AssertionFailedError;
20   import junit.framework.Test;
21   import junit.framework.TestSuite;
22  
# Line 144 | Line 144 | public class AbstractQueuedSynchronizerT
144          long startTime = System.nanoTime();
145          while (!sync.isQueued(t)) {
146              if (millisElapsedSince(startTime) > LONG_DELAY_MS)
147 <                throw new AssertionFailedError("timed out");
147 >                throw new AssertionError("timed out");
148              Thread.yield();
149          }
150          assertTrue(t.isAlive());
# Line 228 | Line 228 | public class AbstractQueuedSynchronizerT
228              assertTrue(c.await(timeoutMillis, MILLISECONDS));
229              break;
230          case awaitNanos:
231 <            long nanosTimeout = MILLISECONDS.toNanos(timeoutMillis);
232 <            long nanosRemaining = c.awaitNanos(nanosTimeout);
231 >            long timeoutNanos = MILLISECONDS.toNanos(timeoutMillis);
232 >            long nanosRemaining = c.awaitNanos(timeoutNanos);
233              assertTrue(nanosRemaining > 0);
234              break;
235          case awaitUntil:
# Line 256 | Line 256 | public class AbstractQueuedSynchronizerT
256                  break;
257              case awaitNanos:
258                  startTime = System.nanoTime();
259 <                long nanosTimeout = MILLISECONDS.toNanos(timeoutMillis);
260 <                long nanosRemaining = c.awaitNanos(nanosTimeout);
259 >                long timeoutNanos = MILLISECONDS.toNanos(timeoutMillis);
260 >                long nanosRemaining = c.awaitNanos(timeoutNanos);
261                  assertTrue(nanosRemaining <= 0);
262                  assertTrue(nanosRemaining > -MILLISECONDS.toNanos(LONG_DELAY_MS));
263                  assertTrue(millisElapsedSince(startTime) >= timeoutMillis);
# Line 1261 | Line 1261 | public class AbstractQueuedSynchronizerT
1261      }
1262  
1263      /**
1264 –     * Disabled demo test for (unfixed as of 2017-11)
1264       * JDK-8191483: AbstractQueuedSynchronizer cancel/cancel race
1265       * ant -Djsr166.tckTestClass=AbstractQueuedSynchronizerTest -Djsr166.methodFilter=testCancelCancelRace -Djsr166.runsPerTest=100 tck
1266       */
1267 <    public void XXXXtestCancelCancelRace() throws InterruptedException {
1267 >    public void testCancelCancelRace() throws InterruptedException {
1268          class Sync extends AbstractQueuedSynchronizer {
1269 <            private static final long serialVersionUID = 1L;
1271 <
1272 <            public boolean tryAcquire(int acquires) {
1269 >            protected boolean tryAcquire(int acquires) {
1270                  return !hasQueuedPredecessors() && compareAndSetState(0, 1);
1271              }
1275 –
1272              protected boolean tryRelease(int releases) {
1273                  return compareAndSetState(1, 0);
1274              }
# Line 1282 | Line 1278 | public class AbstractQueuedSynchronizerT
1278          s.acquire(1);           // acquire to force other threads to enqueue
1279  
1280          // try to trigger double cancel race with two background threads
1281 <        ArrayList<Thread> ts = new ArrayList<>();
1281 >        ArrayList<Thread> threads = new ArrayList<>();
1282          Runnable failedAcquire = () -> {
1283              try {
1284                  s.acquireInterruptibly(1);
1285 <                throw new AssertionError();
1286 <            } catch (InterruptedException expected) {}
1285 >                shouldThrow();
1286 >            } catch (InterruptedException success) {}
1287          };
1288          for (int i = 0; i < 2; i++) {
1289 <            Thread t = new Thread(failedAcquire);
1290 <            t.start();
1291 <            ts.add(t);
1289 >            Thread thread = new Thread(failedAcquire);
1290 >            thread.start();
1291 >            threads.add(thread);
1292          }
1293          Thread.sleep(100);
1294 <        for (Thread t : ts) t.interrupt();
1295 <        for (Thread t : ts) t.join();
1294 >        for (Thread thread : threads) thread.interrupt();
1295 >        for (Thread thread : threads) awaitTermination(thread);
1296  
1297          s.release(1);
1298  
# Line 1311 | Line 1307 | public class AbstractQueuedSynchronizerT
1307                      s.getFirstQueuedThread()));
1308      }
1309  
1310 +    /**
1311 +     * Tests scenario for
1312 +     * JDK-8191937: Lost interrupt in AbstractQueuedSynchronizer when tryAcquire methods throw
1313 +     */
1314 +    public void testInterruptedFailingAcquire() throws InterruptedException {
1315 +        final RuntimeException ex = new RuntimeException();
1316 +
1317 +        // A synchronizer only offering a choice of failure modes
1318 +        class Sync extends AbstractQueuedSynchronizer {
1319 +            volatile boolean pleaseThrow;
1320 +            @Override protected boolean tryAcquire(int ignored) {
1321 +                if (pleaseThrow) throw ex;
1322 +                return false;
1323 +            }
1324 +            @Override protected int tryAcquireShared(int ignored) {
1325 +                if (pleaseThrow) throw ex;
1326 +                return -1;
1327 +            }
1328 +            @Override protected boolean tryRelease(int ignored) {
1329 +                return true;
1330 +            }
1331 +            @Override protected boolean tryReleaseShared(int ignored) {
1332 +                return true;
1333 +            }
1334 +        }
1335 +
1336 +        final Sync s = new Sync();
1337 +
1338 +        final Thread thread = newStartedThread(new CheckedRunnable() {
1339 +            public void realRun() {
1340 +                try {
1341 +                    if (randomBoolean())
1342 +                        s.acquire(1);
1343 +                    else
1344 +                        s.acquireShared(1);
1345 +                    shouldThrow();
1346 +                } catch (Throwable t) {
1347 +                    assertSame(ex, t);
1348 +                    assertTrue(Thread.interrupted());
1349 +                }
1350 +            }});
1351 +        waitForThreadToEnterWaitState(thread);
1352 +        assertSame(thread, s.getFirstQueuedThread());
1353 +        assertTrue(s.hasQueuedPredecessors());
1354 +        assertTrue(s.hasQueuedThreads());
1355 +        assertEquals(1, s.getQueueLength());
1356 +
1357 +        s.pleaseThrow = true;
1358 +        thread.interrupt();
1359 +        s.release(1);
1360 +        awaitTermination(thread);
1361 +    }
1362 +
1363   }

Diff Legend

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