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.45 by jsr166, Tue Dec 2 07:23:13 2014 UTC

# Line 9 | Line 9
9   import junit.framework.*;
10   import java.util.*;
11   import static java.util.concurrent.TimeUnit.MILLISECONDS;
12 + import static java.util.concurrent.TimeUnit.NANOSECONDS;
13   import java.util.concurrent.locks.AbstractQueuedSynchronizer;
14   import java.util.concurrent.locks.AbstractQueuedSynchronizer.ConditionObject;
15  
# Line 121 | Line 122 | public class AbstractQueuedSynchronizerT
122      }
123  
124      /** A constant to clarify calls to checking methods below. */
125 <    final static Thread[] NO_THREADS = new Thread[0];
125 >    static final Thread[] NO_THREADS = new Thread[0];
126  
127      /**
128       * Spin-waits until sync.isQueued(t) becomes true.
# Line 1190 | Line 1191 | public class AbstractQueuedSynchronizerT
1191       */
1192      public void testTryAcquireSharedNanos_Timeout() {
1193          final BooleanLatch l = new BooleanLatch();
1194 +        final BooleanLatch observedQueued = new BooleanLatch();
1195 +        final long timeoutMillis = timeoutMillis();
1196          Thread t = newStartedThread(new CheckedRunnable() {
1197              public void realRun() throws InterruptedException {
1198                  assertFalse(l.isSignalled());
1199 <                long startTime = System.nanoTime();
1200 <                long nanos = MILLISECONDS.toNanos(timeoutMillis());
1201 <                assertFalse(l.tryAcquireSharedNanos(0, nanos));
1202 <                assertTrue(millisElapsedSince(startTime) >= timeoutMillis());
1199 >                for (long millis = timeoutMillis();
1200 >                     !observedQueued.isSignalled();
1201 >                     millis *= 2) {
1202 >                    long nanos = MILLISECONDS.toNanos(millis);
1203 >                    long startTime = System.nanoTime();
1204 >                    assertFalse(l.tryAcquireSharedNanos(0, nanos));
1205 >                    assertTrue(millisElapsedSince(startTime) >= millis);
1206 >                }
1207                  assertFalse(l.isSignalled());
1208              }});
1209  
1210          waitForQueuedThread(l, t);
1211 +        observedQueued.releaseShared(0);
1212          assertFalse(l.isSignalled());
1213          awaitTermination(t);
1214          assertFalse(l.isSignalled());
1215      }
1216  
1217 +    /**
1218 +     * awaitNanos/timed await with 0 wait times out immediately
1219 +     */
1220 +    public void testAwait_Zero() throws InterruptedException {
1221 +        final Mutex sync = new Mutex();
1222 +        final ConditionObject c = sync.newCondition();
1223 +        sync.acquire();
1224 +        assertTrue(c.awaitNanos(0L) <= 0);
1225 +        assertFalse(c.await(0L, NANOSECONDS));
1226 +        sync.release();
1227 +    }
1228 +
1229 +    /**
1230 +     * awaitNanos/timed await with maximum negative wait times does not underflow
1231 +     */
1232 +    public void testAwait_NegativeInfinity() throws InterruptedException {
1233 +        final Mutex sync = new Mutex();
1234 +        final ConditionObject c = sync.newCondition();
1235 +        sync.acquire();
1236 +        assertTrue(c.awaitNanos(Long.MIN_VALUE) <= 0);
1237 +        assertFalse(c.await(Long.MIN_VALUE, NANOSECONDS));
1238 +        sync.release();
1239 +    }
1240 +
1241   }

Diff Legend

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