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.31 by jsr166, Sat Feb 18 00:34:52 2017 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 StampedLock lock = new StampedLock();
276	+
277	+	Action[] interruptibleLockActions = {
278	+	() -> lock.writeLockInterruptibly(),
279	+	() -> lock.tryWriteLock(Long.MIN_VALUE, DAYS),
280	+	() -> lock.tryWriteLock(Long.MAX_VALUE, DAYS),
281	+	() -> lock.readLockInterruptibly(),
282	+	() -> lock.tryReadLock(Long.MIN_VALUE, DAYS),
283	+	() -> lock.tryReadLock(Long.MAX_VALUE, DAYS),
284	+	() -> lock.asWriteLock().lockInterruptibly(),
285	+	() -> lock.asWriteLock().tryLock(0L, DAYS),
286	+	() -> lock.asWriteLock().tryLock(Long.MAX_VALUE, DAYS),
287	+	() -> lock.asReadLock().lockInterruptibly(),
288	+	() -> lock.asReadLock().tryLock(0L, DAYS),
289	+	() -> lock.asReadLock().tryLock(Long.MAX_VALUE, DAYS),
290	+	};
291	+	shuffle(interruptibleLockActions);
292	+
293	+	assertThrowInterruptedExceptionWhenPreInterrupted(interruptibleLockActions);
294	+	{
295	+	long s = lock.writeLock();
296	+	assertThrowInterruptedExceptionWhenPreInterrupted(interruptibleLockActions);
297	+	lock.unlockWrite(s);
298	+	}
299	+	{
300	+	long s = lock.readLock();
301	+	assertThrowInterruptedExceptionWhenPreInterrupted(interruptibleLockActions);
302	+	lock.unlockRead(s);
303	+	}
304	+	}
305	+
306	+	void assertThrowInterruptedExceptionWhenInterrupted(Action[] actions) {
307	+	int n = actions.length;
308	+	Future<?>[] futures = new Future<?>[n];
309	+	CountDownLatch threadsStarted = new CountDownLatch(n);
310	+	CountDownLatch done = new CountDownLatch(n);
311	+
312	+	for (int i = 0; i < n; i++) {
313	+	Action action = actions[i];
314	+	futures[i] = cachedThreadPool.submit(new CheckedRunnable() {
315	+	public void realRun() throws Throwable {
316	+	threadsStarted.countDown();
317	+	try {
318	+	action.run();
319	+	shouldThrow();
320	+	}
321	+	catch (InterruptedException success) {}
322	+	catch (Throwable fail) { threadUnexpectedException(fail); }
323	+	assertFalse(Thread.interrupted());
324	+	done.countDown();
325	+	}});
326	+	}
327	+
328	+	await(threadsStarted);
329	+	assertEquals(n, done.getCount());
330	+	for (Future<?> future : futures) // Interrupt all the tasks
331	+	future.cancel(true);
332	+	await(done);
333	+	}
334	+
335	+	/**
336	+	* interruptible operations throw InterruptedException when write locked and interrupted
337	+	*/
338	+	public void testInterruptibleOperationsThrowInterruptedExceptionWriteLockedInterrupted() {
339	+	final StampedLock lock = new StampedLock();
340	+	long s = lock.writeLock();
341	+
342	+	Action[] interruptibleLockBlockingActions = {
343	+	() -> lock.writeLockInterruptibly(),
344	+	() -> lock.tryWriteLock(Long.MAX_VALUE, DAYS),
345	+	() -> lock.readLockInterruptibly(),
346	+	() -> lock.tryReadLock(Long.MAX_VALUE, DAYS),
347	+	() -> lock.asWriteLock().lockInterruptibly(),
348	+	() -> lock.asWriteLock().tryLock(Long.MAX_VALUE, DAYS),
349	+	() -> lock.asReadLock().lockInterruptibly(),
350	+	() -> lock.asReadLock().tryLock(Long.MAX_VALUE, DAYS),
351	+	};
352	+	shuffle(interruptibleLockBlockingActions);
353	+
354	+	assertThrowInterruptedExceptionWhenInterrupted(interruptibleLockBlockingActions);
355	+	}
356	+
357	+	/**
358	+	* interruptible operations throw InterruptedException when read locked and interrupted
359	+	*/
360	+	public void testInterruptibleOperationsThrowInterruptedExceptionReadLockedInterrupted() {
361	+	final StampedLock lock = new StampedLock();
362	+	long s = lock.readLock();
363	+
364	+	Action[] interruptibleLockBlockingActions = {
365	+	() -> lock.writeLockInterruptibly(),
366	+	() -> lock.tryWriteLock(Long.MAX_VALUE, DAYS),
367	+	() -> lock.asWriteLock().lockInterruptibly(),
368	+	() -> lock.asWriteLock().tryLock(Long.MAX_VALUE, DAYS),
369	+	};
370	+	shuffle(interruptibleLockBlockingActions);
371	+
372	+	assertThrowInterruptedExceptionWhenInterrupted(interruptibleLockBlockingActions);
373	+	}
374	+
375	+	/**
376	+	* Non-interruptible operations ignore and preserve interrupt status
377	+	*/
378	+	public void testNonInterruptibleOperationsIgnoreInterrupts() {
379	+	final StampedLock lock = new StampedLock();
380	+	Thread.currentThread().interrupt();
381	+
382	+	for (BiConsumer<StampedLock, Long> readUnlocker : readUnlockers()) {
383	+	long s = assertValid(lock, lock.readLock());
384	+	readUnlocker.accept(lock, s);
385	+	s = assertValid(lock, lock.tryReadLock());
386	+	readUnlocker.accept(lock, s);
387	+	}
388	+
389	+	lock.asReadLock().lock();
390	+	lock.asReadLock().unlock();
391	+
392	+	for (BiConsumer<StampedLock, Long> writeUnlocker : writeUnlockers()) {
393	+	long s = assertValid(lock, lock.writeLock());
394	+	writeUnlocker.accept(lock, s);
395	+	s = assertValid(lock, lock.tryWriteLock());
396	+	writeUnlocker.accept(lock, s);
397	+	}
398	+
399	+	lock.asWriteLock().lock();
400	+	lock.asWriteLock().unlock();
401	+
402	+	assertTrue(Thread.interrupted());
403	+	}
404	+
405	+	/**
406	+	* tryWriteLock on an unlocked lock succeeds
407	+	*/
408	+	public void testTryWriteLock() {
409	+	final StampedLock lock = new StampedLock();
410	+	long s = lock.tryWriteLock();
411	+	assertTrue(s != 0L);
412	+	assertTrue(lock.isWriteLocked());
413	+	assertEquals(0L, lock.tryWriteLock());
414	+	releaseWriteLock(lock, s);
415	+	}
416	+
417	+	/**
418	+	* tryWriteLock fails if locked
419	+	*/
420	+	public void testTryWriteLockWhenLocked() {
421	+	final StampedLock lock = new StampedLock();
422	+	long s = lock.writeLock();
423	+	Thread t = newStartedThread(new CheckedRunnable() {
424	+	public void realRun() {
425	+	assertEquals(0L, lock.tryWriteLock());
426	+	}});
427	+
428	+	assertEquals(0L, lock.tryWriteLock());
429	+	awaitTermination(t);
430	+	releaseWriteLock(lock, s);
431	+	}
432	+
433	+	/**
434	+	* tryReadLock fails if write-locked
435	+	*/
436	+	public void testTryReadLockWhenLocked() {
437	+	final StampedLock lock = new StampedLock();
438	+	long s = lock.writeLock();
439	+	Thread t = newStartedThread(new CheckedRunnable() {
440	+	public void realRun() {
441	+	assertEquals(0L, lock.tryReadLock());
442	+	}});
443	+
444	+	assertEquals(0L, lock.tryReadLock());
445	+	awaitTermination(t);
446	+	releaseWriteLock(lock, s);
447	+	}
448	+
449	+	/**
450	+	* Multiple threads can hold a read lock when not write-locked
451	+	*/
452	+	public void testMultipleReadLocks() {
453	+	final StampedLock lock = new StampedLock();
454	+	final long s = lock.readLock();
455	+	Thread t = newStartedThread(new CheckedRunnable() {
456	+	public void realRun() throws InterruptedException {
457	+	long s2 = lock.tryReadLock();
458	+	assertValid(lock, s2);
459	+	lock.unlockRead(s2);
460	+	long s3 = lock.tryReadLock(LONG_DELAY_MS, MILLISECONDS);
461	+	assertValid(lock, s3);
462	+	lock.unlockRead(s3);
463	+	long s4 = lock.readLock();
464	+	assertValid(lock, s4);
465	+	lock.unlockRead(s4);
466	+	lock.asReadLock().lock();
467	+	lock.asReadLock().unlock();
468	+	lock.asReadLock().lockInterruptibly();
469	+	lock.asReadLock().unlock();
470	+	lock.asReadLock().tryLock(Long.MIN_VALUE, DAYS);
471	+	lock.asReadLock().unlock();
472	+	}});
473	+
474	+	awaitTermination(t);
475	+	lock.unlockRead(s);
476	+	}
477	+
478	+	/**
479	+	* A writelock succeeds only after a reading thread unlocks
480	+	*/
481	+	public void testWriteAfterReadLock() throws InterruptedException {
482	+	final CountDownLatch threadStarted = new CountDownLatch(1);
483	+	final StampedLock lock = new StampedLock();
484	+	long rs = lock.readLock();
485	+	Thread t = newStartedThread(new CheckedRunnable() {
486	+	public void realRun() {
487	+	threadStarted.countDown();
488	+	long s = lock.writeLock();
489	+	lock.unlockWrite(s);
490	+	}});
491	+
492	+	threadStarted.await();
493	+	waitForThreadToEnterWaitState(t, MEDIUM_DELAY_MS);
494	+	assertFalse(lock.isWriteLocked());
495	+	lock.unlockRead(rs);
496	+	awaitTermination(t);
497	+	assertFalse(lock.isWriteLocked());
498	+	}
499	+
500	+	/**
501	+	* A writelock succeeds only after reading threads unlock
502	+	*/
503	+	public void testWriteAfterMultipleReadLocks() {
504	+	final StampedLock lock = new StampedLock();
505	+	long s = lock.readLock();
506	+	Thread t1 = newStartedThread(new CheckedRunnable() {
507	+	public void realRun() {
508	+	long rs = lock.readLock();
509	+	lock.unlockRead(rs);
510	+	}});
511	+
512	+	awaitTermination(t1);
513	+
514	+	Thread t2 = newStartedThread(new CheckedRunnable() {
515	+	public void realRun() {
516	+	long ws = lock.writeLock();
517	+	lock.unlockWrite(ws);
518	+	}});
519	+
520	+	assertTrue(lock.isReadLocked());
521	+	assertFalse(lock.isWriteLocked());
522	+	lock.unlockRead(s);
523	+	awaitTermination(t2);
524	+	assertFalse(lock.isWriteLocked());
525	+	}
526	+
527	+	/**
528	+	* Readlocks succeed only after a writing thread unlocks
529	+	*/
530	+	public void testReadAfterWriteLock() {
531	+	final StampedLock lock = new StampedLock();
532	+	final CountDownLatch threadsStarted = new CountDownLatch(2);
533	+	final long s = lock.writeLock();
534	+	Thread t1 = newStartedThread(new CheckedRunnable() {
535	+	public void realRun() {
536	+	threadsStarted.countDown();
537	+	long rs = lock.readLock();
538	+	lock.unlockRead(rs);
539	+	}});
540	+	Thread t2 = newStartedThread(new CheckedRunnable() {
541	+	public void realRun() {
542	+	threadsStarted.countDown();
543	+	long rs = lock.readLock();
544	+	lock.unlockRead(rs);
545	+	}});
546	+
547	+	await(threadsStarted);
548	+	waitForThreadToEnterWaitState(t1, MEDIUM_DELAY_MS);
549	+	waitForThreadToEnterWaitState(t2, MEDIUM_DELAY_MS);
550	+	releaseWriteLock(lock, s);
551	+	awaitTermination(t1);
552	+	awaitTermination(t2);
553	+	}
554	+
555	+	/**
556	+	* tryReadLock succeeds if read locked but not write locked
557	+	*/
558	+	public void testTryLockWhenReadLocked() {
559	+	final StampedLock lock = new StampedLock();
560	+	long s = lock.readLock();
561	+	Thread t = newStartedThread(new CheckedRunnable() {
562	+	public void realRun() {
563	+	long rs = lock.tryReadLock();
564	+	assertValid(lock, rs);
565	+	lock.unlockRead(rs);
566	+	}});
567	+
568	+	awaitTermination(t);
569	+	lock.unlockRead(s);
570	+	}
571	+
572	+	/**
573	+	* tryWriteLock fails when read locked
574	+	*/
575	+	public void testTryWriteLockWhenReadLocked() {
576	+	final StampedLock lock = new StampedLock();
577	+	long s = lock.readLock();
578	+	Thread t = newStartedThread(new CheckedRunnable() {
579	+	public void realRun() {
580	+	threadAssertEquals(0L, lock.tryWriteLock());
581	+	}});
582	+
583	+	awaitTermination(t);
584	+	lock.unlockRead(s);
585	+	}
586	+
587	+	/**
588	+	* timed lock operations time out if lock not available
589	+	*/
590	+	public void testTimedLock_Timeout() throws Exception {
591	+	ArrayList<Future<?>> futures = new ArrayList<>();
592	+
593	+	// Write locked
594	+	final StampedLock lock = new StampedLock();
595	+	long stamp = lock.writeLock();
596	+	assertEquals(0L, lock.tryReadLock(0L, DAYS));
597	+	assertEquals(0L, lock.tryReadLock(Long.MIN_VALUE, DAYS));
598	+	assertFalse(lock.asReadLock().tryLock(0L, DAYS));
599	+	assertFalse(lock.asReadLock().tryLock(Long.MIN_VALUE, DAYS));
600	+	assertEquals(0L, lock.tryWriteLock(0L, DAYS));
601	+	assertEquals(0L, lock.tryWriteLock(Long.MIN_VALUE, DAYS));
602	+	assertFalse(lock.asWriteLock().tryLock(0L, DAYS));
603	+	assertFalse(lock.asWriteLock().tryLock(Long.MIN_VALUE, DAYS));
604	+
605	+	futures.add(cachedThreadPool.submit(new CheckedRunnable() {
606	+	public void realRun() throws InterruptedException {
607	+	long startTime = System.nanoTime();
608	+	assertEquals(0L, lock.tryWriteLock(timeoutMillis(), MILLISECONDS));
609	+	assertTrue(millisElapsedSince(startTime) >= timeoutMillis());
610	+	}}));
611	+
612	+	futures.add(cachedThreadPool.submit(new CheckedRunnable() {
613	+	public void realRun() throws InterruptedException {
614	+	long startTime = System.nanoTime();
615	+	assertEquals(0L, lock.tryReadLock(timeoutMillis(), MILLISECONDS));
616	+	assertTrue(millisElapsedSince(startTime) >= timeoutMillis());
617	+	}}));
618	+
619	+	// Read locked
620	+	final StampedLock lock2 = new StampedLock();
621	+	long stamp2 = lock2.readLock();
622	+	assertEquals(0L, lock2.tryWriteLock(0L, DAYS));
623	+	assertEquals(0L, lock2.tryWriteLock(Long.MIN_VALUE, DAYS));
624	+	assertFalse(lock2.asWriteLock().tryLock(0L, DAYS));
625	+	assertFalse(lock2.asWriteLock().tryLock(Long.MIN_VALUE, DAYS));
626	+
627	+	futures.add(cachedThreadPool.submit(new CheckedRunnable() {
628	+	public void realRun() throws InterruptedException {
629	+	long startTime = System.nanoTime();
630	+	assertEquals(0L, lock2.tryWriteLock(timeoutMillis(), MILLISECONDS));
631	+	assertTrue(millisElapsedSince(startTime) >= timeoutMillis());
632	+	}}));
633	+
634	+	for (Future<?> future : futures)
635	+	assertNull(future.get());
636	+
637	+	releaseWriteLock(lock, stamp);
638	+	releaseReadLock(lock2, stamp2);
639	+	}
640	+
641	+	/**
642	+	* writeLockInterruptibly succeeds if unlocked
643	+	*/
644	+	public void testWriteLockInterruptibly() throws InterruptedException {
645	+	final StampedLock lock = new StampedLock();
646	+	long s = lock.writeLockInterruptibly();
647	+	assertTrue(lock.isWriteLocked());
648	+	releaseWriteLock(lock, s);
649	+	}
650	+
651	+	/**
652	+	* readLockInterruptibly succeeds if lock free
653	+	*/
654	+	public void testReadLockInterruptibly() throws InterruptedException {
655	+	final StampedLock lock = new StampedLock();
656	+
657	+	long s = assertValid(lock, lock.readLockInterruptibly());
658	+	assertTrue(lock.isReadLocked());
659	+	lock.unlockRead(s);
660	+
661	+	lock.asReadLock().lockInterruptibly();
662	+	assertTrue(lock.isReadLocked());
663	+	lock.asReadLock().unlock();
664	+	}
665	+
666	+	/**
667	+	* A serialized lock deserializes as unlocked
668	+	*/
669	+	public void testSerialization() {
670	+	StampedLock lock = new StampedLock();
671	+	lock.writeLock();
672	+	StampedLock clone = serialClone(lock);
673	+	assertTrue(lock.isWriteLocked());
674	+	assertFalse(clone.isWriteLocked());
675	+	long s = clone.writeLock();
676	+	assertTrue(clone.isWriteLocked());
677	+	clone.unlockWrite(s);
678	+	assertFalse(clone.isWriteLocked());
679	+	}
680	+
681	+	/**
682	+	* toString indicates current lock state
683	+	*/
684	+	public void testToString() {
685	+	StampedLock lock = new StampedLock();
686	+	assertTrue(lock.toString().contains("Unlocked"));
687	+	long s = lock.writeLock();
688	+	assertTrue(lock.toString().contains("Write-locked"));
689	+	lock.unlockWrite(s);
690	+	s = lock.readLock();
691	+	assertTrue(lock.toString().contains("Read-locks"));
692	+	}
693	+
694	+	/**
695	+	* tryOptimisticRead succeeds and validates if unlocked, fails if
696	+	* exclusively locked
697	+	*/
698	+	public void testValidateOptimistic() throws InterruptedException {
699	+	StampedLock lock = new StampedLock();
700	+
701	+	assertValid(lock, lock.tryOptimisticRead());
702	+
703	+	for (Function<StampedLock, Long> writeLocker : writeLockers()) {
704	+	long s = assertValid(lock, writeLocker.apply(lock));
705	+	assertEquals(0L, lock.tryOptimisticRead());
706	+	releaseWriteLock(lock, s);
707	+	}
708	+
709	+	for (Function<StampedLock, Long> readLocker : readLockers()) {
710	+	long s = assertValid(lock, readLocker.apply(lock));
711	+	long p = assertValid(lock, lock.tryOptimisticRead());
712	+	releaseReadLock(lock, s);
713	+	assertTrue(lock.validate(p));
714	+	}
715	+
716	+	assertValid(lock, lock.tryOptimisticRead());
717	+	}
718	+
719	+	/**
720	+	* tryOptimisticRead stamp does not validate if a write lock intervenes
721	+	*/
722	+	public void testValidateOptimisticWriteLocked() {
723	+	final StampedLock lock = new StampedLock();
724	+	final long p = assertValid(lock, lock.tryOptimisticRead());
725	+	final long s = assertValid(lock, lock.writeLock());
726	+	assertFalse(lock.validate(p));
727	+	assertEquals(0L, lock.tryOptimisticRead());
728	+	assertTrue(lock.validate(s));
729	+	lock.unlockWrite(s);
730	+	}
731	+
732	+	/**
733	+	* tryOptimisticRead stamp does not validate if a write lock
734	+	* intervenes in another thread
735	+	*/
736	+	public void testValidateOptimisticWriteLocked2()
737	+	throws InterruptedException {
738	+	final CountDownLatch running = new CountDownLatch(1);
739	+	final StampedLock lock = new StampedLock();
740	+	final long p = assertValid(lock, lock.tryOptimisticRead());
741	+
742	+	Thread t = newStartedThread(new CheckedInterruptedRunnable() {
743	+	public void realRun() throws InterruptedException {
744	+	lock.writeLockInterruptibly();
745	+	running.countDown();
746	+	lock.writeLockInterruptibly();
747	+	}});
748	+
749	+	running.await();
750	+	assertFalse(lock.validate(p));
751	+	assertEquals(0L, lock.tryOptimisticRead());
752	+	t.interrupt();
753	+	awaitTermination(t);
754	+	}
755	+
756	+	/**
757	+	* tryConvertToOptimisticRead succeeds and validates if successfully locked
758	+	*/
759	+	public void testTryConvertToOptimisticRead() throws InterruptedException {
760	+	StampedLock lock = new StampedLock();
761	+	long s, p, q;
762	+	assertEquals(0L, lock.tryConvertToOptimisticRead(0L));
763	+
764	+	s = assertValid(lock, lock.tryOptimisticRead());
765	+	assertEquals(s, lock.tryConvertToOptimisticRead(s));
766	+	assertTrue(lock.validate(s));
767	+
768	+	for (Function<StampedLock, Long> writeLocker : writeLockers()) {
769	+	s = assertValid(lock, writeLocker.apply(lock));
770	+	p = assertValid(lock, lock.tryConvertToOptimisticRead(s));
771	+	assertFalse(lock.validate(s));
772	+	assertTrue(lock.validate(p));
773	+	assertUnlocked(lock);
774	+	}
775	+
776	+	for (Function<StampedLock, Long> readLocker : readLockers()) {
777	+	s = assertValid(lock, readLocker.apply(lock));
778	+	q = assertValid(lock, lock.tryOptimisticRead());
779	+	assertEquals(q, lock.tryConvertToOptimisticRead(q));
780	+	assertTrue(lock.validate(q));
781	+	assertTrue(lock.isReadLocked());
782	+	p = assertValid(lock, lock.tryConvertToOptimisticRead(s));
783	+	assertTrue(lock.validate(p));
784	+	assertTrue(lock.validate(s));
785	+	assertUnlocked(lock);
786	+	assertEquals(q, lock.tryConvertToOptimisticRead(q));
787	+	assertTrue(lock.validate(q));
788	+	}
789	+	}
790	+
791	+	/**
792	+	* tryConvertToReadLock succeeds for valid stamps
793	+	*/
794	+	public void testTryConvertToReadLock() throws InterruptedException {
795	+	StampedLock lock = new StampedLock();
796	+	long s, p;
797	+
798	+	assertEquals(0L, lock.tryConvertToReadLock(0L));
799	+
800	+	s = assertValid(lock, lock.tryOptimisticRead());
801	+	p = assertValid(lock, lock.tryConvertToReadLock(s));
802	+	assertTrue(lock.isReadLocked());
803	+	assertEquals(1, lock.getReadLockCount());
804	+	assertTrue(lock.validate(s));
805	+	lock.unlockRead(p);
806	+
807	+	s = assertValid(lock, lock.tryOptimisticRead());
808	+	lock.readLock();
809	+	p = assertValid(lock, lock.tryConvertToReadLock(s));
810	+	assertTrue(lock.isReadLocked());
811	+	assertEquals(2, lock.getReadLockCount());
812	+	lock.unlockRead(p);
813	+	lock.unlockRead(p);
814	+	assertUnlocked(lock);
815	+
816	+	for (BiConsumer<StampedLock, Long> readUnlocker : readUnlockers()) {
817	+	for (Function<StampedLock, Long> writeLocker : writeLockers()) {
818	+	s = assertValid(lock, writeLocker.apply(lock));
819	+	p = assertValid(lock, lock.tryConvertToReadLock(s));
820	+	assertFalse(lock.validate(s));
821	+	assertTrue(lock.isReadLocked());
822	+	assertEquals(1, lock.getReadLockCount());
823	+	readUnlocker.accept(lock, p);
824	+	}
825	+
826	+	for (Function<StampedLock, Long> readLocker : readLockers()) {
827	+	s = assertValid(lock, readLocker.apply(lock));
828	+	assertEquals(s, lock.tryConvertToReadLock(s));
829	+	assertTrue(lock.validate(s));
830	+	assertTrue(lock.isReadLocked());
831	+	assertEquals(1, lock.getReadLockCount());
832	+	readUnlocker.accept(lock, s);
833	+	}
834	+	}
835	+	}
836	+
837	+	/**
838	+	* tryConvertToWriteLock succeeds if lock available; fails if multiply read locked
839	+	*/
840	+	public void testTryConvertToWriteLock() throws InterruptedException {
841	+	StampedLock lock = new StampedLock();
842	+	long s, p;
843	+
844	+	assertEquals(0L, lock.tryConvertToWriteLock(0L));
845	+
846	+	assertTrue((s = lock.tryOptimisticRead()) != 0L);
847	+	assertTrue((p = lock.tryConvertToWriteLock(s)) != 0L);
848	+	assertTrue(lock.isWriteLocked());
849	+	lock.unlockWrite(p);
850	+
851	+	for (BiConsumer<StampedLock, Long> writeUnlocker : writeUnlockers()) {
852	+	for (Function<StampedLock, Long> writeLocker : writeLockers()) {
853	+	s = assertValid(lock, writeLocker.apply(lock));
854	+	assertEquals(s, lock.tryConvertToWriteLock(s));
855	+	assertTrue(lock.validate(s));
856	+	assertTrue(lock.isWriteLocked());
857	+	writeUnlocker.accept(lock, s);
858	+	}
859	+
860	+	for (Function<StampedLock, Long> readLocker : readLockers()) {
861	+	s = assertValid(lock, readLocker.apply(lock));
862	+	p = assertValid(lock, lock.tryConvertToWriteLock(s));
863	+	assertFalse(lock.validate(s));
864	+	assertTrue(lock.validate(p));
865	+	assertTrue(lock.isWriteLocked());
866	+	writeUnlocker.accept(lock, p);
867	+	}
868	+	}
869	+
870	+	// failure if multiply read locked
871	+	for (Function<StampedLock, Long> readLocker : readLockers()) {
872	+	s = assertValid(lock, readLocker.apply(lock));
873	+	p = assertValid(lock, readLocker.apply(lock));
874	+	assertEquals(0L, lock.tryConvertToWriteLock(s));
875	+	assertTrue(lock.validate(s));
876	+	assertTrue(lock.validate(p));
877	+	assertEquals(2, lock.getReadLockCount());
878	+	lock.unlock(p);
879	+	lock.unlock(s);
880	+	assertUnlocked(lock);
881	+	}
882	+	}
883	+
884	+	/**
885	+	* asWriteLock can be locked and unlocked
886	+	*/
887	+	public void testAsWriteLock() throws Throwable {
888	+	StampedLock sl = new StampedLock();
889	+	Lock lock = sl.asWriteLock();
890	+	for (Action locker : lockLockers(lock)) {
891	+	locker.run();
892	+	assertTrue(sl.isWriteLocked());
893	+	assertFalse(sl.isReadLocked());
894	+	assertFalse(lock.tryLock());
895	+	lock.unlock();
896	+	assertUnlocked(sl);
897	+	}
898	+	}
899	+
900	+	/**
901	+	* asReadLock can be locked and unlocked
902	+	*/
903	+	public void testAsReadLock() throws Throwable {
904	+	StampedLock sl = new StampedLock();
905	+	Lock lock = sl.asReadLock();
906	+	for (Action locker : lockLockers(lock)) {
907	+	locker.run();
908	+	assertTrue(sl.isReadLocked());
909	+	assertFalse(sl.isWriteLocked());
910	+	assertEquals(1, sl.getReadLockCount());
911	+	locker.run();
912	+	assertTrue(sl.isReadLocked());
913	+	assertEquals(2, sl.getReadLockCount());
914	+	lock.unlock();
915	+	lock.unlock();
916	+	assertUnlocked(sl);
917	+	}
918	+	}
919	+
920	+	/**
921	+	* asReadWriteLock.writeLock can be locked and unlocked
922	+	*/
923	+	public void testAsReadWriteLockWriteLock() throws Throwable {
924	+	StampedLock sl = new StampedLock();
925	+	Lock lock = sl.asReadWriteLock().writeLock();
926	+	for (Action locker : lockLockers(lock)) {
927	+	locker.run();
928	+	assertTrue(sl.isWriteLocked());
929	+	assertFalse(sl.isReadLocked());
930	+	assertFalse(lock.tryLock());
931	+	lock.unlock();
932	+	assertUnlocked(sl);
933	+	}
934	+	}
935	+
936	+	/**
937	+	* asReadWriteLock.readLock can be locked and unlocked
938	+	*/
939	+	public void testAsReadWriteLockReadLock() throws Throwable {
940	+	StampedLock sl = new StampedLock();
941	+	Lock lock = sl.asReadWriteLock().readLock();
942	+	for (Action locker : lockLockers(lock)) {
943	+	locker.run();
944	+	assertTrue(sl.isReadLocked());
945	+	assertFalse(sl.isWriteLocked());
946	+	assertEquals(1, sl.getReadLockCount());
947	+	locker.run();
948	+	assertTrue(sl.isReadLocked());
949	+	assertEquals(2, sl.getReadLockCount());
950	+	lock.unlock();
951	+	lock.unlock();
952	+	assertUnlocked(sl);
953	+	}
954	+	}
955	+
956	+	/**
957	+	* Lock.newCondition throws UnsupportedOperationException
958	+	*/
959	+	public void testLockViewsDoNotSupportConditions() {
960	+	StampedLock sl = new StampedLock();
961	+	assertThrows(UnsupportedOperationException.class,
962	+	() -> sl.asWriteLock().newCondition(),
963	+	() -> sl.asReadLock().newCondition(),
964	+	() -> sl.asReadWriteLock().writeLock().newCondition(),
965	+	() -> sl.asReadWriteLock().readLock().newCondition());
966	+	}
967	+
968	+	/**
969	+	* Passing optimistic read stamps to unlock operations result in
970	+	* IllegalMonitorStateException
971	+	*/
972	+	public void testCannotUnlockOptimisticReadStamps() {
973	+	Runnable[] actions = {
974	+	() -> {
975	+	StampedLock sl = new StampedLock();
976	+	long stamp = assertValid(sl, sl.tryOptimisticRead());
977	+	sl.unlockRead(stamp);
978	+	},
979	+	() -> {
980	+	StampedLock sl = new StampedLock();
981	+	long stamp = sl.tryOptimisticRead();
982	+	sl.unlock(stamp);
983	+	},
984	+
985	+	() -> {
986	+	StampedLock sl = new StampedLock();
987	+	long stamp = sl.tryOptimisticRead();
988	+	sl.writeLock();
989	+	sl.unlock(stamp);
990	+	},
991	+	() -> {
992	+	StampedLock sl = new StampedLock();
993	+	sl.readLock();
994	+	long stamp = assertValid(sl, sl.tryOptimisticRead());
995	+	sl.unlockRead(stamp);
996	+	},
997	+	() -> {
998	+	StampedLock sl = new StampedLock();
999	+	sl.readLock();
1000	+	long stamp = assertValid(sl, sl.tryOptimisticRead());
1001	+	sl.unlock(stamp);
1002	+	},
1003	+
1004	+	() -> {
1005	+	StampedLock sl = new StampedLock();
1006	+	long stamp = sl.tryConvertToOptimisticRead(sl.writeLock());
1007	+	assertValid(sl, stamp);
1008	+	sl.writeLock();
1009	+	sl.unlockWrite(stamp);
1010	+	},
1011	+	() -> {
1012	+	StampedLock sl = new StampedLock();
1013	+	long stamp = sl.tryConvertToOptimisticRead(sl.writeLock());
1014	+	sl.writeLock();
1015	+	sl.unlock(stamp);
1016	+	},
1017	+	() -> {
1018	+	StampedLock sl = new StampedLock();
1019	+	long stamp = sl.tryConvertToOptimisticRead(sl.writeLock());
1020	+	sl.readLock();
1021	+	sl.unlockRead(stamp);
1022	+	},
1023	+	() -> {
1024	+	StampedLock sl = new StampedLock();
1025	+	long stamp = sl.tryConvertToOptimisticRead(sl.writeLock());
1026	+	sl.readLock();
1027	+	sl.unlock(stamp);
1028	+	},
1029	+
1030	+	() -> {
1031	+	StampedLock sl = new StampedLock();
1032	+	long stamp = sl.tryConvertToOptimisticRead(sl.readLock());
1033	+	assertValid(sl, stamp);
1034	+	sl.writeLock();
1035	+	sl.unlockWrite(stamp);
1036	+	},
1037	+	() -> {
1038	+	StampedLock sl = new StampedLock();
1039	+	long stamp = sl.tryConvertToOptimisticRead(sl.readLock());
1040	+	sl.writeLock();
1041	+	sl.unlock(stamp);
1042	+	},
1043	+	() -> {
1044	+	StampedLock sl = new StampedLock();
1045	+	long stamp = sl.tryConvertToOptimisticRead(sl.readLock());
1046	+	sl.readLock();
1047	+	sl.unlockRead(stamp);
1048	+	},
1049	+	() -> {
1050	+	StampedLock sl = new StampedLock();
1051	+	sl.readLock();
1052	+	long stamp = sl.tryConvertToOptimisticRead(sl.readLock());
1053	+	assertValid(sl, stamp);
1054	+	sl.readLock();
1055	+	sl.unlockRead(stamp);
1056	+	},
1057	+	() -> {
1058	+	StampedLock sl = new StampedLock();
1059	+	long stamp = sl.tryConvertToOptimisticRead(sl.readLock());
1060	+	sl.readLock();
1061	+	sl.unlock(stamp);
1062	+	},
1063	+	() -> {
1064	+	StampedLock sl = new StampedLock();
1065	+	sl.readLock();
1066	+	long stamp = sl.tryConvertToOptimisticRead(sl.readLock());
1067	+	sl.readLock();
1068	+	sl.unlock(stamp);
1069	+	},
1070	+	};
1071	+
1072	+	assertThrows(IllegalMonitorStateException.class, actions);
1073	+	}
1074	+
1075	+	static long writeLockInterruptiblyUninterrupted(StampedLock sl) {
1076	+	try { return sl.writeLockInterruptibly(); }
1077	+	catch (InterruptedException ex) { throw new AssertionError(ex); }
1078	+	}
1079	+
1080	+	static long tryWriteLockUninterrupted(StampedLock sl, long time, TimeUnit unit) {
1081	+	try { return sl.tryWriteLock(time, unit); }
1082	+	catch (InterruptedException ex) { throw new AssertionError(ex); }
1083	+	}
1084	+
1085	+	static long readLockInterruptiblyUninterrupted(StampedLock sl) {
1086	+	try { return sl.readLockInterruptibly(); }
1087	+	catch (InterruptedException ex) { throw new AssertionError(ex); }
1088	+	}
1089	+
1090	+	static long tryReadLockUninterrupted(StampedLock sl, long time, TimeUnit unit) {
1091	+	try { return sl.tryReadLock(time, unit); }
1092	+	catch (InterruptedException ex) { throw new AssertionError(ex); }
1093	+	}
1094	+
1095	+	/**
1096	+	* Invalid stamps result in IllegalMonitorStateException
1097	+	*/
1098	+	public void testInvalidStampsThrowIllegalMonitorStateException() {
1099	+	final StampedLock sl = new StampedLock();
1100	+
1101	+	assertThrows(IllegalMonitorStateException.class,
1102	+	() -> sl.unlockWrite(0L),
1103	+	() -> sl.unlockRead(0L),
1104	+	() -> sl.unlock(0L));
1105	+
1106	+	final long optimisticStamp = sl.tryOptimisticRead();
1107	+	final long readStamp = sl.readLock();
1108	+	sl.unlockRead(readStamp);
1109	+	final long writeStamp = sl.writeLock();
1110	+	sl.unlockWrite(writeStamp);
1111	+	assertTrue(optimisticStamp != 0L && readStamp != 0L && writeStamp != 0L);
1112	+	final long[] noLongerValidStamps = { optimisticStamp, readStamp, writeStamp };
1113	+	final Runnable assertNoLongerValidStampsThrow = () -> {
1114	+	for (long noLongerValidStamp : noLongerValidStamps)
1115	+	assertThrows(IllegalMonitorStateException.class,
1116	+	() -> sl.unlockWrite(noLongerValidStamp),
1117	+	() -> sl.unlockRead(noLongerValidStamp),
1118	+	() -> sl.unlock(noLongerValidStamp));
1119	+	};
1120	+	assertNoLongerValidStampsThrow.run();
1121	+
1122	+	for (Function<StampedLock, Long> readLocker : readLockers())
1123	+	for (BiConsumer<StampedLock, Long> readUnlocker : readUnlockers()) {
1124	+	final long stamp = readLocker.apply(sl);
1125	+	assertValid(sl, stamp);
1126	+	assertNoLongerValidStampsThrow.run();
1127	+	assertThrows(IllegalMonitorStateException.class,
1128	+	() -> sl.unlockWrite(stamp),
1129	+	() -> sl.unlockRead(sl.tryOptimisticRead()),
1130	+	() -> sl.unlockRead(0L));
1131	+	readUnlocker.accept(sl, stamp);
1132	+	assertUnlocked(sl);
1133	+	assertNoLongerValidStampsThrow.run();
1134	+	}
1135	+
1136	+	for (Function<StampedLock, Long> writeLocker : writeLockers())
1137	+	for (BiConsumer<StampedLock, Long> writeUnlocker : writeUnlockers()) {
1138	+	final long stamp = writeLocker.apply(sl);
1139	+	assertValid(sl, stamp);
1140	+	assertNoLongerValidStampsThrow.run();
1141	+	assertThrows(IllegalMonitorStateException.class,
1142	+	() -> sl.unlockRead(stamp),
1143	+	() -> sl.unlockWrite(0L));
1144	+	writeUnlocker.accept(sl, stamp);
1145	+	assertUnlocked(sl);
1146	+	assertNoLongerValidStampsThrow.run();
1147	+	}
1148	+	}
1149	+
1150	+	/**
1151	+	* Read locks can be very deeply nested
1152	+	*/
1153	+	public void testDeeplyNestedReadLocks() {
1154	+	final StampedLock lock = new StampedLock();
1155	+	final int depth = 300;
1156	+	final long[] stamps = new long[depth];
1157	+	final List<Function<StampedLock, Long>> readLockers = readLockers();
1158	+	final List<BiConsumer<StampedLock, Long>> readUnlockers = readUnlockers();
1159	+	for (int i = 0; i < depth; i++) {
1160	+	Function<StampedLock, Long> readLocker
1161	+	= readLockers.get(i % readLockers.size());
1162	+	long stamp = readLocker.apply(lock);
1163	+	assertEquals(i + 1, lock.getReadLockCount());
1164	+	assertTrue(lock.isReadLocked());
1165	+	stamps[i] = stamp;
1166	+	}
1167	+	for (int i = 0; i < depth; i++) {
1168	+	BiConsumer<StampedLock, Long> readUnlocker
1169	+	= readUnlockers.get(i % readUnlockers.size());
1170	+	assertEquals(depth - i, lock.getReadLockCount());
1171	+	assertTrue(lock.isReadLocked());
1172	+	readUnlocker.accept(lock, stamps[depth - 1 - i]);
1173	+	}
1174	+	assertUnlocked(lock);
1175	+	}
1176		}

Diff Legend

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