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.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) {

				}

			}

			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 be 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);

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;

	}