/*******************************************************************************
 * Copyright (c) 2000, 2013 IBM Corporation and others.
 *
 * This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License 2.0
 * which accompanies this distribution, and is available at
 * https://www.eclipse.org/legal/epl-2.0/
 *
 * SPDX-License-Identifier: EPL-2.0
 *
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/
package org.eclipse.jdt.core.tests.model;

import junit.framework.Test;

import org.eclipse.core.runtime.CoreException;
import org.eclipse.jdt.core.ICompilationUnit;
import org.eclipse.jdt.core.IJavaElement;
import org.eclipse.jdt.core.JavaModelException;
import org.eclipse.jdt.core.WorkingCopyOwner;

public class SelectionJavadocModelTests extends AbstractJavaModelTests {

	IJavaElement element;

	public SelectionJavadocModelTests(String name) {
		super(name, 3);
//		this.endChar = "";
		this.displayName = true;
	}

	static {
//		TESTS_PREFIX = "testBug";
//		TESTS_NUMBERS = new int[] { 86380 };
//		TESTS_RANGE = new int[] { 13, 16 };
	}

	public static Test suite() {
		return buildModelTestSuite(SelectionJavadocModelTests.class);
	}

	public void setUpSuite() throws Exception {
		super.setUpSuite();
		setUpJavaProject("Tests", "1.5");
	}
	public void tearDownSuite() throws Exception {
		deleteProject("Tests");
		super.tearDownSuite();
	}

	void setUnit(String name, String source) throws JavaModelException {
		this.workingCopies = new ICompilationUnit[1];
		this.workingCopies[0] = getWorkingCopy("/Tests/"+name, source);
	}

	void assertElementEquals(String message, String expected) {
		assertElementEquals(message, expected, this.element);
	}

	void assertSelectionIsEmpty(ICompilationUnit unit, String selection) throws JavaModelException {
		assertSelectionIsEmpty(unit, selection, 1);
	}

	void assertSelectionIsEmpty(ICompilationUnit unit, String selection, int occurences) throws JavaModelException {
		int[] selectionPositions = selectionInfo(unit, selection, occurences);
		IJavaElement[] elements = unit.codeSelect(selectionPositions[0], selectionPositions[1]);
		assertTrue("Selection should be empty", elements == null || elements.length == 0);
	}

	public void test01() throws JavaModelException {
		setUnit("Test.java",
			"public class Test {\n" +
			"	/** @see #foo() */\n" +
			"	void bar() {\n" +
			"		foo();\n" +
			"	}\n" +
			"	void foo() {}\n" +
			"}\n"
		);
		this.element = selectMethod(this.workingCopies[0], "foo");
		assertElementEquals("Invalid selected method",
			"foo() [in Test [in [Working copy] Test.java [in <default> [in <project root> [in Tests]]]]]"
		);
	}

	public void test02() throws JavaModelException {
		setUnit("Test.java",
			"public class Test {\n" +
			"	/** {@link #foo() foo} */\n" +
			"	void bar() {\n" +
			"		foo();\n" +
			"	}\n" +
			"	void foo() {}\n" +
			"}\n"
		);
		this.element = selectMethod(this.workingCopies[0], "foo");
		assertElementEquals("Invalid selected method",
			"foo() [in Test [in [Working copy] Test.java [in <default> [in <project root> [in Tests]]]]]"
		);
	}

	public void test03() throws JavaModelException {
		setUnit("Test.java",
			"public class Test {\n" +
			"	/** @see Test */\n" +
			"	void foo() {}\n" +
			"}\n"
		);
		this.element = selectType(this.workingCopies[0], "Test", 2);
		assertElementEquals("Invalid selected type",
			"Test [in [Working copy] Test.java [in <default> [in <project root> [in Tests]]]]"
		);
	}

	public void test04() throws JavaModelException {
		setUnit("Test.java",
			"public class Test {\n" +
			"	/** Javadoc {@link Test} */\n" +
			"	void foo() {}\n" +
			"}\n"
		);
		this.element = selectType(this.workingCopies[0], "Test", 2);
		assertElementEquals("Invalid selected type",
			"Test [in [Working copy] Test.java [in <default> [in <project root> [in Tests]]]]"
		);
	}

	public void test05() throws JavaModelException {
		setUnit("Test.java",
			"public class Test {\n" +
			"	int field;\n" +
			"	/** @see #field */\n" +
			"	void foo() {}\n" +
			"}\n"
		);
		this.element = selectField(this.workingCopies[0], "field", 2);
		assertElementEquals("Invalid selected field",
			"field [in Test [in [Working copy] Test.java [in <default> [in <project root> [in Tests]]]]]"
		);
	}

	public void test06() throws JavaModelException {
		setUnit("Test.java",
			"public class Test {\n" +
			"	int field;\n" +
			"	/**{@link #field}*/\n" +
			"	void foo() {}\n" +
			"}\n"
		);
		this.element = selectField(this.workingCopies[0], "field", 2);
		assertElementEquals("Invalid selected field",
			"field [in Test [in [Working copy] Test.java [in <default> [in <project root> [in Tests]]]]]"
		);
	}

	public void test07() throws JavaModelException {
		setUnit("Test.java",
			"public class Test {\n" +
			"	/**\n" +
			"	 * @see Test#field\n" +
			"	 * @see #foo(int, String)\n" +
			"	 * @see Test#foo(int, String)\n" +
			"	 */\n" +
			"	void bar() {\n" +
			"		foo(0, \"\");\n" +
			"	}\n" +
			"	int field;\n" +
			"	void foo(int x, String s) {}\n" +
			"}\n"
		);
		IJavaElement[] elements = new IJavaElement[7];
		elements[0] = selectType(this.workingCopies[0], "Test", 2);
		elements[1] = selectField(this.workingCopies[0], "field");
		elements[2] = selectMethod(this.workingCopies[0], "foo");
		elements[3] = selectType(this.workingCopies[0], "String");
		elements[4] = selectType(this.workingCopies[0], "Test", 3);
		elements[5] = selectMethod(this.workingCopies[0], "foo", 2);
		elements[6] = selectType(this.workingCopies[0], "String", 2);
		assertElementsEqual("Invalid selection(s)",
			"Test [in [Working copy] Test.java [in <default> [in <project root> [in Tests]]]]\n" +
			"field [in Test [in [Working copy] Test.java [in <default> [in <project root> [in Tests]]]]]\n" +
			"foo(int, String) [in Test [in [Working copy] Test.java [in <default> [in <project root> [in Tests]]]]]\n" +
			"String [in String.class [in java.lang [in "+ getExternalJCLPathString("1.5") + "]]]\n" +
			"Test [in [Working copy] Test.java [in <default> [in <project root> [in Tests]]]]\n" +
			"foo(int, String) [in Test [in [Working copy] Test.java [in <default> [in <project root> [in Tests]]]]]\n" +
			"String [in String.class [in java.lang [in "+ getExternalJCLPathString("1.5") + "]]]",
			elements
		);
	}

	public void test08() throws JavaModelException {
		setUnit("Test.java",
			"public class Test {\n" +
			"	/**\n" +
			"	 * First {@link #foo(int, String)}\n" +
			"	 * Second {@link Test#foo(int, String) method foo}\n" +
			"	 * Third {@link Test#field field}\n" +
			"	 */\n" +
			"	void bar() {\n" +
			"		foo(0, \"\");\n" +
			"	}\n" +
			"	int field;\n" +
			"	void foo(int x, String s) {}\n" +
			"}\n"
		);
		IJavaElement[] elements = new IJavaElement[7];
		elements[0] = selectType(this.workingCopies[0], "Test", 2);
		elements[1] = selectField(this.workingCopies[0], "field");
		elements[2] = selectMethod(this.workingCopies[0], "foo");
		elements[3] = selectType(this.workingCopies[0], "String");
		elements[4] = selectType(this.workingCopies[0], "Test", 3);
		elements[5] = selectMethod(this.workingCopies[0], "foo", 2);
		elements[6] = selectType(this.workingCopies[0], "String", 2);
		assertElementsEqual("Invalid selection(s)",
			"Test [in [Working copy] Test.java [in <default> [in <project root> [in Tests]]]]\n" +
			"field [in Test [in [Working copy] Test.java [in <default> [in <project root> [in Tests]]]]]\n" +
			"foo(int, String) [in Test [in [Working copy] Test.java [in <default> [in <project root> [in Tests]]]]]\n" +
			"String [in String.class [in java.lang [in "+ getExternalJCLPathString("1.5") + "]]]\n" +
			"Test [in [Working copy] Test.java [in <default> [in <project root> [in Tests]]]]\n" +
			"foo(int, String) [in Test [in [Working copy] Test.java [in <default> [in <project root> [in Tests]]]]]\n" +
			"String [in String.class [in java.lang [in "+ getExternalJCLPathString("1.5") + "]]]",
			elements
		);
	}

	public void test09() throws JavaModelException {
		setUnit("test/junit/Test.java",
			"package test.junit;\n" +
			"public class Test {\n" +
			"	/**\n" +
			"	 * @see test.junit.Test\n" +
			"	 * @see test.junit.Test#field\n" +
			"	 * @see test.junit.Test#foo(Object[] array)\n" +
			"	 */\n" +
			"	void bar() {\n" +
			"		foo(null);\n" +
			"	}\n" +
			"	int field;\n" +
			"	void foo(Object[] array) {}\n" +
			"}\n"
		);
		IJavaElement[] elements = new IJavaElement[6];
		assertSelectionIsEmpty(this.workingCopies[0], "test", 2);
		assertSelectionIsEmpty(this.workingCopies[0], "junit", 2);
		elements[0] = selectType(this.workingCopies[0], "Test", 2);
		assertSelectionIsEmpty(this.workingCopies[0], "test", 3);
		assertSelectionIsEmpty(this.workingCopies[0], "junit", 3);
		elements[1] = selectType(this.workingCopies[0], "Test", 3);
		elements[2] = selectField(this.workingCopies[0], "field");
		assertSelectionIsEmpty(this.workingCopies[0], "test", 4);
		assertSelectionIsEmpty(this.workingCopies[0], "junit", 4);
		elements[3] = selectType(this.workingCopies[0], "Test", 4);
		elements[4] = selectMethod(this.workingCopies[0], "foo");
		elements[5] = selectType(this.workingCopies[0], "Object");
		assertSelectionIsEmpty(this.workingCopies[0], "array");
		assertElementsEqual("Invalid selection(s)",
			"Test [in [Working copy] Test.java [in test.junit [in <project root> [in Tests]]]]\n" +
			"Test [in [Working copy] Test.java [in test.junit [in <project root> [in Tests]]]]\n" +
			"field [in Test [in [Working copy] Test.java [in test.junit [in <project root> [in Tests]]]]]\n" +
			"Test [in [Working copy] Test.java [in test.junit [in <project root> [in Tests]]]]\n" +
			"foo(Object[]) [in Test [in [Working copy] Test.java [in test.junit [in <project root> [in Tests]]]]]\n" +
			"Object [in Object.class [in java.lang [in "+ getExternalJCLPathString("1.5") + "]]]",
			elements
		);
	}

	public void test10() throws JavaModelException {
		setUnit("test/junit/Test.java",
			"package test.junit;\n" +
			"public class Test {\n" +
			"	/** Javadoc {@linkplain test.junit.Test}\n" +
			"	 * {@linkplain test.junit.Test#field field}\n" +
			"	 * last line {@linkplain test.junit.Test#foo(Object[] array) foo(Object[])}\n" +
			"	 */\n" +
			"	void bar() {\n" +
			"		foo(null);\n" +
			"	}\n" +
			"	int field;\n" +
			"	void foo(Object[] array) {}\n" +
			"}\n"
		);
		IJavaElement[] elements = new IJavaElement[6];
		assertSelectionIsEmpty(this.workingCopies[0], "test", 2);
		assertSelectionIsEmpty(this.workingCopies[0], "junit", 2);
		elements[0] = selectType(this.workingCopies[0], "Test", 2);
		assertSelectionIsEmpty(this.workingCopies[0], "test", 3);
		assertSelectionIsEmpty(this.workingCopies[0], "junit", 3);
		elements[1] = selectType(this.workingCopies[0], "Test", 3);
		elements[2] = selectField(this.workingCopies[0], "field");
		assertSelectionIsEmpty(this.workingCopies[0], "test", 4);
		assertSelectionIsEmpty(this.workingCopies[0], "junit", 4);
		elements[3] = selectType(this.workingCopies[0], "Test", 4);
		elements[4] = selectMethod(this.workingCopies[0], "foo");
		elements[5] = selectType(this.workingCopies[0], "Object");
		assertSelectionIsEmpty(this.workingCopies[0], "array");
		assertElementsEqual("Invalid selection(s)",
			"Test [in [Working copy] Test.java [in test.junit [in <project root> [in Tests]]]]\n" +
			"Test [in [Working copy] Test.java [in test.junit [in <project root> [in Tests]]]]\n" +
			"field [in Test [in [Working copy] Test.java [in test.junit [in <project root> [in Tests]]]]]\n" +
			"Test [in [Working copy] Test.java [in test.junit [in <project root> [in Tests]]]]\n" +
			"foo(Object[]) [in Test [in [Working copy] Test.java [in test.junit [in <project root> [in Tests]]]]]\n" +
			"Object [in Object.class [in java.lang [in "+ getExternalJCLPathString("1.5") + "]]]",
			elements
		);
	}

	public void test11() throws JavaModelException {
		setUnit("Test.java",
			"public class Test {\n" +
			"	/**\n" +
			"	 * @throws RuntimeException runtime exception\n" +
			"	 * @throws InterruptedException interrupted exception\n" +
			"	 */\n" +
			"	void foo() {}\n" +
			"}\n"
		);
		IJavaElement[] elements = new IJavaElement[2];
		elements[0] = selectType(this.workingCopies[0], "RuntimeException");
		elements[1] = selectType(this.workingCopies[0], "InterruptedException");
		assertElementsEqual("Invalid selection(s)",
			"RuntimeException [in RuntimeException.class [in java.lang [in "+ getExternalJCLPathString("1.5") + "]]]\n" +
			"InterruptedException [in InterruptedException.class [in java.lang [in "+ getExternalJCLPathString("1.5") + "]]]",
			elements
		);
	}

	public void test12() throws JavaModelException {
		setUnit("Test.java",
			"public class Test {\n" +
			"	/**\n" +
			"	 * @exception RuntimeException runtime exception\n" +
			"	 * @exception InterruptedException interrupted exception\n" +
			"	 */\n" +
			"	void foo() {}\n" +
			"}\n"
		);
		IJavaElement[] elements = new IJavaElement[2];
		elements[0] = selectType(this.workingCopies[0], "RuntimeException");
		elements[1] = selectType(this.workingCopies[0], "InterruptedException");
		assertElementsEqual("Invalid selection(s)",
			"RuntimeException [in RuntimeException.class [in java.lang [in "+ getExternalJCLPathString("1.5") + "]]]\n" +
			"InterruptedException [in InterruptedException.class [in java.lang [in "+ getExternalJCLPathString("1.5") + "]]]",
			elements
		);
	}

	public void test13() throws JavaModelException {
		setUnit("Test.java",
			"public class Test {\n" +
			"	/**\n" +
			"	 * @param xxx integer param\n" +
			"	 * @param str string param\n" +
			"	 */\n" +
			"	void foo(int xxx, String str) {}\n" +
			"}\n"
		);
		IJavaElement[] elements = new IJavaElement[2];
		elements[0] = selectLocalVariable(this.workingCopies[0], "xxx");
		elements[1] = selectLocalVariable(this.workingCopies[0], "str");
		assertElementsEqual("Invalid selection(s)",
			"xxx [in foo(int, String) [in Test [in [Working copy] Test.java [in <default> [in <project root> [in Tests]]]]]]\n" +
			"str [in foo(int, String) [in Test [in [Working copy] Test.java [in <default> [in <project root> [in Tests]]]]]]",
			elements
		);
	}

	public void test14() throws JavaModelException {
		setUnit("Test.java",
			"/**\n" +
			" * Javadoc of {@link Test}\n" +
			" * @see Field#foo\n" +
			" */\n" +
			"public class Test {}\n" +
			"/**\n" +
			" * Javadoc on {@link Field} to test selection in javadoc field references\n" +
			" * @see #foo\n" +
			" */\n" +
			"class Field {\n" +
			"	/**\n" +
			"	 * Javadoc on {@link #foo} to test selection in javadoc field references\n" +
			"	 * @see #foo\n" +
			"	 * @see Field#foo\n" +
			"	 */\n" +
			"	int foo;\n" +
			"}\n"
		);
		IJavaElement[] elements = new IJavaElement[9];
		elements[0] = selectType(this.workingCopies[0], "Test", 2);
		elements[1] = selectType(this.workingCopies[0], "Field");
		elements[2] = selectField(this.workingCopies[0], "foo");
		elements[3] = selectType(this.workingCopies[0], "Field", 2);
		elements[4] = selectField(this.workingCopies[0], "foo", 2);
		elements[5] = selectField(this.workingCopies[0], "foo", 3);
		elements[6] = selectField(this.workingCopies[0], "foo", 4);
		elements[7] = selectType(this.workingCopies[0], "Field", 4);
		elements[8] = selectField(this.workingCopies[0], "foo", 5);
		assertElementsEqual("Invalid selection(s)",
			"Test [in [Working copy] Test.java [in <default> [in <project root> [in Tests]]]]\n" +
			"Field [in [Working copy] Test.java [in <default> [in <project root> [in Tests]]]]\n" +
			"foo [in Field [in [Working copy] Test.java [in <default> [in <project root> [in Tests]]]]]\n" +
			"Field [in [Working copy] Test.java [in <default> [in <project root> [in Tests]]]]\n" +
			"foo [in Field [in [Working copy] Test.java [in <default> [in <project root> [in Tests]]]]]\n" +
			"foo [in Field [in [Working copy] Test.java [in <default> [in <project root> [in Tests]]]]]\n" +
			"foo [in Field [in [Working copy] Test.java [in <default> [in <project root> [in Tests]]]]]\n" +
			"Field [in [Working copy] Test.java [in <default> [in <project root> [in Tests]]]]\n" +
			"foo [in Field [in [Working copy] Test.java [in <default> [in <project root> [in Tests]]]]]",
			elements
		);
	}

	public void test15() throws JavaModelException {
		setUnit("Test.java",
			"/**\n" +
			" * Javadoc of {@link Test}\n" +
			" * @see Method#foo\n" +
			" */\n" +
			"public class Test {}\n" +
			"/**\n" +
			" * Javadoc on {@link Method} to test selection in javadoc method references\n" +
			" * @see #foo\n" +
			" */\n" +
			"class Method {\n" +
			"	/**\n" +
			"	 * Javadoc on {@link #foo} to test selection in javadoc method references\n" +
			"	 * @see #foo\n" +
			"	 * @see Method#foo\n" +
			"	 */\n" +
			"	void bar() {}\n" +
			"	/**\n" +
			"	 * Method with parameter and throws clause to test selection in javadoc\n" +
			"	 * @param xxx TODO\n" +
			"	 * @param str TODO\n" +
			"	 * @throws RuntimeException blabla\n" +
			"	 * @throws InterruptedException bloblo\n" +
			"	 */\n" +
			"	void foo(int xxx, String str) throws RuntimeException, InterruptedException {}\n" +
			"}\n"
		);
		IJavaElement[] elements = new IJavaElement[13];
		elements[0] = selectType(this.workingCopies[0], "Test", 2);
		elements[1] = selectType(this.workingCopies[0], "Method");
		elements[2] = selectMethod(this.workingCopies[0], "foo");
		elements[3] = selectType(this.workingCopies[0], "Method", 2);
		elements[4] = selectMethod(this.workingCopies[0], "foo", 2);
		elements[5] = selectMethod(this.workingCopies[0], "foo", 3);
		elements[6] = selectMethod(this.workingCopies[0], "foo", 4);
		elements[7] = selectType(this.workingCopies[0], "Method", 4);
		elements[8] = selectMethod(this.workingCopies[0], "foo", 5);
		elements[9] = selectLocalVariable(this.workingCopies[0], "xxx");
		elements[10] = selectLocalVariable(this.workingCopies[0], "str");
		elements[11] = selectType(this.workingCopies[0], "RuntimeException");
		elements[12] = selectType(this.workingCopies[0], "InterruptedException");
		assertElementsEqual("Invalid selection(s)",
			"Test [in [Working copy] Test.java [in <default> [in <project root> [in Tests]]]]\n" +
			"Method [in [Working copy] Test.java [in <default> [in <project root> [in Tests]]]]\n" +
			"foo(int, String) [in Method [in [Working copy] Test.java [in <default> [in <project root> [in Tests]]]]]\n" +
			"Method [in [Working copy] Test.java [in <default> [in <project root> [in Tests]]]]\n" +
			"foo(int, String) [in Method [in [Working copy] Test.java [in <default> [in <project root> [in Tests]]]]]\n" +
			"foo(int, String) [in Method [in [Working copy] Test.java [in <default> [in <project root> [in Tests]]]]]\n" +
			"foo(int, String) [in Method [in [Working copy] Test.java [in <default> [in <project root> [in Tests]]]]]\n" +
			"Method [in [Working copy] Test.java [in <default> [in <project root> [in Tests]]]]\n" +
			"foo(int, String) [in Method [in [Working copy] Test.java [in <default> [in <project root> [in Tests]]]]]\n" +
			"xxx [in foo(int, String) [in Method [in [Working copy] Test.java [in <default> [in <project root> [in Tests]]]]]]\n" +
			"str [in foo(int, String) [in Method [in [Working copy] Test.java [in <default> [in <project root> [in Tests]]]]]]\n" +
			"RuntimeException [in RuntimeException.class [in java.lang [in "+ getExternalJCLPathString("1.5") + "]]]\n" +
			"InterruptedException [in InterruptedException.class [in java.lang [in "+ getExternalJCLPathString("1.5") + "]]]",
			elements
		);
	}

	public void test16() throws JavaModelException {
		setUnit("Test.java",
			"/**\n" +
			" * Javadoc of {@link Test}\n" +
			" * @see Other\n" +
			" */\n" +
			"public class Test {}\n" +
			"/**\n" +
			" * Javadoc of {@link Other}\n" +
			" * @see Test\n" +
			" */\n" +
			"class Other {}\n"
		);
		IJavaElement[] elements = new IJavaElement[4];
		elements[0] = selectType(this.workingCopies[0], "Test");
		elements[1] = selectType(this.workingCopies[0], "Other");
		elements[2] = selectType(this.workingCopies[0], "Test", 3);
		elements[3] = selectType(this.workingCopies[0], "Other", 2);
		assertElementsEqual("Invalid selection(s)",
			"Test [in [Working copy] Test.java [in <default> [in <project root> [in Tests]]]]\n" +
			"Other [in [Working copy] Test.java [in <default> [in <project root> [in Tests]]]]\n" +
			"Test [in [Working copy] Test.java [in <default> [in <project root> [in Tests]]]]\n" +
			"Other [in [Working copy] Test.java [in <default> [in <project root> [in Tests]]]]",
			elements
		);
	}

	public void test17() throws JavaModelException {
		setUnit("Test.java",
			"/**\n" +
			" * @see Test.Field#foo\n" +
			" */\n" +
			"public class Test {\n" +
			"	/**\n" +
			"	 * @see Field#foo\n" +
			"	 */\n" +
			"	class Field {\n" +
			"		/**\n" +
			"		 * @see #foo\n" +
			"		 * @see Field#foo\n" +
			"		 * @see Test.Field#foo\n" +
			"		 */\n" +
			"		int foo;\n" +
			"	}\n" +
			"}\n"
		);
		IJavaElement[] elements = new IJavaElement[11];
		elements[0] = selectType(this.workingCopies[0], "Test", 2);
		elements[1] = selectType(this.workingCopies[0], "Field");
		elements[2] = selectField(this.workingCopies[0], "foo");
		elements[3] = selectType(this.workingCopies[0], "Field", 2);
		elements[4] = selectField(this.workingCopies[0], "foo", 2);
		elements[5] = selectField(this.workingCopies[0], "foo", 3);
		elements[6] = selectType(this.workingCopies[0], "Field", 4);
		elements[7] = selectField(this.workingCopies[0], "foo", 4);
		elements[8] = selectType(this.workingCopies[0], "Test", 3);
		elements[9] = selectType(this.workingCopies[0], "Field", 5);
		elements[10] = selectField(this.workingCopies[0], "foo", 5);
		assertElementsEqual("Invalid selection(s)",
			"Test [in [Working copy] Test.java [in <default> [in <project root> [in Tests]]]]\n" +
			"Field [in Test [in [Working copy] Test.java [in <default> [in <project root> [in Tests]]]]]\n" +
			"foo [in Field [in Test [in [Working copy] Test.java [in <default> [in <project root> [in Tests]]]]]]\n" +
			"Field [in Test [in [Working copy] Test.java [in <default> [in <project root> [in Tests]]]]]\n" +
			"foo [in Field [in Test [in [Working copy] Test.java [in <default> [in <project root> [in Tests]]]]]]\n" +
			"foo [in Field [in Test [in [Working copy] Test.java [in <default> [in <project root> [in Tests]]]]]]\n" +
			"Field [in Test [in [Working copy] Test.java [in <default> [in <project root> [in Tests]]]]]\n" +
			"foo [in Field [in Test [in [Working copy] Test.java [in <default> [in <project root> [in Tests]]]]]]\n" +
			"Test [in [Working copy] Test.java [in <default> [in <project root> [in Tests]]]]\n" +
			"Field [in Test [in [Working copy] Test.java [in <default> [in <project root> [in Tests]]]]]\n" +
			"foo [in Field [in Test [in [Working copy] Test.java [in <default> [in <project root> [in Tests]]]]]]",
			elements
		);
	}

	public void test18() throws JavaModelException {
		setUnit("Test.java",
			"/**\n" +
			" * @see Test.Method#foo()\n" +
			" */\n" +
			"public class Test {\n" +
			"	/**\n" +
			"	 * @see Method#foo()\n" +
			"	 */\n" +
			"	class Method {\n" +
			"		/**\n" +
			"		 * @see #foo()\n" +
			"		 * @see Method#foo()\n" +
			"		 * @see Test.Method#foo()\n" +
			"		 */\n" +
			"		void foo() {}\n" +
			"	}\n" +
			"}"
		);
		IJavaElement[] elements = new IJavaElement[11];
		elements[0] = selectType(this.workingCopies[0], "Test", 2);
		elements[1] = selectType(this.workingCopies[0], "Method");
		elements[2] = selectMethod(this.workingCopies[0], "foo");
		elements[3] = selectType(this.workingCopies[0], "Method", 2);
		elements[4] = selectMethod(this.workingCopies[0], "foo", 2);
		elements[5] = selectMethod(this.workingCopies[0], "foo", 3);
		elements[6] = selectType(this.workingCopies[0], "Method", 4);
		elements[7] = selectMethod(this.workingCopies[0], "foo", 4);
		elements[8] = selectType(this.workingCopies[0], "Test", 3);
		elements[9] = selectType(this.workingCopies[0], "Method", 5);
		elements[10] = selectMethod(this.workingCopies[0], "foo", 5);
		assertElementsEqual("Invalid selection(s)",
			"Test [in [Working copy] Test.java [in <default> [in <project root> [in Tests]]]]\n" +
			"Method [in Test [in [Working copy] Test.java [in <default> [in <project root> [in Tests]]]]]\n" +
			"foo() [in Method [in Test [in [Working copy] Test.java [in <default> [in <project root> [in Tests]]]]]]\n" +
			"Method [in Test [in [Working copy] Test.java [in <default> [in <project root> [in Tests]]]]]\n" +
			"foo() [in Method [in Test [in [Working copy] Test.java [in <default> [in <project root> [in Tests]]]]]]\n" +
			"foo() [in Method [in Test [in [Working copy] Test.java [in <default> [in <project root> [in Tests]]]]]]\n" +
			"Method [in Test [in [Working copy] Test.java [in <default> [in <project root> [in Tests]]]]]\n" +
			"foo() [in Method [in Test [in [Working copy] Test.java [in <default> [in <project root> [in Tests]]]]]]\n" +
			"Test [in [Working copy] Test.java [in <default> [in <project root> [in Tests]]]]\n" +
			"Method [in Test [in [Working copy] Test.java [in <default> [in <project root> [in Tests]]]]]\n" +
			"foo() [in Method [in Test [in [Working copy] Test.java [in <default> [in <project root> [in Tests]]]]]]",
			elements
		);
	}

	public void test19() throws JavaModelException {
		setUnit("Test.java",
			"/**\n" +
			" * @see Test.Other\n" +
			" */\n" +
			"public class Test {\n" +
			"	/**\n" +
			"	 * @see Test\n" +
			"	 * @see Other\n" +
			"	 * @see Test.Other\n" +
			"	 */\n" +
			"	class Other {}\n" +
			"}"
		);
		IJavaElement[] elements = new IJavaElement[6];
		elements[0] = selectType(this.workingCopies[0], "Test");
		elements[1] = selectType(this.workingCopies[0], "Other");
		elements[2] = selectType(this.workingCopies[0], "Test", 3);
		elements[3] = selectType(this.workingCopies[0], "Other", 2);
		elements[4] = selectType(this.workingCopies[0], "Test", 4);
		elements[5] = selectType(this.workingCopies[0], "Other", 3);
		assertElementsEqual("Invalid selection(s)",
			"Test [in [Working copy] Test.java [in <default> [in <project root> [in Tests]]]]\n" +
			"Other [in Test [in [Working copy] Test.java [in <default> [in <project root> [in Tests]]]]]\n" +
			"Test [in [Working copy] Test.java [in <default> [in <project root> [in Tests]]]]\n" +
			"Other [in Test [in [Working copy] Test.java [in <default> [in <project root> [in Tests]]]]]\n" +
			"Test [in [Working copy] Test.java [in <default> [in <project root> [in Tests]]]]\n" +
			"Other [in Test [in [Working copy] Test.java [in <default> [in <project root> [in Tests]]]]]",
			elements
		);
	}

	public void test20() throws JavaModelException {
		setUnit("Test.java",
			"public class Test {\n" +
			"	void bar() {\n" +
			"		/**\n" +
			"		 * @see Field#foo\n" +
			"		 */\n" +
			"		class Field {\n" +
			"			/**\n" +
			"			 * @see #foo\n" +
			"			 * @see Field#foo\n" +
			"			 */\n" +
			"			int foo;\n" +
			"		}\n" +
			"	}\n" +
			"}\n"
		);
		IJavaElement[] elements = new IJavaElement[5];
		elements[0] = selectType(this.workingCopies[0], "Field");
		elements[1] = selectField(this.workingCopies[0], "foo");
		elements[2] = selectField(this.workingCopies[0], "foo", 2);
		elements[3] = selectType(this.workingCopies[0], "Field", 3);
		elements[4] = selectField(this.workingCopies[0], "foo", 3);
		// Running test with Unix/Windows do not matter even if result includes positions as we use working copies
		assertElementsEqual("Invalid selection(s)",
			"Field [in bar() [in Test [in [Working copy] Test.java [in <default> [in <project root> [in Tests]]]]]]\n" +
			"foo [in Field [in bar() [in Test [in [Working copy] Test.java [in <default> [in <project root> [in Tests]]]]]]]\n" +
			"foo [in Field [in bar() [in Test [in [Working copy] Test.java [in <default> [in <project root> [in Tests]]]]]]]\n" +
			"Field [in bar() [in Test [in [Working copy] Test.java [in <default> [in <project root> [in Tests]]]]]]\n" +
			"foo [in Field [in bar() [in Test [in [Working copy] Test.java [in <default> [in <project root> [in Tests]]]]]]]",
			elements
		);
	}

	public void test21() throws JavaModelException {
		setUnit("Test.java",
			"public class Test {\n" +
			"	void bar() {\n" +
			"		/**\n" +
			"		 * @see Method#foo()\n" +
			"		 */\n" +
			"		class Method {\n" +
			"			/**\n" +
			"			 * @see #foo()\n" +
			"			 * @see Method#foo()\n" +
			"			 */\n" +
			"			void foo() {}\n" +
			"		}\n" +
			"	}\n" +
			"}"
		);
		IJavaElement[] elements = new IJavaElement[5];
		elements[0] = selectType(this.workingCopies[0], "Method");
		elements[1] = selectMethod(this.workingCopies[0], "foo");
		elements[2] = selectMethod(this.workingCopies[0], "foo", 2);
		elements[3] = selectType(this.workingCopies[0], "Method", 3);
		elements[4] = selectMethod(this.workingCopies[0], "foo", 3);
		// Running test with Unix/Windows do not matter even if result includes positions as we use working copies
		assertElementsEqual("Invalid selection(s)",
			"Method [in bar() [in Test [in [Working copy] Test.java [in <default> [in <project root> [in Tests]]]]]]\n" +
			"foo() [in Method [in bar() [in Test [in [Working copy] Test.java [in <default> [in <project root> [in Tests]]]]]]]\n" +
			"foo() [in Method [in bar() [in Test [in [Working copy] Test.java [in <default> [in <project root> [in Tests]]]]]]]\n" +
			"Method [in bar() [in Test [in [Working copy] Test.java [in <default> [in <project root> [in Tests]]]]]]\n" +
			"foo() [in Method [in bar() [in Test [in [Working copy] Test.java [in <default> [in <project root> [in Tests]]]]]]]",
			elements
		);
	}

	public void test22() throws JavaModelException {
		setUnit("Test.java",
			"public class Test {\n" +
			"	void bar() {\n" +
			"		/**\n" +
			"		 * @see Test\n" +
			"		 * @see Other\n" +
			"		 */\n" +
			"		class Other {}\n" +
			"	}\n" +
			"}"
		);
		IJavaElement[] elements = new IJavaElement[2];
		elements[0] = selectType(this.workingCopies[0], "Test", 2);
		elements[1] = selectType(this.workingCopies[0], "Other");
		// Running test with Unix/Windows do not matter even if result includes positions as we use working copies
		assertElementsEqual("Invalid selection(s)",
			"Test [in [Working copy] Test.java [in <default> [in <project root> [in Tests]]]]\n" +
			"Other [in bar() [in Test [in [Working copy] Test.java [in <default> [in <project root> [in Tests]]]]]]",
			elements
		);
	}

	public void test23() throws JavaModelException {
		setUnit("Test.java",
			"public class Test {\n" +
			"	void bar() {\n" +
			"		new Object() {\n" +
			"			/**\n" +
			"			 * @see Field#foo\n" +
			"			 */\n" +
			"			class Field {\n" +
			"				/**\n" +
			"				 * @see #foo\n" +
			"				 * @see Field#foo\n" +
			"				 */\n" +
			"				int foo;\n" +
			"			}\n" +
			"		};\n" +
			"	}\n" +
			"}\n"
		);
		IJavaElement[] elements = new IJavaElement[5];
		elements[0] = selectType(this.workingCopies[0], "Field");
		elements[1] = selectField(this.workingCopies[0], "foo");
		elements[2] = selectField(this.workingCopies[0], "foo", 2);
		elements[3] = selectType(this.workingCopies[0], "Field", 3);
		elements[4] = selectField(this.workingCopies[0], "foo", 3);
		// Running test with Unix/Windows do not matter even if result includes positions as we use working copies
		assertElementsEqual("Invalid selection(s)",
			"Field [in <anonymous #1> [in bar() [in Test [in [Working copy] Test.java [in <default> [in <project root> [in Tests]]]]]]]\n" +
			"foo [in Field [in <anonymous #1> [in bar() [in Test [in [Working copy] Test.java [in <default> [in <project root> [in Tests]]]]]]]]\n" +
			"foo [in Field [in <anonymous #1> [in bar() [in Test [in [Working copy] Test.java [in <default> [in <project root> [in Tests]]]]]]]]\n" +
			"Field [in <anonymous #1> [in bar() [in Test [in [Working copy] Test.java [in <default> [in <project root> [in Tests]]]]]]]\n" +
			"foo [in Field [in <anonymous #1> [in bar() [in Test [in [Working copy] Test.java [in <default> [in <project root> [in Tests]]]]]]]]",
			elements
		);
	}

	public void test24() throws JavaModelException {
		setUnit("Test.java",
			"public class Test {\n" +
			"	void bar() {\n" +
			"		new Object() {\n" +
			"			/**\n" +
			"			 * @see Method#foo()\n" +
			"			 */\n" +
			"			class Method {\n" +
			"				/**\n" +
			"				 * @see #foo()\n" +
			"				 * @see Method#foo()\n" +
			"				 */\n" +
			"				void foo() {}\n" +
			"			}\n" +
			"		};\n" +
			"	}\n" +
			"}"
		);
		IJavaElement[] elements = new IJavaElement[5];
		elements[0] = selectType(this.workingCopies[0], "Method");
		elements[1] = selectMethod(this.workingCopies[0], "foo");
		elements[2] = selectMethod(this.workingCopies[0], "foo", 2);
		elements[3] = selectType(this.workingCopies[0], "Method", 3);
		elements[4] = selectMethod(this.workingCopies[0], "foo", 3);
		// Running test with Unix/Windows do not matter even if result includes positions as we use working copies
		assertElementsEqual("Invalid selection(s)",
			"Method [in <anonymous #1> [in bar() [in Test [in [Working copy] Test.java [in <default> [in <project root> [in Tests]]]]]]]\n" +
			"foo() [in Method [in <anonymous #1> [in bar() [in Test [in [Working copy] Test.java [in <default> [in <project root> [in Tests]]]]]]]]\n" +
			"foo() [in Method [in <anonymous #1> [in bar() [in Test [in [Working copy] Test.java [in <default> [in <project root> [in Tests]]]]]]]]\n" +
			"Method [in <anonymous #1> [in bar() [in Test [in [Working copy] Test.java [in <default> [in <project root> [in Tests]]]]]]]\n" +
			"foo() [in Method [in <anonymous #1> [in bar() [in Test [in [Working copy] Test.java [in <default> [in <project root> [in Tests]]]]]]]]",
			elements
		);
	}

	public void test25() throws JavaModelException {
		setUnit("Test.java",
			"public class Test {\n" +
			"	void bar() {\n" +
			"		new Object() {\n" +
			"			/**\n" +
			"			 * @see Test\n" +
			"			 * @see Other\n" +
			"			 */\n" +
			"			class Other {}\n" +
			"		};\n" +
			"	}\n" +
			"}"
		);
		IJavaElement[] elements = new IJavaElement[2];
		elements[0] = selectType(this.workingCopies[0], "Test", 2);
		elements[1] = selectType(this.workingCopies[0], "Other");
		// Running test with Unix/Windows do not matter even if result includes positions as we use working copies
		assertElementsEqual("Invalid selection(s)",
			"Test [in [Working copy] Test.java [in <default> [in <project root> [in Tests]]]]\n" +
			"Other [in <anonymous #1> [in bar() [in Test [in [Working copy] Test.java [in <default> [in <project root> [in Tests]]]]]]]",
			elements
		);
	}

	public void test26() throws JavaModelException {
		setUnit("Test.java",
			"public class Test {\n" +
			"	static int field;\n" +
			"	/** \n" +
			"	 * First {@value #field}" +
			"	 * Second {@value Test#field}" +
			"	 */\n" +
			"	void foo() {}\n" +
			"}\n"
		);
		IJavaElement[] elements = new IJavaElement[3];
		elements[0] = selectField(this.workingCopies[0], "field");
		elements[1] = selectType(this.workingCopies[0], "Test");
		elements[2] = selectField(this.workingCopies[0], "field");
		assertElementsEqual("Invalid selection(s)",
			"field [in Test [in [Working copy] Test.java [in <default> [in <project root> [in Tests]]]]]\n" +
			"Test [in [Working copy] Test.java [in <default> [in <project root> [in Tests]]]]\n" +
			"field [in Test [in [Working copy] Test.java [in <default> [in <project root> [in Tests]]]]]",
			elements
		);
	}

	/**
	 * Bug 86380: [1.5][search][annot] Add support to find references inside annotations on a package declaration
	 * @see "https://bugs.eclipse.org/bugs/show_bug.cgi?id=86380"
	 */
	public void testBug86380() throws CoreException {
		this.wcOwner = new WorkingCopyOwner() {};
		this.workingCopies = new ICompilationUnit[2];
		this.workingCopies[0] = getWorkingCopy("/Tests/b86380/package-info.java",
			"/**\n" +
			" * Valid javadoc.\n" +
			" * @see Test\n" +
			" * @see Unknown\n" +
			" * @see Test#foo()\n" +
			" * @see Test#unknown()\n" +
			" * @see Test#field\n" +
			" * @see Test#unknown\n" +
			" * @param unexpected\n" +
			" * @throws unexpected\n" +
			" * @return unexpected \n" +
			" */\n" +
			"package b86380;\n"
		);
		this.workingCopies[1] = getWorkingCopy("/Tests/b86380/Test.java",
			"/**\n" +
			" * Invalid javadoc\n" +
			" */\n" +
			"package b86380;\n" +
			"public class Test {\n" +
			"	public int field;\n" +
			"	public void foo() {}\n" +
			"}\n"
		);
		IJavaElement[] elements = new IJavaElement[3];
		elements[0] = selectType(this.workingCopies[0], "Test");
		elements[1] = selectMethod(this.workingCopies[0], "foo");
		elements[2] = selectField(this.workingCopies[0], "field");
		assertElementsEqual("Invalid selection(s)",
			"Test [in [Working copy] Test.java [in b86380 [in <project root> [in Tests]]]]\n" +
			"foo() [in Test [in [Working copy] Test.java [in b86380 [in <project root> [in Tests]]]]]\n" +
			"field [in Test [in [Working copy] Test.java [in b86380 [in <project root> [in Tests]]]]]",
			elements
		);
	}

	/**
	 * Bug 90266: [select] Code select returns null when there's a string including a slash on same line
	 * @see "https://bugs.eclipse.org/bugs/show_bug.cgi?id=90266"
	 */
	public void testBug90266_String() throws JavaModelException {
		setUnit("b90266/Test.java",
			"package b90266;\n" +
			"public class Test {\n" +
			"	public int field;\n" +
			"	public void foo(String str, int i) {}\n" +
			"	public void bar() {\n" +
			"		foo(\"String including / (slash)\", this.field)\n" +
			"	}\n" +
			"}\n"
		);
		int[] selectionPositions = selectionInfo(this.workingCopies[0], "field", 2);
		IJavaElement[] elements = this.workingCopies[0].codeSelect(selectionPositions[0], 0);
		assertElementsEqual("Invalid selection(s)",
			"field [in Test [in [Working copy] Test.java [in b90266 [in <project root> [in Tests]]]]]",
			elements
		);
	}
	public void testBug90266_Char() throws JavaModelException {
		setUnit("b90266/Test.java",
			"package b90266;\n" +
			"public class Test {\n" +
			"	public int field;\n" +
			"	public void foo(Char c, int i) {}\n" +
			"	public void bar() {\n" +
			"		foo('/', this.field)\n" +
			"	}\n" +
			"}\n"
		);
		int[] selectionPositions = selectionInfo(this.workingCopies[0], "field", 2);
		IJavaElement[] elements = this.workingCopies[0].codeSelect(selectionPositions[0], 0);
		assertElementsEqual("Invalid selection(s)",
			"field [in Test [in [Working copy] Test.java [in b90266 [in <project root> [in Tests]]]]]",
			elements
		);
	}

	/**
	 * @bug 165701: [model] No hint for ambiguous javadoc
	 * @test Ensure that no exception is thrown while selecting method in javadoc comment
	 * @see "http://bugs.eclipse.org/bugs/show_bug.cgi?id=165701"
	 */
	public void testBug165701() throws JavaModelException {
		setUnit("b165701/Test.java",
			"package b165701;\n" +
			"/**\n" +
			" * @see #fooo(int)\n" +
			" */\n" +
			"public class Test {\n" +
			"	public void foo() {}\n" +
			"}\n"
		);
		int[] selectionPositions = selectionInfo(this.workingCopies[0], "fooo", 1);
		IJavaElement[] elements = this.workingCopies[0].codeSelect(selectionPositions[0], 0);
		assertElementsEqual("Invalid selection(s)",
			"Test [in [Working copy] Test.java [in b165701 [in <project root> [in Tests]]]]",
			elements
		);
	}

	/**
	 * @bug 165794: [model] No hint for ambiguous javadoc
	 * @test Ensure that no exception is thrown while selecting method in javadoc comment
	 * @see "http://bugs.eclipse.org/bugs/show_bug.cgi?id=165794"
	 */
	public void testBug165794() throws JavaModelException {
		setUnit("b165794/Test.java",
			"package b165794;\n" +
			"/**\n" +
			" * No reasonable hint for resolving the {@link #getMax(A)}.\n" +
			" */\n" +
			"public class X {\n" +
			"    /**\n" +
			"     * Extends Number method.\n" +
			"     * @see #getMax(A ipZ)\n" +
			"     */\n" +
			"    public <T extends Y> T getMax(final A<T> ipY) {\n" +
			"        return ipY.t();\n" +
			"    }\n" +
			"    \n" +
			"    /**\n" +
			"     * Extends Exception method.\n" +
			"     * @see #getMax(A ipY)\n" +
			"     */\n" +
			"    public <T extends Z> T getMax(final A<T> ipZ) {\n" +
			"        return ipZ.t();\n" +
			"    }\n" +
			"}\n" +
			"class A<T> {\n" +
			"	T t() { return null; }\n" +
			"}\n" +
			"class Y {}\n" +
			"class Z {}"
		);
		int[] selectionPositions = selectionInfo(this.workingCopies[0], "getMax", 1);
		IJavaElement[] elements = this.workingCopies[0].codeSelect(selectionPositions[0], 0);
		assertElementsEqual("Invalid selection(s)",
			"getMax(A<T>) [in X [in [Working copy] Test.java [in b165794 [in <project root> [in Tests]]]]]",
			elements
		);
	}

	/**
	 * Bug 171802: [javadoc][select] F3 does not work on method which have deprecated type as argument
	 * @see "https://bugs.eclipse.org/bugs/show_bug.cgi?id=171802"
	 */
	public void testBug171802() throws CoreException {
		this.wcOwner = new WorkingCopyOwner() {};
		this.workingCopies = new ICompilationUnit[2];
		this.workingCopies[0] = getWorkingCopy("/Tests/b171802/Y.java",
			"package b171802;\n" +
			"\n" +
			"/**\n" +
			" * @deprecated\n" +
			" */\n" +
			"public class Y {\n" +
			"\n" +
			"}\n"
		);
		this.workingCopies[1] = getWorkingCopy("/Tests/b171802/X.java",
			"package b171802;\n" +
			"\n" +
			"public class X {\n" +
			"	/**\n" +
			"	 * @deprecated Use {@link #bar(char[], Y)}\n" +
			"	 * instead\n" +
			"	 */\n" +
			"	void foo(char[] param1, Y param2) {}\n" +
			"\n" +
			"	/**\n" +
			"	 * @deprecated\n" +
			"	 */\n" +
			"	void bar(char[] param1, Y param2) {}\n" +
			"\n" +
			"}\n"
		);
		IJavaElement[] elements = new IJavaElement[1];
		elements[0] = selectMethod(this.workingCopies[1], "bar");
		assertElementsEqual("Invalid selection(s)",
			"bar(char[], Y) [in X [in [Working copy] X.java [in b171802 [in <project root> [in Tests]]]]]",
			elements
		);
	}

	/**
	 * @bug 191322: [javadoc] @see or @link reference to method without signature fails to resolve to base class method
	 * @see "https://bugs.eclipse.org/bugs/show_bug.cgi?id=191322"
	 */
	public void testBug191322a() throws CoreException {
		this.wcOwner = new WorkingCopyOwner() {};
		this.workingCopies = new ICompilationUnit[1];
		this.workingCopies[0] = getWorkingCopy("/Tests/b191322/X.java",
			"package b191322;\n" +
			"public class X {\n" +
			"	void foo() {}\n" +
			"}\n" +
			"class Y extends X {\n" +
			"	/**\n" +
			"	 * {@link #foo}\n" +
			"	 * @see #foo\n" +
			"	 */\n" +
			"	void hoo() {}\n" +
			"}\n"
		);
		IJavaElement[] elements = new IJavaElement[1];
		elements[0] = selectMethod(this.workingCopies[0], "foo", 2);
		assertElementsEqual("Invalid selection(s)",
			"foo() [in X [in [Working copy] X.java [in b191322 [in <project root> [in Tests]]]]]",
			elements
		);
	}
	public void testBug191322b() throws CoreException {
		this.wcOwner = new WorkingCopyOwner() {};
		this.workingCopies = new ICompilationUnit[1];
		this.workingCopies[0] = getWorkingCopy("/Tests/b191322/X.java",
			"package b191322;\n" +
			"public class X {\n" +
			"	void foo() {}\n" +
			"}\n" +
			"class Y extends X {}\n" +
			"class W extends Y {}\n" +
			"class Z extends W {\n" +
			"	/**\n" +
			"	 * @see #foo\n" +
			"	 */\n" +
			"	void hoo() {}\n" +
			"}\n"
		);
		IJavaElement[] elements = new IJavaElement[1];
		elements[0] = selectMethod(this.workingCopies[0], "foo", 2);
		assertElementsEqual("Invalid selection(s)",
			"foo() [in X [in [Working copy] X.java [in b191322 [in <project root> [in Tests]]]]]",
			elements
		);
	}
	public void testBug191322c() throws CoreException {
		this.wcOwner = new WorkingCopyOwner() {};
		this.workingCopies = new ICompilationUnit[1];
		this.workingCopies[0] = getWorkingCopy("/Tests/b191322/X.java",
			"package b191322;\n" +
			"public interface X {\n" +
			"	void foo();\n" +
			"}\n" +
			"interface Y extends X {\n" +
			"	/**\n" +
			"	 * {@link #foo}\n" +
			"	 */\n" +
			"	void hoo();\n" +
			"}\n"
		);
		IJavaElement[] elements = new IJavaElement[1];
		elements[0] = selectMethod(this.workingCopies[0], "foo", 2);
		assertElementsEqual("Invalid selection(s)",
			"foo() [in X [in [Working copy] X.java [in b191322 [in <project root> [in Tests]]]]]",
			elements
		);
	}
	public void testBug191322d() throws CoreException {
		this.wcOwner = new WorkingCopyOwner() {};
		this.workingCopies = new ICompilationUnit[1];
		this.workingCopies[0] = getWorkingCopy("/Tests/b191322/X.java",
			"package b191322;\n" +
			"public interface X {\n" +
			"	void foo();\n" +
			"}\n" +
			"interface Y extends X {}\n" +
			"abstract class W implements Y {}\n" +
			"abstract class Z extends W {\n" +
			"	/**\n" +
			"	 * @see #foo\n" +
			"	 */\n" +
			"	void hoo() {}\n" +
			"}\n"
		);
		IJavaElement[] elements = new IJavaElement[1];
		elements[0] = selectMethod(this.workingCopies[0], "foo", 2);
		assertElementsEqual("Invalid selection(s)",
			"foo() [in X [in [Working copy] X.java [in b191322 [in <project root> [in Tests]]]]]",
			elements
		);
	}
	public void testBug191322e() throws CoreException {
		this.wcOwner = new WorkingCopyOwner() {};
		this.workingCopies = new ICompilationUnit[1];
		this.workingCopies[0] = getWorkingCopy("/Tests/b191322/X.java",
			"package b191322;\n" +
			"public class X {\n" +
			"	void foo() {}\n" +
			"	class Y {\n" +
			"		/**\n" +
			"		 * @see #foo\n" +
			"		 */\n" +
			"		void hoo() {}\n" +
			"	}\n" +
			"}\n"
		);
		IJavaElement[] elements = new IJavaElement[1];
		elements[0] = selectMethod(this.workingCopies[0], "foo", 2);
		assertElementsEqual("Invalid selection(s)",
			"foo() [in X [in [Working copy] X.java [in b191322 [in <project root> [in Tests]]]]]",
			elements
		);
	}
	public void testBug191322f() throws CoreException {
		this.wcOwner = new WorkingCopyOwner() {};
		this.workingCopies = new ICompilationUnit[1];
		this.workingCopies[0] = getWorkingCopy("/Tests/b191322/X.java",
			"package b191322;\n" +
			"public class X {\n" +
			"	void foo() {}\n" +
			"	void foo(String str) {}\n" +
			"}\n" +
			"class Y extends X {\n" +
			"	/**\n" +
			"	 * @see #foo\n" +
			"	 */\n" +
			"	void hoo() {}\n" +
			"}\n"
		);
		IJavaElement[] elements = new IJavaElement[1];
		elements[0] = selectMethod(this.workingCopies[0], "foo", 3);
		assertElementsEqual("Invalid selection(s)",
			"foo() [in X [in [Working copy] X.java [in b191322 [in <project root> [in Tests]]]]]",
			elements
		);
	}
	public void testBug191322g() throws CoreException {
		this.wcOwner = new WorkingCopyOwner() {};
		this.workingCopies = new ICompilationUnit[1];
		this.workingCopies[0] = getWorkingCopy("/Tests/b191322/X.java",
			"package b191322;\n" +
			"public class X {\n" +
			"	void foo(String str) {}\n" +
			"	void foo() {}\n" +
			"}\n" +
			"class Y extends X {\n" +
			"	/**\n" +
			"	 * {@link #foo}\n" +
			"	 */\n" +
			"	void hoo() {}\n" +
			"}\n"
		);
		IJavaElement[] elements = new IJavaElement[1];
		elements[0] = selectMethod(this.workingCopies[0], "foo", 3);
		assertElementsEqual("Invalid selection(s)",
			"foo() [in X [in [Working copy] X.java [in b191322 [in <project root> [in Tests]]]]]",
			elements
		);
	}
	public void testBug191322h() throws CoreException {
		this.wcOwner = new WorkingCopyOwner() {};
		this.workingCopies = new ICompilationUnit[1];
		this.workingCopies[0] = getWorkingCopy("/Tests/b191322/X.java",
			"package b191322;\n" +
			"public class X {\n" +
			"	void foo(String str) {}\n" +
			"	void foo(int x) {}\n" +
			"}\n" +
			"class Y extends X {\n" +
			"	/**\n" +
			"	 * @see #foo\n" +
			"	 */\n" +
			"	void hoo() {}\n" +
			"}\n"
		);
		IJavaElement[] elements = new IJavaElement[1];
		elements[0] = selectMethod(this.workingCopies[0], "foo", 3);
		assertElementsEqual("Invalid selection(s)",
			"foo(String) [in X [in [Working copy] X.java [in b191322 [in <project root> [in Tests]]]]]",
			elements
		);
	}
	public void testBug191322i() throws CoreException {
		this.wcOwner = new WorkingCopyOwner() {};
		this.workingCopies = new ICompilationUnit[1];
		this.workingCopies[0] = getWorkingCopy("/Tests/b191322/X.java",
			"package b191322;\n" +
			"public class X {\n" +
			"	void foo(String str) {}\n" +
			"}\n" +
			"class Y extends X {\n" +
			"	/**\n" +
			"	 * @see #foo\n" +
			"	 */\n" +
			"	void hoo() {}\n" +
			"}\n"
		);
		IJavaElement[] elements = new IJavaElement[1];
		elements[0] = selectMethod(this.workingCopies[0], "foo", 2);
		assertElementsEqual("Invalid selection(s)",
			"foo(String) [in X [in [Working copy] X.java [in b191322 [in <project root> [in Tests]]]]]",
			elements
		);
	}
	public void testBug191322j1() throws CoreException {
		this.wcOwner = new WorkingCopyOwner() {};
		this.workingCopies = new ICompilationUnit[1];
		this.workingCopies[0] = getWorkingCopy("/Tests/b191322/X.java",
			"package b191322;\n" +
			"interface X {\n" +
			"	void foo();\n" +
			"}\n" +
			"interface Y {\n" +
			"	void foo(int i);\n" +
			"}\n" +
			"abstract class Z implements X, Y {\n" +
			"	/**\n" +
			"	 * @see #foo\n" +
			"	 */\n" +
			"	void bar() {\n" +
			"	}\n" +
			"}"
		);
		IJavaElement[] elements = new IJavaElement[1];
		elements[0] = selectMethod(this.workingCopies[0], "foo", 3);
		assertElementsEqual("Invalid selection(s)",
			"foo() [in X [in [Working copy] X.java [in b191322 [in <project root> [in Tests]]]]]",
			elements
		);
	}
	public void testBug191322j2() throws CoreException {
		this.wcOwner = new WorkingCopyOwner() {};
		this.workingCopies = new ICompilationUnit[1];
		this.workingCopies[0] = getWorkingCopy("/Tests/b191322/X.java",
			"package b191322;\n" +
			"interface X {\n" +
			"	void foo(int x);\n" +
			"}\n" +
			"interface Y {\n" +
			"	void foo();\n" +
			"}\n" +
			"abstract class Z implements X, Y {\n" +
			"	/**\n" +
			"	 * @see #foo\n" +
			"	 */\n" +
			"	void bar() {\n" +
			"	}\n" +
			"}"
		);
		IJavaElement[] elements = new IJavaElement[1];
		elements[0] = selectMethod(this.workingCopies[0], "foo", 3);
		assertElementsEqual("Invalid selection(s)",
			"foo() [in Y [in [Working copy] X.java [in b191322 [in <project root> [in Tests]]]]]",
			elements
		);
	}
	public void testBug191322j3() throws CoreException {
		this.wcOwner = new WorkingCopyOwner() {};
		this.workingCopies = new ICompilationUnit[1];
		this.workingCopies[0] = getWorkingCopy("/Tests/b191322/X.java",
			"package b191322;\n" +
			"interface X {\n" +
			"	void foo(int x);\n" +
			"}\n" +
			"interface Y {\n" +
			"	void foo(String str);\n" +
			"}\n" +
			"abstract class Z implements X, Y {\n" +
			"	/**\n" +
			"	 * @see #foo\n" +
			"	 */\n" +
			"	void bar() {\n" +
			"	}\n" +
			"}"
		);
		IJavaElement[] elements = new IJavaElement[1];
		elements[0] = selectMethod(this.workingCopies[0], "foo", 3);
		assertElementsEqual("Invalid selection(s)",
			"foo(int) [in X [in [Working copy] X.java [in b191322 [in <project root> [in Tests]]]]]",
			elements
		);
	}
	// https://bugs.eclipse.org/bugs/show_bug.cgi?id=171019
	// To verify that inheritDoc tag is recognized as a valid selection and
	// pressing F3 on it navigates to the overriden method with the javadoc according to spec
	// as documented in org.eclipse.jdt.internal.codeassist.SelectionEngine.InheritDocVisitor
	public void testBug171019() throws CoreException {
		this.wcOwner = new WorkingCopyOwner() {};
		this.workingCopies = new ICompilationUnit[1];
		this.workingCopies[0] = getWorkingCopy("/Tests/b171019/X.java",
			"package b171019;\n" +
			"interface X {\n" +
			"   /**\n" +
			"	 * Main desc of foo..\n" +
			"	 */\n" +
			"	void foo(int x);\n" +
			"}\n" +
			"interface Y extends X {\n" +
			"   /**\n" +
			"	 * {@inheritDoc}\n" +	// should navigate to X.foo(int)
			"	 */\n" +
			"	void foo(int x);\n\n" +
			"   /**\n" +
			"	 * {@inheritDoc}\n" +	// should navigate to Y.foo(String)
			"	 */\n" +
			"	void foo(String s);\n" +
			"}\n"
		);
		IJavaElement[] elements = new IJavaElement[2];
		elements[0] = selectMethod(this.workingCopies[0], "@inheritDoc", 1);
		elements[1] = selectMethod(this.workingCopies[0], "@inheritDoc", 2);
		assertElementsEqual("Invalid selection(s)",
			"foo(int) [in X [in [Working copy] X.java [in b171019 [in <project root> [in Tests]]]]]\n" + 
			"foo(String) [in Y [in [Working copy] X.java [in b171019 [in <project root> [in Tests]]]]]",
			elements
		);
	}
	// https://bugs.eclipse.org/bugs/show_bug.cgi?id=171019
	// To verify that inheritDoc tag is recognized as a valid selection and
	// pressing F3 on it navigates to the overriden method with the javadoc according to spec
	// as documented in org.eclipse.jdt.internal.codeassist.SelectionEngine.InheritDocVisitor
	public void testBug171019b() throws CoreException {
		this.wcOwner = new WorkingCopyOwner() {};
		this.workingCopies = new ICompilationUnit[1];
		this.workingCopies[0] = getWorkingCopy("/Tests/b171019/X.java",
			"package b171019;\n" +
			"interface X {\n" +
			"   /**\n" +
			"	 * Main desc of foo..\n" +
			"	 */\n" +
			"	void foo(int x);\n" +
			"}\n" +
			"class X1 implements X{\n" +
			"	void foo(int x){}\n" +
			"}\n" +
			"class Y extends X1 {\n" +
			"   /**\n" +
			"	 * {@inheritDoc}\n" +	// should navigate to X.foo(int)
			"	 */\n" +
			"	void foo(int x);\n\n" +
			"   /**\n" +
			"	 * {@inheritDoc}\n" +	// should navigate to Y.foo(String)
			"	 */\n" +
			"	void foo(String s);\n" +
			"}\n"
		);
		IJavaElement[] elements = new IJavaElement[2];
		elements[0] = selectMethod(this.workingCopies[0], "@inheritDoc", 1);
		elements[1] = selectMethod(this.workingCopies[0], "@inheritDoc", 2);
		assertElementsEqual("Invalid selection(s)",
			"foo(int) [in X [in [Working copy] X.java [in b171019 [in <project root> [in Tests]]]]]\n" + 
			"foo(String) [in Y [in [Working copy] X.java [in b171019 [in <project root> [in Tests]]]]]",
			elements
		);
	}
	// https://bugs.eclipse.org/bugs/show_bug.cgi?id=171019
	// To verify that inheritDoc tag is recognized as a valid selection and
	// pressing F3 on it navigates to the overriden method with the javadoc according to spec
	// as documented in org.eclipse.jdt.internal.codeassist.SelectionEngine.InheritDocVisitor
	public void testBug171019c() throws CoreException {
		this.wcOwner = new WorkingCopyOwner() {};
		this.workingCopies = new ICompilationUnit[1];
		this.workingCopies[0] = getWorkingCopy("/Tests/b171019/X.java",
			"package b171019;\n" +
			"interface X1 {\n" +
			"   /**\n" +
			"	 * Main desc of foo in X1..\n" +
			"	 */\n" +
			"	void foo(int x);\n" +
			"}\n" +
			"interface X2 {\n" +
			"   /**\n" +
			"	 * Main desc of foo in X2..\n" +
			"	 */\n" +
			"	void foo(int x);\n" +
			"}\n" +
			"class X implements X1 {\n" +
			"   /**\n" +
			"	 * X desc of foo..\n" +
			"	 */\n" +
			"	void foo(int x){}\n" +
			"}\n" +
			"class Y extends X implements X2 {\n" +
			"   /**\n" +
			"	 * {@inheritDoc}\n" +	// should navigate to X2.foo(int)
			"	 */\n" +
			"	void foo(int x);\n\n" +
			"}\n"
		);
		IJavaElement[] elements = new IJavaElement[1];
		elements[0] = selectMethod(this.workingCopies[0], "@inheritDoc", 1);
		assertElementsEqual("Invalid selection(s)",
			"foo(int) [in X2 [in [Working copy] X.java [in b171019 [in <project root> [in Tests]]]]]",
			elements
		);
	}
	// https://bugs.eclipse.org/bugs/show_bug.cgi?id=171019
	// To verify that inheritDoc tag is recognized as a valid selection and
	// pressing F3 on it navigates to the overriden method with the javadoc according to spec
	// as documented in org.eclipse.jdt.internal.codeassist.SelectionEngine.InheritDocVisitor
	public void testBug171019d() throws CoreException {
		this.wcOwner = new WorkingCopyOwner() {};
		this.workingCopies = new ICompilationUnit[1];
		this.workingCopies[0] = getWorkingCopy("/Tests/b171019/X.java",
			"package b171019;\n" +
			"interface X1 {\n" +
			"   /**\n" +
			"	 * Main desc of foo in X1..\n" +
			"	 */\n" +
			"	void foo(int x);\n" +
			"}\n" +
			"interface X2 {\n" +
			"	void foo(int x);\n" +
			"}\n" +
			"class X implements X1 {\n" +
			"   /**\n" +
			"	 * X desc of foo..\n" +
			"	 */\n" +
			"	void foo(int x){}\n" +
			"}\n" +
			"class Y extends X implements X2 {\n" +
			"   /**\n" +
			"	 * {@inheritDoc}\n" +	// should navigate to X.foo(int)
			"	 */\n" +
			"	void foo(int x);\n\n" +
			"}\n"
		);
		IJavaElement[] elements = new IJavaElement[1];
		elements[0] = selectMethod(this.workingCopies[0], "@inheritDoc", 1);
		assertElementsEqual("Invalid selection(s)",
			"foo(int) [in X [in [Working copy] X.java [in b171019 [in <project root> [in Tests]]]]]",
			elements
		);
	}
	// https://bugs.eclipse.org/bugs/show_bug.cgi?id=171019
	// To verify that inheritDoc tag is recognized as a valid selection and
	// pressing F3 on it navigates to the overriden method with the javadoc according to spec
	// as documented in org.eclipse.jdt.internal.codeassist.SelectionEngine.InheritDocVisitor
	public void testBug171019e() throws CoreException {
		this.wcOwner = new WorkingCopyOwner() {};
		this.workingCopies = new ICompilationUnit[1];
		this.workingCopies[0] = getWorkingCopy("/Tests/b171019/X.java",
			"package b171019;\n" +
			"interface X {\n" +
			"   /**\n" +
			"	 * Main desc of foo..\n" +
			"	 */\n" +
			"	void foo(int x);\n" +
			"}\n" +
			"interface Y {\n" +
			"	void foo(String str);\n" +
			"}\n" +
			"abstract class Z implements X, Y {\n" +
			"	/**\n" +
			"	 * {@inheritDoc}\n" +	// navigates to X.foo(int)
			"	 */\n" +
			"	void foo(int x) {\n" +
			"	}\n" +
			"}"
		);
		IJavaElement[] elements = new IJavaElement[1];
		elements[0] = selectMethod(this.workingCopies[0], "@inheritDoc", 1);
		assertElementsEqual("Invalid selection(s)",
			"foo(int) [in X [in [Working copy] X.java [in b171019 [in <project root> [in Tests]]]]]",
			elements
		);
	}
	// https://bugs.eclipse.org/bugs/show_bug.cgi?id=171019
	// To verify that inheritDoc tag is recognized as a valid selection and
	// pressing F3 on it navigates to the overriden method with the javadoc according to spec
	// as documented in org.eclipse.jdt.internal.codeassist.SelectionEngine.InheritDocVisitor
	// Here the inheritDoc should work when it occurs inside another valid block tag viz.
	// @param, @throws, @exception, @return
	public void testBug171019f() throws CoreException {
		this.wcOwner = new WorkingCopyOwner() {};
		this.workingCopies = new ICompilationUnit[1];
		this.workingCopies[0] = getWorkingCopy("/Tests/b171019/X.java",
			"package b171019;\n" +
			"interface X {\n" +
			"   /**\n" +
			"	 * Main desc of foo..\n" +
			"	 */\n" +
			"	void foo(int x);\n" +
			"}\n" +
			"interface Y extends X {\n" +
			"   /**\n" +
			"	 * {@inheritDoc}\n" +	// should navigate to X.foo(int)
			"	 * @param {@inheritDoc}\n" +	// should navigate to X.foo(int)
			"	 * @return {@inheritDoc}\n" +	// should navigate to X.foo(int)
			"	 * @throws {@inheritDoc}\n" +	// should navigate to X.foo(int)
			"	 * @exception {@inheritDoc}\n" +	// should navigate to X.foo(int)
			"	 */\n" +
			"	void foo(int x);\n\n" +
			"}\n"
		);
		IJavaElement[] elements = new IJavaElement[4];
		elements[0] = selectMethod(this.workingCopies[0], "@inheritDoc", 1);
		elements[1] = selectMethod(this.workingCopies[0], "@inheritDoc", 2);
		elements[2] = selectMethod(this.workingCopies[0], "@inheritDoc", 3);
		elements[3] = selectMethod(this.workingCopies[0], "@inheritDoc", 4);
		assertElementsEqual("Invalid selection(s)",
			"foo(int) [in X [in [Working copy] X.java [in b171019 [in <project root> [in Tests]]]]]\n" + 
			"foo(int) [in X [in [Working copy] X.java [in b171019 [in <project root> [in Tests]]]]]\n" + 
			"foo(int) [in X [in [Working copy] X.java [in b171019 [in <project root> [in Tests]]]]]\n" + 
			"foo(int) [in X [in [Working copy] X.java [in b171019 [in <project root> [in Tests]]]]]",
			elements
		);
	}
	// https://bugs.eclipse.org/bugs/show_bug.cgi?id=400767
	public void testBug400767() throws Exception {
		String content = "package test;\n"
				+ "import b400767.ETest;\n"
				+ "public class Bug {\n"
				+ "	Bug() {\n"
				+ "		doSomethingUsingOtherPackage();\n"
				+ "	}\n"
				+ "	public void addComponentListener(ComponentListener listener) {}\n"
				+ "	private void doSomethingUsingOtherPackage() {\n"
				+ "		for (ETest val : ETest.values()) {\n"
				+ "			System.out.println(val.name());\n"
				+ "		}\n"
				+ "		Bug bug = new Bug();\n"
				+ "		bug.addComponentListener(new ComponentAdapter() {\n"
				+ "			/**\n"
				+ "			 * @see ComponentAdapter#componentShown(ComponentEvent)\n"
				+ "			 */\n"
				+ "			@Override\n"
				+ "			public void componentShown(ComponentEvent e) {\n"
				+ "				super.componentShown(e);\n"
				+ "			}\n"
				+ "		});\n"
				+ "	}\n"
				+ "}\n"
				+ "interface ComponentListener {\n"
				+ "    public void componentShown(ComponentEvent e);\n"
				+ "}\n"
				+ "class ComponentAdapter implements ComponentListener {\n"
				+ "	public void componentShown(ComponentEvent e) { }\n"
				+ "}\n"
				+ "class ComponentEvent {}";
		this.wcOwner = new WorkingCopyOwner() {};
		this.workingCopies = new ICompilationUnit[3];
		this.workingCopies[2] =  getWorkingCopy("/Tests/test/ETest.java", content);
		content = "/**\n "
				+ "* This package is used by another package and will cause an error.\n"
				+ " */\n"
				+ "package b400767;";
		// package-info is physically required at some point. Just put it to move forward.
		createFolder("/Tests/b400767");
		createFile("/Tests/b400767/package-info.java", content);
		this.workingCopies[0] = getWorkingCopy("/Tests/b400767/package-info.java", content);
		content = "package b400767;\n"
				+ "public enum ETest {\n"
				+ "	VAL1, VAL2, VAL3;\n"
				+ "}";
		this.workingCopies[1] = getWorkingCopy("/Tests/b400767/ETest.java", content);
		final IJavaElement[] selection = new IJavaElement[1];
		final ICompilationUnit[] copy = this.workingCopies;
		Thread t = new Thread(new Runnable() {
			public void run() {
				try {
					selection[0] = selectMethod(copy[2], "componentShown");
				} catch (JavaModelException e) {
					e.printStackTrace();
					fail("Shouldn't be an exception");
				}
			}
		});
		t.start();
		try {
			Thread.sleep(500);
		} catch (InterruptedException e) {
		}
		if (t.isAlive()) {
			fail("Thread shouldn't still be running");
		}
		assertElementEquals("Should return a valid element", 
							"componentShown(ComponentEvent) [in ComponentAdapter [in [Working copy] ETest.java [in test [in <project root> [in Tests]]]]]", selection[0]);
	}
}