/*

 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

 *

 * This code is free software; you can redistribute it and/or modify it

 * under the terms of the GNU General Public License version 2 only, as

 * published by the Free Software Foundation.

 *

 * This code is distributed in the hope that it will be useful, but WITHOUT

 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

 * version 2 for more details (a copy is included in the LICENSE file that

 * accompanied this code).

 *

 * You should have received a copy of the GNU General Public License version

 * 2 along with this work; if not, write to the Free Software Foundation,

 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

 *

 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

 * or visit www.oracle.com if you need additional information or have any

 * questions.

 */

/*

 * This file is available under and governed by the GNU General Public

 * License version 2 only, as published by the Free Software Foundation.

 * However, the following notice accompanied the original version of this

 * file:

 *

 * Written by Doug Lea and Martin Buchholz

 * with assistance from members of JCP JSR-166 Expert Group and

 * released to the public domain, as explained at

 * http://creativecommons.org/publicdomain/zero/1.0/

 */

import static java.util.concurrent.TimeUnit.DAYS;

import static java.util.concurrent.TimeUnit.MILLISECONDS;

import static java.util.concurrent.locks.StampedLock.isLockStamp;

import static java.util.concurrent.locks.StampedLock.isOptimisticReadStamp;

import static java.util.concurrent.locks.StampedLock.isReadLockStamp;

import static java.util.concurrent.locks.StampedLock.isWriteLockStamp;

import java.util.ArrayList;

import java.util.List;

import java.util.concurrent.CountDownLatch;

import java.util.concurrent.Future;

import java.util.concurrent.TimeUnit;

import java.util.concurrent.locks.Lock;

import java.util.concurrent.locks.StampedLock;

import java.util.function.BiConsumer;

import java.util.function.Function;

import junit.framework.Test;

import junit.framework.TestSuite;

public class StampedLockTest extends JSR166TestCase {

    public static void main(String[] args) {

        main(suite(), args);

    }

    public static Test suite() {

        return new TestSuite(StampedLockTest.class);

    }

    /**

     * Releases write lock, checking isWriteLocked before and after

     */

    void releaseWriteLock(StampedLock lock, long stamp) {

        assertTrue(lock.isWriteLocked());

        assertValid(lock, stamp);

        lock.unlockWrite(stamp);

        assertFalse(lock.isWriteLocked());

        assertFalse(lock.validate(stamp));

    }

    /**

     * Releases read lock, checking isReadLocked before and after

     */

    void releaseReadLock(StampedLock lock, long stamp) {

        assertTrue(lock.isReadLocked());

        assertValid(lock, stamp);

        lock.unlockRead(stamp);

        assertFalse(lock.isReadLocked());

        assertTrue(lock.validate(stamp));

    }

    long assertNonZero(long v) {

        assertTrue(v != 0L);

        return v;

    }

    long assertValid(StampedLock lock, long stamp) {

        assertTrue(stamp != 0L);

        assertTrue(lock.validate(stamp));

        return stamp;

    }

    void assertUnlocked(StampedLock lock) {

        assertFalse(lock.isReadLocked());

        assertFalse(lock.isWriteLocked());

        assertEquals(0, lock.getReadLockCount());

        assertValid(lock, lock.tryOptimisticRead());

    }

    List<Action> lockLockers(Lock lock) {

        List<Action> lockers = new ArrayList<>();

        lockers.add(() -> lock.lock());

        lockers.add(() -> lock.lockInterruptibly());

        lockers.add(() -> lock.tryLock());

        lockers.add(() -> lock.tryLock(Long.MIN_VALUE, DAYS));

        lockers.add(() -> lock.tryLock(0L, DAYS));

        lockers.add(() -> lock.tryLock(Long.MAX_VALUE, DAYS));

        return lockers;

    }

    List<Function<StampedLock, Long>> readLockers() {

        List<Function<StampedLock, Long>> readLockers = new ArrayList<>();

        readLockers.add(sl -> sl.readLock());

        readLockers.add(sl -> sl.tryReadLock());

        readLockers.add(sl -> readLockInterruptiblyUninterrupted(sl));

        readLockers.add(sl -> tryReadLockUninterrupted(sl, Long.MIN_VALUE, DAYS));

        readLockers.add(sl -> tryReadLockUninterrupted(sl, 0L, DAYS));

        readLockers.add(sl -> sl.tryConvertToReadLock(sl.tryOptimisticRead()));

        return readLockers;

    }

    List<BiConsumer<StampedLock, Long>> readUnlockers() {

        List<BiConsumer<StampedLock, Long>> readUnlockers = new ArrayList<>();

        readUnlockers.add((sl, stamp) -> sl.unlockRead(stamp));

        readUnlockers.add((sl, stamp) -> assertTrue(sl.tryUnlockRead()));

        readUnlockers.add((sl, stamp) -> sl.asReadLock().unlock());

        readUnlockers.add((sl, stamp) -> sl.unlock(stamp));

        readUnlockers.add((sl, stamp) -> assertValid(sl, sl.tryConvertToOptimisticRead(stamp)));

        return readUnlockers;

    }

    List<Function<StampedLock, Long>> writeLockers() {

        List<Function<StampedLock, Long>> writeLockers = new ArrayList<>();

        writeLockers.add(sl -> sl.writeLock());

        writeLockers.add(sl -> sl.tryWriteLock());

        writeLockers.add(sl -> writeLockInterruptiblyUninterrupted(sl));

        writeLockers.add(sl -> tryWriteLockUninterrupted(sl, Long.MIN_VALUE, DAYS));

        writeLockers.add(sl -> tryWriteLockUninterrupted(sl, 0L, DAYS));

        writeLockers.add(sl -> sl.tryConvertToWriteLock(sl.tryOptimisticRead()));

        return writeLockers;

    }

    List<BiConsumer<StampedLock, Long>> writeUnlockers() {

        List<BiConsumer<StampedLock, Long>> writeUnlockers = new ArrayList<>();

        writeUnlockers.add((sl, stamp) -> sl.unlockWrite(stamp));

        writeUnlockers.add((sl, stamp) -> assertTrue(sl.tryUnlockWrite()));

        writeUnlockers.add((sl, stamp) -> sl.asWriteLock().unlock());

        writeUnlockers.add((sl, stamp) -> sl.unlock(stamp));

        writeUnlockers.add((sl, stamp) -> assertValid(sl, sl.tryConvertToOptimisticRead(stamp)));

        return writeUnlockers;

    }

    /**

     * Constructed StampedLock is in unlocked state

     */

    public void testConstructor() {

        assertUnlocked(new StampedLock());

    }

    /**

     * write-locking, then unlocking, an unlocked lock succeed

     */

    public void testWriteLock_lockUnlock() {

        StampedLock lock = new StampedLock();

        for (Function<StampedLock, Long> writeLocker : writeLockers())

        for (BiConsumer<StampedLock, Long> writeUnlocker : writeUnlockers()) {

            assertFalse(lock.isWriteLocked());

            assertFalse(lock.isReadLocked());

            assertEquals(0, lock.getReadLockCount());

            long s = writeLocker.apply(lock);

            assertValid(lock, s);

            assertTrue(lock.isWriteLocked());

            assertFalse(lock.isReadLocked());

            assertEquals(0, lock.getReadLockCount());

            writeUnlocker.accept(lock, s);

            assertUnlocked(lock);

        }

    }

    /**

     * read-locking, then unlocking, an unlocked lock succeed

     */

    public void testReadLock_lockUnlock() {

        StampedLock lock = new StampedLock();

        for (Function<StampedLock, Long> readLocker : readLockers())

        for (BiConsumer<StampedLock, Long> readUnlocker : readUnlockers()) {

            long s = 42;

            for (int i = 0; i < 2; i++) {

                s = assertValid(lock, readLocker.apply(lock));

                assertFalse(lock.isWriteLocked());

                assertTrue(lock.isReadLocked());

                assertEquals(i + 1, lock.getReadLockCount());

            }

            for (int i = 0; i < 2; i++) {

                assertFalse(lock.isWriteLocked());

                assertTrue(lock.isReadLocked());

                assertEquals(2 - i, lock.getReadLockCount());

                readUnlocker.accept(lock, s);

            }

            assertUnlocked(lock);

        }

    }

    /**

     * tryUnlockWrite fails if not write locked

     */

    public void testTryUnlockWrite_failure() {

        StampedLock lock = new StampedLock();

        assertFalse(lock.tryUnlockWrite());

        for (Function<StampedLock, Long> readLocker : readLockers())

        for (BiConsumer<StampedLock, Long> readUnlocker : readUnlockers()) {

            long s = assertValid(lock, readLocker.apply(lock));

            assertFalse(lock.tryUnlockWrite());

            assertTrue(lock.isReadLocked());

            readUnlocker.accept(lock, s);

            assertUnlocked(lock);

        }

    }

    /**

     * tryUnlockRead fails if not read locked

     */

    public void testTryUnlockRead_failure() {

        StampedLock lock = new StampedLock();

        assertFalse(lock.tryUnlockRead());

        for (Function<StampedLock, Long> writeLocker : writeLockers())

        for (BiConsumer<StampedLock, Long> writeUnlocker : writeUnlockers()) {

            long s = writeLocker.apply(lock);

            assertFalse(lock.tryUnlockRead());

            assertTrue(lock.isWriteLocked());

            writeUnlocker.accept(lock, s);

            assertUnlocked(lock);

        }

    }

    /**

     * validate(0L) fails

     */

    public void testValidate0() {

        StampedLock lock = new StampedLock();

        assertFalse(lock.validate(0L));

    }

    /**

     * A stamp obtained from a successful lock operation validates while the lock is held

     */

    public void testValidate() throws InterruptedException {

        StampedLock lock = new StampedLock();

        for (Function<StampedLock, Long> readLocker : readLockers())

        for (BiConsumer<StampedLock, Long> readUnlocker : readUnlockers()) {

            long s = assertNonZero(readLocker.apply(lock));

            assertTrue(lock.validate(s));

            readUnlocker.accept(lock, s);

        }

        for (Function<StampedLock, Long> writeLocker : writeLockers())

        for (BiConsumer<StampedLock, Long> writeUnlocker : writeUnlockers()) {

            long s = assertNonZero(writeLocker.apply(lock));

            assertTrue(lock.validate(s));

            writeUnlocker.accept(lock, s);

        }

    }

    /**

     * A stamp obtained from an unsuccessful lock operation does not validate

     */

    public void testValidate2() throws InterruptedException {

        StampedLock lock = new StampedLock();

        long s = assertNonZero(lock.writeLock());

        assertTrue(lock.validate(s));

        assertFalse(lock.validate(lock.tryWriteLock()));

        assertFalse(lock.validate(lock.tryWriteLock(randomExpiredTimeout(),

                                                    randomTimeUnit())));

        assertFalse(lock.validate(lock.tryReadLock()));

        assertFalse(lock.validate(lock.tryWriteLock(randomExpiredTimeout(),

                                                    randomTimeUnit())));

        assertFalse(lock.validate(lock.tryOptimisticRead()));

        lock.unlockWrite(s);

    }

    void assertThrowInterruptedExceptionWhenPreInterrupted(Action[] actions) {

        for (Action action : actions) {

            Thread.currentThread().interrupt();

            try {

                action.run();

                shouldThrow();

            }

            catch (InterruptedException success) {}

            catch (Throwable fail) { threadUnexpectedException(fail); }

            assertFalse(Thread.interrupted());

        }

    }

    /**

     * interruptible operations throw InterruptedException when pre-interrupted

     */

    public void testInterruptibleOperationsThrowInterruptedExceptionWhenPreInterrupted() {

        final StampedLock lock = new StampedLock();

        Action[] interruptibleLockActions = {

            () -> lock.writeLockInterruptibly(),

            () -> lock.tryWriteLock(Long.MIN_VALUE, DAYS),

            () -> lock.tryWriteLock(Long.MAX_VALUE, DAYS),

            () -> lock.readLockInterruptibly(),

            () -> lock.tryReadLock(Long.MIN_VALUE, DAYS),

            () -> lock.tryReadLock(Long.MAX_VALUE, DAYS),

            () -> lock.asWriteLock().lockInterruptibly(),

            () -> lock.asWriteLock().tryLock(0L, DAYS),

            () -> lock.asWriteLock().tryLock(Long.MAX_VALUE, DAYS),

            () -> lock.asReadLock().lockInterruptibly(),

            () -> lock.asReadLock().tryLock(0L, DAYS),

            () -> lock.asReadLock().tryLock(Long.MAX_VALUE, DAYS),

        };

        shuffle(interruptibleLockActions);

        assertThrowInterruptedExceptionWhenPreInterrupted(interruptibleLockActions);

        {

            long s = lock.writeLock();

            assertThrowInterruptedExceptionWhenPreInterrupted(interruptibleLockActions);

            lock.unlockWrite(s);

        }

        {

            long s = lock.readLock();

            assertThrowInterruptedExceptionWhenPreInterrupted(interruptibleLockActions);

            lock.unlockRead(s);

        }

    }

    void assertThrowInterruptedExceptionWhenInterrupted(Action[] actions) {

        int n = actions.length;

        Future<?>[] futures = new Future<?>[n];

        CountDownLatch threadsStarted = new CountDownLatch(n);

        CountDownLatch done = new CountDownLatch(n);

        for (int i = 0; i < n; i++) {

            Action action = actions[i];

            futures[i] = cachedThreadPool.submit(new CheckedRunnable() {

                public void realRun() throws Throwable {

                    threadsStarted.countDown();

                    try {

                        action.run();

                        shouldThrow();

                    }

                    catch (InterruptedException success) {}

                    catch (Throwable fail) { threadUnexpectedException(fail); }

                    assertFalse(Thread.interrupted());

                    done.countDown();

                }});

        }

        await(threadsStarted);

        assertEquals(n, done.getCount());

        for (Future<?> future : futures) // Interrupt all the tasks

            future.cancel(true);

        await(done);

    }

    /**

     * interruptible operations throw InterruptedException when write locked and interrupted

     */

    public void testInterruptibleOperationsThrowInterruptedExceptionWriteLockedInterrupted() {

        final StampedLock lock = new StampedLock();

        long s = lock.writeLock();

        Action[] interruptibleLockBlockingActions = {

            () -> lock.writeLockInterruptibly(),

            () -> lock.tryWriteLock(Long.MAX_VALUE, DAYS),

            () -> lock.readLockInterruptibly(),

            () -> lock.tryReadLock(Long.MAX_VALUE, DAYS),

            () -> lock.asWriteLock().lockInterruptibly(),

            () -> lock.asWriteLock().tryLock(Long.MAX_VALUE, DAYS),

            () -> lock.asReadLock().lockInterruptibly(),

            () -> lock.asReadLock().tryLock(Long.MAX_VALUE, DAYS),

        };

        shuffle(interruptibleLockBlockingActions);

        assertThrowInterruptedExceptionWhenInterrupted(interruptibleLockBlockingActions);

    }

    /**

     * interruptible operations throw InterruptedException when read locked and interrupted

     */

    public void testInterruptibleOperationsThrowInterruptedExceptionReadLockedInterrupted() {

        final StampedLock lock = new StampedLock();

        long s = lock.readLock();

        Action[] interruptibleLockBlockingActions = {

            () -> lock.writeLockInterruptibly(),

            () -> lock.tryWriteLock(Long.MAX_VALUE, DAYS),

            () -> lock.asWriteLock().lockInterruptibly(),

            () -> lock.asWriteLock().tryLock(Long.MAX_VALUE, DAYS),

        };

        shuffle(interruptibleLockBlockingActions);

        assertThrowInterruptedExceptionWhenInterrupted(interruptibleLockBlockingActions);

    }

    /**

     * Non-interruptible operations ignore and preserve interrupt status

     */

    public void testNonInterruptibleOperationsIgnoreInterrupts() {

        final StampedLock lock = new StampedLock();

        Thread.currentThread().interrupt();

        for (BiConsumer<StampedLock, Long> readUnlocker : readUnlockers()) {

            long s = assertValid(lock, lock.readLock());

            readUnlocker.accept(lock, s);

            s = assertValid(lock, lock.tryReadLock());

            readUnlocker.accept(lock, s);

        }

        lock.asReadLock().lock();

        lock.asReadLock().unlock();

        for (BiConsumer<StampedLock, Long> writeUnlocker : writeUnlockers()) {

            long s = assertValid(lock, lock.writeLock());

            writeUnlocker.accept(lock, s);

            s = assertValid(lock, lock.tryWriteLock());

            writeUnlocker.accept(lock, s);

        }

        lock.asWriteLock().lock();

        lock.asWriteLock().unlock();

        assertTrue(Thread.interrupted());

    }

    /**

     * tryWriteLock on an unlocked lock succeeds

     */

    public void testTryWriteLock() {

        final StampedLock lock = new StampedLock();

        long s = lock.tryWriteLock();

        assertTrue(s != 0L);

        assertTrue(lock.isWriteLocked());

        assertEquals(0L, lock.tryWriteLock());

        releaseWriteLock(lock, s);

    }

    /**

     * tryWriteLock fails if locked

     */

    public void testTryWriteLockWhenLocked() {

        final StampedLock lock = new StampedLock();

        long s = lock.writeLock();

        Thread t = newStartedThread(new CheckedRunnable() {

            public void realRun() {

                assertEquals(0L, lock.tryWriteLock());

            }});

        assertEquals(0L, lock.tryWriteLock());

        awaitTermination(t);

        releaseWriteLock(lock, s);

    }

    /**

     * tryReadLock fails if write-locked

     */

    public void testTryReadLockWhenLocked() {

        final StampedLock lock = new StampedLock();

        long s = lock.writeLock();

        Thread t = newStartedThread(new CheckedRunnable() {

            public void realRun() {

                assertEquals(0L, lock.tryReadLock());

            }});

        assertEquals(0L, lock.tryReadLock());

        awaitTermination(t);

        releaseWriteLock(lock, s);

    }

    /**

     * Multiple threads can hold a read lock when not write-locked

     */

    public void testMultipleReadLocks() {

        final StampedLock lock = new StampedLock();

        final long s = lock.readLock();

        Thread t = newStartedThread(new CheckedRunnable() {

            public void realRun() throws InterruptedException {

                long s2 = lock.tryReadLock();

                assertValid(lock, s2);

                lock.unlockRead(s2);

                long s3 = lock.tryReadLock(LONG_DELAY_MS, MILLISECONDS);

                assertValid(lock, s3);

                lock.unlockRead(s3);

                long s4 = lock.readLock();

                assertValid(lock, s4);

                lock.unlockRead(s4);

                lock.asReadLock().lock();

                lock.asReadLock().unlock();