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

Comparing jsr166/src/test/tck/ReentrantReadWriteLockTest.java (file contents):
Revision 1.68 by jsr166, Wed Dec 31 05:04:04 2014 UTC vs.
Revision 1.78 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.*;
9 > import static java.util.concurrent.TimeUnit.MILLISECONDS;
10 >
11 > import java.util.Arrays;
12 > import java.util.Collection;
13 > import java.util.HashSet;
14 > import java.util.concurrent.CountDownLatch;
15   import java.util.concurrent.atomic.AtomicBoolean;
16   import java.util.concurrent.locks.Condition;
17   import java.util.concurrent.locks.Lock;
18   import java.util.concurrent.locks.ReentrantReadWriteLock;
19 < import java.util.concurrent.CountDownLatch;
20 < import static java.util.concurrent.TimeUnit.MILLISECONDS;
21 < import java.util.*;
19 >
20 > import junit.framework.AssertionFailedError;
21 > import junit.framework.Test;
22 > import junit.framework.TestSuite;
23  
24   public class ReentrantReadWriteLockTest extends JSR166TestCase {
25      public static void main(String[] args) {
26 <        junit.textui.TestRunner.run(suite());
26 >        main(suite(), args);
27      }
28      public static Test suite() {
29          return new TestSuite(ReentrantReadWriteLockTest.class);
# Line 149 | Line 155 | public class ReentrantReadWriteLockTest
155      enum AwaitMethod { await, awaitTimed, awaitNanos, awaitUntil }
156  
157      /**
158 <     * Awaits condition using the specified AwaitMethod.
158 >     * Awaits condition "indefinitely" using the specified AwaitMethod.
159       */
160      void await(Condition c, AwaitMethod awaitMethod)
161              throws InterruptedException {
162 +        long timeoutMillis = 2 * LONG_DELAY_MS;
163          switch (awaitMethod) {
164          case await:
165              c.await();
166              break;
167          case awaitTimed:
168 <            assertTrue(c.await(2 * LONG_DELAY_MS, MILLISECONDS));
168 >            assertTrue(c.await(timeoutMillis, MILLISECONDS));
169              break;
170          case awaitNanos:
171 <            long nanosRemaining = c.awaitNanos(MILLISECONDS.toNanos(2 * LONG_DELAY_MS));
172 <            assertTrue(nanosRemaining > 0);
171 >            long timeoutNanos = MILLISECONDS.toNanos(timeoutMillis);
172 >            long nanosRemaining = c.awaitNanos(timeoutNanos);
173 >            assertTrue(nanosRemaining > timeoutNanos / 2);
174 >            assertTrue(nanosRemaining <= timeoutNanos);
175              break;
176          case awaitUntil:
177 <            java.util.Date d = new java.util.Date();
169 <            assertTrue(c.awaitUntil(new java.util.Date(d.getTime() + 2 * LONG_DELAY_MS)));
177 >            assertTrue(c.awaitUntil(delayedDate(timeoutMillis)));
178              break;
179 +        default:
180 +            throw new AssertionError();
181          }
182      }
183  
# Line 228 | Line 238 | public class ReentrantReadWriteLockTest
238          }
239          for (int i = SIZE; i > 0; i--) {
240              lock.writeLock().unlock();
241 <            assertEquals(i-1,lock.getWriteHoldCount());
241 >            assertEquals(i - 1,lock.getWriteHoldCount());
242          }
243      }
244  
# Line 245 | Line 255 | public class ReentrantReadWriteLockTest
255          }
256          for (int i = SIZE; i > 0; i--) {
257              lock.writeLock().unlock();
258 <            assertEquals(i-1,lock.writeLock().getHoldCount());
258 >            assertEquals(i - 1,lock.writeLock().getHoldCount());
259          }
260      }
261  
# Line 262 | Line 272 | public class ReentrantReadWriteLockTest
272          }
273          for (int i = SIZE; i > 0; i--) {
274              lock.readLock().unlock();
275 <            assertEquals(i-1,lock.getReadHoldCount());
275 >            assertEquals(i - 1,lock.getReadHoldCount());
276          }
277      }
278  
# Line 822 | Line 832 | public class ReentrantReadWriteLockTest
832              new PublicReentrantReadWriteLock(fair);
833          try {
834              lock.writeLock().lockInterruptibly();
835 <        } catch (InterruptedException ie) {
826 <            threadUnexpectedException(ie);
827 <        }
835 >        } catch (InterruptedException fail) { threadUnexpectedException(fail); }
836          Thread t = newStartedThread(new CheckedInterruptedRunnable() {
837              public void realRun() throws InterruptedException {
838                  lock.writeLock().lockInterruptibly();
# Line 849 | Line 857 | public class ReentrantReadWriteLockTest
857              lock.readLock().lockInterruptibly();
858              lock.readLock().unlock();
859              lock.writeLock().lockInterruptibly();
860 <        } catch (InterruptedException ie) {
853 <            threadUnexpectedException(ie);
854 <        }
860 >        } catch (InterruptedException fail) { threadUnexpectedException(fail); }
861          Thread t = newStartedThread(new CheckedInterruptedRunnable() {
862              public void realRun() throws InterruptedException {
863                  lock.readLock().lockInterruptibly();
# Line 877 | Line 883 | public class ReentrantReadWriteLockTest
883                  await(c, awaitMethod);
884                  shouldThrow();
885              } catch (IllegalMonitorStateException success) {
886 <            } catch (InterruptedException e) { threadUnexpectedException(e); }
886 >            } catch (InterruptedException fail) {
887 >                threadUnexpectedException(fail);
888 >            }
889              assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
890          }
891      }
# Line 928 | Line 936 | public class ReentrantReadWriteLockTest
936              assertTrue(nanosRemaining <= 0);
937              assertTrue(millisElapsedSince(startTime) >= timeoutMillis);
938              lock.writeLock().unlock();
939 <        } catch (InterruptedException e) {
932 <            threadUnexpectedException(e);
933 <        }
939 >        } catch (InterruptedException fail) { threadUnexpectedException(fail); }
940      }
941  
942      /**
# Line 949 | Line 955 | public class ReentrantReadWriteLockTest
955              assertFalse(c.await(timeoutMillis, MILLISECONDS));
956              assertTrue(millisElapsedSince(startTime) >= timeoutMillis);
957              lock.writeLock().unlock();
958 <        } catch (InterruptedException e) {
953 <            threadUnexpectedException(e);
954 <        }
958 >        } catch (InterruptedException fail) { threadUnexpectedException(fail); }
959      }
960  
961      /**
# Line 965 | Line 969 | public class ReentrantReadWriteLockTest
969                  new ReentrantReadWriteLock(fair);
970              final Condition c = lock.writeLock().newCondition();
971              lock.writeLock().lock();
972 <            long startTime = System.nanoTime();
973 <            long timeoutMillis = 10;
974 <            java.util.Date d = new java.util.Date();
975 <            assertFalse(c.awaitUntil(new java.util.Date(d.getTime() + timeoutMillis)));
976 <            assertTrue(millisElapsedSince(startTime) >= timeoutMillis);
972 >            // We shouldn't assume that nanoTime and currentTimeMillis
973 >            // use the same time source, so don't use nanoTime here.
974 >            java.util.Date delayedDate = delayedDate(timeoutMillis());
975 >            assertFalse(c.awaitUntil(delayedDate));
976 >            assertTrue(new java.util.Date().getTime() >= delayedDate.getTime());
977              lock.writeLock().unlock();
978 <        } catch (InterruptedException e) {
975 <            threadUnexpectedException(e);
976 <        }
978 >        } catch (InterruptedException fail) { threadUnexpectedException(fail); }
979      }
980  
981      /**

Diff Legend

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