ViewVC Help
View File | Revision Log | Show Annotations | Download File | Root Listing
root/jsr166/jsr166/src/test/tck/StampedLockTest.java
(Generate patch)

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.24 by jsr166, Tue Jun 7 23:28:30 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.tryOptimisticRead()) != 0L);
779 +        lock.readLock();
780          assertTrue((p = lock.tryConvertToReadLock(s)) != 0L);
781 +        assertTrue(lock.isReadLocked());
782 +        assertEquals(2, lock.getReadLockCount());
783 +        lock.unlockRead(p);
784          lock.unlockRead(p);
785 +
786          assertTrue((s = lock.writeLock()) != 0L);
787          assertTrue((p = lock.tryConvertToReadLock(s)) != 0L);
788          assertTrue(lock.validate(p));
789 +        assertTrue(lock.isReadLocked());
790 +        assertEquals(1, lock.getReadLockCount());
791          lock.unlockRead(p);
792 +
793          assertTrue((s = lock.readLock()) != 0L);
794          assertTrue(lock.validate(s));
795 <        assertTrue((p = lock.tryConvertToReadLock(s)) != 0L);
796 <        assertTrue(lock.validate(p));
797 <        lock.unlockRead(p);
795 >        assertEquals(s, lock.tryConvertToReadLock(s));
796 >        assertTrue(lock.validate(s));
797 >        assertTrue(lock.isReadLocked());
798 >        assertEquals(1, lock.getReadLockCount());
799 >        lock.unlockRead(s);
800 >
801          assertTrue((s = lock.tryWriteLock()) != 0L);
802          assertTrue(lock.validate(s));
803          assertTrue((p = lock.tryConvertToReadLock(s)) != 0L);
804          assertTrue(lock.validate(p));
805 +        assertEquals(1, lock.getReadLockCount());
806          lock.unlockRead(p);
807 +
808          assertTrue((s = lock.tryReadLock()) != 0L);
809          assertTrue(lock.validate(s));
810 <        assertTrue((p = lock.tryConvertToReadLock(s)) != 0L);
811 <        assertTrue(lock.validate(p));
812 <        lock.unlockRead(p);
810 >        assertEquals(s, lock.tryConvertToReadLock(s));
811 >        assertTrue(lock.validate(s));
812 >        assertTrue(lock.isReadLocked());
813 >        assertEquals(1, lock.getReadLockCount());
814 >        lock.unlockRead(s);
815 >
816          assertTrue((s = lock.tryWriteLock(100L, MILLISECONDS)) != 0L);
817          assertTrue((p = lock.tryConvertToReadLock(s)) != 0L);
818          assertTrue(lock.validate(p));
819 +        assertTrue(lock.isReadLocked());
820 +        assertEquals(1, lock.getReadLockCount());
821          lock.unlockRead(p);
822 +
823          assertTrue((s = lock.tryReadLock(100L, MILLISECONDS)) != 0L);
824          assertTrue(lock.validate(s));
825 <        assertTrue((p = lock.tryConvertToReadLock(s)) != 0L);
826 <        assertTrue(lock.validate(p));
827 <        lock.unlockRead(p);
825 >        assertEquals(s, lock.tryConvertToReadLock(s));
826 >        assertTrue(lock.validate(s));
827 >        assertTrue(lock.isReadLocked());
828 >        assertEquals(1, lock.getReadLockCount());
829 >        lock.unlockRead(s);
830      }
831  
832      /**
# Line 802 | Line 836 | public class StampedLockTest extends JSR
836      public void testTryConvertToWriteLock() throws InterruptedException {
837          StampedLock lock = new StampedLock();
838          long s, p;
839 <        s = 0L;
840 <        assertFalse((p = lock.tryConvertToWriteLock(s)) != 0L);
839 >
840 >        assertFalse((p = lock.tryConvertToWriteLock(0L)) != 0L);
841 >
842          assertTrue((s = lock.tryOptimisticRead()) != 0L);
843          assertTrue((p = lock.tryConvertToWriteLock(s)) != 0L);
844 +        assertTrue(lock.isWriteLocked());
845          lock.unlockWrite(p);
846 +
847          assertTrue((s = lock.writeLock()) != 0L);
848 <        assertTrue((p = lock.tryConvertToWriteLock(s)) != 0L);
849 <        assertTrue(lock.validate(p));
850 <        lock.unlockWrite(p);
848 >        assertEquals(s, lock.tryConvertToWriteLock(s));
849 >        assertTrue(lock.validate(s));
850 >        assertTrue(lock.isWriteLocked());
851 >        lock.unlockWrite(s);
852 >
853          assertTrue((s = lock.readLock()) != 0L);
854          assertTrue(lock.validate(s));
855          assertTrue((p = lock.tryConvertToWriteLock(s)) != 0L);
856          assertTrue(lock.validate(p));
857 +        assertTrue(lock.isWriteLocked());
858          lock.unlockWrite(p);
859 +
860          assertTrue((s = lock.tryWriteLock()) != 0L);
861          assertTrue(lock.validate(s));
862 <        assertTrue((p = lock.tryConvertToWriteLock(s)) != 0L);
863 <        assertTrue(lock.validate(p));
864 <        lock.unlockWrite(p);
862 >        assertEquals(s, lock.tryConvertToWriteLock(s));
863 >        assertTrue(lock.validate(s));
864 >        assertTrue(lock.isWriteLocked());
865 >        lock.unlockWrite(s);
866 >
867          assertTrue((s = lock.tryReadLock()) != 0L);
868          assertTrue(lock.validate(s));
869          assertTrue((p = lock.tryConvertToWriteLock(s)) != 0L);
870          assertTrue(lock.validate(p));
871 +        assertTrue(lock.isWriteLocked());
872          lock.unlockWrite(p);
873 +
874          assertTrue((s = lock.tryWriteLock(100L, MILLISECONDS)) != 0L);
875          assertTrue((p = lock.tryConvertToWriteLock(s)) != 0L);
876          assertTrue(lock.validate(p));
877 +        assertTrue(lock.isWriteLocked());
878          lock.unlockWrite(p);
879 +
880          assertTrue((s = lock.tryReadLock(100L, MILLISECONDS)) != 0L);
881          assertTrue(lock.validate(s));
882          assertTrue((p = lock.tryConvertToWriteLock(s)) != 0L);
883          assertTrue(lock.validate(p));
884 +        assertTrue(lock.isWriteLocked());
885          lock.unlockWrite(p);
886      }
887  

Diff Legend

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