ViewVC Help

View File | Revision Log | Show Annotations | Download File | Root Listing

root/jsr166/jsr166/src/test/tck/StampedLockTest.java

Comparing jsr166/src/test/tck/StampedLockTest.java (file contents):
Revision 1.2 by jsr166, Fri Feb 1 21:44:41 2013 UTC vs.
Revision 1.29 by jsr166, Sun Nov 6 22:42:10 2016 UTC

#	Line 3 | Line 3
3		* with assistance from members of JCP JSR-166 Expert Group and
4		* released to the public domain, as explained at
5		* http://creativecommons.org/publicdomain/zero/1.0/
6	–	* Other contributors include Andrew Wright, Jeffrey Hayes,
7	–	* Pat Fisher, Mike Judd.
6		*/
7
8	<	import junit.framework.*;
9	<	import java.util.concurrent.atomic.AtomicBoolean;
10	<	import java.util.concurrent.locks.Condition;
8	>	import static java.util.concurrent.TimeUnit.DAYS;
9	>	import static java.util.concurrent.TimeUnit.MILLISECONDS;
10	>	import static java.util.concurrent.TimeUnit.SECONDS;
11	>
12	>	import java.util.ArrayList;
13	>	import java.util.List;
14	>	import java.util.concurrent.CountDownLatch;
15	>	import java.util.concurrent.Future;
16	>	import java.util.concurrent.TimeUnit;
17		import java.util.concurrent.locks.Lock;
14	–	import java.util.concurrent.locks.ReadWriteLock;
18		import java.util.concurrent.locks.StampedLock;
19	<	import java.util.concurrent.CountDownLatch;
20	<	import static java.util.concurrent.TimeUnit.MILLISECONDS;
21	<	import java.util.*;
19	>	import java.util.function.BiConsumer;
20	>	import java.util.function.Function;
21	>
22	>	import junit.framework.Test;
23	>	import junit.framework.TestSuite;
24
25		public class StampedLockTest extends JSR166TestCase {
26		public static void main(String[] args) {
27	<	junit.textui.TestRunner.run(suite());
27	>	main(suite(), args);
28		}
29		public static Test suite() {
30		return new TestSuite(StampedLockTest.class);
31		}
32
33	<	// XXXX Just a skeleton implementation for now.
34	<	public void testTODO() { fail("StampedLockTest needs help"); }
33	>	/**
34	>	* Releases write lock, checking isWriteLocked before and after
35	>	*/
36	>	void releaseWriteLock(StampedLock lock, long stamp) {
37	>	assertTrue(lock.isWriteLocked());
38	>	assertValid(lock, stamp);
39	>	lock.unlockWrite(stamp);
40	>	assertFalse(lock.isWriteLocked());
41	>	assertFalse(lock.validate(stamp));
42	>	}
43	>
44	>	/**
45	>	* Releases read lock, checking isReadLocked before and after
46	>	*/
47	>	void releaseReadLock(StampedLock lock, long stamp) {
48	>	assertTrue(lock.isReadLocked());
49	>	assertValid(lock, stamp);
50	>	lock.unlockRead(stamp);
51	>	assertFalse(lock.isReadLocked());
52	>	assertTrue(lock.validate(stamp));
53	>	}
54	>
55	>	long assertNonZero(long v) {
56	>	assertTrue(v != 0L);
57	>	return v;
58	>	}
59	>
60	>	long assertValid(StampedLock lock, long stamp) {
61	>	assertTrue(stamp != 0L);
62	>	assertTrue(lock.validate(stamp));
63	>	return stamp;
64	>	}
65	>
66	>	void assertUnlocked(StampedLock lock) {
67	>	assertFalse(lock.isReadLocked());
68	>	assertFalse(lock.isWriteLocked());
69	>	assertEquals(0, lock.getReadLockCount());
70	>	assertValid(lock, lock.tryOptimisticRead());
71	>	}
72	>
73	>	List<Action> lockLockers(Lock lock) {
74	>	List<Action> lockers = new ArrayList<>();
75	>	lockers.add(() -> lock.lock());
76	>	lockers.add(() -> lock.lockInterruptibly());
77	>	lockers.add(() -> lock.tryLock());
78	>	lockers.add(() -> lock.tryLock(Long.MIN_VALUE, DAYS));
79	>	lockers.add(() -> lock.tryLock(0L, DAYS));
80	>	lockers.add(() -> lock.tryLock(Long.MAX_VALUE, DAYS));
81	>	return lockers;
82	>	}
83	>
84	>	List<Function<StampedLock, Long>> readLockers() {
85	>	List<Function<StampedLock, Long>> readLockers = new ArrayList<>();
86	>	readLockers.add(sl -> sl.readLock());
87	>	readLockers.add(sl -> sl.tryReadLock());
88	>	readLockers.add(sl -> readLockInterruptiblyUninterrupted(sl));
89	>	readLockers.add(sl -> tryReadLockUninterrupted(sl, Long.MIN_VALUE, DAYS));
90	>	readLockers.add(sl -> tryReadLockUninterrupted(sl, 0L, DAYS));
91	>	readLockers.add(sl -> sl.tryConvertToReadLock(sl.tryOptimisticRead()));
92	>	return readLockers;
93	>	}
94	>
95	>	List<BiConsumer<StampedLock, Long>> readUnlockers() {
96	>	List<BiConsumer<StampedLock, Long>> readUnlockers = new ArrayList<>();
97	>	readUnlockers.add((sl, stamp) -> sl.unlockRead(stamp));
98	>	readUnlockers.add((sl, stamp) -> assertTrue(sl.tryUnlockRead()));
99	>	readUnlockers.add((sl, stamp) -> sl.asReadLock().unlock());
100	>	readUnlockers.add((sl, stamp) -> sl.unlock(stamp));
101	>	readUnlockers.add((sl, stamp) -> assertValid(sl, sl.tryConvertToOptimisticRead(stamp)));
102	>	return readUnlockers;
103	>	}
104	>
105	>	List<Function<StampedLock, Long>> writeLockers() {
106	>	List<Function<StampedLock, Long>> writeLockers = new ArrayList<>();
107	>	writeLockers.add(sl -> sl.writeLock());
108	>	writeLockers.add(sl -> sl.tryWriteLock());
109	>	writeLockers.add(sl -> writeLockInterruptiblyUninterrupted(sl));
110	>	writeLockers.add(sl -> tryWriteLockUninterrupted(sl, Long.MIN_VALUE, DAYS));
111	>	writeLockers.add(sl -> tryWriteLockUninterrupted(sl, 0L, DAYS));
112	>	writeLockers.add(sl -> sl.tryConvertToWriteLock(sl.tryOptimisticRead()));
113	>	return writeLockers;
114	>	}
115	>
116	>	List<BiConsumer<StampedLock, Long>> writeUnlockers() {
117	>	List<BiConsumer<StampedLock, Long>> writeUnlockers = new ArrayList<>();
118	>	writeUnlockers.add((sl, stamp) -> sl.unlockWrite(stamp));
119	>	writeUnlockers.add((sl, stamp) -> assertTrue(sl.tryUnlockWrite()));
120	>	writeUnlockers.add((sl, stamp) -> sl.asWriteLock().unlock());
121	>	writeUnlockers.add((sl, stamp) -> sl.unlock(stamp));
122	>	writeUnlockers.add((sl, stamp) -> assertValid(sl, sl.tryConvertToOptimisticRead(stamp)));
123	>	return writeUnlockers;
124	>	}
125	>
126	>	/**
127	>	* Constructed StampedLock is in unlocked state
128	>	*/
129	>	public void testConstructor() {
130	>	assertUnlocked(new StampedLock());
131	>	}
132	>
133	>	/**
134	>	* write-locking, then unlocking, an unlocked lock succeed
135	>	*/
136	>	public void testWriteLock_lockUnlock() {
137	>	StampedLock lock = new StampedLock();
138	>
139	>	for (Function<StampedLock, Long> writeLocker : writeLockers())
140	>	for (BiConsumer<StampedLock, Long> writeUnlocker : writeUnlockers()) {
141	>	assertFalse(lock.isWriteLocked());
142	>	assertFalse(lock.isReadLocked());
143	>	assertEquals(0, lock.getReadLockCount());
144	>
145	>	long s = writeLocker.apply(lock);
146	>	assertValid(lock, s);
147	>	assertTrue(lock.isWriteLocked());
148	>	assertFalse(lock.isReadLocked());
149	>	assertEquals(0, lock.getReadLockCount());
150	>	writeUnlocker.accept(lock, s);
151	>	assertUnlocked(lock);
152	>	}
153	>	}
154
155	<	public void testConstructor() { new StampedLock(); }
155	>	/**
156	>	* read-locking, then unlocking, an unlocked lock succeed
157	>	*/
158	>	public void testReadLock_lockUnlock() {
159	>	StampedLock lock = new StampedLock();
160	>
161	>	for (Function<StampedLock, Long> readLocker : readLockers())
162	>	for (BiConsumer<StampedLock, Long> readUnlocker : readUnlockers()) {
163	>	long s = 42;
164	>	for (int i = 0; i < 2; i++) {
165	>	s = assertValid(lock, readLocker.apply(lock));
166	>	assertFalse(lock.isWriteLocked());
167	>	assertTrue(lock.isReadLocked());
168	>	assertEquals(i + 1, lock.getReadLockCount());
169	>	}
170	>	for (int i = 0; i < 2; i++) {
171	>	assertFalse(lock.isWriteLocked());
172	>	assertTrue(lock.isReadLocked());
173	>	assertEquals(2 - i, lock.getReadLockCount());
174	>	readUnlocker.accept(lock, s);
175	>	}
176	>	assertUnlocked(lock);
177	>	}
178	>	}
179
180	<	//     /**
181	<	//      * A runnable calling lockInterruptibly
182	<	//      */
183	<	//     class InterruptibleLockRunnable extends CheckedRunnable {
184	<	//         final ReentrantReadWriteLock lock;
185	<	//         InterruptibleLockRunnable(ReentrantReadWriteLock l) { lock = l; }
186	<	//         public void realRun() throws InterruptedException {
187	<	//             lock.writeLock().lockInterruptibly();
188	<	//         }
189	<	//     }
190	<
191	<	//     /**
192	<	//      * A runnable calling lockInterruptibly that expects to be
193	<	//      * interrupted
194	<	//      */
195	<	//     class InterruptedLockRunnable extends CheckedInterruptedRunnable {
49	<	//         final ReentrantReadWriteLock lock;
50	<	//         InterruptedLockRunnable(ReentrantReadWriteLock l) { lock = l; }
51	<	//         public void realRun() throws InterruptedException {
52	<	//             lock.writeLock().lockInterruptibly();
53	<	//         }
54	<	//     }
55	<
56	<	//     /**
57	<	//      * Subclass to expose protected methods
58	<	//      */
59	<	//     static class PublicReentrantReadWriteLock extends ReentrantReadWriteLock {
60	<	//         PublicReentrantReadWriteLock() { super(); }
61	<	//         PublicReentrantReadWriteLock(boolean fair) { super(fair); }
62	<	//         public Thread getOwner() {
63	<	//             return super.getOwner();
64	<	//         }
65	<	//         public Collection<Thread> getQueuedThreads() {
66	<	//             return super.getQueuedThreads();
67	<	//         }
68	<	//         public Collection<Thread> getWaitingThreads(Condition c) {
69	<	//             return super.getWaitingThreads(c);
70	<	//         }
71	<	//     }
72	<
73	<	//     /**
74	<	//      * Releases write lock, checking that it had a hold count of 1.
75	<	//      */
76	<	//     void releaseWriteLock(PublicReentrantReadWriteLock lock) {
77	<	//         ReentrantReadWriteLock.WriteLock writeLock = lock.writeLock();
78	<	//         assertWriteLockedByMoi(lock);
79	<	//         assertEquals(1, lock.getWriteHoldCount());
80	<	//         writeLock.unlock();
81	<	//         assertNotWriteLocked(lock);
82	<	//     }
83	<
84	<	//     /**
85	<	//      * Spin-waits until lock.hasQueuedThread(t) becomes true.
86	<	//      */
87	<	//     void waitForQueuedThread(PublicReentrantReadWriteLock lock, Thread t) {
88	<	//         long startTime = System.nanoTime();
89	<	//         while (!lock.hasQueuedThread(t)) {
90	<	//             if (millisElapsedSince(startTime) > LONG_DELAY_MS)
91	<	//                 throw new AssertionFailedError("timed out");
92	<	//             Thread.yield();
93	<	//         }
94	<	//         assertTrue(t.isAlive());
95	<	//         assertTrue(lock.getOwner() != t);
96	<	//     }
97	<
98	<	//     /**
99	<	//      * Checks that lock is not write-locked.
100	<	//      */
101	<	//     void assertNotWriteLocked(PublicReentrantReadWriteLock lock) {
102	<	//         assertFalse(lock.isWriteLocked());
103	<	//         assertFalse(lock.isWriteLockedByCurrentThread());
104	<	//         assertFalse(lock.writeLock().isHeldByCurrentThread());
105	<	//         assertEquals(0, lock.getWriteHoldCount());
106	<	//         assertEquals(0, lock.writeLock().getHoldCount());
107	<	//         assertNull(lock.getOwner());
108	<	//     }
109	<
110	<	//     /**
111	<	//      * Checks that lock is write-locked by the given thread.
112	<	//      */
113	<	//     void assertWriteLockedBy(PublicReentrantReadWriteLock lock, Thread t) {
114	<	//         assertTrue(lock.isWriteLocked());
115	<	//         assertSame(t, lock.getOwner());
116	<	//         assertEquals(t == Thread.currentThread(),
117	<	//                      lock.isWriteLockedByCurrentThread());
118	<	//         assertEquals(t == Thread.currentThread(),
119	<	//                      lock.writeLock().isHeldByCurrentThread());
120	<	//         assertEquals(t == Thread.currentThread(),
121	<	//                      lock.getWriteHoldCount() > 0);
122	<	//         assertEquals(t == Thread.currentThread(),
123	<	//                      lock.writeLock().getHoldCount() > 0);
124	<	//         assertEquals(0, lock.getReadLockCount());
125	<	//     }
126	<
127	<	//     /**
128	<	//      * Checks that lock is write-locked by the current thread.
129	<	//      */
130	<	//     void assertWriteLockedByMoi(PublicReentrantReadWriteLock lock) {
131	<	//         assertWriteLockedBy(lock, Thread.currentThread());
132	<	//     }
133	<
134	<	//     /**
135	<	//      * Checks that condition c has no waiters.
136	<	//      */
137	<	//     void assertHasNoWaiters(PublicReentrantReadWriteLock lock, Condition c) {
138	<	//         assertHasWaiters(lock, c, new Thread[] {});
139	<	//     }
140	<
141	<	//     /**
142	<	//      * Checks that condition c has exactly the given waiter threads.
143	<	//      */
144	<	//     void assertHasWaiters(PublicReentrantReadWriteLock lock, Condition c,
145	<	//                           Thread... threads) {
146	<	//         lock.writeLock().lock();
147	<	//         assertEquals(threads.length > 0, lock.hasWaiters(c));
148	<	//         assertEquals(threads.length, lock.getWaitQueueLength(c));
149	<	//         assertEquals(threads.length == 0, lock.getWaitingThreads(c).isEmpty());
150	<	//         assertEquals(threads.length, lock.getWaitingThreads(c).size());
151	<	//         assertEquals(new HashSet<Thread>(lock.getWaitingThreads(c)),
152	<	//                      new HashSet<Thread>(Arrays.asList(threads)));
153	<	//         lock.writeLock().unlock();
154	<	//     }
155	<
156	<	//     enum AwaitMethod { await, awaitTimed, awaitNanos, awaitUntil };
157	<
158	<	//     /**
159	<	//      * Awaits condition using the specified AwaitMethod.
160	<	//      */
161	<	//     void await(Condition c, AwaitMethod awaitMethod)
162	<	//             throws InterruptedException {
163	<	//         switch (awaitMethod) {
164	<	//         case await:
165	<	//             c.await();
166	<	//             break;
167	<	//         case awaitTimed:
168	<	//             assertTrue(c.await(2 * LONG_DELAY_MS, MILLISECONDS));
169	<	//             break;
170	<	//         case awaitNanos:
171	<	//             long nanosRemaining = c.awaitNanos(MILLISECONDS.toNanos(2 * LONG_DELAY_MS));
172	<	//             assertTrue(nanosRemaining > 0);
173	<	//             break;
174	<	//         case awaitUntil:
175	<	//             java.util.Date d = new java.util.Date();
176	<	//             assertTrue(c.awaitUntil(new java.util.Date(d.getTime() + 2 * LONG_DELAY_MS)));
177	<	//             break;
178	<	//         }
179	<	//     }
180	<
181	<	//     /**
182	<	//      * Constructor sets given fairness, and is in unlocked state
183	<	//      */
184	<	//     public void testConstructor() {
185	<	//         PublicReentrantReadWriteLock lock;
186	<
187	<	//         lock = new PublicReentrantReadWriteLock();
188	<	//         assertFalse(lock.isFair());
189	<	//         assertNotWriteLocked(lock);
190	<	//         assertEquals(0, lock.getReadLockCount());
191	<
192	<	//         lock = new PublicReentrantReadWriteLock(true);
193	<	//         assertTrue(lock.isFair());
194	<	//         assertNotWriteLocked(lock);
195	<	//         assertEquals(0, lock.getReadLockCount());
196	<
197	<	//         lock = new PublicReentrantReadWriteLock(false);
198	<	//         assertFalse(lock.isFair());
199	<	//         assertNotWriteLocked(lock);
200	<	//         assertEquals(0, lock.getReadLockCount());
201	<	//     }
202	<
203	<	//     /**
204	<	//      * write-locking and read-locking an unlocked lock succeed
205	<	//      */
206	<	//     public void testLock()      { testLock(false); }
207	<	//     public void testLock_fair() { testLock(true); }
208	<	//     public void testLock(boolean fair) {
209	<	//         PublicReentrantReadWriteLock lock =
210	<	//             new PublicReentrantReadWriteLock(fair);
211	<	//         assertNotWriteLocked(lock);
212	<	//         lock.writeLock().lock();
213	<	//         assertWriteLockedByMoi(lock);
214	<	//         lock.writeLock().unlock();
215	<	//         assertNotWriteLocked(lock);
216	<	//         assertEquals(0, lock.getReadLockCount());
217	<	//         lock.readLock().lock();
218	<	//         assertNotWriteLocked(lock);
219	<	//         assertEquals(1, lock.getReadLockCount());
220	<	//         lock.readLock().unlock();
221	<	//         assertNotWriteLocked(lock);
222	<	//         assertEquals(0, lock.getReadLockCount());
223	<	//     }
224	<
225	<	//     /**
226	<	//      * getWriteHoldCount returns number of recursive holds
227	<	//      */
228	<	//     public void testGetWriteHoldCount()      { testGetWriteHoldCount(false); }
229	<	//     public void testGetWriteHoldCount_fair() { testGetWriteHoldCount(true); }
230	<	//     public void testGetWriteHoldCount(boolean fair) {
231	<	//         ReentrantReadWriteLock lock = new ReentrantReadWriteLock(fair);
232	<	//         for (int i = 1; i <= SIZE; i++) {
233	<	//             lock.writeLock().lock();
234	<	//             assertEquals(i,lock.getWriteHoldCount());
235	<	//         }
236	<	//         for (int i = SIZE; i > 0; i--) {
237	<	//             lock.writeLock().unlock();
238	<	//             assertEquals(i-1,lock.getWriteHoldCount());
239	<	//         }
240	<	//     }
241	<
242	<	//     /**
243	<	//      * writelock.getHoldCount returns number of recursive holds
244	<	//      */
245	<	//     public void testGetHoldCount()      { testGetHoldCount(false); }
246	<	//     public void testGetHoldCount_fair() { testGetHoldCount(true); }
247	<	//     public void testGetHoldCount(boolean fair) {
248	<	//         ReentrantReadWriteLock lock = new ReentrantReadWriteLock(fair);
249	<	//         for (int i = 1; i <= SIZE; i++) {
250	<	//             lock.writeLock().lock();
251	<	//             assertEquals(i,lock.writeLock().getHoldCount());
252	<	//         }
253	<	//         for (int i = SIZE; i > 0; i--) {
254	<	//             lock.writeLock().unlock();
255	<	//             assertEquals(i-1,lock.writeLock().getHoldCount());
256	<	//         }
257	<	//     }
258	<
259	<	//     /**
260	<	//      * getReadHoldCount returns number of recursive holds
261	<	//      */
262	<	//     public void testGetReadHoldCount()      { testGetReadHoldCount(false); }
263	<	//     public void testGetReadHoldCount_fair() { testGetReadHoldCount(true); }
264	<	//     public void testGetReadHoldCount(boolean fair) {
265	<	//         ReentrantReadWriteLock lock = new ReentrantReadWriteLock(fair);
266	<	//         for (int i = 1; i <= SIZE; i++) {
267	<	//             lock.readLock().lock();
268	<	//             assertEquals(i,lock.getReadHoldCount());
269	<	//         }
270	<	//         for (int i = SIZE; i > 0; i--) {
271	<	//             lock.readLock().unlock();
272	<	//             assertEquals(i-1,lock.getReadHoldCount());
273	<	//         }
274	<	//     }
275	<
276	<	//     /**
277	<	//      * write-unlocking an unlocked lock throws IllegalMonitorStateException
278	<	//      */
279	<	//     public void testWriteUnlock_IMSE()      { testWriteUnlock_IMSE(false); }
280	<	//     public void testWriteUnlock_IMSE_fair() { testWriteUnlock_IMSE(true); }
281	<	//     public void testWriteUnlock_IMSE(boolean fair) {
282	<	//         ReentrantReadWriteLock lock = new ReentrantReadWriteLock(fair);
283	<	//         try {
284	<	//             lock.writeLock().unlock();
285	<	//             shouldThrow();
286	<	//         } catch (IllegalMonitorStateException success) {}
287	<	//     }
288	<
289	<	//     /**
290	<	//      * read-unlocking an unlocked lock throws IllegalMonitorStateException
291	<	//      */
292	<	//     public void testReadUnlock_IMSE()      { testReadUnlock_IMSE(false); }
293	<	//     public void testReadUnlock_IMSE_fair() { testReadUnlock_IMSE(true); }
294	<	//     public void testReadUnlock_IMSE(boolean fair) {
295	<	//         ReentrantReadWriteLock lock = new ReentrantReadWriteLock(fair);
296	<	//         try {
297	<	//             lock.readLock().unlock();
298	<	//             shouldThrow();
299	<	//         } catch (IllegalMonitorStateException success) {}
300	<	//     }
301	<
302	<	//     /**
303	<	//      * write-lockInterruptibly is interruptible
304	<	//      */
305	<	//     public void testWriteLockInterruptibly_Interruptible()      { testWriteLockInterruptibly_Interruptible(false); }
306	<	//     public void testWriteLockInterruptibly_Interruptible_fair() { testWriteLockInterruptibly_Interruptible(true); }
307	<	//     public void testWriteLockInterruptibly_Interruptible(boolean fair) {
308	<	//         final PublicReentrantReadWriteLock lock =
309	<	//             new PublicReentrantReadWriteLock(fair);
310	<	//         lock.writeLock().lock();
311	<	//         Thread t = newStartedThread(new CheckedInterruptedRunnable() {
312	<	//             public void realRun() throws InterruptedException {
313	<	//                 lock.writeLock().lockInterruptibly();
314	<	//             }});
315	<
316	<	//         waitForQueuedThread(lock, t);
317	<	//         t.interrupt();
318	<	//         awaitTermination(t);
319	<	//         releaseWriteLock(lock);
320	<	//     }
321	<
322	<	//     /**
323	<	//      * timed write-tryLock is interruptible
324	<	//      */
325	<	//     public void testWriteTryLock_Interruptible()      { testWriteTryLock_Interruptible(false); }
326	<	//     public void testWriteTryLock_Interruptible_fair() { testWriteTryLock_Interruptible(true); }
327	<	//     public void testWriteTryLock_Interruptible(boolean fair) {
328	<	//         final PublicReentrantReadWriteLock lock =
329	<	//             new PublicReentrantReadWriteLock(fair);
330	<	//         lock.writeLock().lock();
331	<	//         Thread t = newStartedThread(new CheckedInterruptedRunnable() {
332	<	//             public void realRun() throws InterruptedException {
333	<	//                 lock.writeLock().tryLock(2 * LONG_DELAY_MS, MILLISECONDS);
334	<	//             }});
335	<
336	<	//         waitForQueuedThread(lock, t);
337	<	//         t.interrupt();
338	<	//         awaitTermination(t);
339	<	//         releaseWriteLock(lock);
340	<	//     }
341	<
342	<	//     /**
343	<	//      * read-lockInterruptibly is interruptible
344	<	//      */
345	<	//     public void testReadLockInterruptibly_Interruptible()      { testReadLockInterruptibly_Interruptible(false); }
346	<	//     public void testReadLockInterruptibly_Interruptible_fair() { testReadLockInterruptibly_Interruptible(true); }
347	<	//     public void testReadLockInterruptibly_Interruptible(boolean fair) {
348	<	//         final PublicReentrantReadWriteLock lock =
349	<	//             new PublicReentrantReadWriteLock(fair);
350	<	//         lock.writeLock().lock();
351	<	//         Thread t = newStartedThread(new CheckedInterruptedRunnable() {
352	<	//             public void realRun() throws InterruptedException {
353	<	//                 lock.readLock().lockInterruptibly();
354	<	//             }});
355	<
356	<	//         waitForQueuedThread(lock, t);
357	<	//         t.interrupt();
358	<	//         awaitTermination(t);
359	<	//         releaseWriteLock(lock);
360	<	//     }
361	<
362	<	//     /**
363	<	//      * timed read-tryLock is interruptible
364	<	//      */
365	<	//     public void testReadTryLock_Interruptible()      { testReadTryLock_Interruptible(false); }
366	<	//     public void testReadTryLock_Interruptible_fair() { testReadTryLock_Interruptible(true); }
367	<	//     public void testReadTryLock_Interruptible(boolean fair) {
368	<	//         final PublicReentrantReadWriteLock lock =
369	<	//             new PublicReentrantReadWriteLock(fair);
370	<	//         lock.writeLock().lock();
371	<	//         Thread t = newStartedThread(new CheckedInterruptedRunnable() {
372	<	//             public void realRun() throws InterruptedException {
373	<	//                 lock.readLock().tryLock(2 * LONG_DELAY_MS, MILLISECONDS);
374	<	//             }});
375	<
376	<	//         waitForQueuedThread(lock, t);
377	<	//         t.interrupt();
378	<	//         awaitTermination(t);
379	<	//         releaseWriteLock(lock);
380	<	//     }
381	<
382	<	//     /**
383	<	//      * write-tryLock on an unlocked lock succeeds
384	<	//      */
385	<	//     public void testWriteTryLock()      { testWriteTryLock(false); }
386	<	//     public void testWriteTryLock_fair() { testWriteTryLock(true); }
387	<	//     public void testWriteTryLock(boolean fair) {
388	<	//         final PublicReentrantReadWriteLock lock =
389	<	//             new PublicReentrantReadWriteLock(fair);
390	<	//         assertTrue(lock.writeLock().tryLock());
391	<	//         assertWriteLockedByMoi(lock);
392	<	//         assertTrue(lock.writeLock().tryLock());
393	<	//         assertWriteLockedByMoi(lock);
394	<	//         lock.writeLock().unlock();
395	<	//         releaseWriteLock(lock);
396	<	//     }
397	<
398	<	//     /**
399	<	//      * write-tryLock fails if locked
400	<	//      */
401	<	//     public void testWriteTryLockWhenLocked()      { testWriteTryLockWhenLocked(false); }
402	<	//     public void testWriteTryLockWhenLocked_fair() { testWriteTryLockWhenLocked(true); }
403	<	//     public void testWriteTryLockWhenLocked(boolean fair) {
404	<	//         final PublicReentrantReadWriteLock lock =
405	<	//             new PublicReentrantReadWriteLock(fair);
406	<	//         lock.writeLock().lock();
407	<	//         Thread t = newStartedThread(new CheckedRunnable() {
408	<	//             public void realRun() {
409	<	//                 assertFalse(lock.writeLock().tryLock());
410	<	//             }});
411	<
412	<	//         awaitTermination(t);
413	<	//         releaseWriteLock(lock);
414	<	//     }
415	<
416	<	//     /**
417	<	//      * read-tryLock fails if locked
418	<	//      */
419	<	//     public void testReadTryLockWhenLocked()      { testReadTryLockWhenLocked(false); }
420	<	//     public void testReadTryLockWhenLocked_fair() { testReadTryLockWhenLocked(true); }
421	<	//     public void testReadTryLockWhenLocked(boolean fair) {
422	<	//         final PublicReentrantReadWriteLock lock =
423	<	//             new PublicReentrantReadWriteLock(fair);
424	<	//         lock.writeLock().lock();
425	<	//         Thread t = newStartedThread(new CheckedRunnable() {
426	<	//             public void realRun() {
427	<	//                 assertFalse(lock.readLock().tryLock());
428	<	//             }});
429	<
430	<	//         awaitTermination(t);
431	<	//         releaseWriteLock(lock);
432	<	//     }
433	<
434	<	//     /**
435	<	//      * Multiple threads can hold a read lock when not write-locked
436	<	//      */
437	<	//     public void testMultipleReadLocks()      { testMultipleReadLocks(false); }
438	<	//     public void testMultipleReadLocks_fair() { testMultipleReadLocks(true); }
439	<	//     public void testMultipleReadLocks(boolean fair) {
440	<	//         final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(fair);
441	<	//         lock.readLock().lock();
442	<	//         Thread t = newStartedThread(new CheckedRunnable() {
443	<	//             public void realRun() throws InterruptedException {
444	<	//                 assertTrue(lock.readLock().tryLock());
445	<	//                 lock.readLock().unlock();
446	<	//                 assertTrue(lock.readLock().tryLock(LONG_DELAY_MS, MILLISECONDS));
447	<	//                 lock.readLock().unlock();
448	<	//                 lock.readLock().lock();
449	<	//                 lock.readLock().unlock();
450	<	//             }});
451	<
452	<	//         awaitTermination(t);
453	<	//         lock.readLock().unlock();
454	<	//     }
455	<
456	<	//     /**
457	<	//      * A writelock succeeds only after a reading thread unlocks
458	<	//      */
459	<	//     public void testWriteAfterReadLock()      { testWriteAfterReadLock(false); }
460	<	//     public void testWriteAfterReadLock_fair() { testWriteAfterReadLock(true); }
461	<	//     public void testWriteAfterReadLock(boolean fair) {
462	<	//         final PublicReentrantReadWriteLock lock =
463	<	//             new PublicReentrantReadWriteLock(fair);
464	<	//         lock.readLock().lock();
465	<	//         Thread t = newStartedThread(new CheckedRunnable() {
466	<	//             public void realRun() {
467	<	//                 assertEquals(1, lock.getReadLockCount());
468	<	//                 lock.writeLock().lock();
469	<	//                 assertEquals(0, lock.getReadLockCount());
470	<	//                 lock.writeLock().unlock();
471	<	//             }});
472	<	//         waitForQueuedThread(lock, t);
473	<	//         assertNotWriteLocked(lock);
474	<	//         assertEquals(1, lock.getReadLockCount());
475	<	//         lock.readLock().unlock();
476	<	//         assertEquals(0, lock.getReadLockCount());
477	<	//         awaitTermination(t);
478	<	//         assertNotWriteLocked(lock);
479	<	//     }
480	<
481	<	//     /**
482	<	//      * A writelock succeeds only after reading threads unlock
483	<	//      */
484	<	//     public void testWriteAfterMultipleReadLocks()      { testWriteAfterMultipleReadLocks(false); }
485	<	//     public void testWriteAfterMultipleReadLocks_fair() { testWriteAfterMultipleReadLocks(true); }
486	<	//     public void testWriteAfterMultipleReadLocks(boolean fair) {
487	<	//         final PublicReentrantReadWriteLock lock =
488	<	//             new PublicReentrantReadWriteLock(fair);
489	<	//         lock.readLock().lock();
490	<	//         lock.readLock().lock();
491	<	//         Thread t1 = newStartedThread(new CheckedRunnable() {
492	<	//             public void realRun() {
493	<	//                 lock.readLock().lock();
494	<	//                 assertEquals(3, lock.getReadLockCount());
495	<	//                 lock.readLock().unlock();
496	<	//             }});
497	<	//         awaitTermination(t1);
498	<
499	<	//         Thread t2 = newStartedThread(new CheckedRunnable() {
500	<	//             public void realRun() {
501	<	//                 assertEquals(2, lock.getReadLockCount());
502	<	//                 lock.writeLock().lock();
503	<	//                 assertEquals(0, lock.getReadLockCount());
504	<	//                 lock.writeLock().unlock();
505	<	//             }});
506	<	//         waitForQueuedThread(lock, t2);
507	<	//         assertNotWriteLocked(lock);
508	<	//         assertEquals(2, lock.getReadLockCount());
509	<	//         lock.readLock().unlock();
510	<	//         lock.readLock().unlock();
511	<	//         assertEquals(0, lock.getReadLockCount());
512	<	//         awaitTermination(t2);
513	<	//         assertNotWriteLocked(lock);
514	<	//     }
515	<
516	<	//     /**
517	<	//      * A thread that tries to acquire a fair read lock (non-reentrantly)
518	<	//      * will block if there is a waiting writer thread
519	<	//      */
520	<	//     public void testReaderWriterReaderFairFifo() {
521	<	//         final PublicReentrantReadWriteLock lock =
522	<	//             new PublicReentrantReadWriteLock(true);
523	<	//         final AtomicBoolean t1GotLock = new AtomicBoolean(false);
524	<
525	<	//         lock.readLock().lock();
526	<	//         Thread t1 = newStartedThread(new CheckedRunnable() {
527	<	//             public void realRun() {
528	<	//                 assertEquals(1, lock.getReadLockCount());
529	<	//                 lock.writeLock().lock();
530	<	//                 assertEquals(0, lock.getReadLockCount());
531	<	//                 t1GotLock.set(true);
532	<	//                 lock.writeLock().unlock();
533	<	//             }});
534	<	//         waitForQueuedThread(lock, t1);
535	<
536	<	//         Thread t2 = newStartedThread(new CheckedRunnable() {
537	<	//             public void realRun() {
538	<	//                 assertEquals(1, lock.getReadLockCount());
539	<	//                 lock.readLock().lock();
540	<	//                 assertEquals(1, lock.getReadLockCount());
541	<	//                 assertTrue(t1GotLock.get());
542	<	//                 lock.readLock().unlock();
543	<	//             }});
544	<	//         waitForQueuedThread(lock, t2);
545	<	//         assertTrue(t1.isAlive());
546	<	//         assertNotWriteLocked(lock);
547	<	//         assertEquals(1, lock.getReadLockCount());
548	<	//         lock.readLock().unlock();
549	<	//         awaitTermination(t1);
550	<	//         awaitTermination(t2);
551	<	//         assertNotWriteLocked(lock);
552	<	//     }
553	<
554	<	//     /**
555	<	//      * Readlocks succeed only after a writing thread unlocks
556	<	//      */
557	<	//     public void testReadAfterWriteLock()      { testReadAfterWriteLock(false); }
558	<	//     public void testReadAfterWriteLock_fair() { testReadAfterWriteLock(true); }
559	<	//     public void testReadAfterWriteLock(boolean fair) {
560	<	//         final PublicReentrantReadWriteLock lock =
561	<	//             new PublicReentrantReadWriteLock(fair);
562	<	//         lock.writeLock().lock();
563	<	//         Thread t1 = newStartedThread(new CheckedRunnable() {
564	<	//             public void realRun() {
565	<	//                 lock.readLock().lock();
566	<	//                 lock.readLock().unlock();
567	<	//             }});
568	<	//         Thread t2 = newStartedThread(new CheckedRunnable() {
569	<	//             public void realRun() {
570	<	//                 lock.readLock().lock();
571	<	//                 lock.readLock().unlock();
572	<	//             }});
573	<
574	<	//         waitForQueuedThread(lock, t1);
575	<	//         waitForQueuedThread(lock, t2);
576	<	//         releaseWriteLock(lock);
577	<	//         awaitTermination(t1);
578	<	//         awaitTermination(t2);
579	<	//     }
580	<
581	<	//     /**
582	<	//      * Read trylock succeeds if write locked by current thread
583	<	//      */
584	<	//     public void testReadHoldingWriteLock()      { testReadHoldingWriteLock(false); }
585	<	//     public void testReadHoldingWriteLock_fair() { testReadHoldingWriteLock(true); }
586	<	//     public void testReadHoldingWriteLock(boolean fair) {
587	<	//         final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(fair);
588	<	//         lock.writeLock().lock();
589	<	//         assertTrue(lock.readLock().tryLock());
590	<	//         lock.readLock().unlock();
591	<	//         lock.writeLock().unlock();
592	<	//     }
593	<
594	<	//     /**
595	<	//      * Read trylock succeeds (barging) even in the presence of waiting
596	<	//      * readers and/or writers
597	<	//      */
598	<	//     public void testReadTryLockBarging()      { testReadTryLockBarging(false); }
599	<	//     public void testReadTryLockBarging_fair() { testReadTryLockBarging(true); }
600	<	//     public void testReadTryLockBarging(boolean fair) {
601	<	//         final PublicReentrantReadWriteLock lock =
602	<	//             new PublicReentrantReadWriteLock(fair);
603	<	//         lock.readLock().lock();
604	<
605	<	//         Thread t1 = newStartedThread(new CheckedRunnable() {
606	<	//             public void realRun() {
607	<	//                 lock.writeLock().lock();
608	<	//                 lock.writeLock().unlock();
609	<	//             }});
610	<
611	<	//         waitForQueuedThread(lock, t1);
612	<
613	<	//         Thread t2 = newStartedThread(new CheckedRunnable() {
614	<	//             public void realRun() {
615	<	//                 lock.readLock().lock();
616	<	//                 lock.readLock().unlock();
617	<	//             }});
618	<
619	<	//         if (fair)
620	<	//             waitForQueuedThread(lock, t2);
621	<
622	<	//         Thread t3 = newStartedThread(new CheckedRunnable() {
623	<	//             public void realRun() {
624	<	//                 lock.readLock().tryLock();
625	<	//                 lock.readLock().unlock();
626	<	//             }});
627	<
628	<	//         assertTrue(lock.getReadLockCount() > 0);
629	<	//         awaitTermination(t3);
630	<	//         assertTrue(t1.isAlive());
631	<	//         if (fair) assertTrue(t2.isAlive());
632	<	//         lock.readLock().unlock();
633	<	//         awaitTermination(t1);
634	<	//         awaitTermination(t2);
635	<	//     }
636	<
637	<	//     /**
638	<	//      * Read lock succeeds if write locked by current thread even if
639	<	//      * other threads are waiting for readlock
640	<	//      */
641	<	//     public void testReadHoldingWriteLock2()      { testReadHoldingWriteLock2(false); }
642	<	//     public void testReadHoldingWriteLock2_fair() { testReadHoldingWriteLock2(true); }
643	<	//     public void testReadHoldingWriteLock2(boolean fair) {
644	<	//         final PublicReentrantReadWriteLock lock =
645	<	//             new PublicReentrantReadWriteLock(fair);
646	<	//         lock.writeLock().lock();
647	<	//         lock.readLock().lock();
648	<	//         lock.readLock().unlock();
649	<
650	<	//         Thread t1 = newStartedThread(new CheckedRunnable() {
651	<	//             public void realRun() {
652	<	//                 lock.readLock().lock();
653	<	//                 lock.readLock().unlock();
654	<	//             }});
655	<	//         Thread t2 = newStartedThread(new CheckedRunnable() {
656	<	//             public void realRun() {
657	<	//                 lock.readLock().lock();
658	<	//                 lock.readLock().unlock();
659	<	//             }});
660	<
661	<	//         waitForQueuedThread(lock, t1);
662	<	//         waitForQueuedThread(lock, t2);
663	<	//         assertWriteLockedByMoi(lock);
664	<	//         lock.readLock().lock();
665	<	//         lock.readLock().unlock();
666	<	//         releaseWriteLock(lock);
667	<	//         awaitTermination(t1);
668	<	//         awaitTermination(t2);
669	<	//     }
670	<
671	<	//     /**
672	<	//      * Read lock succeeds if write locked by current thread even if
673	<	//      * other threads are waiting for writelock
674	<	//      */
675	<	//     public void testReadHoldingWriteLock3()      { testReadHoldingWriteLock3(false); }
676	<	//     public void testReadHoldingWriteLock3_fair() { testReadHoldingWriteLock3(true); }
677	<	//     public void testReadHoldingWriteLock3(boolean fair) {
678	<	//         final PublicReentrantReadWriteLock lock =
679	<	//             new PublicReentrantReadWriteLock(fair);
680	<	//         lock.writeLock().lock();
681	<	//         lock.readLock().lock();
682	<	//         lock.readLock().unlock();
683	<
684	<	//         Thread t1 = newStartedThread(new CheckedRunnable() {
685	<	//             public void realRun() {
686	<	//                 lock.writeLock().lock();
687	<	//                 lock.writeLock().unlock();
688	<	//             }});
689	<	//         Thread t2 = newStartedThread(new CheckedRunnable() {
690	<	//             public void realRun() {
691	<	//                 lock.writeLock().lock();
692	<	//                 lock.writeLock().unlock();
693	<	//             }});
694	<
695	<	//         waitForQueuedThread(lock, t1);
696	<	//         waitForQueuedThread(lock, t2);
697	<	//         assertWriteLockedByMoi(lock);
698	<	//         lock.readLock().lock();
699	<	//         lock.readLock().unlock();
700	<	//         assertWriteLockedByMoi(lock);
701	<	//         lock.writeLock().unlock();
702	<	//         awaitTermination(t1);
703	<	//         awaitTermination(t2);
704	<	//     }
705	<
706	<	//     /**
707	<	//      * Write lock succeeds if write locked by current thread even if
708	<	//      * other threads are waiting for writelock
709	<	//      */
710	<	//     public void testWriteHoldingWriteLock4()      { testWriteHoldingWriteLock4(false); }
711	<	//     public void testWriteHoldingWriteLock4_fair() { testWriteHoldingWriteLock4(true); }
712	<	//     public void testWriteHoldingWriteLock4(boolean fair) {
713	<	//         final PublicReentrantReadWriteLock lock =
714	<	//             new PublicReentrantReadWriteLock(fair);
715	<	//         lock.writeLock().lock();
716	<	//         lock.writeLock().lock();
717	<	//         lock.writeLock().unlock();
718	<
719	<	//         Thread t1 = newStartedThread(new CheckedRunnable() {
720	<	//             public void realRun() {
721	<	//                 lock.writeLock().lock();
722	<	//                 lock.writeLock().unlock();
723	<	//             }});
724	<	//         Thread t2 = newStartedThread(new CheckedRunnable() {
725	<	//             public void realRun() {
726	<	//                 lock.writeLock().lock();
727	<	//                 lock.writeLock().unlock();
728	<	//             }});
729	<
730	<	//         waitForQueuedThread(lock, t1);
731	<	//         waitForQueuedThread(lock, t2);
732	<	//         assertWriteLockedByMoi(lock);
733	<	//         assertEquals(1, lock.getWriteHoldCount());
734	<	//         lock.writeLock().lock();
735	<	//         assertWriteLockedByMoi(lock);
736	<	//         assertEquals(2, lock.getWriteHoldCount());
737	<	//         lock.writeLock().unlock();
738	<	//         assertWriteLockedByMoi(lock);
739	<	//         assertEquals(1, lock.getWriteHoldCount());
740	<	//         lock.writeLock().unlock();
741	<	//         awaitTermination(t1);
742	<	//         awaitTermination(t2);
743	<	//     }
744	<
745	<	//     /**
746	<	//      * Read tryLock succeeds if readlocked but not writelocked
747	<	//      */
748	<	//     public void testTryLockWhenReadLocked()      { testTryLockWhenReadLocked(false); }
749	<	//     public void testTryLockWhenReadLocked_fair() { testTryLockWhenReadLocked(true); }
750	<	//     public void testTryLockWhenReadLocked(boolean fair) {
751	<	//         final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(fair);
752	<	//         lock.readLock().lock();
753	<	//         Thread t = newStartedThread(new CheckedRunnable() {
754	<	//             public void realRun() {
755	<	//                 assertTrue(lock.readLock().tryLock());
756	<	//                 lock.readLock().unlock();
757	<	//             }});
758	<
759	<	//         awaitTermination(t);
760	<	//         lock.readLock().unlock();
761	<	//     }
762	<
763	<	//     /**
764	<	//      * write tryLock fails when readlocked
765	<	//      */
766	<	//     public void testWriteTryLockWhenReadLocked()      { testWriteTryLockWhenReadLocked(false); }
767	<	//     public void testWriteTryLockWhenReadLocked_fair() { testWriteTryLockWhenReadLocked(true); }
768	<	//     public void testWriteTryLockWhenReadLocked(boolean fair) {
769	<	//         final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(fair);
770	<	//         lock.readLock().lock();
771	<	//         Thread t = newStartedThread(new CheckedRunnable() {
772	<	//             public void realRun() {
773	<	//                 assertFalse(lock.writeLock().tryLock());
774	<	//             }});
775	<
776	<	//         awaitTermination(t);
777	<	//         lock.readLock().unlock();
778	<	//     }
779	<
780	<	//     /**
781	<	//      * write timed tryLock times out if locked
782	<	//      */
783	<	//     public void testWriteTryLock_Timeout()      { testWriteTryLock_Timeout(false); }
784	<	//     public void testWriteTryLock_Timeout_fair() { testWriteTryLock_Timeout(true); }
785	<	//     public void testWriteTryLock_Timeout(boolean fair) {
786	<	//         final PublicReentrantReadWriteLock lock =
787	<	//             new PublicReentrantReadWriteLock(fair);
788	<	//         lock.writeLock().lock();
789	<	//         Thread t = newStartedThread(new CheckedRunnable() {
790	<	//             public void realRun() throws InterruptedException {
791	<	//                 long startTime = System.nanoTime();
792	<	//                 long timeoutMillis = 10;
793	<	//                 assertFalse(lock.writeLock().tryLock(timeoutMillis, MILLISECONDS));
794	<	//                 assertTrue(millisElapsedSince(startTime) >= timeoutMillis);
795	<	//             }});
796	<
797	<	//         awaitTermination(t);
798	<	//         releaseWriteLock(lock);
799	<	//     }
800	<
801	<	//     /**
802	<	//      * read timed tryLock times out if write-locked
803	<	//      */
804	<	//     public void testReadTryLock_Timeout()      { testReadTryLock_Timeout(false); }
805	<	//     public void testReadTryLock_Timeout_fair() { testReadTryLock_Timeout(true); }
806	<	//     public void testReadTryLock_Timeout(boolean fair) {
807	<	//         final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(fair);
808	<	//         lock.writeLock().lock();
809	<	//         Thread t = newStartedThread(new CheckedRunnable() {
810	<	//             public void realRun() throws InterruptedException {
811	<	//                 long startTime = System.nanoTime();
812	<	//                 long timeoutMillis = 10;
813	<	//                 assertFalse(lock.readLock().tryLock(timeoutMillis, MILLISECONDS));
814	<	//                 assertTrue(millisElapsedSince(startTime) >= timeoutMillis);
815	<	//             }});
816	<
817	<	//         awaitTermination(t);
818	<	//         assertTrue(lock.writeLock().isHeldByCurrentThread());
819	<	//         lock.writeLock().unlock();
820	<	//     }
821	<
822	<	//     /**
823	<	//      * write lockInterruptibly succeeds if unlocked, else is interruptible
824	<	//      */
825	<	//     public void testWriteLockInterruptibly()      { testWriteLockInterruptibly(false); }
826	<	//     public void testWriteLockInterruptibly_fair() { testWriteLockInterruptibly(true); }
827	<	//     public void testWriteLockInterruptibly(boolean fair) {
828	<	//         final PublicReentrantReadWriteLock lock =
829	<	//             new PublicReentrantReadWriteLock(fair);
830	<	//         try {
831	<	//             lock.writeLock().lockInterruptibly();
832	<	//         } catch (InterruptedException ie) {
833	<	//             threadUnexpectedException(ie);
834	<	//         }
835	<	//         Thread t = newStartedThread(new CheckedInterruptedRunnable() {
836	<	//             public void realRun() throws InterruptedException {
837	<	//                 lock.writeLock().lockInterruptibly();
838	<	//             }});
839	<
840	<	//         waitForQueuedThread(lock, t);
841	<	//         t.interrupt();
842	<	//         assertTrue(lock.writeLock().isHeldByCurrentThread());
843	<	//         awaitTermination(t);
844	<	//         releaseWriteLock(lock);
845	<	//     }
846	<
847	<	//     /**
848	<	//      * read lockInterruptibly succeeds if lock free else is interruptible
849	<	//      */
850	<	//     public void testReadLockInterruptibly()      { testReadLockInterruptibly(false); }
851	<	//     public void testReadLockInterruptibly_fair() { testReadLockInterruptibly(true); }
852	<	//     public void testReadLockInterruptibly(boolean fair) {
853	<	//         final PublicReentrantReadWriteLock lock =
854	<	//             new PublicReentrantReadWriteLock(fair);
855	<	//         try {
856	<	//             lock.readLock().lockInterruptibly();
857	<	//             lock.readLock().unlock();
858	<	//             lock.writeLock().lockInterruptibly();
859	<	//         } catch (InterruptedException ie) {
860	<	//             threadUnexpectedException(ie);
861	<	//         }
862	<	//         Thread t = newStartedThread(new CheckedInterruptedRunnable() {
863	<	//             public void realRun() throws InterruptedException {
864	<	//                 lock.readLock().lockInterruptibly();
865	<	//             }});
866	<
867	<	//         waitForQueuedThread(lock, t);
868	<	//         t.interrupt();
869	<	//         awaitTermination(t);
870	<	//         releaseWriteLock(lock);
871	<	//     }
872	<
873	<	//     /**
874	<	//      * Calling await without holding lock throws IllegalMonitorStateException
875	<	//      */
876	<	//     public void testAwait_IMSE()      { testAwait_IMSE(false); }
877	<	//     public void testAwait_IMSE_fair() { testAwait_IMSE(true); }
878	<	//     public void testAwait_IMSE(boolean fair) {
879	<	//         final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(fair);
880	<	//         final Condition c = lock.writeLock().newCondition();
881	<	//         for (AwaitMethod awaitMethod : AwaitMethod.values()) {
882	<	//             long startTime = System.nanoTime();
883	<	//             try {
884	<	//                 await(c, awaitMethod);
885	<	//                 shouldThrow();
886	<	//             } catch (IllegalMonitorStateException success) {
887	<	//             } catch (InterruptedException e) { threadUnexpectedException(e); }
888	<	//             assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
889	<	//         }
890	<	//     }
891	<
892	<	//     /**
893	<	//      * Calling signal without holding lock throws IllegalMonitorStateException
894	<	//      */
895	<	//     public void testSignal_IMSE()      { testSignal_IMSE(false); }
896	<	//     public void testSignal_IMSE_fair() { testSignal_IMSE(true); }
897	<	//     public void testSignal_IMSE(boolean fair) {
898	<	//         final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(fair);
899	<	//         final Condition c = lock.writeLock().newCondition();
900	<	//         try {
901	<	//             c.signal();
902	<	//             shouldThrow();
903	<	//         } catch (IllegalMonitorStateException success) {}
904	<	//     }
905	<
906	<	//     /**
907	<	//      * Calling signalAll without holding lock throws IllegalMonitorStateException
908	<	//      */
909	<	//     public void testSignalAll_IMSE()      { testSignalAll_IMSE(false); }
910	<	//     public void testSignalAll_IMSE_fair() { testSignalAll_IMSE(true); }
911	<	//     public void testSignalAll_IMSE(boolean fair) {
912	<	//         final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(fair);
913	<	//         final Condition c = lock.writeLock().newCondition();
914	<	//         try {
915	<	//             c.signalAll();
916	<	//             shouldThrow();
917	<	//         } catch (IllegalMonitorStateException success) {}
918	<	//     }
919	<
920	<	//     /**
921	<	//      * awaitNanos without a signal times out
922	<	//      */
923	<	//     public void testAwaitNanos_Timeout()      { testAwaitNanos_Timeout(false); }
924	<	//     public void testAwaitNanos_Timeout_fair() { testAwaitNanos_Timeout(true); }
925	<	//     public void testAwaitNanos_Timeout(boolean fair) {
926	<	//         try {
927	<	//             final ReentrantReadWriteLock lock =
928	<	//                 new ReentrantReadWriteLock(fair);
929	<	//             final Condition c = lock.writeLock().newCondition();
930	<	//             lock.writeLock().lock();
931	<	//             long startTime = System.nanoTime();
932	<	//             long timeoutMillis = 10;
933	<	//             long timeoutNanos = MILLISECONDS.toNanos(timeoutMillis);
934	<	//             long nanosRemaining = c.awaitNanos(timeoutNanos);
935	<	//             assertTrue(nanosRemaining <= 0);
936	<	//             assertTrue(millisElapsedSince(startTime) >= timeoutMillis);
937	<	//             lock.writeLock().unlock();
938	<	//         } catch (InterruptedException e) {
939	<	//             threadUnexpectedException(e);
940	<	//         }
941	<	//     }
942	<
943	<	//     /**
944	<	//      * timed await without a signal times out
945	<	//      */
946	<	//     public void testAwait_Timeout()      { testAwait_Timeout(false); }
947	<	//     public void testAwait_Timeout_fair() { testAwait_Timeout(true); }
948	<	//     public void testAwait_Timeout(boolean fair) {
949	<	//         try {
950	<	//             final ReentrantReadWriteLock lock =
951	<	//                 new ReentrantReadWriteLock(fair);
952	<	//             final Condition c = lock.writeLock().newCondition();
953	<	//             lock.writeLock().lock();
954	<	//             long startTime = System.nanoTime();
955	<	//             long timeoutMillis = 10;
956	<	//             assertFalse(c.await(timeoutMillis, MILLISECONDS));
957	<	//             assertTrue(millisElapsedSince(startTime) >= timeoutMillis);
958	<	//             lock.writeLock().unlock();
959	<	//         } catch (InterruptedException e) {
960	<	//             threadUnexpectedException(e);
961	<	//         }
962	<	//     }
963	<
964	<	//     /**
965	<	//      * awaitUntil without a signal times out
966	<	//      */
967	<	//     public void testAwaitUntil_Timeout()      { testAwaitUntil_Timeout(false); }
968	<	//     public void testAwaitUntil_Timeout_fair() { testAwaitUntil_Timeout(true); }
969	<	//     public void testAwaitUntil_Timeout(boolean fair) {
970	<	//         try {
971	<	//             final ReentrantReadWriteLock lock =
972	<	//                 new ReentrantReadWriteLock(fair);
973	<	//             final Condition c = lock.writeLock().newCondition();
974	<	//             lock.writeLock().lock();
975	<	//             long startTime = System.nanoTime();
976	<	//             long timeoutMillis = 10;
977	<	//             java.util.Date d = new java.util.Date();
978	<	//             assertFalse(c.awaitUntil(new java.util.Date(d.getTime() + timeoutMillis)));
979	<	//             assertTrue(millisElapsedSince(startTime) >= timeoutMillis);
980	<	//             lock.writeLock().unlock();
981	<	//         } catch (InterruptedException e) {
982	<	//             threadUnexpectedException(e);
983	<	//         }
984	<	//     }
985	<
986	<	//     /**
987	<	//      * await returns when signalled
988	<	//      */
989	<	//     public void testAwait()      { testAwait(false); }
990	<	//     public void testAwait_fair() { testAwait(true); }
991	<	//     public void testAwait(boolean fair) {
992	<	//         final PublicReentrantReadWriteLock lock =
993	<	//             new PublicReentrantReadWriteLock(fair);
994	<	//         final Condition c = lock.writeLock().newCondition();
995	<	//         final CountDownLatch locked = new CountDownLatch(1);
996	<	//         Thread t = newStartedThread(new CheckedRunnable() {
997	<	//             public void realRun() throws InterruptedException {
998	<	//                 lock.writeLock().lock();
999	<	//                 locked.countDown();
1000	<	//                 c.await();
1001	<	//                 lock.writeLock().unlock();
1002	<	//             }});
1003	<
1004	<	//         await(locked);
1005	<	//         lock.writeLock().lock();
1006	<	//         assertHasWaiters(lock, c, t);
1007	<	//         c.signal();
1008	<	//         assertHasNoWaiters(lock, c);
1009	<	//         assertTrue(t.isAlive());
1010	<	//         lock.writeLock().unlock();
1011	<	//         awaitTermination(t);
1012	<	//     }
1013	<
1014	<	//     /**
1015	<	//      * awaitUninterruptibly is uninterruptible
1016	<	//      */
1017	<	//     public void testAwaitUninterruptibly()      { testAwaitUninterruptibly(false); }
1018	<	//     public void testAwaitUninterruptibly_fair() { testAwaitUninterruptibly(true); }
1019	<	//     public void testAwaitUninterruptibly(boolean fair) {
1020	<	//         final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(fair);
1021	<	//         final Condition c = lock.writeLock().newCondition();
1022	<	//         final CountDownLatch pleaseInterrupt = new CountDownLatch(2);
1023	<
1024	<	//         Thread t1 = newStartedThread(new CheckedRunnable() {
1025	<	//             public void realRun() {
1026	<	//                 // Interrupt before awaitUninterruptibly
1027	<	//                 lock.writeLock().lock();
1028	<	//                 pleaseInterrupt.countDown();
1029	<	//                 Thread.currentThread().interrupt();
1030	<	//                 c.awaitUninterruptibly();
1031	<	//                 assertTrue(Thread.interrupted());
1032	<	//                 lock.writeLock().unlock();
1033	<	//             }});
1034	<
1035	<	//         Thread t2 = newStartedThread(new CheckedRunnable() {
1036	<	//             public void realRun() {
1037	<	//                 // Interrupt during awaitUninterruptibly
1038	<	//                 lock.writeLock().lock();
1039	<	//                 pleaseInterrupt.countDown();
1040	<	//                 c.awaitUninterruptibly();
1041	<	//                 assertTrue(Thread.interrupted());
1042	<	//                 lock.writeLock().unlock();
1043	<	//             }});
1044	<
1045	<	//         await(pleaseInterrupt);
1046	<	//         lock.writeLock().lock();
1047	<	//         lock.writeLock().unlock();
1048	<	//         t2.interrupt();
1049	<
1050	<	//         assertThreadStaysAlive(t1);
1051	<	//         assertTrue(t2.isAlive());
1052	<
1053	<	//         lock.writeLock().lock();
1054	<	//         c.signalAll();
1055	<	//         lock.writeLock().unlock();
1056	<
1057	<	//         awaitTermination(t1);
1058	<	//         awaitTermination(t2);
1059	<	//     }
1060	<
1061	<	//     /**
1062	<	//      * await/awaitNanos/awaitUntil is interruptible
1063	<	//      */
1064	<	//     public void testInterruptible_await()           { testInterruptible(false, AwaitMethod.await); }
1065	<	//     public void testInterruptible_await_fair()      { testInterruptible(true,  AwaitMethod.await); }
1066	<	//     public void testInterruptible_awaitTimed()      { testInterruptible(false, AwaitMethod.awaitTimed); }
1067	<	//     public void testInterruptible_awaitTimed_fair() { testInterruptible(true,  AwaitMethod.awaitTimed); }
1068	<	//     public void testInterruptible_awaitNanos()      { testInterruptible(false, AwaitMethod.awaitNanos); }
1069	<	//     public void testInterruptible_awaitNanos_fair() { testInterruptible(true,  AwaitMethod.awaitNanos); }
1070	<	//     public void testInterruptible_awaitUntil()      { testInterruptible(false, AwaitMethod.awaitUntil); }
1071	<	//     public void testInterruptible_awaitUntil_fair() { testInterruptible(true,  AwaitMethod.awaitUntil); }
1072	<	//     public void testInterruptible(boolean fair, final AwaitMethod awaitMethod) {
1073	<	//         final PublicReentrantReadWriteLock lock =
1074	<	//             new PublicReentrantReadWriteLock(fair);
1075	<	//         final Condition c = lock.writeLock().newCondition();
1076	<	//         final CountDownLatch locked = new CountDownLatch(1);
1077	<	//         Thread t = newStartedThread(new CheckedInterruptedRunnable() {
1078	<	//             public void realRun() throws InterruptedException {
1079	<	//                 lock.writeLock().lock();
1080	<	//                 assertWriteLockedByMoi(lock);
1081	<	//                 assertHasNoWaiters(lock, c);
1082	<	//                 locked.countDown();
1083	<	//                 try {
1084	<	//                     await(c, awaitMethod);
1085	<	//                 } finally {
1086	<	//                     assertWriteLockedByMoi(lock);
1087	<	//                     assertHasNoWaiters(lock, c);
1088	<	//                     lock.writeLock().unlock();
1089	<	//                     assertFalse(Thread.interrupted());
1090	<	//                 }
1091	<	//             }});
1092	<
1093	<	//         await(locked);
1094	<	//         assertHasWaiters(lock, c, t);
1095	<	//         t.interrupt();
1096	<	//         awaitTermination(t);
1097	<	//         assertNotWriteLocked(lock);
1098	<	//     }
1099	<
1100	<	//     /**
1101	<	//      * signalAll wakes up all threads
1102	<	//      */
1103	<	//     public void testSignalAll_await()           { testSignalAll(false, AwaitMethod.await); }
1104	<	//     public void testSignalAll_await_fair()      { testSignalAll(true,  AwaitMethod.await); }
1105	<	//     public void testSignalAll_awaitTimed()      { testSignalAll(false, AwaitMethod.awaitTimed); }
1106	<	//     public void testSignalAll_awaitTimed_fair() { testSignalAll(true,  AwaitMethod.awaitTimed); }
1107	<	//     public void testSignalAll_awaitNanos()      { testSignalAll(false, AwaitMethod.awaitNanos); }
1108	<	//     public void testSignalAll_awaitNanos_fair() { testSignalAll(true,  AwaitMethod.awaitNanos); }
1109	<	//     public void testSignalAll_awaitUntil()      { testSignalAll(false, AwaitMethod.awaitUntil); }
1110	<	//     public void testSignalAll_awaitUntil_fair() { testSignalAll(true,  AwaitMethod.awaitUntil); }
1111	<	//     public void testSignalAll(boolean fair, final AwaitMethod awaitMethod) {
1112	<	//         final PublicReentrantReadWriteLock lock =
1113	<	//             new PublicReentrantReadWriteLock(fair);
1114	<	//         final Condition c = lock.writeLock().newCondition();
1115	<	//         final CountDownLatch locked = new CountDownLatch(2);
1116	<	//         final Lock writeLock = lock.writeLock();
1117	<	//         class Awaiter extends CheckedRunnable {
1118	<	//             public void realRun() throws InterruptedException {
1119	<	//                 writeLock.lock();
1120	<	//                 locked.countDown();
1121	<	//                 await(c, awaitMethod);
1122	<	//                 writeLock.unlock();
1123	<	//             }
1124	<	//         }
1125	<
1126	<	//         Thread t1 = newStartedThread(new Awaiter());
1127	<	//         Thread t2 = newStartedThread(new Awaiter());
1128	<
1129	<	//         await(locked);
1130	<	//         writeLock.lock();
1131	<	//         assertHasWaiters(lock, c, t1, t2);
1132	<	//         c.signalAll();
1133	<	//         assertHasNoWaiters(lock, c);
1134	<	//         writeLock.unlock();
1135	<	//         awaitTermination(t1);
1136	<	//         awaitTermination(t2);
1137	<	//     }
1138	<
1139	<	//     /**
1140	<	//      * signal wakes up waiting threads in FIFO order
1141	<	//      */
1142	<	//     public void testSignalWakesFifo()      { testSignalWakesFifo(false); }
1143	<	//     public void testSignalWakesFifo_fair() { testSignalWakesFifo(true); }
1144	<	//     public void testSignalWakesFifo(boolean fair) {
1145	<	//         final PublicReentrantReadWriteLock lock =
1146	<	//             new PublicReentrantReadWriteLock(fair);
1147	<	//         final Condition c = lock.writeLock().newCondition();
1148	<	//         final CountDownLatch locked1 = new CountDownLatch(1);
1149	<	//         final CountDownLatch locked2 = new CountDownLatch(1);
1150	<	//         final Lock writeLock = lock.writeLock();
1151	<	//         Thread t1 = newStartedThread(new CheckedRunnable() {
1152	<	//             public void realRun() throws InterruptedException {
1153	<	//                 writeLock.lock();
1154	<	//                 locked1.countDown();
1155	<	//                 c.await();
1156	<	//                 writeLock.unlock();
1157	<	//             }});
1158	<
1159	<	//         await(locked1);
1160	<
1161	<	//         Thread t2 = newStartedThread(new CheckedRunnable() {
1162	<	//             public void realRun() throws InterruptedException {
1163	<	//                 writeLock.lock();
1164	<	//                 locked2.countDown();
1165	<	//                 c.await();
1166	<	//                 writeLock.unlock();
1167	<	//             }});
1168	<
1169	<	//         await(locked2);
1170	<
1171	<	//         writeLock.lock();
1172	<	//         assertHasWaiters(lock, c, t1, t2);
1173	<	//         assertFalse(lock.hasQueuedThreads());
1174	<	//         c.signal();
1175	<	//         assertHasWaiters(lock, c, t2);
1176	<	//         assertTrue(lock.hasQueuedThread(t1));
1177	<	//         assertFalse(lock.hasQueuedThread(t2));
1178	<	//         c.signal();
1179	<	//         assertHasNoWaiters(lock, c);
1180	<	//         assertTrue(lock.hasQueuedThread(t1));
1181	<	//         assertTrue(lock.hasQueuedThread(t2));
1182	<	//         writeLock.unlock();
1183	<	//         awaitTermination(t1);
1184	<	//         awaitTermination(t2);
1185	<	//     }
1186	<
1187	<	//     /**
1188	<	//      * await after multiple reentrant locking preserves lock count
1189	<	//      */
1190	<	//     public void testAwaitLockCount()      { testAwaitLockCount(false); }
1191	<	//     public void testAwaitLockCount_fair() { testAwaitLockCount(true); }
1192	<	//     public void testAwaitLockCount(boolean fair) {
1193	<	//         final PublicReentrantReadWriteLock lock =
1194	<	//             new PublicReentrantReadWriteLock(fair);
1195	<	//         final Condition c = lock.writeLock().newCondition();
1196	<	//         final CountDownLatch locked = new CountDownLatch(2);
1197	<	//         Thread t1 = newStartedThread(new CheckedRunnable() {
1198	<	//             public void realRun() throws InterruptedException {
1199	<	//                 lock.writeLock().lock();
1200	<	//                 assertWriteLockedByMoi(lock);
1201	<	//                 assertEquals(1, lock.writeLock().getHoldCount());
1202	<	//                 locked.countDown();
1203	<	//                 c.await();
1204	<	//                 assertWriteLockedByMoi(lock);
1205	<	//                 assertEquals(1, lock.writeLock().getHoldCount());
1206	<	//                 lock.writeLock().unlock();
1207	<	//             }});
1208	<
1209	<	//         Thread t2 = newStartedThread(new CheckedRunnable() {
1210	<	//             public void realRun() throws InterruptedException {
1211	<	//                 lock.writeLock().lock();
1212	<	//                 lock.writeLock().lock();
1213	<	//                 assertWriteLockedByMoi(lock);
1214	<	//                 assertEquals(2, lock.writeLock().getHoldCount());
1215	<	//                 locked.countDown();
1216	<	//                 c.await();
1217	<	//                 assertWriteLockedByMoi(lock);
1218	<	//                 assertEquals(2, lock.writeLock().getHoldCount());
1219	<	//                 lock.writeLock().unlock();
1220	<	//                 lock.writeLock().unlock();
1221	<	//             }});
1222	<
1223	<	//         await(locked);
1224	<	//         lock.writeLock().lock();
1225	<	//         assertHasWaiters(lock, c, t1, t2);
1226	<	//         c.signalAll();
1227	<	//         assertHasNoWaiters(lock, c);
1228	<	//         lock.writeLock().unlock();
1229	<	//         awaitTermination(t1);
1230	<	//         awaitTermination(t2);
1231	<	//     }
1232	<
1233	<	//     /**
1234	<	//      * A serialized lock deserializes as unlocked
1235	<	//      */
1236	<	//     public void testSerialization()      { testSerialization(false); }
1237	<	//     public void testSerialization_fair() { testSerialization(true); }
1238	<	//     public void testSerialization(boolean fair) {
1239	<	//         ReentrantReadWriteLock lock = new ReentrantReadWriteLock(fair);
1240	<	//         lock.writeLock().lock();
1241	<	//         lock.readLock().lock();
1242	<
1243	<	//         ReentrantReadWriteLock clone = serialClone(lock);
1244	<	//         assertEquals(lock.isFair(), clone.isFair());
1245	<	//         assertTrue(lock.isWriteLocked());
1246	<	//         assertFalse(clone.isWriteLocked());
1247	<	//         assertEquals(1, lock.getReadLockCount());
1248	<	//         assertEquals(0, clone.getReadLockCount());
1249	<	//         clone.writeLock().lock();
1250	<	//         clone.readLock().lock();
1251	<	//         assertTrue(clone.isWriteLocked());
1252	<	//         assertEquals(1, clone.getReadLockCount());
1253	<	//         clone.readLock().unlock();
1254	<	//         clone.writeLock().unlock();
1255	<	//         assertFalse(clone.isWriteLocked());
1256	<	//         assertEquals(1, lock.getReadLockCount());
1257	<	//         assertEquals(0, clone.getReadLockCount());
1258	<	//     }
1259	<
1260	<	//     /**
1261	<	//      * hasQueuedThreads reports whether there are waiting threads
1262	<	//      */
1263	<	//     public void testHasQueuedThreads()      { testHasQueuedThreads(false); }
1264	<	//     public void testHasQueuedThreads_fair() { testHasQueuedThreads(true); }
1265	<	//     public void testHasQueuedThreads(boolean fair) {
1266	<	//         final PublicReentrantReadWriteLock lock =
1267	<	//             new PublicReentrantReadWriteLock(fair);
1268	<	//         Thread t1 = new Thread(new InterruptedLockRunnable(lock));
1269	<	//         Thread t2 = new Thread(new InterruptibleLockRunnable(lock));
1270	<	//         assertFalse(lock.hasQueuedThreads());
1271	<	//         lock.writeLock().lock();
1272	<	//         assertFalse(lock.hasQueuedThreads());
1273	<	//         t1.start();
1274	<	//         waitForQueuedThread(lock, t1);
1275	<	//         assertTrue(lock.hasQueuedThreads());
1276	<	//         t2.start();
1277	<	//         waitForQueuedThread(lock, t2);
1278	<	//         assertTrue(lock.hasQueuedThreads());
1279	<	//         t1.interrupt();
1280	<	//         awaitTermination(t1);
1281	<	//         assertTrue(lock.hasQueuedThreads());
1282	<	//         lock.writeLock().unlock();
1283	<	//         awaitTermination(t2);
1284	<	//         assertFalse(lock.hasQueuedThreads());
1285	<	//     }
1286	<
1287	<	//     /**
1288	<	//      * hasQueuedThread(null) throws NPE
1289	<	//      */
1290	<	//     public void testHasQueuedThreadNPE()      { testHasQueuedThreadNPE(false); }
1291	<	//     public void testHasQueuedThreadNPE_fair() { testHasQueuedThreadNPE(true); }
1292	<	//     public void testHasQueuedThreadNPE(boolean fair) {
1293	<	//         final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(fair);
1294	<	//         try {
1295	<	//             lock.hasQueuedThread(null);
1296	<	//             shouldThrow();
1297	<	//         } catch (NullPointerException success) {}
1298	<	//     }
1299	<
1300	<	//     /**
1301	<	//      * hasQueuedThread reports whether a thread is queued
1302	<	//      */
1303	<	//     public void testHasQueuedThread()      { testHasQueuedThread(false); }
1304	<	//     public void testHasQueuedThread_fair() { testHasQueuedThread(true); }
1305	<	//     public void testHasQueuedThread(boolean fair) {
1306	<	//         final PublicReentrantReadWriteLock lock =
1307	<	//             new PublicReentrantReadWriteLock(fair);
1308	<	//         Thread t1 = new Thread(new InterruptedLockRunnable(lock));
1309	<	//         Thread t2 = new Thread(new InterruptibleLockRunnable(lock));
1310	<	//         assertFalse(lock.hasQueuedThread(t1));
1311	<	//         assertFalse(lock.hasQueuedThread(t2));
1312	<	//         lock.writeLock().lock();
1313	<	//         t1.start();
1314	<	//         waitForQueuedThread(lock, t1);
1315	<	//         assertTrue(lock.hasQueuedThread(t1));
1316	<	//         assertFalse(lock.hasQueuedThread(t2));
1317	<	//         t2.start();
1318	<	//         waitForQueuedThread(lock, t2);
1319	<	//         assertTrue(lock.hasQueuedThread(t1));
1320	<	//         assertTrue(lock.hasQueuedThread(t2));
1321	<	//         t1.interrupt();
1322	<	//         awaitTermination(t1);
1323	<	//         assertFalse(lock.hasQueuedThread(t1));
1324	<	//         assertTrue(lock.hasQueuedThread(t2));
1325	<	//         lock.writeLock().unlock();
1326	<	//         awaitTermination(t2);
1327	<	//         assertFalse(lock.hasQueuedThread(t1));
1328	<	//         assertFalse(lock.hasQueuedThread(t2));
1329	<	//     }
1330	<
1331	<	//     /**
1332	<	//      * getQueueLength reports number of waiting threads
1333	<	//      */
1334	<	//     public void testGetQueueLength()      { testGetQueueLength(false); }
1335	<	//     public void testGetQueueLength_fair() { testGetQueueLength(true); }
1336	<	//     public void testGetQueueLength(boolean fair) {
1337	<	//         final PublicReentrantReadWriteLock lock =
1338	<	//             new PublicReentrantReadWriteLock(fair);
1339	<	//         Thread t1 = new Thread(new InterruptedLockRunnable(lock));
1340	<	//         Thread t2 = new Thread(new InterruptibleLockRunnable(lock));
1341	<	//         assertEquals(0, lock.getQueueLength());
1342	<	//         lock.writeLock().lock();
1343	<	//         t1.start();
1344	<	//         waitForQueuedThread(lock, t1);
1345	<	//         assertEquals(1, lock.getQueueLength());
1346	<	//         t2.start();
1347	<	//         waitForQueuedThread(lock, t2);
1348	<	//         assertEquals(2, lock.getQueueLength());
1349	<	//         t1.interrupt();
1350	<	//         awaitTermination(t1);
1351	<	//         assertEquals(1, lock.getQueueLength());
1352	<	//         lock.writeLock().unlock();
1353	<	//         awaitTermination(t2);
1354	<	//         assertEquals(0, lock.getQueueLength());
1355	<	//     }
1356	<
1357	<	//     /**
1358	<	//      * getQueuedThreads includes waiting threads
1359	<	//      */
1360	<	//     public void testGetQueuedThreads()      { testGetQueuedThreads(false); }
1361	<	//     public void testGetQueuedThreads_fair() { testGetQueuedThreads(true); }
1362	<	//     public void testGetQueuedThreads(boolean fair) {
1363	<	//         final PublicReentrantReadWriteLock lock =
1364	<	//             new PublicReentrantReadWriteLock(fair);
1365	<	//         Thread t1 = new Thread(new InterruptedLockRunnable(lock));
1366	<	//         Thread t2 = new Thread(new InterruptibleLockRunnable(lock));
1367	<	//         assertTrue(lock.getQueuedThreads().isEmpty());
1368	<	//         lock.writeLock().lock();
1369	<	//         assertTrue(lock.getQueuedThreads().isEmpty());
1370	<	//         t1.start();
1371	<	//         waitForQueuedThread(lock, t1);
1372	<	//         assertEquals(1, lock.getQueuedThreads().size());
1373	<	//         assertTrue(lock.getQueuedThreads().contains(t1));
1374	<	//         t2.start();
1375	<	//         waitForQueuedThread(lock, t2);
1376	<	//         assertEquals(2, lock.getQueuedThreads().size());
1377	<	//         assertTrue(lock.getQueuedThreads().contains(t1));
1378	<	//         assertTrue(lock.getQueuedThreads().contains(t2));
1379	<	//         t1.interrupt();
1380	<	//         awaitTermination(t1);
1381	<	//         assertFalse(lock.getQueuedThreads().contains(t1));
1382	<	//         assertTrue(lock.getQueuedThreads().contains(t2));
1383	<	//         assertEquals(1, lock.getQueuedThreads().size());
1384	<	//         lock.writeLock().unlock();
1385	<	//         awaitTermination(t2);
1386	<	//         assertTrue(lock.getQueuedThreads().isEmpty());
1387	<	//     }
1388	<
1389	<	//     /**
1390	<	//      * hasWaiters throws NPE if null
1391	<	//      */
1392	<	//     public void testHasWaitersNPE()      { testHasWaitersNPE(false); }
1393	<	//     public void testHasWaitersNPE_fair() { testHasWaitersNPE(true); }
1394	<	//     public void testHasWaitersNPE(boolean fair) {
1395	<	//         final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(fair);
1396	<	//         try {
1397	<	//             lock.hasWaiters(null);
1398	<	//             shouldThrow();
1399	<	//         } catch (NullPointerException success) {}
1400	<	//     }
1401	<
1402	<	//     /**
1403	<	//      * getWaitQueueLength throws NPE if null
1404	<	//      */
1405	<	//     public void testGetWaitQueueLengthNPE()      { testGetWaitQueueLengthNPE(false); }
1406	<	//     public void testGetWaitQueueLengthNPE_fair() { testGetWaitQueueLengthNPE(true); }
1407	<	//     public void testGetWaitQueueLengthNPE(boolean fair) {
1408	<	//         final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(fair);
1409	<	//         try {
1410	<	//             lock.getWaitQueueLength(null);
1411	<	//             shouldThrow();
1412	<	//         } catch (NullPointerException success) {}
1413	<	//     }
1414	<
1415	<	//     /**
1416	<	//      * getWaitingThreads throws NPE if null
1417	<	//      */
1418	<	//     public void testGetWaitingThreadsNPE()      { testGetWaitingThreadsNPE(false); }
1419	<	//     public void testGetWaitingThreadsNPE_fair() { testGetWaitingThreadsNPE(true); }
1420	<	//     public void testGetWaitingThreadsNPE(boolean fair) {
1421	<	//         final PublicReentrantReadWriteLock lock = new PublicReentrantReadWriteLock(fair);
1422	<	//         try {
1423	<	//             lock.getWaitingThreads(null);
1424	<	//             shouldThrow();
1425	<	//         } catch (NullPointerException success) {}
1426	<	//     }
1427	<
1428	<	//     /**
1429	<	//      * hasWaiters throws IllegalArgumentException if not owned
1430	<	//      */
1431	<	//     public void testHasWaitersIAE()      { testHasWaitersIAE(false); }
1432	<	//     public void testHasWaitersIAE_fair() { testHasWaitersIAE(true); }
1433	<	//     public void testHasWaitersIAE(boolean fair) {
1434	<	//         final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(fair);
1435	<	//         final Condition c = lock.writeLock().newCondition();
1436	<	//         final ReentrantReadWriteLock lock2 = new ReentrantReadWriteLock(fair);
1437	<	//         try {
1438	<	//             lock2.hasWaiters(c);
1439	<	//             shouldThrow();
1440	<	//         } catch (IllegalArgumentException success) {}
1441	<	//     }
1442	<
1443	<	//     /**
1444	<	//      * hasWaiters throws IllegalMonitorStateException if not locked
1445	<	//      */
1446	<	//     public void testHasWaitersIMSE()      { testHasWaitersIMSE(false); }
1447	<	//     public void testHasWaitersIMSE_fair() { testHasWaitersIMSE(true); }
1448	<	//     public void testHasWaitersIMSE(boolean fair) {
1449	<	//         final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(fair);
1450	<	//         final Condition c = lock.writeLock().newCondition();
1451	<	//         try {
1452	<	//             lock.hasWaiters(c);
1453	<	//             shouldThrow();
1454	<	//         } catch (IllegalMonitorStateException success) {}
1455	<	//     }
1456	<
1457	<	//     /**
1458	<	//      * getWaitQueueLength throws IllegalArgumentException if not owned
1459	<	//      */
1460	<	//     public void testGetWaitQueueLengthIAE()      { testGetWaitQueueLengthIAE(false); }
1461	<	//     public void testGetWaitQueueLengthIAE_fair() { testGetWaitQueueLengthIAE(true); }
1462	<	//     public void testGetWaitQueueLengthIAE(boolean fair) {
1463	<	//         final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(fair);
1464	<	//         final Condition c = lock.writeLock().newCondition();
1465	<	//         final ReentrantReadWriteLock lock2 = new ReentrantReadWriteLock(fair);
1466	<	//         try {
1467	<	//             lock2.getWaitQueueLength(c);
1468	<	//             shouldThrow();
1469	<	//         } catch (IllegalArgumentException success) {}
1470	<	//     }
1471	<
1472	<	//     /**
1473	<	//      * getWaitQueueLength throws IllegalMonitorStateException if not locked
1474	<	//      */
1475	<	//     public void testGetWaitQueueLengthIMSE()      { testGetWaitQueueLengthIMSE(false); }
1476	<	//     public void testGetWaitQueueLengthIMSE_fair() { testGetWaitQueueLengthIMSE(true); }
1477	<	//     public void testGetWaitQueueLengthIMSE(boolean fair) {
1478	<	//         final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(fair);
1479	<	//         final Condition c = lock.writeLock().newCondition();
1480	<	//         try {
1481	<	//             lock.getWaitQueueLength(c);
1482	<	//             shouldThrow();
1483	<	//         } catch (IllegalMonitorStateException success) {}
1484	<	//     }
1485	<
1486	<	//     /**
1487	<	//      * getWaitingThreads throws IllegalArgumentException if not owned
1488	<	//      */
1489	<	//     public void testGetWaitingThreadsIAE()      { testGetWaitingThreadsIAE(false); }
1490	<	//     public void testGetWaitingThreadsIAE_fair() { testGetWaitingThreadsIAE(true); }
1491	<	//     public void testGetWaitingThreadsIAE(boolean fair) {
1492	<	//         final PublicReentrantReadWriteLock lock =
1493	<	//             new PublicReentrantReadWriteLock(fair);
1494	<	//         final Condition c = lock.writeLock().newCondition();
1495	<	//         final PublicReentrantReadWriteLock lock2 =
1496	<	//             new PublicReentrantReadWriteLock(fair);
1497	<	//         try {
1498	<	//             lock2.getWaitingThreads(c);
1499	<	//             shouldThrow();
1500	<	//         } catch (IllegalArgumentException success) {}
1501	<	//     }
1502	<
1503	<	//     /**
1504	<	//      * getWaitingThreads throws IllegalMonitorStateException if not locked
1505	<	//      */
1506	<	//     public void testGetWaitingThreadsIMSE()      { testGetWaitingThreadsIMSE(false); }
1507	<	//     public void testGetWaitingThreadsIMSE_fair() { testGetWaitingThreadsIMSE(true); }
1508	<	//     public void testGetWaitingThreadsIMSE(boolean fair) {
1509	<	//         final PublicReentrantReadWriteLock lock =
1510	<	//             new PublicReentrantReadWriteLock(fair);
1511	<	//         final Condition c = lock.writeLock().newCondition();
1512	<	//         try {
1513	<	//             lock.getWaitingThreads(c);
1514	<	//             shouldThrow();
1515	<	//         } catch (IllegalMonitorStateException success) {}
1516	<	//     }
1517	<
1518	<	//     /**
1519	<	//      * hasWaiters returns true when a thread is waiting, else false
1520	<	//      */
1521	<	//     public void testHasWaiters()      { testHasWaiters(false); }
1522	<	//     public void testHasWaiters_fair() { testHasWaiters(true); }
1523	<	//     public void testHasWaiters(boolean fair) {
1524	<	//         final PublicReentrantReadWriteLock lock =
1525	<	//             new PublicReentrantReadWriteLock(fair);
1526	<	//         final Condition c = lock.writeLock().newCondition();
1527	<	//         final CountDownLatch locked = new CountDownLatch(1);
1528	<	//         Thread t = newStartedThread(new CheckedRunnable() {
1529	<	//             public void realRun() throws InterruptedException {
1530	<	//                 lock.writeLock().lock();
1531	<	//                 assertHasNoWaiters(lock, c);
1532	<	//                 assertFalse(lock.hasWaiters(c));
1533	<	//                 locked.countDown();
1534	<	//                 c.await();
1535	<	//                 assertHasNoWaiters(lock, c);
1536	<	//                 assertFalse(lock.hasWaiters(c));
1537	<	//                 lock.writeLock().unlock();
1538	<	//             }});
1539	<
1540	<	//         await(locked);
1541	<	//         lock.writeLock().lock();
1542	<	//         assertHasWaiters(lock, c, t);
1543	<	//         assertTrue(lock.hasWaiters(c));
1544	<	//         c.signal();
1545	<	//         assertHasNoWaiters(lock, c);
1546	<	//         assertFalse(lock.hasWaiters(c));
1547	<	//         lock.writeLock().unlock();
1548	<	//         awaitTermination(t);
1549	<	//         assertHasNoWaiters(lock, c);
1550	<	//     }
1551	<
1552	<	//     /**
1553	<	//      * getWaitQueueLength returns number of waiting threads
1554	<	//      */
1555	<	//     public void testGetWaitQueueLength()      { testGetWaitQueueLength(false); }
1556	<	//     public void testGetWaitQueueLength_fair() { testGetWaitQueueLength(true); }
1557	<	//     public void testGetWaitQueueLength(boolean fair) {
1558	<	//         final PublicReentrantReadWriteLock lock =
1559	<	//             new PublicReentrantReadWriteLock(fair);
1560	<	//         final Condition c = lock.writeLock().newCondition();
1561	<	//         final CountDownLatch locked = new CountDownLatch(1);
1562	<	//         Thread t = newStartedThread(new CheckedRunnable() {
1563	<	//             public void realRun() throws InterruptedException {
1564	<	//                 lock.writeLock().lock();
1565	<	//                 assertEquals(0, lock.getWaitQueueLength(c));
1566	<	//                 locked.countDown();
1567	<	//                 c.await();
1568	<	//                 lock.writeLock().unlock();
1569	<	//             }});
1570	<
1571	<	//         await(locked);
1572	<	//         lock.writeLock().lock();
1573	<	//         assertHasWaiters(lock, c, t);
1574	<	//         assertEquals(1, lock.getWaitQueueLength(c));
1575	<	//         c.signal();
1576	<	//         assertHasNoWaiters(lock, c);
1577	<	//         assertEquals(0, lock.getWaitQueueLength(c));
1578	<	//         lock.writeLock().unlock();
1579	<	//         awaitTermination(t);
1580	<	//     }
1581	<
1582	<	//     /**
1583	<	//      * getWaitingThreads returns only and all waiting threads
1584	<	//      */
1585	<	//     public void testGetWaitingThreads()      { testGetWaitingThreads(false); }
1586	<	//     public void testGetWaitingThreads_fair() { testGetWaitingThreads(true); }
1587	<	//     public void testGetWaitingThreads(boolean fair) {
1588	<	//         final PublicReentrantReadWriteLock lock =
1589	<	//             new PublicReentrantReadWriteLock(fair);
1590	<	//         final Condition c = lock.writeLock().newCondition();
1591	<	//         final CountDownLatch locked1 = new CountDownLatch(1);
1592	<	//         final CountDownLatch locked2 = new CountDownLatch(1);
1593	<	//         Thread t1 = new Thread(new CheckedRunnable() {
1594	<	//             public void realRun() throws InterruptedException {
1595	<	//                 lock.writeLock().lock();
1596	<	//                 assertTrue(lock.getWaitingThreads(c).isEmpty());
1597	<	//                 locked1.countDown();
1598	<	//                 c.await();
1599	<	//                 lock.writeLock().unlock();
1600	<	//             }});
1601	<
1602	<	//         Thread t2 = new Thread(new CheckedRunnable() {
1603	<	//             public void realRun() throws InterruptedException {
1604	<	//                 lock.writeLock().lock();
1605	<	//                 assertFalse(lock.getWaitingThreads(c).isEmpty());
1606	<	//                 locked2.countDown();
1607	<	//                 c.await();
1608	<	//                 lock.writeLock().unlock();
1609	<	//             }});
1610	<
1611	<	//         lock.writeLock().lock();
1612	<	//         assertTrue(lock.getWaitingThreads(c).isEmpty());
1613	<	//         lock.writeLock().unlock();
1614	<
1615	<	//         t1.start();
1616	<	//         await(locked1);
1617	<	//         t2.start();
1618	<	//         await(locked2);
1619	<
1620	<	//         lock.writeLock().lock();
1621	<	//         assertTrue(lock.hasWaiters(c));
1622	<	//         assertTrue(lock.getWaitingThreads(c).contains(t1));
1623	<	//         assertTrue(lock.getWaitingThreads(c).contains(t2));
1624	<	//         assertEquals(2, lock.getWaitingThreads(c).size());
1625	<	//         c.signalAll();
1626	<	//         assertHasNoWaiters(lock, c);
1627	<	//         lock.writeLock().unlock();
1628	<
1629	<	//         awaitTermination(t1);
1630	<	//         awaitTermination(t2);
1631	<
1632	<	//         assertHasNoWaiters(lock, c);
1633	<	//     }
1634	<
1635	<	//     /**
1636	<	//      * toString indicates current lock state
1637	<	//      */
1638	<	//     public void testToString()      { testToString(false); }
1639	<	//     public void testToString_fair() { testToString(true); }
1640	<	//     public void testToString(boolean fair) {
1641	<	//         ReentrantReadWriteLock lock = new ReentrantReadWriteLock(fair);
1642	<	//         assertTrue(lock.toString().contains("Write locks = 0"));
1643	<	//         assertTrue(lock.toString().contains("Read locks = 0"));
1644	<	//         lock.writeLock().lock();
1645	<	//         assertTrue(lock.toString().contains("Write locks = 1"));
1646	<	//         assertTrue(lock.toString().contains("Read locks = 0"));
1647	<	//         lock.writeLock().unlock();
1648	<	//         lock.readLock().lock();
1649	<	//         lock.readLock().lock();
1650	<	//         assertTrue(lock.toString().contains("Write locks = 0"));
1651	<	//         assertTrue(lock.toString().contains("Read locks = 2"));
1652	<	//     }
1653	<
1654	<	//     /**
1655	<	//      * readLock.toString indicates current lock state
1656	<	//      */
1657	<	//     public void testReadLockToString()      { testReadLockToString(false); }
1658	<	//     public void testReadLockToString_fair() { testReadLockToString(true); }
1659	<	//     public void testReadLockToString(boolean fair) {
1660	<	//         ReentrantReadWriteLock lock = new ReentrantReadWriteLock(fair);
1661	<	//         assertTrue(lock.readLock().toString().contains("Read locks = 0"));
1662	<	//         lock.readLock().lock();
1663	<	//         lock.readLock().lock();
1664	<	//         assertTrue(lock.readLock().toString().contains("Read locks = 2"));
1665	<	//     }
1666	<
1667	<	//     /**
1668	<	//      * writeLock.toString indicates current lock state
1669	<	//      */
1670	<	//     public void testWriteLockToString()      { testWriteLockToString(false); }
1671	<	//     public void testWriteLockToString_fair() { testWriteLockToString(true); }
1672	<	//     public void testWriteLockToString(boolean fair) {
1673	<	//         ReentrantReadWriteLock lock = new ReentrantReadWriteLock(fair);
1674	<	//         assertTrue(lock.writeLock().toString().contains("Unlocked"));
1675	<	//         lock.writeLock().lock();
1676	<	//         assertTrue(lock.writeLock().toString().contains("Locked"));
1677	<	//         lock.writeLock().unlock();
1678	<	//         assertTrue(lock.writeLock().toString().contains("Unlocked"));
1679	<	//     }
180	>	/**
181	>	* tryUnlockWrite fails if not write locked
182	>	*/
183	>	public void testTryUnlockWrite_failure() {
184	>	StampedLock lock = new StampedLock();
185	>	assertFalse(lock.tryUnlockWrite());
186	>
187	>	for (Function<StampedLock, Long> readLocker : readLockers())
188	>	for (BiConsumer<StampedLock, Long> readUnlocker : readUnlockers()) {
189	>	long s = assertValid(lock, readLocker.apply(lock));
190	>	assertFalse(lock.tryUnlockWrite());
191	>	assertTrue(lock.isReadLocked());
192	>	readUnlocker.accept(lock, s);
193	>	assertUnlocked(lock);
194	>	}
195	>	}
196
197	+	/**
198	+	* tryUnlockRead fails if not read locked
199	+	*/
200	+	public void testTryUnlockRead_failure() {
201	+	StampedLock lock = new StampedLock();
202	+	assertFalse(lock.tryUnlockRead());
203	+
204	+	for (Function<StampedLock, Long> writeLocker : writeLockers())
205	+	for (BiConsumer<StampedLock, Long> writeUnlocker : writeUnlockers()) {
206	+	long s = writeLocker.apply(lock);
207	+	assertFalse(lock.tryUnlockRead());
208	+	assertTrue(lock.isWriteLocked());
209	+	writeUnlocker.accept(lock, s);
210	+	assertUnlocked(lock);
211	+	}
212	+	}
213	+
214	+	/**
215	+	* validate(0L) fails
216	+	*/
217	+	public void testValidate0() {
218	+	StampedLock lock = new StampedLock();
219	+	assertFalse(lock.validate(0L));
220	+	}
221	+
222	+	/**
223	+	* A stamp obtained from a successful lock operation validates while the lock is held
224	+	*/
225	+	public void testValidate() throws InterruptedException {
226	+	StampedLock lock = new StampedLock();
227	+
228	+	for (Function<StampedLock, Long> readLocker : readLockers())
229	+	for (BiConsumer<StampedLock, Long> readUnlocker : readUnlockers()) {
230	+	long s = assertNonZero(readLocker.apply(lock));
231	+	assertTrue(lock.validate(s));
232	+	readUnlocker.accept(lock, s);
233	+	}
234	+
235	+	for (Function<StampedLock, Long> writeLocker : writeLockers())
236	+	for (BiConsumer<StampedLock, Long> writeUnlocker : writeUnlockers()) {
237	+	long s = assertNonZero(writeLocker.apply(lock));
238	+	assertTrue(lock.validate(s));
239	+	writeUnlocker.accept(lock, s);
240	+	}
241	+	}
242	+
243	+	/**
244	+	* A stamp obtained from an unsuccessful lock operation does not validate
245	+	*/
246	+	public void testValidate2() throws InterruptedException {
247	+	StampedLock lock = new StampedLock();
248	+	long s = assertNonZero(lock.writeLock());
249	+	assertTrue(lock.validate(s));
250	+	assertFalse(lock.validate(lock.tryWriteLock()));
251	+	assertFalse(lock.validate(lock.tryWriteLock(0L, SECONDS)));
252	+	assertFalse(lock.validate(lock.tryReadLock()));
253	+	assertFalse(lock.validate(lock.tryReadLock(0L, SECONDS)));
254	+	assertFalse(lock.validate(lock.tryOptimisticRead()));
255	+	lock.unlockWrite(s);
256	+	}
257	+
258	+	void assertThrowInterruptedExceptionWhenPreInterrupted(Action[] actions) {
259	+	for (Action action : actions) {
260	+	Thread.currentThread().interrupt();
261	+	try {
262	+	action.run();
263	+	shouldThrow();
264	+	}
265	+	catch (InterruptedException success) {}
266	+	catch (Throwable fail) { threadUnexpectedException(fail); }
267	+	assertFalse(Thread.interrupted());
268	+	}
269	+	}
270	+
271	+	/**
272	+	* interruptible operations throw InterruptedException when pre-interrupted
273	+	*/
274	+	public void testInterruptibleOperationsThrowInterruptedExceptionWhenPreInterrupted() {
275	+	final CountDownLatch running = new CountDownLatch(1);
276	+	final StampedLock lock = new StampedLock();
277	+
278	+	Action[] interruptibleLockActions = {
279	+	() -> lock.writeLockInterruptibly(),
280	+	() -> lock.tryWriteLock(Long.MIN_VALUE, DAYS),
281	+	() -> lock.tryWriteLock(Long.MAX_VALUE, DAYS),
282	+	() -> lock.readLockInterruptibly(),
283	+	() -> lock.tryReadLock(Long.MIN_VALUE, DAYS),
284	+	() -> lock.tryReadLock(Long.MAX_VALUE, DAYS),
285	+	() -> lock.asWriteLock().lockInterruptibly(),
286	+	() -> lock.asWriteLock().tryLock(0L, DAYS),
287	+	() -> lock.asWriteLock().tryLock(Long.MAX_VALUE, DAYS),
288	+	() -> lock.asReadLock().lockInterruptibly(),
289	+	() -> lock.asReadLock().tryLock(0L, DAYS),
290	+	() -> lock.asReadLock().tryLock(Long.MAX_VALUE, DAYS),
291	+	};
292	+	shuffle(interruptibleLockActions);
293	+
294	+	assertThrowInterruptedExceptionWhenPreInterrupted(interruptibleLockActions);
295	+	{
296	+	long s = lock.writeLock();
297	+	assertThrowInterruptedExceptionWhenPreInterrupted(interruptibleLockActions);
298	+	lock.unlockWrite(s);
299	+	}
300	+	{
301	+	long s = lock.readLock();
302	+	assertThrowInterruptedExceptionWhenPreInterrupted(interruptibleLockActions);
303	+	lock.unlockRead(s);
304	+	}
305	+	}
306	+
307	+	void assertThrowInterruptedExceptionWhenInterrupted(Action[] actions) {
308	+	int n = actions.length;
309	+	Future<?>[] futures = new Future<?>[n];
310	+	CountDownLatch threadsStarted = new CountDownLatch(n);
311	+	CountDownLatch done = new CountDownLatch(n);
312	+
313	+	for (int i = 0; i < n; i++) {
314	+	Action action = actions[i];
315	+	futures[i] = cachedThreadPool.submit(new CheckedRunnable() {
316	+	public void realRun() throws Throwable {
317	+	threadsStarted.countDown();
318	+	try {
319	+	action.run();
320	+	shouldThrow();
321	+	}
322	+	catch (InterruptedException success) {}
323	+	catch (Throwable fail) { threadUnexpectedException(fail); }
324	+	assertFalse(Thread.interrupted());
325	+	done.countDown();
326	+	}});
327	+	}
328	+
329	+	await(threadsStarted);
330	+	assertEquals(n, done.getCount());
331	+	for (Future<?> future : futures) // Interrupt all the tasks
332	+	future.cancel(true);
333	+	await(done);
334	+	}
335	+
336	+	/**
337	+	* interruptible operations throw InterruptedException when write locked and interrupted
338	+	*/
339	+	public void testInterruptibleOperationsThrowInterruptedExceptionWriteLockedInterrupted() {
340	+	final CountDownLatch running = new CountDownLatch(1);
341	+	final StampedLock lock = new StampedLock();
342	+	long s = lock.writeLock();
343	+
344	+	Action[] interruptibleLockBlockingActions = {
345	+	() -> lock.writeLockInterruptibly(),
346	+	() -> lock.tryWriteLock(Long.MAX_VALUE, DAYS),
347	+	() -> lock.readLockInterruptibly(),
348	+	() -> lock.tryReadLock(Long.MAX_VALUE, DAYS),
349	+	() -> lock.asWriteLock().lockInterruptibly(),
350	+	() -> lock.asWriteLock().tryLock(Long.MAX_VALUE, DAYS),
351	+	() -> lock.asReadLock().lockInterruptibly(),
352	+	() -> lock.asReadLock().tryLock(Long.MAX_VALUE, DAYS),
353	+	};
354	+	shuffle(interruptibleLockBlockingActions);
355	+
356	+	assertThrowInterruptedExceptionWhenInterrupted(interruptibleLockBlockingActions);
357	+	}
358	+
359	+	/**
360	+	* interruptible operations throw InterruptedException when read locked and interrupted
361	+	*/
362	+	public void testInterruptibleOperationsThrowInterruptedExceptionReadLockedInterrupted() {
363	+	final CountDownLatch running = new CountDownLatch(1);
364	+	final StampedLock lock = new StampedLock();
365	+	long s = lock.readLock();
366	+
367	+	Action[] interruptibleLockBlockingActions = {
368	+	() -> lock.writeLockInterruptibly(),
369	+	() -> lock.tryWriteLock(Long.MAX_VALUE, DAYS),
370	+	() -> lock.asWriteLock().lockInterruptibly(),
371	+	() -> lock.asWriteLock().tryLock(Long.MAX_VALUE, DAYS),
372	+	};
373	+	shuffle(interruptibleLockBlockingActions);
374	+
375	+	assertThrowInterruptedExceptionWhenInterrupted(interruptibleLockBlockingActions);
376	+	}
377	+
378	+	/**
379	+	* Non-interruptible operations ignore and preserve interrupt status
380	+	*/
381	+	public void testNonInterruptibleOperationsIgnoreInterrupts() {
382	+	final StampedLock lock = new StampedLock();
383	+	Thread.currentThread().interrupt();
384	+
385	+	for (BiConsumer<StampedLock, Long> readUnlocker : readUnlockers()) {
386	+	long s = assertValid(lock, lock.readLock());
387	+	readUnlocker.accept(lock, s);
388	+	s = assertValid(lock, lock.tryReadLock());
389	+	readUnlocker.accept(lock, s);
390	+	}
391	+
392	+	lock.asReadLock().lock();
393	+	lock.asReadLock().unlock();
394	+
395	+	for (BiConsumer<StampedLock, Long> writeUnlocker : writeUnlockers()) {
396	+	long s = assertValid(lock, lock.writeLock());
397	+	writeUnlocker.accept(lock, s);
398	+	s = assertValid(lock, lock.tryWriteLock());
399	+	writeUnlocker.accept(lock, s);
400	+	}
401	+
402	+	lock.asWriteLock().lock();
403	+	lock.asWriteLock().unlock();
404	+
405	+	assertTrue(Thread.interrupted());
406	+	}
407	+
408	+	/**
409	+	* tryWriteLock on an unlocked lock succeeds
410	+	*/
411	+	public void testTryWriteLock() {
412	+	final StampedLock lock = new StampedLock();
413	+	long s = lock.tryWriteLock();
414	+	assertTrue(s != 0L);
415	+	assertTrue(lock.isWriteLocked());
416	+	assertEquals(0L, lock.tryWriteLock());
417	+	releaseWriteLock(lock, s);
418	+	}
419	+
420	+	/**
421	+	* tryWriteLock fails if locked
422	+	*/
423	+	public void testTryWriteLockWhenLocked() {
424	+	final StampedLock lock = new StampedLock();
425	+	long s = lock.writeLock();
426	+	Thread t = newStartedThread(new CheckedRunnable() {
427	+	public void realRun() {
428	+	assertEquals(0L, lock.tryWriteLock());
429	+	}});
430	+
431	+	assertEquals(0L, lock.tryWriteLock());
432	+	awaitTermination(t);
433	+	releaseWriteLock(lock, s);
434	+	}
435	+
436	+	/**
437	+	* tryReadLock fails if write-locked
438	+	*/
439	+	public void testTryReadLockWhenLocked() {
440	+	final StampedLock lock = new StampedLock();
441	+	long s = lock.writeLock();
442	+	Thread t = newStartedThread(new CheckedRunnable() {
443	+	public void realRun() {
444	+	assertEquals(0L, lock.tryReadLock());
445	+	}});
446	+
447	+	assertEquals(0L, lock.tryReadLock());
448	+	awaitTermination(t);
449	+	releaseWriteLock(lock, s);
450	+	}
451	+
452	+	/**
453	+	* Multiple threads can hold a read lock when not write-locked
454	+	*/
455	+	public void testMultipleReadLocks() {
456	+	final StampedLock lock = new StampedLock();
457	+	final long s = lock.readLock();
458	+	Thread t = newStartedThread(new CheckedRunnable() {
459	+	public void realRun() throws InterruptedException {
460	+	long s2 = lock.tryReadLock();
461	+	assertValid(lock, s2);
462	+	lock.unlockRead(s2);
463	+	long s3 = lock.tryReadLock(LONG_DELAY_MS, MILLISECONDS);
464	+	assertValid(lock, s3);
465	+	lock.unlockRead(s3);
466	+	long s4 = lock.readLock();
467	+	assertValid(lock, s4);
468	+	lock.unlockRead(s4);
469	+	lock.asReadLock().lock();
470	+	lock.asReadLock().unlock();
471	+	lock.asReadLock().lockInterruptibly();
472	+	lock.asReadLock().unlock();
473	+	lock.asReadLock().tryLock(Long.MIN_VALUE, DAYS);
474	+	lock.asReadLock().unlock();
475	+	}});
476	+
477	+	awaitTermination(t);
478	+	lock.unlockRead(s);
479	+	}
480	+
481	+	/**
482	+	* A writelock succeeds only after a reading thread unlocks
483	+	*/
484	+	public void testWriteAfterReadLock() throws InterruptedException {
485	+	final CountDownLatch running = new CountDownLatch(1);
486	+	final StampedLock lock = new StampedLock();
487	+	long rs = lock.readLock();
488	+	Thread t = newStartedThread(new CheckedRunnable() {
489	+	public void realRun() {
490	+	running.countDown();
491	+	long s = lock.writeLock();
492	+	lock.unlockWrite(s);
493	+	}});
494	+
495	+	running.await();
496	+	waitForThreadToEnterWaitState(t, MEDIUM_DELAY_MS);
497	+	assertFalse(lock.isWriteLocked());
498	+	lock.unlockRead(rs);
499	+	awaitTermination(t);
500	+	assertFalse(lock.isWriteLocked());
501	+	}
502	+
503	+	/**
504	+	* A writelock succeeds only after reading threads unlock
505	+	*/
506	+	public void testWriteAfterMultipleReadLocks() {
507	+	final StampedLock lock = new StampedLock();
508	+	long s = lock.readLock();
509	+	Thread t1 = newStartedThread(new CheckedRunnable() {
510	+	public void realRun() {
511	+	long rs = lock.readLock();
512	+	lock.unlockRead(rs);
513	+	}});
514	+
515	+	awaitTermination(t1);
516	+
517	+	Thread t2 = newStartedThread(new CheckedRunnable() {
518	+	public void realRun() {
519	+	long ws = lock.writeLock();
520	+	lock.unlockWrite(ws);
521	+	}});
522	+
523	+	assertTrue(lock.isReadLocked());
524	+	assertFalse(lock.isWriteLocked());
525	+	lock.unlockRead(s);
526	+	awaitTermination(t2);
527	+	assertFalse(lock.isWriteLocked());
528	+	}
529	+
530	+	/**
531	+	* Readlocks succeed only after a writing thread unlocks
532	+	*/
533	+	public void testReadAfterWriteLock() {
534	+	final StampedLock lock = new StampedLock();
535	+	final CountDownLatch threadsStarted = new CountDownLatch(2);
536	+	final long s = lock.writeLock();
537	+	Thread t1 = newStartedThread(new CheckedRunnable() {
538	+	public void realRun() {
539	+	threadsStarted.countDown();
540	+	long rs = lock.readLock();
541	+	lock.unlockRead(rs);
542	+	}});
543	+	Thread t2 = newStartedThread(new CheckedRunnable() {
544	+	public void realRun() {
545	+	threadsStarted.countDown();
546	+	long rs = lock.readLock();
547	+	lock.unlockRead(rs);
548	+	}});
549	+
550	+	await(threadsStarted);
551	+	waitForThreadToEnterWaitState(t1, MEDIUM_DELAY_MS);
552	+	waitForThreadToEnterWaitState(t2, MEDIUM_DELAY_MS);
553	+	releaseWriteLock(lock, s);
554	+	awaitTermination(t1);
555	+	awaitTermination(t2);
556	+	}
557	+
558	+	/**
559	+	* tryReadLock succeeds if read locked but not write locked
560	+	*/
561	+	public void testTryLockWhenReadLocked() {
562	+	final StampedLock lock = new StampedLock();
563	+	long s = lock.readLock();
564	+	Thread t = newStartedThread(new CheckedRunnable() {
565	+	public void realRun() {
566	+	long rs = lock.tryReadLock();
567	+	assertValid(lock, rs);
568	+	lock.unlockRead(rs);
569	+	}});
570	+
571	+	awaitTermination(t);
572	+	lock.unlockRead(s);
573	+	}
574	+
575	+	/**
576	+	* tryWriteLock fails when read locked
577	+	*/
578	+	public void testTryWriteLockWhenReadLocked() {
579	+	final StampedLock lock = new StampedLock();
580	+	long s = lock.readLock();
581	+	Thread t = newStartedThread(new CheckedRunnable() {
582	+	public void realRun() {
583	+	threadAssertEquals(0L, lock.tryWriteLock());
584	+	}});
585	+
586	+	awaitTermination(t);
587	+	lock.unlockRead(s);
588	+	}
589	+
590	+	/**
591	+	* timed lock operations time out if lock not available
592	+	*/
593	+	public void testTimedLock_Timeout() throws Exception {
594	+	ArrayList<Future<?>> futures = new ArrayList<>();
595	+
596	+	// Write locked
597	+	final StampedLock lock = new StampedLock();
598	+	long stamp = lock.writeLock();
599	+	assertEquals(0L, lock.tryReadLock(0L, DAYS));
600	+	assertEquals(0L, lock.tryReadLock(Long.MIN_VALUE, DAYS));
601	+	assertFalse(lock.asReadLock().tryLock(0L, DAYS));
602	+	assertFalse(lock.asReadLock().tryLock(Long.MIN_VALUE, DAYS));
603	+	assertEquals(0L, lock.tryWriteLock(0L, DAYS));
604	+	assertEquals(0L, lock.tryWriteLock(Long.MIN_VALUE, DAYS));
605	+	assertFalse(lock.asWriteLock().tryLock(0L, DAYS));
606	+	assertFalse(lock.asWriteLock().tryLock(Long.MIN_VALUE, DAYS));
607	+
608	+	futures.add(cachedThreadPool.submit(new CheckedRunnable() {
609	+	public void realRun() throws InterruptedException {
610	+	long startTime = System.nanoTime();
611	+	assertEquals(0L, lock.tryWriteLock(timeoutMillis(), MILLISECONDS));
612	+	assertTrue(millisElapsedSince(startTime) >= timeoutMillis());
613	+	}}));
614	+
615	+	futures.add(cachedThreadPool.submit(new CheckedRunnable() {
616	+	public void realRun() throws InterruptedException {
617	+	long startTime = System.nanoTime();
618	+	assertEquals(0L, lock.tryReadLock(timeoutMillis(), MILLISECONDS));
619	+	assertTrue(millisElapsedSince(startTime) >= timeoutMillis());
620	+	}}));
621	+
622	+	// Read locked
623	+	final StampedLock lock2 = new StampedLock();
624	+	long stamp2 = lock2.readLock();
625	+	assertEquals(0L, lock2.tryWriteLock(0L, DAYS));
626	+	assertEquals(0L, lock2.tryWriteLock(Long.MIN_VALUE, DAYS));
627	+	assertFalse(lock2.asWriteLock().tryLock(0L, DAYS));
628	+	assertFalse(lock2.asWriteLock().tryLock(Long.MIN_VALUE, DAYS));
629	+
630	+	futures.add(cachedThreadPool.submit(new CheckedRunnable() {
631	+	public void realRun() throws InterruptedException {
632	+	long startTime = System.nanoTime();
633	+	assertEquals(0L, lock2.tryWriteLock(timeoutMillis(), MILLISECONDS));
634	+	assertTrue(millisElapsedSince(startTime) >= timeoutMillis());
635	+	}}));
636	+
637	+	for (Future<?> future : futures)
638	+	assertNull(future.get());
639	+
640	+	releaseWriteLock(lock, stamp);
641	+	releaseReadLock(lock2, stamp2);
642	+	}
643	+
644	+	/**
645	+	* writeLockInterruptibly succeeds if unlocked
646	+	*/
647	+	public void testWriteLockInterruptibly() throws InterruptedException {
648	+	final StampedLock lock = new StampedLock();
649	+	long s = lock.writeLockInterruptibly();
650	+	assertTrue(lock.isWriteLocked());
651	+	releaseWriteLock(lock, s);
652	+	}
653	+
654	+	/**
655	+	* readLockInterruptibly succeeds if lock free
656	+	*/
657	+	public void testReadLockInterruptibly() throws InterruptedException {
658	+	final StampedLock lock = new StampedLock();
659	+
660	+	long s = assertValid(lock, lock.readLockInterruptibly());
661	+	assertTrue(lock.isReadLocked());
662	+	lock.unlockRead(s);
663	+
664	+	lock.asReadLock().lockInterruptibly();
665	+	assertTrue(lock.isReadLocked());
666	+	lock.asReadLock().unlock();
667	+	}
668	+
669	+	/**
670	+	* A serialized lock deserializes as unlocked
671	+	*/
672	+	public void testSerialization() {
673	+	StampedLock lock = new StampedLock();
674	+	lock.writeLock();
675	+	StampedLock clone = serialClone(lock);
676	+	assertTrue(lock.isWriteLocked());
677	+	assertFalse(clone.isWriteLocked());
678	+	long s = clone.writeLock();
679	+	assertTrue(clone.isWriteLocked());
680	+	clone.unlockWrite(s);
681	+	assertFalse(clone.isWriteLocked());
682	+	}
683	+
684	+	/**
685	+	* toString indicates current lock state
686	+	*/
687	+	public void testToString() {
688	+	StampedLock lock = new StampedLock();
689	+	assertTrue(lock.toString().contains("Unlocked"));
690	+	long s = lock.writeLock();
691	+	assertTrue(lock.toString().contains("Write-locked"));
692	+	lock.unlockWrite(s);
693	+	s = lock.readLock();
694	+	assertTrue(lock.toString().contains("Read-locks"));
695	+	}
696	+
697	+	/**
698	+	* tryOptimisticRead succeeds and validates if unlocked, fails if
699	+	* exclusively locked
700	+	*/
701	+	public void testValidateOptimistic() throws InterruptedException {
702	+	StampedLock lock = new StampedLock();
703	+
704	+	assertValid(lock, lock.tryOptimisticRead());
705	+
706	+	for (Function<StampedLock, Long> writeLocker : writeLockers()) {
707	+	long s = assertValid(lock, writeLocker.apply(lock));
708	+	assertEquals(0L, lock.tryOptimisticRead());
709	+	releaseWriteLock(lock, s);
710	+	}
711	+
712	+	for (Function<StampedLock, Long> readLocker : readLockers()) {
713	+	long s = assertValid(lock, readLocker.apply(lock));
714	+	long p = assertValid(lock, lock.tryOptimisticRead());
715	+	releaseReadLock(lock, s);
716	+	assertTrue(lock.validate(p));
717	+	}
718	+
719	+	assertValid(lock, lock.tryOptimisticRead());
720	+	}
721	+
722	+	/**
723	+	* tryOptimisticRead stamp does not validate if a write lock intervenes
724	+	*/
725	+	public void testValidateOptimisticWriteLocked() {
726	+	final StampedLock lock = new StampedLock();
727	+	final long p = assertValid(lock, lock.tryOptimisticRead());
728	+	final long s = assertValid(lock, lock.writeLock());
729	+	assertFalse(lock.validate(p));
730	+	assertEquals(0L, lock.tryOptimisticRead());
731	+	assertTrue(lock.validate(s));
732	+	lock.unlockWrite(s);
733	+	}
734	+
735	+	/**
736	+	* tryOptimisticRead stamp does not validate if a write lock
737	+	* intervenes in another thread
738	+	*/
739	+	public void testValidateOptimisticWriteLocked2()
740	+	throws InterruptedException {
741	+	final CountDownLatch running = new CountDownLatch(1);
742	+	final StampedLock lock = new StampedLock();
743	+	final long p = assertValid(lock, lock.tryOptimisticRead());
744	+
745	+	Thread t = newStartedThread(new CheckedInterruptedRunnable() {
746	+	public void realRun() throws InterruptedException {
747	+	lock.writeLockInterruptibly();
748	+	running.countDown();
749	+	lock.writeLockInterruptibly();
750	+	}});
751	+
752	+	running.await();
753	+	assertFalse(lock.validate(p));
754	+	assertEquals(0L, lock.tryOptimisticRead());
755	+	t.interrupt();
756	+	awaitTermination(t);
757	+	}
758	+
759	+	/**
760	+	* tryConvertToOptimisticRead succeeds and validates if successfully locked
761	+	*/
762	+	public void testTryConvertToOptimisticRead() throws InterruptedException {
763	+	StampedLock lock = new StampedLock();
764	+	long s, p, q;
765	+	assertEquals(0L, lock.tryConvertToOptimisticRead(0L));
766	+
767	+	s = assertValid(lock, lock.tryOptimisticRead());
768	+	assertEquals(s, lock.tryConvertToOptimisticRead(s));
769	+	assertTrue(lock.validate(s));
770	+
771	+	for (Function<StampedLock, Long> writeLocker : writeLockers()) {
772	+	s = assertValid(lock, writeLocker.apply(lock));
773	+	p = assertValid(lock, lock.tryConvertToOptimisticRead(s));
774	+	assertFalse(lock.validate(s));
775	+	assertTrue(lock.validate(p));
776	+	assertUnlocked(lock);
777	+	}
778	+
779	+	for (Function<StampedLock, Long> readLocker : readLockers()) {
780	+	s = assertValid(lock, readLocker.apply(lock));
781	+	q = assertValid(lock, lock.tryOptimisticRead());
782	+	assertEquals(q, lock.tryConvertToOptimisticRead(q));
783	+	assertTrue(lock.validate(q));
784	+	assertTrue(lock.isReadLocked());
785	+	p = assertValid(lock, lock.tryConvertToOptimisticRead(s));
786	+	assertTrue(lock.validate(p));
787	+	assertTrue(lock.validate(s));
788	+	assertUnlocked(lock);
789	+	assertEquals(q, lock.tryConvertToOptimisticRead(q));
790	+	assertTrue(lock.validate(q));
791	+	}
792	+	}
793	+
794	+	/**
795	+	* tryConvertToReadLock succeeds for valid stamps
796	+	*/
797	+	public void testTryConvertToReadLock() throws InterruptedException {
798	+	StampedLock lock = new StampedLock();
799	+	long s, p;
800	+
801	+	assertEquals(0L, lock.tryConvertToReadLock(0L));
802	+
803	+	s = assertValid(lock, lock.tryOptimisticRead());
804	+	p = assertValid(lock, lock.tryConvertToReadLock(s));
805	+	assertTrue(lock.isReadLocked());
806	+	assertEquals(1, lock.getReadLockCount());
807	+	assertTrue(lock.validate(s));
808	+	lock.unlockRead(p);
809	+
810	+	s = assertValid(lock, lock.tryOptimisticRead());
811	+	lock.readLock();
812	+	p = assertValid(lock, lock.tryConvertToReadLock(s));
813	+	assertTrue(lock.isReadLocked());
814	+	assertEquals(2, lock.getReadLockCount());
815	+	lock.unlockRead(p);
816	+	lock.unlockRead(p);
817	+	assertUnlocked(lock);
818	+
819	+	for (BiConsumer<StampedLock, Long> readUnlocker : readUnlockers()) {
820	+	for (Function<StampedLock, Long> writeLocker : writeLockers()) {
821	+	s = assertValid(lock, writeLocker.apply(lock));
822	+	p = assertValid(lock, lock.tryConvertToReadLock(s));
823	+	assertFalse(lock.validate(s));
824	+	assertTrue(lock.isReadLocked());
825	+	assertEquals(1, lock.getReadLockCount());
826	+	readUnlocker.accept(lock, p);
827	+	}
828	+
829	+	for (Function<StampedLock, Long> readLocker : readLockers()) {
830	+	s = assertValid(lock, readLocker.apply(lock));
831	+	assertEquals(s, lock.tryConvertToReadLock(s));
832	+	assertTrue(lock.validate(s));
833	+	assertTrue(lock.isReadLocked());
834	+	assertEquals(1, lock.getReadLockCount());
835	+	readUnlocker.accept(lock, s);
836	+	}
837	+	}
838	+	}
839	+
840	+	/**
841	+	* tryConvertToWriteLock succeeds if lock available; fails if multiply read locked
842	+	*/
843	+	public void testTryConvertToWriteLock() throws InterruptedException {
844	+	StampedLock lock = new StampedLock();
845	+	long s, p;
846	+
847	+	assertEquals(0L, lock.tryConvertToWriteLock(0L));
848	+
849	+	assertTrue((s = lock.tryOptimisticRead()) != 0L);
850	+	assertTrue((p = lock.tryConvertToWriteLock(s)) != 0L);
851	+	assertTrue(lock.isWriteLocked());
852	+	lock.unlockWrite(p);
853	+
854	+	for (BiConsumer<StampedLock, Long> writeUnlocker : writeUnlockers()) {
855	+	for (Function<StampedLock, Long> writeLocker : writeLockers()) {
856	+	s = assertValid(lock, writeLocker.apply(lock));
857	+	assertEquals(s, lock.tryConvertToWriteLock(s));
858	+	assertTrue(lock.validate(s));
859	+	assertTrue(lock.isWriteLocked());
860	+	writeUnlocker.accept(lock, s);
861	+	}
862	+
863	+	for (Function<StampedLock, Long> readLocker : readLockers()) {
864	+	s = assertValid(lock, readLocker.apply(lock));
865	+	p = assertValid(lock, lock.tryConvertToWriteLock(s));
866	+	assertFalse(lock.validate(s));
867	+	assertTrue(lock.validate(p));
868	+	assertTrue(lock.isWriteLocked());
869	+	writeUnlocker.accept(lock, p);
870	+	}
871	+	}
872	+
873	+	// failure if multiply read locked
874	+	for (Function<StampedLock, Long> readLocker : readLockers()) {
875	+	s = assertValid(lock, readLocker.apply(lock));
876	+	p = assertValid(lock, readLocker.apply(lock));
877	+	assertEquals(0L, lock.tryConvertToWriteLock(s));
878	+	assertTrue(lock.validate(s));
879	+	assertTrue(lock.validate(p));
880	+	assertEquals(2, lock.getReadLockCount());
881	+	lock.unlock(p);
882	+	lock.unlock(s);
883	+	assertUnlocked(lock);
884	+	}
885	+	}
886	+
887	+	/**
888	+	* asWriteLock can be locked and unlocked
889	+	*/
890	+	public void testAsWriteLock() throws Throwable {
891	+	StampedLock sl = new StampedLock();
892	+	Lock lock = sl.asWriteLock();
893	+	for (Action locker : lockLockers(lock)) {
894	+	locker.run();
895	+	assertTrue(sl.isWriteLocked());
896	+	assertFalse(sl.isReadLocked());
897	+	assertFalse(lock.tryLock());
898	+	lock.unlock();
899	+	assertUnlocked(sl);
900	+	}
901	+	}
902	+
903	+	/**
904	+	* asReadLock can be locked and unlocked
905	+	*/
906	+	public void testAsReadLock() throws Throwable {
907	+	StampedLock sl = new StampedLock();
908	+	Lock lock = sl.asReadLock();
909	+	for (Action locker : lockLockers(lock)) {
910	+	locker.run();
911	+	assertTrue(sl.isReadLocked());
912	+	assertFalse(sl.isWriteLocked());
913	+	assertEquals(1, sl.getReadLockCount());
914	+	locker.run();
915	+	assertTrue(sl.isReadLocked());
916	+	assertEquals(2, sl.getReadLockCount());
917	+	lock.unlock();
918	+	lock.unlock();
919	+	assertUnlocked(sl);
920	+	}
921	+	}
922	+
923	+	/**
924	+	* asReadWriteLock.writeLock can be locked and unlocked
925	+	*/
926	+	public void testAsReadWriteLockWriteLock() throws Throwable {
927	+	StampedLock sl = new StampedLock();
928	+	Lock lock = sl.asReadWriteLock().writeLock();
929	+	for (Action locker : lockLockers(lock)) {
930	+	locker.run();
931	+	assertTrue(sl.isWriteLocked());
932	+	assertFalse(sl.isReadLocked());
933	+	assertFalse(lock.tryLock());
934	+	lock.unlock();
935	+	assertUnlocked(sl);
936	+	}
937	+	}
938	+
939	+	/**
940	+	* asReadWriteLock.readLock can be locked and unlocked
941	+	*/
942	+	public void testAsReadWriteLockReadLock() throws Throwable {
943	+	StampedLock sl = new StampedLock();
944	+	Lock lock = sl.asReadWriteLock().readLock();
945	+	for (Action locker : lockLockers(lock)) {
946	+	locker.run();
947	+	assertTrue(sl.isReadLocked());
948	+	assertFalse(sl.isWriteLocked());
949	+	assertEquals(1, sl.getReadLockCount());
950	+	locker.run();
951	+	assertTrue(sl.isReadLocked());
952	+	assertEquals(2, sl.getReadLockCount());
953	+	lock.unlock();
954	+	lock.unlock();
955	+	assertUnlocked(sl);
956	+	}
957	+	}
958	+
959	+	/**
960	+	* Lock.newCondition throws UnsupportedOperationException
961	+	*/
962	+	public void testLockViewsDoNotSupportConditions() {
963	+	StampedLock sl = new StampedLock();
964	+	assertThrows(UnsupportedOperationException.class,
965	+	() -> sl.asWriteLock().newCondition(),
966	+	() -> sl.asReadLock().newCondition(),
967	+	() -> sl.asReadWriteLock().writeLock().newCondition(),
968	+	() -> sl.asReadWriteLock().readLock().newCondition());
969	+	}
970	+
971	+	/**
972	+	* Passing optimistic read stamps to unlock operations result in
973	+	* IllegalMonitorStateException
974	+	*/
975	+	public void testCannotUnlockOptimisticReadStamps() {
976	+	Runnable[] actions = {
977	+	() -> {
978	+	StampedLock sl = new StampedLock();
979	+	long stamp = assertValid(sl, sl.tryOptimisticRead());
980	+	sl.unlockRead(stamp);
981	+	},
982	+	() -> {
983	+	StampedLock sl = new StampedLock();
984	+	long stamp = sl.tryOptimisticRead();
985	+	sl.unlock(stamp);
986	+	},
987	+
988	+	() -> {
989	+	StampedLock sl = new StampedLock();
990	+	long stamp = sl.tryOptimisticRead();
991	+	sl.writeLock();
992	+	sl.unlock(stamp);
993	+	},
994	+	() -> {
995	+	StampedLock sl = new StampedLock();
996	+	sl.readLock();
997	+	long stamp = assertValid(sl, sl.tryOptimisticRead());
998	+	sl.unlockRead(stamp);
999	+	},
1000	+	() -> {
1001	+	StampedLock sl = new StampedLock();
1002	+	sl.readLock();
1003	+	long stamp = assertValid(sl, sl.tryOptimisticRead());
1004	+	sl.unlock(stamp);
1005	+	},
1006	+
1007	+	() -> {
1008	+	StampedLock sl = new StampedLock();
1009	+	long stamp = sl.tryConvertToOptimisticRead(sl.writeLock());
1010	+	assertValid(sl, stamp);
1011	+	sl.writeLock();
1012	+	sl.unlockWrite(stamp);
1013	+	},
1014	+	() -> {
1015	+	StampedLock sl = new StampedLock();
1016	+	long stamp = sl.tryConvertToOptimisticRead(sl.writeLock());
1017	+	sl.writeLock();
1018	+	sl.unlock(stamp);
1019	+	},
1020	+	() -> {
1021	+	StampedLock sl = new StampedLock();
1022	+	long stamp = sl.tryConvertToOptimisticRead(sl.writeLock());
1023	+	sl.readLock();
1024	+	sl.unlockRead(stamp);
1025	+	},
1026	+	() -> {
1027	+	StampedLock sl = new StampedLock();
1028	+	long stamp = sl.tryConvertToOptimisticRead(sl.writeLock());
1029	+	sl.readLock();
1030	+	sl.unlock(stamp);
1031	+	},
1032	+
1033	+	() -> {
1034	+	StampedLock sl = new StampedLock();
1035	+	long stamp = sl.tryConvertToOptimisticRead(sl.readLock());
1036	+	assertValid(sl, stamp);
1037	+	sl.writeLock();
1038	+	sl.unlockWrite(stamp);
1039	+	},
1040	+	() -> {
1041	+	StampedLock sl = new StampedLock();
1042	+	long stamp = sl.tryConvertToOptimisticRead(sl.readLock());
1043	+	sl.writeLock();
1044	+	sl.unlock(stamp);
1045	+	},
1046	+	() -> {
1047	+	StampedLock sl = new StampedLock();
1048	+	long stamp = sl.tryConvertToOptimisticRead(sl.readLock());
1049	+	sl.readLock();
1050	+	sl.unlockRead(stamp);
1051	+	},
1052	+	() -> {
1053	+	StampedLock sl = new StampedLock();
1054	+	sl.readLock();
1055	+	long stamp = sl.tryConvertToOptimisticRead(sl.readLock());
1056	+	assertValid(sl, stamp);
1057	+	sl.readLock();
1058	+	sl.unlockRead(stamp);
1059	+	},
1060	+	() -> {
1061	+	StampedLock sl = new StampedLock();
1062	+	long stamp = sl.tryConvertToOptimisticRead(sl.readLock());
1063	+	sl.readLock();
1064	+	sl.unlock(stamp);
1065	+	},
1066	+	() -> {
1067	+	StampedLock sl = new StampedLock();
1068	+	sl.readLock();
1069	+	long stamp = sl.tryConvertToOptimisticRead(sl.readLock());
1070	+	sl.readLock();
1071	+	sl.unlock(stamp);
1072	+	},
1073	+	};
1074	+
1075	+	assertThrows(IllegalMonitorStateException.class, actions);
1076	+	}
1077	+
1078	+	static long writeLockInterruptiblyUninterrupted(StampedLock sl) {
1079	+	try { return sl.writeLockInterruptibly(); }
1080	+	catch (InterruptedException ex) { throw new AssertionError(ex); }
1081	+	}
1082	+
1083	+	static long tryWriteLockUninterrupted(StampedLock sl, long time, TimeUnit unit) {
1084	+	try { return sl.tryWriteLock(time, unit); }
1085	+	catch (InterruptedException ex) { throw new AssertionError(ex); }
1086	+	}
1087	+
1088	+	static long readLockInterruptiblyUninterrupted(StampedLock sl) {
1089	+	try { return sl.readLockInterruptibly(); }
1090	+	catch (InterruptedException ex) { throw new AssertionError(ex); }
1091	+	}
1092	+
1093	+	static long tryReadLockUninterrupted(StampedLock sl, long time, TimeUnit unit) {
1094	+	try { return sl.tryReadLock(time, unit); }
1095	+	catch (InterruptedException ex) { throw new AssertionError(ex); }
1096	+	}
1097	+
1098	+	/**
1099	+	* Invalid stamps result in IllegalMonitorStateException
1100	+	*/
1101	+	public void testInvalidStampsThrowIllegalMonitorStateException() {
1102	+	final StampedLock sl = new StampedLock();
1103	+
1104	+	assertThrows(IllegalMonitorStateException.class,
1105	+	() -> sl.unlockWrite(0L),
1106	+	() -> sl.unlockRead(0L),
1107	+	() -> sl.unlock(0L));
1108	+
1109	+	final long optimisticStamp = sl.tryOptimisticRead();
1110	+	final long readStamp = sl.readLock();
1111	+	sl.unlockRead(readStamp);
1112	+	final long writeStamp = sl.writeLock();
1113	+	sl.unlockWrite(writeStamp);
1114	+	assertTrue(optimisticStamp != 0L && readStamp != 0L && writeStamp != 0L);
1115	+	final long[] noLongerValidStamps = { optimisticStamp, readStamp, writeStamp };
1116	+	final Runnable assertNoLongerValidStampsThrow = () -> {
1117	+	for (long noLongerValidStamp : noLongerValidStamps)
1118	+	assertThrows(IllegalMonitorStateException.class,
1119	+	() -> sl.unlockWrite(noLongerValidStamp),
1120	+	() -> sl.unlockRead(noLongerValidStamp),
1121	+	() -> sl.unlock(noLongerValidStamp));
1122	+	};
1123	+	assertNoLongerValidStampsThrow.run();
1124	+
1125	+	for (Function<StampedLock, Long> readLocker : readLockers())
1126	+	for (BiConsumer<StampedLock, Long> readUnlocker : readUnlockers()) {
1127	+	final long stamp = readLocker.apply(sl);
1128	+	assertValid(sl, stamp);
1129	+	assertNoLongerValidStampsThrow.run();
1130	+	assertThrows(IllegalMonitorStateException.class,
1131	+	() -> sl.unlockWrite(stamp),
1132	+	() -> sl.unlockRead(sl.tryOptimisticRead()),
1133	+	() -> sl.unlockRead(0L));
1134	+	readUnlocker.accept(sl, stamp);
1135	+	assertUnlocked(sl);
1136	+	assertNoLongerValidStampsThrow.run();
1137	+	}
1138	+
1139	+	for (Function<StampedLock, Long> writeLocker : writeLockers())
1140	+	for (BiConsumer<StampedLock, Long> writeUnlocker : writeUnlockers()) {
1141	+	final long stamp = writeLocker.apply(sl);
1142	+	assertValid(sl, stamp);
1143	+	assertNoLongerValidStampsThrow.run();
1144	+	assertThrows(IllegalMonitorStateException.class,
1145	+	() -> sl.unlockRead(stamp),
1146	+	() -> sl.unlockWrite(0L));
1147	+	writeUnlocker.accept(sl, stamp);
1148	+	assertUnlocked(sl);
1149	+	assertNoLongerValidStampsThrow.run();
1150	+	}
1151	+	}
1152	+
1153	+	/**
1154	+	* Read locks can be very deeply nested
1155	+	*/
1156	+	public void testDeeplyNestedReadLocks() {
1157	+	final StampedLock lock = new StampedLock();
1158	+	final int depth = 300;
1159	+	final long[] stamps = new long[depth];
1160	+	final List<Function<StampedLock, Long>> readLockers = readLockers();
1161	+	final List<BiConsumer<StampedLock, Long>> readUnlockers = readUnlockers();
1162	+	for (int i = 0; i < depth; i++) {
1163	+	Function<StampedLock, Long> readLocker
1164	+	= readLockers.get(i % readLockers.size());
1165	+	long stamp = readLocker.apply(lock);
1166	+	assertEquals(i + 1, lock.getReadLockCount());
1167	+	assertTrue(lock.isReadLocked());
1168	+	stamps[i] = stamp;
1169	+	}
1170	+	for (int i = 0; i < depth; i++) {
1171	+	BiConsumer<StampedLock, Long> readUnlocker
1172	+	= readUnlockers.get(i % readUnlockers.size());
1173	+	assertEquals(depth - i, lock.getReadLockCount());
1174	+	assertTrue(lock.isReadLocked());
1175	+	readUnlocker.accept(lock, stamps[depth - 1 - i]);
1176	+	}
1177	+	assertUnlocked(lock);
1178	+	}
1179		}

Diff Legend

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