/*

 * Copyright (c) 2006, 2018, Oracle and/or its affiliates. All rights reserved.

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

 */

package nsk.share.jdi;

import java.util.*;

import nsk.share.TestBug;

import nsk.share.locks.MonitorLockingThread;

/*

 * This class generates MonitorWaitEvent and MonitorWaitedEvent

 */

class MonitorWaitExecutor extends EventActionsExecutor {

    // MonitorWaited event may occurs when waiting thread was interrupted,

    // notified by notify or notifyAll, or when timeout expired

    enum ExitFromWaitType {

        EXIT_WITH_TIMEOUT,

        INTERRUPT,

        NOTIFY,

        NOTIFY_ALL

    }

    // this thread forces MonitorWaitExecutor to exit from wait()

    class AuxiliaryThread extends Thread {

        private Thread threadToInterrupt;

        private Object monitor;

        public AuxiliaryThread(Thread threadToInterrupt, Object monitor) {

            this.threadToInterrupt = threadToInterrupt;

            this.monitor = monitor;

        }

        public void run() {

            // wait when interrupted thread switches state to 'TIMED_WAITING'

            while ((threadToInterrupt.getState() != Thread.State.WAITING) && !exitedFromWait) {

            }

            // threadToInterrupt 'spuriously' exited from wait()

            if(exitedFromWait)

                return;

            if (exitFromWaitType == ExitFromWaitType.INTERRUPT) {

                threadToInterrupt.interrupt();

            } else if ((exitFromWaitType == ExitFromWaitType.NOTIFY)

                    || (exitFromWaitType == ExitFromWaitType.NOTIFY_ALL)) {

                /*

                 * NOTE: thread's state WAITING doesn't guarantee that thread released

                 * monitor, and entering to the next synchronized block may cause MonitorContentedEnterEvent

                 * (if corresponding request was created).

                 *

                 * Debugger should take in account this issue.

                 */

                synchronized (monitor) {

                    if (exitFromWaitType == ExitFromWaitType.NOTIFY)

                        monitor.notify();

                    else if (exitFromWaitType == ExitFromWaitType.NOTIFY_ALL)

                        monitor.notifyAll();

                }

            }

        }

    }

    // thread may 'spuriously' exit from wait(), in this case AuxiliaryThread shouldn't wait 'WAITING' state

    private volatile boolean exitedFromWait;

    // save data about MonitorWait events

    private boolean monitorWait;

    // save data about MonitorWaited events

    private boolean monitorWaited;

    public MonitorWaitExecutor(boolean monitorWait, boolean monitorWaited) {

        this.monitorWait = monitorWait;

        this.monitorWaited = monitorWaited;

    }

    protected ExitFromWaitType exitFromWaitType;

    public void doEventAction() {

        for (ExitFromWaitType exitType : ExitFromWaitType.values()) {

            exitFromWaitType = exitType;

            monitorWait();

        }

    }

    protected void monitorWait() {

        exitedFromWait = false;

        long timeout;

        if (exitFromWaitType == ExitFromWaitType.EXIT_WITH_TIMEOUT)

            timeout = 100;

        else

            timeout = 0;

        if (monitorWait) {

            DebuggeeEventData.DebugMonitorWaitEventData eventData = new DebuggeeEventData.DebugMonitorWaitEventData(

                    this, Thread.currentThread(), timeout, this);

            addEventData(eventData);

        }

        if (monitorWaited) {

            DebuggeeEventData.DebugMonitorWaitedEventData eventData = new DebuggeeEventData.DebugMonitorWaitedEventData(

                    this, Thread.currentThread(),

                    (exitFromWaitType == ExitFromWaitType.EXIT_WITH_TIMEOUT),

                    this);

            addEventData(eventData);

        }

        AuxiliaryThread auxiliaryThread = null;

        if (exitFromWaitType != ExitFromWaitType.EXIT_WITH_TIMEOUT) {

            auxiliaryThread = new AuxiliaryThread(Thread.currentThread(), this);

            auxiliaryThread.start();

        }

        try {

            eventMethod(timeout);

        } catch (InterruptedException e) {

            // expected exception

        }

        exitedFromWait = true;

        if (auxiliaryThread != null) {

            // don't using join, because of join is realized with using of

            // wait(), and this method can generate unexpected events

            while (auxiliaryThread.getState() != Thread.State.TERMINATED)

                Thread.yield();

        }

    }

    // move event actions to the separate method to simplify method redifinition

    // in subclasses

    synchronized protected void eventMethod(long timeout)

            throws InterruptedException {

        wait(timeout);

    }

}

/*

 * Subclass of MonitorWaitExecutor, define its own event method(copy of parent

 * method), intended for event filters test

 */

class MonitorWaitExecutor_1Subclass extends MonitorWaitExecutor {

    public MonitorWaitExecutor_1Subclass(boolean monitorWait,

            boolean monitorWaited) {

        super(monitorWait, monitorWaited);

    }

    synchronized protected void eventMethod(long timeout)

            throws InterruptedException {

        wait(timeout);

    }

}

/*

 * Subclass of MonitorWaitExecutor, define its own event method(copy of parent

 * method), intended for event filters test

 */

class MonitorWaitExecutor_2Subclass extends MonitorWaitExecutor_1Subclass {

    public MonitorWaitExecutor_2Subclass(boolean monitorWait,

            boolean monitorWaited) {

        super(monitorWait, monitorWaited);

    }

    synchronized protected void eventMethod(long timeout)

            throws InterruptedException {

        wait(timeout);

    }

}

/*

 * This class generates MonitorContendedEnterEvent and

 * MonitorContendedEnteredEvent

 */

class MonitorEnterExecutor extends EventActionsExecutor {

    /*

     * Types of monitor acquiring:

     * - through synchronized block

     * - through synchronized method

     * - through JNI MonitorEnter

     */

    static enum MonitorAcquireType {

        SYNCHRONIZED_BLOCK,

        SYNCHRONIZED_METHOD,

        JNI_MONITOR_ENTER

    }

    // native method uses this class

    private static final Class<?> jniError = nsk.share.TestJNIError.class;

    static final String nativeLibararyName = "MonitorEnterExecutor";

    static {

        System.loadLibrary(nativeLibararyName);

    }

    // this thread forces MonitorLockingThread to release holding lock

    static class LockFreeThread extends Thread {

        private Thread blockedThread;

        private MonitorLockingThread lockingThread;

        public LockFreeThread(Thread blockedThread,

                MonitorLockingThread lockingThread) {

            this.blockedThread = blockedThread;

            this.lockingThread = lockingThread;

        }

        public void run() {

            // wait when blocked thread switches state to 'BLOCKED'

            while (blockedThread.getState() != Thread.State.BLOCKED)

            lockingThread.releaseLock();

        }

    }

    private boolean monitorEnter;

    private boolean monitorEntered;

    public MonitorEnterExecutor(boolean monitorEnter, boolean monitorEntered) {

        this.monitorEnter = monitorEnter;

        this.monitorEntered = monitorEntered;

    }

    protected void monitorEnter() {

        // locking thread acquires 'this' lock

        MonitorLockingThread lockingThread = new MonitorLockingThread(this);

        lockingThread.acquireLock();

        if (monitorEnter) {

            DebuggeeEventData.DebugMonitorEnterEventData eventData = new DebuggeeEventData.DebugMonitorEnterEventData(

                    this, Thread.currentThread(), this);

            addEventData(eventData);

        }

        if (monitorEntered) {

            DebuggeeEventData.DebugMonitorEnteredEventData eventData = new DebuggeeEventData.DebugMonitorEnteredEventData(

                    this, Thread.currentThread(), this);

            addEventData(eventData);

        }

        /*

         * This thread forces lockingThread to free 'this' lock when current thread's state will change to 'BLOCKED'

         *

         * NOTE: this method to provoke MonitorContended events isn't 100% robust

         * Tests should take in account this issue.

         *

         */

        LockFreeThread lockFreeThread = new LockFreeThread(Thread.currentThread(), lockingThread);

        lockFreeThread.start();

        // try to acquire 'this' lock

        eventMethod();

        while(lockingThread.getState() != Thread.State.TERMINATED)

            Thread.yield();

        while(lockFreeThread.getState() != Thread.State.TERMINATED)

            Thread.yield();

    }

    private MonitorAcquireType monitorAcquireType;

    // generate events in different ways

    public void doEventAction() {

        for (MonitorAcquireType monitorAcquireType : MonitorAcquireType.values()) {

            this.monitorAcquireType = monitorAcquireType;

            monitorEnter();

        }

    }

    protected void eventMethod() {

        switch (monitorAcquireType) {

        case SYNCHRONIZED_BLOCK:

            synchronizedBlock();

            break;

        case SYNCHRONIZED_METHOD:

            synchronizedMethod();

            break;

        case JNI_MONITOR_ENTER:

            nativeJNIMonitorEnter();

            break;

        default:

            throw new TestBug("Invalid monitorAcquireType: "

                    + monitorAcquireType);

        }

    }

    // move event actions to the separate methods to simplify method

    // redifinition in subclasses:

    protected void synchronizedBlock() {

        // MonitorContendedEnterEvent and MonitorContendedEnteredEvent should occur here

        synchronized (this) {

            // don't expect events for following synchronized block

            synchronized (this) {

            }

        }

    }

    // MonitorContendedEnterEvent and MonitorContendedEnteredEvent should occur here

    synchronized protected void synchronizedMethod() {

        // don't expect events for following synchronized block

        synchronized (this) {

        }

    }

    // call JNI methods MonitorEnter and MonitorExit for 'this' object

    protected native void nativeJNIMonitorEnter();

}

/*

 * Subclass of MonitorEnterExecutor, defines its own event methods(copy of parent

 * method), intended for event filters test

 */

class MonitorEnterExecutor_1Subclass extends MonitorEnterExecutor {

    static {

        System.loadLibrary(nativeLibararyName);

    }

    public MonitorEnterExecutor_1Subclass(boolean monitorEnter,

            boolean monitorEntered) {

        super(monitorEnter, monitorEntered);

    }

    protected void synchronizedBlock() {

        // MonitorContendedEnterEvent and MonitorContendedEnteredEvent should occur here

        synchronized (this) {

        }

    }

    // MonitorContendedEnterEvent and MonitorContendedEnteredEvent should occur here

    synchronized protected void synchronizedMethod() {

    }

    // call JNI methods MonitorEnter and MonitorExit for 'this' object

    protected native void nativeJNIMonitorEnter();

}

/*

 * Subclass of MonitorEnterExecutor, defines its own event methods(copy of parent

 * method), intended for event filters test

 */

class MonitorEnterExecutor_2Subclass extends MonitorEnterExecutor_1Subclass {

    static {

        System.loadLibrary(nativeLibararyName);

    }

    public MonitorEnterExecutor_2Subclass(boolean monitorEnter,

            boolean monitorEntered) {

        super(monitorEnter, monitorEntered);

    }

    protected void synchronizedBlock() {

        // MonitorContendedEnterEvent and MonitorContendedEnteredEvent should occur here

        synchronized (this) {

        }

    }

    // MonitorContendedEnterEvent and MonitorContendedEnteredEvent should occur here

    synchronized protected void synchronizedMethod() {

    }

    // call JNI methods MonitorEnter and MonitorExit for 'this' object

    protected native void nativeJNIMonitorEnter();

}

/*

 * Class is used as base debuggee in tests for following events and event requests:

 * - MonitorContendedEnterRequest / MonitorContendedEnterEvent

 * - MonitorContendedEnteredRequest / MonitorContendedEnteredEvent

 * - MonitorWaitRequest / MonitorWaitEvent

 * - MonitorWaitedRequest / MonitorWaitedEvent

 */

public class MonitorEventsDebuggee extends JDIEventsDebuggee {

    public static void main(String[] args) {

        MonitorEventsDebuggee debuggee = new MonitorEventsDebuggee();

        debuggee.doTest(args);

    }

    protected void createActionsExecutors(String description, int eventsCount) {

        boolean monitorEnter = description

                .contains(JDIEventsDebugger.EventType.MONITOR_CONTENTED_ENTER

                        .name());

        boolean monitorEntered = description

                .contains(JDIEventsDebugger.EventType.MONITOR_CONTENTED_ENTERED

                        .name());

        boolean monitorWait = description

                .contains(JDIEventsDebugger.EventType.MONITOR_WAIT.name());

        boolean monitorWaited = description

                .contains(JDIEventsDebugger.EventType.MONITOR_WAITED.name());

        if (monitorEnter || monitorEntered || monitorWait || monitorWaited) {

            createActionsExecutors(monitorEnter, monitorEntered, monitorWait,

                    monitorWaited, eventsCount);

        } else

            throw new TestBug(

                    "Invalid command format (required event not specified)");

    }

    private List<DebuggeeEventData.DebugMonitorEventData> eventsData = new ArrayList<DebuggeeEventData.DebugMonitorEventData>();

    protected void clearResults() {

        super.clearResults();

        eventsData.clear();

    }

    private void createActionsExecutors(boolean monitorEnter,

            boolean monitorEntered, boolean monitorWait, boolean monitorWaited,

            int actionsCount) {

        EventActionsThread thread;

        // create 3 instances of generating objects of 3 different classes (for

        // event filters tests)

        if (monitorEnter || monitorEntered) {

            thread = new EventActionsThread(new MonitorEnterExecutor(

                    monitorEnter, monitorEntered), actionsCount);

            thread.start();

            eventActionsExecutorsPool.add(thread);

            thread = new EventActionsThread(new MonitorEnterExecutor_1Subclass(

                    monitorEnter, monitorEntered), actionsCount);

            thread.start();

            eventActionsExecutorsPool.add(thread);

            thread = new EventActionsThread(new MonitorEnterExecutor_2Subclass(

                    monitorEnter, monitorEntered), actionsCount);

            thread.start();

            eventActionsExecutorsPool.add(thread);

        }

        // create 3 instances of generating objects of 3 different classes (for

        // event filters tests)

        if (monitorWait || monitorWaited) {

            thread = new EventActionsThread(new MonitorWaitExecutor(

                    monitorWait, monitorWaited), actionsCount);

            thread.start();

            eventActionsExecutorsPool.add(thread);

            thread = new EventActionsThread(new MonitorWaitExecutor_1Subclass(

                    monitorWait, monitorWaited), actionsCount);

            thread.start();

            eventActionsExecutorsPool.add(thread);

            thread = new EventActionsThread(new MonitorWaitExecutor_2Subclass(

                    monitorWait, monitorWaited), actionsCount);

            thread.start();

            eventActionsExecutorsPool.add(thread);

        }

    }

    // start event generating threads and wait when all this threads finish

    // execution

    // override parent method because of Thread.join() used in parent method

    // generates unexpected MonitorWait/MonitorWaited events

    protected void startExecution() {

        if (eventActionsExecutorsPool.size() == 0) {

            throw new TestBug("ActionsExecutors were not created");

        }

        for (EventActionsThread thread : eventActionsExecutorsPool) {

            thread.startExecution();

        }

        // wait completion of test threads in separate thread to free thread listening commands

        executionControllingThread = new Thread(

                new Runnable() {

                    public void run() {

                        boolean executionCompleted;

                        do {

                            try {

                                // give time to event generators

                                Thread.sleep(500);

                            } catch (InterruptedException e) {

                                unexpectedException(e);

                            }

                            executionCompleted = true;

                            for (EventActionsThread thread : eventActionsExecutorsPool) {

                                if (thread.isAlive()) {

                                    executionCompleted = false;

                                    break;

                                }

                            }

                        } while (!executionCompleted);

                        completeExecution();

                    }

                });

        executionControllingThread.start();

    }

}