*     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.core.runtime.IAdaptable;

import org.eclipse.jdt.core.IJavaElement;

import org.eclipse.jdt.core.IJavaProject;

import org.eclipse.jdt.core.IMethod;

import org.eclipse.jdt.core.IType;

import org.eclipse.jdt.core.JavaModelException;

/**

 * 

 * @since 3.7 implements {@link IAdaptable}

 */

public class TestCaseElement extends TestElement implements ITestCaseElement, IAdaptable {

	private IType fJavaType = null;

	private IMethod fJavaMethod = null;

	/**

	 * {@inheritDoc}

	 * @see org.eclipse.jdt.junit.model.ITestCaseElement#getJavaMethod()

	 */

	public IMethod getJavaMethod() {

		if(fJavaMethod == null) {

			try {

				String testMethodName= getTestMethodName();

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

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

				if (index != -1) {

					fJavaMethod= findJavaMethod(testMethodName.substring(0, index));

				} else {

					fJavaMethod= findJavaMethod(testMethodName);

				}

			} catch (JavaModelException e) {

				JUnitCorePlugin.log(e);

			}

		}

		return fJavaMethod;

	}

	/**

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

	 * 

	 * @param methodName the name of the method to find 

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

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

	 */

	private IMethod findJavaMethod(final String methodName) throws JavaModelException {

		final IType type= getJavaType();

		if(type != null) {

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

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

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

					return methods[i];

				}

			}

		}

		return null;

	}

	}

	/**

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

	 * {@inheritDoc}

	 * @see org.eclipse.jdt.junit.model.ITestCaseElement#getJavaType()

	 */

	public IType getJavaType() {

		if(fJavaType == null) {

			try {

				String[] items= getTestClassName().split("\\."); //$NON-NLS-1$

				StringBuffer buffer= new StringBuffer();

				boolean primaryTypeFound= false;

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

					buffer.append(items[i]);

					boolean firstChar= Character.isUpperCase(items[i].charAt(0));

					if (firstChar && !primaryTypeFound) {

						primaryTypeFound= true;

					}

					if (i < items.length - 1) {

						if (primaryTypeFound) {

							buffer.append('$');

						} else {

							buffer.append('.');

						}

					}

				}

				fJavaType= getTestRunSession().getLaunchedProject().findType(buffer.toString());

			} catch (JavaModelException e) {

				JUnitCorePlugin.log(e);

			}

		}

		return fJavaType;

	/**

	 * Provides support for converting this {@link TestCaseElement} into an {@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)) {

			if(fJavaMethod == null) {

				try {

					final IJavaProject launchedProject= getTestRunSession().getLaunchedProject();

					final IType type= launchedProject.findType(this.getTestClassName());

					if(type != null && type.exists()) {

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

						if(methods != null) {

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

								if(methods[i].getElementName().equals(this.getJavaMethod())) {

									fJavaMethod = methods[i];

									break;

								}

							}

						}

					}

				} catch (JavaModelException e) {

					JUnitCorePlugin.log(e);

				}

			}

			return fJavaMethod;

		}

		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.jdt.core.IMethod;

import org.eclipse.jdt.core.IType;

	 * Returns the Java method.

	 *

	 * @return returns the Java method.

	 * @since 3.7

	 */

	public IMethod getJavaMethod();

	/**

	/**

	 * Returns Java type the test is contained in.

	 *

	 * @return Java type the test is contained in.

	 * @since 3.7

	 */

	public IType getJavaType();

 *     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.ui.PreferenceConstants;

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

	/**

	 * Helper to open and activate editors.

	 * @since 3.7

	 */

	private LinkWithEditorAction fLinkWithEditorAction;

			fLinkWithEditorAction.setEnabled(true);

					fLinkWithEditorAction.setEnabled(fTestRunSession != null);

	}

	/**

	 * This action toggles whether this {@link TestRunnerViewPart} links

	 * its selection to the active editor.

	 *

	 */

	private class LinkWithEditorAction extends AbstractToggleLinkingAction {

		LinkWithEditorAction() {

			boolean isLinkingEnabled= PreferenceConstants.getPreferenceStore().getBoolean(PreferenceConstants.LINK_BROWSING_JUNIT_TESTS_TO_EDITOR);

			setChecked(isLinkingEnabled);

		}

		@Override

		public void run() {

			PreferenceConstants.getPreferenceStore().setValue(PreferenceConstants.LINK_BROWSING_JUNIT_TESTS_TO_EDITOR, isChecked());

			setLinkingActive(isChecked());

		}

	}

	/**

	 * @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 setLinkingActive(boolean active) {

		fTestViewer.setLinkingActive(getSite().getPage(), active);

	}

				fLinkWithEditorAction.setEnabled(true);

				fLinkWithEditorAction.setEnabled(fTestRunSession != null);

		//getSite().getPage().removeSelectionListener(fTestViewer);

		fLinkWithEditorAction= new LinkWithEditorAction();

		fLinkWithEditorAction.setEnabled(false);

 *     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.jdt.junit.model.ITestCaseElement;

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

import org.eclipse.jface.viewers.IPostSelectionProvider;

import org.eclipse.jface.viewers.ISelection;

import org.eclipse.jface.viewers.ISelectionProvider;

import org.eclipse.jface.text.ITextSelection;

import org.eclipse.ui.IEditorPart;

import org.eclipse.ui.IEditorReference;

import org.eclipse.ui.IPartListener2;

import org.eclipse.ui.ISelectionListener;

import org.eclipse.ui.IWorkbenchPage;

import org.eclipse.ui.IWorkbenchPart;

import org.eclipse.ui.IWorkbenchPartReference;

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;

		// re-activate the "Link with editor" from start if it was enabled in the previous

		// instance of the workbench.

		if(runner.isLinkWithEditorActive()) {

			setLinkingActive(runner.getSite().getPage(), true);

		}

		// 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(fTestRunnerPart.isLinkWithEditorActive() && testElement instanceof TestCaseElement) {

			handleTestSelected((TestCaseElement) testElement);

		}

	}

	/**

	 * Reacts to a selection change in another {@link IWorkbenchPart}. If the given

	 * {@link ISelection} matches an existing {@link TestCaseElement} in the viewer, this later will

	 * be selected.

	 * 

	 * @param part the part in which the selection changed.

	 * @param selection the new selection

	 * 

	 * @since 3.7

	 */

	public void selectionChanged(IWorkbenchPart part, ISelection selection) {

		if(fTestRunnerPart.isLinkWithEditorActive() && fTestRunnerPart.isLinkWithEditorActive() && part instanceof CompilationUnitEditor) {

			setSelection((CompilationUnitEditor)part);

		}

	/**

	 * Sets the current selection from the given {@link CompilationUnitEditor} and its selection.

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

	 * 

	 */

	private void setSelection(final CompilationUnitEditor editor) {

		final ISelectionProvider selectionProvider = editor.getSelectionProvider();

		final IJavaElement selectedJavaElement= getSelectedJavaElementInEditor(JavaUI.getEditorInputJavaElement(editor.getEditorInput()), selectionProvider.getSelection());

		if(selectedJavaElement != null) {

			setSelection(selectedJavaElement);

			fJavaEditorSelectionListener = new JavaEditorSelectionListener((ICompilationUnit)selectedJavaElement.getAncestor(IJavaElement.COMPILATION_UNIT));

			((IPostSelectionProvider)editor.getSelectionProvider()).addPostSelectionChangedListener(fJavaEditorSelectionListener);

		}

	}

	/**

	 * Selects the  the current selection from the given {@link IJavaElement} if it is an {@link IMethod}

	 * @param activeJavaElement the selected Java Element in the active Java Editor

	 * 

	 */

	private void setSelection(final IJavaElement activeJavaElement) {

		// select the method in the JUnit ViewPart

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

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

			final IMethod activeJavaMethod = (IMethod)activeJavaElement;

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

			final String testClassName= activeJavaType.getFullyQualifiedName();

			final String testMethodName= activeJavaMethod.getElementName();

			final ITestCaseElement activeTestCaseElement = findTestCaseElement(fTestRunSession.getTestRoot(), testClassName, testMethodName);

			if(activeTestCaseElement != null) {

				final StructuredSelection selection= new StructuredSelection(activeTestCaseElement);

				if(!selection.equals(getActiveViewer().getSelection())) {

					fSelectionProvider.setSelection(selection, 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.getJavaType() != null && testCaseElement.getJavaType().getFullyQualifiedName().equals(testClassName) && 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;

	}

	/**

	 * Links the selected test method with the Java Editor

	 * @param page the currently active page

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

	 * 

	 * @since 3.7

	 */

	public void setLinkingActive(final IWorkbenchPage page, final boolean active) {

		if(page == null) {

			return;

		}

		if (active) {

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

			page.addPartListener(fLinkWithEditorPartListener);

			page.addPostSelectionListener(fLinkWithEditorSelectionListener);

			if(page.getActiveEditor() instanceof CompilationUnitEditor) {

				setSelection((CompilationUnitEditor)page.getActiveEditor());

			}

		} else {

			// removes the IPartListener

			page.removePartListener(fLinkWithEditorPartListener);

			page.removePostSelectionListener(fLinkWithEditorSelectionListener);

		}

	}

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

			}

		}

	};

	private ISelectionListener fLinkWithEditorSelectionListener = new ISelectionListener() {

		public void selectionChanged(IWorkbenchPart editor, ISelection selection) {

			if(editor instanceof CompilationUnitEditor && selection instanceof ITextSelection) {

				setSelection((CompilationUnitEditor)editor);

			}

		}

	};

	private JavaEditorSelectionListener fJavaEditorSelectionListener;

	/**

	 * Static Inner Java Editor selection listener

	 * When the user moves to another 

	 * @since 3.7

	 */

	private class JavaEditorSelectionListener implements ISelectionChangedListener {

		private final ICompilationUnit compilationUnit;

		JavaEditorSelectionListener(final ICompilationUnit compilationUnit) {

			this.compilationUnit = compilationUnit;

		}

		public void selectionChanged(final SelectionChangedEvent event) {

			IJavaElement selectedJavaElement= getSelectedJavaElementInEditor(compilationUnit, event.getSelection());

			setSelection(selectedJavaElement);

		}

		/**

		 * 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;

		}

	}

	/**

	 * 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 CompilationUnitEditor)) {

			return;

		}

		CompilationUnitEditor javaEditor= (CompilationUnitEditor)editor;

		setSelection(javaEditor);

	}

	private IJavaElement getSelectedJavaElementInEditor(final IJavaElement javaElement, final ISelection selection) {

		if(javaElement instanceof ICompilationUnit && selection instanceof ITextSelection) {

			try {

				return ((ICompilationUnit)javaElement).getElementAt(((ITextSelection)selection).getOffset());

			} catch(JavaModelException e) {

				JUnitPlugin.log(e);

			}

		}

		return null;

	}

	/**

	 * An editor has been deactivated. 

	 * @param editor the activated editor

	 */

	private void editorDeactivated(IEditorPart editor) {

		if(fJavaEditorSelectionListener != null & editor instanceof CompilationUnitEditor) {

			final IPostSelectionProvider selectionProvider = (IPostSelectionProvider)((CompilationUnitEditor)editor).getSelectionProvider();

			selectionProvider.removePostSelectionChangedListener(fJavaEditorSelectionListener);

		}

	}

	private void handleTestSelected(final TestCaseElement testCaseElement) {

		try {

			final IType type= testCaseElement.getJavaType();

			final IEditorPart editor= EditorUtility.isOpenInEditor(type);

			final IMethod selectedMethod= testCaseElement.getJavaMethod();

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

				final JavaEditor javaEditor = (JavaEditor)editor;

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

				final IJavaElement javaEditorSelectedElement= type.getCompilationUnit().getElementAt(javaEditorSelection.getOffset());

				IEditorPart selectedMethodEditor = EditorUtility.isOpenInEditor(selectedMethod);

				// checks if the editor is already open or not

				if(selectedMethodEditor != null) {

					EditorUtility.openInEditor(selectedMethod, false);

					if(!selectedMethod.equals(javaEditorSelectedElement)) {

						EditorUtility.revealInEditor(selectedMethodEditor, selectedMethod);

					}

				}

				if(!selectedMethod.equals(javaEditorSelectedElement)) {

					JavaUI.revealInEditor(editor, (IJavaElement)selectedMethod);

				}

			}

		} catch(JavaModelException e) {

			JUnitPlugin.log(e);

		} catch(PartInitException e) {

			// ignore if no editor input can be found

		}		

	}

	/**

	 * A named preference that controls whether the JUnit view's selection is

	 * linked to the active editor.

	 * <p>

	 * Value is of type <code>Boolean</code>.

	 * </p>

	 * @since 3.9

	 */

	public static final String LINK_BROWSING_JUNIT_TESTS_TO_EDITOR= "org.eclipse.jdt.ui.browsing.junitteststoeditor"; //$NON-NLS-1$