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.19 by jsr166, Tue Jun 7 06:25:29 2016 UTC vs.
Revision 1.22 by jsr166, Tue Jun 7 22:19:52 2016 UTC

#	Line 724 | Line 724 | public class StampedLockTest extends JSR
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));
#	Line 760 | Line 766 | public class StampedLockTest extends JSR
766		public void testTryConvertToReadLock() throws InterruptedException {
767		StampedLock lock = new StampedLock();
768		long s, p;
769	<	s = 0L;
770	<	assertFalse((p = lock.tryConvertToReadLock(s)) != 0L);
769	>
770	>	assertFalse((p = lock.tryConvertToReadLock(0L)) != 0L);
771	>
772		assertTrue((s = lock.tryOptimisticRead()) != 0L);
773		assertTrue((p = lock.tryConvertToReadLock(s)) != 0L);
774	+	assertTrue(lock.isReadLocked());
775	+	assertEquals(1, lock.getReadLockCount());
776		lock.unlockRead(p);
777	+
778		assertTrue((s = lock.writeLock()) != 0L);
779		assertTrue((p = lock.tryConvertToReadLock(s)) != 0L);
780		assertTrue(lock.validate(p));
781	+	assertTrue(lock.isReadLocked());
782	+	assertEquals(1, lock.getReadLockCount());
783		lock.unlockRead(p);
784	+
785		assertTrue((s = lock.readLock()) != 0L);
786		assertTrue(lock.validate(s));
787	<	assertTrue((p = lock.tryConvertToReadLock(s)) != 0L);
788	<	assertTrue(lock.validate(p));
789	<	lock.unlockRead(p);
787	>	assertEquals(s, lock.tryConvertToReadLock(s));
788	>	assertTrue(lock.validate(s));
789	>	assertTrue(lock.isReadLocked());
790	>	assertEquals(1, lock.getReadLockCount());
791	>	lock.unlockRead(s);
792	>
793		assertTrue((s = lock.tryWriteLock()) != 0L);
794		assertTrue(lock.validate(s));
795		assertTrue((p = lock.tryConvertToReadLock(s)) != 0L);
796		assertTrue(lock.validate(p));
797	+	assertEquals(1, lock.getReadLockCount());
798		lock.unlockRead(p);
799	+
800		assertTrue((s = lock.tryReadLock()) != 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(100L, MILLISECONDS)) != 0L);
809		assertTrue((p = lock.tryConvertToReadLock(s)) != 0L);
810		assertTrue(lock.validate(p));
811	+	assertTrue(lock.isReadLocked());
812	+	assertEquals(1, lock.getReadLockCount());
813		lock.unlockRead(p);
814	+
815		assertTrue((s = lock.tryReadLock(100L, MILLISECONDS)) != 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
824		/**
#	Line 802 | Line 828 | public class StampedLockTest extends JSR
828		public void testTryConvertToWriteLock() throws InterruptedException {
829		StampedLock lock = new StampedLock();
830		long s, p;
831	<	s = 0L;
832	<	assertFalse((p = lock.tryConvertToWriteLock(s)) != 0L);
831	>
832	>	assertFalse((p = lock.tryConvertToWriteLock(0L)) != 0L);
833	>
834		assertTrue((s = lock.tryOptimisticRead()) != 0L);
835		assertTrue((p = lock.tryConvertToWriteLock(s)) != 0L);
836		lock.unlockWrite(p);
837	+
838		assertTrue((s = lock.writeLock()) != 0L);
839	<	assertTrue((p = lock.tryConvertToWriteLock(s)) != 0L);
840	<	assertTrue(lock.validate(p));
841	<	lock.unlockWrite(p);
839	>	assertEquals(s, lock.tryConvertToWriteLock(s));
840	>	assertTrue(lock.validate(s));
841	>	lock.unlockWrite(s);
842	>
843		assertTrue((s = lock.readLock()) != 0L);
844		assertTrue(lock.validate(s));
845		assertTrue((p = lock.tryConvertToWriteLock(s)) != 0L);
846		assertTrue(lock.validate(p));
847		lock.unlockWrite(p);
848	+
849		assertTrue((s = lock.tryWriteLock()) != 0L);
850		assertTrue(lock.validate(s));
851	<	assertTrue((p = lock.tryConvertToWriteLock(s)) != 0L);
852	<	assertTrue(lock.validate(p));
853	<	lock.unlockWrite(p);
851	>	assertEquals(s, lock.tryConvertToWriteLock(s));
852	>	assertTrue(lock.validate(s));
853	>	lock.unlockWrite(s);
854	>
855		assertTrue((s = lock.tryReadLock()) != 0L);
856		assertTrue(lock.validate(s));
857		assertTrue((p = lock.tryConvertToWriteLock(s)) != 0L);
858		assertTrue(lock.validate(p));
859		lock.unlockWrite(p);
860	+
861		assertTrue((s = lock.tryWriteLock(100L, MILLISECONDS)) != 0L);
862		assertTrue((p = lock.tryConvertToWriteLock(s)) != 0L);
863		assertTrue(lock.validate(p));
864		lock.unlockWrite(p);
865	+
866		assertTrue((s = lock.tryReadLock(100L, MILLISECONDS)) != 0L);
867		assertTrue(lock.validate(s));
868		assertTrue((p = lock.tryConvertToWriteLock(s)) != 0L);

Diff Legend

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