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.14 by jsr166, Fri May 15 18:21:19 2015 UTC vs.
Revision 1.25 by jsr166, Sun Jul 17 02:30:53 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;
#	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	+	/**
1072	+	* Invalid write stamps result in IllegalMonitorStateException
1073	+	*/
1074	+	public void testInvalidWriteStampsThrowIllegalMonitorStateException() {
1075	+	List<Function<StampedLock, Long>> writeLockers = new ArrayList<>();
1076	+	writeLockers.add((sl) -> sl.writeLock());
1077	+	writeLockers.add((sl) -> writeLockInterruptiblyUninterrupted(sl));
1078	+	writeLockers.add((sl) -> tryWriteLockUninterrupted(sl, Long.MIN_VALUE, DAYS));
1079	+	writeLockers.add((sl) -> tryWriteLockUninterrupted(sl, 0, DAYS));
1080	+
1081	+	List<Consumer<StampedLock>> mutaters = new ArrayList<>();
1082	+	mutaters.add((sl) -> {});
1083	+	mutaters.add((sl) -> sl.readLock());
1084	+	for (Function<StampedLock, Long> writeLocker : writeLockers)
1085	+	mutaters.add((sl) -> writeLocker.apply(sl));
1086	+
1087	+	List<BiConsumer<StampedLock, Long>> writeUnlockers = new ArrayList<>();
1088	+	writeUnlockers.add((sl, stamp) -> sl.unlockWrite(stamp));
1089	+	writeUnlockers.add((sl, stamp) -> assertTrue(sl.tryUnlockWrite()));
1090	+	writeUnlockers.add((sl, stamp) -> sl.asWriteLock().unlock());
1091	+	writeUnlockers.add((sl, stamp) -> sl.unlock(stamp));
1092	+
1093	+	for (Function<StampedLock, Long> writeLocker : writeLockers)
1094	+	for (BiConsumer<StampedLock, Long> writeUnlocker : writeUnlockers)
1095	+	for (Consumer<StampedLock> mutater : mutaters) {
1096	+	StampedLock sl = new StampedLock();
1097	+	long stamp = writeLocker.apply(sl);
1098	+	assertTrue(stamp != 0L);
1099	+	assertThrows(IllegalMonitorStateException.class,
1100	+	() -> sl.unlockRead(stamp));
1101	+	writeUnlocker.accept(sl, stamp);
1102	+	mutater.accept(sl);
1103	+	assertThrows(IllegalMonitorStateException.class,
1104	+	() -> sl.unlock(stamp),
1105	+	() -> sl.unlockRead(stamp),
1106	+	() -> sl.unlockWrite(stamp));
1107	+	}
1108	+	}
1109	+
1110		}

Diff Legend

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