/*
* Copyright (c) 1999, 2004, 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 main StepTest 2 line 2 MethodCalls
* @run main StepTest 3 line 14 MethodCalls
*
* @run main StepTest 2 line 18 MethodCallsReflection 12
*
* @run main StepTest 2 min 4 MethodCalls
* @run main StepTest 3 min 43 MethodCalls
*
* @run main 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;
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();
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();
StepEvent stepEvent = stepIntoLine(thread);
String className = thread.frame(0).location().declaringType().name();
System.out.println("\n\n-------Running test for class: " + className);
BreakpointEvent bpEvent = resumeTo(className, "go", "()V");
thread = bpEvent.thread();
for (int i = 0; i < expectedCount; i++) {
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() < 2) {
// 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() > 2) {
// 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() != 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");
}
}
}