/*
 * 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 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/
 */

/*
 * @test
 * @bug 8005697
 * @summary Basic tests for StampedLock
 * @library /lib/testlibrary/
 * @author Chris Hegarty
 */

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

import java.util.Iterator;
import java.util.concurrent.Phaser;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.StampedLock;
import jdk.testlibrary.Utils;

public class Basic {
    static final long LONG_DELAY_MS = Utils.adjustTimeout(10_000);

    static void checkResult(Locker l, Class<? extends Throwable> c) {
        Throwable t = l.thrown();
        if (! ((t == null && c == null) || (c != null && c.isInstance(t)))) {
            fail("Mismatch in thread " +
                 l.getName() + ": " +
                 t + ", " +
                 (c == null ? "<null>" : c.getName()));
        }

        if (c == null)
            check(l.stamp() != 0L);  // must have acquired the lock
        else
            check(l.stamp() == 0L);  // must NOT have acquired the lock
    }

    //----------------------------------------------------------------
    // Mechanism to get all test threads into "running" mode.
    //----------------------------------------------------------------
    static void toTheStartingGate(Phaser gate) {
        try {
            gate.arriveAndAwaitAdvance();
        } catch (Throwable t) {
            unexpected(t);
        }
    }

    abstract static class Locker extends Thread {
        static AtomicInteger count = new AtomicInteger(1);
        private volatile Throwable thrown;
        private volatile long stamp;
        protected void thrown(Throwable thrown) { this.thrown = thrown; }
        public Throwable thrown() { return thrown; }
        protected void stamp(long stamp) { this.stamp = stamp; }
        public long stamp() { return stamp; }

        Locker() {
            this("Locker");
        }

        Locker(String name) {
            this.setName(name + ":" + count.getAndIncrement());
            this.setDaemon(true);
        }
    }

    abstract static class Reader extends Locker {
        Reader() { super("Reader"); }
        Reader(String name) { super(name); }
    }

    static Reader reader(final StampedLock sl, final Phaser gate) {
        return new Reader() { public void run() {
            if (gate != null ) toTheStartingGate(gate);
            stamp(sl.readLock());
            try {
                check(sl.validate(stamp()));
                check(sl.isReadLocked());
                check(!sl.isWriteLocked());
            } finally { sl.unlockRead(stamp()); } }};
    }

    static Reader readerView(final StampedLock sl, final Phaser gate) {
        return new Reader("ReaderView") { public void run() {
            if (gate != null ) toTheStartingGate(gate);
            final Lock rl = sl.asReadLock();
            rl.lock();
            try {
                stamp(1L);   // got the lock
                check(sl.isReadLocked());
                check(!sl.isWriteLocked());
            } finally { rl.unlock(); } }};
    }

    static Reader reader(StampedLock sl, Phaser gate, boolean view) {
        return view ? readerView(sl, gate) : reader(sl, gate);
    }

    static Reader interruptibleReader(final StampedLock sl,
                                      final long timeout,
                                      final TimeUnit unit,
                                      final Phaser gate) {
        return new Reader("InterruptibleReader") { public void run() {
            if (gate != null ) toTheStartingGate(gate);
            try {
                if (timeout < 0)
                    stamp(sl.readLockInterruptibly());
                else
                    stamp(sl.tryReadLock(timeout, unit));
                check(sl.validate(stamp()));
                check(sl.isReadLocked());
                check(!sl.isWriteLocked());
            } catch (Throwable x) { thrown(x);
            } finally { if (stamp() != 0L) sl.unlockRead(stamp()); } }};
    }

    static Reader interruptibleReaderView(final StampedLock sl,
                                          final long timeout,
                                          final TimeUnit unit,
                                          final Phaser gate) {
        return new Reader("InterruptibleReaderView") { public void run() {
            if (gate != null ) toTheStartingGate(gate);
            final Lock rl = sl.asReadLock();

            try {
                if (timeout < 0)
                    rl.lockInterruptibly();
                else
                    rl.tryLock(timeout, unit);
                stamp(1L);  // got the lock
                check(sl.isReadLocked());
                check(!sl.isWriteLocked());
            } catch (Throwable x) { thrown(x);
            } finally { if (stamp() != 0L) rl.unlock(); } }};
    }

    static Reader interruptibleReader(final StampedLock sl,
                                      final long timeout,
                                      final TimeUnit unit,
                                      final Phaser gate,
                                      final boolean view) {
        return view ? interruptibleReaderView(sl, timeout, unit, gate)
                    : interruptibleReader(sl, timeout, unit, gate);
    }

    abstract static class Writer extends Locker {
        Writer() { super("Writer"); }
        Writer(String name) { super(name); }
    }

    static Writer writer(final StampedLock sl, final Phaser gate) {
        return new Writer() { public void run() {
            if (gate != null ) toTheStartingGate(gate);
            try {
                stamp(sl.writeLock());
                check(sl.validate(stamp()));
                check(!sl.isReadLocked());
                check(sl.isWriteLocked());
            } finally { sl.unlockWrite(stamp()); } }};
    }

    static Writer writerView(final StampedLock sl, final Phaser gate) {
        return new Writer("WriterView") { public void run() {
            if (gate != null ) toTheStartingGate(gate);
            Lock wl = sl.asWriteLock();
            wl.lock();
            try {
                stamp(1L);  // got the lock
                check(!sl.isReadLocked());
                check(sl.isWriteLocked());
            } finally { wl.unlock(); } }};
    }

    static Writer writer(StampedLock sl, Phaser gate, boolean view) {
        return view ? writerView(sl, gate) : writer(sl, gate);
    }

    static Writer interruptibleWriter(final StampedLock sl,
                                      final long timeout,
                                      final TimeUnit unit,
                                      final Phaser gate) {
        return new Writer("InterruptibleWriter") { public void run() {
            if (gate != null ) toTheStartingGate(gate);
            try {
                if (timeout < 0)
                    stamp(sl.writeLockInterruptibly());
                else
                    stamp(sl.tryWriteLock(timeout, unit));
                check(sl.validate(stamp()));
                check(!sl.isReadLocked());
                check(sl.isWriteLocked());
            } catch (Throwable x) { thrown(x);
            } finally { if (stamp() != 0L) sl.unlockWrite(stamp()); } }};
    }

    static Writer interruptibleWriterView(final StampedLock sl,
                                          final long timeout,
                                          final TimeUnit unit,
                                          final Phaser gate) {
        return new Writer("InterruptibleWriterView") { public void run() {
            if (gate != null ) toTheStartingGate(gate);
            Lock wl = sl.asWriteLock();
            try {
                if (timeout < 0)
                    wl.lockInterruptibly();
                else
                    wl.tryLock(timeout, unit);
                stamp(1L);  // got the lock
                check(!sl.isReadLocked());
                check(sl.isWriteLocked());
            } catch (Throwable x) { thrown(x);
            } finally { if (stamp() != 0L) wl.unlock(); } }};
    }

    static Writer interruptibleWriter(final StampedLock sl,
                                      final long timeout,
                                      final TimeUnit unit,
                                      final Phaser gate,
                                      final boolean view) {
        return view ? interruptibleWriterView(sl, timeout, unit, gate)
                    : interruptibleWriter(sl, timeout, unit, gate);
    }

    // Returns an infinite lazy list of all possible reader combinations.
    static Iterator<Reader> readerIterator(final StampedLock sl,
                                           final Phaser gate) {
        return new Iterator<Reader>() {
            int i = 0;
            boolean view = false;
            public boolean hasNext() { return true; }
            public Reader next() {
                switch ((i++)&7) {
                    case 1: case 4: case 7:
                        return reader(sl, gate, view ^= true);
                    case 2: case 5:
                        return interruptibleReader(sl, -1, SECONDS, gate, view ^= true);
                    default:
                        return interruptibleReader(sl, LONG_DELAY_MS, MILLISECONDS, gate, view ^= true); }}
            public void remove() {throw new UnsupportedOperationException();}};
    }

    // Returns an infinite lazy list of all possible writer combinations.
    static Iterator<Writer> writerIterator(final StampedLock sl,
                                           final Phaser gate) {
        return new Iterator<Writer>() {
            int i = 0;
            boolean view = false;
            public boolean hasNext() { return true; }
            public Writer next() {
                switch ((i++)&7) {
                    case 1: case 4: case 7:
                        return writer(sl, gate, view ^= true);
                    case 2: case 5:
                        return interruptibleWriter(sl, -1, SECONDS, gate, view ^= true);
                    default:
                        return interruptibleWriter(sl, LONG_DELAY_MS, MILLISECONDS, gate, view ^= true); }}
            public void remove() {throw new UnsupportedOperationException();}};
    }

    static class SimpleTimer {
        long startTime = System.nanoTime();
        long elapsedMillis() {
            long now = System.nanoTime();
            long elapsed = NANOSECONDS.toMillis(now - startTime);
            startTime = now;
            return elapsed;
        }
        void printElapsed() { System.out.println(elapsedMillis() + " ms"); }
    }

    static void waitForThreadToBlock(Thread thread) {
        for (long startTime = 0;;) {
            Thread.State state = thread.getState();
            if (state == Thread.State.WAITING ||
                state == Thread.State.TIMED_WAITING)
                break;
            if (startTime == 0) startTime = System.nanoTime();
            else if (System.nanoTime() - startTime > 10L * 1000L * 1000L * 1000L)
                throw new AssertionError("timed out waiting for thread to block");
        }
    }

    private static void realMain(String[] args) throws Throwable {
        SimpleTimer timer = new SimpleTimer();

        //----------------------------------------------------------------
        System.out.print("Some basic sanity: ");
        //----------------------------------------------------------------
        try {
            final StampedLock sl = new StampedLock();
            check(!sl.isReadLocked());
            check(!sl.isWriteLocked());
            long stamp = sl.tryOptimisticRead();
            check(stamp != 0L);
            check(sl.validate(stamp));
            check(!sl.validate(0));

            stamp = sl.writeLock();
            try {
                check(sl.validate(stamp));
                check(!sl.isReadLocked());
                check(sl.isWriteLocked());
                check(sl.tryReadLock() == 0L);
                check(sl.tryReadLock(1, MILLISECONDS) == 0L);
                check(sl.tryOptimisticRead() == 0L);
                check(sl.tryWriteLock() == 0L);
                check(sl.tryWriteLock(1, MILLISECONDS) == 0L);
                check(!sl.tryUnlockRead());
                check(sl.tryConvertToWriteLock(stamp) == stamp);
                try {
                    sl.unlockRead(stamp);
                    fail("Expected unlockRead to throw when not holding read lock");
                } catch (IllegalMonitorStateException x) {
                    pass();
                }
                check(sl.validate(stamp));
            } finally {
                sl.unlockWrite(stamp);
            }
            check(!sl.isWriteLocked());

            stamp = sl.readLock();
            try {
                check(sl.validate(stamp));
                check(sl.isReadLocked());
                check(!sl.isWriteLocked());
                check(sl.tryOptimisticRead() != 0L);
                check(sl.tryWriteLock() == 0L);
                check(sl.tryWriteLock(1, MILLISECONDS) == 0L);
                check(!sl.tryUnlockWrite());
                check(sl.tryConvertToReadLock(stamp) == stamp);
                try {
                    sl.unlockWrite(stamp);
                    fail("Expected unlockWrite to throw when not holding read lock");
                } catch (IllegalMonitorStateException x) {
                    pass();
                }
                check(sl.validate(stamp));
            } finally {
                sl.unlockRead(stamp);
            }
            check(!sl.isReadLocked());

            stamp = sl.tryReadLock(1, MILLISECONDS);
            try {
                check(stamp != 0L);
            } finally {
                sl.unlockRead(stamp);
            }
        } catch (Throwable t) { unexpected(t); }
        timer.printElapsed();

        //----------------------------------------------------------------
        System.out.print("Multiple writers single reader: ");
        //----------------------------------------------------------------
        try {
            StampedLock sl = new StampedLock();
            int nThreads = 10;
            Phaser gate = new Phaser(nThreads + 2);
            Iterator<Writer> writers = writerIterator(sl, gate);
            Iterator<Reader> readers = readerIterator(sl, gate);
            for (int i = 0; i < 2; i++) {
                check(!sl.isReadLocked());
                check(!sl.isWriteLocked());
                check(!sl.tryUnlockRead());
                check(!sl.tryUnlockWrite());
                check(sl.tryOptimisticRead() != 0L);
                Locker[] wThreads = new Locker[nThreads];
                for (int j=0; j<nThreads; j++)
                    wThreads[j] = writers.next();
                for (int j=0; j<nThreads; j++)
                    wThreads[j].start();
                Reader reader = readers.next(); reader.start();
                toTheStartingGate(gate);
                reader.join();
                for (int j=0; j<nThreads; j++)
                    wThreads[j].join();
                for (int j=0; j<nThreads; j++)
                    checkResult(wThreads[j], null);
                checkResult(reader, null);
            }
        } catch (Throwable t) { unexpected(t); }
        timer.printElapsed();

        //----------------------------------------------------------------
        System.out.print("Multiple readers single writer: ");
        //----------------------------------------------------------------
        try {
            StampedLock sl = new StampedLock();
            int nThreads = 10;
            Phaser gate = new Phaser(nThreads + 2);
            Iterator<Writer> writers = writerIterator(sl, gate);
            Iterator<Reader> readers = readerIterator(sl, gate);
            for (int i = 0; i < 2; i++) {
                check(!sl.isReadLocked());
                check(!sl.isWriteLocked());
                check(!sl.tryUnlockRead());
                check(!sl.tryUnlockWrite());
                check(sl.tryOptimisticRead() != 0L);
                Locker[] rThreads = new Locker[nThreads];
                for (int j=0; j<nThreads; j++)
                    rThreads[j] = readers.next();
                for (int j=0; j<nThreads; j++)
                    rThreads[j].start();
                Writer writer = writers.next(); writer.start();
                toTheStartingGate(gate);
                writer.join();
                for (int j=0; j<nThreads; j++)
                    rThreads[j].join();
                for (int j=0; j<nThreads; j++)
                    checkResult(rThreads[j], null);
                checkResult(writer, null);
            }
        } catch (Throwable t) { unexpected(t); }
        timer.printElapsed();

        //----------------------------------------------------------------
        System.out.print("thread interrupted: ");
        //----------------------------------------------------------------
        try {
            // We test interrupting both before and after trying to acquire
            boolean view = false;
            StampedLock sl = new StampedLock();
            for (long timeout : new long[] { -1L, LONG_DELAY_MS, -1L, LONG_DELAY_MS }) {
                long stamp;
                Thread.State state;

                stamp = sl.writeLock();
                try {
                    Reader r = interruptibleReader(sl, timeout, MILLISECONDS, null, view);
                    r.start();
                    r.interrupt();
                    r.join();
                    checkResult(r, InterruptedException.class);
                } finally {
                    sl.unlockWrite(stamp);
                }

                stamp = sl.writeLock();
                try {
                    Reader r = interruptibleReader(sl, timeout, MILLISECONDS, null, view);
                    r.start();
                    waitForThreadToBlock(r);
                    r.interrupt();
                    r.join();
                    checkResult(r, InterruptedException.class);
                } finally {
                    sl.unlockWrite(stamp);
                }

                stamp = sl.readLock();
                try {
                    Writer w = interruptibleWriter(sl, timeout, MILLISECONDS, null, view);
                    w.start();
                    w.interrupt();
                    w.join();
                    checkResult(w, InterruptedException.class);
                } finally {
                    sl.unlockRead(stamp);
                }

                stamp = sl.readLock();
                try {
                    Writer w = interruptibleWriter(sl, timeout, MILLISECONDS, null, view);
                    w.start();
                    waitForThreadToBlock(w);
                    w.interrupt();
                    w.join();
                    checkResult(w, InterruptedException.class);
                } finally {
                    sl.unlockRead(stamp);
                }

                check(!sl.isReadLocked());
                check(!sl.isWriteLocked());
                check(!sl.tryUnlockRead());
                check(!sl.tryUnlockWrite());
                check(sl.tryOptimisticRead() != 0L);
                if (timeout == LONG_DELAY_MS)
                    view = true;
            }
        } catch (Throwable t) { unexpected(t); }
        timer.printElapsed();

        //----------------------------------------------------------------
        System.out.print("timeout: ");
        //----------------------------------------------------------------
        try {
            StampedLock sl = new StampedLock();
            for (long timeout : new long[] { 0L, 5L }) {
                long stamp = sl.writeLock();
                try {
                    check(sl.tryReadLock(timeout, MILLISECONDS) == 0L);
                } finally {
                    sl.unlockWrite(stamp);
                }
                stamp = sl.readLock();
                try {
                    check(sl.tryWriteLock(timeout, MILLISECONDS) == 0L);
                } finally {
                    sl.unlockRead(stamp);
                }
                check(!sl.isReadLocked());
                check(!sl.isWriteLocked());
                check(!sl.tryUnlockRead());
                check(!sl.tryUnlockWrite());
                check(sl.tryOptimisticRead() != 0L);
            }
        } catch (Throwable t) { unexpected(t); }
        timer.printElapsed();

        //----------------------------------------------------------------
        System.out.print("optimistic read: ");
        //----------------------------------------------------------------
        try {
            StampedLock sl = new StampedLock();
            Iterator<Writer> writers = writerIterator(sl, null);
            Iterator<Reader> readers = readerIterator(sl, null);
            for (int i = 0; i < 10; i++) {
                check(!sl.isReadLocked());
                check(!sl.isWriteLocked());
                check(!sl.tryUnlockRead());
                check(!sl.tryUnlockWrite());
                long stamp = sl.tryOptimisticRead();
                check(stamp != 0L);
                check(sl.tryConvertToOptimisticRead(stamp) == stamp);
                Reader r = readers.next(); r.start();
                r.join();
                checkResult(r, null);
                check(sl.validate(stamp));
                check(sl.tryConvertToOptimisticRead(stamp) == stamp);
                Writer w = writers.next(); w.start();
                w.join();
                checkResult(w, null);
                check(sl.validate(stamp) == false);
            }
        } catch (Throwable t) { unexpected(t); }
        timer.printElapsed();

        //----------------------------------------------------------------
        System.out.print("convert: ");
        //----------------------------------------------------------------
        try {
            StampedLock sl = new StampedLock();
            for (int i = 0; i < 2; i++) {
                check(!sl.isReadLocked());
                check(!sl.isWriteLocked());
                check(!sl.tryUnlockRead());
                check(!sl.tryUnlockWrite());
                long stamp = sl.tryOptimisticRead();
                check(stamp != 0L);
                check((stamp = sl.tryConvertToReadLock(stamp)) != 0L);
                check(sl.validate(stamp));
                check(sl.isReadLocked());
                check(sl.tryWriteLock() == 0L);
                check(sl.tryWriteLock(1L, MILLISECONDS) == 0L);
                check((stamp = sl.tryConvertToWriteLock(stamp)) != 0L);
                check(sl.validate(stamp));
                check(!sl.isReadLocked());
                check(sl.isWriteLocked());
                check(sl.tryReadLock(1L, MILLISECONDS) == 0L);
                if (i != 0) {
                    sl.unlockWrite(stamp);
                    continue;
                }
                // convert down
                check((stamp = sl.tryConvertToReadLock(stamp)) != 0L);
                check(sl.validate(stamp));
                check(sl.isReadLocked());
                check(!sl.isWriteLocked());
                check(sl.tryWriteLock() == 0L);
                check(sl.tryWriteLock(1L, MILLISECONDS) == 0L);
                check((stamp = sl.tryConvertToOptimisticRead(stamp)) != 0L);
                check(sl.validate(stamp));
                check(!sl.isReadLocked());
                check(!sl.isWriteLocked());
                check(sl.validate(stamp));
            }
        } catch (Throwable t) { unexpected(t); }
        timer.printElapsed();

        //----------------------------------------------------------------
        System.out.print("views: ");
        //----------------------------------------------------------------
        try {
            StampedLock sl = new StampedLock();

            Lock rl = sl.asReadLock();
            Lock wl = sl.asWriteLock();
            for (int i = 0; i < 2; i++) {
                rl.lock();
                try {
                    check(sl.isReadLocked());
                    check(!sl.isWriteLocked());
                    check(sl.tryWriteLock() == 0L);
                    check(sl.tryWriteLock(1L, MILLISECONDS) == 0L);
                } finally {
                    rl.unlock();
                }
                check(!sl.isReadLocked());
                check(!sl.isWriteLocked());

                wl.lock();
                try {
                    check(!sl.isReadLocked());
                    check(sl.isWriteLocked());
                    check(sl.tryWriteLock() == 0L);
                    check(sl.tryWriteLock(1L, MILLISECONDS) == 0L);
                } finally {
                    wl.unlock();
                }
                check(!sl.isReadLocked());
                check(!sl.isWriteLocked());

                ReadWriteLock rwl = sl.asReadWriteLock();
                rl = rwl.readLock();
                wl = rwl.writeLock();
            }
        } catch (Throwable t) { unexpected(t); }
        timer.printElapsed();
    }

    //--------------------- Infrastructure ---------------------------
    static volatile int passed = 0, failed = 0;
    static void pass() {passed++;}
    static void fail() {failed++; Thread.dumpStack();}
    static void fail(String msg) {System.out.println(msg); fail();}
    static void unexpected(Throwable t) {failed++; t.printStackTrace();}
    static void check(boolean cond) {if (cond) pass(); else fail();}
    static void equal(Object x, Object y) {
        if (x == null ? y == null : x.equals(y)) pass();
        else fail(x + " not equal to " + y);}
    public static void main(String[] args) throws Throwable {
        try {realMain(args);} catch (Throwable t) {unexpected(t);}
        System.out.printf("%nPassed = %d, failed = %d%n%n", passed, failed);
        if (failed > 0) throw new AssertionError("Some tests failed");}
}