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

Comparing jsr166/src/test/tck/AbstractQueuedLongSynchronizerTest.java (file contents):
Revision 1.25 by jsr166, Fri Jun 3 05:07:14 2011 UTC vs.
Revision 1.36 by jsr166, Fri Jul 3 05:48:30 2015 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.AbstractQueuedLongSynchronizer;
16   import java.util.concurrent.locks.AbstractQueuedLongSynchronizer.ConditionObject;
17  
18 + import junit.framework.AssertionFailedError;
19 + import junit.framework.Test;
20 + import junit.framework.TestSuite;
21 +
22   public class AbstractQueuedLongSynchronizerTest 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(AbstractQueuedLongSynchronizerTest.class);
# Line 87 | Line 94 | public class AbstractQueuedLongSynchroni
94          }
95  
96          public boolean tryReleaseShared(long ignore) {
97 <            setState(1 << 62);
97 >            setState(1L << 62);
98              return true;
99          }
100      }
# Line 117 | Line 124 | public class AbstractQueuedLongSynchroni
124      }
125  
126      /** A constant to clarify calls to checking methods below. */
127 <    final static Thread[] NO_THREADS = new Thread[0];
127 >    static final Thread[] NO_THREADS = new Thread[0];
128  
129      /**
130       * Spin-waits until sync.isQueued(t) becomes true.
# Line 195 | Line 202 | public class AbstractQueuedLongSynchroni
202                       new HashSet<Thread>(Arrays.asList(threads)));
203      }
204  
205 <    enum AwaitMethod { await, awaitTimed, awaitNanos, awaitUntil };
205 >    enum AwaitMethod { await, awaitTimed, awaitNanos, awaitUntil }
206  
207      /**
208       * Awaits condition using the specified AwaitMethod.
# Line 218 | Line 225 | public class AbstractQueuedLongSynchroni
225          case awaitUntil:
226              assertTrue(c.awaitUntil(delayedDate(timeoutMillis)));
227              break;
228 +        default:
229 +            throw new AssertionError();
230          }
231      }
232  
# Line 227 | Line 236 | public class AbstractQueuedLongSynchroni
236       */
237      void assertAwaitTimesOut(ConditionObject c, AwaitMethod awaitMethod) {
238          long timeoutMillis = timeoutMillis();
239 <        long startTime = System.nanoTime();
239 >        long startTime;
240          try {
241              switch (awaitMethod) {
242              case awaitTimed:
243 +                startTime = System.nanoTime();
244                  assertFalse(c.await(timeoutMillis, MILLISECONDS));
245 +                assertTrue(millisElapsedSince(startTime) >= timeoutMillis);
246                  break;
247              case awaitNanos:
248 +                startTime = System.nanoTime();
249                  long nanosTimeout = MILLISECONDS.toNanos(timeoutMillis);
250                  long nanosRemaining = c.awaitNanos(nanosTimeout);
251                  assertTrue(nanosRemaining <= 0);
252 +                assertTrue(nanosRemaining > -MILLISECONDS.toNanos(LONG_DELAY_MS));
253 +                assertTrue(millisElapsedSince(startTime) >= timeoutMillis);
254                  break;
255              case awaitUntil:
256 +                // We shouldn't assume that nanoTime and currentTimeMillis
257 +                // use the same time source, so don't use nanoTime here.
258 +                java.util.Date delayedDate = delayedDate(timeoutMillis());
259                  assertFalse(c.awaitUntil(delayedDate(timeoutMillis)));
260 +                assertTrue(new java.util.Date().getTime() >= delayedDate.getTime());
261                  break;
262              default:
263                  throw new UnsupportedOperationException();
264              }
265          } catch (InterruptedException ie) { threadUnexpectedException(ie); }
248 –        assertTrue(millisElapsedSince(startTime) >= timeoutMillis);
266      }
267  
268      /**
# Line 1187 | Line 1204 | public class AbstractQueuedLongSynchroni
1204       */
1205      public void testTryAcquireSharedNanos_Timeout() {
1206          final BooleanLatch l = new BooleanLatch();
1207 +        final BooleanLatch observedQueued = new BooleanLatch();
1208          Thread t = newStartedThread(new CheckedRunnable() {
1209              public void realRun() throws InterruptedException {
1210                  assertFalse(l.isSignalled());
1211 <                long startTime = System.nanoTime();
1212 <                long nanos = MILLISECONDS.toNanos(timeoutMillis());
1213 <                assertFalse(l.tryAcquireSharedNanos(0, nanos));
1214 <                assertTrue(millisElapsedSince(startTime) >= timeoutMillis());
1211 >                for (long millis = timeoutMillis();
1212 >                     !observedQueued.isSignalled();
1213 >                     millis *= 2) {
1214 >                    long nanos = MILLISECONDS.toNanos(millis);
1215 >                    long startTime = System.nanoTime();
1216 >                    assertFalse(l.tryAcquireSharedNanos(0, nanos));
1217 >                    assertTrue(millisElapsedSince(startTime) >= millis);
1218 >                }
1219                  assertFalse(l.isSignalled());
1220              }});
1221  
1222          waitForQueuedThread(l, t);
1223 +        observedQueued.releaseShared(0);
1224          assertFalse(l.isSignalled());
1225          awaitTermination(t);
1226          assertFalse(l.isSignalled());
1227      }
1228  
1229 +    /**
1230 +     * awaitNanos/timed await with 0 wait times out immediately
1231 +     */
1232 +    public void testAwait_Zero() throws InterruptedException {
1233 +        final Mutex sync = new Mutex();
1234 +        final ConditionObject c = sync.newCondition();
1235 +        sync.acquire();
1236 +        assertTrue(c.awaitNanos(0L) <= 0);
1237 +        assertFalse(c.await(0L, NANOSECONDS));
1238 +        sync.release();
1239 +    }
1240 +
1241 +    /**
1242 +     * awaitNanos/timed await with maximum negative wait times does not underflow
1243 +     */
1244 +    public void testAwait_NegativeInfinity() throws InterruptedException {
1245 +        final Mutex sync = new Mutex();
1246 +        final ConditionObject c = sync.newCondition();
1247 +        sync.acquire();
1248 +        assertTrue(c.awaitNanos(Long.MIN_VALUE) <= 0);
1249 +        assertFalse(c.await(Long.MIN_VALUE, NANOSECONDS));
1250 +        sync.release();
1251 +    }
1252 +
1253   }

Diff Legend

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