1 /*

     2  * Copyright (c) 2005, 2015, Oracle and/or its affiliates. All rights reserved.

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

     4  *

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

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

     7  * published by the Free Software Foundation.

     8  *

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

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

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

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

    13  * accompanied this code).

    14  *

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

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

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

    18  *

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

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

    21  * questions.

    22  */

    23 

    24 /**

    25  * @test

    26  * @bug 4401399

    27  * @summary Simple basic test of jdi Monitor request and event.

    28  * @author Swamy Venkataramanappa

    29  *

    30  * @run build TestScaffold VMConnection TargetListener TargetAdapter

    31  * @run compile -g MonitorEventTest.java

    32  * @run driver MonitorEventTest

    33  */

    34 import com.sun.jdi.*;

    35 import com.sun.jdi.event.*;

    36 import com.sun.jdi.request.*;

    37 

    38 import java.util.*;

    39 

    40 /********** target program **********/

    41 

    42 class MonitorTestTarg {

    43     public static Object endingMonitor;

    44     public static Object startingMonitor;

    45     public static final long timeout = 30 * 6000; // milliseconds

    46 

    47     public static volatile boolean aboutEnterLock;

    48 

    49     static void foo() {

    50         System.out.println("Howdy!");

    51     }

    52 

    53     public static void main(String[] args){

    54         endingMonitor = new Object();

    55         startingMonitor = new Object();

    56 

    57         myThread t1 = new myThread();

    58         foo();

    59         aboutEnterLock = false;

    60 

    61         synchronized(endingMonitor) {

    62 

    63             // run thread

    64             try {

    65                 // start thread

    66                 synchronized (startingMonitor) {

    67                     t1.start();

    68                     startingMonitor.wait(timeout);

    69                 }

    70             } catch (InterruptedException e) {

    71                 System.out.println("Interrupted exception " + e);

    72             }

    73 

    74             Thread.yield();

    75             while(!(aboutEnterLock && t1.getState() == Thread.State.BLOCKED)) {

    76                 try {

    77                     Thread.sleep(1000);

    78                 }catch(Exception x){

    79                     System.out.println(x);

    80                 }

    81             }

    82         }

    83         try {

    84             t1.join(timeout);

    85         } catch (Exception x){

    86             System.out.println("Exception while thread.join :" + x);

    87         }

    88         System.out.println("Test exiting");

    89     }

    90 }

    91 

    92 class myThread extends Thread {

    93     public void run() {

    94         synchronized(MonitorTestTarg.startingMonitor) {

    95             MonitorTestTarg.startingMonitor.notify();

    96         }

    97 

    98         // contended enter wait until main thread release monitor

    99         MonitorTestTarg.aboutEnterLock = true;

   100         synchronized (MonitorTestTarg.endingMonitor) {

   101         }

   102     }

   103 }

   104 

   105 

   106     /********** test program **********/

   107 

   108 public class MonitorEventTest extends TestScaffold {

   109     ReferenceType targetClass;

   110     ThreadReference mainThread;

   111     List monitors;

   112     MonitorContendedEnterRequest contendedEnterRequest;

   113     MonitorWaitedRequest monitorWaitedRequest;

   114     MonitorContendedEnteredRequest contendedEnteredRequest;

   115     MonitorWaitRequest monitorWaitRequest;

   116 

   117     static int actualWaitCount = 0;

   118     static int actualWaitedCount = 0;

   119     static int actualContendedEnterCount = 0;

   120     static int actualContendedEnteredCount= 0;

   121 

   122     MonitorEventTest (String args[]) {

   123         super(args);

   124     }

   125 

   126     public static void main(String[] args)      throws Exception {

   127         new MonitorEventTest(args).startTests();

   128     }

   129 

   130     /********** event handlers **********/

   131 

   132     public void monitorContendedEnter(MonitorContendedEnterEvent event) {

   133 

   134         actualContendedEnterCount++;

   135     }

   136 

   137     public void monitorContendedEntered(MonitorContendedEnteredEvent event) {

   138 

   139         actualContendedEnteredCount++;

   140 

   141     }

   142 

   143     public void monitorWait(MonitorWaitEvent event) {

   144 

   145         actualWaitCount++;

   146 

   147     }

   148     public void monitorWaited(MonitorWaitedEvent event) {

   149 

   150         actualWaitedCount++;

   151 

   152     }

   153 

   154 

   155 

   156     /********** test core **********/

   157 

   158     protected void runTests() throws Exception {

   159         /*

   160          * Get to the top of main()

   161          * to determine targetClass and mainThread

   162          */

   163         BreakpointEvent bpe = startToMain("MonitorTestTarg");

   164         targetClass = bpe.location().declaringType();

   165         mainThread = bpe.thread();

   166 

   167         int initialSize = mainThread.frames().size();

   168         if (vm().canRequestMonitorEvents()) {

   169             contendedEnterRequest = eventRequestManager().createMonitorContendedEnterRequest();

   170             contendedEnterRequest.setSuspendPolicy(EventRequest.SUSPEND_NONE);

   171             contendedEnterRequest.enable();

   172             contendedEnteredRequest = eventRequestManager().createMonitorContendedEnteredRequest();

   173             contendedEnteredRequest.setSuspendPolicy(EventRequest.SUSPEND_NONE);

   174             contendedEnteredRequest.enable();

   175             monitorWaitRequest = eventRequestManager().createMonitorWaitRequest();

   176             monitorWaitRequest.setSuspendPolicy(EventRequest.SUSPEND_NONE);

   177             monitorWaitRequest.enable();

   178             monitorWaitedRequest = eventRequestManager().createMonitorWaitedRequest();

   179             monitorWaitedRequest.setSuspendPolicy(EventRequest.SUSPEND_NONE);

   180             monitorWaitedRequest.enable();

   181         } else {

   182             System.out.println("request monitor events not supported " );

   183         }

   184 

   185 

   186         resumeTo("MonitorTestTarg", "foo", "()V");

   187 

   188         /*

   189          * resume until end

   190          */

   191         listenUntilVMDisconnect();

   192 

   193         /*

   194          * At least one of each type event should have recevied by this test.

   195          */

   196         if (vm().canRequestMonitorEvents()) {

   197             if (actualContendedEnterCount == 0) {

   198                 failure("Did not receive any  contended enter event.");

   199             }

   200             if (actualContendedEnteredCount == 0) {

   201                 failure("Did not receive any contended entered event. ");

   202             }

   203             if (actualWaitCount == 0) {

   204                 failure("Did not receive any contended monitor wait event");

   205             }

   206             if (actualWaitedCount == 0) {

   207                 failure("Did not receive any contended monitor waited event");

   208             }

   209         }

   210 

   211 

   212         /*

   213          * deal with results of test

   214          * if anything has called failure("foo") testFailed will be true

   215          */

   216         if (!testFailed) {

   217             println("MonitorEventTest: passed");

   218         } else {

   219             throw new Exception("MonitorEventTest: failed");

   220         }

   221     }

   222 }