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 6230699

    27  * @summary Test ThreadReference.ownedMonitorsAndFrames()

    28  * @bug 6701700

    29  * @summary MonitorInfo objects aren't invalidated when the owning thread is resumed

    30  * @author Swamy Venkataramanappa

    31  *

    32  * @run build TestScaffold VMConnection TargetListener TargetAdapter

    33  * @run compile -g MonitorFrameInfo.java

    34  * @run driver MonitorFrameInfo

    35  */

    36 import com.sun.jdi.*;

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

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

    39 

    40 import java.util.*;

    41 

    42     /********** target program **********/

    43 

    44 class MonitorTestTarg {

    45     static void foo3() {

    46         System.out.println("executing foo3");

    47 

    48     }

    49     static void foo2() {

    50         Object l1 = new Object();

    51         synchronized(l1) {

    52             System.out.println("executing foo2 " + l1);

    53             foo3();

    54         }

    55     }

    56     static void foo1() {

    57         foo2();

    58     }

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

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

    61         Object l1 = new Object();

    62         synchronized(l1) {

    63             System.out.println("executing main" + l1);

    64             foo1();

    65         }

    66     }

    67 }

    68 

    69     /********** test program **********/

    70 

    71 public class MonitorFrameInfo extends TestScaffold {

    72     ReferenceType targetClass;

    73     ThreadReference mainThread;

    74     List monitors;

    75 

    76     static int expectedCount = 2;

    77     static int[] expectedDepth = { 1, 3 };

    78 

    79     static String[] expectedNames = {"foo3", "foo2", "foo1", "main"};

    80 

    81     MonitorFrameInfo (String args[]) {

    82         super(args);

    83     }

    84 

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

    86         new MonitorFrameInfo(args).startTests();

    87     }

    88 

    89     /********** test core **********/

    90 

    91     protected void runTests() throws Exception {

    92         /*

    93          * Get to the top of main()

    94          * to determine targetClass and mainThread

    95          */

    96         BreakpointEvent bpe = startToMain("MonitorTestTarg");

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

    98         mainThread = bpe.thread();

    99 

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

   101 

   102         resumeTo("MonitorTestTarg", "foo3", "()V");

   103 

   104         if (!mainThread.frame(0).location().method().name()

   105                         .equals("foo3")) {

   106             failure("FAILED: frame failed");

   107         }

   108 

   109         if (mainThread.frames().size() != (initialSize + 3)) {

   110             failure("FAILED: frames size failed");

   111         }

   112 

   113         if (mainThread.frames().size() != mainThread.frameCount()) {

   114             failure("FAILED: frames size not equal to frameCount");

   115         }

   116 

   117         /* Test monitor frame info.

   118          */

   119         if (vm().canGetMonitorFrameInfo()) {

   120             System.out.println("Get monitors");

   121             monitors = mainThread.ownedMonitorsAndFrames();

   122             if (monitors.size() != expectedCount) {

   123                 failure("monitors count is not equal to expected count");

   124             }

   125             MonitorInfo mon = null;

   126             for (int j=0; j < monitors.size(); j++) {

   127                 mon  = (MonitorInfo)monitors.get(j);

   128                 System.out.println("Monitor obj " + mon.monitor() + "depth =" +mon.stackDepth());

   129                 if (mon.stackDepth() != expectedDepth[j]) {

   130                     failure("FAILED: monitor stack depth is not equal to expected depth");

   131                 }

   132             }

   133 

   134             // The last gotten monInfo is in mon.   When we resume the thread,

   135             // it should become invalid.  We will step out of the top frame

   136             // so that the frame depth in this mon object will no longer be correct.

   137             // That is why the monInfo's have to become invalid when the thread is

   138             // resumed.

   139             stepOut(mainThread);

   140             boolean ok = false;

   141             try {

   142                 System.out.println("*** Saved Monitor obj " + mon.monitor() + "depth =" +mon.stackDepth());

   143             } catch(InvalidStackFrameException ee) {

   144                 // ok

   145                 ok = true;

   146                 System.out.println("Got expected InvalidStackFrameException after a resume");

   147             }

   148             if (!ok) {

   149                 failure("FAILED: MonitorInfo object was not invalidated by a resume");

   150             }

   151         } else {

   152             System.out.println("can not get monitors frame info");

   153         }

   154 

   155 

   156         /*

   157          * resume until end

   158          */

   159         listenUntilVMDisconnect();

   160 

   161         /*

   162          * deal with results of test

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

   164          */

   165         if (!testFailed) {

   166             println("MonitorFrameInfo: passed");

   167         } else {

   168             throw new Exception("MonitorFrameInfo: failed");

   169         }

   170     }

   171 }