| Methods Summary |
|---|
| private org.eclipse.jdt.core.IJavaElement | chooseContainer(org.eclipse.jdt.core.IJavaElement initElement)
Class[] acceptedClasses = new Class[] { IJavaProject.class,
IPackageFragment.class };
TypedElementSelectionValidator validator = new TypedElementSelectionValidator(
acceptedClasses, false) {
@Override
public boolean isSelectedValid(Object element) {
return true;
}
};
acceptedClasses = new Class[] { IJavaModel.class, IPackageFragmentRoot.class,
IJavaProject.class, IPackageFragment.class };
ViewerFilter filter = new TypedViewerFilter(acceptedClasses) {
@Override
public boolean select(Viewer viewer, Object parent, Object element) {
if (element instanceof IPackageFragmentRoot &&
((IPackageFragmentRoot) element).isArchive()) {
return false;
}
try {
if (element instanceof IPackageFragment &&
!((IPackageFragment) element).hasChildren()) {
return false;
}
} catch (JavaModelException e) {
return false;
}
return super.select(viewer, parent, element);
}
};
AndroidJavaElementContentProvider provider = new AndroidJavaElementContentProvider();
ILabelProvider labelProvider = new JavaElementLabelProvider(
JavaElementLabelProvider.SHOW_DEFAULT);
ElementTreeSelectionDialog dialog = new ElementTreeSelectionDialog(getShell(),
labelProvider, provider);
dialog.setValidator(validator);
dialog.setComparator(new JavaElementComparator());
dialog.setTitle(JUnitMessages.JUnitLaunchConfigurationTab_folderdialog_title);
dialog.setMessage(JUnitMessages.JUnitLaunchConfigurationTab_folderdialog_message);
dialog.addFilter(filter);
dialog.setInput(JavaCore.create(getWorkspaceRoot()));
dialog.setInitialSelection(initElement);
dialog.setAllowMultiple(false);
if (dialog.open() == Window.OK) {
Object element = dialog.getFirstResult();
return (IJavaElement) element;
}
return null;
|
| public void | createControl(org.eclipse.swt.widgets.Composite parent)
/* (non-Javadoc)
* @see org.eclipse.debug.ui.ILaunchConfigurationTab#createControl(org.eclipse.swt.widgets.Composite)
*/
mProjectChooserHelper = new ProjectChooserHelper(parent.getShell());
Composite comp = new Composite(parent, SWT.NONE);
setControl(comp);
GridLayout topLayout = new GridLayout();
topLayout.numColumns = 3;
comp.setLayout(topLayout);
createSingleTestSection(comp);
createTestContainerSelectionGroup(comp);
createSpacer(comp);
createInstrumentationGroup(comp);
createSpacer(comp);
Dialog.applyDialogFont(comp);
// TODO: add help link here when available
//PlatformUI.getWorkbench().getHelpSystem().setHelp(getControl(),
// IJUnitHelpContextIds.LAUNCH_CONFIGURATION_DIALOG_JUNIT_MAIN_TAB);
validatePage();
|
| private void | createInstrumentationGroup(org.eclipse.swt.widgets.Composite comp)
Label loaderLabel = new Label(comp, SWT.NONE);
loaderLabel.setText("Instrumentation runner:");
GridData gd = new GridData();
gd.horizontalIndent = 0;
loaderLabel.setLayoutData(gd);
mInstrumentationCombo = new Combo(comp, SWT.DROP_DOWN | SWT.READ_ONLY);
gd = new GridData(GridData.FILL_HORIZONTAL);
mInstrumentationCombo.setLayoutData(new GridData(GridData.FILL_HORIZONTAL));
mInstrumentationCombo.clearSelection();
mInstrumentationCombo.addSelectionListener(new SelectionAdapter() {
@Override
public void widgetSelected(SelectionEvent e) {
validatePage();
updateLaunchConfigurationDialog();
}
});
|
| private void | createSingleTestSection(org.eclipse.swt.widgets.Composite comp)
mTestRadioButton = new Button(comp, SWT.RADIO);
mTestRadioButton.setText(JUnitMessages.JUnitLaunchConfigurationTab_label_oneTest);
GridData gd = new GridData();
gd.horizontalSpan = 3;
mTestRadioButton.setLayoutData(gd);
mTestRadioButton.addSelectionListener(new SelectionAdapter() {
@Override
public void widgetSelected(SelectionEvent e) {
if (mTestRadioButton.getSelection()) {
testModeChanged();
}
}
});
mProjLabel = new Label(comp, SWT.NONE);
mProjLabel.setText(JUnitMessages.JUnitLaunchConfigurationTab_label_project);
gd = new GridData();
gd.horizontalIndent = 25;
mProjLabel.setLayoutData(gd);
mProjText = new Text(comp, SWT.SINGLE | SWT.BORDER);
mProjText.setLayoutData(new GridData(GridData.FILL_HORIZONTAL));
mProjText.addModifyListener(new ModifyListener() {
public void modifyText(ModifyEvent evt) {
validatePage();
updateLaunchConfigurationDialog();
mSearchButton.setEnabled(mTestRadioButton.getSelection() &&
mProjText.getText().length() > 0);
}
});
mProjButton = new Button(comp, SWT.PUSH);
mProjButton.setText(JUnitMessages.JUnitLaunchConfigurationTab_label_browse);
mProjButton.addSelectionListener(new SelectionAdapter() {
@Override
public void widgetSelected(SelectionEvent evt) {
handleProjectButtonSelected();
}
});
setButtonGridData(mProjButton);
mTestLabel = new Label(comp, SWT.NONE);
gd = new GridData();
gd.horizontalIndent = 25;
mTestLabel.setLayoutData(gd);
mTestLabel.setText(JUnitMessages.JUnitLaunchConfigurationTab_label_test);
mTestText = new Text(comp, SWT.SINGLE | SWT.BORDER);
mTestText.setLayoutData(new GridData(GridData.FILL_HORIZONTAL));
mTestText.addModifyListener(new ModifyListener() {
public void modifyText(ModifyEvent evt) {
validatePage();
updateLaunchConfigurationDialog();
}
});
mSearchButton = new Button(comp, SWT.PUSH);
mSearchButton.setEnabled(mProjText.getText().length() > 0);
mSearchButton.setText(JUnitMessages.JUnitLaunchConfigurationTab_label_search);
mSearchButton.addSelectionListener(new SelectionAdapter() {
@Override
public void widgetSelected(SelectionEvent evt) {
handleSearchButtonSelected();
}
});
setButtonGridData(mSearchButton);
new Label(comp, SWT.NONE);
mTestMethodLabel = new Label(comp, SWT.NONE);
mTestMethodLabel.setText(""); //$NON-NLS-1$
gd = new GridData();
gd.horizontalSpan = 2;
mTestMethodLabel.setLayoutData(gd);
|
| private void | createSpacer(org.eclipse.swt.widgets.Composite comp)
Label label = new Label(comp, SWT.NONE);
GridData gd = new GridData();
gd.horizontalSpan = 3;
label.setLayoutData(gd);
|
| private void | createTestContainerSelectionGroup(org.eclipse.swt.widgets.Composite comp)
mTestContainerRadioButton = new Button(comp, SWT.RADIO);
mTestContainerRadioButton.setText(
"Run all tests in the selected project, or package");
GridData gd = new GridData();
gd.horizontalSpan = 3;
mTestContainerRadioButton.setLayoutData(gd);
mTestContainerRadioButton.addSelectionListener(new SelectionListener() {
public void widgetSelected(SelectionEvent e) {
if (mTestContainerRadioButton.getSelection()) {
testModeChanged();
}
}
public void widgetDefaultSelected(SelectionEvent e) {
}
});
mContainerText = new Text(comp, SWT.SINGLE | SWT.BORDER | SWT.READ_ONLY);
gd = new GridData(GridData.FILL_HORIZONTAL);
gd.horizontalIndent = 25;
gd.horizontalSpan = 2;
mContainerText.setLayoutData(gd);
mContainerText.addModifyListener(new ModifyListener() {
public void modifyText(ModifyEvent evt) {
updateLaunchConfigurationDialog();
}
});
mContainerSearchButton = new Button(comp, SWT.PUSH);
mContainerSearchButton.setText(JUnitMessages.JUnitLaunchConfigurationTab_label_search);
mContainerSearchButton.addSelectionListener(new SelectionAdapter() {
@Override
public void widgetSelected(SelectionEvent evt) {
handleContainerSearchButtonSelected();
}
});
setButtonGridData(mContainerSearchButton);
|
| public void | dispose()
super.dispose();
if (mTabIcon != null) {
mTabIcon.dispose();
mTabIcon = null;
}
mJavaElementLabelProvider.dispose();
|
| private org.eclipse.jdt.core.IJavaElement | getContext()Returns the current Java element context from which to initialize
default settings, or null if none.
IWorkbenchWindow activeWorkbenchWindow =
PlatformUI.getWorkbench().getActiveWorkbenchWindow();
if (activeWorkbenchWindow == null) {
return null;
}
IWorkbenchPage page = activeWorkbenchWindow.getActivePage();
if (page != null) {
ISelection selection = page.getSelection();
if (selection instanceof IStructuredSelection) {
IStructuredSelection ss = (IStructuredSelection) selection;
if (!ss.isEmpty()) {
Object obj = ss.getFirstElement();
if (obj instanceof IJavaElement) {
return (IJavaElement) obj;
}
if (obj instanceof IResource) {
IJavaElement je = JavaCore.create((IResource) obj);
if (je == null) {
IProject pro = ((IResource) obj).getProject();
je = JavaCore.create(pro);
}
if (je != null) {
return je;
}
}
}
}
IEditorPart part = page.getActiveEditor();
if (part != null) {
IEditorInput input = part.getEditorInput();
return (IJavaElement) input.getAdapter(IJavaElement.class);
}
}
return null;
|
| public java.lang.String | getId()
return "com.android.ide.eclipse.adt.launch.AndroidJUnitLaunchConfigurationTab"; //$NON-NLS-1$
|
| public org.eclipse.swt.graphics.Image | getImage()
// reuse icon from the Android App Launch config tab
if (mTabIcon == null) {
mTabIcon = AdtPlugin.getImageLoader().loadImage(MainLaunchConfigTab.LAUNCH_TAB_IMAGE,
null);
}
return mTabIcon;
|
| private org.eclipse.jdt.core.IJavaModel | getJavaModel()Convenience method to get access to the java model.
return JavaCore.create(getWorkspaceRoot());
|
| private org.eclipse.jdt.core.IJavaProject | getJavaProject()Return the IJavaProject corresponding to the project name in the project name
text field, or null if the text does not match a Android project name.
String projectName = getProjectName();
return getJavaModel().getJavaProject(projectName);
|
| public java.lang.String | getName()
return JUnitMessages.JUnitLaunchConfigurationTab_tab_label;
|
| private java.lang.String | getPresentationName(org.eclipse.jdt.core.IJavaElement element)
return mJavaElementLabelProvider.getText(element);
|
| private java.lang.String | getProjectName()Returns the name of the currently specified project. Null if no project is selected.
String projectName = mProjText.getText().trim();
if (projectName.length() < 1) {
return null;
}
return projectName;
|
| private java.lang.String | getSelectedInstrumentation()
int selectionIndex = mInstrumentationCombo.getSelectionIndex();
if (mInstrumentations != null && selectionIndex >= 0 &&
selectionIndex < mInstrumentations.length) {
return mInstrumentations[selectionIndex];
}
return null;
|
| private org.eclipse.jdt.internal.junit.launcher.ITestKind | getTestKind()
// harddcode this to JUnit 3
return TestKindRegistry.getDefault().getKind(TestKindRegistry.JUNIT3_TEST_KIND_ID);
|
| private org.eclipse.core.resources.IWorkspaceRoot | getWorkspaceRoot()Convenience method to get the workspace root.
return ResourcesPlugin.getWorkspace().getRoot();
|
| private void | handleContainerSearchButtonSelected()
IJavaElement javaElement = chooseContainer(mContainerElement);
if (javaElement != null) {
setContainerElement(javaElement);
}
|
| private void | handleProjectButtonSelected()Show a dialog that lets the user select a Android project. This in turn provides
context for the main type, allowing the user to key a main type name, or
constraining the search for main types to the specified project.
IJavaProject project = mProjectChooserHelper.chooseJavaProject(getProjectName());
if (project == null) {
return;
}
String projectName = project.getElementName();
mProjText.setText(projectName);
loadInstrumentations(project.getProject());
|
| private void | handleSearchButtonSelected()Show a dialog that lists all main types
Shell shell = getShell();
IJavaProject javaProject = getJavaProject();
IType[] types = new IType[0];
boolean[] radioSetting = new boolean[2];
try {
// fix for Eclipse bug 66922 Wrong radio behaviour when switching
// remember the selected radio button
radioSetting[0] = mTestRadioButton.getSelection();
radioSetting[1] = mTestContainerRadioButton.getSelection();
types = TestSearchEngine.findTests(getLaunchConfigurationDialog(), javaProject,
getTestKind());
} catch (InterruptedException e) {
setErrorMessage(e.getMessage());
return;
} catch (InvocationTargetException e) {
AdtPlugin.log(e.getTargetException(), "Error finding test types"); //$NON-NLS-1$
return;
} finally {
mTestRadioButton.setSelection(radioSetting[0]);
mTestContainerRadioButton.setSelection(radioSetting[1]);
}
SelectionDialog dialog = new TestSelectionDialog(shell, types);
dialog.setTitle(JUnitMessages.JUnitLaunchConfigurationTab_testdialog_title);
dialog.setMessage(JUnitMessages.JUnitLaunchConfigurationTab_testdialog_message);
if (dialog.open() == Window.CANCEL) {
return;
}
Object[] results = dialog.getResult();
if ((results == null) || (results.length < 1)) {
return;
}
IType type = (IType) results[0];
if (type != null) {
mTestText.setText(type.getFullyQualifiedName('."));
javaProject = type.getJavaProject();
mProjText.setText(javaProject.getElementName());
}
|
| public void | initializeFrom(org.eclipse.debug.core.ILaunchConfiguration config)
String projectName = updateProjectFromConfig(config);
String containerHandle = EMPTY_STRING;
try {
containerHandle = config.getAttribute(
JUnitLaunchConfigurationConstants.ATTR_TEST_CONTAINER, EMPTY_STRING);
} catch (CoreException ce) {
// ignore
}
if (containerHandle.length() > 0) {
updateTestContainerFromConfig(config);
} else {
updateTestTypeFromConfig(config);
}
IProject proj = mProjectChooserHelper.getAndroidProject(projectName);
loadInstrumentations(proj);
updateInstrumentationFromConfig(config);
validatePage();
|
| private void | initializeJavaProject(org.eclipse.jdt.core.IJavaElement javaElement, org.eclipse.debug.core.ILaunchConfigurationWorkingCopy config)
IJavaProject javaProject = javaElement.getJavaProject();
String name = null;
if (javaProject != null && javaProject.exists()) {
name = javaProject.getElementName();
}
config.setAttribute(IJavaLaunchConfigurationConstants.ATTR_PROJECT_NAME, name);
|
| private void | initializeName(org.eclipse.debug.core.ILaunchConfigurationWorkingCopy config, java.lang.String name)
if (name == null) {
name = EMPTY_STRING;
}
if (name.length() > 0) {
int index = name.lastIndexOf('.");
if (index > 0) {
name = name.substring(index + 1);
}
name = getLaunchConfigurationDialog().generateName(name);
config.rename(name);
}
|
| private void | initializeTestAttributes(org.eclipse.jdt.core.IJavaElement javaElement, org.eclipse.debug.core.ILaunchConfigurationWorkingCopy config)
if (javaElement != null && javaElement.getElementType() < IJavaElement.COMPILATION_UNIT) {
initializeTestContainer(javaElement, config);
} else {
initializeTestType(javaElement, config);
}
|
| private void | initializeTestContainer(org.eclipse.jdt.core.IJavaElement javaElement, org.eclipse.debug.core.ILaunchConfigurationWorkingCopy config)
config.setAttribute(JUnitLaunchConfigurationConstants.ATTR_TEST_CONTAINER,
javaElement.getHandleIdentifier());
initializeName(config, javaElement.getElementName());
|
| private void | initializeTestType(org.eclipse.jdt.core.IJavaElement javaElement, org.eclipse.debug.core.ILaunchConfigurationWorkingCopy config)Sets the main type & name attributes on the working copy based on the IJavaElement
String name = EMPTY_STRING;
String testKindId = null;
try {
// only do a search for compilation units or class files or source references
if (javaElement instanceof ISourceReference) {
ITestKind testKind = TestKindRegistry.getContainerTestKind(javaElement);
testKindId = testKind.getId();
IType[] types = TestSearchEngine.findTests(getLaunchConfigurationDialog(),
javaElement, testKind);
if ((types == null) || (types.length < 1)) {
return;
}
// Simply grab the first main type found in the searched element
name = types[0].getFullyQualifiedName('.");
}
} catch (InterruptedException ie) {
// ignore
} catch (InvocationTargetException ite) {
// ignore
}
config.setAttribute(IJavaLaunchConfigurationConstants.ATTR_MAIN_TYPE_NAME, name);
if (testKindId != null) {
config.setAttribute(JUnitLaunchConfigurationConstants.ATTR_TEST_RUNNER_KIND,
testKindId);
}
initializeName(config, name);
|
| public boolean | isValid(org.eclipse.debug.core.ILaunchConfiguration config)
validatePage();
return getErrorMessage() == null;
|
| private void | loadInstrumentations(org.eclipse.core.resources.IProject project)Loads the UI with the instrumentations of the specified project, and stores the
instrumentations in mInstrumentations.
try {
mInstrValidator = new InstrumentationRunnerValidator(project);
mInstrumentations = (mInstrValidator == null ? null :
mInstrValidator.getInstrumentationNames());
if (mInstrumentations != null) {
mInstrumentationCombo.removeAll();
for (String instrumentation : mInstrumentations) {
mInstrumentationCombo.add(instrumentation);
}
// the selection will be set when we update the ui from the current
// config object.
return;
}
} catch (CoreException e) {
AdtPlugin.logAndPrintError(e, TAG, "ERROR: Failed to get instrumentations for %1$s",
project.getName());
}
// if we reach this point, either project is null, or we got an exception during
// the parsing. In either case, we empty the instrumentation list.
mInstrValidator = null;
mInstrumentations = null;
mInstrumentationCombo.removeAll();
|
| private void | mapResources(org.eclipse.debug.core.ILaunchConfigurationWorkingCopy config)
JUnitMigrationDelegate.mapResources(config);
|
| public void | performApply(org.eclipse.debug.core.ILaunchConfigurationWorkingCopy config)
if (mTestContainerRadioButton.getSelection() && mContainerElement != null) {
config.setAttribute(IJavaLaunchConfigurationConstants.ATTR_PROJECT_NAME,
mContainerElement.getJavaProject().getElementName());
config.setAttribute(JUnitLaunchConfigurationConstants.ATTR_TEST_CONTAINER,
mContainerElement.getHandleIdentifier());
config.setAttribute(IJavaLaunchConfigurationConstants.ATTR_MAIN_TYPE_NAME,
EMPTY_STRING);
//workaround for Eclipse bug 65399
config.setAttribute(JUnitLaunchConfigurationConstants.ATTR_TEST_METHOD_NAME,
EMPTY_STRING);
} else {
config.setAttribute(IJavaLaunchConfigurationConstants.ATTR_PROJECT_NAME,
mProjText.getText());
config.setAttribute(IJavaLaunchConfigurationConstants.ATTR_MAIN_TYPE_NAME,
mTestText.getText());
config.setAttribute(JUnitLaunchConfigurationConstants.ATTR_TEST_CONTAINER,
EMPTY_STRING);
config.setAttribute(JUnitLaunchConfigurationConstants.ATTR_TEST_METHOD_NAME,
mOriginalTestMethodName);
}
try {
mapResources(config);
} catch (CoreException e) {
// TODO: does the real error need to be extracted out of CoreException
AdtPlugin.log(e, "Error occurred saving configuration"); //$NON-NLS-1$
}
AndroidJUnitLaunchConfigDelegate.setJUnitDefaults(config);
config.setAttribute(AndroidJUnitLaunchConfigDelegate.ATTR_INSTR_NAME,
getSelectedInstrumentation());
|
| private void | setButtonGridData(org.eclipse.swt.widgets.Button button)
GridData gridData = new GridData();
button.setLayoutData(gridData);
LayoutUtil.setButtonDimensionHint(button);
|
| private void | setContainerElement(org.eclipse.jdt.core.IJavaElement javaElement)
mContainerElement = javaElement;
mContainerText.setText(getPresentationName(javaElement));
validatePage();
updateLaunchConfigurationDialog();
|
| public void | setDefaults(org.eclipse.debug.core.ILaunchConfigurationWorkingCopy config)
IJavaElement javaElement = getContext();
if (javaElement != null) {
initializeJavaProject(javaElement, config);
} else {
// We set empty attributes for project & main type so that when one config is
// compared to another, the existence of empty attributes doesn't cause an
// incorrect result (the performApply() method can result in empty values
// for these attributes being set on a config if there is nothing in the
// corresponding text boxes)
config.setAttribute(IJavaLaunchConfigurationConstants.ATTR_PROJECT_NAME, EMPTY_STRING);
config.setAttribute(JUnitLaunchConfigurationConstants.ATTR_TEST_CONTAINER,
EMPTY_STRING);
}
initializeTestAttributes(javaElement, config);
|
| private void | setEnableContainerTestGroup(boolean enabled)
mContainerSearchButton.setEnabled(enabled);
mContainerText.setEnabled(enabled);
|
| private void | setEnableSingleTestGroup(boolean enabled)
mProjLabel.setEnabled(enabled);
mProjText.setEnabled(enabled);
mProjButton.setEnabled(enabled);
mTestLabel.setEnabled(enabled);
mTestText.setEnabled(enabled);
mSearchButton.setEnabled(enabled && mProjText.getText().length() > 0);
mTestMethodLabel.setEnabled(enabled);
|
| private void | setTestMethodLabel(java.lang.String testMethodName)
if (!EMPTY_STRING.equals(testMethodName)) {
mTestMethodLabel.setText(
JUnitMessages.JUnitLaunchConfigurationTab_label_method +
mOriginalTestMethodName);
} else {
mTestMethodLabel.setText(EMPTY_STRING);
}
|
| private void | testModeChanged()
boolean isSingleTestMode = mTestRadioButton.getSelection();
setEnableSingleTestGroup(isSingleTestMode);
setEnableContainerTestGroup(!isSingleTestMode);
if (!isSingleTestMode && mContainerText.getText().length() == 0) {
String projText = mProjText.getText();
if (Path.EMPTY.isValidSegment(projText)) {
IJavaProject javaProject = getJavaModel().getJavaProject(projText);
if (javaProject != null && javaProject.exists()) {
setContainerElement(javaProject);
}
}
}
validatePage();
updateLaunchConfigurationDialog();
|
| private void | updateInstrumentationFromConfig(org.eclipse.debug.core.ILaunchConfiguration config)
boolean found = false;
try {
String currentInstrumentation = config.getAttribute(
AndroidJUnitLaunchConfigDelegate.ATTR_INSTR_NAME, EMPTY_STRING);
if (mInstrumentations != null) {
// look for the name of the instrumentation in the combo.
for (int i = 0; i < mInstrumentations.length; i++) {
if (currentInstrumentation.equals(mInstrumentations[i])) {
found = true;
mInstrumentationCombo.select(i);
break;
}
}
}
} catch (CoreException ce) {
// ignore
}
if (!found) {
mInstrumentationCombo.clearSelection();
}
|
| private java.lang.String | updateProjectFromConfig(org.eclipse.debug.core.ILaunchConfiguration config)
String projectName = EMPTY_STRING;
try {
projectName = config.getAttribute(IJavaLaunchConfigurationConstants.ATTR_PROJECT_NAME,
EMPTY_STRING);
} catch (CoreException ce) {
// ignore
}
mProjText.setText(projectName);
return projectName;
|
| private void | updateTestContainerFromConfig(org.eclipse.debug.core.ILaunchConfiguration config)
String containerHandle = EMPTY_STRING;
IJavaElement containerElement = null;
try {
containerHandle = config.getAttribute(
JUnitLaunchConfigurationConstants.ATTR_TEST_CONTAINER, EMPTY_STRING);
if (containerHandle.length() > 0) {
containerElement = JavaCore.create(containerHandle);
}
} catch (CoreException ce) {
// ignore
}
if (containerElement != null) {
mContainerElement = containerElement;
}
mTestContainerRadioButton.setSelection(true);
setEnableSingleTestGroup(false);
setEnableContainerTestGroup(true);
mTestRadioButton.setSelection(false);
if (mContainerElement != null) {
mContainerText.setText(getPresentationName(mContainerElement));
}
mTestText.setText(EMPTY_STRING);
|
| private void | updateTestTypeFromConfig(org.eclipse.debug.core.ILaunchConfiguration config)
String testTypeName = EMPTY_STRING;
mOriginalTestMethodName = EMPTY_STRING;
try {
testTypeName = config.getAttribute(
IJavaLaunchConfigurationConstants.ATTR_MAIN_TYPE_NAME, ""); //$NON-NLS-1$
mOriginalTestMethodName = config.getAttribute(
JUnitLaunchConfigurationConstants.ATTR_TEST_METHOD_NAME, ""); //$NON-NLS-1$
} catch (CoreException ce) {
// ignore
}
mTestRadioButton.setSelection(true);
setEnableSingleTestGroup(true);
setEnableContainerTestGroup(false);
mTestContainerRadioButton.setSelection(false);
mTestText.setText(testTypeName);
mContainerText.setText(EMPTY_STRING);
setTestMethodLabel(mOriginalTestMethodName);
|
| private void | validateInstrumentation()
String instrumentation = getSelectedInstrumentation();
if (instrumentation == null) {
setErrorMessage("Instrumentation runner not specified");
return;
}
String result = mInstrValidator.validateInstrumentationRunner(instrumentation);
if (result != InstrumentationRunnerValidator.INSTRUMENTATION_OK) {
setErrorMessage(result);
return;
}
|
| private void | validateJavaProject(org.eclipse.jdt.core.IJavaProject javaProject)
if (!TestSearchEngine.hasTestCaseType(javaProject)) {
setErrorMessage(JUnitMessages.JUnitLaunchConfigurationTab_error_testcasenotonpath);
return;
}
|
| private void | validatePage()
setErrorMessage(null);
setMessage(null);
if (mTestContainerRadioButton.getSelection()) {
if (mContainerElement == null) {
setErrorMessage(JUnitMessages.JUnitLaunchConfigurationTab_error_noContainer);
return;
}
validateJavaProject(mContainerElement.getJavaProject());
return;
}
String projectName = mProjText.getText().trim();
if (projectName.length() == 0) {
setErrorMessage(JUnitMessages.JUnitLaunchConfigurationTab_error_projectnotdefined);
return;
}
IStatus status = ResourcesPlugin.getWorkspace().validatePath(IPath.SEPARATOR + projectName,
IResource.PROJECT);
if (!status.isOK() || !Path.ROOT.isValidSegment(projectName)) {
setErrorMessage(Messages.format(
JUnitMessages.JUnitLaunchConfigurationTab_error_invalidProjectName,
projectName));
return;
}
IProject project = getWorkspaceRoot().getProject(projectName);
if (!project.exists()) {
setErrorMessage(JUnitMessages.JUnitLaunchConfigurationTab_error_projectnotexists);
return;
}
IJavaProject javaProject = JavaCore.create(project);
validateJavaProject(javaProject);
try {
if (!project.hasNature(AndroidConstants.NATURE)) {
setErrorMessage("Specified project is not an Android project");
return;
}
String className = mTestText.getText().trim();
if (className.length() == 0) {
setErrorMessage(JUnitMessages.JUnitLaunchConfigurationTab_error_testnotdefined);
return;
}
if (javaProject.findType(className) == null) {
setErrorMessage(Messages.format(
JUnitMessages.JUnitLaunchConfigurationTab_error_test_class_not_found,
new String[] { className, projectName }));
return;
}
} catch (CoreException e) {
AdtPlugin.log(e, "validatePage failed"); //$NON-NLS-1$
}
validateInstrumentation();
|
