Java tutorial
/* * Copyright (C) 2009 The Android Open Source Project * * Licensed under the Eclipse Public License, Version 1.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.eclipse.org/org/documents/epl-v10.php * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ package com.android.ide.eclipse.adt.internal.launch.junit; import com.android.SdkConstants; import com.android.ide.eclipse.adt.AdtConstants; import com.android.ide.eclipse.adt.AdtPlugin; import com.android.ide.eclipse.adt.internal.editors.IconFactory; import com.android.ide.eclipse.adt.internal.launch.LaunchMessages; import com.android.ide.eclipse.adt.internal.launch.MainLaunchConfigTab; import com.android.ide.eclipse.adt.internal.project.BaseProjectHelper; import com.android.ide.eclipse.adt.internal.project.ProjectChooserHelper; import org.eclipse.core.resources.IProject; import org.eclipse.core.resources.IResource; import org.eclipse.core.resources.IWorkspaceRoot; import org.eclipse.core.resources.ResourcesPlugin; import org.eclipse.core.runtime.CoreException; import org.eclipse.core.runtime.IPath; import org.eclipse.core.runtime.IStatus; import org.eclipse.core.runtime.Path; import org.eclipse.debug.core.ILaunchConfiguration; import org.eclipse.debug.core.ILaunchConfigurationWorkingCopy; import org.eclipse.debug.ui.AbstractLaunchConfigurationTab; import org.eclipse.jdt.core.IJavaElement; import org.eclipse.jdt.core.IJavaModel; import org.eclipse.jdt.core.IJavaProject; import org.eclipse.jdt.core.IPackageFragment; import org.eclipse.jdt.core.IPackageFragmentRoot; import org.eclipse.jdt.core.ISourceReference; import org.eclipse.jdt.core.IType; import org.eclipse.jdt.core.JavaCore; import org.eclipse.jdt.core.JavaModelException; import org.eclipse.jdt.internal.junit.Messages; import org.eclipse.jdt.internal.junit.launcher.ITestKind; import org.eclipse.jdt.internal.junit.launcher.JUnitLaunchConfigurationConstants; import org.eclipse.jdt.internal.junit.launcher.JUnitMigrationDelegate; import org.eclipse.jdt.internal.junit.launcher.TestKindRegistry; import org.eclipse.jdt.internal.junit.launcher.TestSelectionDialog; import org.eclipse.jdt.internal.junit.ui.JUnitMessages; import org.eclipse.jdt.internal.junit.util.LayoutUtil; import org.eclipse.jdt.internal.junit.util.TestSearchEngine; import org.eclipse.jdt.internal.ui.wizards.TypedElementSelectionValidator; import org.eclipse.jdt.internal.ui.wizards.TypedViewerFilter; import org.eclipse.jdt.launching.IJavaLaunchConfigurationConstants; import org.eclipse.jdt.ui.JavaElementComparator; import org.eclipse.jdt.ui.JavaElementLabelProvider; import org.eclipse.jdt.ui.StandardJavaElementContentProvider; import org.eclipse.jface.dialogs.Dialog; import org.eclipse.jface.layout.GridDataFactory; import org.eclipse.jface.viewers.ILabelProvider; import org.eclipse.jface.viewers.ISelection; import org.eclipse.jface.viewers.IStructuredSelection; import org.eclipse.jface.viewers.Viewer; import org.eclipse.jface.viewers.ViewerFilter; import org.eclipse.jface.window.Window; import org.eclipse.swt.SWT; import org.eclipse.swt.events.ModifyEvent; import org.eclipse.swt.events.ModifyListener; import org.eclipse.swt.events.SelectionAdapter; import org.eclipse.swt.events.SelectionEvent; import org.eclipse.swt.graphics.Image; import org.eclipse.swt.layout.GridData; import org.eclipse.swt.layout.GridLayout; import org.eclipse.swt.widgets.Button; import org.eclipse.swt.widgets.Combo; import org.eclipse.swt.widgets.Composite; import org.eclipse.swt.widgets.Label; import org.eclipse.swt.widgets.Shell; import org.eclipse.swt.widgets.Text; import org.eclipse.ui.IEditorInput; import org.eclipse.ui.IEditorPart; import org.eclipse.ui.IWorkbenchPage; import org.eclipse.ui.IWorkbenchWindow; import org.eclipse.ui.PlatformUI; import org.eclipse.ui.dialogs.ElementTreeSelectionDialog; import org.eclipse.ui.dialogs.SelectionDialog; import java.lang.reflect.InvocationTargetException; import java.util.Arrays; import java.util.List; /** * The launch config UI tab for Android JUnit * <p/> * Based on org.eclipse.jdt.junit.launcher.JUnitLaunchConfigurationTab */ @SuppressWarnings("restriction") public class AndroidJUnitLaunchConfigurationTab extends AbstractLaunchConfigurationTab { // Project UI widgets private Label mProjLabel; private Text mProjText; private Button mProjButton; // Test class UI widgets private Text mTestText; private Button mSearchButton; private String mOriginalTestMethodName; private Label mTestMethodLabel; private Text mContainerText; private IJavaElement mContainerElement; private final ILabelProvider mJavaElementLabelProvider = new JavaElementLabelProvider(); private Button mContainerSearchButton; private Button mTestContainerRadioButton; private Button mTestRadioButton; private Label mTestLabel; // Android specific members private Image mTabIcon = null; private Combo mInstrumentationCombo; private Combo mTestSizeCombo; private static final String EMPTY_STRING = ""; //$NON-NLS-1$ private static final String TAG = "AndroidJUnitLaunchConfigurationTab"; //$NON-NLS-1$ private String[] mInstrumentations = null; private InstrumentationRunnerValidator mInstrValidator = null; private ProjectChooserHelper mProjectChooserHelper; public static final String SMALL_TEST_ANNOTATION = "@SmallTest"; //$NON-NLS-1$ public static final String MEDIUM_TEST_ANNOTATION = "@MediumTest"; //$NON-NLS-1$ public static final String LARGE_TEST_ANNOTATION = "@LargeTest"; //$NON-NLS-1$ private static final List<String> TEST_SIZE_OPTIONS = Arrays.asList("All Tests", SMALL_TEST_ANNOTATION, MEDIUM_TEST_ANNOTATION, LARGE_TEST_ANNOTATION); /* (non-Javadoc) * @see org.eclipse.debug.ui.ILaunchConfigurationTab#createControl(org.eclipse.swt.widgets.Composite) */ @Override public void createControl(Composite parent) { mProjectChooserHelper = new ProjectChooserHelper(parent.getShell(), null /*filter*/); 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); createSizeSelector(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 createSpacer(Composite comp) { Label label = new Label(comp, SWT.NONE); GridData gd = new GridData(); gd.horizontalSpan = 3; label.setLayoutData(gd); } private void createSingleTestSection(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() { @Override 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() { @Override 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 createTestContainerSelectionGroup(Composite comp) { mTestContainerRadioButton = new Button(comp, SWT.RADIO); mTestContainerRadioButton.setText(LaunchMessages.AndroidJUnitTab_TestContainerText); GridData gd = new GridData(); gd.horizontalSpan = 3; mTestContainerRadioButton.setLayoutData(gd); mTestContainerRadioButton.addSelectionListener(new SelectionAdapter() { @Override public void widgetSelected(SelectionEvent e) { if (mTestContainerRadioButton.getSelection()) { testModeChanged(); } } }); 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() { @Override 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); } private void createInstrumentationGroup(Composite comp) { Label loaderLabel = new Label(comp, SWT.NONE); loaderLabel.setText(LaunchMessages.AndroidJUnitTab_LoaderLabel); GridData gd = new GridData(); gd.horizontalIndent = 0; loaderLabel.setLayoutData(gd); mInstrumentationCombo = new Combo(comp, SWT.DROP_DOWN | SWT.READ_ONLY); GridDataFactory.defaultsFor(mInstrumentationCombo).span(2, 1).applyTo(mInstrumentationCombo); mInstrumentationCombo.clearSelection(); mInstrumentationCombo.addSelectionListener(new SelectionAdapter() { @Override public void widgetSelected(SelectionEvent e) { validatePage(); updateLaunchConfigurationDialog(); } }); } private void createSizeSelector(Composite comp) { Label l = new Label(comp, SWT.NONE); l.setText(LaunchMessages.AndroidJUnitTab_SizeLabel); GridData gd = new GridData(); gd.horizontalIndent = 0; l.setLayoutData(gd); mTestSizeCombo = new Combo(comp, SWT.DROP_DOWN | SWT.READ_ONLY); mTestSizeCombo.setItems(TEST_SIZE_OPTIONS.toArray(new String[TEST_SIZE_OPTIONS.size()])); mTestSizeCombo.select(0); mTestSizeCombo.addSelectionListener(new SelectionAdapter() { @Override public void widgetSelected(SelectionEvent e) { updateLaunchConfigurationDialog(); } }); } private void handleContainerSearchButtonSelected() { IJavaElement javaElement = chooseContainer(mContainerElement); if (javaElement != null) { setContainerElement(javaElement); } } private void setContainerElement(IJavaElement javaElement) { mContainerElement = javaElement; mContainerText.setText(getPresentationName(javaElement)); validatePage(); updateLaunchConfigurationDialog(); } /* (non-Javadoc) * @see org.eclipse.debug.ui.ILaunchConfigurationTab#initializeFrom(org.eclipse.debug.core.ILaunchConfiguration) */ @Override public void initializeFrom(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); updateTestSizeFromConfig(config); validatePage(); } private void updateInstrumentationFromConfig(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 void updateTestSizeFromConfig(ILaunchConfiguration config) { try { String testSize = config.getAttribute(AndroidJUnitLaunchConfigDelegate.ATTR_TEST_SIZE, EMPTY_STRING); int index = TEST_SIZE_OPTIONS.indexOf(testSize); if (index >= 0 && mTestSizeCombo != null) { mTestSizeCombo.select(index); } } catch (CoreException e) { // ignore } } private String updateProjectFromConfig(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 updateTestTypeFromConfig(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 setTestMethodLabel(String testMethodName) { if (!EMPTY_STRING.equals(testMethodName)) { mTestMethodLabel .setText(JUnitMessages.JUnitLaunchConfigurationTab_label_method + mOriginalTestMethodName); } else { mTestMethodLabel.setText(EMPTY_STRING); } } private void updateTestContainerFromConfig(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); } /* * (non-Javadoc) * @see org.eclipse.debug.ui.ILaunchConfigurationTab#performApply(org.eclipse.debug.core.ILaunchConfigurationWorkingCopy) */ @Override public void performApply(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()); config.setAttribute(AndroidJUnitLaunchConfigDelegate.ATTR_TEST_SIZE, getSelectedTestSize()); } private void mapResources(ILaunchConfigurationWorkingCopy config) throws CoreException { JUnitMigrationDelegate.mapResources(config); } /* (non-Javadoc) * @see org.eclipse.debug.ui.AbstractLaunchConfigurationTab#dispose() */ @Override public void dispose() { super.dispose(); mTabIcon = null; mJavaElementLabelProvider.dispose(); } /* (non-Javadoc) * @see org.eclipse.debug.ui.AbstractLaunchConfigurationTab#getImage() */ @Override public Image getImage() { // reuse icon from the Android App Launch config tab if (mTabIcon == null) { mTabIcon = IconFactory.getInstance().getIcon(MainLaunchConfigTab.LAUNCH_TAB_IMAGE); } return mTabIcon; } /** * Show a dialog that lists all main types */ private void handleSearchButtonSelected() { 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()); } } private ITestKind getTestKind() { // harddcode this to JUnit 3 return TestKindRegistry.getDefault().getKind(TestKindRegistry.JUNIT3_TEST_KIND_ID); } /** * 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. */ private void handleProjectButtonSelected() { IJavaProject project = mProjectChooserHelper.chooseJavaProject(getProjectName(), "Please select a project to launch"); if (project == null) { return; } String projectName = project.getElementName(); mProjText.setText(projectName); loadInstrumentations(project.getProject()); } /** * 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. */ private IJavaProject getJavaProject() { String projectName = getProjectName(); return getJavaModel().getJavaProject(projectName); } /** * Returns the name of the currently specified project. Null if no project is selected. */ private String getProjectName() { String projectName = mProjText.getText().trim(); if (projectName.length() < 1) { return null; } return projectName; } /** * Convenience method to get the workspace root. */ private IWorkspaceRoot getWorkspaceRoot() { return ResourcesPlugin.getWorkspace().getRoot(); } /** * Convenience method to get access to the java model. */ private IJavaModel getJavaModel() { return JavaCore.create(getWorkspaceRoot()); } /* (non-Javadoc) * @see org.eclipse.debug.ui.AbstractLaunchConfigurationTab#isValid(org.eclipse.debug.core.ILaunchConfiguration) */ @Override public boolean isValid(ILaunchConfiguration config) { validatePage(); return getErrorMessage() == null; } 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 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(AdtConstants.NATURE_DEFAULT)) { setErrorMessage(LaunchMessages.NonAndroidProjectError); 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(); } private void validateJavaProject(IJavaProject javaProject) { if (!TestSearchEngine.hasTestCaseType(javaProject)) { setErrorMessage(JUnitMessages.JUnitLaunchConfigurationTab_error_testcasenotonpath); return; } } private void validateInstrumentation() { String instrumentation = getSelectedInstrumentation(); if (instrumentation == null) { setErrorMessage(LaunchMessages.AndroidJUnitTab_NoRunnerError); return; } String result = mInstrValidator.validateInstrumentationRunner(instrumentation); if (result != InstrumentationRunnerValidator.INSTRUMENTATION_OK) { setErrorMessage(result); return; } } private String getSelectedInstrumentation() { int selectionIndex = mInstrumentationCombo.getSelectionIndex(); if (mInstrumentations != null && selectionIndex >= 0 && selectionIndex < mInstrumentations.length) { return mInstrumentations[selectionIndex]; } return null; } private String getSelectedTestSize() { if (mTestSizeCombo != null) { int index = mTestSizeCombo.getSelectionIndex(); return TEST_SIZE_OPTIONS.get(index); } else { return null; } } 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); } /* (non-Javadoc) * @see org.eclipse.debug.ui.ILaunchConfigurationTab#setDefaults(org.eclipse.debug.core.ILaunchConfigurationWorkingCopy) */ @Override public void setDefaults(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 initializeTestAttributes(IJavaElement javaElement, ILaunchConfigurationWorkingCopy config) { if (javaElement != null && javaElement.getElementType() < IJavaElement.COMPILATION_UNIT) { initializeTestContainer(javaElement, config); } else { initializeTestType(javaElement, config); } } private void initializeTestContainer(IJavaElement javaElement, ILaunchConfigurationWorkingCopy config) { config.setAttribute(JUnitLaunchConfigurationConstants.ATTR_TEST_CONTAINER, javaElement.getHandleIdentifier()); initializeName(config, javaElement.getElementName()); } private void initializeName(ILaunchConfigurationWorkingCopy config, 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); } } /** * Sets the main type & name attributes on the working copy based on the IJavaElement */ private void initializeTestType(IJavaElement javaElement, ILaunchConfigurationWorkingCopy config) { 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); } /* (non-Javadoc) * @see org.eclipse.debug.ui.ILaunchConfigurationTab#getName() */ @Override public String getName() { return JUnitMessages.JUnitLaunchConfigurationTab_tab_label; } private IJavaElement chooseContainer(IJavaElement initElement) { @SuppressWarnings("rawtypes") 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; } private String getPresentationName(IJavaElement element) { return mJavaElementLabelProvider.getText(element); } /** * Returns the current Java element context from which to initialize * default settings, or <code>null</code> if none. * * @return Java element context. */ private IJavaElement getContext() { 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; } private void initializeJavaProject(IJavaElement javaElement, 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 setButtonGridData(Button button) { GridData gridData = new GridData(); button.setLayoutData(gridData); LayoutUtil.setButtonDimensionHint(button); } /* (non-Javadoc) * @see org.eclipse.debug.ui.AbstractLaunchConfigurationTab#getId() */ @Override public String getId() { return "com.android.ide.eclipse.adt.launch.AndroidJUnitLaunchConfigurationTab"; //$NON-NLS-1$ } /** * Loads the UI with the instrumentations of the specified project, and stores the * instrumentations in <code>mInstrumentations</code>. * * @param project the {@link IProject} to load the instrumentations from. */ private void loadInstrumentations(IProject project) { try { mInstrValidator = new InstrumentationRunnerValidator(project); mInstrumentations = mInstrValidator.getInstrumentationNames(); if (mInstrumentations.length > 0) { 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, project.getName(), LaunchMessages.AndroidJUnitTab_LoadInstrError_s, SdkConstants.FN_ANDROID_MANIFEST_XML); } // 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(); } /** * Overrides the {@link StandardJavaElementContentProvider} to only display Android projects */ private static class AndroidJavaElementContentProvider extends StandardJavaElementContentProvider { /** * Override parent to return only Android projects if at the root. Otherwise, use parent * functionality. */ @Override public Object[] getChildren(Object element) { if (element instanceof IJavaModel) { return BaseProjectHelper.getAndroidProjects((IJavaModel) element, null /*filter*/); } return super.getChildren(element); } } }