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.42 by jsr166, Fri Jun 3 05:07:14 2011 UTC vs.
Revision 1.56 by jsr166, Sun May 14 02:24:10 2017 UTC

# Line 6 | Line 6
6   * Pat Fisher, Mike Judd.
7   */
8  
9 – import junit.framework.*;
10 – import java.util.*;
9   import static java.util.concurrent.TimeUnit.MILLISECONDS;
10 + import static java.util.concurrent.TimeUnit.NANOSECONDS;
11 +
12 + import java.util.Arrays;
13 + import java.util.Collection;
14 + import java.util.HashSet;
15   import java.util.concurrent.locks.AbstractQueuedSynchronizer;
16   import java.util.concurrent.locks.AbstractQueuedSynchronizer.ConditionObject;
17  
18 + import junit.framework.AssertionFailedError;
19 + import junit.framework.Test;
20 + import junit.framework.TestSuite;
21 +
22   public class AbstractQueuedSynchronizerTest extends JSR166TestCase {
23      public static void main(String[] args) {
24 <        junit.textui.TestRunner.run(suite());
24 >        main(suite(), args);
25      }
26      public static Test suite() {
27          return new TestSuite(AbstractQueuedSynchronizerTest.class);
# Line 121 | Line 128 | public class AbstractQueuedSynchronizerT
128      }
129  
130      /** A constant to clarify calls to checking methods below. */
131 <    final static Thread[] NO_THREADS = new Thread[0];
131 >    static final Thread[] NO_THREADS = new Thread[0];
132  
133      /**
134       * Spin-waits until sync.isQueued(t) becomes true.
# Line 198 | Line 205 | public class AbstractQueuedSynchronizerT
205                       new HashSet<Thread>(Arrays.asList(threads)));
206      }
207  
208 <    enum AwaitMethod { await, awaitTimed, awaitNanos, awaitUntil };
208 >    enum AwaitMethod { await, awaitTimed, awaitNanos, awaitUntil }
209  
210      /**
211       * Awaits condition using the specified AwaitMethod.
# Line 221 | Line 228 | public class AbstractQueuedSynchronizerT
228          case awaitUntil:
229              assertTrue(c.awaitUntil(delayedDate(timeoutMillis)));
230              break;
231 +        default:
232 +            throw new AssertionError();
233          }
234      }
235  
# Line 229 | Line 238 | public class AbstractQueuedSynchronizerT
238       * default timeout duration).
239       */
240      void assertAwaitTimesOut(ConditionObject c, AwaitMethod awaitMethod) {
241 <        long timeoutMillis = timeoutMillis();
242 <        long startTime = System.nanoTime();
241 >        final long timeoutMillis = timeoutMillis();
242 >        final long startTime;
243          try {
244              switch (awaitMethod) {
245              case awaitTimed:
246 +                startTime = System.nanoTime();
247                  assertFalse(c.await(timeoutMillis, MILLISECONDS));
248 +                assertTrue(millisElapsedSince(startTime) >= timeoutMillis);
249                  break;
250              case awaitNanos:
251 +                startTime = System.nanoTime();
252                  long nanosTimeout = MILLISECONDS.toNanos(timeoutMillis);
253                  long nanosRemaining = c.awaitNanos(nanosTimeout);
254                  assertTrue(nanosRemaining <= 0);
255 +                assertTrue(nanosRemaining > -MILLISECONDS.toNanos(LONG_DELAY_MS));
256 +                assertTrue(millisElapsedSince(startTime) >= timeoutMillis);
257                  break;
258              case awaitUntil:
259 +                // We shouldn't assume that nanoTime and currentTimeMillis
260 +                // use the same time source, so don't use nanoTime here.
261 +                java.util.Date delayedDate = delayedDate(timeoutMillis);
262                  assertFalse(c.awaitUntil(delayedDate(timeoutMillis)));
263 +                assertTrue(new java.util.Date().getTime() >= delayedDate.getTime());
264                  break;
265              default:
266                  throw new UnsupportedOperationException();
267              }
268          } catch (InterruptedException ie) { threadUnexpectedException(ie); }
251 –        assertTrue(millisElapsedSince(startTime) >= timeoutMillis);
269      }
270  
271      /**
# Line 951 | Line 968 | public class AbstractQueuedSynchronizerT
968       */
969      public void testAwaitUninterruptibly() {
970          final Mutex sync = new Mutex();
971 <        final ConditionObject c = sync.newCondition();
971 >        final ConditionObject condition = sync.newCondition();
972          final BooleanLatch pleaseInterrupt = new BooleanLatch();
973          Thread t = newStartedThread(new CheckedRunnable() {
974              public void realRun() {
975                  sync.acquire();
976                  assertTrue(pleaseInterrupt.releaseShared(0));
977 <                c.awaitUninterruptibly();
977 >                condition.awaitUninterruptibly();
978                  assertTrue(Thread.interrupted());
979 <                assertHasWaitersLocked(sync, c, NO_THREADS);
979 >                assertHasWaitersLocked(sync, condition, NO_THREADS);
980                  sync.release();
981              }});
982  
983          pleaseInterrupt.acquireShared(0);
984          sync.acquire();
985 <        assertHasWaitersLocked(sync, c, t);
985 >        assertHasWaitersLocked(sync, condition, t);
986          sync.release();
987          t.interrupt();
988 <        assertHasWaitersUnlocked(sync, c, t);
989 <        assertThreadStaysAlive(t);
988 >        assertHasWaitersUnlocked(sync, condition, t);
989 >        assertThreadBlocks(t, Thread.State.WAITING);
990          sync.acquire();
991 <        assertHasWaitersLocked(sync, c, t);
991 >        assertHasWaitersLocked(sync, condition, t);
992          assertHasExclusiveQueuedThreads(sync, NO_THREADS);
993 <        c.signal();
994 <        assertHasWaitersLocked(sync, c, NO_THREADS);
993 >        condition.signal();
994 >        assertHasWaitersLocked(sync, condition, NO_THREADS);
995          assertHasExclusiveQueuedThreads(sync, t);
996          sync.release();
997          awaitTermination(t);
# Line 1117 | Line 1134 | public class AbstractQueuedSynchronizerT
1134  
1135          waitForQueuedThread(l, t);
1136          assertFalse(l.isSignalled());
1137 <        assertThreadStaysAlive(t);
1137 >        assertThreadBlocks(t, Thread.State.WAITING);
1138          assertHasSharedQueuedThreads(l, t);
1139          assertTrue(l.releaseShared(0));
1140          assertTrue(l.isSignalled());
# Line 1142 | Line 1159 | public class AbstractQueuedSynchronizerT
1159  
1160          waitForQueuedThread(l, t);
1161          assertFalse(l.isSignalled());
1162 <        assertThreadStaysAlive(t);
1162 >        assertThreadBlocks(t, Thread.State.TIMED_WAITING);
1163          assertTrue(l.releaseShared(0));
1164          assertTrue(l.isSignalled());
1165          awaitTermination(t);
# Line 1190 | Line 1207 | public class AbstractQueuedSynchronizerT
1207       */
1208      public void testTryAcquireSharedNanos_Timeout() {
1209          final BooleanLatch l = new BooleanLatch();
1210 +        final BooleanLatch observedQueued = new BooleanLatch();
1211          Thread t = newStartedThread(new CheckedRunnable() {
1212              public void realRun() throws InterruptedException {
1213                  assertFalse(l.isSignalled());
1214 <                long startTime = System.nanoTime();
1215 <                long nanos = MILLISECONDS.toNanos(timeoutMillis());
1216 <                assertFalse(l.tryAcquireSharedNanos(0, nanos));
1217 <                assertTrue(millisElapsedSince(startTime) >= timeoutMillis());
1214 >                for (long millis = timeoutMillis();
1215 >                     !observedQueued.isSignalled();
1216 >                     millis *= 2) {
1217 >                    long nanos = MILLISECONDS.toNanos(millis);
1218 >                    long startTime = System.nanoTime();
1219 >                    assertFalse(l.tryAcquireSharedNanos(0, nanos));
1220 >                    assertTrue(millisElapsedSince(startTime) >= millis);
1221 >                }
1222                  assertFalse(l.isSignalled());
1223              }});
1224  
1225          waitForQueuedThread(l, t);
1226 +        observedQueued.releaseShared(0);
1227          assertFalse(l.isSignalled());
1228          awaitTermination(t);
1229          assertFalse(l.isSignalled());
1230      }
1231  
1232 +    /**
1233 +     * awaitNanos/timed await with 0 wait times out immediately
1234 +     */
1235 +    public void testAwait_Zero() throws InterruptedException {
1236 +        final Mutex sync = new Mutex();
1237 +        final ConditionObject c = sync.newCondition();
1238 +        sync.acquire();
1239 +        assertTrue(c.awaitNanos(0L) <= 0);
1240 +        assertFalse(c.await(0L, NANOSECONDS));
1241 +        sync.release();
1242 +    }
1243 +
1244 +    /**
1245 +     * awaitNanos/timed await with maximum negative wait times does not underflow
1246 +     */
1247 +    public void testAwait_NegativeInfinity() throws InterruptedException {
1248 +        final Mutex sync = new Mutex();
1249 +        final ConditionObject c = sync.newCondition();
1250 +        sync.acquire();
1251 +        assertTrue(c.awaitNanos(Long.MIN_VALUE) <= 0);
1252 +        assertFalse(c.await(Long.MIN_VALUE, NANOSECONDS));
1253 +        sync.release();
1254 +    }
1255 +
1256   }

Diff Legend

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