org.eclipse.jdt.debug.tests/tests/org/eclipse/jdt/debug/test/stepping/StepResultTests.java - jdt/eclipse.jdt.debug - Git at Google

 /*******************************************************************************
  * Copyright (c) 2018 Till Brychcy and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
  *
  * Contributors:
  *     Till Brychcy - initial API and implementation
  *******************************************************************************/
 package org.eclipse.jdt.debug.test.stepping;

 import org.eclipse.core.runtime.preferences.DefaultScope;
 import org.eclipse.core.runtime.preferences.IEclipsePreferences;
 import org.eclipse.debug.core.model.ILineBreakpoint;
 import org.eclipse.debug.core.model.IStackFrame;
 import org.eclipse.debug.core.model.IVariable;
 import org.eclipse.jdt.debug.core.IJavaDebugTarget;
 import org.eclipse.jdt.debug.core.IJavaExceptionBreakpoint;
 import org.eclipse.jdt.debug.core.IJavaMethodBreakpoint;
 import org.eclipse.jdt.debug.core.IJavaObject;
 import org.eclipse.jdt.debug.core.IJavaStackFrame;
 import org.eclipse.jdt.debug.core.IJavaThread;
 import org.eclipse.jdt.debug.core.IJavaValue;
 import org.eclipse.jdt.debug.core.JDIDebugModel;
 import org.eclipse.jdt.debug.tests.AbstractDebugTest;
 import org.eclipse.jdt.internal.debug.core.JDIDebugPlugin;
 import org.eclipse.jdt.internal.debug.ui.IJDIPreferencesConstants;
 import org.eclipse.jdt.internal.debug.ui.JDIDebugUIPlugin;
 import org.eclipse.jface.preference.IPreferenceStore;

 public class StepResultTests extends AbstractDebugTest {

 	public StepResultTests(String name) {
 		super(name);
 	}

 	public void testReturnValueAfterStepReturn() throws Exception {
 		String typeName = "StepResult1";
 		ILineBreakpoint bp1 = createLineBreakpoint(28, "StepResult1");
 		bp1.setEnabled(true);

 		IJavaThread thread = null;
 		try {
 			thread = launchToLineBreakpoint(typeName, bp1, false);
 			IJavaStackFrame stackFrame = (IJavaStackFrame) thread.getTopStackFrame();
 			assertEquals("h", stackFrame.getMethodName());

 			thread = stepReturn(stackFrame);
 			stackFrame = (IJavaStackFrame) thread.getTopStackFrame();
 			assertEquals("g", stackFrame.getMethodName());
 			IVariable varInG = stackFrame.getVariables()[0];
 			assertEquals("h() returned", varInG.getName());
 			assertEquals("\"h-i\"", varInG.getValue().toString());

 			// skip the synthetic via a step filter.
 			IJavaDebugTarget javaDebugTarget = (IJavaDebugTarget) stackFrame.getDebugTarget();
 			boolean oldStepFiltersEnabled = javaDebugTarget.isStepFiltersEnabled();
 			boolean oldFilterSynthetics = javaDebugTarget.isFilterSynthetics();
 			try {
 				javaDebugTarget.setStepFiltersEnabled(true);
 				javaDebugTarget.setFilterSynthetics(true);
 				thread = stepReturn(stackFrame);
 			}
 			finally {
 				javaDebugTarget.setStepFiltersEnabled(oldStepFiltersEnabled);
 				javaDebugTarget.setFilterSynthetics(oldFilterSynthetics);
 			}
 			stackFrame = (IJavaStackFrame) thread.getTopStackFrame();
 			assertEquals("f", stackFrame.getMethodName());
 			IVariable varInF = stackFrame.getVariables()[0];
 			assertEquals("access$0() returned", varInF.getName());
 			assertEquals("\"g-h-i-j\"", varInF.getValue().toString());

 			thread = stepReturn(stackFrame);
 			stackFrame = (IJavaStackFrame) thread.getTopStackFrame();
 			assertEquals("main", stackFrame.getMethodName());
 			IVariable varInMain1 = stackFrame.getVariables()[0];
 			assertEquals("f() returned", varInMain1.getName());

 			// test that running the thread a bit will clear the "f() returned"
 			thread = stepOver(stackFrame);
 			stackFrame = (IJavaStackFrame) thread.getTopStackFrame();
 			assertEquals("main", stackFrame.getMethodName());
 			IVariable varInMain2 = stackFrame.getVariables()[0];
 			assertEquals("no method return value", varInMain2.getName());
 		}
 		finally {
 			terminateAndRemove(thread);
 			removeAllBreakpoints();
 		}
 	}

 	/**
 	 * test that if the step return is aborted by some other break point, no return value of a recursive invocation is shown
 	 *
 	 * @throws Exception
 	 */
 	public void testNoReturnValueAfterAbortedStepReturn() throws Exception {
 		String typeName = "StepResult1";
 		ILineBreakpoint bp2A = createLineBreakpoint(49, "StepResult1");
 		bp2A.setEnabled(true);
 		ILineBreakpoint bp2B = createLineBreakpoint(50, "StepResult1");
 		bp2B.setEnabled(true);
 		ILineBreakpoint bp2C = createLineBreakpoint(24, "StepResult1");
 		bp2C.setEnabled(true);

 		IJavaThread thread = null;
 		try {
 			thread = launchToLineBreakpoint(typeName, bp2A, false);
 			IJavaStackFrame stackFrame = (IJavaStackFrame) thread.getTopStackFrame();
 			assertEquals("j", stackFrame.getMethodName());

 			// trigger stepReturn, but bp2B will be hit.
 			stackFrame.stepReturn();

 			resumeToLineBreakpoint(thread, bp2B);

 			IStackFrame[] stackFrames = thread.getStackFrames();
 			stackFrame = (IJavaStackFrame) stackFrames[0];
 			assertEquals("j", stackFrame.getMethodName());

 			stackFrame = (IJavaStackFrame) stackFrames[1];
 			assertEquals("g", stackFrame.getMethodName());

 			// bp2C is at the target stack level of the stepReturn
 			resumeToLineBreakpoint(thread, bp2C);

 			stackFrame = (IJavaStackFrame) thread.getTopStackFrame();
 			assertEquals("g", stackFrame.getMethodName());

 			IVariable varInH = stackFrame.getVariables()[0];

 			// specifically no "i() returned" must be present
 			assertEquals("no method return value", varInH.getName());
 		}
 		finally {
 			terminateAndRemove(thread);
 			removeAllBreakpoints();
 		}
 	}

 	public void testNoReturnValueAfterStepReturnWithException() throws Exception {
 		String typeName = "StepResult1";
 		ILineBreakpoint bp3A = createLineBreakpoint(41, "StepResult1");
 		bp3A.setEnabled(true);
 		ILineBreakpoint bp3B = createLineBreakpoint(33, "StepResult1");
 		bp3B.setEnabled(true);

 		IJavaThread thread = null;
 		try {
 			thread = launchToLineBreakpoint(typeName, bp3A, false);
 			IJavaStackFrame stackFrame = (IJavaStackFrame) thread.getTopStackFrame();
 			assertEquals("i", stackFrame.getMethodName());

 			stepReturn(stackFrame);

 			stackFrame = (IJavaStackFrame) thread.getTopStackFrame();
 			assertEquals("h", stackFrame.getMethodName());

 			IVariable varInH = stackFrame.getVariables()[0];

 			assertEquals("i() threw", varInH.getName());
 		}
 		finally {
 			terminateAndRemove(thread);
 			removeAllBreakpoints();
 		}
 	}

 	public void testReturnValueAfterStepReturnInStatic() throws Exception {
 		String typeName = "StepResult1";
 		ILineBreakpoint bp4 = createLineBreakpoint(56, "StepResult1");
 		bp4.setEnabled(true);

 		IJavaThread thread = null;
 		try {
 			thread = launchToLineBreakpoint(typeName, bp4, false);
 			IJavaStackFrame stackFrame = (IJavaStackFrame) thread.getTopStackFrame();
 			assertEquals("s", stackFrame.getMethodName());

 			thread = stepReturn(stackFrame);

 			stackFrame = (IJavaStackFrame) thread.getTopStackFrame();
 			assertEquals("main", stackFrame.getMethodName());

 			IVariable varInMain = stackFrame.getVariables()[0];

 			assertEquals("s() returned", varInMain.getName());
 		}
 		finally {
 			terminateAndRemove(thread);
 			removeAllBreakpoints();
 		}
 	}

 	public void testReturnValueAfterStepReturnViaInterface() throws Exception {
 		String typeName = "StepResult1";
 		ILineBreakpoint bp5 = createLineBreakpoint(66, "StepResult1");
 		bp5.setEnabled(true);

 		IJavaThread thread = null;
 		try {
 			thread = launchToLineBreakpoint(typeName, bp5, false);
 			IJavaStackFrame stackFrame = (IJavaStackFrame) thread.getTopStackFrame();
 			assertEquals("get", stackFrame.getMethodName());

 			thread = stepReturn(stackFrame);

 			stackFrame = (IJavaStackFrame) thread.getTopStackFrame();
 			assertEquals("testViaInterface", stackFrame.getMethodName());

 			IVariable varInMain = stackFrame.getVariables()[0];

 			assertEquals("get() returned", varInMain.getName());
 		}
 		finally {
 			terminateAndRemove(thread);
 			removeAllBreakpoints();
 		}
 	}

 	public void testHasExitedWithExceptionFor5BytesDistance() throws Exception {
 		String typeName = "StepResult1";
 		ILineBreakpoint bp3 = createLineBreakpoint(41, "StepResult1");
 		bp3.setEnabled(true);

 		IJavaThread thread = null;
 		try {
 			thread = launchToLineBreakpoint(typeName, bp3, false);
 			IJavaStackFrame stackFrame = (IJavaStackFrame) thread.getTopStackFrame();
 			assertEquals("i", stackFrame.getMethodName());

 			stepReturn(stackFrame);

 			stackFrame = (IJavaStackFrame) thread.getTopStackFrame();
 			assertEquals("h", stackFrame.getMethodName());

 			IVariable varInH = stackFrame.getVariables()[0];

 			assertEquals("i() threw", varInH.getName());

 			// will set the thread to running to get the toString result
 			IJavaValue stringValue = ((IJavaObject) varInH.getValue()).sendMessage("toString", "()Ljava/lang/String;", null, thread, false);

 			assertEquals("\"java.lang.RuntimeException: i\"", stringValue.toString());

 			// because the thread has run in between, check that after refreshing the stack, the thrown exception is still present
 			IVariable varInH2 = stackFrame.getVariables()[0];
 			assertEquals("i() threw", varInH2.getName());

 		}
 		finally {
 			terminateAndRemove(thread);
 			removeAllBreakpoints();
 		}
 	}

 	public void testStepReturn_ExceptionWithFinallyAndEmptyCatch() throws Exception {
 		String typeName = "StepResult2";
 		ILineBreakpoint bp6 = createLineBreakpoint(38, "StepResult2");
 		bp6.setEnabled(true);

 		IJavaThread thread = null;
 		try {
 			thread = launchToLineBreakpoint(typeName, bp6, false);
 			IJavaStackFrame stackFrame = (IJavaStackFrame) thread.getTopStackFrame();
 			assertEquals("i", stackFrame.getMethodName());

 			stepReturn(stackFrame);

 			stackFrame = (IJavaStackFrame) thread.getTopStackFrame(); // in finally clause
 			assertEquals("g", stackFrame.getMethodName());

 			IVariable varInG = stackFrame.getVariables()[0];

 			assertEquals("i() threw", varInG.getName());

 			stepReturn(stackFrame);

 			stackFrame = (IJavaStackFrame) thread.getTopStackFrame(); // after empty catch clause
 			assertEquals("f", stackFrame.getMethodName());

 			IVariable varInF = stackFrame.getVariables()[0];

 			assertEquals("g() threw", varInF.getName());

 		}
 		finally {
 			terminateAndRemove(thread);
 			removeAllBreakpoints();
 		}
 	}

 	public void testStepOver_ExceptionWithFinallyAndEmptyCatch() throws Exception {
 		String typeName = "StepResult2";
 		ILineBreakpoint bp6 = createLineBreakpoint(38, "StepResult2");
 		bp6.setEnabled(true);

 		IJavaThread thread = null;
 		try {
 			thread = launchToLineBreakpoint(typeName, bp6, false);
 			IJavaStackFrame stackFrame = (IJavaStackFrame) thread.getTopStackFrame();
 			assertEquals("i", stackFrame.getMethodName());

 			stepOver(stackFrame);

 			stackFrame = (IJavaStackFrame) thread.getTopStackFrame(); // in finally clause
 			assertEquals("g", stackFrame.getMethodName());

 			IVariable varInG = stackFrame.getVariables()[0];

 			assertEquals("i() threw", varInG.getName());

 			stepOver(stackFrame);
 			stepOver(stackFrame);

 			stackFrame = (IJavaStackFrame) thread.getTopStackFrame(); // still in finally clause
 			assertEquals("g", stackFrame.getMethodName());

 			IVariable varInG2 = stackFrame.getVariables()[0];

 			assertEquals("length() returned", varInG2.getName());

 			stepOver(stackFrame);

 			stackFrame = (IJavaStackFrame) thread.getTopStackFrame(); // after empty catch clause
 			assertEquals("f", stackFrame.getMethodName());

 			IVariable varInF = stackFrame.getVariables()[0];

 			assertEquals("g() threw", varInF.getName());

 		}
 		finally {
 			terminateAndRemove(thread);
 			removeAllBreakpoints();
 		}
 	}

 	public void testStepOver() throws Exception {
 		String typeName = "StepResult3";
 		ILineBreakpoint bp7 = createLineBreakpoint(22, "StepResult3");
 		bp7.setEnabled(true);

 		IJavaThread thread = null;
 		try {
 			thread = launchToLineBreakpoint(typeName, bp7, false);
 			IJavaStackFrame stackFrame = (IJavaStackFrame) thread.getTopStackFrame();
 			assertEquals("f", stackFrame.getMethodName());

 			stepOver(stackFrame);

 			stackFrame = (IJavaStackFrame) thread.getTopStackFrame();
 			assertEquals("hashCode() returned", stackFrame.getVariables()[0].getName());

 			stepOver(stackFrame);

 			stackFrame = (IJavaStackFrame) thread.getTopStackFrame();
 			assertEquals("getClassLoader() returned", stackFrame.getVariables()[0].getName());

 			stepOver(stackFrame);
 			stackFrame = (IJavaStackFrame) thread.getTopStackFrame();
 			assertEquals("<init>() returned", stackFrame.getVariables()[0].getName());

 			stepOver(stackFrame);

 			stackFrame = (IJavaStackFrame) thread.getTopStackFrame();
 			assertEquals("newProxyInstance() returned", stackFrame.getVariables()[0].getName());

 			stepOver(stackFrame);

 			stackFrame = (IJavaStackFrame) thread.getTopStackFrame();
 			assertEquals("get() returned", stackFrame.getVariables()[0].getName());
 			assertEquals("\"hello from proxy\"", stackFrame.getVariables()[0].getValue().toString());

 			stepOver(stackFrame);

 			stackFrame = (IJavaStackFrame) thread.getTopStackFrame();
 			assertEquals("h() returned", stackFrame.getVariables()[0].getName());
 			assertEquals("null", String.valueOf(stackFrame.getVariables()[0].getValue()));

 			stepOver(stackFrame);

 			stackFrame = (IJavaStackFrame) thread.getTopStackFrame();
 			assertEquals("g() returned", stackFrame.getVariables()[0].getName());
 			assertEquals("\"XXX\"", stackFrame.getVariables()[0].getValue().toString());

 			stepOver(stackFrame);

 			stackFrame = (IJavaStackFrame) thread.getTopStackFrame();
 			assertEquals("main", stackFrame.getMethodName());
 			assertEquals("g() threw", stackFrame.getVariables()[0].getName());

 			stepOver(stackFrame);

 			stackFrame = (IJavaStackFrame) thread.getTopStackFrame();
 			assertEquals("println() returned", stackFrame.getVariables()[0].getName());

 			stepOver(stackFrame);

 			stackFrame = (IJavaStackFrame) thread.getTopStackFrame();
 			assertEquals("currentTimeMillis() returned", stackFrame.getVariables()[0].getName());
 		}
 		finally {
 			terminateAndRemove(thread);
 			removeAllBreakpoints();
 		}
 	}

 	public void testStepInto() throws Exception {
 		String typeName = "StepResult3";
 		ILineBreakpoint bp8 = createLineBreakpoint(31, "StepResult3");
 		bp8.setEnabled(true);

 		IJavaThread thread = null;
 		try {
 			thread = launchToLineBreakpoint(typeName, bp8, false);
 			IJavaStackFrame stackFrame = (IJavaStackFrame) thread.getTopStackFrame();
 			assertEquals("f", stackFrame.getMethodName());

 			stepInto(stackFrame);

 			stackFrame = (IJavaStackFrame) thread.getTopStackFrame();
 			assertEquals("g", stackFrame.getMethodName());
 			assertFalse(stackFrame.getVariables()[0].getName().contains("returned"));

 			stepInto(stackFrame);

 			stackFrame = (IJavaStackFrame) thread.getTopStackFrame();
 			assertEquals("g", stackFrame.getMethodName());
 			assertFalse(stackFrame.getVariables()[0].getName().contains("returned"));

 			stepInto(stackFrame);

 			stackFrame = (IJavaStackFrame) thread.getTopStackFrame();
 			assertEquals("f", stackFrame.getMethodName());
 			assertEquals("g() returned", stackFrame.getVariables()[0].getName());
 			assertEquals("\"XXX\"", stackFrame.getVariables()[0].getValue().toString());

 			stepInto(stackFrame);
 			stackFrame = (IJavaStackFrame) thread.getTopStackFrame();
 			assertEquals("f", stackFrame.getMethodName());
 			assertFalse(stackFrame.getVariables()[0].getName().contains("returned"));

 			stepInto(stackFrame);
 			stackFrame = (IJavaStackFrame) thread.getTopStackFrame();
 			assertEquals("g", stackFrame.getMethodName());
 			assertFalse(stackFrame.getVariables()[0].getName().contains("returned"));

 			stepInto(stackFrame);

 			stackFrame = (IJavaStackFrame) thread.getTopStackFrame();
 			assertEquals("g", stackFrame.getMethodName());
 			assertFalse(stackFrame.getVariables()[0].getName().contains("returned"));

 			stepInto(stackFrame);

 			stackFrame = (IJavaStackFrame) thread.getTopStackFrame();
 			assertEquals("<init>", stackFrame.getMethodName()); // constructor of Exception
 			assertFalse(stackFrame.getVariables()[0].getName().contains("returned"));

 			stepReturn(stackFrame);

 			stackFrame = (IJavaStackFrame) thread.getTopStackFrame();
 			assertEquals("g", stackFrame.getMethodName());
 			assertEquals("<init>() returned", stackFrame.getVariables()[0].getName());

 			stepInto(stackFrame);

 			stackFrame = (IJavaStackFrame) thread.getTopStackFrame();
 			assertEquals("main", stackFrame.getMethodName());
 			assertEquals("g() threw", stackFrame.getVariables()[0].getName());
 		}
 		finally {
 			terminateAndRemove(thread);
 			removeAllBreakpoints();
 		}
 	}

 	public void testStepUncaught() throws Exception {
 		IPreferenceStore preferenceStore = JDIDebugUIPlugin.getDefault().getPreferenceStore();
 		boolean origPrefValue = preferenceStore.getBoolean(IJDIPreferencesConstants.PREF_SUSPEND_ON_UNCAUGHT_EXCEPTIONS);
 		preferenceStore.setValue(IJDIPreferencesConstants.PREF_SUSPEND_ON_UNCAUGHT_EXCEPTIONS, true);
 		String typeName = "StepUncaught";
 		ILineBreakpoint bp = createLineBreakpoint(15, "StepUncaught");
 		bp.setEnabled(true);

 		IJavaThread thread = null;
 		try {
 			thread = launchAndSuspend(typeName);
 			IJavaStackFrame stackFrame = (IJavaStackFrame) thread.getTopStackFrame();
 			assertEquals("main", stackFrame.getMethodName());

 			stepOver(stackFrame);

 			stackFrame = (IJavaStackFrame) thread.getTopStackFrame();
 			assertEquals("main", stackFrame.getMethodName());
 			assertEquals("f() threw", stackFrame.getVariables()[0].getName());

 			stepOverToBreakpoint(stackFrame);

 			stackFrame = (IJavaStackFrame) thread.getTopStackFrame();
 			assertEquals("g", stackFrame.getMethodName());
 		}
 		finally {
 			preferenceStore.setValue(IJDIPreferencesConstants.PREF_SUSPEND_ON_UNCAUGHT_EXCEPTIONS, origPrefValue);
 			terminateAndRemove(thread);
 			removeAllBreakpoints();
 		}
 	}

 	public void testMethodResultOnMethodExitAndExceptionBreakpoints() throws Exception {
 		IPreferenceStore preferenceStore = JDIDebugUIPlugin.getDefault().getPreferenceStore();
 		boolean origPrefValue = preferenceStore.getBoolean(IJDIPreferencesConstants.PREF_SUSPEND_ON_UNCAUGHT_EXCEPTIONS);
 		preferenceStore.setValue(IJDIPreferencesConstants.PREF_SUSPEND_ON_UNCAUGHT_EXCEPTIONS, true);
 		String typeName = "MethodExitAndException";
 		IJavaMethodBreakpoint methodExitBreakpoint = createMethodBreakpoint("MethodExitAndException", "f", null, false, true);
 		IJavaExceptionBreakpoint exceptionBreakpoint = createExceptionBreakpoint("MyException", true, true);
 		methodExitBreakpoint.setEnabled(true);
 		exceptionBreakpoint.setEnabled(true);
 		IJavaThread thread = null;
 		try {
 			thread = launchAndSuspend(typeName);
 			IJavaStackFrame stackFrame = (IJavaStackFrame) thread.getTopStackFrame();
 			assertEquals("f", stackFrame.getMethodName());
 			assertEquals("f() is returning", stackFrame.getVariables()[0].getName());

 			resume(thread);

 			stackFrame = (IJavaStackFrame) thread.getTopStackFrame();
 			assertEquals("g", stackFrame.getMethodName());
 			assertEquals("g() is throwing", stackFrame.getVariables()[0].getName());
 		}
 		finally {
 			preferenceStore.setValue(IJDIPreferencesConstants.PREF_SUSPEND_ON_UNCAUGHT_EXCEPTIONS, origPrefValue);
 			terminateAndRemove(thread);
 			removeAllBreakpoints();
 		}
 	}

 	public void testNoReturnValueAfterStepReturnWhichExceedsTimeout() throws Exception {
 		IEclipsePreferences node = DefaultScope.INSTANCE.getNode(JDIDebugPlugin.getUniqueIdentifier());
 		int origPrefValue = node.getInt(JDIDebugModel.PREF_SHOW_STEP_TIMEOUT, JDIDebugModel.DEF_SHOW_STEP_TIMEOUT);
 		node.putInt(JDIDebugModel.PREF_SHOW_STEP_TIMEOUT, -1);

 		String typeName = "StepResult1";
 		ILineBreakpoint bp1 = createLineBreakpoint(28, "StepResult1");
 		bp1.setEnabled(true);

 		IJavaThread thread = null;
 		try {
 			thread = launchToLineBreakpoint(typeName, bp1, false);
 			IJavaStackFrame stackFrame = (IJavaStackFrame) thread.getTopStackFrame();
 			assertEquals("h", stackFrame.getMethodName());

 			thread = stepReturn(stackFrame);
 			stackFrame = (IJavaStackFrame) thread.getTopStackFrame();
 			assertEquals("g", stackFrame.getMethodName());
 			IVariable varInG = stackFrame.getVariables()[0];
 			assertEquals("no method return value", varInG.getName());
 			assertEquals("(Not observed to speed up the long running step operation)", varInG.getValue().toString());
 		} finally {
 			node.putInt(JDIDebugModel.PREF_SHOW_STEP_TIMEOUT, origPrefValue);
 			terminateAndRemove(thread);
 			removeAllBreakpoints();
 		}
 	}
 }
	/*******************************************************************************
	* Copyright (c) 2018 Till Brychcy and others.
	* All rights reserved. This program and the accompanying materials
	* are made available under the terms of the Eclipse Public License v1.0
	* which accompanies this distribution, and is available at
	* http://www.eclipse.org/legal/epl-v10.html
	*
	* Contributors:
	* Till Brychcy - initial API and implementation
	*******************************************************************************/
	package org.eclipse.jdt.debug.test.stepping;

	import org.eclipse.core.runtime.preferences.DefaultScope;
	import org.eclipse.core.runtime.preferences.IEclipsePreferences;
	import org.eclipse.debug.core.model.ILineBreakpoint;
	import org.eclipse.debug.core.model.IStackFrame;
	import org.eclipse.debug.core.model.IVariable;
	import org.eclipse.jdt.debug.core.IJavaDebugTarget;
	import org.eclipse.jdt.debug.core.IJavaExceptionBreakpoint;
	import org.eclipse.jdt.debug.core.IJavaMethodBreakpoint;
	import org.eclipse.jdt.debug.core.IJavaObject;
	import org.eclipse.jdt.debug.core.IJavaStackFrame;
	import org.eclipse.jdt.debug.core.IJavaThread;
	import org.eclipse.jdt.debug.core.IJavaValue;
	import org.eclipse.jdt.debug.core.JDIDebugModel;
	import org.eclipse.jdt.debug.tests.AbstractDebugTest;
	import org.eclipse.jdt.internal.debug.core.JDIDebugPlugin;
	import org.eclipse.jdt.internal.debug.ui.IJDIPreferencesConstants;
	import org.eclipse.jdt.internal.debug.ui.JDIDebugUIPlugin;
	import org.eclipse.jface.preference.IPreferenceStore;

	public class StepResultTests extends AbstractDebugTest {

	public StepResultTests(String name) {
	super(name);
	}

	public void testReturnValueAfterStepReturn() throws Exception {
	String typeName = "StepResult1";
	ILineBreakpoint bp1 = createLineBreakpoint(28, "StepResult1");
	bp1.setEnabled(true);

	IJavaThread thread = null;
	try {
	thread = launchToLineBreakpoint(typeName, bp1, false);
	IJavaStackFrame stackFrame = (IJavaStackFrame) thread.getTopStackFrame();
	assertEquals("h", stackFrame.getMethodName());

	thread = stepReturn(stackFrame);
	stackFrame = (IJavaStackFrame) thread.getTopStackFrame();
	assertEquals("g", stackFrame.getMethodName());
	IVariable varInG = stackFrame.getVariables()[0];
	assertEquals("h() returned", varInG.getName());
	assertEquals("\"h-i\"", varInG.getValue().toString());

	// skip the synthetic via a step filter.
	IJavaDebugTarget javaDebugTarget = (IJavaDebugTarget) stackFrame.getDebugTarget();
	boolean oldStepFiltersEnabled = javaDebugTarget.isStepFiltersEnabled();
	boolean oldFilterSynthetics = javaDebugTarget.isFilterSynthetics();
	try {
	javaDebugTarget.setStepFiltersEnabled(true);
	javaDebugTarget.setFilterSynthetics(true);
	thread = stepReturn(stackFrame);
	}
	finally {
	javaDebugTarget.setStepFiltersEnabled(oldStepFiltersEnabled);
	javaDebugTarget.setFilterSynthetics(oldFilterSynthetics);
	}
	stackFrame = (IJavaStackFrame) thread.getTopStackFrame();
	assertEquals("f", stackFrame.getMethodName());
	IVariable varInF = stackFrame.getVariables()[0];
	assertEquals("access$0() returned", varInF.getName());
	assertEquals("\"g-h-i-j\"", varInF.getValue().toString());

	thread = stepReturn(stackFrame);
	stackFrame = (IJavaStackFrame) thread.getTopStackFrame();
	assertEquals("main", stackFrame.getMethodName());
	IVariable varInMain1 = stackFrame.getVariables()[0];
	assertEquals("f() returned", varInMain1.getName());

	// test that running the thread a bit will clear the "f() returned"
	thread = stepOver(stackFrame);
	stackFrame = (IJavaStackFrame) thread.getTopStackFrame();
	assertEquals("main", stackFrame.getMethodName());
	IVariable varInMain2 = stackFrame.getVariables()[0];
	assertEquals("no method return value", varInMain2.getName());
	}
	finally {
	terminateAndRemove(thread);
	removeAllBreakpoints();
	}
	}

	/**
	* test that if the step return is aborted by some other break point, no return value of a recursive invocation is shown
	*
	* @throws Exception
	*/
	public void testNoReturnValueAfterAbortedStepReturn() throws Exception {
	String typeName = "StepResult1";
	ILineBreakpoint bp2A = createLineBreakpoint(49, "StepResult1");
	bp2A.setEnabled(true);
	ILineBreakpoint bp2B = createLineBreakpoint(50, "StepResult1");
	bp2B.setEnabled(true);
	ILineBreakpoint bp2C = createLineBreakpoint(24, "StepResult1");
	bp2C.setEnabled(true);

	IJavaThread thread = null;
	try {
	thread = launchToLineBreakpoint(typeName, bp2A, false);
	IJavaStackFrame stackFrame = (IJavaStackFrame) thread.getTopStackFrame();
	assertEquals("j", stackFrame.getMethodName());

	// trigger stepReturn, but bp2B will be hit.
	stackFrame.stepReturn();

	resumeToLineBreakpoint(thread, bp2B);

	IStackFrame[] stackFrames = thread.getStackFrames();
	stackFrame = (IJavaStackFrame) stackFrames[0];
	assertEquals("j", stackFrame.getMethodName());

	stackFrame = (IJavaStackFrame) stackFrames[1];
	assertEquals("g", stackFrame.getMethodName());

	// bp2C is at the target stack level of the stepReturn
	resumeToLineBreakpoint(thread, bp2C);

	stackFrame = (IJavaStackFrame) thread.getTopStackFrame();
	assertEquals("g", stackFrame.getMethodName());

	IVariable varInH = stackFrame.getVariables()[0];

	// specifically no "i() returned" must be present
	assertEquals("no method return value", varInH.getName());
	}
	finally {
	terminateAndRemove(thread);
	removeAllBreakpoints();
	}
	}

	public void testNoReturnValueAfterStepReturnWithException() throws Exception {
	String typeName = "StepResult1";
	ILineBreakpoint bp3A = createLineBreakpoint(41, "StepResult1");
	bp3A.setEnabled(true);
	ILineBreakpoint bp3B = createLineBreakpoint(33, "StepResult1");
	bp3B.setEnabled(true);

	IJavaThread thread = null;
	try {
	thread = launchToLineBreakpoint(typeName, bp3A, false);
	IJavaStackFrame stackFrame = (IJavaStackFrame) thread.getTopStackFrame();
	assertEquals("i", stackFrame.getMethodName());

	stepReturn(stackFrame);

	stackFrame = (IJavaStackFrame) thread.getTopStackFrame();
	assertEquals("h", stackFrame.getMethodName());

	IVariable varInH = stackFrame.getVariables()[0];

	assertEquals("i() threw", varInH.getName());
	}
	finally {
	terminateAndRemove(thread);
	removeAllBreakpoints();
	}
	}

	public void testReturnValueAfterStepReturnInStatic() throws Exception {
	String typeName = "StepResult1";
	ILineBreakpoint bp4 = createLineBreakpoint(56, "StepResult1");
	bp4.setEnabled(true);

	IJavaThread thread = null;
	try {
	thread = launchToLineBreakpoint(typeName, bp4, false);
	IJavaStackFrame stackFrame = (IJavaStackFrame) thread.getTopStackFrame();
	assertEquals("s", stackFrame.getMethodName());

	thread = stepReturn(stackFrame);

	stackFrame = (IJavaStackFrame) thread.getTopStackFrame();
	assertEquals("main", stackFrame.getMethodName());

	IVariable varInMain = stackFrame.getVariables()[0];

	assertEquals("s() returned", varInMain.getName());
	}
	finally {
	terminateAndRemove(thread);
	removeAllBreakpoints();
	}
	}

	public void testReturnValueAfterStepReturnViaInterface() throws Exception {
	String typeName = "StepResult1";
	ILineBreakpoint bp5 = createLineBreakpoint(66, "StepResult1");
	bp5.setEnabled(true);

	IJavaThread thread = null;
	try {
	thread = launchToLineBreakpoint(typeName, bp5, false);
	IJavaStackFrame stackFrame = (IJavaStackFrame) thread.getTopStackFrame();
	assertEquals("get", stackFrame.getMethodName());

	thread = stepReturn(stackFrame);

	stackFrame = (IJavaStackFrame) thread.getTopStackFrame();
	assertEquals("testViaInterface", stackFrame.getMethodName());

	IVariable varInMain = stackFrame.getVariables()[0];

	assertEquals("get() returned", varInMain.getName());
	}
	finally {
	terminateAndRemove(thread);
	removeAllBreakpoints();
	}
	}

	public void testHasExitedWithExceptionFor5BytesDistance() throws Exception {
	String typeName = "StepResult1";
	ILineBreakpoint bp3 = createLineBreakpoint(41, "StepResult1");
	bp3.setEnabled(true);

	IJavaThread thread = null;
	try {
	thread = launchToLineBreakpoint(typeName, bp3, false);
	IJavaStackFrame stackFrame = (IJavaStackFrame) thread.getTopStackFrame();
	assertEquals("i", stackFrame.getMethodName());

	stepReturn(stackFrame);

	stackFrame = (IJavaStackFrame) thread.getTopStackFrame();
	assertEquals("h", stackFrame.getMethodName());

	IVariable varInH = stackFrame.getVariables()[0];

	assertEquals("i() threw", varInH.getName());

	// will set the thread to running to get the toString result
	IJavaValue stringValue = ((IJavaObject) varInH.getValue()).sendMessage("toString", "()Ljava/lang/String;", null, thread, false);

	assertEquals("\"java.lang.RuntimeException: i\"", stringValue.toString());

	// because the thread has run in between, check that after refreshing the stack, the thrown exception is still present
	IVariable varInH2 = stackFrame.getVariables()[0];
	assertEquals("i() threw", varInH2.getName());

	}
	finally {
	terminateAndRemove(thread);
	removeAllBreakpoints();
	}
	}

	public void testStepReturn_ExceptionWithFinallyAndEmptyCatch() throws Exception {
	String typeName = "StepResult2";
	ILineBreakpoint bp6 = createLineBreakpoint(38, "StepResult2");
	bp6.setEnabled(true);

	IJavaThread thread = null;
	try {
	thread = launchToLineBreakpoint(typeName, bp6, false);
	IJavaStackFrame stackFrame = (IJavaStackFrame) thread.getTopStackFrame();
	assertEquals("i", stackFrame.getMethodName());

	stepReturn(stackFrame);

	stackFrame = (IJavaStackFrame) thread.getTopStackFrame(); // in finally clause
	assertEquals("g", stackFrame.getMethodName());

	IVariable varInG = stackFrame.getVariables()[0];

	assertEquals("i() threw", varInG.getName());

	stepReturn(stackFrame);

	stackFrame = (IJavaStackFrame) thread.getTopStackFrame(); // after empty catch clause
	assertEquals("f", stackFrame.getMethodName());

	IVariable varInF = stackFrame.getVariables()[0];

	assertEquals("g() threw", varInF.getName());

	}
	finally {
	terminateAndRemove(thread);
	removeAllBreakpoints();
	}
	}

	public void testStepOver_ExceptionWithFinallyAndEmptyCatch() throws Exception {
	String typeName = "StepResult2";
	ILineBreakpoint bp6 = createLineBreakpoint(38, "StepResult2");
	bp6.setEnabled(true);

	IJavaThread thread = null;
	try {
	thread = launchToLineBreakpoint(typeName, bp6, false);
	IJavaStackFrame stackFrame = (IJavaStackFrame) thread.getTopStackFrame();
	assertEquals("i", stackFrame.getMethodName());

	stepOver(stackFrame);

	stackFrame = (IJavaStackFrame) thread.getTopStackFrame(); // in finally clause
	assertEquals("g", stackFrame.getMethodName());

	IVariable varInG = stackFrame.getVariables()[0];

	assertEquals("i() threw", varInG.getName());

	stepOver(stackFrame);
	stepOver(stackFrame);

	stackFrame = (IJavaStackFrame) thread.getTopStackFrame(); // still in finally clause
	assertEquals("g", stackFrame.getMethodName());

	IVariable varInG2 = stackFrame.getVariables()[0];

	assertEquals("length() returned", varInG2.getName());

	stepOver(stackFrame);

	stackFrame = (IJavaStackFrame) thread.getTopStackFrame(); // after empty catch clause
	assertEquals("f", stackFrame.getMethodName());

	IVariable varInF = stackFrame.getVariables()[0];

	assertEquals("g() threw", varInF.getName());

	}
	finally {
	terminateAndRemove(thread);
	removeAllBreakpoints();
	}
	}

	public void testStepOver() throws Exception {
	String typeName = "StepResult3";
	ILineBreakpoint bp7 = createLineBreakpoint(22, "StepResult3");
	bp7.setEnabled(true);

	IJavaThread thread = null;
	try {
	thread = launchToLineBreakpoint(typeName, bp7, false);
	IJavaStackFrame stackFrame = (IJavaStackFrame) thread.getTopStackFrame();
	assertEquals("f", stackFrame.getMethodName());

	stepOver(stackFrame);

	stackFrame = (IJavaStackFrame) thread.getTopStackFrame();
	assertEquals("hashCode() returned", stackFrame.getVariables()[0].getName());

	stepOver(stackFrame);

	stackFrame = (IJavaStackFrame) thread.getTopStackFrame();
	assertEquals("getClassLoader() returned", stackFrame.getVariables()[0].getName());

	stepOver(stackFrame);
	stackFrame = (IJavaStackFrame) thread.getTopStackFrame();
	assertEquals("<init>() returned", stackFrame.getVariables()[0].getName());

	stepOver(stackFrame);

	stackFrame = (IJavaStackFrame) thread.getTopStackFrame();
	assertEquals("newProxyInstance() returned", stackFrame.getVariables()[0].getName());

	stepOver(stackFrame);

	stackFrame = (IJavaStackFrame) thread.getTopStackFrame();
	assertEquals("get() returned", stackFrame.getVariables()[0].getName());
	assertEquals("\"hello from proxy\"", stackFrame.getVariables()[0].getValue().toString());

	stepOver(stackFrame);

	stackFrame = (IJavaStackFrame) thread.getTopStackFrame();
	assertEquals("h() returned", stackFrame.getVariables()[0].getName());
	assertEquals("null", String.valueOf(stackFrame.getVariables()[0].getValue()));

	stepOver(stackFrame);

	stackFrame = (IJavaStackFrame) thread.getTopStackFrame();
	assertEquals("g() returned", stackFrame.getVariables()[0].getName());
	assertEquals("\"XXX\"", stackFrame.getVariables()[0].getValue().toString());

	stepOver(stackFrame);

	stackFrame = (IJavaStackFrame) thread.getTopStackFrame();
	assertEquals("main", stackFrame.getMethodName());
	assertEquals("g() threw", stackFrame.getVariables()[0].getName());

	stepOver(stackFrame);

	stackFrame = (IJavaStackFrame) thread.getTopStackFrame();
	assertEquals("println() returned", stackFrame.getVariables()[0].getName());

	stepOver(stackFrame);

	stackFrame = (IJavaStackFrame) thread.getTopStackFrame();
	assertEquals("currentTimeMillis() returned", stackFrame.getVariables()[0].getName());
	}
	finally {
	terminateAndRemove(thread);
	removeAllBreakpoints();
	}
	}

	public void testStepInto() throws Exception {
	String typeName = "StepResult3";
	ILineBreakpoint bp8 = createLineBreakpoint(31, "StepResult3");
	bp8.setEnabled(true);

	IJavaThread thread = null;
	try {
	thread = launchToLineBreakpoint(typeName, bp8, false);
	IJavaStackFrame stackFrame = (IJavaStackFrame) thread.getTopStackFrame();
	assertEquals("f", stackFrame.getMethodName());

	stepInto(stackFrame);

	stackFrame = (IJavaStackFrame) thread.getTopStackFrame();
	assertEquals("g", stackFrame.getMethodName());
	assertFalse(stackFrame.getVariables()[0].getName().contains("returned"));

	stepInto(stackFrame);

	stackFrame = (IJavaStackFrame) thread.getTopStackFrame();
	assertEquals("g", stackFrame.getMethodName());
	assertFalse(stackFrame.getVariables()[0].getName().contains("returned"));

	stepInto(stackFrame);

	stackFrame = (IJavaStackFrame) thread.getTopStackFrame();
	assertEquals("f", stackFrame.getMethodName());
	assertEquals("g() returned", stackFrame.getVariables()[0].getName());
	assertEquals("\"XXX\"", stackFrame.getVariables()[0].getValue().toString());

	stepInto(stackFrame);
	stackFrame = (IJavaStackFrame) thread.getTopStackFrame();
	assertEquals("f", stackFrame.getMethodName());
	assertFalse(stackFrame.getVariables()[0].getName().contains("returned"));

	stepInto(stackFrame);
	stackFrame = (IJavaStackFrame) thread.getTopStackFrame();
	assertEquals("g", stackFrame.getMethodName());
	assertFalse(stackFrame.getVariables()[0].getName().contains("returned"));

	stepInto(stackFrame);

	stackFrame = (IJavaStackFrame) thread.getTopStackFrame();
	assertEquals("g", stackFrame.getMethodName());
	assertFalse(stackFrame.getVariables()[0].getName().contains("returned"));

	stepInto(stackFrame);

	stackFrame = (IJavaStackFrame) thread.getTopStackFrame();
	assertEquals("<init>", stackFrame.getMethodName()); // constructor of Exception
	assertFalse(stackFrame.getVariables()[0].getName().contains("returned"));

	stepReturn(stackFrame);

	stackFrame = (IJavaStackFrame) thread.getTopStackFrame();
	assertEquals("g", stackFrame.getMethodName());
	assertEquals("<init>() returned", stackFrame.getVariables()[0].getName());

	stepInto(stackFrame);

	stackFrame = (IJavaStackFrame) thread.getTopStackFrame();
	assertEquals("main", stackFrame.getMethodName());
	assertEquals("g() threw", stackFrame.getVariables()[0].getName());
	}
	finally {
	terminateAndRemove(thread);
	removeAllBreakpoints();
	}
	}

	public void testStepUncaught() throws Exception {
	IPreferenceStore preferenceStore = JDIDebugUIPlugin.getDefault().getPreferenceStore();
	boolean origPrefValue = preferenceStore.getBoolean(IJDIPreferencesConstants.PREF_SUSPEND_ON_UNCAUGHT_EXCEPTIONS);
	preferenceStore.setValue(IJDIPreferencesConstants.PREF_SUSPEND_ON_UNCAUGHT_EXCEPTIONS, true);
	String typeName = "StepUncaught";
	ILineBreakpoint bp = createLineBreakpoint(15, "StepUncaught");
	bp.setEnabled(true);

	IJavaThread thread = null;
	try {
	thread = launchAndSuspend(typeName);
	IJavaStackFrame stackFrame = (IJavaStackFrame) thread.getTopStackFrame();
	assertEquals("main", stackFrame.getMethodName());

	stepOver(stackFrame);

	stackFrame = (IJavaStackFrame) thread.getTopStackFrame();
	assertEquals("main", stackFrame.getMethodName());
	assertEquals("f() threw", stackFrame.getVariables()[0].getName());

	stepOverToBreakpoint(stackFrame);

	stackFrame = (IJavaStackFrame) thread.getTopStackFrame();
	assertEquals("g", stackFrame.getMethodName());
	}
	finally {
	preferenceStore.setValue(IJDIPreferencesConstants.PREF_SUSPEND_ON_UNCAUGHT_EXCEPTIONS, origPrefValue);
	terminateAndRemove(thread);
	removeAllBreakpoints();
	}
	}

	public void testMethodResultOnMethodExitAndExceptionBreakpoints() throws Exception {
	IPreferenceStore preferenceStore = JDIDebugUIPlugin.getDefault().getPreferenceStore();
	boolean origPrefValue = preferenceStore.getBoolean(IJDIPreferencesConstants.PREF_SUSPEND_ON_UNCAUGHT_EXCEPTIONS);
	preferenceStore.setValue(IJDIPreferencesConstants.PREF_SUSPEND_ON_UNCAUGHT_EXCEPTIONS, true);
	String typeName = "MethodExitAndException";
	IJavaMethodBreakpoint methodExitBreakpoint = createMethodBreakpoint("MethodExitAndException", "f", null, false, true);
	IJavaExceptionBreakpoint exceptionBreakpoint = createExceptionBreakpoint("MyException", true, true);
	methodExitBreakpoint.setEnabled(true);
	exceptionBreakpoint.setEnabled(true);
	IJavaThread thread = null;
	try {
	thread = launchAndSuspend(typeName);
	IJavaStackFrame stackFrame = (IJavaStackFrame) thread.getTopStackFrame();
	assertEquals("f", stackFrame.getMethodName());
	assertEquals("f() is returning", stackFrame.getVariables()[0].getName());

	resume(thread);

	stackFrame = (IJavaStackFrame) thread.getTopStackFrame();
	assertEquals("g", stackFrame.getMethodName());
	assertEquals("g() is throwing", stackFrame.getVariables()[0].getName());
	}
	finally {
	preferenceStore.setValue(IJDIPreferencesConstants.PREF_SUSPEND_ON_UNCAUGHT_EXCEPTIONS, origPrefValue);
	terminateAndRemove(thread);
	removeAllBreakpoints();
	}
	}

	public void testNoReturnValueAfterStepReturnWhichExceedsTimeout() throws Exception {
	IEclipsePreferences node = DefaultScope.INSTANCE.getNode(JDIDebugPlugin.getUniqueIdentifier());
	int origPrefValue = node.getInt(JDIDebugModel.PREF_SHOW_STEP_TIMEOUT, JDIDebugModel.DEF_SHOW_STEP_TIMEOUT);
	node.putInt(JDIDebugModel.PREF_SHOW_STEP_TIMEOUT, -1);

	String typeName = "StepResult1";
	ILineBreakpoint bp1 = createLineBreakpoint(28, "StepResult1");
	bp1.setEnabled(true);

	IJavaThread thread = null;
	try {
	thread = launchToLineBreakpoint(typeName, bp1, false);
	IJavaStackFrame stackFrame = (IJavaStackFrame) thread.getTopStackFrame();
	assertEquals("h", stackFrame.getMethodName());

	thread = stepReturn(stackFrame);
	stackFrame = (IJavaStackFrame) thread.getTopStackFrame();
	assertEquals("g", stackFrame.getMethodName());
	IVariable varInG = stackFrame.getVariables()[0];
	assertEquals("no method return value", varInG.getName());
	assertEquals("(Not observed to speed up the long running step operation)", varInG.getValue().toString());
	} finally {
	node.putInt(JDIDebugModel.PREF_SHOW_STEP_TIMEOUT, origPrefValue);
	terminateAndRemove(thread);
	removeAllBreakpoints();
	}
	}
	}