1 /*
2 * Copyright (c) 2018, 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 8193879 8193801 8129348
27 * @summary Invokes static and instance methods when debugger trace
28 * mode is on.
29 * @library /test/lib
30 * @run build TestScaffold VMConnection TargetListener TargetAdapter
31 * @run compile -g MethodInvokeWithTraceOnTest.java
32 * @run driver MethodInvokeWithTraceOnTest
33 */
34
35 import com.sun.jdi.*;
36 import com.sun.jdi.event.*;
37 import com.sun.jdi.request.*;
38
39 import java.util.*;
40
41 import static lib.jdb.JdbTest.*;
42
43 /********** target program **********/
44
45 class MethodInvokeWithTraceOnTestTarg {
46 public static void main(String[] args) {
47 new MethodInvokeWithTraceOnTestTarg().test();
48 }
49
50 private void test() {
51 Thread thread = Thread.currentThread();
52 print(thread); // @1 breakpoint
53 String str = "test";
54 printStatic(str); // @2 breakpoint
55
56 }
57
58 public void print(Object obj) {
59 System.out.println(obj);
60 }
61
62 public static void printStatic(Object obj) {
63 System.out.println(obj);
64 }
65
66 }
67
68
69 /********** test program **********/
70
71 public class MethodInvokeWithTraceOnTest extends TestScaffold {
72
73 MethodInvokeWithTraceOnTest(String args[]) {
74 super(args);
75 }
76
77 public static void main(String[] args)
78 throws Exception {
79 new MethodInvokeWithTraceOnTest(args).startTests();
80 }
81
82 /********** test core **********/
83
84 protected void runTests() throws Exception {
85 init();
86
87 // Test with suspend policy set to SUSPEND_EVENT_THREAD
88 BreakpointEvent be = resumeToBreakpoint(true, 1);
89 System.out.println("Breakpoint 1 is hit, suspendPolicy:" + be.request().suspendPolicy());
90 testMethods(be);
91
92 // Test with suspend policy set to SUSPEND_ALL
93 be = resumeToBreakpoint(false, 2);
94 System.out.println("Breakpoint 2 is hit, suspendPolicy:" + be.request().suspendPolicy());
95 testMethods(be);
96
97 listenUntilVMDisconnect();
98 }
99
100 private void init() throws Exception {
101 startToMain("MethodInvokeWithTraceOnTestTarg");
102 vm().setDebugTraceMode(VirtualMachine.TRACE_ALL);
103 }
104
105 private BreakpointEvent resumeToBreakpoint(boolean suspendThread, int breakpointId) throws Exception {
106 int bkpLine = parseBreakpoints(getTestSourcePath("MethodInvokeWithTraceOnTest.java"), breakpointId).get(0);
107 System.out.println("Running to line: " + bkpLine);
108 return resumeTo("MethodInvokeWithTraceOnTestTarg", bkpLine, suspendThread);
109 }
110
111 private void testMethods(BreakpointEvent be) throws Exception {
112 System.out.println("Testing methods...");
113 ThreadReference thread = be.thread();
114 StackFrame frame = thread.frame(0);
115 ObjectReference thisObj = frame.thisObject();
116 LocalVariable threadVar = frame.visibleVariableByName("thread");
117 ThreadReference threadObj = (ThreadReference) frame.getValue(threadVar);
118 StringReference stringObj = vm().mirrorOf("test string");
119 int invokeOptions = getMethodInvokeOptions(be);
120
121 testInstanceMethod1(thread, thisObj, stringObj, threadObj, invokeOptions);
122 testStaticMethod1(thread, thisObj, stringObj, threadObj, invokeOptions);
123 testStaticMethod2(thread, invokeOptions);
124 }
125
126 private void testInstanceMethod1(ThreadReference thread, ObjectReference thisObj, StringReference stringObj,
127 ThreadReference threadObj, int invokeOptions) throws Exception {
128 ClassType classType = (ClassType) thisObj.referenceType();
129 Method printMethod = classType.methodsByName("print",
130 "(Ljava/lang/Object;)V").get(0);
131
132 System.out.println("Passing StringReference to instance method...");
133 thisObj.invokeMethod(thread, printMethod, Collections.singletonList(stringObj), invokeOptions);
134
135 System.out.println("Passing ThreadReference to instance method...");
136 thisObj.invokeMethod(thread, printMethod, Collections.singletonList(threadObj), invokeOptions);
137 }
138
139 private void testStaticMethod1(ThreadReference thread, ObjectReference thisObj, StringReference stringObj,
140 ThreadReference threadObj, int invokeOptions) throws Exception {
141 ClassType classType = (ClassType) thisObj.referenceType();
142 Method printMethod = classType.methodsByName("printStatic",
143 "(Ljava/lang/Object;)V").get(0);
144
145 System.out.println("Passing StringReference to static method...");
146 classType.invokeMethod(thread, printMethod, Collections.singletonList(stringObj), invokeOptions);
147
148 System.out.println("Passing ThreadReference to static method...");
149 classType.invokeMethod(thread, printMethod, Collections.singletonList(threadObj), invokeOptions);
150 }
151
152 private void testStaticMethod2(ThreadReference thread, int invokeOptions) throws Exception {
153 ClassType classType = getClassType("java.lang.Class");
154 Method forNameMethod = classType.methodsByName("forName",
155 "(Ljava/lang/String;)Ljava/lang/Class;").get(0);
156 StringReference classNameParam = vm().mirrorOf("java.lang.String");
157 classType.invokeMethod(thread, forNameMethod, Collections.singletonList(classNameParam), invokeOptions);
158 }
159
160 private ClassType getClassType(String className) {
161 List classes = vm().classesByName(className);
162 return (ClassType) classes.get(0);
163 }
164
165 private int getMethodInvokeOptions(BreakpointEvent be) {
166 return be.request().suspendPolicy() == EventRequest.SUSPEND_EVENT_THREAD ?
167 ObjectReference.INVOKE_SINGLE_THREADED : 0;
168 }
169 }