test/hotspot/jtreg/vmTestbase/nsk/share/jdi/MonitorEventsDebuggee.java - platform/libcore - Git at Google

 /*
  * 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) {
                 yield();
             }

             // 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)
                 yield();

             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();
     }

 }
	/*
	* 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) {
	yield();
	}

	// 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)
	yield();

	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();
	}

	}