/*******************************************************************************
* Copyright (c) 2000, 2016 IBM Corporation 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
*
* This is an implementation of an early-draft specification developed under the Java
* Community Process (JCP) and is made available for testing and evaluation purposes
* only. The code is not compatible with any specification of the JCP.
*
* Contributors:
* IBM Corporation - initial API and implementation
* Jesper Steen Møller - bug 422029: [1.8] Enable debug evaluation support for default methods
* Jesper Steen Møller - bug 426903: [1.8] Cannot evaluate super call to default method
* Jesper Steen Møller - bug 341232
*******************************************************************************/
package org.eclipse.jdt.debug.tests;
import java.io.File;
import java.io.PrintWriter;
import java.io.StringWriter;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import org.eclipse.core.resources.IFile;
import org.eclipse.core.resources.IFolder;
import org.eclipse.core.resources.IMarkerDelta;
import org.eclipse.core.resources.IProject;
import org.eclipse.core.resources.IResource;
import org.eclipse.core.resources.IncrementalProjectBuilder;
import org.eclipse.core.resources.ResourcesPlugin;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IPath;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.OperationCanceledException;
import org.eclipse.core.runtime.Path;
import org.eclipse.core.runtime.Platform;
import org.eclipse.core.runtime.Status;
import org.eclipse.core.runtime.jobs.Job;
import org.eclipse.core.runtime.preferences.IEclipsePreferences;
import org.eclipse.core.runtime.preferences.InstanceScope;
import org.eclipse.debug.core.DebugEvent;
import org.eclipse.debug.core.DebugException;
import org.eclipse.debug.core.DebugPlugin;
import org.eclipse.debug.core.IBreakpointListener;
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.ILaunchDelegate;
import org.eclipse.debug.core.ILaunchManager;
import org.eclipse.debug.core.model.IBreakpoint;
import org.eclipse.debug.core.model.IDebugTarget;
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.IValue;
import org.eclipse.debug.core.model.IVariable;
import org.eclipse.debug.internal.core.LaunchDelegate;
import org.eclipse.debug.internal.core.LaunchManager;
import org.eclipse.debug.internal.ui.DebugUIPlugin;
import org.eclipse.debug.internal.ui.IInternalDebugUIConstants;
import org.eclipse.debug.internal.ui.breakpoints.provisional.IBreakpointOrganizer;
import org.eclipse.debug.internal.ui.launchConfigurations.LaunchConfigurationManager;
import org.eclipse.debug.internal.ui.launchConfigurations.LaunchConfigurationPresentationManager;
import org.eclipse.debug.internal.ui.launchConfigurations.LaunchConfigurationsDialog;
import org.eclipse.debug.internal.ui.launchConfigurations.LaunchShortcutExtension;
import org.eclipse.debug.internal.ui.preferences.IDebugPreferenceConstants;
import org.eclipse.debug.internal.ui.views.breakpoints.BreakpointOrganizerManager;
import org.eclipse.debug.internal.ui.views.console.ProcessConsole;
import org.eclipse.debug.ui.DebugUITools;
import org.eclipse.debug.ui.IDebugModelPresentation;
import org.eclipse.debug.ui.IDebugUIConstants;
import org.eclipse.debug.ui.IDebugView;
import org.eclipse.debug.ui.ILaunchConfigurationDialog;
import org.eclipse.debug.ui.ILaunchConfigurationTabGroup;
import org.eclipse.debug.ui.actions.ToggleBreakpointAction;
import org.eclipse.jdt.core.IAccessRule;
import org.eclipse.jdt.core.IBuffer;
import org.eclipse.jdt.core.IClassFile;
import org.eclipse.jdt.core.IClasspathAttribute;
import org.eclipse.jdt.core.IClasspathEntry;
import org.eclipse.jdt.core.ICompilationUnit;
import org.eclipse.jdt.core.IField;
import org.eclipse.jdt.core.IJavaElement;
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.JavaModelException;
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.IJavaObject;
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.testplugin.JavaProjectHelper;
import org.eclipse.jdt.debug.testplugin.JavaTestPlugin;
import org.eclipse.jdt.debug.tests.core.LiteralTests17;
import org.eclipse.jdt.debug.tests.refactoring.MemberParser;
import org.eclipse.jdt.debug.ui.IJavaDebugUIConstants;
import org.eclipse.jdt.internal.debug.core.model.JDIDebugTarget;
import org.eclipse.jdt.internal.debug.eval.ast.engine.ASTEvaluationEngine;
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.jdt.launching.IVMInstall;
import org.eclipse.jdt.launching.JavaRuntime;
import org.eclipse.jdt.launching.environments.IExecutionEnvironment;
import org.eclipse.jface.dialogs.ErrorDialog;
import org.eclipse.jface.dialogs.MessageDialogWithToggle;
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.text.source.IVerticalRulerInfo;
import org.eclipse.jface.util.SafeRunnable;
import org.eclipse.swt.widgets.Display;
import org.eclipse.ui.IEditorPart;
import org.eclipse.ui.IWorkbench;
import org.eclipse.ui.IWorkbenchPage;
import org.eclipse.ui.IWorkbenchPreferenceConstants;
import org.eclipse.ui.IWorkbenchWindow;
import org.eclipse.ui.PartInitException;
import org.eclipse.ui.PlatformUI;
import org.eclipse.ui.console.IConsole;
import org.eclipse.ui.console.IHyperlink;
import org.eclipse.ui.console.TextConsole;
import org.eclipse.ui.ide.IDE;
import org.eclipse.ui.internal.WorkbenchWindow;
import org.eclipse.ui.internal.console.ConsoleHyperlinkPosition;
import org.eclipse.ui.internal.util.PrefUtil;
import org.eclipse.ui.intro.IIntroManager;
import org.eclipse.ui.intro.IIntroPart;
import org.eclipse.ui.progress.UIJob;
import org.eclipse.ui.progress.WorkbenchJob;
import org.osgi.service.prefs.BackingStoreException;
import com.sun.jdi.InternalException;
import junit.framework.TestCase;
/**
* Tests for launch configurations
*/
@SuppressWarnings("deprecation")
public abstract class AbstractDebugTest extends TestCase implements IEvaluationListener {
public static final String MULTI_OUTPUT_PROJECT_NAME = "MultiOutput";
public static final String BOUND_EE_PROJECT_NAME = "BoundEE";
public static final String ONE_FOUR_PROJECT_NAME = "DebugTests";
public static final String ONE_FOUR_PROJECT_CLOSED_NAME = "ClosedDebugTests";
public static final String ONE_FIVE_PROJECT_NAME = "OneFive";
public static final String ONE_SEVEN_PROJECT_NAME = "OneSeven";
public static final String ONE_EIGHT_PROJECT_NAME = "OneEight";
public static final String BOUND_JRE_PROJECT_NAME = "BoundJRE";
public static final String CLONE_SUFFIX = "Clone";
final String[] LAUNCH_CONFIG_NAMES_1_4 = {"LargeSourceFile", "LotsOfFields", "Breakpoints", "InstanceVariablesTests", "LocalVariablesTests", "LocalVariableTests2", "StaticVariablesTests",
"DropTests", "ThrowsNPE", "ThrowsException", "org.eclipse.debug.tests.targets.Watchpoint",
"org.eclipse.debug.tests.targets.BreakpointsLocationBug344984", "org.eclipse.debug.tests.targets.CallLoop", "A",
"HitCountLooper", "CompileError", "MultiThreadedLoop", "HitCountException", "MultiThreadedException", "MultiThreadedList", "MethodLoop", "StepFilterOne",
"StepFilterFour", "EvalArrayTests", "EvalSimpleTests", "EvalTypeTests", "EvalNestedTypeTests", "EvalTypeHierarchyTests",
"EvalAnonymousClassVariableTests", "WorkingDirectoryTest",
"OneToTen", "OneToTenPrint", "FloodConsole", "ConditionalStepReturn", "VariableChanges", "DefPkgReturnType", "InstanceFilterObject", "org.eclipse.debug.tests.targets.CallStack",
"org.eclipse.debug.tests.targets.ThreadStack", "org.eclipse.debug.tests.targets.HcrClass", "org.eclipse.debug.tests.targets.StepIntoSelectionClass",
"WatchItemTests", "ArrayTests", "ByteArrayTests", "PerfLoop", "Console80Chars", "ConsoleStackTrace", "ConsoleVariableLineLength", "StackTraces",
"ConsoleInput", "PrintConcatenation", "VariableDetails", "org.eclipse.debug.tests.targets.ArrayDetailTests", "ArrayDetailTestsDef", "ForceReturnTests",
"ForceReturnTestsTwo", "LogicalStructures", "BreakpointListenerTest", "LaunchHistoryTest", "LaunchHistoryTest2", "RunnableAppletImpl", "java6.AllInstancesTests",
"bug329294", "bug401270", "org.eclipse.debug.tests.targets.HcrClass2", "org.eclipse.debug.tests.targets.HcrClass3", "org.eclipse.debug.tests.targets.HcrClass4",
"org.eclipse.debug.tests.targets.HcrClass5", "org.eclipse.debug.tests.targets.HcrClass6", "org.eclipse.debug.tests.targets.HcrClass7", "org.eclipse.debug.tests.targets.HcrClass8",
"org.eclipse.debug.tests.targets.HcrClass9", "TestContributedStepFilterClass", "TerminateAll_01", "TerminateAll_02", "StepResult1",
"StepResult2", "StepResult3", "TriggerPoint_01" };
final String[] LAUNCH_CONFIG_NAMES_1_8 = {"LargeSourceFile"};
/**
* the default timeout
*/
public static final int DEFAULT_TIMEOUT = 30000;
//constants
protected static final String JAVA = "java"; //$NON-NLS-1$
protected static final String JAVA_EXTENSION = ".java"; //$NON-NLS-1$
protected static final String LAUNCHCONFIGURATIONS = "launchConfigurations"; //$NON-NLS-1$
protected static final String LAUNCH_EXTENSION = ".launch"; //$NON-NLS-1$
protected static final String LOCAL_JAVA_APPLICATION_TYPE_ID = "org.eclipse.jdt.launching.localJavaApplication"; //$NON-NLS-1$
protected static final String JAVA_LAUNCH_SHORTCUT_ID = "org.eclipse.jdt.debug.ui.localJavaShortcut"; //$NON-NLS-1$
protected static final String TEST_LAUNCH_SHORTCUT = "org.eclipse.jdt.debug.tests.testShortCut";
/**
* an evaluation result
*/
public IEvaluationResult fEvaluationResult;
/**
* The last relevant event set - for example, that caused
* a thread to suspend
*/
protected DebugEvent[] fEventSet;
private static boolean loadedPrefs = false;
private static boolean loaded14 = false;
private static boolean loaded15 = false;
private static boolean loaded17 = false;
private static boolean loaded18 = false;
private static boolean loadedEE = false;
private static boolean loadedJRE = false;
private static boolean loadedMulti = false;
private static boolean welcomeClosed = false;
/**
* Constructor
* @param name
*/
public AbstractDebugTest(String name) {
super(name);
// set error dialog to non-blocking to avoid hanging the UI during test
ErrorDialog.AUTOMATED_MODE = true;
SafeRunnable.setIgnoreErrors(true);
}
@Override
protected void setUp() throws Exception {
TestUtil.log(IStatus.INFO, getName(), "setUp");
super.setUp();
setPreferences();
IProject pro = ResourcesPlugin.getWorkspace().getRoot().getProject(ONE_FOUR_PROJECT_NAME);
loaded14 = pro.exists();
pro = ResourcesPlugin.getWorkspace().getRoot().getProject(ONE_FIVE_PROJECT_NAME);
loaded15 = pro.exists();
pro = ResourcesPlugin.getWorkspace().getRoot().getProject(ONE_SEVEN_PROJECT_NAME);
loaded17 = pro.exists();
pro = ResourcesPlugin.getWorkspace().getRoot().getProject(ONE_EIGHT_PROJECT_NAME);
loaded18 = pro.exists();
pro = ResourcesPlugin.getWorkspace().getRoot().getProject(BOUND_JRE_PROJECT_NAME);
loadedJRE = pro.exists();
pro = ResourcesPlugin.getWorkspace().getRoot().getProject(BOUND_EE_PROJECT_NAME);
loadedEE = pro.exists();
pro = ResourcesPlugin.getWorkspace().getRoot().getProject(MULTI_OUTPUT_PROJECT_NAME);
loadedMulti = pro.exists();
assertWelcomeScreenClosed();
}
synchronized void setPreferences() throws BackingStoreException {
if(!loadedPrefs) {
IPreferenceStore debugUIPreferences = DebugUIPlugin.getDefault().getPreferenceStore();
// Don't prompt for perspective switching
debugUIPreferences.setValue(IInternalDebugUIConstants.PREF_SWITCH_PERSPECTIVE_ON_SUSPEND, MessageDialogWithToggle.ALWAYS);
debugUIPreferences.setValue(IInternalDebugUIConstants.PREF_SWITCH_TO_PERSPECTIVE, MessageDialogWithToggle.ALWAYS);
debugUIPreferences.setValue(IInternalDebugUIConstants.PREF_RELAUNCH_IN_DEBUG_MODE, MessageDialogWithToggle.NEVER);
debugUIPreferences.setValue(IInternalDebugUIConstants.PREF_WAIT_FOR_BUILD, MessageDialogWithToggle.ALWAYS);
debugUIPreferences.setValue(IInternalDebugUIConstants.PREF_CONTINUE_WITH_COMPILE_ERROR, MessageDialogWithToggle.ALWAYS);
debugUIPreferences.setValue(IInternalDebugUIConstants.PREF_SAVE_DIRTY_EDITORS_BEFORE_LAUNCH, MessageDialogWithToggle.NEVER);
String property = System.getProperty("debug.workbenchActivation");
boolean activate = property != null && property.equals("on");
debugUIPreferences.setValue(IDebugPreferenceConstants.CONSOLE_OPEN_ON_ERR, activate);
debugUIPreferences.setValue(IDebugPreferenceConstants.CONSOLE_OPEN_ON_OUT, activate);
debugUIPreferences.setValue(IInternalDebugUIConstants.PREF_ACTIVATE_DEBUG_VIEW, activate);
debugUIPreferences.setValue(IDebugUIConstants.PREF_ACTIVATE_WORKBENCH, activate);
IPreferenceStore jdiUIPreferences = JDIDebugUIPlugin.getDefault().getPreferenceStore();
// Turn off suspend on uncaught exceptions
jdiUIPreferences.setValue(IJDIPreferencesConstants.PREF_SUSPEND_ON_UNCAUGHT_EXCEPTIONS, false);
jdiUIPreferences.setValue(IJDIPreferencesConstants.PREF_SUSPEND_ON_COMPILATION_ERRORS, false);
// Don't warn about HCR failures
jdiUIPreferences.setValue(IJDIPreferencesConstants.PREF_ALERT_HCR_FAILED, false);
jdiUIPreferences.setValue(IJDIPreferencesConstants.PREF_ALERT_HCR_NOT_SUPPORTED, false);
jdiUIPreferences.setValue(IJDIPreferencesConstants.PREF_ALERT_OBSOLETE_METHODS, false);
// Set the timeout preference to a high value, to avoid timeouts while
// testing
JDIDebugModel.getPreferences().setDefault(JDIDebugModel.PREF_REQUEST_TIMEOUT, 10000);
// turn off monitor information
jdiUIPreferences.setValue(IJavaDebugUIConstants.PREF_SHOW_MONITOR_THREAD_INFO, false);
// turn off workbench heap monitor
PrefUtil.getAPIPreferenceStore().setValue(IWorkbenchPreferenceConstants.SHOW_MEMORY_MONITOR, false);
IWorkbenchWindow[] windows = PlatformUI.getWorkbench().getWorkbenchWindows();
for (int i = 0; i < windows.length; i++) {
IWorkbenchWindow window = windows[i];
if(window instanceof WorkbenchWindow){
((WorkbenchWindow) window).showHeapStatus(false);
}
}
//make sure we are auto-refreshing external workspace changes
IEclipsePreferences node = InstanceScope.INSTANCE.getNode(ResourcesPlugin.PI_RESOURCES);
if(node != null) {
node.putBoolean(ResourcesPlugin.PREF_AUTO_REFRESH, true);
node.putBoolean(ResourcesPlugin.PREF_LIGHTWEIGHT_AUTO_REFRESH, true);
node.flush();
}
loadedPrefs = true;
}
}
/**
* Creates the Java 1.4 compliant project
*/
synchronized void assert14Project() {
IJavaProject jp = null;
ArrayList<ILaunchConfiguration> cfgs = new ArrayList<>(1);
try {
if (!loaded14) {
try {
jp = JavaProjectHelper.createJavaProject(ONE_FOUR_PROJECT_CLOSED_NAME);
jp.getProject().close(null);
}
catch(Exception e) {
handleProjectCreationException(e, ONE_FOUR_PROJECT_CLOSED_NAME, jp);
}
jp = createProject(ONE_FOUR_PROJECT_NAME, JavaProjectHelper.TEST_SRC_DIR.toString(), JavaProjectHelper.J2SE_1_4_EE_NAME, false);
IPackageFragmentRoot src = jp.findPackageFragmentRoot(new Path(ONE_FOUR_PROJECT_NAME).append(JavaProjectHelper.SRC_DIR).makeAbsolute());
assertNotNull("The 'src' package fragment root should not be null", src);
File root = JavaTestPlugin.getDefault().getFileInPlugin(new Path("testjars"));
JavaProjectHelper.importFilesFromDirectory(root, src.getPath(), null);
IPath path = src.getPath().append("A.jar");
JavaProjectHelper.addLibrary(jp, path);
//add a closed project optional classpath entry
//see https://bugs.eclipse.org/bugs/show_bug.cgi?id=380918
IClasspathEntry entry = JavaCore.newProjectEntry(
new Path(ONE_FOUR_PROJECT_CLOSED_NAME).makeAbsolute(),
new IAccessRule[0],
false,
new IClasspathAttribute[] {JavaCore.newClasspathAttribute(IClasspathAttribute.OPTIONAL, Boolean.TRUE.toString())},
false);
JavaProjectHelper.addToClasspath(jp, entry);
// create launch configurations
for (int i = 0; i < LAUNCH_CONFIG_NAMES_1_4.length; i++) {
cfgs.add(createLaunchConfiguration(jp, LAUNCH_CONFIG_NAMES_1_4[i]));
}
loaded14 = true;
waitForBuild();
}
}
catch(Exception e) {
try {
if(jp != null) {
jp.getProject().delete(true, true, null);
}
for (int i = 0; i < cfgs.size(); i++) {
cfgs.get(i).delete();
}
}
catch (CoreException ce) {
//ignore
}
handleProjectCreationException(e, ONE_FOUR_PROJECT_NAME, jp);
}
}
/**
* Creates the Java 1.5 compliant project
*/
void assert15Project() {
IJavaProject jp = null;
ArrayList<ILaunchConfiguration> cfgs = new ArrayList<>(1);
try {
if (!loaded15) {
jp = createProject(ONE_FIVE_PROJECT_NAME, JavaProjectHelper.TEST_1_5_SRC_DIR.toString(), JavaProjectHelper.J2SE_1_5_EE_NAME, true);
cfgs.add(createLaunchConfiguration(jp, "a.b.c.MethodBreakpoints"));
cfgs.add(createLaunchConfiguration(jp, "a.b.c.IntegerAccess"));
cfgs.add(createLaunchConfiguration(jp, "a.b.c.StepIntoSelectionWithGenerics"));
cfgs.add(createLaunchConfiguration(jp, "a.b.c.ConditionalsNearGenerics"));
cfgs.add(createLaunchConfiguration(jp, "a.b.c.bug329294WithGenerics"));
cfgs.add(createLaunchConfiguration(jp, "a.b.c.bug403028"));
cfgs.add(createLaunchConfiguration(jp, "a.b.c.bug484686"));
cfgs.add(createLaunchConfiguration(jp, "a.b.c.GenericMethodEntryTest"));
cfgs.add(createLaunchConfiguration(jp, "org.eclipse.debug.tests.targets.HcrClass", true));
loaded15 = true;
waitForBuild();
}
}
catch(Exception e) {
try {
if(jp != null) {
jp.getProject().delete(true, true, null);
for (int i = 0; i < cfgs.size(); i++) {
cfgs.get(i).delete();
}
}
}
catch (CoreException ce) {
//ignore
}
handleProjectCreationException(e, ONE_FIVE_PROJECT_NAME, jp);
}
}
/**
* Creates the Java 1.7 compliant project
*/
synchronized void assert17Project() {
IJavaProject jp = null;
ArrayList<ILaunchConfiguration> cfgs = new ArrayList<>(1);
try {
if (!loaded17) {
jp = createProject(ONE_SEVEN_PROJECT_NAME, JavaProjectHelper.TEST_1_7_SRC_DIR.toString(), JavaProjectHelper.JAVA_SE_1_7_EE_NAME, false);
cfgs.add(createLaunchConfiguration(jp, LiteralTests17.LITERAL_TYPE_NAME));
loaded17 = true;
waitForBuild();
}
}
catch(Exception e) {
try {
if(jp != null) {
jp.getProject().delete(true, true, null);
for (int i = 0; i < cfgs.size(); i++) {
cfgs.get(i).delete();
}
}
}
catch (CoreException ce) {
//ignore
}
handleProjectCreationException(e, ONE_SEVEN_PROJECT_NAME, jp);
}
}
/**
* Creates the Java 1.8 compliant project
*/
synchronized void assert18Project() {
IJavaProject jp = null;
ArrayList<ILaunchConfiguration> cfgs = new ArrayList<>(1);
try {
if (!loaded18) {
jp = createProject(ONE_EIGHT_PROJECT_NAME, JavaProjectHelper.TEST_1_8_SRC_DIR.toString(), JavaProjectHelper.JAVA_SE_1_8_EE_NAME, false);
cfgs.add(createLaunchConfiguration(jp, "EvalTest18"));
cfgs.add(createLaunchConfiguration(jp, "EvalTestIntf18"));
cfgs.add(createLaunchConfiguration(jp, "EvalIntfSuperDefault"));
loaded18 = true;
waitForBuild();
}
}
catch(Exception e) {
try {
if(jp != null) {
jp.getProject().delete(true, true, null);
for (int i = 0; i < cfgs.size(); i++) {
cfgs.get(i).delete();
}
}
}
catch (CoreException ce) {
//ignore
}
handleProjectCreationException(e, ONE_SEVEN_PROJECT_NAME, jp);
}
}
/**
* Creates the 'BoundJRE' project used for the JRE testing
*/
synchronized void assertBoundJreProject() {
IJavaProject jp = null;
try {
if (!loadedJRE) {
jp =JavaProjectHelper.createJavaProject(BOUND_JRE_PROJECT_NAME);
JavaProjectHelper.addSourceContainer(jp, JavaProjectHelper.SRC_DIR, JavaProjectHelper.BIN_DIR);
// add VM specific JRE container
IPath path = JavaRuntime.newJREContainerPath(JavaRuntime.getDefaultVMInstall());
JavaProjectHelper.addContainerEntry(jp, path);
loadedJRE = true;
waitForBuild();
}
}
catch(Exception e) {
try {
if(jp != null) {
jp.getProject().delete(true, true, null);
}
}
catch (CoreException ce) {
//ignore
}
handleProjectCreationException(e, BOUND_JRE_PROJECT_NAME, jp);
}
}
/**
* Creates the 'BoundEE' project for EE testing
*/
void assertBoundeEeProject() {
IJavaProject jp = null;
try {
if(!loadedEE) {
// create project with two src folders and output locations
jp = JavaProjectHelper.createJavaProject(BOUND_EE_PROJECT_NAME);
JavaProjectHelper.addSourceContainer(jp, JavaProjectHelper.SRC_DIR, JavaProjectHelper.BIN_DIR);
// add VM specific JRE container
IExecutionEnvironment j2se14 = JavaRuntime.getExecutionEnvironmentsManager().getEnvironment(JavaProjectHelper.J2SE_1_4_EE_NAME);
assertNotNull("Missing J2SE-1.4 environment", j2se14);
IPath path = JavaRuntime.newJREContainerPath(j2se14);
JavaProjectHelper.addContainerEntry(jp, path);
loadedEE = true;
waitForBuild();
}
}
catch(Exception e) {
try {
if(jp != null) {
jp.getProject().delete(true, true, null);
}
}
catch (CoreException ce) {
//ignore
}
handleProjectCreationException(e, BOUND_EE_PROJECT_NAME, jp);
}
}
/**
* Creates the 'MultiOutput' project for source / binary output testing
*/
synchronized void assertMultioutputProject() {
IJavaProject jp = null;
try {
if(!loadedMulti) {
// create project with two src folders and output locations
jp = JavaProjectHelper.createJavaProject(MULTI_OUTPUT_PROJECT_NAME);
JavaProjectHelper.addSourceContainer(jp, "src1", "bin1");
JavaProjectHelper.addSourceContainer(jp, "src2", "bin2");
// add rt.jar
IVMInstall vm = JavaRuntime.getDefaultVMInstall();
assertNotNull("No default JRE", vm);
JavaProjectHelper.addContainerEntry(jp, new Path(JavaRuntime.JRE_CONTAINER));
loadedMulti = true;
waitForBuild();
}
}
catch(Exception e) {
try {
if(jp != null) {
jp.getProject().delete(true, true, null);
}
}
catch (CoreException ce) {
//ignore
}
handleProjectCreationException(e, MULTI_OUTPUT_PROJECT_NAME, jp);
}
}
/**
* Ensure the welcome screen is closed because in 4.x the debug perspective opens a giant fast-view causing issues
*
* @throws Exception
* @since 3.8
*/
protected final void assertWelcomeScreenClosed() throws Exception {
if(!welcomeClosed && PlatformUI.isWorkbenchRunning()) {
final IWorkbench wb = PlatformUI.getWorkbench();
if (wb == null) {
return;
}
// In UI thread we don't need to run a job
if (Display.getCurrent() != null) {
closeIntro(wb);
return;
}
UIJob job = new UIJob("close welcome screen for debug test suite") {
@Override
public IStatus runInUIThread(IProgressMonitor monitor) {
closeIntro(wb);
return Status.OK_STATUS;
}
};
job.setPriority(Job.INTERACTIVE);
job.setSystem(true);
job.schedule();
}
}
private static void closeIntro(final IWorkbench wb) {
IWorkbenchWindow window = wb.getActiveWorkbenchWindow();
if (window != null) {
IIntroManager im = wb.getIntroManager();
IIntroPart intro = im.getIntro();
if (intro != null) {
welcomeClosed = im.closeIntro(intro);
}
}
}
void handleProjectCreationException(Exception e, String pname, IJavaProject jp) {
StringWriter buf = new StringWriter();
String msg = e.getMessage();
if(msg == null) {
msg = "could not acquire message for exception class: " + e.getClass();
}
buf.write("Failed to create the '" + pname + "' test project.\n");
buf.write("'jp' is " + (jp != null ? "not " : "") + " 'null'\n");
buf.write("Stack tace:\n");
e.printStackTrace(new PrintWriter(buf));
fail(buf.toString());
}
/**
* Sets the contents of the given {@link ICompilationUnit} to be the new contents provided
* @param unit
* @param contents the new {@link String} contents, cannot be <code>null</code>
* @throws JavaModelException
*/
protected void setFileContents(ICompilationUnit unit, String contents) throws JavaModelException {
assertNotNull("You cannot set the new contents of an ICompilationUnit to null", contents);
IBuffer buffer = unit.getBuffer();
buffer.setContents(contents);
unit.save(null, true);
waitForBuild();
}
/**
* 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 singleton instance of the <code>LaunchConfigurationManager</code>
*
* @return the singleton instance of the <code>LaunchConfigurationManager</code>
* @since 3.3
*/
protected LaunchConfigurationManager getLaunchConfigurationManager() {
return DebugUIPlugin.getDefault().getLaunchConfigurationManager();
}
/**
* Returns the breakpoint manager
*
* @return breakpoint manager
*/
protected IBreakpointManager getBreakpointManager() {
return DebugPlugin.getDefault().getBreakpointManager();
}
/**
* Returns the project context for the current test - each
* test must implement this method
*/
protected IJavaProject getProjectContext() {
return get14Project();
}
/**
* Returns the 'DebugTests' project.
*
* @return the test project
*/
protected IJavaProject get14Project() {
assert14Project();
return getJavaProject(ONE_FOUR_PROJECT_NAME);
}
/**
* Returns the {@link IBreakpointOrganizer} with the given id or <code>null</code>
* if no such organizer exists
* @param id
* @return the {@link IBreakpointOrganizer} or <code>null</code>
* @since 3.8.100
*/
protected IBreakpointOrganizer getOrganizer(String id) {
return BreakpointOrganizerManager.getDefault().getOrganizer(id);
}
/**
* Returns the 'OneFive' project.
*
* @return the test project
*/
protected IJavaProject get15Project() {
assert15Project();
return getJavaProject(ONE_FIVE_PROJECT_NAME);
}
/**
* Returns the 'OneSeven' project.
*
* @return the test project
*/
protected IJavaProject get17Project() {
assert17Project();
return getJavaProject(ONE_SEVEN_PROJECT_NAME);
}
/**
* Returns the 'OneSeven' project.
*
* @return the test project
*/
protected IJavaProject get18Project() {
assert18Project();
return getJavaProject(ONE_EIGHT_PROJECT_NAME);
}
/**
* Returns the 'BoundJRE' project
*
* @return the test project
*/
protected IJavaProject getBoundJreProject() {
assertBoundJreProject();
return getJavaProject(BOUND_JRE_PROJECT_NAME);
}
/**
* Returns the 'BoundEE' project
*
* @return the test project
*/
protected IJavaProject getBoundEeProject() {
assertBoundeEeProject();
return getJavaProject(BOUND_EE_PROJECT_NAME);
}
/**
* Returns the 'MultiOutput' project
*
* @return the test project
*/
protected IJavaProject getMultiOutputProject() {
assertMultioutputProject();
return getJavaProject(MULTI_OUTPUT_PROJECT_NAME);
}
/**
* 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);
}
/**
* Creates a new {@link IJavaProject} with the given name and optionally initializing it from the given
* resource path from the testing bundle.
* <br><br>
* The project has the default <code>src</code> and <code>bin</code> folders. It is also created with a default
* <code>launchConfigurations</code> folder.
*
* @param name the name for the project
* @param contentpath the path within the jdt.debug test bundle to initialize the source from
* @param ee the level of execution environment to use
* @param if an existing project should be deleted
* @return the new Java project
* @throws Exception
*/
protected IJavaProject createProject(String name, String contentpath, String ee, boolean delete) throws Exception {
IProject pro = ResourcesPlugin.getWorkspace().getRoot().getProject(name);
if (pro.exists() && delete) {
try {
pro.delete(true, true, null);
}
catch(Exception e) {}
}
// create project and import source
IJavaProject jp = JavaProjectHelper.createJavaProject(name, JavaProjectHelper.BIN_DIR);
IPackageFragmentRoot src = JavaProjectHelper.addSourceContainer(jp, JavaProjectHelper.SRC_DIR);
File root = JavaTestPlugin.getDefault().getFileInPlugin(new Path(contentpath));
JavaProjectHelper.importFilesFromDirectory(root, src.getPath(), null);
// add the EE library
IVMInstall vm = JavaRuntime.getDefaultVMInstall();
assertNotNull("No default JRE", vm);
IExecutionEnvironment environment = JavaRuntime.getExecutionEnvironmentsManager().getEnvironment(ee);
assertNotNull("The EE ["+ee+"] does not exist", environment);
IPath containerPath = JavaRuntime.newJREContainerPath(environment);
JavaProjectHelper.addContainerEntry(jp, containerPath);
pro = jp.getProject();
JavaProjectHelper.updateCompliance(jp, ee);
// create launch configuration folder
IFolder folder = pro.getFolder("launchConfigurations");
if (!folder.exists()) {
folder.create(true, true, null);
}
return jp;
}
/**
* Creates a new {@link IJavaProject} with the given name and initializes the contents from the given
* resource path from the testing bundle.
* <br><br>
* The project has the default <code>src</code> and <code>bin</code> folders. It is also created with a default
* <code>launchConfigurations</code> folder.
*
* @param name the name for the project
* @param contentpath the path within the jdt.debug test bundle to initialize the source from
* @param ee the level of execution environment to use
* @param if an existing project should be deleted
* @return the new Java project
* @throws Exception
*/
protected IJavaProject createJavaProjectClone(String name, String contentpath, String ee, boolean delete) throws Exception {
IProject pro = ResourcesPlugin.getWorkspace().getRoot().getProject(name);
String owner = "Creating project: " + name;
if (pro.exists() && delete) {
pro.delete(true, true, null);
TestUtil.waitForJobs(owner, 100, 10000);
TestUtil.runEventLoop();
}
// create project and import source
IJavaProject jp = JavaProjectHelper.createJavaProject(name, JavaProjectHelper.BIN_DIR);
TestUtil.waitForJobs(owner, 100, 10000);
TestUtil.runEventLoop();
JavaProjectHelper.addSourceContainer(jp, JavaProjectHelper.SRC_DIR);
TestUtil.waitForJobs(owner, 100, 10000);
TestUtil.runEventLoop();
File root = JavaTestPlugin.getDefault().getFileInPlugin(new Path(contentpath));
JavaProjectHelper.importFilesFromDirectory(root, jp.getPath(), null);
TestUtil.waitForJobs(owner, 100, 10000);
TestUtil.runEventLoop();
// add the EE library
IVMInstall vm = JavaRuntime.getDefaultVMInstall();
assertNotNull("No default JRE", vm);
IExecutionEnvironment environment = JavaRuntime.getExecutionEnvironmentsManager().getEnvironment(ee);
assertNotNull("The EE ["+ee+"] does not exist", environment);
IPath containerPath = JavaRuntime.newJREContainerPath(environment);
JavaProjectHelper.addContainerEntry(jp, containerPath);
pro = jp.getProject();
// create launch configuration folder
IFolder folder = pro.getFolder("launchConfigurations");
if (!folder.exists()) {
folder.create(true, true, null);
}
TestUtil.waitForJobs(owner, 100, 10000);
TestUtil.runEventLoop();
return jp;
}
/**
* Creates a new {@link IProject} with the given name and initializes the contents from the given
* resource path from the testing bundle.
*
* @param name the name for the project
* @param contentpath the path within the jdt.debug test bundle to initialize the source from
* @param if an existing project should be deleted
* @return the new project
* @throws Exception
*/
protected IProject createProjectClone(String name, String contentpath, boolean delete) throws Exception {
IProject pro = ResourcesPlugin.getWorkspace().getRoot().getProject(name);
String owner = "Creating project: " + name;
if (pro.exists() && delete) {
pro.delete(true, true, null);
TestUtil.waitForJobs(owner, 100, 10000);
TestUtil.runEventLoop();
}
// create project and import source
IProject pj = JavaProjectHelper.createProject(name);
TestUtil.waitForJobs(owner, 100, 10000);
TestUtil.runEventLoop();
File root = JavaTestPlugin.getDefault().getFileInPlugin(new Path(contentpath));
JavaProjectHelper.importFilesFromDirectory(root, pj.getFullPath(), null);
TestUtil.waitForJobs(owner, 100, 10000);
TestUtil.runEventLoop();
return pj;
}
/**
* Returns the launch shortcut with the given id
* @param id
* @return the <code>LaunchShortcutExtension</code> with the given id,
* or <code>null</code> if none
*
* @since 3.3
*/
protected LaunchShortcutExtension getLaunchShortcutExtension(String id) {
List<?> exts = getLaunchConfigurationManager().getLaunchShortcuts();
LaunchShortcutExtension ext = null;
for (int i = 0; i < exts.size(); i++) {
ext = (LaunchShortcutExtension) exts.get(i);
if(ext.getId().equals(id)) {
return ext;
}
}
return null;
}
/**
* New to 3.3 is the ability to have multiple delegates for a variety of overlapping mode combinations.
* As such, for tests that launch specific configurations, must be check to ensure that there is a preferred
* launch delegate available for the launch in the event there are duplicates. Otherwise the tests
* will hang waiting for a user to select a resolution action.
* @param configuration
* @param modes
* @throws CoreException
*
* @since 3.3
*/
protected void ensurePreferredDelegate(ILaunchConfiguration configuration, Set<String> modes) throws CoreException {
ILaunchConfigurationType type = configuration.getType();
ILaunchDelegate[] delegates = type.getDelegates(modes);
if(delegates.length > 1) {
type.setPreferredDelegate(modes, getDelegateById(type.getIdentifier(), LOCAL_JAVA_APPLICATION_TYPE_ID));
}
}
/**
* Returns the LaunchDelegate for the specified ID
* @param delegateId the id of the delegate to search for
* @return the <code>LaunchDelegate</code> associated with the specified id or <code>null</code> if not found
* @since 3.3
*/
protected ILaunchDelegate getDelegateById(String typeId, String delegateId) {
LaunchManager lm = (LaunchManager) getLaunchManager();
LaunchDelegate[] delegates = lm.getLaunchDelegates(typeId);
for(int i = 0; i < delegates.length; i++) {
if(delegates[i].getId().equals(delegateId)) {
return delegates[i];
}
}
return null;
}
/**
* 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));
}
/**
* Returns the <code>IHyperLink</code> at the given offset in the specified document
* or <code>null</code> if the offset does not point to an <code>IHyperLink</code>
* @param offset
* @param doc
* @return the <code>IHyperLink</code> at the given offset or <code>null</code>
*/
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 in debug mode 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 {
return launchAndWait(configuration, ILaunchManager.DEBUG_MODE, waiter, register);
}
/**
* 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 mode the mode to launch the configuration in
* @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, String mode, DebugEventWaiter waiter, boolean register) throws CoreException {
ILaunch launch = configuration.launch(mode, null, false, register);
Object suspendee= waiter.waitForEvent();
if (suspendee == null) {
StringBuffer buf = new StringBuffer();
buf.append("Test case: "); //$NON-NLS-1$
buf.append(getName());
buf.append("\n"); //$NON-NLS-1$
buf.append("Never received event: "); //$NON-NLS-1$
buf.append(waiter.getEventKindName());
buf.append("\n"); //$NON-NLS-1$
if (launch.isTerminated()) {
buf.append("Process exit value: "); //$NON-NLS-1$
buf.append(launch.getProcesses()[0].getExitValue());
buf.append("\n"); //$NON-NLS-1$
}
IConsole console = DebugUITools.getConsole(launch.getProcesses()[0]);
if (console instanceof TextConsole) {
TextConsole textConsole = (TextConsole)console;
String string = textConsole.getDocument().get();
buf.append("Console output follows:\n"); //$NON-NLS-1$
buf.append(string);
}
buf.append("\n"); //$NON-NLS-1$
DebugPlugin.log(new Status(IStatus.ERROR, "org.eclipse.jdt.debug.ui.tests", buf.toString())); //$NON-NLS-1$
try {
launch.terminate();
} catch (CoreException e) {
e.printStackTrace();
fail("Program did not suspend, and unable to terminate launch."); //$NON-NLS-1$
}
throw new TestAgainException("Program did not suspend, launch terminated.");
}
setEventSet(waiter.getEventSet());
assertNotNull("Program did not suspend, launch terminated.", suspendee); //$NON-NLS-1$
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); //$NON-NLS-1$
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(getProjectContext(), mainTypeName);
}
/**
* 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 project the project the type is in
* @param mainTypeName the program to launch
* @return thread in which the first suspend event occurred
*/
protected IJavaThread launchToBreakpoint(IJavaProject project, String mainTypeName) throws Exception {
return launchToBreakpoint(project, 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 {
return launchToBreakpoint(getProjectContext(), mainTypeName, register);
}
/**
* 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(IJavaProject project, String mainTypeName, boolean register) throws Exception {
ILaunchConfiguration config = getLaunchConfiguration(project, mainTypeName);
assertNotNull("Could not locate launch configuration for " + mainTypeName, config); //$NON-NLS-1$
return launchToBreakpoint(config, register);
}
/**
* 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(IJavaProject project, String mainTypeName, String launchName, boolean register) throws Exception {
ILaunchConfiguration config = getLaunchConfiguration(project, launchName);
assertNotNull("Could not locate launch configuration for " + mainTypeName, config); //$NON-NLS-1$
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); //$NON-NLS-1$
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); //$NON-NLS-1$
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 {
return launchAndTerminate(config, timeout, true);
}
/**
* 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
* @param register whether to register the launch
* @return thread in which the first suspend event occurred
*/
protected IJavaDebugTarget launchAndTerminate(ILaunchConfiguration config, int timeout, boolean register) throws Exception {
DebugEventWaiter waiter= new DebugElementKindEventWaiter(DebugEvent.TERMINATE, IJavaDebugTarget.class);
waiter.setTimeout(timeout);
Object terminatee = launchAndWait(config, waiter, register);
assertNotNull("Program did not terminate.", terminatee); //$NON-NLS-1$
assertTrue("terminatee is not an IJavaDebugTarget", terminatee instanceof IJavaDebugTarget); //$NON-NLS-1$
IJavaDebugTarget debugTarget = (IJavaDebugTarget) terminatee;
assertTrue("debug target is not terminated", debugTarget.isTerminated() || debugTarget.isDisconnected()); //$NON-NLS-1$
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 {
return launchToLineBreakpoint(mainTypeName, bp, true);
}
/**
* 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
* @param register whether to register the launch
* @return thread in which the first suspend event occurred
*/
protected IJavaThread launchToLineBreakpoint(String mainTypeName, ILineBreakpoint bp, boolean register) throws Exception {
ILaunchConfiguration config = getLaunchConfiguration(mainTypeName);
assertNotNull("Could not locate launch configuration for " + mainTypeName, config); //$NON-NLS-1$
return launchToLineBreakpoint(config, bp, register);
}
/**
* 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, boolean register) throws Exception {
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); //$NON-NLS-1$
IJavaThread thread = (IJavaThread) suspendee;
IBreakpoint hit = getBreakpoint(thread);
assertNotNull("suspended, but not by breakpoint", hit); //$NON-NLS-1$
assertTrue("hit un-registered breakpoint", bp.equals(hit)); //$NON-NLS-1$
assertTrue("suspended, but not by line breakpoint", hit instanceof ILineBreakpoint); //$NON-NLS-1$
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); //$NON-NLS-1$
return thread;
}
/**
* Returns the standard java launch tab group
* @return the standard java launch tab group
* @throws CoreException
*
* @since 3.3
*/
protected ILaunchConfigurationTabGroup getJavaLaunchGroup() throws CoreException {
ILaunchConfigurationType javaType = getLaunchManager().getLaunchConfigurationType(IJavaLaunchConfigurationConstants.ID_JAVA_APPLICATION);
ILaunchConfigurationTabGroup standardGroup = LaunchConfigurationPresentationManager.getDefault().getTabGroup(javaType, ILaunchManager.DEBUG_MODE);
return standardGroup;
}
/**
* Returns an instance of the launch configuration dialog on the the specified launch mode
* @param modeid the id of the mode to open the launch dialog on
* @return an new instance of <code>IlaunchConfigurationDialog</code>
*
* @since 3.3
*/
protected ILaunchConfigurationDialog getLaunchConfigurationDialog(String modeid) {
return new LaunchConfigurationsDialog(null, DebugUIPlugin.getDefault().getLaunchConfigurationManager().getLaunchGroup(modeid));
}
/**
* 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 milliseconds
* @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); //$NON-NLS-1$
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); //$NON-NLS-1$
assertTrue("suspendee was not an IJavaThread", suspendee instanceof IJavaThread); //$NON-NLS-1$
IJavaThread thread = (IJavaThread) suspendee;
IBreakpoint hit = getBreakpoint(thread);
assertNotNull("suspended, but not by breakpoint", hit); //$NON-NLS-1$
assertTrue("hit un-registered breakpoint", bp.equals(hit)); //$NON-NLS-1$
assertTrue("suspended, but not by line breakpoint", hit instanceof ILineBreakpoint); //$NON-NLS-1$
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); //$NON-NLS-1$
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); //$NON-NLS-1$
}
/**
* 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); //$NON-NLS-1$
IJavaDebugTarget target = (IJavaDebugTarget)suspendee;
assertTrue("program should have exited", target.isTerminated() || target.isDisconnected()); //$NON-NLS-1$
return target;
}
/**
* Returns the launch configuration for the given main type
*
* @param mainTypeName program to launch
* @see ProjectCreationDecorator
*/
protected ILaunchConfiguration getLaunchConfiguration(String mainTypeName) {
return getLaunchConfiguration(getProjectContext(), mainTypeName);
}
/**
* Returns the launch configuration for the given main type
*
* @param mainTypeName program to launch
* @see ProjectCreationDecorator
*/
protected ILaunchConfiguration getLaunchConfiguration(IJavaProject project, String mainTypeName) {
IFile file = project.getProject().getFolder(LAUNCHCONFIGURATIONS).getFile(mainTypeName + LAUNCH_EXTENSION);
ILaunchConfiguration config = getLaunchManager().getLaunchConfiguration(file);
assertNotNull("the configuration cannot be null", config);
assertTrue("Could not find launch configuration for " + mainTypeName, config.exists()); //$NON-NLS-1$
return config;
}
/**
* Returns the launch configuration in the specified folder in the given project, for the given main type
*
* @param project the project to look in
* @param containername the name of the container in the specified project to look for the config
* @param mainTypeName program to launch
* @see ProjectCreationDecorator
*/
protected ILaunchConfiguration getLaunchConfiguration(IJavaProject project, String containername, String mainTypeName) {
IFile file = project.getProject().getFolder(containername).getFile(mainTypeName + LAUNCH_EXTENSION);
ILaunchConfiguration config = getLaunchManager().getLaunchConfiguration(file);
assertNotNull("the configuration cannot be null", config);
assertTrue("Could not find launch configuration for " + mainTypeName, config.exists()); //$NON-NLS-1$
return config;
}
/**
* Returns the corresponding <code>IResource</code> from the <code>IJavaElement</code> with the
* specified name
* @param typeName the name of the <code>IJavaElement</code> to get the resource for
* @return the corresponding <code>IResource</code> from the <code>IJavaElement</code> with the
* specified name
* @throws Exception
*/
protected IResource getBreakpointResource(String typeName) throws Exception {
IJavaElement element = getProjectContext().findElement(new Path(typeName + JAVA_EXTENSION));
IResource resource = element.getCorrespondingResource();
if (resource == null) {
resource = getProjectContext().getProject();
}
return resource;
}
/**
* Returns the resource from the specified type or the project from the testing java project in the
* event there is no resource from the specified type
* @param type
* @return
* @throws Exception
*/
protected IResource getBreakpointResource(IType type) throws Exception {
if (type == null) {
return getProjectContext().getProject();
}
IResource resource = type.getResource();
if (resource == null) {
resource = type.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);
assertNotNull("Could not find the requested IType: "+typeName, type);
return createLineBreakpoint(type, lineNumber);
}
/**
* Creates am new java line breakpoint
* @param lineNumber
* @param root
* @param packageName
* @param cuName
* @param fullTargetName
* @return a new line breakpoint
*/
protected IJavaLineBreakpoint createLineBreakpoint(int lineNumber, String root, String packageName, String cuName,
String fullTargetName) throws Exception{
IJavaProject javaProject = getProjectContext();
ICompilationUnit cunit = getCompilationUnit(javaProject, root, packageName, cuName);
assertNotNull("did not find requested Compilation Unit", cunit); //$NON-NLS-1$
IType targetType = (IType)(new MemberParser()).getDeepest(cunit,fullTargetName);
assertNotNull("did not find requested type", targetType); //$NON-NLS-1$
assertTrue("did not find type to install breakpoint in", targetType.exists()); //$NON-NLS-1$
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);
assertNotNull("Could not find the requested IType: "+typeName, type);
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 {
assertNotNull("You cannot create a line breakpoint for a null IType", type);
IMember member = 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<String, Object> map = getExtraBreakpointAttributes(member);
IJavaLineBreakpoint bp = JDIDebugModel.createLineBreakpoint(getBreakpointResource(type), type.getFullyQualifiedName(), lineNumber, -1, -1, 0, true, map);
forceDeltas(bp);
return bp;
}
/**
* Forces marker deltas to be sent based on breakpoint creation.
*
* @param breakpoint
*/
private void forceDeltas(IBreakpoint breakpoint) throws CoreException {
IProject project = breakpoint.getMarker().getResource().getProject();
if (project != null) {
project.build(IncrementalProjectBuilder.INCREMENTAL_BUILD, null);
}
}
/**
* 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 = getProjectContext().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("\\$"); //$NON-NLS-1$
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<String, Object> getExtraBreakpointAttributes(IMember element) throws Exception {
if (element != null && element.exists()) {
Map<String, Object> 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(getProjectContext().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(getProjectContext().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(getProjectContext().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 {
return createMethodBreakpoint(getProjectContext(), typeNamePattern, methodName, methodSignature, entry, exit);
}
/**
* Creates and returns a method breakpoint
*
* @param project java project
* @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(IJavaProject project, String typeNamePattern, String methodName, String methodSignature, boolean entry, boolean exit) throws Exception {
IMethod method= null;
IResource resource = project.getProject();
if (methodSignature != null && methodName != null) {
IType type = project.findType(typeNamePattern);
if (type != null ) {
resource = getBreakpointResource(type);
method = type.getMethod(methodName, Signature.getParameterTypes(methodSignature));
}
}
Map<String, Object> map = getExtraBreakpointAttributes(method);
IJavaMethodBreakpoint bp = JDIDebugModel.createMethodBreakpoint(resource, typeNamePattern, methodName, methodSignature, entry, exit,false, -1, -1, -1, 0, true, map);
forceDeltas(bp);
return bp;
}
/**
* 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 signature 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); //$NON-NLS-1$
IMethod method= null;
if (methodSignature != null && methodName != null) {
if (type != null ) {
method = type.getMethod(methodName, Signature.getParameterTypes(methodSignature));
}
}
Map<String, Object> map = getExtraBreakpointAttributes(method);
IJavaMethodBreakpoint bp = JDIDebugModel.createMethodBreakpoint(getBreakpointResource(type), type.getFullyQualifiedName(), methodName, methodSignature, entry, exit,false, -1, -1, -1, 0, true, map);
forceDeltas(bp);
return bp;
}
/**
* 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 = getProjectContext();
ICompilationUnit cunit = getCompilationUnit(javaProject, root, packageName, cuName);
assertNotNull("did not find requested Compilation Unit", cunit); //$NON-NLS-1$
IMethod targetMethod = (IMethod)(new MemberParser()).getDeepest(cunit,fullTargetName);
assertNotNull("did not find requested method", targetMethod); //$NON-NLS-1$
assertTrue("Given method does not exist", targetMethod.exists()); //$NON-NLS-1$
IType methodParent = (IType)targetMethod.getParent();//safe - method's only parent = Type
assertNotNull("did not find type to install breakpoint in", methodParent); //$NON-NLS-1$
Map<String, Object> map = getExtraBreakpointAttributes(targetMethod);
IJavaMethodBreakpoint bp = JDIDebugModel.createMethodBreakpoint(getBreakpointResource(methodParent), methodParent.getFullyQualifiedName(),targetMethod.getElementName(), targetMethod.getSignature(), entry, exit,false, -1, -1, -1, 0, true, map);
forceDeltas(bp);
return bp;
}
/**
* @param cu the Compilation where the target resides
* @param target the full name 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;
}
/**
* Delegate method to get a resource with a specific name from the testing workspace 'src' folder
* @param name the name of the <code>IResource</code> to get
* @return the specified <code>IResource</code> or <code>null</code> if it does not exist
*
* @since 3.4
*/
protected IResource getResource(String name) {
return ResourcesPlugin.getWorkspace().getRoot().findMember(new Path("/DebugTests/src/"+name));
}
/**
* 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(getProjectContext(), root, packageName, cuName);
IType type = (IType)getMember(cunit,fullTargetName);
assertTrue("Target type not found", type.exists()); //$NON-NLS-1$
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); //$NON-NLS-1$
int kind = IJavaClassPrepareBreakpoint.TYPE_CLASS;
if (type.isInterface()) {
kind = IJavaClassPrepareBreakpoint.TYPE_INTERFACE;
}
Map<String, Object> map = getExtraBreakpointAttributes(type);
IJavaClassPrepareBreakpoint bp = JDIDebugModel.createClassPrepareBreakpoint(getBreakpointResource(type), type.getFullyQualifiedName(), kind, -1, -1, true, map);
forceDeltas(bp);
return bp;
}
/**
* 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 getProjectContext().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<String, Object> map = getExtraBreakpointAttributes(type);
IJavaExceptionBreakpoint bp = JDIDebugModel.createExceptionBreakpoint(getBreakpointResource(type),exName, caught, uncaught, false, true, map);
forceDeltas(bp);
return bp;
}
/**
* 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
*
* <p>
* <pre>
* Syntax example:
* Type$InnerType$MethodNameAndSignature$AnonymousTypeDeclarationNumber$FieldName
* eg:
* public class Foo{
* class Inner
* {
* public void aMethod()
* {
* Object anon = new Object(){
* int anIntField;
* String anonTypeMethod() {return "an Example";}
* }
* }
* }
* }</pre>
* </p>
* 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(getProjectContext(), root, packageName, cuName);
IField field = (IField)getMember(cunit,fullTargetName);
assertNotNull("Path to field is not valid", field); //$NON-NLS-1$
assertTrue("Field is not valid", field.exists()); //$NON-NLS-1$
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); //$NON-NLS-1$
IField field = type.getField(fieldName);
Map<String, Object> map = getExtraBreakpointAttributes(field);
IJavaWatchpoint wp = JDIDebugModel.createWatchpoint(getBreakpointResource(type), type.getFullyQualifiedName(), fieldName, -1, -1, -1, 0, true, map);
wp.setAccess(access);
wp.setModification(modification);
forceDeltas(wp);
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) {
assertNotNull(getName()+" - you cannot terminate and remove a null debug target", debugTarget);
ILaunch launch = debugTarget.getLaunch();
if (!(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(getProjectContext(), (IJavaDebugTarget)frame.getDebugTarget());
try {
engine.evaluate(snippet, frame, this, DebugEvent.EVALUATION, true);
Object suspendee= waiter.waitForEvent();
setEventSet(waiter.getEventSet());
if(suspendee == null) {
throw new TestAgainException("Program did not suspend evaluating: \n\n"+snippet);
}
assertNotNull("Program did not suspend.", suspendee); //$NON-NLS-1$
return fEvaluationResult;
}
finally {
engine.dispose();
}
}
/**
* Runs an evaluation using an embedded listener and the {@link #DEFAULT_TIMEOUT} for the operation
* @param snippet the snippet to evaluate
* @param thread the suspended thread to run the evaluation on
* @return the {@link IEvaluationResult}
* @throws Exception
* @since 3.1.200
*/
protected IEvaluationResult evaluate(String snippet, IJavaThread thread) throws Exception {
class Listener implements IEvaluationListener {
IEvaluationResult fResult;
@Override
public void evaluationComplete(IEvaluationResult result) {
fResult= result;
}
}
Listener listener= new Listener();
IJavaStackFrame frame = (IJavaStackFrame) thread.getTopStackFrame();
assertNotNull("There should be a stackframe", frame);
ASTEvaluationEngine engine = new ASTEvaluationEngine(getProjectContext(), (IJavaDebugTarget) thread.getDebugTarget());
try {
engine.evaluate(snippet, frame, listener, DebugEvent.EVALUATION_IMPLICIT, false);
long timeout = System.currentTimeMillis()+DEFAULT_TIMEOUT;
while(listener.fResult == null && System.currentTimeMillis() < timeout) {
Thread.sleep(100);
}
return listener.fResult;
}
finally {
engine.dispose();
}
}
/**
* @see IEvaluationListener#evaluationComplete(IEvaluationResult)
*/
@Override
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); //$NON-NLS-1$
return (IJavaThread) suspendee;
}
/**
* Performs a step over in the given stack frame and returns when a breakpoint is hit.
*
* @param frame stack frame to step in
*/
protected IJavaThread stepOverToBreakpoint(IJavaStackFrame frame) throws Exception {
DebugEventWaiter waiter= new DebugElementKindEventDetailWaiter(DebugEvent.SUSPEND, IJavaThread.class, DebugEvent.BREAKPOINT);
waiter.setTimeout(DEFAULT_TIMEOUT);
frame.stepOver();
Object suspendee= waiter.waitForEvent();
setEventSet(waiter.getEventSet());
assertNotNull("Program did not suspend.", suspendee); //$NON-NLS-1$
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); //$NON-NLS-1$
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); //$NON-NLS-1$
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 {
return stepIntoWithFilters(frame, true);
}
/**
* Performs a step into with filters in the given stack frame and returns when
* complete.
*
* @param whether to step thru or step return from a filtered location
* @param frame stack frame to step in
*/
protected IJavaThread stepIntoWithFilters(IJavaStackFrame frame, boolean stepThru) throws Exception {
DebugEventWaiter waiter= new DebugElementKindEventWaiter(DebugEvent.SUSPEND, IJavaThread.class);
waiter.setTimeout(DEFAULT_TIMEOUT);
// turn filters on
IJavaDebugTarget target = (IJavaDebugTarget) frame.getDebugTarget();
try {
target.setStepFiltersEnabled(true);
target.setStepThruFilters(stepThru);
frame.stepInto();
Object suspendee= waiter.waitForEvent();
setEventSet(waiter.getEventSet());
assertNotNull("Program did not suspend.", suspendee); //$NON-NLS-1$
return (IJavaThread) suspendee;
} catch (DebugException e) {
tryTestAgain(e);
} finally {
// turn filters off
target.setStepFiltersEnabled(false);
target.setStepThruFilters(true);
}
return null;
}
/**
* 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
IJavaDebugTarget target = (IJavaDebugTarget) frame.getDebugTarget();
try {
target.setStepFiltersEnabled(true);
frame.stepReturn();
} catch (DebugException e) {
tryTestAgain(e);
} finally {
// turn filters off
target.setStepFiltersEnabled(false);
}
Object suspendee= waiter.waitForEvent();
setEventSet(waiter.getEventSet());
assertNotNull("Program did not suspend.", suspendee); //$NON-NLS-1$
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
IJavaDebugTarget target = (IJavaDebugTarget) frame.getDebugTarget();
try {
target.setStepFiltersEnabled(true);
frame.stepOver();
} catch (DebugException e) {
tryTestAgain(e);
} finally {
// turn filters off
target.setStepFiltersEnabled(false);
}
Object suspendee= waiter.waitForEvent();
setEventSet(waiter.getEventSet());
assertNotNull("Program did not suspend.", suspendee); //$NON-NLS-1$
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 {
Job.getJobManager().join(ResourcesPlugin.FAMILY_AUTO_BUILD, null);
Job.getJobManager().join(ResourcesPlugin.FAMILY_MANUAL_BUILD, null);
// Let also all other pending jobs proceed, ignore console jobs
TestUtil.waitForJobs("waitForBuild", 100, 1000, ProcessConsole.class);
wasInterrupted = false;
} catch (OperationCanceledException e) {
e.printStackTrace();
} catch (InterruptedException e) {
wasInterrupted = true;
}
} while (wasInterrupted);
}
/**
* Finds the specified variable within the context of the specified stackframe. Returns null if a variable with
* the given name does not exist
* @param frame
* @param name
* @return the <code>IJavaVariable</code> with the given name or <code>null</code> if it
* does not exist
* @throws DebugException
*/
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)); //$NON-NLS-1$ //$NON-NLS-2$
System.out.println("Visible variables are:"); //$NON-NLS-1$
IVariable[] variables = frame.getVariables();
for (int i = 0; i < variables.length; i++) {
IVariable variable2 = variables[i];
System.out.println("\t" + presentation.getText(variable2)); //$NON-NLS-1$
}
if (!frame.isStatic() && !frame.isNative()) {
IJavaObject ths = frame.getThis();
if (ths != null) {
variables = ths.getVariables();
for (int i = 0; i < variables.length; i++) {
IVariable variable2 = variables[i];
System.out.println("\t" + presentation.getText(variable2)); //$NON-NLS-1$
}
}
}
}
return variable;
}
/**
* Returns if the local filesystem is case-sensitive or not
* @return true if the local filesystem is case-sensitive, false otherwise
*/
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 ILaunchConfiguration createLaunchConfiguration(String mainTypeName) throws Exception {
return createLaunchConfiguration(getProjectContext(), mainTypeName);
}
/**
* Creates a shared launch configuration for the type with the given name.
*/
protected ILaunchConfiguration createLaunchConfiguration(IJavaProject project, String mainTypeName) throws Exception {
return createLaunchConfiguration(project, mainTypeName, false);
}
/**
* Creates a shared launch configuration for the type with the given name.
*
* @param clone
* true if the launch config name should be different from the main type name
*/
protected ILaunchConfiguration createLaunchConfiguration(IJavaProject project, String mainTypeName, boolean clone) throws Exception {
ILaunchConfigurationType type = getLaunchManager().getLaunchConfigurationType(IJavaLaunchConfigurationConstants.ID_JAVA_APPLICATION);
String configName = clone ? mainTypeName + CLONE_SUFFIX : mainTypeName;
ILaunchConfigurationWorkingCopy config = type.newInstance(project.getProject().getFolder(LAUNCHCONFIGURATIONS), configName);
config.setAttribute(IJavaLaunchConfigurationConstants.ATTR_MAIN_TYPE_NAME, mainTypeName);
config.setAttribute(IJavaLaunchConfigurationConstants.ATTR_PROJECT_NAME, project.getElementName());
Set<String> modes = new HashSet<>();
modes.add(ILaunchManager.RUN_MODE);
config.setPreferredLaunchDelegate(modes, LOCAL_JAVA_APPLICATION_TYPE_ID);
modes = new HashSet<>();
modes.add(ILaunchManager.DEBUG_MODE);
config.setPreferredLaunchDelegate(modes, LOCAL_JAVA_APPLICATION_TYPE_ID);
// use 'java' instead of 'javaw' to launch tests (javaw is problematic
// on JDK1.4.2)
Map<String, String> map = new HashMap<>(1);
map.put(IJavaLaunchConfigurationConstants.ATTR_JAVA_COMMAND, JAVA);
config.setAttribute(IJavaLaunchConfigurationConstants.ATTR_VM_INSTALL_TYPE_SPECIFIC_ATTRS_MAP, map);
return config.doSave();
}
/**
* Creates a shared launch configuration for the type with the given name.
*/
protected ILaunchConfiguration createLaunchConfiguration(IJavaProject project, String containername, String mainTypeName) throws Exception {
ILaunchConfigurationType type = getLaunchManager().getLaunchConfigurationType(IJavaLaunchConfigurationConstants.ID_JAVA_APPLICATION);
ILaunchConfigurationWorkingCopy config = type.newInstance(project.getProject().getFolder(containername), mainTypeName);
config.setAttribute(IJavaLaunchConfigurationConstants.ATTR_MAIN_TYPE_NAME, mainTypeName);
config.setAttribute(IJavaLaunchConfigurationConstants.ATTR_PROJECT_NAME, project.getElementName());
Set<String> modes = new HashSet<>();
modes.add(ILaunchManager.RUN_MODE);
config.setPreferredLaunchDelegate(modes, LOCAL_JAVA_APPLICATION_TYPE_ID);
modes = new HashSet<>();
modes.add(ILaunchManager.DEBUG_MODE);
config.setPreferredLaunchDelegate(modes, LOCAL_JAVA_APPLICATION_TYPE_ID);
// use 'java' instead of 'javaw' to launch tests (javaw is problematic
// on JDK1.4.2)
Map<String, String> map = new HashMap<>(1);
map.put(IJavaLaunchConfigurationConstants.ATTR_JAVA_COMMAND, JAVA);
config.setAttribute(IJavaLaunchConfigurationConstants.ATTR_VM_INSTALL_TYPE_SPECIFIC_ATTRS_MAP, map);
return config.doSave();
}
/**
* When a test throws the 'try again' exception, try it again.
* @see junit.framework.TestCase#runBare()
*/
@Override
public void runBare() throws Throwable {
boolean tryAgain = true;
int attempts = 0;
while (tryAgain) {
try {
attempts++;
super.runBare();
tryAgain = false;
} catch (TestAgainException e) {
TestUtil.log(IStatus.ERROR, getName(), "Test failed attempt " + attempts + ". Re-testing.", e);
TestUtil.cleanUp(getName());
if (attempts > 4) {
// the next attempt will fail
break;
}
}
}
if (tryAgain) {
// last attempt and if it fails then we should fail, see bug 515988
super.runBare();
}
}
@Override
protected void tearDown() throws Exception {
TestUtil.log(IStatus.INFO, getName(), "tearDown");
shutdownDebugTargets();
TestUtil.cleanUp(getName());
super.tearDown();
}
protected void shutdownDebugTargets() {
ILaunchManager launchManager = DebugPlugin.getDefault().getLaunchManager();
IDebugTarget[] targets = launchManager.getDebugTargets();
for (IDebugTarget target : targets) {
if (target instanceof JDIDebugTarget) {
((JDIDebugTarget) target).shutdown();
}
}
}
/**
* Opens and returns an editor on the given file or <code>null</code>
* if none. The editor will be activated.
*
* @param file
* @return editor or <code>null</code>
*/
protected IEditorPart openEditor(final IFile file) throws PartInitException, InterruptedException {
Display display = DebugUIPlugin.getStandardDisplay();
if (Thread.currentThread().equals(display.getThread())) {
IWorkbenchPage page = PlatformUI.getWorkbench().getActiveWorkbenchWindow().getActivePage();
return IDE.openEditor(page, file, true);
}
final IEditorPart[] parts = new IEditorPart[1];
WorkbenchJob job = new WorkbenchJob(display, "open editor") {
@Override
public IStatus runInUIThread(IProgressMonitor monitor) {
IWorkbenchPage page = PlatformUI.getWorkbench().getActiveWorkbenchWindow().getActivePage();
try {
parts[0] = IDE.openEditor(page, file, true);
} catch (PartInitException e) {
return e.getStatus();
}
return Status.OK_STATUS;
}
};
job.schedule();
job.join();
return parts[0];
}
/**
* Opens the {@link IDebugView} with the given id, does nothing if no such view exists.
* This method can return <code>null</code>
*
* @param viewId
* @return the handle to the {@link IDebugView} with the given id
* @throws PartInitException
* @throws InterruptedException
* @since 3.8.100
*/
protected IDebugView openDebugView(final String viewId) throws PartInitException, InterruptedException {
if(viewId != null) {
Display display = DebugUIPlugin.getStandardDisplay();
if (Thread.currentThread().equals(display.getThread())) {
return doShowDebugView(viewId);
}
final IDebugView[] view = new IDebugView[1];
WorkbenchJob job = new WorkbenchJob("Showing the debug view: "+viewId) {
@Override
public IStatus runInUIThread(IProgressMonitor monitor) {
try {
view[0] = doShowDebugView(viewId);
}
catch(CoreException ce) {
return ce.getStatus();
}
return Status.OK_STATUS;
}
};
job.schedule();
job.join();
return view[0];
}
return null;
}
/**
* Opens a debug view
* @param viewId
* @return return the debug view handle or <code>null</code>
* @throws PartInitException
* @since 3.8.100
*/
private IDebugView doShowDebugView(String viewId) throws PartInitException {
IWorkbenchWindow window = PlatformUI.getWorkbench().getActiveWorkbenchWindow();
if(window != null) {
IWorkbenchPage page = window.getActivePage();
assertNotNull("We shold have found the active page to open the debug view in", page);
return (IDebugView) page.showView(viewId);
}
return null;
}
/**
* Toggles a breakpoint in the editor at the given line number returning the breakpoint
* or <code>null</code> if none.
*
* @param editor
* @param lineNumber
* @return returns the created breakpoint or <code>null</code> if none.
* @throws InterruptedException
*/
protected IBreakpoint toggleBreakpoint(final IEditorPart editor, int lineNumber) throws InterruptedException {
final IVerticalRulerInfo info = new VerticalRulerInfoStub(lineNumber-1); // sub 1, as the doc lines start at 0
WorkbenchJob job = new WorkbenchJob(DebugUIPlugin.getStandardDisplay(), "toggle breakpoint") {
@Override
public IStatus runInUIThread(IProgressMonitor monitor) {
ToggleBreakpointAction action = new ToggleBreakpointAction(editor, null, info);
action.run();
return Status.OK_STATUS;
}
};
final Object lock = new Object();
final IBreakpoint[] breakpoints = new IBreakpoint[1];
IBreakpointListener listener = new IBreakpointListener() {
@Override
public void breakpointRemoved(IBreakpoint breakpoint, IMarkerDelta delta) {
}
@Override
public void breakpointChanged(IBreakpoint breakpoint, IMarkerDelta delta) {
}
@Override
public void breakpointAdded(IBreakpoint breakpoint) {
synchronized (lock) {
breakpoints[0] = breakpoint;
lock.notifyAll();
}
}
};
IBreakpointManager manager = DebugPlugin.getDefault().getBreakpointManager();
manager.addBreakpointListener(listener);
synchronized (lock) {
job.schedule();
lock.wait(DEFAULT_TIMEOUT);
}
manager.removeBreakpointListener(listener);
return breakpoints[0];
}
/**
* Closes all editors in the active workbench page.
*/
protected void closeAllEditors() {
Runnable closeAll = new Runnable() {
@Override
public void run() {
IWorkbenchWindow activeWorkbenchWindow = PlatformUI.getWorkbench().getActiveWorkbenchWindow();
activeWorkbenchWindow.getActivePage().closeAllEditors(false);
}
};
Display display = DebugUIPlugin.getStandardDisplay();
display.syncExec(closeAll);
}
/**
* Returns the version level of the class files being run, based on the system property <code>java.class.version</code>
* @return the version level of the class files being run in the current VM
*
* @since 3.6
*/
protected String getClassFileVersion() {
String version = System.getProperty("java.class.version");
if(version.compareTo("48.0") <= 0) {
return JavaCore.VERSION_1_4;
}
if(version.compareTo("49.0") <= 0) {
return JavaCore.VERSION_1_5;
}
return JavaCore.VERSION_1_6;
}
/**
* Determines if the test should be attempted again based on the error code.
* See bug 297071.
*
* @param e Debug Exception
* @throws TestAgainException
* @throws DebugException
*/
protected void tryTestAgain(DebugException e) throws Exception {
Throwable cause = e.getCause();
if (cause instanceof InternalException) {
int code = ((InternalException)cause).errorCode();
if (code == 13) {
throw new TestAgainException("Retest - exception during test: "+getName()+": "+e.getMessage());
}
}
throw e;
}
/**
* Perform the actual evaluation (inspect)
* @param thread
* @return the result of the evaluation
* @throws Exception
*/
protected IValue doEval(IJavaThread thread, String snippet) throws Exception{
class Listener implements IEvaluationListener {
IEvaluationResult fResult;
@Override
public void evaluationComplete(IEvaluationResult result) {
fResult= result;
}
public IEvaluationResult getResult() {
return fResult;
}
}
Listener listener = new Listener();
IJavaStackFrame frame = (IJavaStackFrame) thread.getTopStackFrame();
assertNotNull("There should be a stackframe", frame);
ASTEvaluationEngine engine = new ASTEvaluationEngine(getProjectContext(), (IJavaDebugTarget) thread.getDebugTarget());
try {
engine.evaluate(snippet, frame, listener, DebugEvent.EVALUATION_IMPLICIT, false);
long timeout = System.currentTimeMillis() + 5000;
while(listener.getResult() == null && System.currentTimeMillis() < timeout) {
Thread.sleep(100);
}
IEvaluationResult result = listener.getResult();
assertNotNull("The evaluation should have result: ", result);
assertNull("The evaluation should not have exception : " + result.getException(), result.getException());
String firstError = result.hasErrors() ? result.getErrorMessages()[0] : "";
assertFalse("The evaluation should not have errors : " + firstError, result.hasErrors());
return listener.getResult().getValue();
}
finally {
engine.dispose();
}
}
}