import org.eclipse.core.runtime.IAdaptable;

import org.eclipse.jdt.core.IJavaElement;

import org.eclipse.jdt.core.IMethod;

import org.eclipse.jdt.core.IType;

import org.eclipse.jdt.core.JavaModelException;

	}

	/**

	 * @return the name of the Java Method associated with this {@link TestCaseElement}, ie, it

	 *         returns the valid java identifier part of the name (in particular, it removes the

	 *         brackets suffix for Parameterized JUnit tests).

	 * 

	 * 

	 */

	private String getJavaTestMethodName() {

		String testMethodName= getTestMethodName();

		for (int i= 0; i < testMethodName.length(); i++) {

			if (!Character.isJavaIdentifierPart(testMethodName.charAt(i))) {

				return testMethodName.substring(0, i);

			}

		}

		return testMethodName;

	}

	/**

	 * Finds and returns the {@link IMethod} associated with this {@link TestCaseElement}.

	 * 

	 * @return the corresponding Java method element or null if not found.

	 */

	public IMethod getJavaMethod() {

		if (!fJavaMethodResolved) {

			try {

				final IType type= getJavaType();

				if (type != null) {

					final IMethod[] methods= type.getMethods();

					String testMethodName= getJavaTestMethodName();

					for (int i= 0; i < methods.length; i++) {

						if (methods[i].getElementName().equals(testMethodName)) {

							fJavaMethod= methods[i];

							return methods[i];

						}

					}

				}

				return null;

			} catch (JavaModelException e) {

				JUnitCorePlugin.log(e);

			} finally {

				fJavaMethodResolved= true;

			}

		}

		return fJavaMethod;

	/**

	 * Provides support for converting this {@link TestCaseElement} into an {@link IMethod} when the

	 * given adapter class is {@link IJavaElement}.

	 * 

	 * @param adapter the class in which this {@link TestCaseElement} should be adapted.

	 * @return an object in the request type, or null if it could not be adapted.

	 * @since 3.7

	 */

	public Object getAdapter(Class adapter) {

		if (adapter != null && adapter.equals(IJavaElement.class)) {

			return getJavaMethod();

		}

		return null;

	}

import org.eclipse.jdt.core.IType;

import org.eclipse.jdt.core.JavaModelException;

import org.eclipse.jdt.internal.junit.JUnitCorePlugin;

	private IType fJavaType= null;

	private boolean fJavaTypeResolved= false;

	/**

	 * @return the Java {@link IType} associated with this {@link TestElement}.

	 */

	public IType getJavaType() {

		if (!fJavaTypeResolved) {

			try {

				fJavaType= getTestRunSession().getLaunchedProject().findType(getClassName());

			} catch (JavaModelException e) {

				JUnitCorePlugin.log(e);

			} finally {

				fJavaTypeResolved= true;

			}

		}

		return fJavaType;

	}

import org.eclipse.core.runtime.IAdaptable;

	/**

	 * Provides support for converting this {@link TestSuiteElement} into an {@link IType} (or an

	 * {@link IMethod} when this {@link TestSuiteElement} matches a JUnit Parameterized Test) when

	 * the given adapter class is {@link IJavaElement}.

	 * 

	 * @param adapter the class in which this {@link TestSuiteElement} should be adapted.

	 * @return an object in the request type, or null if it could not be adapted.

	 * @since 3.7

	 */

	public Object getAdapter(Class adapter) {

		if (adapter != null && adapter.equals(IJavaElement.class)) {

			return getJavaElement();

		}

		return null;

	}

	/**

	 * Returns the closest {@link IJavaElement} for the given {@link TestSuiteElement}, including

	 * with a work-around for Parameterized tests by looking at the child elements: if there's only

	 * one, return its Java {@link IMethod}. Otherwise, return the {@link IType}

	 * 

	 * @return the {@link IJavaElement} found for this {@link TestSuiteElement}.

	 * 

	 * @see TestElement#getJavaType()

	 */

	public IJavaElement getJavaElement() {

		if (!fJavaElementResolved) {

			// whatever happens, let's consider that the Java Type has been resolved, to make sure we don't come back here again for this TestSuitElement.

			fJavaElementResolved= true;

			fJavaElement= super.getJavaType();

			if (fJavaElement == null) {

				if (getChildren().length == 1 && getChildren()[0] instanceof TestCaseElement) {

					fJavaElement= ((TestCaseElement)getChildren()[0]).getJavaMethod();

				}

			}

		}

		return fJavaElement;

	}

	/**

	 * Returns the {@link IType} associated with the given {@link TestSuiteElement}, or uses the

	 * work-around in {@link TestSuiteElement#getJavaElement()} to retrieve the {@link IType}

	 * associated with the single child {@link TestCaseElement} if this {@link TestSuiteElement}

	 * matches a Parameterized JUnit Test.

	 * 

	 * @see TestElement#getJavaType()

	 */

	public IType getJavaType() {

		final IType javaType= super.getJavaType();

		if (javaType != null) {

			return javaType;

		} else if (getJavaElement() != null) {

			return (IType)fJavaElement.getAncestor(IJavaElement.TYPE);

		}

		return null;

	}

 *     Xavier Coulon <xcoulon@redhat.com> -  [JUnit] Add "Link with Editor" to JUnit view - https://bugs.eclipse.org/bugs/show_bug.cgi?id=372588

import org.eclipse.jface.viewers.ISelection;

import org.eclipse.jdt.internal.ui.JavaPluginImages;

import org.eclipse.jdt.internal.ui.actions.AbstractToggleLinkingAction;

	/**

	 * Helper to open and activate editors.

	 * 

	 * @since 3.7

	 */

	private LinkWithEditorAction fLinkWithEditorAction;

					fLinkWithEditorAction.setEnabled(fTestRunSession != null);

					setLinkingWithEditorActive(fTestRunSession != null);

	}

	/**

	 * This action toggles whether this {@link TestRunnerViewPart} links its selection to the active

	 * editor.

	 *

	 */

	private class LinkWithEditorAction extends AbstractToggleLinkingAction {

		/** Image to use when the sync is on.*/

		private static final String SYNCED_GIF= "synced.gif"; //$NON-NLS-1$

		/** Image to use when the sync is broken.*/

		private static final String SYNC_BROKEN_GIF= "sync_broken.gif"; //$NON-NLS-1$

		private String fIconName = SYNC_BROKEN_GIF;

		LinkWithEditorAction() {

			// enable by default

			setChecked(true);

		}

		@Override

		public void run() {

			setLinkingWithEditorActive(isChecked());

		}

		/**

		 * Updates the Link image with a "normal link" image if parameter is true, or a

		 * "broken link" image otherwise

		 * 

		 * @param isInSync the state of synchronization

		 */

		public void updateLinkImage(boolean isInSync) {

			String iconName= isInSync ? SYNCED_GIF : SYNC_BROKEN_GIF;

			if (!iconName.equals(fIconName)) {

				JavaPluginImages.setLocalImageDescriptors(fLinkWithEditorAction, iconName);

				fIconName= iconName;

			}

		}

	}

	/**

	 * @return {@code true} if the {@link LinkWithEditorAction} is checked, false otherwise.

	 * @since 3.7

	 */

	public boolean isLinkWithEditorActive() {

		return fLinkWithEditorAction.isChecked();

	}

	/**

	 * Activate the 'Link with Editor' in the current {@link IWorkbenchPage}. (The

	 * {@link TestViewer} will respond to {@link ISelection} changes.)

	 * 

	 * @param active boolean to indicate if the link with editor is active ({@code true}) or not (

	 *            {@code false})

	 * 

	 * @since 3.7

	 */

	public void setLinkingWithEditorActive(final boolean active) {

		if (active) {

			getSite().getPage().addPostSelectionListener(fTestViewer);

			fTestViewer.setSelection(getSite().getPage().getActiveEditor());

		} else {

			getSite().getPage().removePostSelectionListener(fTestViewer);

		}

	}

	/**

	 * Updates the Link image with a "normal link" image if parameter is true, or a "broken link"

	 * image otherwise

	 * 

	 * @param isInSync the state of synchronization

	 * 

	 * @since 3.7

	 */

	public void setLinkingWithEditorInSync(final boolean isInSync) {

		fLinkWithEditorAction.updateLinkImage(isInSync);

				fLinkWithEditorAction.setEnabled(true);

				fLinkWithEditorAction.setEnabled(fTestRunSession != null);

				// if "Link with Editor" is active, register the listener

				if (isLinkWithEditorActive()) {

					getSite().getPage().addPostSelectionListener(fTestViewer);

					fTestViewer.setSelection(getSite().getPage().getActiveEditor());

				}

		getSite().getPage().removePostSelectionListener(fTestViewer);

		fLinkWithEditorAction= new LinkWithEditorAction();

		fLinkWithEditorAction.setEnabled(false);

		toolBar.add(new Separator());

		toolBar.add(fLinkWithEditorAction);

import org.eclipse.jdt.junit.model.ITestCaseElement;

import org.eclipse.jdt.junit.model.ITestSuiteElement;

import org.eclipse.jface.viewers.ISelection;

import org.eclipse.jface.viewers.ITreeSelection;

import org.eclipse.jface.text.ITextSelection;

import org.eclipse.ui.IEditorPart;

import org.eclipse.ui.ISelectionListener;

import org.eclipse.ui.IWorkbenchPart;

import org.eclipse.ui.PartInitException;

import org.eclipse.jdt.core.ICompilationUnit;

import org.eclipse.jdt.core.IJavaElement;

import org.eclipse.jdt.core.IMethod;

import org.eclipse.jdt.ui.JavaUI;

import org.eclipse.jdt.internal.ui.javaeditor.CompilationUnitEditor;

import org.eclipse.jdt.internal.ui.javaeditor.EditorUtility;

import org.eclipse.jdt.internal.ui.javaeditor.JavaEditor;

		// if LinkWithEditor is active, reveal the JavaEditor and select the java type or method 

		// matching the selected test element, even if the JavaEditor is opened by not active.

		if (fTestRunnerPart.isLinkWithEditorActive()) {

			handleTestElementSelected(testElement);

		}

	/**

	 * Sets the current selection from the given {@link IEditorPart} (if it is a

	 * {@link CompilationUnitEditor}) and its selection.

	 * 

	 * @param editor the selected Java Element in the active Compilation Unit Editor

	 * 

	 * @since 3.7

	 */

	public void setSelection(final IEditorPart editor) {

		final IJavaElement selectedJavaElement= getSelectedJavaElementInEditor(editor);

		setSelection(selectedJavaElement);

	}

	/**

	 * Sets the current selection from the given {@link IJavaElement} if it matches an

	 * {@link ITestCaseElement} and updates the LinkWithEditorAction image in the associated

	 * {@link TestRunnerViewPart}.

	 * 

	 * @param activeJavaElement the selected Java Element (or null) in the active

	 *            {@link IWorkbenchPart}

	 * 

	 */

	private void setSelection(final IJavaElement activeJavaElement) {

		final ITestElement activeTestCaseElement= findTestElement(activeJavaElement);

		if (activeTestCaseElement != null) {

			// selection is in-sync

			fTestRunnerPart.setLinkingWithEditorInSync(true);

			// update the current selection in the viewer if it does not match with the java element selected in the given part (if it's not the parent TestViewerPart)

			final Object currentSelection= getCurrentViewerSelection();

			if ((currentSelection instanceof TestCaseElement && ((TestCaseElement)currentSelection).getJavaMethod() != null && !((TestCaseElement)currentSelection).getJavaMethod().equals(

					activeJavaElement))

					|| (currentSelection instanceof TestSuiteElement && ((TestSuiteElement)currentSelection).getJavaType() != null && !((TestSuiteElement)currentSelection).getJavaType().equals(

							activeJavaElement))) {

				final IStructuredSelection selection= new StructuredSelection(activeTestCaseElement);

				fSelectionProvider.setSelection(selection, true);

			}

		}

		else {

			// selection is out-of-sync: show a different icon on the button.

			fTestRunnerPart.setLinkingWithEditorInSync(false);

		}

	}

	/**

	 * @return the current selection in the JUnit Viewer (provided by the underlying selection

	 *         provider), or {@code null} if the kind of selection is not an {@link ITreeSelection}

	 *         nor an {@link IStructuredSelection}.

	 */

	private Object getCurrentViewerSelection() {

		final ISelection currentSelection= fSelectionProvider.getSelection();

		if (currentSelection instanceof ITreeSelection) {

			return ((ITreeSelection)currentSelection).getFirstElement();

		} else if (currentSelection instanceof IStructuredSelection) {

			return ((IStructuredSelection)currentSelection).getFirstElement();

		}

		return null;

	}

	/**

	 * Finds the {@link ITestElement} from the given {@link IJavaElement}

	 * 

	 * @param javaElement the java element associated with the {@link ITestElement} to find.

	 * @return the {@link ITestElement} or null if it could not be found.

	 */

	private ITestElement findTestElement(final IJavaElement javaElement) {

		if (fTestRunSession == null || javaElement == null) {

			return null;

		}

		switch (javaElement.getElementType()) {

			case IJavaElement.METHOD:

				final IMethod javaMethod= (IMethod)javaElement;

				final IType javaType= (IType)javaMethod.getAncestor(IJavaElement.TYPE);

				final String testClassName= javaType.getFullyQualifiedName();

				final String testMethodName= javaMethod.getElementName();

				return findTestCaseElement(fTestRunSession.getTestRoot(), testClassName, testMethodName);

			case IJavaElement.TYPE:

				return findTestSuiteElement(fTestRunSession.getTestRoot(), ((IType)javaElement).getFullyQualifiedName());

			default:

				return null;

		}

	}

	/**

	 * Finds the {@link ITestCaseElement} with the given test class name and test method name in the

	 * given {@link ITestSuiteElement}

	 * 

	 * @param parentElement the parent Test Suite

	 * @param testClassName the name of the test class

	 * @param testMethodName the name of the test method

	 * 

	 * @return the {@link ITestCaseElement} or null if it could not be found.

	 */

	private ITestCaseElement findTestCaseElement(final ITestSuiteElement parentElement, final String testClassName, final String testMethodName) {

		for (ITestElement childElement : parentElement.getChildren()) {

			if (childElement instanceof ITestCaseElement) {

				final TestCaseElement testCaseElement= (TestCaseElement)childElement;

				if (testCaseElement.getJavaType() != null && testCaseElement.getJavaType().getFullyQualifiedName().equals(testClassName) && testCaseElement.getJavaMethod() != null

						&& testCaseElement.getJavaMethod() != null && testCaseElement.getJavaMethod().getElementName().equals(testMethodName)) {

					return testCaseElement;

				}

			} else if (childElement instanceof ITestSuiteElement) {

				final ITestCaseElement localResult= findTestCaseElement((ITestSuiteElement)childElement, testClassName, testMethodName);

				if (localResult != null) {

					return localResult;

				}

			}

		}

		return null;

	}

	/**

	 * Finds the {@link ITestSuiteElement} with the given test class name in the given

	 * {@link ITestSuiteElement}

	 * 

	 * @param parentElement the parent Test Suite

	 * @param testClassName the name of the test class

	 * 

	 * @return the {@link ITestSuiteElement} or null if it could not be found.

	 */

	private ITestSuiteElement findTestSuiteElement(final ITestSuiteElement parentElement, final String testClassName) {

		for (ITestElement childElement : parentElement.getChildren()) {

			if (childElement instanceof ITestSuiteElement) {

				final ITestSuiteElement childTestSuite= (ITestSuiteElement)childElement;

				if (childTestSuite.getSuiteTypeName().equals(testClassName)) {

					return childTestSuite;

				}

			}

		}

		return null;

	}

	/**

	 * @return the selected {@link IJavaElement} in the current editor if it is a {@link CompilationUnitEditor}, null otherwise. 

	 * @param editor the editor

	 */

	private IJavaElement getSelectedJavaElementInEditor(final IEditorPart editor) {

		if (editor instanceof CompilationUnitEditor) {

			final CompilationUnitEditor compilationUnitEditor = (CompilationUnitEditor)editor;

			try {

				final IJavaElement inputJavaElement= JavaUI.getEditorInputJavaElement(editor.getEditorInput());

				final ITextSelection selection= (ITextSelection)compilationUnitEditor.getSelectionProvider().getSelection();

				final ICompilationUnit compilationUnit= (ICompilationUnit)inputJavaElement.getAncestor(IJavaElement.COMPILATION_UNIT);

				return compilationUnit.getElementAt(selection.getOffset());

			} catch (JavaModelException e) {

				JUnitPlugin.log(e);

			}

		}

		return null;

	}

	/**

	 * Handles the case when a {@link TestCaseElement} has been selected: open the associated code

	 * in the Java Editor

	 * 

	 * @param testElement the new selected {@link TestCaseElement}

	 */

	private void handleTestElementSelected(final ITestElement testElement) {

		if (testElement instanceof TestCaseElement) {

			final IMethod selectedMethod= ((TestCaseElement)testElement).getJavaMethod();

			handleJavaElementSelected(selectedMethod);

		} else if (testElement instanceof TestSuiteElement) {

			final IJavaElement selectedElement= ((TestSuiteElement)testElement).getJavaElement();

			handleJavaElementSelected(selectedElement);

		}

	}

	/**

	 * Reveals the given {@link IJavaElement} in its associated Editor if this later is already

	 * open, and sets the "Link with Editor" button state accordingly.

	 * 

	 * @param selectedJavaElement the selected {@link IJavaElement} in the {@link TestViewer} that

	 *            should be revealed in its Java Editor.

	 */

	private void handleJavaElementSelected(final IJavaElement selectedJavaElement) {

		try {

			final IEditorPart editor= EditorUtility.isOpenInEditor(selectedJavaElement);

			if (selectedJavaElement != null && editor != null && editor instanceof JavaEditor) {

				final JavaEditor javaEditor= (JavaEditor)editor;

				final ITextSelection javaEditorSelection= (ITextSelection)javaEditor.getSelectionProvider().getSelection();

				final IEditorPart selectedMethodEditor= EditorUtility.isOpenInEditor(selectedJavaElement);

				// checks if the editor is already open or not

				if (selectedMethodEditor != null) {

					// Retrieve the current active editor

					final IEditorPart activeEditor= fTestRunnerPart.getSite().getPage().getActiveEditor();

					// open the required editor if it is not the active one   

					if (!selectedMethodEditor.equals(activeEditor)) {

						EditorUtility.openInEditor(selectedJavaElement, false);

					}

					// retrieve the current java element (unless the associated compilation unit cannot be retrieved)

					final ICompilationUnit compilationUnit= (ICompilationUnit)selectedJavaElement.getAncestor(IJavaElement.COMPILATION_UNIT);

					if (compilationUnit != null) {

						final IJavaElement javaEditorSelectedElement= compilationUnit.getElementAt(javaEditorSelection.getOffset());

						// force to reveal the selected element in case where the editor was not active

						if (!selectedMethodEditor.equals(activeEditor) || !selectedJavaElement.equals(javaEditorSelectedElement)) {

							EditorUtility.revealInEditor(selectedMethodEditor, selectedJavaElement);

						}

						fTestRunnerPart.setLinkingWithEditorInSync(true);

						return;

					}

				}

			}

		} catch (JavaModelException e) {

			JUnitPlugin.log(e);

		} catch (PartInitException e) {

			// occurs if the editor could not be opened or the input element is not valid Status code

			JUnitPlugin.log(e);

		}

		fTestRunnerPart.setLinkingWithEditorInSync(false);

	}

}