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.17 by jsr166, Tue Jun 7 02:04:47 2016 UTC vs.
Revision 1.23 by jsr166, Tue Jun 7 22:21:05 2016 UTC

# 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 753 | 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 795 | 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 +        assertTrue(lock.isWriteLocked());
837          lock.unlockWrite(p);
838 +
839          assertTrue((s = lock.writeLock()) != 0L);
840 <        assertTrue((p = lock.tryConvertToWriteLock(s)) != 0L);
841 <        assertTrue(lock.validate(p));
842 <        lock.unlockWrite(p);
840 >        assertEquals(s, lock.tryConvertToWriteLock(s));
841 >        assertTrue(lock.validate(s));
842 >        assertTrue(lock.isWriteLocked());
843 >        lock.unlockWrite(s);
844 >
845          assertTrue((s = lock.readLock()) != 0L);
846          assertTrue(lock.validate(s));
847          assertTrue((p = lock.tryConvertToWriteLock(s)) != 0L);
848          assertTrue(lock.validate(p));
849 +        assertTrue(lock.isWriteLocked());
850          lock.unlockWrite(p);
851 +
852          assertTrue((s = lock.tryWriteLock()) != 0L);
853          assertTrue(lock.validate(s));
854 <        assertTrue((p = lock.tryConvertToWriteLock(s)) != 0L);
855 <        assertTrue(lock.validate(p));
856 <        lock.unlockWrite(p);
854 >        assertEquals(s, lock.tryConvertToWriteLock(s));
855 >        assertTrue(lock.validate(s));
856 >        assertTrue(lock.isWriteLocked());
857 >        lock.unlockWrite(s);
858 >
859          assertTrue((s = lock.tryReadLock()) != 0L);
860          assertTrue(lock.validate(s));
861          assertTrue((p = lock.tryConvertToWriteLock(s)) != 0L);
862          assertTrue(lock.validate(p));
863 +        assertTrue(lock.isWriteLocked());
864          lock.unlockWrite(p);
865 +
866          assertTrue((s = lock.tryWriteLock(100L, MILLISECONDS)) != 0L);
867          assertTrue((p = lock.tryConvertToWriteLock(s)) != 0L);
868          assertTrue(lock.validate(p));
869 +        assertTrue(lock.isWriteLocked());
870          lock.unlockWrite(p);
871 +
872          assertTrue((s = lock.tryReadLock(100L, MILLISECONDS)) != 0L);
873          assertTrue(lock.validate(s));
874          assertTrue((p = lock.tryConvertToWriteLock(s)) != 0L);
875          assertTrue(lock.validate(p));
876 +        assertTrue(lock.isWriteLocked());
877          lock.unlockWrite(p);
878      }
879  
# Line 972 | Line 1019 | public class StampedLockTest extends JSR
1019              },
1020              () -> {
1021                  StampedLock sl = new StampedLock();
1022 +                sl.readLock();
1023 +                long stamp = sl.tryConvertToOptimisticRead(sl.readLock());
1024 +                assertTrue(stamp != 0);
1025 +                sl.readLock();
1026 +                sl.unlockRead(stamp);
1027 +            },
1028 +            () -> {
1029 +                StampedLock sl = new StampedLock();
1030 +                long stamp = sl.tryConvertToOptimisticRead(sl.readLock());
1031 +                sl.readLock();
1032 +                sl.unlock(stamp);
1033 +            },
1034 +            () -> {
1035 +                StampedLock sl = new StampedLock();
1036 +                sl.readLock();
1037                  long stamp = sl.tryConvertToOptimisticRead(sl.readLock());
1038                  sl.readLock();
1039                  sl.unlock(stamp);

Diff Legend

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