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.12 by jsr166, Fri Feb 27 21:54:13 2015 UTC vs.
Revision 1.24 by jsr166, Tue Jun 7 23:28:30 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 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.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 795 | 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  
# Line 876 | Line 931 | public class StampedLockTest extends JSR
931          assertTrue(lock.tryLock());
932      }
933  
934 +    /**
935 +     * Lock.newCondition throws UnsupportedOperationException
936 +     */
937 +    public void testLockViewsDoNotSupportConditions() {
938 +        StampedLock sl = new StampedLock();
939 +        assertThrows(UnsupportedOperationException.class,
940 +                     () -> sl.asWriteLock().newCondition(),
941 +                     () -> sl.asReadLock().newCondition(),
942 +                     () -> sl.asReadWriteLock().writeLock().newCondition(),
943 +                     () -> sl.asReadWriteLock().readLock().newCondition());
944 +    }
945 +
946 +    /**
947 +     * Passing optimistic read stamps to unlock operations result in
948 +     * IllegalMonitorStateException
949 +     */
950 +    public void testCannotUnlockOptimisticReadStamps() {
951 +        Runnable[] actions = {
952 +            () -> {
953 +                StampedLock sl = new StampedLock();
954 +                long stamp = sl.tryOptimisticRead();
955 +                assertTrue(stamp != 0);
956 +                sl.unlockRead(stamp);
957 +            },
958 +            () -> {
959 +                StampedLock sl = new StampedLock();
960 +                long stamp = sl.tryOptimisticRead();
961 +                sl.unlock(stamp);
962 +            },
963 +
964 +            () -> {
965 +                StampedLock sl = new StampedLock();
966 +                long stamp = sl.tryOptimisticRead();
967 +                sl.writeLock();
968 +                sl.unlock(stamp);
969 +            },
970 +            () -> {
971 +                StampedLock sl = new StampedLock();
972 +                long stamp = sl.tryOptimisticRead();
973 +                sl.readLock();
974 +                sl.unlockRead(stamp);
975 +            },
976 +            () -> {
977 +                StampedLock sl = new StampedLock();
978 +                long stamp = sl.tryOptimisticRead();
979 +                sl.readLock();
980 +                sl.unlock(stamp);
981 +            },
982 +
983 +            () -> {
984 +                StampedLock sl = new StampedLock();
985 +                long stamp = sl.tryConvertToOptimisticRead(sl.writeLock());
986 +                assertTrue(stamp != 0);
987 +                sl.writeLock();
988 +                sl.unlockWrite(stamp);
989 +            },
990 +            () -> {
991 +                StampedLock sl = new StampedLock();
992 +                long stamp = sl.tryConvertToOptimisticRead(sl.writeLock());
993 +                sl.writeLock();
994 +                sl.unlock(stamp);
995 +            },
996 +            () -> {
997 +                StampedLock sl = new StampedLock();
998 +                long stamp = sl.tryConvertToOptimisticRead(sl.writeLock());
999 +                sl.readLock();
1000 +                sl.unlockRead(stamp);
1001 +            },
1002 +            () -> {
1003 +                StampedLock sl = new StampedLock();
1004 +                long stamp = sl.tryConvertToOptimisticRead(sl.writeLock());
1005 +                sl.readLock();
1006 +                sl.unlock(stamp);
1007 +            },
1008 +
1009 +            () -> {
1010 +                StampedLock sl = new StampedLock();
1011 +                long stamp = sl.tryConvertToOptimisticRead(sl.readLock());
1012 +                assertTrue(stamp != 0);
1013 +                sl.writeLock();
1014 +                sl.unlockWrite(stamp);
1015 +            },
1016 +            () -> {
1017 +                StampedLock sl = new StampedLock();
1018 +                long stamp = sl.tryConvertToOptimisticRead(sl.readLock());
1019 +                sl.writeLock();
1020 +                sl.unlock(stamp);
1021 +            },
1022 +            () -> {
1023 +                StampedLock sl = new StampedLock();
1024 +                long stamp = sl.tryConvertToOptimisticRead(sl.readLock());
1025 +                sl.readLock();
1026 +                sl.unlockRead(stamp);
1027 +            },
1028 +            () -> {
1029 +                StampedLock sl = new StampedLock();
1030 +                sl.readLock();
1031 +                long stamp = sl.tryConvertToOptimisticRead(sl.readLock());
1032 +                assertTrue(stamp != 0);
1033 +                sl.readLock();
1034 +                sl.unlockRead(stamp);
1035 +            },
1036 +            () -> {
1037 +                StampedLock sl = new StampedLock();
1038 +                long stamp = sl.tryConvertToOptimisticRead(sl.readLock());
1039 +                sl.readLock();
1040 +                sl.unlock(stamp);
1041 +            },
1042 +            () -> {
1043 +                StampedLock sl = new StampedLock();
1044 +                sl.readLock();
1045 +                long stamp = sl.tryConvertToOptimisticRead(sl.readLock());
1046 +                sl.readLock();
1047 +                sl.unlock(stamp);
1048 +            },
1049 +        };
1050 +
1051 +        assertThrows(IllegalMonitorStateException.class, actions);
1052 +    }
1053 +
1054   }

Diff Legend

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