/********************************************************************** | |
* This file is part of "Object Teams Development Tooling"-Software | |
* | |
* Copyright 2004, 2010 Fraunhofer Gesellschaft, Munich, Germany, | |
* for its Fraunhofer Institute and Computer Architecture and Software | |
* Technology (FIRST), Berlin, Germany and Technical University Berlin, | |
* Germany. | |
* | |
* 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 | |
* $Id: AbstractOTDTDebugTest.java 23492 2010-02-05 22:57:56Z stephan $ | |
* | |
* Please visit http://www.eclipse.org/objectteams for updates and contact. | |
* | |
* Contributors: | |
* Fraunhofer FIRST - Initial API and implementation | |
* Technical University Berlin - Initial API and implementation | |
**********************************************************************/ | |
package org.eclipse.objectteams.otdt.debug.tests; | |
import java.io.File; | |
import java.util.ArrayList; | |
import java.util.HashMap; | |
import java.util.Map; | |
import junit.framework.TestCase; | |
import junit.framework.TestResult; | |
import junit.framework.TestSuite; | |
import org.eclipse.core.resources.IFile; | |
import org.eclipse.core.resources.IMarker; | |
import org.eclipse.core.resources.IProject; | |
import org.eclipse.core.resources.IResource; | |
import org.eclipse.core.resources.ResourcesPlugin; | |
import org.eclipse.core.runtime.CoreException; | |
import org.eclipse.core.runtime.IPath; | |
import org.eclipse.core.runtime.OperationCanceledException; | |
import org.eclipse.core.runtime.Path; | |
import org.eclipse.core.runtime.Platform; | |
import org.eclipse.debug.core.DebugEvent; | |
import org.eclipse.debug.core.DebugException; | |
import org.eclipse.debug.core.DebugPlugin; | |
import org.eclipse.debug.core.IBreakpointManager; | |
import org.eclipse.debug.core.ILaunch; | |
import org.eclipse.debug.core.ILaunchConfiguration; | |
import org.eclipse.debug.core.ILaunchConfigurationType; | |
import org.eclipse.debug.core.ILaunchConfigurationWorkingCopy; | |
import org.eclipse.debug.core.ILaunchManager; | |
import org.eclipse.debug.core.model.IBreakpoint; | |
import org.eclipse.debug.core.model.ILineBreakpoint; | |
import org.eclipse.debug.core.model.IProcess; | |
import org.eclipse.debug.core.model.IThread; | |
import org.eclipse.debug.core.model.IVariable; | |
import org.eclipse.debug.internal.ui.DebugUIPlugin; | |
import org.eclipse.debug.ui.DebugUITools; | |
import org.eclipse.debug.ui.IDebugModelPresentation; | |
import org.eclipse.jdt.core.IClassFile; | |
import org.eclipse.jdt.core.ICompilationUnit; | |
import org.eclipse.jdt.core.IField; | |
import org.eclipse.jdt.core.IJavaElement; | |
import org.eclipse.jdt.core.IJavaModelMarker; | |
import org.eclipse.jdt.core.IJavaProject; | |
import org.eclipse.jdt.core.IMember; | |
import org.eclipse.jdt.core.IMethod; | |
import org.eclipse.jdt.core.IPackageFragment; | |
import org.eclipse.jdt.core.IPackageFragmentRoot; | |
import org.eclipse.jdt.core.ISourceRange; | |
import org.eclipse.jdt.core.IType; | |
import org.eclipse.jdt.core.JavaCore; | |
import org.eclipse.jdt.core.Signature; | |
import org.eclipse.jdt.debug.core.IJavaClassPrepareBreakpoint; | |
import org.eclipse.jdt.debug.core.IJavaDebugTarget; | |
import org.eclipse.jdt.debug.core.IJavaExceptionBreakpoint; | |
import org.eclipse.jdt.debug.core.IJavaLineBreakpoint; | |
import org.eclipse.jdt.debug.core.IJavaMethodBreakpoint; | |
import org.eclipse.jdt.debug.core.IJavaPatternBreakpoint; | |
import org.eclipse.jdt.debug.core.IJavaStackFrame; | |
import org.eclipse.jdt.debug.core.IJavaStratumLineBreakpoint; | |
import org.eclipse.jdt.debug.core.IJavaTargetPatternBreakpoint; | |
import org.eclipse.jdt.debug.core.IJavaThread; | |
import org.eclipse.jdt.debug.core.IJavaVariable; | |
import org.eclipse.jdt.debug.core.IJavaWatchpoint; | |
import org.eclipse.jdt.debug.core.JDIDebugModel; | |
import org.eclipse.jdt.debug.eval.EvaluationManager; | |
import org.eclipse.jdt.debug.eval.IAstEvaluationEngine; | |
import org.eclipse.jdt.debug.eval.IEvaluationListener; | |
import org.eclipse.jdt.debug.eval.IEvaluationResult; | |
import org.eclipse.jdt.debug.testplugin.DebugElementEventWaiter; | |
import org.eclipse.jdt.debug.testplugin.DebugElementKindEventDetailWaiter; | |
import org.eclipse.jdt.debug.testplugin.DebugElementKindEventWaiter; | |
import org.eclipse.jdt.debug.testplugin.DebugEventWaiter; | |
import org.eclipse.jdt.debug.tests.refactoring.MemberParser; | |
import org.eclipse.jdt.internal.debug.ui.BreakpointUtils; | |
import org.eclipse.jdt.internal.debug.ui.IJDIPreferencesConstants; | |
import org.eclipse.jdt.internal.debug.ui.JDIDebugUIPlugin; | |
import org.eclipse.jdt.launching.IJavaLaunchConfigurationConstants; | |
import org.eclipse.jface.dialogs.ErrorDialog; | |
import org.eclipse.jface.preference.IPreferenceStore; | |
import org.eclipse.jface.text.BadPositionCategoryException; | |
import org.eclipse.jface.text.Document; | |
import org.eclipse.jface.text.IDocument; | |
import org.eclipse.jface.text.IRegion; | |
import org.eclipse.jface.text.Position; | |
import org.eclipse.jface.util.SafeRunnable; | |
import org.eclipse.objectteams.otdt.debug.ui.internal.actions.OTToggleBreakpointAdapter; | |
import org.eclipse.ui.console.IConsole; | |
import org.eclipse.ui.console.IHyperlink; | |
import org.eclipse.ui.console.TextConsole; | |
import org.eclipse.ui.internal.console.ConsoleHyperlinkPosition; | |
/** | |
* Tests for launch configurations | |
*/ | |
public abstract class AbstractOTDTDebugTest extends TestCase implements IEvaluationListener { | |
public static final int DEFAULT_TIMEOUT = 30000; | |
public IEvaluationResult fEvaluationResult; | |
public static IJavaProject fJavaProject; | |
/** | |
* The last relevent event set - for example, that caused | |
* a thread to suspend | |
*/ | |
protected DebugEvent[] fEventSet; | |
public AbstractOTDTDebugTest(String name) { | |
super(name); | |
// set error dialog to non-blocking to avoid hanging the UI during test | |
ErrorDialog.AUTOMATED_MODE = true; | |
SafeRunnable.setIgnoreErrors(true); | |
} | |
protected void setUp() throws Exception { | |
super.setUp(); | |
//{ObjectTeams replace ProjectCreationDecorator with own | |
/* orig: | |
if (!ProjectCreationDecorator.isReady()) { | |
new TestSuite(ProjectCreationDecorator.class).run(new TestResult()); | |
} | |
:giro */ | |
if (!OTProjectCreationDecorator.isReady()) { | |
new TestSuite(OTProjectCreationDecorator.class).run(new TestResult()); | |
} | |
//ike+SH} | |
} | |
//{ObjectTeams: get OS-Path for classfiles | |
protected IPath getAbsoluteOSClassFilePath(String typeName) throws Exception { | |
IResource project = getJavaProject().getResource(); | |
IPath projectPath = project.getLocation(); | |
IFile classfile = ((IProject) project).getFile(typeName+".class"); | |
if (classfile!= null) | |
{ | |
// TODO(ike): Workaround, cause file.getAbsolutePath() return path without "src" | |
return new Path(projectPath.toOSString(),java.io.File.separator + "src" + java.io.File.separator + typeName + ".class"); | |
} | |
return null; | |
} | |
//ike} | |
/** | |
* Sets the last relevant event set | |
* | |
* @param set event set | |
*/ | |
protected void setEventSet(DebugEvent[] set) { | |
fEventSet = set; | |
} | |
/** | |
* Returns the last relevant event set | |
* | |
* @return event set | |
*/ | |
protected DebugEvent[] getEventSet() { | |
return fEventSet; | |
} | |
/** | |
* Returns the launch manager | |
* | |
* @return launch manager | |
*/ | |
protected ILaunchManager getLaunchManager() { | |
return DebugPlugin.getDefault().getLaunchManager(); | |
} | |
/** | |
* Returns the breakpoint manager | |
* | |
* @return breakpoint manager | |
*/ | |
protected IBreakpointManager getBreakpointManager() { | |
return DebugPlugin.getDefault().getBreakpointManager(); | |
} | |
/** | |
* Returns the 'DebugTests' project. | |
* | |
* @return the test project | |
*/ | |
protected IJavaProject getJavaProject() { | |
return getJavaProject("DebugTests"); | |
} | |
/** | |
* Returns the Java project with the given name. | |
* | |
* @param name project name | |
* @return the Java project with the given name | |
*/ | |
protected IJavaProject getJavaProject(String name) { | |
IProject project = ResourcesPlugin.getWorkspace().getRoot().getProject(name); | |
return JavaCore.create(project); | |
} | |
/** | |
* Returns the source folder with the given name in the given project. | |
* | |
* @param project | |
* @param name source folder name | |
* @return package fragment root | |
*/ | |
protected IPackageFragmentRoot getPackageFragmentRoot(IJavaProject project, String name) { | |
IProject p = project.getProject(); | |
return project.getPackageFragmentRoot(p.getFolder(name)); | |
} | |
protected IHyperlink getHyperlink(int offset, IDocument doc) { | |
if (offset >= 0 && doc != null) { | |
Position[] positions = null; | |
try { | |
positions = doc.getPositions(ConsoleHyperlinkPosition.HYPER_LINK_CATEGORY); | |
} catch (BadPositionCategoryException ex) { | |
// no links have been added | |
return null; | |
} | |
for (int i = 0; i < positions.length; i++) { | |
Position position = positions[i]; | |
if (offset >= position.getOffset() && offset <= (position.getOffset() + position.getLength())) { | |
return ((ConsoleHyperlinkPosition)position).getHyperLink(); | |
} | |
} | |
} | |
return null; | |
} | |
/** | |
* Launches the given configuration and waits for an event. Returns the | |
* source of the event. If the event is not received, the launch is | |
* terminated and an exception is thrown. | |
* | |
* @param configuration the configuration to launch | |
* @param waiter the event waiter to use | |
* @return Object the source of the event | |
* @exception Exception if the event is never received. | |
*/ | |
protected Object launchAndWait(ILaunchConfiguration configuration, DebugEventWaiter waiter) throws CoreException { | |
return launchAndWait(configuration, waiter, true); | |
} | |
/** | |
* Launches the given configuration and waits for an event. Returns the | |
* source of the event. If the event is not received, the launch is | |
* terminated and an exception is thrown. | |
* | |
* @param configuration the configuration to launch | |
* @param waiter the event waiter to use | |
* @param register whether to register the launch | |
* @return Object the source of the event | |
* @exception Exception if the event is never received. | |
*/ | |
protected Object launchAndWait(ILaunchConfiguration configuration, DebugEventWaiter waiter, boolean register) throws CoreException { | |
ILaunch launch = configuration.launch(ILaunchManager.DEBUG_MODE, null, false, register); | |
Object suspendee= waiter.waitForEvent(); | |
if (suspendee == null) { | |
System.out.println(); | |
System.out.println("Test case: " + this.getName()); | |
System.out.println("Never received event: " + waiter.getEventKindName()); | |
if (launch.isTerminated()) { | |
System.out.println("Process exit value: " + launch.getProcesses()[0].getExitValue()); | |
} | |
IConsole console = DebugUITools.getConsole(launch.getProcesses()[0]); | |
if (console instanceof TextConsole) { | |
TextConsole textConsole = (TextConsole)console; | |
String string = textConsole.getDocument().get(); | |
System.out.println("Console output follows:"); | |
System.out.println(string); | |
} | |
System.out.println(); | |
try { | |
launch.terminate(); | |
} catch (CoreException e) { | |
e.printStackTrace(); | |
fail("Program did not suspend, and unable to terminate launch."); | |
} | |
} | |
setEventSet(waiter.getEventSet()); | |
assertNotNull("Program did not suspend, launch terminated.", suspendee); | |
return suspendee; | |
} | |
/** | |
* Launches the type with the given name, and waits for a | |
* suspend event in that program. Returns the thread in which the suspend | |
* event occurred. | |
* | |
* @param mainTypeName the program to launch | |
* @return thread in which the first suspend event occurred | |
*/ | |
protected IJavaThread launchAndSuspend(String mainTypeName) throws Exception { | |
ILaunchConfiguration config = getLaunchConfiguration(mainTypeName); | |
assertNotNull("Could not locate launch configuration for " + mainTypeName, config); | |
return launchAndSuspend(config); | |
} | |
/** | |
* Launches the given configuration in debug mode, and waits for a | |
* suspend event in that program. Returns the thread in which the suspend | |
* event occurred. | |
* | |
* @param config the configuration to launch | |
* @return thread in which the first suspend event occurred | |
*/ | |
protected IJavaThread launchAndSuspend(ILaunchConfiguration config) throws Exception { | |
DebugEventWaiter waiter= new DebugElementKindEventWaiter(DebugEvent.SUSPEND, IJavaThread.class); | |
waiter.setTimeout(DEFAULT_TIMEOUT); | |
Object suspendee = launchAndWait(config, waiter); | |
return (IJavaThread)suspendee; | |
} | |
/** | |
* Launches the type with the given name, and waits for a breakpoint-caused | |
* suspend event in that program. Returns the thread in which the suspend | |
* event occurred. | |
* | |
* @param mainTypeName the program to launch | |
* @return thread in which the first suspend event occurred | |
*/ | |
protected IJavaThread launchToBreakpoint(String mainTypeName) throws Exception { | |
return launchToBreakpoint(mainTypeName, true); | |
} | |
/** | |
* Launches the type with the given name, and waits for a breakpoint-caused | |
* suspend event in that program. Returns the thread in which the suspend | |
* event occurred. | |
* | |
* @param mainTypeName the program to launch | |
* @param register whether to register the launch | |
* @return thread in which the first suspend event occurred | |
*/ | |
protected IJavaThread launchToBreakpoint(String mainTypeName, boolean register) throws Exception { | |
ILaunchConfiguration config = getLaunchConfiguration(mainTypeName); | |
assertNotNull("Could not locate launch configuration for " + mainTypeName, config); | |
return launchToBreakpoint(config, register); | |
} | |
/** | |
* Launches the given configuration in debug mode, and waits for a breakpoint-caused | |
* suspend event in that program. Returns the thread in which the suspend | |
* event occurred. | |
* | |
* @param config the configuration to launch | |
* @return thread in which the first suspend event occurred | |
*/ | |
protected IJavaThread launchToBreakpoint(ILaunchConfiguration config) throws CoreException { | |
return launchToBreakpoint(config, true); | |
} | |
/** | |
* Launches the given configuration in debug mode, and waits for a breakpoint-caused | |
* suspend event in that program. Returns the thread in which the suspend | |
* event occurred. | |
* | |
* @param config the configuration to launch | |
* @param whether to register the launch | |
* @return thread in which the first suspend event occurred | |
*/ | |
protected IJavaThread launchToBreakpoint(ILaunchConfiguration config, boolean register) throws CoreException { | |
DebugEventWaiter waiter= new DebugElementKindEventDetailWaiter(DebugEvent.SUSPEND, IJavaThread.class, DebugEvent.BREAKPOINT); | |
waiter.setTimeout(DEFAULT_TIMEOUT); | |
Object suspendee= launchAndWait(config, waiter, register); | |
assertTrue("suspendee was not an IJavaThread", suspendee instanceof IJavaThread); | |
return (IJavaThread)suspendee; | |
} | |
/** | |
* Launches the type with the given name, and waits for a terminate | |
* event in that program. Returns the debug target in which the suspend | |
* event occurred. | |
* | |
* @param mainTypeName the program to launch | |
* @param timeout the number of milliseconds to wait for a terminate event | |
* @return debug target in which the terminate event occurred | |
*/ | |
protected IJavaDebugTarget launchAndTerminate(String mainTypeName) throws Exception { | |
ILaunchConfiguration config = getLaunchConfiguration(mainTypeName); | |
assertNotNull("Could not locate launch configuration for " + mainTypeName, config); | |
return launchAndTerminate(config, DEFAULT_TIMEOUT); | |
} | |
/** | |
* Launches the given configuration in debug mode, and waits for a terminate | |
* event in that program. Returns the debug target in which the terminate | |
* event occurred. | |
* | |
* @param config the configuration to launch | |
* @param timeout the number of milliseconds to wait for a terminate event | |
* @return thread in which the first suspend event occurred | |
*/ | |
protected IJavaDebugTarget launchAndTerminate(ILaunchConfiguration config, int timeout) throws Exception { | |
DebugEventWaiter waiter= new DebugElementKindEventWaiter(DebugEvent.TERMINATE, IJavaDebugTarget.class); | |
waiter.setTimeout(timeout); | |
Object terminatee = launchAndWait(config, waiter); | |
assertNotNull("Program did not terminate.", terminatee); | |
assertTrue("terminatee is not an IJavaDebugTarget", terminatee instanceof IJavaDebugTarget); | |
IJavaDebugTarget debugTarget = (IJavaDebugTarget) terminatee; | |
assertTrue("debug target is not terminated", debugTarget.isTerminated() || debugTarget.isDisconnected()); | |
return debugTarget; | |
} | |
/** | |
* Launches the type with the given name, and waits for a line breakpoint suspend | |
* event in that program. Returns the thread in which the suspend | |
* event occurred. | |
* | |
* @param mainTypeName the program to launch | |
* @param bp the breakpoint that should cause a suspend event | |
* @return thread in which the first suspend event occurred | |
*/ | |
protected IJavaThread launchToLineBreakpoint(String mainTypeName, ILineBreakpoint bp) throws Exception { | |
ILaunchConfiguration config = getLaunchConfiguration(mainTypeName); | |
assertNotNull("Could not locate launch configuration for " + mainTypeName, config); | |
return launchToLineBreakpoint(config, bp); | |
} | |
/** | |
* Launches the given configuration in debug mode, and waits for a line breakpoint | |
* suspend event in that program. Returns the thread in which the suspend | |
* event occurred. | |
* | |
* @param config the configuration to launch | |
* @param bp the breakpoint that should cause a suspend event | |
* @return thread in which the first suspend event occurred | |
*/ | |
protected IJavaThread launchToLineBreakpoint(ILaunchConfiguration config, ILineBreakpoint bp) throws Exception { | |
DebugEventWaiter waiter= new DebugElementKindEventDetailWaiter(DebugEvent.SUSPEND, IJavaThread.class, DebugEvent.BREAKPOINT); | |
waiter.setTimeout(DEFAULT_TIMEOUT); | |
Object suspendee= launchAndWait(config, waiter); | |
assertTrue("suspendee was not an IJavaThread", suspendee instanceof IJavaThread); | |
IJavaThread thread = (IJavaThread) suspendee; | |
IBreakpoint hit = getBreakpoint(thread); | |
assertNotNull("suspended, but not by breakpoint", hit); | |
assertTrue("hit un-registered breakpoint", bp.equals(hit)); | |
assertTrue("suspended, but not by line breakpoint", hit instanceof ILineBreakpoint); | |
ILineBreakpoint breakpoint= (ILineBreakpoint) hit; | |
int lineNumber = breakpoint.getLineNumber(); | |
int stackLine = thread.getTopStackFrame().getLineNumber(); | |
assertTrue("line numbers of breakpoint and stack frame do not match", lineNumber == stackLine); | |
return thread; | |
} | |
/** | |
* Resumes the given thread, and waits for another breakpoint-caused suspend event. | |
* Returns the thread in which the suspend event occurs. | |
* | |
* @param thread thread to resume | |
* @return thread in which the first suspend event occurs | |
*/ | |
protected IJavaThread resume(IJavaThread thread) throws Exception { | |
return resume(thread, DEFAULT_TIMEOUT); | |
} | |
/** | |
* Resumes the given thread, and waits for another breakpoint-caused suspend event. | |
* Returns the thread in which the suspend event occurs. | |
* | |
* @param thread thread to resume | |
* @param timeout timeout in ms | |
* @return thread in which the first suspend event occurs | |
*/ | |
protected IJavaThread resume(IJavaThread thread, int timeout) throws Exception { | |
DebugEventWaiter waiter= new DebugElementKindEventDetailWaiter(DebugEvent.SUSPEND, IJavaThread.class, DebugEvent.BREAKPOINT); | |
waiter.setTimeout(timeout); | |
thread.resume(); | |
Object suspendee= waiter.waitForEvent(); | |
setEventSet(waiter.getEventSet()); | |
assertNotNull("Program did not suspend.", suspendee); | |
return (IJavaThread)suspendee; | |
} | |
/** | |
* Resumes the given thread, and waits for a suspend event caused by the specified | |
* line breakpoint. Returns the thread in which the suspend event occurs. | |
* | |
* @param thread thread to resume | |
* @return thread in which the first suspend event occurs | |
*/ | |
protected IJavaThread resumeToLineBreakpoint(IJavaThread resumeThread, ILineBreakpoint bp) throws Exception { | |
DebugEventWaiter waiter= new DebugElementKindEventDetailWaiter(DebugEvent.SUSPEND, IJavaThread.class, DebugEvent.BREAKPOINT); | |
waiter.setTimeout(DEFAULT_TIMEOUT); | |
resumeThread.resume(); | |
Object suspendee= waiter.waitForEvent(); | |
setEventSet(waiter.getEventSet()); | |
assertNotNull("Program did not suspend.", suspendee); | |
assertTrue("suspendee was not an IJavaThread", suspendee instanceof IJavaThread); | |
IJavaThread thread = (IJavaThread) suspendee; | |
IBreakpoint hit = getBreakpoint(thread); | |
assertNotNull("suspended, but not by breakpoint", hit); | |
assertTrue("hit un-registered breakpoint", bp.equals(hit)); | |
assertTrue("suspended, but not by line breakpoint", hit instanceof ILineBreakpoint); | |
ILineBreakpoint breakpoint= (ILineBreakpoint) hit; | |
int lineNumber = breakpoint.getLineNumber(); | |
int stackLine = thread.getTopStackFrame().getLineNumber(); | |
assertTrue("line numbers of breakpoint and stack frame do not match", lineNumber == stackLine); | |
return (IJavaThread)suspendee; | |
} | |
/** | |
* Resumes the given thread, and waits for the debug target | |
* to terminate (i.e. finish/exit the program). | |
* | |
* @param thread thread to resume | |
*/ | |
protected void exit(IJavaThread thread) throws Exception { | |
DebugEventWaiter waiter= new DebugElementKindEventWaiter(DebugEvent.TERMINATE, IProcess.class); | |
waiter.setTimeout(DEFAULT_TIMEOUT); | |
thread.resume(); | |
Object suspendee= waiter.waitForEvent(); | |
setEventSet(waiter.getEventSet()); | |
assertNotNull("Program did not terminate.", suspendee); | |
} | |
/** | |
* Resumes the given thread, and waits the associated debug | |
* target to terminate. | |
* | |
* @param thread thread to resume | |
* @return the terminated debug target | |
*/ | |
protected IJavaDebugTarget resumeAndExit(IJavaThread thread) throws Exception { | |
DebugEventWaiter waiter= new DebugElementEventWaiter(DebugEvent.TERMINATE, thread.getDebugTarget()); | |
waiter.setTimeout(DEFAULT_TIMEOUT); | |
thread.resume(); | |
Object suspendee= waiter.waitForEvent(); | |
setEventSet(waiter.getEventSet()); | |
assertNotNull("Program did not terminate.", suspendee); | |
IJavaDebugTarget target = (IJavaDebugTarget)suspendee; | |
assertTrue("program should have exited", target.isTerminated() || target.isDisconnected()); | |
return target; | |
} | |
/** | |
* Returns the launch configuration for the given main type | |
* | |
* @param mainTypeName program to launch | |
* @see OTProjectCreationDecorator | |
*/ | |
protected ILaunchConfiguration getLaunchConfiguration(String mainTypeName) { | |
IFile file = getJavaProject().getProject().getFolder("launchConfigurations").getFile(mainTypeName + ".launch"); | |
ILaunchConfiguration config = getLaunchManager().getLaunchConfiguration(file); | |
assertTrue("Could not find launch configuration for " + mainTypeName, config.exists()); | |
return config; | |
} | |
protected IResource getBreakpointResource(String typeName) throws Exception { | |
IJavaElement element = getJavaProject().findElement(new Path(typeName + ".java")); | |
IResource resource = element.getCorrespondingResource(); | |
if (resource == null) { | |
resource = getJavaProject().getProject(); | |
} | |
return resource; | |
} | |
protected IResource getBreakpointResource(IType type) throws Exception { | |
if (type == null) { | |
return getJavaProject().getProject(); | |
} | |
IResource resource = type.getResource(); | |
if (resource == null) { | |
resource = getJavaProject().getProject(); | |
} | |
return resource; | |
} | |
/** | |
* Creates and returns a line breakpoint at the given line number in the type with the | |
* given name. | |
* | |
* @param lineNumber line number | |
* @param typeName type name | |
*/ | |
protected IJavaLineBreakpoint createLineBreakpoint(int lineNumber, String typeName) throws Exception { | |
IType type = getType(typeName); | |
return createLineBreakpoint(type, lineNumber); | |
} | |
/** | |
* | |
* @param lineNumber | |
* @param root | |
* @param packageName | |
* @param cuName | |
* @param fullTargetName | |
* @return | |
*/ | |
protected IJavaLineBreakpoint createLineBreakpoint(int lineNumber, String root, String packageName, String cuName, | |
String fullTargetName) throws Exception{ | |
IJavaProject javaProject = getJavaProject(); | |
ICompilationUnit cunit = getCompilationUnit(javaProject, root, packageName, cuName); | |
assertNotNull("did not find requested Compilation Unit", cunit); | |
IType targetType = (IType)(new MemberParser()).getDeepest(cunit,fullTargetName); | |
assertNotNull("did not find requested type", targetType); | |
assertTrue("did not find type to install breakpoint in", targetType.exists()); | |
return createLineBreakpoint(targetType, lineNumber); | |
} | |
/** | |
* Creates a line breakpoint in the given type (may be a top level non public type) | |
* | |
* @param lineNumber line number to create the breakpoint at | |
* @param packageName fully qualified package name containing the type, example "a.b.c" | |
* @param cuName simple name of compilation unit containing the type, example "Something.java" | |
* @param typeName $ qualified type name, example "Something" or "NonPublic" or "Something$Inner" | |
* @return line breakpoint | |
* @throws Exception | |
*/ | |
protected IJavaLineBreakpoint createLineBreakpoint(int lineNumber, String packageName, String cuName, String typeName) throws Exception { | |
IType type = getType(packageName, cuName, typeName); | |
return createLineBreakpoint(type, lineNumber); | |
} | |
/** | |
* Creates a line breakpoint in the given type at the given line number. | |
* | |
* @param type type in which to install the breakpoint | |
* @param lineNumber line number to install the breakpoint at | |
* @return line breakpoint | |
* @throws Exception | |
*/ | |
protected IJavaLineBreakpoint createLineBreakpoint(IType type, int lineNumber) throws Exception { | |
IMember member = null; | |
if (type != null) { | |
IJavaElement sourceElement = null; | |
String source = null; | |
if (type.isBinary()) { | |
IClassFile classFile = type.getClassFile(); | |
source = classFile.getSource(); | |
sourceElement = classFile; | |
} else { | |
ICompilationUnit unit = type.getCompilationUnit(); | |
source = unit.getSource(); | |
sourceElement = unit; | |
} | |
// translate line number to offset | |
if (source != null) { | |
Document document = new Document(source); | |
IRegion region = document.getLineInformation(lineNumber); | |
if (sourceElement instanceof ICompilationUnit) { | |
member = (IMember) ((ICompilationUnit)sourceElement).getElementAt(region.getOffset()); | |
} else { | |
member = (IMember) ((IClassFile)sourceElement).getElementAt(region.getOffset()); | |
} | |
} | |
} | |
Map map = getExtraBreakpointAttributes(member); | |
//{ObjectTeams: special treatment for roles: | |
String typeName = OTToggleBreakpointAdapter.createQualifiedTypeName(type); | |
/* orig: | |
return JDIDebugModel.createLineBreakpoint(getBreakpointResource(type), type.getFullyQualifiedName(), lineNumber, -1, -1, 0, true, map); | |
:giro */ | |
return JDIDebugModel.createLineBreakpoint(getBreakpointResource(type), typeName, lineNumber, -1, -1, 0, true, map); | |
// SH} | |
} | |
/** | |
* Returns the type in the test project based on the given name. The type name may refer to a | |
* top level non public type. | |
* | |
* @param packageName package name, example "a.b.c" | |
* @param cuName simple compilation unit name within the package, example "Something.java" | |
* @param typeName simple dot qualified type name, example "Something" or "NonPublic" or "Something.Inner" | |
* @return associated type or <code>null</code> if none | |
* @throws Exception | |
*/ | |
protected IType getType(String packageName, String cuName, String typeName) throws Exception { | |
IPackageFragment[] packageFragments = getJavaProject().getPackageFragments(); | |
for (int i = 0; i < packageFragments.length; i++) { | |
IPackageFragment fragment = packageFragments[i]; | |
if (fragment.getElementName().equals(packageName)) { | |
ICompilationUnit compilationUnit = fragment.getCompilationUnit(cuName); | |
String[] names = typeName.split("\\$"); | |
IType type = compilationUnit.getType(names[0]); | |
for (int j = 1; j < names.length; j++) { | |
type = type.getType(names[j]); | |
} | |
if (type.exists()) { | |
return type; | |
} | |
} | |
} | |
return null; | |
} | |
/** | |
* Creates and returns a map of java element breakpoint attributes for a breakpoint on the | |
* given java element, or <code>null</code> if none | |
* | |
* @param element java element the breakpoint is associated with | |
* @return map of breakpoint attributes or <code>null</code> | |
* @throws Exception | |
*/ | |
protected Map getExtraBreakpointAttributes(IMember element) throws Exception { | |
if (element != null && element.exists()) { | |
Map map = new HashMap(); | |
ISourceRange sourceRange = element.getSourceRange(); | |
int start = sourceRange.getOffset(); | |
int end = start + sourceRange.getLength(); | |
IType type = null; | |
if (element instanceof IType) { | |
type = (IType) element; | |
} else { | |
type = element.getDeclaringType(); | |
} | |
BreakpointUtils.addJavaBreakpointAttributesWithMemberDetails(map, type, start, end); | |
return map; | |
} | |
return null; | |
} | |
/** | |
* Creates and returns a line breakpoint at the given line number in the type with the | |
* given name and sets the specified condition on the breakpoint. | |
* | |
* @param lineNumber line number | |
* @param typeName type name | |
* @param condition condition | |
*/ | |
protected IJavaLineBreakpoint createConditionalLineBreakpoint(int lineNumber, String typeName, String condition, boolean suspendOnTrue) throws Exception { | |
IJavaLineBreakpoint bp = createLineBreakpoint(lineNumber, typeName); | |
bp.setCondition(condition); | |
bp.setConditionEnabled(true); | |
bp.setConditionSuspendOnTrue(suspendOnTrue); | |
return bp; | |
} | |
/** | |
* Creates and returns a pattern breakpoint at the given line number in the | |
* source file with the given name. | |
* | |
* @param lineNumber line number | |
* @param sourceName name of source file | |
* @param pattern the pattern of the class file name | |
*/ | |
protected IJavaPatternBreakpoint createPatternBreakpoint(int lineNumber, String sourceName, String pattern) throws Exception { | |
return JDIDebugModel.createPatternBreakpoint(getJavaProject().getProject(), sourceName, pattern, lineNumber, -1, -1, 0, true, null); | |
} | |
/** | |
* Creates and returns a target pattern breakpoint at the given line number in the | |
* source file with the given name. | |
* | |
* @param lineNumber line number | |
* @param sourceName name of source file | |
*/ | |
protected IJavaTargetPatternBreakpoint createTargetPatternBreakpoint(int lineNumber, String sourceName) throws Exception { | |
return JDIDebugModel.createTargetPatternBreakpoint(getJavaProject().getProject(), sourceName, lineNumber, -1, -1, 0, true, null); | |
} | |
/** | |
* Creates and returns a stratum breakpoint at the given line number in the | |
* source file with the given name. | |
* | |
* @param lineNumber line number | |
* @param sourceName name of source file | |
* @param stratum the stratum of the source file | |
*/ | |
protected IJavaStratumLineBreakpoint createStratumBreakpoint(int lineNumber, String sourceName, String stratum) throws Exception { | |
return JDIDebugModel.createStratumBreakpoint(getJavaProject().getProject(), stratum, sourceName, null, null, lineNumber, -1, -1, 0, true, null); | |
} | |
/** | |
* Creates and returns a method breakpoint | |
* | |
* @param typeNamePattern type name pattern | |
* @param methodName method name | |
* @param methodSignature method signature or <code>null</code> | |
* @param entry whether to break on entry | |
* @param exit whether to break on exit | |
*/ | |
protected IJavaMethodBreakpoint createMethodBreakpoint(String typeNamePattern, String methodName, String methodSignature, boolean entry, boolean exit) throws Exception { | |
IMethod method= null; | |
IResource resource = getJavaProject().getProject(); | |
if (methodSignature != null && methodName != null) { | |
IType type = getType(typeNamePattern); | |
if (type != null ) { | |
resource = getBreakpointResource(type); | |
method = type.getMethod(methodName, Signature.getParameterTypes(methodSignature)); | |
} | |
} | |
Map map = getExtraBreakpointAttributes(method); | |
return JDIDebugModel.createMethodBreakpoint(resource, typeNamePattern, methodName, methodSignature, entry, exit,false, -1, -1, -1, 0, true, map); | |
} | |
/** | |
* Creates a method breakpoint in a fully specified type (potentially non public). | |
* | |
* @param packageName package name containing type to install breakpoint in, example "a.b.c" | |
* @param cuName simple compilation unit name within package, example "Something.java" | |
* @param typeName $ qualified type name within compilation unit, example "Something" or | |
* "NonPublic" or "Something$Inner" | |
* @param methodName method or <code>null</code> for all methods | |
* @param methodSignature JLS method siganture or <code>null</code> for all methods with the given name | |
* @param entry whether to break on entry | |
* @param exit whether to break on exit | |
* @return method breakpoint | |
* @throws Exception | |
*/ | |
protected IJavaMethodBreakpoint createMethodBreakpoint(String packageName, String cuName, String typeName, String methodName, String methodSignature, boolean entry, boolean exit) throws Exception { | |
IType type = getType(packageName, cuName, typeName); | |
assertNotNull("did not find type to install breakpoint in", type); | |
IMethod method= null; | |
if (methodSignature != null && methodName != null) { | |
if (type != null ) { | |
method = type.getMethod(methodName, Signature.getParameterTypes(methodSignature)); | |
} | |
} | |
Map map = getExtraBreakpointAttributes(method); | |
return JDIDebugModel.createMethodBreakpoint(getBreakpointResource(type), type.getFullyQualifiedName(), methodName, methodSignature, entry, exit,false, -1, -1, -1, 0, true, map); | |
} | |
/** | |
* Creates a MethodBreakPoint on the method specified at the given path. | |
* Syntax: | |
* Type$InnerType$MethodNameAndSignature$AnonymousTypeDeclarationNumber$FieldName | |
* eg:<code> | |
* public class Foo{ | |
* class Inner | |
* { | |
* public void aMethod() | |
* { | |
* Object anon = new Object(){ | |
* int anIntField; | |
* String anonTypeMethod() {return "an Example";} | |
* } | |
* } | |
* } | |
* }</code> | |
* Syntax to get the anonymous toString would be: Foo$Inner$aMethod()V$1$anonTypeMethod()QString | |
* so, createMethodBreakpoint(packageName, cuName, "Foo$Inner$aMethod()V$1$anonTypeMethod()QString",true,false); | |
*/ | |
protected IJavaMethodBreakpoint createMethodBreakpoint(String root, String packageName, String cuName, | |
String fullTargetName, boolean entry, boolean exit) throws Exception { | |
IJavaProject javaProject = getJavaProject(); | |
ICompilationUnit cunit = getCompilationUnit(javaProject, root, packageName, cuName); | |
assertNotNull("did not find requested Compilation Unit", cunit); | |
IMethod targetMethod = (IMethod)(new MemberParser()).getDeepest(cunit,fullTargetName); | |
assertNotNull("did not find requested method", targetMethod); | |
assertTrue("Given method does not exist", targetMethod.exists()); | |
IType methodParent = (IType)targetMethod.getParent();//safe - method's only parent = Type | |
assertNotNull("did not find type to install breakpoint in", methodParent); | |
Map map = getExtraBreakpointAttributes(targetMethod); | |
return JDIDebugModel.createMethodBreakpoint(getBreakpointResource(methodParent), methodParent.getFullyQualifiedName(),targetMethod.getElementName(), targetMethod.getSignature(), entry, exit,false, -1, -1, -1, 0, true, map); | |
} | |
/** | |
* @param cu the Compilation where the target resides | |
* @param target the fullname of the target, as per MemberParser syntax | |
* @return the requested Member | |
*/ | |
protected IMember getMember(ICompilationUnit cu, String target) | |
{ | |
IMember toReturn = (new MemberParser()).getDeepest(cu,target); | |
return toReturn; | |
} | |
/** | |
* Creates and returns a class prepare breakpoint on the type with the given fully qualified name. | |
* | |
* @param typeName type on which to create the breakpoint | |
* @return breakpoint | |
* @throws Exception | |
*/ | |
protected IJavaClassPrepareBreakpoint createClassPrepareBreakpoint(String typeName) throws Exception { | |
return createClassPrepareBreakpoint(getType(typeName)); | |
} | |
/** | |
* Creates and returns a class prepare breakpoint on the type with the given fully qualified name. | |
* | |
* @param typeName type on which to create the breakpoint | |
* @return breakpoint | |
* @throws Exception | |
*/ | |
protected IJavaClassPrepareBreakpoint createClassPrepareBreakpoint(String root, | |
String packageName, String cuName, String fullTargetName) throws Exception { | |
ICompilationUnit cunit = getCompilationUnit(getJavaProject(), root, packageName, cuName); | |
IType type = (IType)getMember(cunit,fullTargetName); | |
assertTrue("Target type not found", type.exists()); | |
return createClassPrepareBreakpoint(type); | |
} | |
/** | |
* Creates a class prepare breakpoint in a fully specified type (potentially non public). | |
* | |
* @param packageName package name containing type to install breakpoint in, example "a.b.c" | |
* @param cuName simple compilation unit name within package, example "Something.java" | |
* @param typeName $ qualified type name within compilation unit, example "Something" or | |
* "NonPublic" or "Something$Inner" | |
*/ | |
protected IJavaClassPrepareBreakpoint createClassPrepareBreakpoint(String packageName, String cuName, String typeName) throws Exception { | |
return createClassPrepareBreakpoint(getType(packageName, cuName, typeName)); | |
} | |
/** | |
* Creates a class prepare breakpoint for the given type | |
* | |
* @param type type | |
* @return class prepare breakpoint | |
* @throws Exception | |
*/ | |
protected IJavaClassPrepareBreakpoint createClassPrepareBreakpoint(IType type) throws Exception { | |
assertNotNull("type not specified for class prepare breakpoint", type); | |
int kind = IJavaClassPrepareBreakpoint.TYPE_CLASS; | |
if (type.isInterface()) { | |
kind = IJavaClassPrepareBreakpoint.TYPE_INTERFACE; | |
} | |
Map map = getExtraBreakpointAttributes(type); | |
return JDIDebugModel.createClassPrepareBreakpoint(getBreakpointResource(type), type.getFullyQualifiedName(), kind, -1, -1, true, map); | |
} | |
/** | |
* Returns the Java model type from the test project with the given name or <code>null</code> | |
* if none. | |
* | |
* @param typeName | |
* @return type or <code>null</code> | |
* @throws Exception | |
*/ | |
protected IType getType(String typeName) throws Exception { | |
return getJavaProject().findType(typeName); | |
} | |
/** | |
* Creates and returns a watchpoint | |
* | |
* @param typeNmae type name | |
* @param fieldName field name | |
* @param access whether to suspend on field access | |
* @param modification whether to suspend on field modification | |
*/ | |
protected IJavaWatchpoint createWatchpoint(String typeName, String fieldName, boolean access, boolean modification) throws Exception { | |
IType type = getType(typeName); | |
return createWatchpoint(type, fieldName, access, modification); | |
} | |
/** | |
* Creates and returns an exception breakpoint | |
* | |
* @param exName exception name | |
* @param caught whether to suspend in caught locations | |
* @param uncaught whether to suspend in uncaught locations | |
*/ | |
protected IJavaExceptionBreakpoint createExceptionBreakpoint(String exName, boolean caught, boolean uncaught) throws Exception { | |
IType type = getType(exName); | |
Map map = getExtraBreakpointAttributes(type); | |
return JDIDebugModel.createExceptionBreakpoint(getBreakpointResource(type),exName, caught, uncaught, false, true, map); | |
} | |
/** | |
* Creates and returns a watchpoint | |
* | |
* @param typeNmae type name | |
* @param fieldName field name | |
* @param access whether to suspend on field access | |
* @param modification whether to suspend on field modification | |
*/ | |
/* protected IJavaWatchpoint createWatchpoint(String typeName, String fieldName, boolean access, boolean modification) throws Exception { | |
IType type = getType(typeName); | |
return createWatchpoint(type, fieldName, access, modification); | |
}*/ | |
/** | |
* Creates a WatchPoint on the field specified at the given path. | |
* Will create watchpoints on fields within anonymous types, inner types, | |
* local (non-public) types, and public types. | |
* @param root | |
* @param packageName package name containing type to install breakpoint in, example "a.b.c" | |
* @param cuName simple compilation unit name within package, example "Something.java" | |
* @param fullTargetName - see below | |
* @param access whether to suspend on access | |
* @param modification whether to suspend on modification | |
* @return a watchpoint | |
* @throws Exception | |
* @throws CoreException | |
* | |
* @see | |
* </code> | |
* Syntax example: | |
* Type$InnerType$MethodNameAndSignature$AnonymousTypeDeclarationNumber$FieldName | |
* eg:<code> | |
* public class Foo{ | |
* class Inner | |
* { | |
* public void aMethod() | |
* { | |
* Object anon = new Object(){ | |
* int anIntField; | |
* String anonTypeMethod() {return "an Example";} | |
* } | |
* } | |
* } | |
* }</code> | |
* To get the anonymous toString, syntax of fullTargetName would be: <code>Foo$Inner$aMethod()V$1$anIntField</code> | |
*/ | |
protected IJavaWatchpoint createNestedTypeWatchPoint(String root, String packageName, String cuName, | |
String fullTargetName, boolean access, boolean modification) throws Exception, CoreException { | |
ICompilationUnit cunit = getCompilationUnit(getJavaProject(), root, packageName, cuName); | |
IField field = (IField)getMember(cunit,fullTargetName); | |
assertNotNull("Path to field is not valid", field); | |
assertTrue("Field is not valid", field.exists()); | |
IType type = (IType)field.getParent(); | |
return createWatchpoint(type, field.getElementName(), access, modification); | |
} | |
/** | |
* Creates a watchpoint in a fully specified type (potentially non public). | |
* | |
* @param packageName package name containing type to install breakpoint in, example "a.b.c" | |
* @param cuName simple compilation unit name within package, example "Something.java" | |
* @param typeName $ qualified type name within compilation unit, example "Something" or | |
* "NonPublic" or "Something$Inner" | |
* @param fieldName name of the field | |
* @param access whether to suspend on access | |
* @param modification whether to suspend on modification | |
*/ | |
protected IJavaWatchpoint createWatchpoint(String packageName, String cuName, String typeName, String fieldName, boolean access, boolean modification) throws Exception { | |
IType type = getType(packageName, cuName, typeName); | |
return createWatchpoint(type, fieldName, access, modification); | |
} | |
/** | |
* Creates a watchpoint on the specified field. | |
* | |
* @param type type containing the field | |
* @param fieldName name of the field | |
* @param access whether to suspend on access | |
* @param modification whether to suspend on modification | |
* @return watchpoint | |
* @throws Exception | |
*/ | |
protected IJavaWatchpoint createWatchpoint(IType type, String fieldName, boolean access, boolean modification) throws Exception, CoreException { | |
assertNotNull("type not specified for watchpoint", type); | |
IField field = type.getField(fieldName); | |
Map map = getExtraBreakpointAttributes(field); | |
IJavaWatchpoint wp = JDIDebugModel.createWatchpoint(getBreakpointResource(type), type.getFullyQualifiedName(), fieldName, -1, -1, -1, 0, true, map); | |
wp.setAccess(access); | |
wp.setModification(modification); | |
return wp; | |
} | |
/** | |
* Terminates the given thread and removes its launch | |
*/ | |
protected void terminateAndRemove(IJavaThread thread) { | |
if (thread != null) { | |
terminateAndRemove((IJavaDebugTarget)thread.getDebugTarget()); | |
} | |
} | |
/** | |
* Terminates the given debug target and removes its launch. | |
* | |
* NOTE: all breakpoints are removed, all threads are resumed, and then | |
* the target is terminated. This avoids defunct processes on linux. | |
*/ | |
protected void terminateAndRemove(IJavaDebugTarget debugTarget) { | |
ILaunch launch = debugTarget.getLaunch(); | |
if (debugTarget != null && !(debugTarget.isTerminated() || debugTarget.isDisconnected())) { | |
IPreferenceStore jdiUIPreferences = JDIDebugUIPlugin.getDefault().getPreferenceStore(); | |
jdiUIPreferences.setValue(IJDIPreferencesConstants.PREF_SUSPEND_ON_UNCAUGHT_EXCEPTIONS, false); | |
DebugEventWaiter waiter = new DebugElementEventWaiter(DebugEvent.TERMINATE, debugTarget); | |
try { | |
removeAllBreakpoints(); | |
IThread[] threads = debugTarget.getThreads(); | |
for (int i = 0; i < threads.length; i++) { | |
IThread thread = threads[i]; | |
try { | |
if (thread.isSuspended()) { | |
thread.resume(); | |
} | |
} catch (CoreException e) { | |
} | |
} | |
debugTarget.getDebugTarget().terminate(); | |
waiter.waitForEvent(); | |
} catch (CoreException e) { | |
} | |
} | |
getLaunchManager().removeLaunch(launch); | |
// ensure event queue is flushed | |
DebugEventWaiter waiter = new DebugElementEventWaiter(DebugEvent.MODEL_SPECIFIC, this); | |
DebugPlugin.getDefault().fireDebugEventSet(new DebugEvent[]{new DebugEvent(this, DebugEvent.MODEL_SPECIFIC)}); | |
waiter.waitForEvent(); | |
} | |
/** | |
* Deletes all existing breakpoints | |
*/ | |
protected void removeAllBreakpoints() { | |
IBreakpoint[] bps = getBreakpointManager().getBreakpoints(); | |
try { | |
getBreakpointManager().removeBreakpoints(bps, true); | |
} catch (CoreException e) { | |
} | |
} | |
/** | |
* Returns the first breakpoint the given thread is suspended | |
* at, or <code>null</code> if none. | |
* | |
* @return the first breakpoint the given thread is suspended | |
* at, or <code>null</code> if none | |
*/ | |
protected IBreakpoint getBreakpoint(IThread thread) { | |
IBreakpoint[] bps = thread.getBreakpoints(); | |
if (bps.length > 0) { | |
return bps[0]; | |
} | |
return null; | |
} | |
/** | |
* Evaluates the given snippet in the context of the given stack frame and returns | |
* the result. | |
* | |
* @param snippet code snippet | |
* @param frame stack frame context | |
* @return evaluation result | |
*/ | |
protected IEvaluationResult evaluate(String snippet, IJavaStackFrame frame) throws Exception { | |
DebugEventWaiter waiter= new DebugElementKindEventWaiter(DebugEvent.SUSPEND, IJavaThread.class); | |
waiter.setTimeout(DEFAULT_TIMEOUT); | |
IAstEvaluationEngine engine = EvaluationManager.newAstEvaluationEngine(getJavaProject(), (IJavaDebugTarget)frame.getDebugTarget()); | |
engine.evaluate(snippet, frame, this, DebugEvent.EVALUATION, true); | |
Object suspendee= waiter.waitForEvent(); | |
setEventSet(waiter.getEventSet()); | |
assertNotNull("Program did not suspend.", suspendee); | |
engine.dispose(); | |
return fEvaluationResult; | |
} | |
/** | |
* @see IEvaluationListener#evaluationComplete(IEvaluationResult) | |
*/ | |
public void evaluationComplete(IEvaluationResult result) { | |
fEvaluationResult = result; | |
} | |
/** | |
* Performs a step over in the given stack frame and returns when complete. | |
* | |
* @param frame stack frame to step in | |
*/ | |
protected IJavaThread stepOver(IJavaStackFrame frame) throws Exception { | |
DebugEventWaiter waiter= new DebugElementKindEventDetailWaiter(DebugEvent.SUSPEND, IJavaThread.class, DebugEvent.STEP_END); | |
waiter.setTimeout(DEFAULT_TIMEOUT); | |
frame.stepOver(); | |
Object suspendee= waiter.waitForEvent(); | |
setEventSet(waiter.getEventSet()); | |
assertNotNull("Program did not suspend.", suspendee); | |
return (IJavaThread) suspendee; | |
} | |
/** | |
* Performs a step into in the given stack frame and returns when complete. | |
* | |
* @param frame stack frame to step in | |
*/ | |
protected IJavaThread stepInto(IJavaStackFrame frame) throws Exception { | |
DebugEventWaiter waiter= new DebugElementKindEventDetailWaiter(DebugEvent.SUSPEND, IJavaThread.class, DebugEvent.STEP_END); | |
waiter.setTimeout(DEFAULT_TIMEOUT); | |
frame.stepInto(); | |
Object suspendee= waiter.waitForEvent(); | |
setEventSet(waiter.getEventSet()); | |
assertNotNull("Program did not suspend.", suspendee); | |
return (IJavaThread) suspendee; | |
} | |
/** | |
* Performs a step return in the given stack frame and returns when complete. | |
* | |
* @param frame stack frame to step return from | |
*/ | |
protected IJavaThread stepReturn(IJavaStackFrame frame) throws Exception { | |
DebugEventWaiter waiter= new DebugElementKindEventDetailWaiter(DebugEvent.SUSPEND, IJavaThread.class, DebugEvent.STEP_END); | |
waiter.setTimeout(DEFAULT_TIMEOUT); | |
frame.stepReturn(); | |
Object suspendee= waiter.waitForEvent(); | |
setEventSet(waiter.getEventSet()); | |
assertNotNull("Program did not suspend.", suspendee); | |
return (IJavaThread) suspendee; | |
} | |
/** | |
* Performs a step into with filters in the given stack frame and returns when | |
* complete. | |
* | |
* @param frame stack frame to step in | |
*/ | |
protected IJavaThread stepIntoWithFilters(IJavaStackFrame frame) throws Exception { | |
DebugEventWaiter waiter= new DebugElementKindEventWaiter(DebugEvent.SUSPEND, IJavaThread.class); | |
waiter.setTimeout(DEFAULT_TIMEOUT); | |
// turn filters on | |
try { | |
DebugUITools.setUseStepFilters(true); | |
frame.stepInto(); | |
} finally { | |
// turn filters off | |
DebugUITools.setUseStepFilters(false); | |
} | |
Object suspendee= waiter.waitForEvent(); | |
setEventSet(waiter.getEventSet()); | |
assertNotNull("Program did not suspend.", suspendee); | |
return (IJavaThread) suspendee; | |
} | |
/** | |
* Performs a step return with filters in the given stack frame and returns when | |
* complete. | |
* | |
* @param frame stack frame to step in | |
*/ | |
protected IJavaThread stepReturnWithFilters(IJavaStackFrame frame) throws Exception { | |
DebugEventWaiter waiter= new DebugElementKindEventWaiter(DebugEvent.SUSPEND, IJavaThread.class); | |
waiter.setTimeout(DEFAULT_TIMEOUT); | |
// turn filters on | |
try { | |
DebugUITools.setUseStepFilters(true); | |
frame.stepReturn(); | |
} finally { | |
// turn filters off | |
DebugUITools.setUseStepFilters(false); | |
} | |
Object suspendee= waiter.waitForEvent(); | |
setEventSet(waiter.getEventSet()); | |
assertNotNull("Program did not suspend.", suspendee); | |
return (IJavaThread) suspendee; | |
} | |
/** | |
* Performs a step over with filters in the given stack frame and returns when | |
* complete. | |
* | |
* @param frame stack frame to step in | |
*/ | |
protected IJavaThread stepOverWithFilters(IJavaStackFrame frame) throws Exception { | |
DebugEventWaiter waiter= new DebugElementKindEventWaiter(DebugEvent.SUSPEND, IJavaThread.class); | |
waiter.setTimeout(DEFAULT_TIMEOUT); | |
// turn filters on | |
try { | |
DebugUITools.setUseStepFilters(true); | |
frame.stepOver(); | |
} finally { | |
// turn filters off | |
DebugUITools.setUseStepFilters(false); | |
} | |
Object suspendee= waiter.waitForEvent(); | |
setEventSet(waiter.getEventSet()); | |
assertNotNull("Program did not suspend.", suspendee); | |
return (IJavaThread) suspendee; | |
} | |
/** | |
* Returns the compilation unit with the given name. | |
* | |
* @param project the project containing the CU | |
* @param root the name of the source folder in the project | |
* @param pkg the name of the package (empty string for default package) | |
* @param name the name of the CU (ex. Something.java) | |
* @return compilation unit | |
*/ | |
protected ICompilationUnit getCompilationUnit(IJavaProject project, String root, String pkg, String name) { | |
IProject p = project.getProject(); | |
IResource r = p.getFolder(root); | |
return project.getPackageFragmentRoot(r).getPackageFragment(pkg).getCompilationUnit(name); | |
} | |
/** | |
* Wait for builds to complete | |
*/ | |
public static void waitForBuild() { | |
boolean wasInterrupted = false; | |
do { | |
try { | |
Platform.getJobManager().join(ResourcesPlugin.FAMILY_AUTO_BUILD, null); | |
Platform.getJobManager().join(ResourcesPlugin.FAMILY_MANUAL_BUILD, null); | |
wasInterrupted = false; | |
} catch (OperationCanceledException e) { | |
e.printStackTrace(); | |
} catch (InterruptedException e) { | |
wasInterrupted = true; | |
} | |
} while (wasInterrupted); | |
} | |
protected IJavaVariable findVariable(IJavaStackFrame frame, String name) throws DebugException { | |
IJavaVariable variable = frame.findVariable(name); | |
if (variable == null) { | |
// dump visible variables | |
IDebugModelPresentation presentation = DebugUIPlugin.getModelPresentation(); | |
System.out.println("Could not find variable '" + name + "' in frame: " + presentation.getText(frame)); | |
System.out.println("Visible variables are:"); | |
IVariable[] variables = frame.getVariables(); | |
for (int i = 0; i < variables.length; i++) { | |
IVariable variable2 = variables[i]; | |
System.out.println("\t" + presentation.getText(variable2)); | |
} | |
if (!frame.isStatic()) { | |
variables = frame.getThis().getVariables(); | |
for (int i = 0; i < variables.length; i++) { | |
IVariable variable2 = variables[i]; | |
System.out.println("\t" + presentation.getText(variable2)); | |
} | |
} | |
} | |
return variable; | |
} | |
protected boolean isFileSystemCaseSensitive() { | |
return Platform.OS_MACOSX.equals(Platform.getOS()) ? false : new File("a").compareTo(new File("A")) != 0; //$NON-NLS-1$ //$NON-NLS-2$ | |
} | |
/** | |
* Creates a shared launch configuration for the type with the given name. | |
*/ | |
protected void createLaunchConfiguration(String mainTypeName) throws Exception { | |
ILaunchConfigurationType type = getLaunchManager().getLaunchConfigurationType(IJavaLaunchConfigurationConstants.ID_JAVA_APPLICATION); | |
ILaunchConfigurationWorkingCopy config = type.newInstance(getJavaProject().getProject().getFolder("launchConfigurations"), mainTypeName); | |
config.setAttribute(IJavaLaunchConfigurationConstants.ATTR_MAIN_TYPE_NAME, mainTypeName); | |
config.setAttribute(IJavaLaunchConfigurationConstants.ATTR_PROJECT_NAME, getJavaProject().getElementName()); | |
// use 'java' instead of 'javaw' to launch tests (javaw is problematic | |
// on JDK1.4.2) | |
Map map = new HashMap(1); | |
map.put(IJavaLaunchConfigurationConstants.ATTR_JAVA_COMMAND, "java"); | |
config.setAttribute(IJavaLaunchConfigurationConstants.ATTR_VM_INSTALL_TYPE_SPECIFIC_ATTRS_MAP, map); | |
config.doSave(); | |
} | |
/** | |
* Return all problems with the specified element. | |
* From jdt.core.tests.builder.TestingEnvironment | |
*/ | |
public Problem[] getProblemsFor(IResource resource){ | |
return getProblemsFor(resource, null); | |
} | |
/** | |
* Return all problems with the specified element. | |
* From jdt.core.tests.builder.TestingEnvironment | |
*/ | |
public Problem[] getProblemsFor(IResource resource, String additionalMarkerType){ | |
try { | |
ArrayList problems = new ArrayList(); | |
IMarker[] markers = resource.findMarkers(IJavaModelMarker.JAVA_MODEL_PROBLEM_MARKER, true, IResource.DEPTH_INFINITE); | |
for (int i = 0; i < markers.length; i++) | |
problems.add(new Problem(markers[i])); | |
markers = resource.findMarkers(IJavaModelMarker.BUILDPATH_PROBLEM_MARKER, true, IResource.DEPTH_INFINITE); | |
for (int i = 0; i < markers.length; i++) | |
problems.add(new Problem(markers[i])); | |
markers = resource.findMarkers(IJavaModelMarker.TASK_MARKER, true, IResource.DEPTH_INFINITE); | |
for (int i = 0; i < markers.length; i++) | |
problems.add(new Problem(markers[i])); | |
if (additionalMarkerType != null) { | |
markers = resource.findMarkers(additionalMarkerType, true, IResource.DEPTH_INFINITE); | |
for (int i = 0; i < markers.length; i++) | |
problems.add(new Problem(markers[i])); | |
} | |
Problem[] result = new Problem[problems.size()]; | |
problems.toArray(result); | |
return result; | |
} catch(CoreException e){ | |
// ignore | |
} | |
return new Problem[0]; | |
} | |
} | |