import org.eclipse.core.runtime.IPath;

import org.eclipse.core.resources.IFile;

import org.eclipse.jface.viewers.IPostSelectionProvider;

import org.eclipse.jface.viewers.ISelection;

import org.eclipse.jface.viewers.ISelectionChangedListener;

import org.eclipse.jface.viewers.ISelectionProvider;

import org.eclipse.jface.viewers.SelectionChangedEvent;

import org.eclipse.jface.text.ITextSelection;

import org.eclipse.ui.IEditorReference;

import org.eclipse.ui.part.FileEditorInput;

import org.eclipse.jdt.core.IClasspathEntry;

import org.eclipse.jdt.core.ICompilationUnit;

import org.eclipse.jdt.core.IMethod;

import org.eclipse.jdt.core.IType;

import org.eclipse.jdt.core.JavaModelException;

import org.eclipse.jdt.ui.JavaUI;

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

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

	private LinkWithEditorAction fLinkWithEditorAction;

			fLinkWithEditorAction.setEnabled(true);

					fLinkWithEditorAction.setEnabled(fTestRunSession != null);

	private class LinkWithEditorAction extends AbstractToggleLinkingAction {

		@Override

		public void run() {

			setLinkingEnabled(isChecked());

		}

	}

	/**

	 * Links the selected test method with the Java Editor

	 * @param enabled boolean to indicate if the link with editor is enabled (<code>true</code>) or not (<code>false</code>) 

	 */

	public void setLinkingEnabled(boolean enabled) {

		final IWorkbenchPage page = getSite().getPage();

		if(page == null) {

			return;

		}

		if (enabled) {

			// add an IPartListener for future editor activations/opening/closing/etc.

			page.addPartListener(fLinkWithEditorPartListener);

		} else {

			// removes the IPartListener

			page.removePartListener(fLinkWithEditorPartListener);

		}

		for(IEditorReference editorReference : page.getEditorReferences()) {

			final IEditorPart editor = editorReference.getEditor(false);

			// set the current editor as active as well

			if (editor != null && enabled) {

				editorActivated(editor);

			} 

			// unset the current editor as active as well

			else if(editor != null && !enabled){

				editorDeactivated(editor);

			}

		}

	}

	private final IPartListener2 fLinkWithEditorPartListener= new IPartListener2() {

		public void partVisible(IWorkbenchPartReference partRef) {}

		public void partBroughtToTop(IWorkbenchPartReference partRef) {}

		public void partHidden(IWorkbenchPartReference partRef) {}

		public void partOpened(IWorkbenchPartReference partRef) {}

		public void partInputChanged(IWorkbenchPartReference partRef) {}

		public void partClosed(IWorkbenchPartReference partRef) {}

		public void partActivated(IWorkbenchPartReference partRef) {

			if (partRef instanceof IEditorReference) {

				editorActivated(((IEditorReference) partRef).getEditor(true));

			}

		}

		public void partDeactivated(IWorkbenchPartReference partRef) {

			if (partRef instanceof IEditorReference) {

				editorDeactivated(((IEditorReference) partRef).getEditor(true));

			}

		}

	};

	/**

	 * Static Inner Java Editor selection listener

	 * When the user moves to another 

	 */

	private class JavaEditorSelectionListener implements ISelectionChangedListener {

		private final ICompilationUnit compilationUnit;

		JavaEditorSelectionListener(final ICompilationUnit compilationUnit) {

			this.compilationUnit = compilationUnit;

		}

		public void selectionChanged(final SelectionChangedEvent event) {

			selectActiveTestCaseElement(event.getSelection());

		}

		private IJavaElement getActiveJavaElement(final ISelection selection) {

			if(selection instanceof ITextSelection) {

				final int offset= ((ITextSelection)selection).getOffset();

				try {

					return compilationUnit.getElementAt(offset);

				} catch (JavaModelException e) {

					JUnitPlugin.log(e);

				}

			}

			return null;

		}

		public void selectActiveTestCaseElement(final ISelection selection) {

			final IJavaElement activeJavaElement = getActiveJavaElement(selection);

			// select the method in the JUnit ViewPart

			if(activeJavaElement != null && activeJavaElement.getElementType() == IJavaElement.METHOD) {

				final IMethod activeJavaMethod = (IMethod)activeJavaElement;

				final IType activeJavaType = (IType)activeJavaMethod.getAncestor(IJavaElement.TYPE);

				fTestViewer.selectTestCaseElement(activeJavaType.getFullyQualifiedName(), activeJavaMethod.getElementName());

			}

		}

		/**

		 * Overriding java.lang.Object#hashCode() using the

		 * {@link ICompilationUnit#getHandleIdentifier()} value to avoid duplicate listener

		 * registrations in the {@link JavaEditor}'s {@link IPostSelectionProvider}.

		 */

		@Override

		public int hashCode() {

			final int prime= 31;

			int result= 1;

			result= prime * result + ((compilationUnit == null) ? 0 : compilationUnit.getHandleIdentifier().hashCode());

			return result;

		}

		/**

		 * Overriding java.lang.Object#equals() using the

		 * {@link ICompilationUnit#getHandleIdentifier()} value to avoid duplicate listener

		 * registrations in the {@link JavaEditor}'s {@link IPostSelectionProvider}.

		 */

		@Override

		public boolean equals(Object obj) {

			if (this == obj) {

				return true;

			}

			if (obj == null) {

				return false;

			}

			if (getClass() != obj.getClass()) {

				return false;

			}

			JavaEditorSelectionListener other= (JavaEditorSelectionListener)obj;

			if (compilationUnit == null) {

				if (other.compilationUnit != null) {

					return false;

				}

			} else if (!compilationUnit.getHandleIdentifier().equals(other.compilationUnit.getHandleIdentifier())) {

				return false;

			}

			return true;

		}

	}

	private JavaEditorSelectionListener fJavaEditorSelectionListener;

	/**

	 * An editor has been activated.  Set the selection in this JUnit ViewPart

	 * to match the editor's input, if linking is enabled.

	 * @param editor the activated editor

	 */

	private void editorActivated(IEditorPart editor) {

		if(!(editor instanceof JavaEditor)) {

			return;

		}

		final ISelectionProvider selectionProvider = ((JavaEditor)editor).getSelectionProvider();

		final Object input= JavaUI.getEditorInputJavaElement(editor.getEditorInput());

		if (input instanceof ICompilationUnit && selectionProvider instanceof IPostSelectionProvider) {

			final ICompilationUnit unit = (ICompilationUnit) input;

			final IPostSelectionProvider postSelectionProvider = (IPostSelectionProvider)selectionProvider;

			fJavaEditorSelectionListener = new JavaEditorSelectionListener(unit);

			postSelectionProvider.addPostSelectionChangedListener(fJavaEditorSelectionListener);

			fJavaEditorSelectionListener.selectActiveTestCaseElement(selectionProvider.getSelection());

		}

	}

	/**

	 * An editor has been deactivated. 

	 * @param editor the activated editor

	 */

	private void editorDeactivated(IEditorPart editor) {

		if(!(editor instanceof JavaEditor)) {

			return;

		}

		final ISelectionProvider selectionProvider = ((JavaEditor)editor).getSelectionProvider();

		if (selectionProvider instanceof IPostSelectionProvider) {

			final IPostSelectionProvider postSelectionProvider = (IPostSelectionProvider)selectionProvider;

			postSelectionProvider.removePostSelectionChangedListener(fJavaEditorSelectionListener);

		}

	}

				fLinkWithEditorAction.setEnabled(true);

				fLinkWithEditorAction.setEnabled(fTestRunSession != null);

		fLinkWithEditorAction= new LinkWithEditorAction();

		fLinkWithEditorAction.setEnabled(false);

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

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

		if(fLinkWithEditorAction.isChecked() && test instanceof TestCaseElement) {

			try {

				final TestCaseElement testCaseElement= (TestCaseElement)test;

				for (IEditorReference editorReference : PlatformUI.getWorkbench().getActiveWorkbenchWindow()

						.getActivePage().getEditorReferences()) {

					final IEditorPart editor = editorReference.getEditor(true);

					final IMethod selectedMethod = findSelectedMethodInEditor(editor, testCaseElement);

					if(selectedMethod != null) {

						JavaUI.openInEditor(selectedMethod, false, true);

						break;

					}

				}

			} catch(JavaModelException e) {

				JUnitPlugin.log(e);

			} catch(PartInitException e) {

				JUnitPlugin.log(e);

			}

		}

	}

	/**

	 * Finds and returns the selected {@link IMethod} matching the given {@link TestCaseElement} in

	 * the given {@link IEditorPart} (if this later is a {@link JavaEditor}), or returns null if the

	 * editor is not a {@link JavaEditor} or is not opened on the expected {@link ICompilationUnit}.

	 * 

	 * @param editor the editor to inspect

	 * @param test the selected test case element 

	 * @return the corresponding Java method element or null

	 * @throws JavaModelException if the inspection of one of the java elements in the given editor failed.

	 */

	private IMethod findSelectedMethodInEditor(IEditorPart editor, TestCaseElement test) throws JavaModelException {

		final String editorClassName = getJavaEditorClassName(editor);

		final String testMethodName= getTestMethodName(test);

		if(test.getClassName().equals(editorClassName)) {

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

			if (editorInputJavaElement.getElementType() == IJavaElement.COMPILATION_UNIT) {

				for (IType type : ((ICompilationUnit)editorInputJavaElement).getTypes()) {

					if (type.getFullyQualifiedName().equals(test.getClassName())) {

						for (IMethod method : type.getMethods()) {

							if (method.getElementName().equals(testMethodName)) {

								return method;

							}

						}

					}

				}

			}

		}

		return null;

	}

	/**

	 * @return the fully qualified name of the Java class opened by the editor if it is a JavaEditor, null otherwise.

	 * @param editor the editor to inspect

	 */

	private String getJavaEditorClassName(final IEditorPart editor) {

		if(editor instanceof JavaEditor && editor.getEditorInput() instanceof FileEditorInput) {

			final JavaEditor javaEditor = (JavaEditor)editor;

			return getEditorClassName(javaEditor);

		}

		return null;

	}

	/** 

	 * @return the name of the Java method associated with this test.

	 * @param test the selected unit test

	 */

	private String getTestMethodName(TestCaseElement test) {

		final String testMethodName = test.getTestMethodName();

		// parameterized tests show an index that should be removed from the name

		final int index = testMethodName.indexOf('[');

		if(index != -1) {

			return testMethodName.substring(0, index);

		}

		return testMethodName;

	}

	/**

	 * @return the Java classname associated with the file opened in the given {@link JavaEditor}.

	 * @param javaEditor the javaEditor in which the file is opened.

	 */

	private String getEditorClassName(final JavaEditor javaEditor) {

		try {

			final FileEditorInput editorInput = (FileEditorInput)javaEditor.getEditorInput();

			final IFile inputFile = editorInput.getFile();

			IPath inputFilePath = inputFile.getFullPath();

			IJavaProject javaProject = JavaCore.create(inputFile.getProject());

			for(IClasspathEntry classpathEntry: javaProject.getRawClasspath()) {

				if(classpathEntry.getEntryKind() == IClasspathEntry.CPE_SOURCE && classpathEntry.getPath().isPrefixOf(inputFilePath)) {

					IPath sourcePath = inputFilePath.makeRelativeTo(classpathEntry.getPath());

					String sourceClassName= sourcePath.removeFileExtension().toOSString().replaceAll("/", "."); //$NON-NLS-1$ //$NON-NLS-2$

					return sourceClassName;

				}

			}

		} catch (JavaModelException e) {

			JUnitPlugin.log(e);

		}

		return null;

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

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

import org.eclipse.jface.viewers.ISelection;

	/**

	 * Selects and reveals the given {@link ITestCaseElement} in the viewer's tree.

	 * @param testClassName the qualified class name of the test to select

	 * @param testMethodName the method name of the test to select

	 */

	public void selectTestCaseElement(final String testClassName, final String testMethodName) {

		// skip if history was cleared and 'Link with Editor' is still enabled.

		if(fTestRunSession == null) {

			return;

		}

		final TestRoot testRoot = fTestRunSession.getTestRoot();

		final ISelection currentSelection= getActiveViewer().getSelection();

		if(currentSelection instanceof IStructuredSelection) {

			for(Object selectedItem : ((IStructuredSelection)currentSelection).toList()) {

				if(selectedItem instanceof TestCaseElement && ((TestCaseElement)selectedItem).getTestClassName().equals(testClassName)

						&& ((TestCaseElement)selectedItem).getTestMethodName().equals(testMethodName)) {

					// the current selection in the TestViewer includes the given test class/method

					return;

				}

			}

		}

		final ITestCaseElement activeTestCaseElement = findTestCaseElement(testRoot, testClassName, testMethodName);

		if(activeTestCaseElement != null) {

			getActiveViewer().setSelection(new StructuredSelection(activeTestCaseElement), true);

		}

	}

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

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

			if(childElement instanceof ITestCaseElement) {

				ITestCaseElement testCaseElement = (ITestCaseElement)childElement;

				if(testCaseElement.getTestClassName().equals(testClassName) && testCaseElement.getTestMethodName().equals(testMethodName)) {

					return testCaseElement;

				}

			} else if(childElement instanceof ITestSuiteElement) {

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

				if(localResult != null) {

					return localResult;

				}

			}

		}

		return null;

	}