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.11 by jsr166, Fri Feb 27 21:43:18 2015 UTC vs.
Revision 1.26 by jsr166, Sun Jul 17 03:06:50 2016 UTC

#	Line 5 | Line 5
5		* http://creativecommons.org/publicdomain/zero/1.0/
6		*/
7
8	+	import static java.util.concurrent.TimeUnit.DAYS;
9		import static java.util.concurrent.TimeUnit.MILLISECONDS;
10
11	+	import java.util.ArrayList;
12	+	import java.util.List;
13		import java.util.concurrent.CountDownLatch;
14	+	import java.util.concurrent.TimeUnit;
15		import java.util.concurrent.locks.Lock;
16		import java.util.concurrent.locks.StampedLock;
17	+	import java.util.function.BiConsumer;
18	+	import java.util.function.Consumer;
19	+	import java.util.function.Function;
20
21		import junit.framework.Test;
22		import junit.framework.TestSuite;
23
24		public class StampedLockTest extends JSR166TestCase {
25		public static void main(String[] args) {
26	<	junit.textui.TestRunner.run(suite());
26	>	main(suite(), args);
27		}
28		public static Test suite() {
29		return new TestSuite(StampedLockTest.class);
#	Line 166 | Line 173 | public class StampedLockTest extends JSR
173		*/
174		public void testWriteUnlock_IMSE2() {
175		StampedLock lock = new StampedLock();
176	+	long s = lock.writeLock();
177	+	lock.unlockWrite(s);
178		try {
170	–	long s = lock.writeLock();
171	–	lock.unlockWrite(s);
179		lock.unlockWrite(s);
180		shouldThrow();
181		} catch (IllegalMonitorStateException success) {}
#	Line 179 | Line 186 | public class StampedLockTest extends JSR
186		*/
187		public void testWriteUnlock_IMSE3() {
188		StampedLock lock = new StampedLock();
189	+	long s = lock.readLock();
190		try {
183	–	long s = lock.readLock();
191		lock.unlockWrite(s);
192		shouldThrow();
193		} catch (IllegalMonitorStateException success) {}
#	Line 191 | Line 198 | public class StampedLockTest extends JSR
198		*/
199		public void testReadUnlock_IMSE() {
200		StampedLock lock = new StampedLock();
201	+	long s = lock.readLock();
202	+	lock.unlockRead(s);
203		try {
195	–	long s = lock.readLock();
196	–	lock.unlockRead(s);
204		lock.unlockRead(s);
205		shouldThrow();
206		} catch (IllegalMonitorStateException success) {}
#	Line 215 | Line 222 | public class StampedLockTest extends JSR
222		*/
223		public void testReadUnlock_IMSE3() {
224		StampedLock lock = new StampedLock();
225	+	long s = lock.writeLock();
226		try {
219	–	long s = lock.writeLock();
227		lock.unlockRead(s);
228		shouldThrow();
229		} catch (IllegalMonitorStateException success) {}
#	Line 285 | Line 292 | public class StampedLockTest extends JSR
292		running.countDown();
293		lock.writeLockInterruptibly();
294		}});
295	<
295	>
296		running.await();
297		waitForThreadToEnterWaitState(t, 100);
298		t.interrupt();
#	Line 305 | Line 312 | public class StampedLockTest extends JSR
312		running.countDown();
313		lock.tryWriteLock(2 * LONG_DELAY_MS, MILLISECONDS);
314		}});
315	<
315	>
316		running.await();
317		waitForThreadToEnterWaitState(t, 100);
318		t.interrupt();
#	Line 326 | Line 333 | public class StampedLockTest extends JSR
333		running.countDown();
334		lock.readLockInterruptibly();
335		}});
336	<
336	>
337		running.await();
338		waitForThreadToEnterWaitState(t, 100);
339		t.interrupt();
#	Line 346 | Line 353 | public class StampedLockTest extends JSR
353		running.countDown();
354		lock.tryReadLock(2 * LONG_DELAY_MS, MILLISECONDS);
355		}});
356	<
356	>
357		running.await();
358		waitForThreadToEnterWaitState(t, 100);
359		t.interrupt();
#	Line 378 | Line 385 | public class StampedLockTest extends JSR
385		long ws = lock.tryWriteLock();
386		assertTrue(ws == 0L);
387		}});
388	<
388	>
389		awaitTermination(t);
390		releaseWriteLock(lock, s);
391		}
#	Line 394 | Line 401 | public class StampedLockTest extends JSR
401		long rs = lock.tryReadLock();
402		assertEquals(rs, 0L);
403		}});
404	<
404	>
405		awaitTermination(t);
406		releaseWriteLock(lock, s);
407		}
#	Line 416 | Line 423 | public class StampedLockTest extends JSR
423		long s4 = lock.readLock();
424		lock.unlockRead(s4);
425		}});
426	<
426	>
427		awaitTermination(t);
428		lock.unlockRead(s);
429		}
#	Line 434 | Line 441 | public class StampedLockTest extends JSR
441		long s = lock.writeLock();
442		lock.unlockWrite(s);
443		}});
444	<
444	>
445		running.await();
446		waitForThreadToEnterWaitState(t, 100);
447		assertFalse(lock.isWriteLocked());
#	Line 454 | Line 461 | public class StampedLockTest extends JSR
461		long rs = lock.readLock();
462		lock.unlockRead(rs);
463		}});
464	<
464	>
465		awaitTermination(t1);
466
467		Thread t2 = newStartedThread(new CheckedRunnable() {
#	Line 462 | Line 469 | public class StampedLockTest extends JSR
469		long ws = lock.writeLock();
470		lock.unlockWrite(ws);
471		}});
472	<
472	>
473		assertFalse(lock.isWriteLocked());
474		lock.unlockRead(s);
475		awaitTermination(t2);
#	Line 599 | Line 606 | public class StampedLockTest extends JSR
606		running.countDown();
607		lock.readLockInterruptibly();
608		}});
609	<
609	>
610		running.await();
611		waitForThreadToEnterWaitState(t, 100);
612		t.interrupt();
#	Line 704 | Line 711 | public class StampedLockTest extends JSR
711		running.countDown();
712		lock.writeLockInterruptibly();
713		}});
714	<
714	>
715		running.await();
716		assertFalse(lock.validate(p));
717		assertFalse((p = lock.tryOptimisticRead()) != 0L);
#	Line 718 | Line 725 | public class StampedLockTest extends JSR
725		public void testTryConvertToOptimisticRead() throws InterruptedException {
726		StampedLock lock = new StampedLock();
727		long s, p;
728	<	s = 0L;
729	<	assertFalse((p = lock.tryConvertToOptimisticRead(s)) != 0L);
728	>	assertEquals(0L, lock.tryConvertToOptimisticRead(0L));
729	>
730		assertTrue((s = lock.tryOptimisticRead()) != 0L);
731	<	assertTrue((p = lock.tryConvertToOptimisticRead(s)) != 0L);
731	>	assertEquals(s, lock.tryConvertToOptimisticRead(s));
732	>	assertTrue(lock.validate(s));
733	>
734	>	assertTrue((p = lock.readLock()) != 0L);
735	>	assertTrue((s = lock.tryOptimisticRead()) != 0L);
736	>	assertEquals(s, lock.tryConvertToOptimisticRead(s));
737	>	assertTrue(lock.validate(s));
738	>	lock.unlockRead(p);
739	>
740		assertTrue((s = lock.writeLock()) != 0L);
741		assertTrue((p = lock.tryConvertToOptimisticRead(s)) != 0L);
742		assertTrue(lock.validate(p));
743	+
744		assertTrue((s = lock.readLock()) != 0L);
745		assertTrue(lock.validate(s));
746		assertTrue((p = lock.tryConvertToOptimisticRead(s)) != 0L);
747		assertTrue(lock.validate(p));
748	+
749		assertTrue((s = lock.tryWriteLock()) != 0L);
750		assertTrue(lock.validate(s));
751		assertTrue((p = lock.tryConvertToOptimisticRead(s)) != 0L);
752		assertTrue(lock.validate(p));
753	+
754		assertTrue((s = lock.tryReadLock()) != 0L);
755		assertTrue(lock.validate(s));
756		assertTrue((p = lock.tryConvertToOptimisticRead(s)) != 0L);
757		assertTrue(lock.validate(p));
758	+
759		assertTrue((s = lock.tryWriteLock(100L, MILLISECONDS)) != 0L);
760		assertTrue((p = lock.tryConvertToOptimisticRead(s)) != 0L);
761		assertTrue(lock.validate(p));
762	+
763		assertTrue((s = lock.tryReadLock(100L, MILLISECONDS)) != 0L);
764		assertTrue(lock.validate(s));
765		assertTrue((p = lock.tryConvertToOptimisticRead(s)) != 0L);
#	Line 753 | Line 773 | public class StampedLockTest extends JSR
773		public void testTryConvertToReadLock() throws InterruptedException {
774		StampedLock lock = new StampedLock();
775		long s, p;
776	<	s = 0L;
777	<	assertFalse((p = lock.tryConvertToReadLock(s)) != 0L);
776	>
777	>	assertFalse((p = lock.tryConvertToReadLock(0L)) != 0L);
778	>
779	>	assertTrue((s = lock.tryOptimisticRead()) != 0L);
780	>	assertTrue((p = lock.tryConvertToReadLock(s)) != 0L);
781	>	assertTrue(lock.isReadLocked());
782	>	assertEquals(1, lock.getReadLockCount());
783	>	lock.unlockRead(p);
784	>
785		assertTrue((s = lock.tryOptimisticRead()) != 0L);
786	+	lock.readLock();
787		assertTrue((p = lock.tryConvertToReadLock(s)) != 0L);
788	+	assertTrue(lock.isReadLocked());
789	+	assertEquals(2, lock.getReadLockCount());
790		lock.unlockRead(p);
791	+	lock.unlockRead(p);
792	+
793		assertTrue((s = lock.writeLock()) != 0L);
794		assertTrue((p = lock.tryConvertToReadLock(s)) != 0L);
795		assertTrue(lock.validate(p));
796	+	assertTrue(lock.isReadLocked());
797	+	assertEquals(1, lock.getReadLockCount());
798		lock.unlockRead(p);
799	+
800		assertTrue((s = lock.readLock()) != 0L);
801		assertTrue(lock.validate(s));
802	<	assertTrue((p = lock.tryConvertToReadLock(s)) != 0L);
803	<	assertTrue(lock.validate(p));
804	<	lock.unlockRead(p);
802	>	assertEquals(s, lock.tryConvertToReadLock(s));
803	>	assertTrue(lock.validate(s));
804	>	assertTrue(lock.isReadLocked());
805	>	assertEquals(1, lock.getReadLockCount());
806	>	lock.unlockRead(s);
807	>
808		assertTrue((s = lock.tryWriteLock()) != 0L);
809		assertTrue(lock.validate(s));
810		assertTrue((p = lock.tryConvertToReadLock(s)) != 0L);
811		assertTrue(lock.validate(p));
812	+	assertEquals(1, lock.getReadLockCount());
813		lock.unlockRead(p);
814	+
815		assertTrue((s = lock.tryReadLock()) != 0L);
816		assertTrue(lock.validate(s));
817	<	assertTrue((p = lock.tryConvertToReadLock(s)) != 0L);
818	<	assertTrue(lock.validate(p));
819	<	lock.unlockRead(p);
817	>	assertEquals(s, lock.tryConvertToReadLock(s));
818	>	assertTrue(lock.validate(s));
819	>	assertTrue(lock.isReadLocked());
820	>	assertEquals(1, lock.getReadLockCount());
821	>	lock.unlockRead(s);
822	>
823		assertTrue((s = lock.tryWriteLock(100L, MILLISECONDS)) != 0L);
824		assertTrue((p = lock.tryConvertToReadLock(s)) != 0L);
825		assertTrue(lock.validate(p));
826	+	assertTrue(lock.isReadLocked());
827	+	assertEquals(1, lock.getReadLockCount());
828		lock.unlockRead(p);
829	+
830		assertTrue((s = lock.tryReadLock(100L, MILLISECONDS)) != 0L);
831		assertTrue(lock.validate(s));
832	<	assertTrue((p = lock.tryConvertToReadLock(s)) != 0L);
833	<	assertTrue(lock.validate(p));
834	<	lock.unlockRead(p);
832	>	assertEquals(s, lock.tryConvertToReadLock(s));
833	>	assertTrue(lock.validate(s));
834	>	assertTrue(lock.isReadLocked());
835	>	assertEquals(1, lock.getReadLockCount());
836	>	lock.unlockRead(s);
837		}
838
839		/**
#	Line 795 | Line 843 | public class StampedLockTest extends JSR
843		public void testTryConvertToWriteLock() throws InterruptedException {
844		StampedLock lock = new StampedLock();
845		long s, p;
846	<	s = 0L;
847	<	assertFalse((p = lock.tryConvertToWriteLock(s)) != 0L);
846	>
847	>	assertFalse((p = lock.tryConvertToWriteLock(0L)) != 0L);
848	>
849		assertTrue((s = lock.tryOptimisticRead()) != 0L);
850		assertTrue((p = lock.tryConvertToWriteLock(s)) != 0L);
851	+	assertTrue(lock.isWriteLocked());
852		lock.unlockWrite(p);
853	+
854		assertTrue((s = lock.writeLock()) != 0L);
855	<	assertTrue((p = lock.tryConvertToWriteLock(s)) != 0L);
856	<	assertTrue(lock.validate(p));
857	<	lock.unlockWrite(p);
855	>	assertEquals(s, lock.tryConvertToWriteLock(s));
856	>	assertTrue(lock.validate(s));
857	>	assertTrue(lock.isWriteLocked());
858	>	lock.unlockWrite(s);
859	>
860		assertTrue((s = lock.readLock()) != 0L);
861		assertTrue(lock.validate(s));
862		assertTrue((p = lock.tryConvertToWriteLock(s)) != 0L);
863		assertTrue(lock.validate(p));
864	+	assertTrue(lock.isWriteLocked());
865		lock.unlockWrite(p);
866	+
867		assertTrue((s = lock.tryWriteLock()) != 0L);
868		assertTrue(lock.validate(s));
869	<	assertTrue((p = lock.tryConvertToWriteLock(s)) != 0L);
870	<	assertTrue(lock.validate(p));
871	<	lock.unlockWrite(p);
869	>	assertEquals(s, lock.tryConvertToWriteLock(s));
870	>	assertTrue(lock.validate(s));
871	>	assertTrue(lock.isWriteLocked());
872	>	lock.unlockWrite(s);
873	>
874		assertTrue((s = lock.tryReadLock()) != 0L);
875		assertTrue(lock.validate(s));
876		assertTrue((p = lock.tryConvertToWriteLock(s)) != 0L);
877		assertTrue(lock.validate(p));
878	+	assertTrue(lock.isWriteLocked());
879		lock.unlockWrite(p);
880	+
881		assertTrue((s = lock.tryWriteLock(100L, MILLISECONDS)) != 0L);
882		assertTrue((p = lock.tryConvertToWriteLock(s)) != 0L);
883		assertTrue(lock.validate(p));
884	+	assertTrue(lock.isWriteLocked());
885		lock.unlockWrite(p);
886	+
887		assertTrue((s = lock.tryReadLock(100L, MILLISECONDS)) != 0L);
888		assertTrue(lock.validate(s));
889		assertTrue((p = lock.tryConvertToWriteLock(s)) != 0L);
890		assertTrue(lock.validate(p));
891	+	assertTrue(lock.isWriteLocked());
892		lock.unlockWrite(p);
893		}
894
#	Line 876 | Line 938 | public class StampedLockTest extends JSR
938		assertTrue(lock.tryLock());
939		}
940
941	+	/**
942	+	* Lock.newCondition throws UnsupportedOperationException
943	+	*/
944	+	public void testLockViewsDoNotSupportConditions() {
945	+	StampedLock sl = new StampedLock();
946	+	assertThrows(UnsupportedOperationException.class,
947	+	() -> sl.asWriteLock().newCondition(),
948	+	() -> sl.asReadLock().newCondition(),
949	+	() -> sl.asReadWriteLock().writeLock().newCondition(),
950	+	() -> sl.asReadWriteLock().readLock().newCondition());
951	+	}
952	+
953	+	/**
954	+	* Passing optimistic read stamps to unlock operations result in
955	+	* IllegalMonitorStateException
956	+	*/
957	+	public void testCannotUnlockOptimisticReadStamps() {
958	+	Runnable[] actions = {
959	+	() -> {
960	+	StampedLock sl = new StampedLock();
961	+	long stamp = sl.tryOptimisticRead();
962	+	assertTrue(stamp != 0);
963	+	sl.unlockRead(stamp);
964	+	},
965	+	() -> {
966	+	StampedLock sl = new StampedLock();
967	+	long stamp = sl.tryOptimisticRead();
968	+	sl.unlock(stamp);
969	+	},
970	+
971	+	() -> {
972	+	StampedLock sl = new StampedLock();
973	+	long stamp = sl.tryOptimisticRead();
974	+	sl.writeLock();
975	+	sl.unlock(stamp);
976	+	},
977	+	() -> {
978	+	StampedLock sl = new StampedLock();
979	+	long stamp = sl.tryOptimisticRead();
980	+	sl.readLock();
981	+	sl.unlockRead(stamp);
982	+	},
983	+	() -> {
984	+	StampedLock sl = new StampedLock();
985	+	long stamp = sl.tryOptimisticRead();
986	+	sl.readLock();
987	+	sl.unlock(stamp);
988	+	},
989	+
990	+	() -> {
991	+	StampedLock sl = new StampedLock();
992	+	long stamp = sl.tryConvertToOptimisticRead(sl.writeLock());
993	+	assertTrue(stamp != 0);
994	+	sl.writeLock();
995	+	sl.unlockWrite(stamp);
996	+	},
997	+	() -> {
998	+	StampedLock sl = new StampedLock();
999	+	long stamp = sl.tryConvertToOptimisticRead(sl.writeLock());
1000	+	sl.writeLock();
1001	+	sl.unlock(stamp);
1002	+	},
1003	+	() -> {
1004	+	StampedLock sl = new StampedLock();
1005	+	long stamp = sl.tryConvertToOptimisticRead(sl.writeLock());
1006	+	sl.readLock();
1007	+	sl.unlockRead(stamp);
1008	+	},
1009	+	() -> {
1010	+	StampedLock sl = new StampedLock();
1011	+	long stamp = sl.tryConvertToOptimisticRead(sl.writeLock());
1012	+	sl.readLock();
1013	+	sl.unlock(stamp);
1014	+	},
1015	+
1016	+	() -> {
1017	+	StampedLock sl = new StampedLock();
1018	+	long stamp = sl.tryConvertToOptimisticRead(sl.readLock());
1019	+	assertTrue(stamp != 0);
1020	+	sl.writeLock();
1021	+	sl.unlockWrite(stamp);
1022	+	},
1023	+	() -> {
1024	+	StampedLock sl = new StampedLock();
1025	+	long stamp = sl.tryConvertToOptimisticRead(sl.readLock());
1026	+	sl.writeLock();
1027	+	sl.unlock(stamp);
1028	+	},
1029	+	() -> {
1030	+	StampedLock sl = new StampedLock();
1031	+	long stamp = sl.tryConvertToOptimisticRead(sl.readLock());
1032	+	sl.readLock();
1033	+	sl.unlockRead(stamp);
1034	+	},
1035	+	() -> {
1036	+	StampedLock sl = new StampedLock();
1037	+	sl.readLock();
1038	+	long stamp = sl.tryConvertToOptimisticRead(sl.readLock());
1039	+	assertTrue(stamp != 0);
1040	+	sl.readLock();
1041	+	sl.unlockRead(stamp);
1042	+	},
1043	+	() -> {
1044	+	StampedLock sl = new StampedLock();
1045	+	long stamp = sl.tryConvertToOptimisticRead(sl.readLock());
1046	+	sl.readLock();
1047	+	sl.unlock(stamp);
1048	+	},
1049	+	() -> {
1050	+	StampedLock sl = new StampedLock();
1051	+	sl.readLock();
1052	+	long stamp = sl.tryConvertToOptimisticRead(sl.readLock());
1053	+	sl.readLock();
1054	+	sl.unlock(stamp);
1055	+	},
1056	+	};
1057	+
1058	+	assertThrows(IllegalMonitorStateException.class, actions);
1059	+	}
1060	+
1061	+	static long writeLockInterruptiblyUninterrupted(StampedLock sl) {
1062	+	try { return sl.writeLockInterruptibly(); }
1063	+	catch (InterruptedException ex) { throw new AssertionError(ex); }
1064	+	}
1065	+
1066	+	static long tryWriteLockUninterrupted(StampedLock sl, long time, TimeUnit unit) {
1067	+	try { return sl.tryWriteLock(time, unit); }
1068	+	catch (InterruptedException ex) { throw new AssertionError(ex); }
1069	+	}
1070	+
1071	+	static long readLockInterruptiblyUninterrupted(StampedLock sl) {
1072	+	try { return sl.readLockInterruptibly(); }
1073	+	catch (InterruptedException ex) { throw new AssertionError(ex); }
1074	+	}
1075	+
1076	+	static long tryReadLockUninterrupted(StampedLock sl, long time, TimeUnit unit) {
1077	+	try { return sl.tryReadLock(time, unit); }
1078	+	catch (InterruptedException ex) { throw new AssertionError(ex); }
1079	+	}
1080	+
1081	+	/**
1082	+	* Invalid write stamps result in IllegalMonitorStateException
1083	+	*/
1084	+	public void testInvalidWriteStampsThrowIllegalMonitorStateException() {
1085	+	List<Function<StampedLock, Long>> writeLockers = new ArrayList<>();
1086	+	writeLockers.add((sl) -> sl.writeLock());
1087	+	writeLockers.add((sl) -> writeLockInterruptiblyUninterrupted(sl));
1088	+	writeLockers.add((sl) -> tryWriteLockUninterrupted(sl, Long.MIN_VALUE, DAYS));
1089	+	writeLockers.add((sl) -> tryWriteLockUninterrupted(sl, 0, DAYS));
1090	+
1091	+	List<BiConsumer<StampedLock, Long>> writeUnlockers = new ArrayList<>();
1092	+	writeUnlockers.add((sl, stamp) -> sl.unlockWrite(stamp));
1093	+	writeUnlockers.add((sl, stamp) -> assertTrue(sl.tryUnlockWrite()));
1094	+	writeUnlockers.add((sl, stamp) -> sl.asWriteLock().unlock());
1095	+	writeUnlockers.add((sl, stamp) -> sl.unlock(stamp));
1096	+
1097	+	List<Consumer<StampedLock>> mutaters = new ArrayList<>();
1098	+	mutaters.add((sl) -> {});
1099	+	mutaters.add((sl) -> sl.readLock());
1100	+	for (Function<StampedLock, Long> writeLocker : writeLockers)
1101	+	mutaters.add((sl) -> writeLocker.apply(sl));
1102	+
1103	+	for (Function<StampedLock, Long> writeLocker : writeLockers)
1104	+	for (BiConsumer<StampedLock, Long> writeUnlocker : writeUnlockers)
1105	+	for (Consumer<StampedLock> mutater : mutaters) {
1106	+	final StampedLock sl = new StampedLock();
1107	+	final long stamp = writeLocker.apply(sl);
1108	+	assertTrue(stamp != 0L);
1109	+	assertThrows(IllegalMonitorStateException.class,
1110	+	() -> sl.unlockRead(stamp));
1111	+	writeUnlocker.accept(sl, stamp);
1112	+	mutater.accept(sl);
1113	+	assertThrows(IllegalMonitorStateException.class,
1114	+	() -> sl.unlock(stamp),
1115	+	() -> sl.unlockRead(stamp),
1116	+	() -> sl.unlockWrite(stamp));
1117	+	}
1118	+	}
1119	+
1120	+	/**
1121	+	* Invalid read stamps result in IllegalMonitorStateException
1122	+	*/
1123	+	public void testInvalidReadStampsThrowIllegalMonitorStateException() {
1124	+	List<Function<StampedLock, Long>> readLockers = new ArrayList<>();
1125	+	readLockers.add((sl) -> sl.readLock());
1126	+	readLockers.add((sl) -> readLockInterruptiblyUninterrupted(sl));
1127	+	readLockers.add((sl) -> tryReadLockUninterrupted(sl, Long.MIN_VALUE, DAYS));
1128	+	readLockers.add((sl) -> tryReadLockUninterrupted(sl, 0, DAYS));
1129	+
1130	+	List<BiConsumer<StampedLock, Long>> readUnlockers = new ArrayList<>();
1131	+	readUnlockers.add((sl, stamp) -> sl.unlockRead(stamp));
1132	+	readUnlockers.add((sl, stamp) -> assertTrue(sl.tryUnlockRead()));
1133	+	readUnlockers.add((sl, stamp) -> sl.asReadLock().unlock());
1134	+	readUnlockers.add((sl, stamp) -> sl.unlock(stamp));
1135	+
1136	+	List<Function<StampedLock, Long>> writeLockers = new ArrayList<>();
1137	+	writeLockers.add((sl) -> sl.writeLock());
1138	+	writeLockers.add((sl) -> writeLockInterruptiblyUninterrupted(sl));
1139	+	writeLockers.add((sl) -> tryWriteLockUninterrupted(sl, Long.MIN_VALUE, DAYS));
1140	+	writeLockers.add((sl) -> tryWriteLockUninterrupted(sl, 0, DAYS));
1141	+
1142	+	List<BiConsumer<StampedLock, Long>> writeUnlockers = new ArrayList<>();
1143	+	writeUnlockers.add((sl, stamp) -> sl.unlockWrite(stamp));
1144	+	writeUnlockers.add((sl, stamp) -> assertTrue(sl.tryUnlockWrite()));
1145	+	writeUnlockers.add((sl, stamp) -> sl.asWriteLock().unlock());
1146	+	writeUnlockers.add((sl, stamp) -> sl.unlock(stamp));
1147	+
1148	+
1149	+	for (Function<StampedLock, Long> readLocker : readLockers)
1150	+	for (BiConsumer<StampedLock, Long> readUnlocker : readUnlockers)
1151	+	for (Function<StampedLock, Long> writeLocker : writeLockers)
1152	+	for (BiConsumer<StampedLock, Long> writeUnlocker : writeUnlockers) {
1153	+	final StampedLock sl = new StampedLock();
1154	+	final long stamp = readLocker.apply(sl);
1155	+	assertTrue(stamp != 0L);
1156	+	assertThrows(IllegalMonitorStateException.class,
1157	+	() -> sl.unlockWrite(stamp));
1158	+	readUnlocker.accept(sl, stamp);
1159	+	assertThrows(IllegalMonitorStateException.class,
1160	+	() -> sl.unlock(stamp),
1161	+	() -> sl.unlockRead(stamp),
1162	+	() -> sl.unlockWrite(stamp));
1163	+	final long writeStamp = writeLocker.apply(sl);
1164	+	assertTrue(writeStamp != 0L);
1165	+	assertTrue(writeStamp != stamp);
1166	+	assertThrows(IllegalMonitorStateException.class,
1167	+	() -> sl.unlock(stamp),
1168	+	() -> sl.unlockRead(stamp),
1169	+	() -> sl.unlockWrite(stamp));
1170	+	writeUnlocker.accept(sl, writeStamp);
1171	+	assertThrows(IllegalMonitorStateException.class,
1172	+	() -> sl.unlock(stamp),
1173	+	() -> sl.unlockRead(stamp),
1174	+	() -> sl.unlockWrite(stamp));
1175	+	}
1176	+	}
1177	+
1178		}

Diff Legend

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