197 lines
7.6 KiB
Java
197 lines
7.6 KiB
Java
/*
|
|
* Copyright (c) 1999, 2023, 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.
|
|
*/
|
|
|
|
/**
|
|
* @test
|
|
* @bug 4270488 4787861
|
|
* @author Gordon Hirsch
|
|
*
|
|
* @run build TestScaffold VMConnection TargetAdapter TargetListener
|
|
* @run compile -g MethodCalls.java
|
|
* @run compile -g MethodCallsReflection.java
|
|
* @run compile -g ControlFlow.java
|
|
* @run build StepTest
|
|
*
|
|
* @summary StepTest starts at a method named "go()" in the debuggee and
|
|
* repetitively steps. It will do a step into until the maximum
|
|
* stack depth (specified on command line) is reached. At that point
|
|
* it begins to step over. Step granularity is determined from the
|
|
* command line. Stepping is repeated the until the end of go() is reached
|
|
* or until the requested number of steps (specified on command line)
|
|
* is performed. An exception is thrown if the requested number of
|
|
* steps does not result in the debuggee's location being at the end of
|
|
* go().
|
|
* This test is sensitive to the line number info generated by the compiler
|
|
* for the debuggee files- MethodCalls.java, ...
|
|
* See LineNumberInfo.java for more info.
|
|
*
|
|
* +--- maximum stack depth in debuggee
|
|
* | +--- step granularity: "line" or "min"
|
|
* | | +---Expected number of steps
|
|
* | | | +--- Debuggee command Line
|
|
* V V V V Workaround-----+
|
|
* V
|
|
* @run driver StepTest 2 line 2 MethodCalls
|
|
* @run driver StepTest 3 line 14 MethodCalls
|
|
*
|
|
* @run driver StepTest 2 line 18 MethodCallsReflection 12
|
|
*
|
|
* @run driver StepTest 2 min 4 MethodCalls
|
|
* @run driver StepTest 3 min 43 MethodCalls
|
|
*
|
|
* @run driver StepTest 2 line 65 ControlFlow 64
|
|
*/
|
|
|
|
/*
|
|
* The workaround column contains the expected number of steps
|
|
* on non IA64 VMs. These VMs get it wrong and should be
|
|
* fixed (4787861). When they are fixed, this test should be fixed
|
|
* to remove this workaround.
|
|
* The C interpreter in the IA64 VM handles catches differently
|
|
* than the asm interpreter. For the construct
|
|
* line statement
|
|
* -----------------
|
|
* 68 catch (Exception ee) {
|
|
* 69 System.out.println(...)
|
|
* javac outputs the store into ee as being on line 68 and the
|
|
* start of the println on line 69. The handler starts with the
|
|
* store into ee, ie, line 68. When a step is done under the
|
|
* associated try and an exception is encountered,
|
|
* the IA64 VM stops at line 68 while the other VM stops at
|
|
* line 69. It seems that the IA64 VM is correct.
|
|
* But, it is too late to fix the other VM for Mantis,
|
|
* so this test is being made so that it will pass both VMs.
|
|
* For each catch that occurs, an extra step is needed
|
|
* on the IA64 VM. This only occurs in MethodCallsReflection
|
|
* which contains 6 of these catches (so we have to do 6
|
|
* extra steps to make it pass) and in ControlFlow which
|
|
* does it once.
|
|
*
|
|
*/
|
|
import com.sun.jdi.*;
|
|
import com.sun.jdi.event.*;
|
|
import com.sun.jdi.request.*;
|
|
|
|
import java.util.Map;
|
|
import java.util.HashMap;
|
|
|
|
public class StepTest extends TestScaffold {
|
|
int maxDepth;
|
|
String granularity;
|
|
int expectedCount;
|
|
String debuggeeClassName;
|
|
int workaroundCount = 0;
|
|
boolean lastStepNeeded = true;
|
|
public static void main(String args[]) throws Exception {
|
|
new StepTest(args).startTests();
|
|
}
|
|
|
|
StepTest(String args[]) throws Exception {
|
|
super(args);
|
|
maxDepth = Integer.decode(args[0]).intValue();
|
|
granularity = args[1];
|
|
expectedCount = Integer.decode(args[2]).intValue();
|
|
debuggeeClassName = args[3];
|
|
if (args.length == 5) {
|
|
workaroundCount = Integer.decode(args[4]).intValue();
|
|
}
|
|
}
|
|
|
|
protected void runTests() throws Exception {
|
|
// Skip test args
|
|
String[] args2 = new String[args.length - 3];
|
|
System.arraycopy(args, 3, args2, 0, args.length - 3);
|
|
|
|
connect(args2);
|
|
ThreadReference thread = waitForVMStart();
|
|
|
|
System.out.println("\n\n-------Running test for class: " + debuggeeClassName);
|
|
|
|
BreakpointEvent bpEvent = resumeTo(debuggeeClassName, "go", "()V");
|
|
thread = bpEvent.thread();
|
|
|
|
int numFrames = thread.frameCount();
|
|
|
|
// maxDepth is based on the assumption that there are just two frames when we
|
|
// enter the go() method. When using the virtual thread wrapper, there are many
|
|
// more than that. So we need to adjust maxDepth. If we aren't using the virtual
|
|
// thread wrapper, then this adjustment becomes a no-op because numFrames == 2.
|
|
maxDepth = maxDepth - 2 + numFrames;
|
|
for (int i = 0; i < expectedCount; i++) {
|
|
StepEvent stepEvent;
|
|
if (thread.frameCount() < maxDepth) {
|
|
if (granularity.equals("line")) {
|
|
stepEvent = stepIntoLine(thread);
|
|
} else {
|
|
stepEvent = stepIntoInstruction(thread);
|
|
}
|
|
} else {
|
|
if (granularity.equals("line")) {
|
|
stepEvent = stepOverLine(thread);
|
|
} else {
|
|
stepEvent = stepOverInstruction(thread);
|
|
}
|
|
}
|
|
System.out.println("Step #" + (i+1) + " complete at " +
|
|
stepEvent.location().method().name() + ":" +
|
|
stepEvent.location().lineNumber() + " (" +
|
|
stepEvent.location().codeIndex() + "), frameCount = " +
|
|
thread.frameCount());
|
|
if (thread.frameCount() < numFrames) {
|
|
// We have stepped one step too far. If we did exactly
|
|
// the 'workaround' number of steps, then this is in all
|
|
// likelihood the non IA64 VM. So, stop.
|
|
if (i == workaroundCount) {
|
|
lastStepNeeded = false;
|
|
break;
|
|
}
|
|
// Gone too far, past return of go()
|
|
throw new Exception("Stepped too far");
|
|
}
|
|
}
|
|
|
|
if (thread.frameCount() > numFrames) {
|
|
// Not far enough
|
|
throw new Exception("Didn't step far enough (" + thread.frame(0) + ")");
|
|
}
|
|
|
|
if (lastStepNeeded) {
|
|
// One last step takes us out of go()
|
|
stepIntoLine(thread);
|
|
}
|
|
if (thread.frameCount() != numFrames - 1) {
|
|
// Gone too far
|
|
throw new Exception("Didn't step far enough (" + thread.frame(0) + ")");
|
|
}
|
|
|
|
// Allow application to complete
|
|
resumeToVMDisconnect();
|
|
|
|
if (!testFailed) {
|
|
println("StepTest: passed");
|
|
} else {
|
|
throw new Exception("StepTest: failed");
|
|
}
|
|
}
|
|
}
|