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.18 by jsr166, Tue Jun 7 02:12:18 2016 UTC vs.
Revision 1.26 by jsr166, Sun Jul 17 03:06:50 2016 UTC

# Line 5 | Line 5
5   * http://creativecommons.org/publicdomain/zero/1.0/
6   */
7  
8 + import static java.util.concurrent.TimeUnit.DAYS;
9   import static java.util.concurrent.TimeUnit.MILLISECONDS;
10  
11 + import java.util.ArrayList;
12 + import java.util.List;
13   import java.util.concurrent.CountDownLatch;
14 + import java.util.concurrent.TimeUnit;
15   import java.util.concurrent.locks.Lock;
16   import java.util.concurrent.locks.StampedLock;
17 + import java.util.function.BiConsumer;
18 + import java.util.function.Consumer;
19 + import java.util.function.Function;
20  
21   import junit.framework.Test;
22   import junit.framework.TestSuite;
# Line 718 | Line 725 | public class StampedLockTest extends JSR
725      public void testTryConvertToOptimisticRead() throws InterruptedException {
726          StampedLock lock = new StampedLock();
727          long s, p;
728 <        s = 0L;
729 <        assertFalse((p = lock.tryConvertToOptimisticRead(s)) != 0L);
728 >        assertEquals(0L, lock.tryConvertToOptimisticRead(0L));
729 >
730          assertTrue((s = lock.tryOptimisticRead()) != 0L);
731 <        assertTrue((p = lock.tryConvertToOptimisticRead(s)) != 0L);
731 >        assertEquals(s, lock.tryConvertToOptimisticRead(s));
732 >        assertTrue(lock.validate(s));
733 >
734 >        assertTrue((p = lock.readLock()) != 0L);
735 >        assertTrue((s = lock.tryOptimisticRead()) != 0L);
736 >        assertEquals(s, lock.tryConvertToOptimisticRead(s));
737 >        assertTrue(lock.validate(s));
738 >        lock.unlockRead(p);
739 >
740          assertTrue((s = lock.writeLock()) != 0L);
741          assertTrue((p = lock.tryConvertToOptimisticRead(s)) != 0L);
742          assertTrue(lock.validate(p));
743 +
744          assertTrue((s = lock.readLock()) != 0L);
745          assertTrue(lock.validate(s));
746          assertTrue((p = lock.tryConvertToOptimisticRead(s)) != 0L);
747          assertTrue(lock.validate(p));
748 +
749          assertTrue((s = lock.tryWriteLock()) != 0L);
750          assertTrue(lock.validate(s));
751          assertTrue((p = lock.tryConvertToOptimisticRead(s)) != 0L);
752          assertTrue(lock.validate(p));
753 +
754          assertTrue((s = lock.tryReadLock()) != 0L);
755          assertTrue(lock.validate(s));
756          assertTrue((p = lock.tryConvertToOptimisticRead(s)) != 0L);
757          assertTrue(lock.validate(p));
758 +
759          assertTrue((s = lock.tryWriteLock(100L, MILLISECONDS)) != 0L);
760          assertTrue((p = lock.tryConvertToOptimisticRead(s)) != 0L);
761          assertTrue(lock.validate(p));
762 +
763          assertTrue((s = lock.tryReadLock(100L, MILLISECONDS)) != 0L);
764          assertTrue(lock.validate(s));
765          assertTrue((p = lock.tryConvertToOptimisticRead(s)) != 0L);
# Line 753 | Line 773 | public class StampedLockTest extends JSR
773      public void testTryConvertToReadLock() throws InterruptedException {
774          StampedLock lock = new StampedLock();
775          long s, p;
776 <        s = 0L;
777 <        assertFalse((p = lock.tryConvertToReadLock(s)) != 0L);
776 >
777 >        assertFalse((p = lock.tryConvertToReadLock(0L)) != 0L);
778 >
779 >        assertTrue((s = lock.tryOptimisticRead()) != 0L);
780 >        assertTrue((p = lock.tryConvertToReadLock(s)) != 0L);
781 >        assertTrue(lock.isReadLocked());
782 >        assertEquals(1, lock.getReadLockCount());
783 >        lock.unlockRead(p);
784 >
785          assertTrue((s = lock.tryOptimisticRead()) != 0L);
786 +        lock.readLock();
787          assertTrue((p = lock.tryConvertToReadLock(s)) != 0L);
788 +        assertTrue(lock.isReadLocked());
789 +        assertEquals(2, lock.getReadLockCount());
790          lock.unlockRead(p);
791 +        lock.unlockRead(p);
792 +
793          assertTrue((s = lock.writeLock()) != 0L);
794          assertTrue((p = lock.tryConvertToReadLock(s)) != 0L);
795          assertTrue(lock.validate(p));
796 +        assertTrue(lock.isReadLocked());
797 +        assertEquals(1, lock.getReadLockCount());
798          lock.unlockRead(p);
799 +
800          assertTrue((s = lock.readLock()) != 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()) != 0L);
809          assertTrue(lock.validate(s));
810          assertTrue((p = lock.tryConvertToReadLock(s)) != 0L);
811          assertTrue(lock.validate(p));
812 +        assertEquals(1, lock.getReadLockCount());
813          lock.unlockRead(p);
814 +
815          assertTrue((s = lock.tryReadLock()) != 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          assertTrue((s = lock.tryWriteLock(100L, MILLISECONDS)) != 0L);
824          assertTrue((p = lock.tryConvertToReadLock(s)) != 0L);
825          assertTrue(lock.validate(p));
826 +        assertTrue(lock.isReadLocked());
827 +        assertEquals(1, lock.getReadLockCount());
828          lock.unlockRead(p);
829 +
830          assertTrue((s = lock.tryReadLock(100L, MILLISECONDS)) != 0L);
831          assertTrue(lock.validate(s));
832 <        assertTrue((p = lock.tryConvertToReadLock(s)) != 0L);
833 <        assertTrue(lock.validate(p));
834 <        lock.unlockRead(p);
832 >        assertEquals(s, lock.tryConvertToReadLock(s));
833 >        assertTrue(lock.validate(s));
834 >        assertTrue(lock.isReadLocked());
835 >        assertEquals(1, lock.getReadLockCount());
836 >        lock.unlockRead(s);
837      }
838  
839      /**
# Line 795 | Line 843 | public class StampedLockTest extends JSR
843      public void testTryConvertToWriteLock() throws InterruptedException {
844          StampedLock lock = new StampedLock();
845          long s, p;
846 <        s = 0L;
847 <        assertFalse((p = lock.tryConvertToWriteLock(s)) != 0L);
846 >
847 >        assertFalse((p = lock.tryConvertToWriteLock(0L)) != 0L);
848 >
849          assertTrue((s = lock.tryOptimisticRead()) != 0L);
850          assertTrue((p = lock.tryConvertToWriteLock(s)) != 0L);
851 +        assertTrue(lock.isWriteLocked());
852          lock.unlockWrite(p);
853 +
854          assertTrue((s = lock.writeLock()) != 0L);
855 <        assertTrue((p = lock.tryConvertToWriteLock(s)) != 0L);
856 <        assertTrue(lock.validate(p));
857 <        lock.unlockWrite(p);
855 >        assertEquals(s, lock.tryConvertToWriteLock(s));
856 >        assertTrue(lock.validate(s));
857 >        assertTrue(lock.isWriteLocked());
858 >        lock.unlockWrite(s);
859 >
860          assertTrue((s = lock.readLock()) != 0L);
861          assertTrue(lock.validate(s));
862          assertTrue((p = lock.tryConvertToWriteLock(s)) != 0L);
863          assertTrue(lock.validate(p));
864 +        assertTrue(lock.isWriteLocked());
865          lock.unlockWrite(p);
866 +
867          assertTrue((s = lock.tryWriteLock()) != 0L);
868          assertTrue(lock.validate(s));
869 <        assertTrue((p = lock.tryConvertToWriteLock(s)) != 0L);
870 <        assertTrue(lock.validate(p));
871 <        lock.unlockWrite(p);
869 >        assertEquals(s, lock.tryConvertToWriteLock(s));
870 >        assertTrue(lock.validate(s));
871 >        assertTrue(lock.isWriteLocked());
872 >        lock.unlockWrite(s);
873 >
874          assertTrue((s = lock.tryReadLock()) != 0L);
875          assertTrue(lock.validate(s));
876          assertTrue((p = lock.tryConvertToWriteLock(s)) != 0L);
877          assertTrue(lock.validate(p));
878 +        assertTrue(lock.isWriteLocked());
879          lock.unlockWrite(p);
880 +
881          assertTrue((s = lock.tryWriteLock(100L, MILLISECONDS)) != 0L);
882          assertTrue((p = lock.tryConvertToWriteLock(s)) != 0L);
883          assertTrue(lock.validate(p));
884 +        assertTrue(lock.isWriteLocked());
885          lock.unlockWrite(p);
886 +
887          assertTrue((s = lock.tryReadLock(100L, MILLISECONDS)) != 0L);
888          assertTrue(lock.validate(s));
889          assertTrue((p = lock.tryConvertToWriteLock(s)) != 0L);
890          assertTrue(lock.validate(p));
891 +        assertTrue(lock.isWriteLocked());
892          lock.unlockWrite(p);
893      }
894  
# Line 996 | Line 1058 | public class StampedLockTest extends JSR
1058          assertThrows(IllegalMonitorStateException.class, actions);
1059      }
1060  
1061 +    static long writeLockInterruptiblyUninterrupted(StampedLock sl) {
1062 +        try { return sl.writeLockInterruptibly(); }
1063 +        catch (InterruptedException ex) { throw new AssertionError(ex); }
1064 +    }
1065 +
1066 +    static long tryWriteLockUninterrupted(StampedLock sl, long time, TimeUnit unit) {
1067 +        try { return sl.tryWriteLock(time, unit); }
1068 +        catch (InterruptedException ex) { throw new AssertionError(ex); }
1069 +    }
1070 +
1071 +    static long readLockInterruptiblyUninterrupted(StampedLock sl) {
1072 +        try { return sl.readLockInterruptibly(); }
1073 +        catch (InterruptedException ex) { throw new AssertionError(ex); }
1074 +    }
1075 +
1076 +    static long tryReadLockUninterrupted(StampedLock sl, long time, TimeUnit unit) {
1077 +        try { return sl.tryReadLock(time, unit); }
1078 +        catch (InterruptedException ex) { throw new AssertionError(ex); }
1079 +    }
1080 +
1081 +    /**
1082 +     * Invalid write stamps result in IllegalMonitorStateException
1083 +     */
1084 +    public void testInvalidWriteStampsThrowIllegalMonitorStateException() {
1085 +        List<Function<StampedLock, Long>> writeLockers = new ArrayList<>();
1086 +        writeLockers.add((sl) -> sl.writeLock());
1087 +        writeLockers.add((sl) -> writeLockInterruptiblyUninterrupted(sl));
1088 +        writeLockers.add((sl) -> tryWriteLockUninterrupted(sl, Long.MIN_VALUE, DAYS));
1089 +        writeLockers.add((sl) -> tryWriteLockUninterrupted(sl, 0, DAYS));
1090 +
1091 +        List<BiConsumer<StampedLock, Long>> writeUnlockers = new ArrayList<>();
1092 +        writeUnlockers.add((sl, stamp) -> sl.unlockWrite(stamp));
1093 +        writeUnlockers.add((sl, stamp) -> assertTrue(sl.tryUnlockWrite()));
1094 +        writeUnlockers.add((sl, stamp) -> sl.asWriteLock().unlock());
1095 +        writeUnlockers.add((sl, stamp) -> sl.unlock(stamp));
1096 +
1097 +        List<Consumer<StampedLock>> mutaters = new ArrayList<>();
1098 +        mutaters.add((sl) -> {});
1099 +        mutaters.add((sl) -> sl.readLock());
1100 +        for (Function<StampedLock, Long> writeLocker : writeLockers)
1101 +            mutaters.add((sl) -> writeLocker.apply(sl));
1102 +
1103 +        for (Function<StampedLock, Long> writeLocker : writeLockers)
1104 +        for (BiConsumer<StampedLock, Long> writeUnlocker : writeUnlockers)
1105 +        for (Consumer<StampedLock> mutater : mutaters) {
1106 +            final StampedLock sl = new StampedLock();
1107 +            final long stamp = writeLocker.apply(sl);
1108 +            assertTrue(stamp != 0L);
1109 +            assertThrows(IllegalMonitorStateException.class,
1110 +                         () -> sl.unlockRead(stamp));
1111 +            writeUnlocker.accept(sl, stamp);
1112 +            mutater.accept(sl);
1113 +            assertThrows(IllegalMonitorStateException.class,
1114 +                         () -> sl.unlock(stamp),
1115 +                         () -> sl.unlockRead(stamp),
1116 +                         () -> sl.unlockWrite(stamp));
1117 +        }
1118 +    }
1119 +
1120 +    /**
1121 +     * Invalid read stamps result in IllegalMonitorStateException
1122 +     */
1123 +    public void testInvalidReadStampsThrowIllegalMonitorStateException() {
1124 +        List<Function<StampedLock, Long>> readLockers = new ArrayList<>();
1125 +        readLockers.add((sl) -> sl.readLock());
1126 +        readLockers.add((sl) -> readLockInterruptiblyUninterrupted(sl));
1127 +        readLockers.add((sl) -> tryReadLockUninterrupted(sl, Long.MIN_VALUE, DAYS));
1128 +        readLockers.add((sl) -> tryReadLockUninterrupted(sl, 0, DAYS));
1129 +
1130 +        List<BiConsumer<StampedLock, Long>> readUnlockers = new ArrayList<>();
1131 +        readUnlockers.add((sl, stamp) -> sl.unlockRead(stamp));
1132 +        readUnlockers.add((sl, stamp) -> assertTrue(sl.tryUnlockRead()));
1133 +        readUnlockers.add((sl, stamp) -> sl.asReadLock().unlock());
1134 +        readUnlockers.add((sl, stamp) -> sl.unlock(stamp));
1135 +
1136 +        List<Function<StampedLock, Long>> writeLockers = new ArrayList<>();
1137 +        writeLockers.add((sl) -> sl.writeLock());
1138 +        writeLockers.add((sl) -> writeLockInterruptiblyUninterrupted(sl));
1139 +        writeLockers.add((sl) -> tryWriteLockUninterrupted(sl, Long.MIN_VALUE, DAYS));
1140 +        writeLockers.add((sl) -> tryWriteLockUninterrupted(sl, 0, DAYS));
1141 +
1142 +        List<BiConsumer<StampedLock, Long>> writeUnlockers = new ArrayList<>();
1143 +        writeUnlockers.add((sl, stamp) -> sl.unlockWrite(stamp));
1144 +        writeUnlockers.add((sl, stamp) -> assertTrue(sl.tryUnlockWrite()));
1145 +        writeUnlockers.add((sl, stamp) -> sl.asWriteLock().unlock());
1146 +        writeUnlockers.add((sl, stamp) -> sl.unlock(stamp));
1147 +
1148 +
1149 +        for (Function<StampedLock, Long> readLocker : readLockers)
1150 +        for (BiConsumer<StampedLock, Long> readUnlocker : readUnlockers)
1151 +        for (Function<StampedLock, Long> writeLocker : writeLockers)
1152 +        for (BiConsumer<StampedLock, Long> writeUnlocker : writeUnlockers) {
1153 +            final StampedLock sl = new StampedLock();
1154 +            final long stamp = readLocker.apply(sl);
1155 +            assertTrue(stamp != 0L);
1156 +            assertThrows(IllegalMonitorStateException.class,
1157 +                         () -> sl.unlockWrite(stamp));
1158 +            readUnlocker.accept(sl, stamp);
1159 +            assertThrows(IllegalMonitorStateException.class,
1160 +                         () -> sl.unlock(stamp),
1161 +                         () -> sl.unlockRead(stamp),
1162 +                         () -> sl.unlockWrite(stamp));
1163 +            final long writeStamp = writeLocker.apply(sl);
1164 +            assertTrue(writeStamp != 0L);
1165 +            assertTrue(writeStamp != stamp);
1166 +            assertThrows(IllegalMonitorStateException.class,
1167 +                         () -> sl.unlock(stamp),
1168 +                         () -> sl.unlockRead(stamp),
1169 +                         () -> sl.unlockWrite(stamp));
1170 +            writeUnlocker.accept(sl, writeStamp);
1171 +            assertThrows(IllegalMonitorStateException.class,
1172 +                         () -> sl.unlock(stamp),
1173 +                         () -> sl.unlockRead(stamp),
1174 +                         () -> sl.unlockWrite(stamp));
1175 +        }
1176 +    }
1177 +
1178   }

Diff Legend

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