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.21 by jsr166, Tue Jun 7 22:10:33 2016 UTC

#	Line 16 | Line 16 | import junit.framework.TestSuite;
16
17		public class StampedLockTest extends JSR166TestCase {
18		public static void main(String[] args) {
19	<	junit.textui.TestRunner.run(suite());
19	>	main(suite(), args);
20		}
21		public static Test suite() {
22		return new TestSuite(StampedLockTest.class);
#	Line 166 | Line 166 | public class StampedLockTest extends JSR
166		*/
167		public void testWriteUnlock_IMSE2() {
168		StampedLock lock = new StampedLock();
169	+	long s = lock.writeLock();
170	+	lock.unlockWrite(s);
171		try {
170	–	long s = lock.writeLock();
171	–	lock.unlockWrite(s);
172		lock.unlockWrite(s);
173		shouldThrow();
174		} catch (IllegalMonitorStateException success) {}
#	Line 179 | Line 179 | public class StampedLockTest extends JSR
179		*/
180		public void testWriteUnlock_IMSE3() {
181		StampedLock lock = new StampedLock();
182	+	long s = lock.readLock();
183		try {
183	–	long s = lock.readLock();
184		lock.unlockWrite(s);
185		shouldThrow();
186		} catch (IllegalMonitorStateException success) {}
#	Line 191 | Line 191 | public class StampedLockTest extends JSR
191		*/
192		public void testReadUnlock_IMSE() {
193		StampedLock lock = new StampedLock();
194	+	long s = lock.readLock();
195	+	lock.unlockRead(s);
196		try {
195	–	long s = lock.readLock();
196	–	lock.unlockRead(s);
197		lock.unlockRead(s);
198		shouldThrow();
199		} catch (IllegalMonitorStateException success) {}
#	Line 215 | Line 215 | public class StampedLockTest extends JSR
215		*/
216		public void testReadUnlock_IMSE3() {
217		StampedLock lock = new StampedLock();
218	+	long s = lock.writeLock();
219		try {
219	–	long s = lock.writeLock();
220		lock.unlockRead(s);
221		shouldThrow();
222		} catch (IllegalMonitorStateException success) {}
#	Line 285 | Line 285 | public class StampedLockTest extends JSR
285		running.countDown();
286		lock.writeLockInterruptibly();
287		}});
288	<
288	>
289		running.await();
290		waitForThreadToEnterWaitState(t, 100);
291		t.interrupt();
#	Line 305 | Line 305 | public class StampedLockTest extends JSR
305		running.countDown();
306		lock.tryWriteLock(2 * LONG_DELAY_MS, MILLISECONDS);
307		}});
308	<
308	>
309		running.await();
310		waitForThreadToEnterWaitState(t, 100);
311		t.interrupt();
#	Line 326 | Line 326 | public class StampedLockTest extends JSR
326		running.countDown();
327		lock.readLockInterruptibly();
328		}});
329	<
329	>
330		running.await();
331		waitForThreadToEnterWaitState(t, 100);
332		t.interrupt();
#	Line 346 | Line 346 | public class StampedLockTest extends JSR
346		running.countDown();
347		lock.tryReadLock(2 * LONG_DELAY_MS, MILLISECONDS);
348		}});
349	<
349	>
350		running.await();
351		waitForThreadToEnterWaitState(t, 100);
352		t.interrupt();
#	Line 378 | Line 378 | public class StampedLockTest extends JSR
378		long ws = lock.tryWriteLock();
379		assertTrue(ws == 0L);
380		}});
381	<
381	>
382		awaitTermination(t);
383		releaseWriteLock(lock, s);
384		}
#	Line 394 | Line 394 | public class StampedLockTest extends JSR
394		long rs = lock.tryReadLock();
395		assertEquals(rs, 0L);
396		}});
397	<
397	>
398		awaitTermination(t);
399		releaseWriteLock(lock, s);
400		}
#	Line 416 | Line 416 | public class StampedLockTest extends JSR
416		long s4 = lock.readLock();
417		lock.unlockRead(s4);
418		}});
419	<
419	>
420		awaitTermination(t);
421		lock.unlockRead(s);
422		}
#	Line 434 | Line 434 | public class StampedLockTest extends JSR
434		long s = lock.writeLock();
435		lock.unlockWrite(s);
436		}});
437	<
437	>
438		running.await();
439		waitForThreadToEnterWaitState(t, 100);
440		assertFalse(lock.isWriteLocked());
#	Line 454 | Line 454 | public class StampedLockTest extends JSR
454		long rs = lock.readLock();
455		lock.unlockRead(rs);
456		}});
457	<
457	>
458		awaitTermination(t1);
459
460		Thread t2 = newStartedThread(new CheckedRunnable() {
#	Line 462 | Line 462 | public class StampedLockTest extends JSR
462		long ws = lock.writeLock();
463		lock.unlockWrite(ws);
464		}});
465	<
465	>
466		assertFalse(lock.isWriteLocked());
467		lock.unlockRead(s);
468		awaitTermination(t2);
#	Line 599 | Line 599 | public class StampedLockTest extends JSR
599		running.countDown();
600		lock.readLockInterruptibly();
601		}});
602	<
602	>
603		running.await();
604		waitForThreadToEnterWaitState(t, 100);
605		t.interrupt();
#	Line 704 | Line 704 | public class StampedLockTest extends JSR
704		running.countDown();
705		lock.writeLockInterruptibly();
706		}});
707	<
707	>
708		running.await();
709		assertFalse(lock.validate(p));
710		assertFalse((p = lock.tryOptimisticRead()) != 0L);
#	Line 718 | Line 718 | public class StampedLockTest extends JSR
718		public void testTryConvertToOptimisticRead() throws InterruptedException {
719		StampedLock lock = new StampedLock();
720		long s, p;
721	<	s = 0L;
722	<	assertFalse((p = lock.tryConvertToOptimisticRead(s)) != 0L);
721	>	assertEquals(0L, lock.tryConvertToOptimisticRead(0L));
722	>
723		assertTrue((s = lock.tryOptimisticRead()) != 0L);
724	<	assertTrue((p = lock.tryConvertToOptimisticRead(s)) != 0L);
724	>	assertEquals(s, lock.tryConvertToOptimisticRead(s));
725	>	assertTrue(lock.validate(s));
726	>
727	>	assertTrue((p = lock.readLock()) != 0L);
728	>	assertTrue((s = lock.tryOptimisticRead()) != 0L);
729	>	assertEquals(s, lock.tryConvertToOptimisticRead(s));
730	>	assertTrue(lock.validate(s));
731	>	lock.unlockRead(p);
732	>
733		assertTrue((s = lock.writeLock()) != 0L);
734		assertTrue((p = lock.tryConvertToOptimisticRead(s)) != 0L);
735		assertTrue(lock.validate(p));
736	+
737		assertTrue((s = lock.readLock()) != 0L);
738		assertTrue(lock.validate(s));
739		assertTrue((p = lock.tryConvertToOptimisticRead(s)) != 0L);
740		assertTrue(lock.validate(p));
741	+
742		assertTrue((s = lock.tryWriteLock()) != 0L);
743		assertTrue(lock.validate(s));
744		assertTrue((p = lock.tryConvertToOptimisticRead(s)) != 0L);
745		assertTrue(lock.validate(p));
746	+
747		assertTrue((s = lock.tryReadLock()) != 0L);
748		assertTrue(lock.validate(s));
749		assertTrue((p = lock.tryConvertToOptimisticRead(s)) != 0L);
750		assertTrue(lock.validate(p));
751	+
752		assertTrue((s = lock.tryWriteLock(100L, MILLISECONDS)) != 0L);
753		assertTrue((p = lock.tryConvertToOptimisticRead(s)) != 0L);
754		assertTrue(lock.validate(p));
755	+
756		assertTrue((s = lock.tryReadLock(100L, MILLISECONDS)) != 0L);
757		assertTrue(lock.validate(s));
758		assertTrue((p = lock.tryConvertToOptimisticRead(s)) != 0L);
#	Line 795 | Line 808 | public class StampedLockTest extends JSR
808		public void testTryConvertToWriteLock() throws InterruptedException {
809		StampedLock lock = new StampedLock();
810		long s, p;
811	<	s = 0L;
812	<	assertFalse((p = lock.tryConvertToWriteLock(s)) != 0L);
811	>
812	>	assertFalse((p = lock.tryConvertToWriteLock(0L)) != 0L);
813	>
814		assertTrue((s = lock.tryOptimisticRead()) != 0L);
815		assertTrue((p = lock.tryConvertToWriteLock(s)) != 0L);
816		lock.unlockWrite(p);
817	+
818		assertTrue((s = lock.writeLock()) != 0L);
819	<	assertTrue((p = lock.tryConvertToWriteLock(s)) != 0L);
820	<	assertTrue(lock.validate(p));
821	<	lock.unlockWrite(p);
819	>	assertEquals(s, lock.tryConvertToWriteLock(s));
820	>	assertTrue(lock.validate(s));
821	>	lock.unlockWrite(s);
822	>
823		assertTrue((s = lock.readLock()) != 0L);
824		assertTrue(lock.validate(s));
825		assertTrue((p = lock.tryConvertToWriteLock(s)) != 0L);
826		assertTrue(lock.validate(p));
827		lock.unlockWrite(p);
828	+
829		assertTrue((s = lock.tryWriteLock()) != 0L);
830		assertTrue(lock.validate(s));
831	<	assertTrue((p = lock.tryConvertToWriteLock(s)) != 0L);
832	<	assertTrue(lock.validate(p));
833	<	lock.unlockWrite(p);
831	>	assertEquals(s, lock.tryConvertToWriteLock(s));
832	>	assertTrue(lock.validate(s));
833	>	lock.unlockWrite(s);
834	>
835		assertTrue((s = lock.tryReadLock()) != 0L);
836		assertTrue(lock.validate(s));
837		assertTrue((p = lock.tryConvertToWriteLock(s)) != 0L);
838		assertTrue(lock.validate(p));
839		lock.unlockWrite(p);
840	+
841		assertTrue((s = lock.tryWriteLock(100L, MILLISECONDS)) != 0L);
842		assertTrue((p = lock.tryConvertToWriteLock(s)) != 0L);
843		assertTrue(lock.validate(p));
844		lock.unlockWrite(p);
845	+
846		assertTrue((s = lock.tryReadLock(100L, MILLISECONDS)) != 0L);
847		assertTrue(lock.validate(s));
848		assertTrue((p = lock.tryConvertToWriteLock(s)) != 0L);
#	Line 876 | Line 896 | public class StampedLockTest extends JSR
896		assertTrue(lock.tryLock());
897		}
898
899	+	/**
900	+	* Lock.newCondition throws UnsupportedOperationException
901	+	*/
902	+	public void testLockViewsDoNotSupportConditions() {
903	+	StampedLock sl = new StampedLock();
904	+	assertThrows(UnsupportedOperationException.class,
905	+	() -> sl.asWriteLock().newCondition(),
906	+	() -> sl.asReadLock().newCondition(),
907	+	() -> sl.asReadWriteLock().writeLock().newCondition(),
908	+	() -> sl.asReadWriteLock().readLock().newCondition());
909	+	}
910	+
911	+	/**
912	+	* Passing optimistic read stamps to unlock operations result in
913	+	* IllegalMonitorStateException
914	+	*/
915	+	public void testCannotUnlockOptimisticReadStamps() {
916	+	Runnable[] actions = {
917	+	() -> {
918	+	StampedLock sl = new StampedLock();
919	+	long stamp = sl.tryOptimisticRead();
920	+	assertTrue(stamp != 0);
921	+	sl.unlockRead(stamp);
922	+	},
923	+	() -> {
924	+	StampedLock sl = new StampedLock();
925	+	long stamp = sl.tryOptimisticRead();
926	+	sl.unlock(stamp);
927	+	},
928	+
929	+	() -> {
930	+	StampedLock sl = new StampedLock();
931	+	long stamp = sl.tryOptimisticRead();
932	+	sl.writeLock();
933	+	sl.unlock(stamp);
934	+	},
935	+	() -> {
936	+	StampedLock sl = new StampedLock();
937	+	long stamp = sl.tryOptimisticRead();
938	+	sl.readLock();
939	+	sl.unlockRead(stamp);
940	+	},
941	+	() -> {
942	+	StampedLock sl = new StampedLock();
943	+	long stamp = sl.tryOptimisticRead();
944	+	sl.readLock();
945	+	sl.unlock(stamp);
946	+	},
947	+
948	+	() -> {
949	+	StampedLock sl = new StampedLock();
950	+	long stamp = sl.tryConvertToOptimisticRead(sl.writeLock());
951	+	assertTrue(stamp != 0);
952	+	sl.writeLock();
953	+	sl.unlockWrite(stamp);
954	+	},
955	+	() -> {
956	+	StampedLock sl = new StampedLock();
957	+	long stamp = sl.tryConvertToOptimisticRead(sl.writeLock());
958	+	sl.writeLock();
959	+	sl.unlock(stamp);
960	+	},
961	+	() -> {
962	+	StampedLock sl = new StampedLock();
963	+	long stamp = sl.tryConvertToOptimisticRead(sl.writeLock());
964	+	sl.readLock();
965	+	sl.unlockRead(stamp);
966	+	},
967	+	() -> {
968	+	StampedLock sl = new StampedLock();
969	+	long stamp = sl.tryConvertToOptimisticRead(sl.writeLock());
970	+	sl.readLock();
971	+	sl.unlock(stamp);
972	+	},
973	+
974	+	() -> {
975	+	StampedLock sl = new StampedLock();
976	+	long stamp = sl.tryConvertToOptimisticRead(sl.readLock());
977	+	assertTrue(stamp != 0);
978	+	sl.writeLock();
979	+	sl.unlockWrite(stamp);
980	+	},
981	+	() -> {
982	+	StampedLock sl = new StampedLock();
983	+	long stamp = sl.tryConvertToOptimisticRead(sl.readLock());
984	+	sl.writeLock();
985	+	sl.unlock(stamp);
986	+	},
987	+	() -> {
988	+	StampedLock sl = new StampedLock();
989	+	long stamp = sl.tryConvertToOptimisticRead(sl.readLock());
990	+	sl.readLock();
991	+	sl.unlockRead(stamp);
992	+	},
993	+	() -> {
994	+	StampedLock sl = new StampedLock();
995	+	sl.readLock();
996	+	long stamp = sl.tryConvertToOptimisticRead(sl.readLock());
997	+	assertTrue(stamp != 0);
998	+	sl.readLock();
999	+	sl.unlockRead(stamp);
1000	+	},
1001	+	() -> {
1002	+	StampedLock sl = new StampedLock();
1003	+	long stamp = sl.tryConvertToOptimisticRead(sl.readLock());
1004	+	sl.readLock();
1005	+	sl.unlock(stamp);
1006	+	},
1007	+	() -> {
1008	+	StampedLock sl = new StampedLock();
1009	+	sl.readLock();
1010	+	long stamp = sl.tryConvertToOptimisticRead(sl.readLock());
1011	+	sl.readLock();
1012	+	sl.unlock(stamp);
1013	+	},
1014	+	};
1015	+
1016	+	assertThrows(IllegalMonitorStateException.class, actions);
1017	+	}
1018	+
1019		}

Diff Legend

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