/*******************************************************************************
 * Copyright (c) 2000, 2003 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials 
 * are made available under the terms of the Common Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/cpl-v10.html
 * 
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/
package org.eclipse.jdt.core.tests.model;

import java.io.File;
import java.io.IOException;
import java.util.Hashtable;

import org.eclipse.jdt.internal.core.JavaModelStatus;
import org.eclipse.core.resources.*;
import org.eclipse.core.resources.IFile;
import org.eclipse.core.resources.IResource;
import org.eclipse.core.resources.IWorkspace;
import org.eclipse.core.resources.ResourcesPlugin;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IPath;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.Path;

import org.eclipse.jdt.core.*;
import org.eclipse.jdt.core.ICompilationUnit;
import org.eclipse.jdt.core.search.*;
import org.eclipse.jdt.core.compiler.CharOperation;

import junit.framework.*;

/**
 * Tests the Java search engine where results are JavaElements and source positions.
 */
public class JavaSearchTests extends AbstractJavaModelTests implements IJavaSearchConstants {

/**
 * Collects results as a string.
 */
public static class JavaSearchResultCollector implements IJavaSearchResultCollector {
	public StringBuffer results = new StringBuffer();
	public boolean showAccuracy = false;
	public boolean showProject = false;
	public void aboutToStart() {
	}
	public void accept(IResource resource, int start, int end, IJavaElement element, int accuracy) {
		try {
			if (results.length() > 0) results.append("\n");
			IPath path = resource.getProjectRelativePath();
			if (path.segmentCount() == 0) {
				IJavaElement root = element;
				while (root != null && !(root instanceof IPackageFragmentRoot)) {
					root = root.getParent();
				}
				if (root != null) {
					IPackageFragmentRoot pkgFragmentRoot = (IPackageFragmentRoot)root;
					if (pkgFragmentRoot.isExternal()) {
						results.append(pkgFragmentRoot.getPath().toOSString());
					} else {
						results.append(pkgFragmentRoot.getPath());
					}
				}
			} else {
				results.append(path);
			}
			if (showProject) {
				IProject project = element.getJavaProject().getProject();
				results.append(" [in ");
				results.append(project.getName());
				results.append("]");
			}
			ICompilationUnit unit = null;
			if (element instanceof IMethod) {
				results.append(" ");
				IMethod method = (IMethod)element;
				results.append(method.getDeclaringType().getFullyQualifiedName());
				if (!method.isConstructor()) {
					results.append(".");
					results.append(method.getElementName());
				}
				results.append("(");
				String[] parameters = method.getParameterTypes();			
				for (int i = 0; i < parameters.length; i++) {
					results.append(Signature.toString(parameters[i]));
					if (i < parameters.length-1) {
						results.append(", ");
					}
				}
				results.append(")");
				if (!method.isConstructor()) {
					results.append(" -> ");
					results.append(Signature.toString(method.getReturnType()));
				}
				unit = method.getCompilationUnit();
			} else if (element instanceof IType) {
				results.append(" ");
				IType type = (IType)element;
				results.append(type.getFullyQualifiedName());
				unit = type.getCompilationUnit();
			} else if (element instanceof IField) {
				results.append(" ");
				IField field = (IField)element;
				results.append(field.getDeclaringType().getFullyQualifiedName());
				results.append(".");
				results.append(field.getElementName());
				unit = field.getCompilationUnit();
			} else if (element instanceof IInitializer) {
				results.append(" ");
				IInitializer initializer = (IInitializer)element;
				results.append(initializer.getDeclaringType().getFullyQualifiedName());
				results.append(".");
				if (Flags.isStatic(initializer.getFlags())) {
					results.append("static ");
				}
				results.append("{}");
				unit = initializer.getCompilationUnit();
			} else if (element instanceof IPackageFragment) {
				results.append(" ");
				results.append(element.getElementName());
			}
			if (resource instanceof IFile) {
				char[] contents = null;
				if ("java".equals(resource.getFileExtension())) {
					if (!resource.equals(element.getUnderlyingResource())) {
						// working copy
						contents = unit.getBuffer().getCharacters();
					} else {
						contents = new org.eclipse.jdt.internal.compiler.batch.CompilationUnit(
							null, 
							((IFile) resource).getLocation().toFile().getPath(),
							null).getContents();
					}
				}
				if (start == -1 || contents != null) { // retrieving attached source not implemented here
					results.append(" [");
					if (start > -1) {
						results.append(CharOperation.subarray(contents, start, end));
					} else {
						results.append("No source");
					}
					results.append("]");
				}
			}
			if (showAccuracy) {
				results.append(" ");
				switch (accuracy) {
					case EXACT_MATCH:
						results.append("EXACT_MATCH");
						break;
					case POTENTIAL_MATCH:
						results.append("POTENTIAL_MATCH");
						break;
				}
			}
		} catch (JavaModelException e) {
			results.append("\n");
			results.append(e.toString());
		}
	}
	public void done() {
	}
	public IProgressMonitor getProgressMonitor() {
		return null;
	}
	public String toString() {
		return results.toString();
	}
}
public JavaSearchTests(String name) {
	super(name);
}
private IJavaSearchScope getJavaSearchScope() {
	return SearchEngine.createJavaSearchScope(new IJavaProject[] {getJavaProject("JavaSearch")});
}
public void setUpSuite() throws Exception {
	super.setUpSuite();
	
	setUpJavaProject("JavaSearch");
}
public void tearDownSuite() throws Exception {
	deleteProject("JavaSearch");
	
	super.tearDownSuite();
}


public static Test suite() {
	TestSuite suite = new Suite(JavaSearchTests.class.getName());
	
	if (false) {
		suite.addTest(new JavaSearchTests("testTypeOccurence2"));
		return suite;
	}
	
	// package declaration
	suite.addTest(new JavaSearchTests("testSimplePackageDeclaration"));
	suite.addTest(new JavaSearchTests("testVariousPackageDeclarations"));
	
	// package reference
	suite.addTest(new JavaSearchTests("testSimplePackageReference"));
	suite.addTest(new JavaSearchTests("testPackageReference1"));
	suite.addTest(new JavaSearchTests("testPackageReference2"));
	suite.addTest(new JavaSearchTests("testVariousPackageReference"));
	suite.addTest(new JavaSearchTests("testAccuratePackageReference"));
	suite.addTest(new JavaSearchTests("testPatternMatchPackageReference"));

	// type declaration
	suite.addTest(new JavaSearchTests("testSimpleTypeDeclaration"));
	suite.addTest(new JavaSearchTests("testTypeDeclaration"));
	suite.addTest(new JavaSearchTests("testTypeDeclarationInJar"));
	suite.addTest(new JavaSearchTests("testTypeDeclarationInJar2"));
	suite.addTest(new JavaSearchTests("testTypeDeclarationInPackageScope"));
	suite.addTest(new JavaSearchTests("testTypeDeclarationInPackageScope2"));
	suite.addTest(new JavaSearchTests("testMemberTypeDeclaration"));
	suite.addTest(new JavaSearchTests("testPatternMatchTypeDeclaration"));
	suite.addTest(new JavaSearchTests("testLongDeclaration"));
	
	// type reference
	suite.addTest(new JavaSearchTests("testSimpleTypeReference"));
	suite.addTest(new JavaSearchTests("testTypeReference1"));
	suite.addTest(new JavaSearchTests("testTypeReference2"));
	suite.addTest(new JavaSearchTests("testTypeReference3"));
	suite.addTest(new JavaSearchTests("testTypeReference4"));
	suite.addTest(new JavaSearchTests("testTypeReferenceInInitializer"));
	suite.addTest(new JavaSearchTests("testTypeReferenceAsSingleNameReference"));
	suite.addTest(new JavaSearchTests("testMemberTypeReference"));
	suite.addTest(new JavaSearchTests("testMemberTypeReference2"));
	suite.addTest(new JavaSearchTests("testObjectMemberTypeReference"));
	suite.addTest(new JavaSearchTests("testTypeReferenceInQualifiedNameReference"));
	suite.addTest(new JavaSearchTests("testTypeReferenceInQualifiedNameReference2"));
	suite.addTest(new JavaSearchTests("testTypeReferenceInQualifiedNameReference3"));
	suite.addTest(new JavaSearchTests("testTypeReferenceInQualifiedNameReference4"));
	suite.addTest(new JavaSearchTests("testTypeReferenceNotInClasspath"));
	suite.addTest(new JavaSearchTests("testVariousTypeReferences"));
	suite.addTest(new JavaSearchTests("testTypeReferenceInImport"));
	suite.addTest(new JavaSearchTests("testTypeReferenceInImport2"));
	suite.addTest(new JavaSearchTests("testTypeReferenceInArray"));
	suite.addTest(new JavaSearchTests("testTypeReferenceInArray2"));
	suite.addTest(new JavaSearchTests("testNegativeTypeReference"));
	suite.addTest(new JavaSearchTests("testTypeReferenceInThrows"));
	suite.addTest(new JavaSearchTests("testInnacurateTypeReference1"));
	suite.addTest(new JavaSearchTests("testInnacurateTypeReference2"));
	suite.addTest(new JavaSearchTests("testInnacurateTypeReference3"));
	suite.addTest(new JavaSearchTests("testTypeReferenceInCast"));
	suite.addTest(new JavaSearchTests("testPatternMatchTypeReference"));
	suite.addTest(new JavaSearchTests("testTypeReferenceNotCaseSensitive"));
	suite.addTest(new JavaSearchTests("testAccurateTypeReference"));
	suite.addTest(new JavaSearchTests("testTypeReferenceInHierarchy"));
	suite.addTest(new JavaSearchTests("testTypeReferenceWithRecovery"));
	
	// type occurences
	suite.addTest(new JavaSearchTests("testTypeOccurence"));
	suite.addTest(new JavaSearchTests("testTypeOccurence2"));
	suite.addTest(new JavaSearchTests("testTypeOccurenceWithDollar"));
	
	// interface implementor
	suite.addTest(new JavaSearchTests("testInterfaceImplementors"));
	suite.addTest(new JavaSearchTests("testInterfaceImplementors2"));
	
	// method declaration
	suite.addTest(new JavaSearchTests("testSimpleMethodDeclaration"));
	suite.addTest(new JavaSearchTests("testSimpleConstructorDeclaration"));
	suite.addTest(new JavaSearchTests("testInnerMethodDeclaration"));
	suite.addTest(new JavaSearchTests("testMethodDeclarationInHierarchyScope1"));
	suite.addTest(new JavaSearchTests("testMethodDeclarationInHierarchyScope2"));
	suite.addTest(new JavaSearchTests("testMethodDeclarationInHierarchyScope3"));
	suite.addTest(new JavaSearchTests("testMethodDeclarationInPackageScope"));
	suite.addTest(new JavaSearchTests("testMethodDeclarationInJar"));
	suite.addTest(new JavaSearchTests("testConstructorDeclarationInJar"));
	suite.addTest(new JavaSearchTests("testMethodDeclarationInInitializer"));
	
	// method reference
	suite.addTest(new JavaSearchTests("testSimpleMethodReference"));
	suite.addTest(new JavaSearchTests("testStaticMethodReference1"));
	suite.addTest(new JavaSearchTests("testStaticMethodReference2"));
	suite.addTest(new JavaSearchTests("testInnerMethodReference"));
	suite.addTest(new JavaSearchTests("testMethodReferenceThroughSuper"));
	suite.addTest(new JavaSearchTests("testMethodReferenceInInnerClass"));
	suite.addTest(new JavaSearchTests("testMethodReferenceInAnonymousClass"));
	suite.addTest(new JavaSearchTests("testMethodReferenceThroughArray"));
	suite.addTest(new JavaSearchTests("testMethodReference1"));
	suite.addTest(new JavaSearchTests("testMethodReference2"));
	suite.addTest(new JavaSearchTests("testMethodReference3"));
	suite.addTest(new JavaSearchTests("testMethodReference4"));
	
	// constructor reference
	suite.addTest(new JavaSearchTests("testSimpleConstructorReference1"));
	suite.addTest(new JavaSearchTests("testSimpleConstructorReference2"));
	suite.addTest(new JavaSearchTests("testConstructorReferenceExplicitConstructorCall1"));
	suite.addTest(new JavaSearchTests("testConstructorReferenceExplicitConstructorCall2"));
	suite.addTest(new JavaSearchTests("testConstructorReferenceImplicitConstructorCall1"));
	suite.addTest(new JavaSearchTests("testConstructorReferenceImplicitConstructorCall2"));
	suite.addTest(new JavaSearchTests("testConstructorReferenceInFieldInitializer"));

	// field declaration
	suite.addTest(new JavaSearchTests("testSimpleFieldDeclaration"));
	suite.addTest(new JavaSearchTests("testFieldDeclarationInJar"));
	suite.addTest(new JavaSearchTests("testFieldDeclarationArrayType"));
	suite.addTest(new JavaSearchTests("testFieldDeclarationWithWildCard"));

	// field reference
	suite.addTest(new JavaSearchTests("testSimpleFieldReference"));
	suite.addTest(new JavaSearchTests("testSimpleReadFieldReference"));
	suite.addTest(new JavaSearchTests("testSimpleWriteFieldReference"));
	suite.addTest(new JavaSearchTests("testMultipleFieldReference"));
	suite.addTest(new JavaSearchTests("testStaticFieldReference"));
	suite.addTest(new JavaSearchTests("testFieldReference"));
	suite.addTest(new JavaSearchTests("testFieldReference2"));
	suite.addTest(new JavaSearchTests("testFieldReference3"));
	suite.addTest(new JavaSearchTests("testFieldReference4"));
	suite.addTest(new JavaSearchTests("testFieldReference5"));
	suite.addTest(new JavaSearchTests("testFieldReference6"));
	suite.addTest(new JavaSearchTests("testFieldReferenceInInnerClass"));
	suite.addTest(new JavaSearchTests("testFieldReferenceInAnonymousClass"));
	suite.addTest(new JavaSearchTests("testFieldReferenceThroughSubclass"));
	suite.addTest(new JavaSearchTests("testReadWriteFieldReferenceInCompoundExpression"));
	suite.addTest(new JavaSearchTests("testReadWriteAccessInQualifiedNameReference"));
	suite.addTest(new JavaSearchTests("testFieldReferenceInBrackets"));
	suite.addTest(new JavaSearchTests("testAccurateFieldReference1"));
	
	// or pattern
	suite.addTest(new JavaSearchTests("testOrPattern"));
	
	// declarations of accessed fields
	suite.addTest(new JavaSearchTests("testDeclarationOfAccessedFields1"));
	suite.addTest(new JavaSearchTests("testDeclarationOfAccessedFields2"));
	suite.addTest(new JavaSearchTests("testDeclarationOfAccessedFields3"));

	// declarations of referenced types
	suite.addTest(new JavaSearchTests("testDeclarationOfReferencedTypes1"));
	suite.addTest(new JavaSearchTests("testDeclarationOfReferencedTypes2"));
	suite.addTest(new JavaSearchTests("testDeclarationOfReferencedTypes3"));
	suite.addTest(new JavaSearchTests("testDeclarationOfReferencedTypes4"));
	suite.addTest(new JavaSearchTests("testDeclarationOfReferencedTypes5"));
	suite.addTest(new JavaSearchTests("testDeclarationOfReferencedTypes6"));
	suite.addTest(new JavaSearchTests("testDeclarationOfReferencedTypes7"));
	
	// declarations of sent messages
	suite.addTest(new JavaSearchTests("testSimpleDeclarationsOfSentMessages"));
	suite.addTest(new JavaSearchTests("testDeclarationOfSentMessages"));
	
	// potential match in binary
	suite.addTest(new JavaSearchTests("testPotentialMatchInBinary"));

	// core exception
	suite.addTest(new JavaSearchTests("testCoreException"));
	
	// search scopes
	suite.addTest(new JavaSearchTests("testHierarchyScope"));
	suite.addTest(new JavaSearchTests("testSubCUSearchScope1"));
	suite.addTest(new JavaSearchTests("testSubCUSearchScope2"));
	suite.addTest(new JavaSearchTests("testSubCUSearchScope3"));
	suite.addTest(new JavaSearchTests("testExternalJarScope"));

	return suite;
}
/**
 * Type reference test.
 */
public void testAccurateFieldReference1() throws CoreException {
	JavaSearchResultCollector resultCollector = new JavaSearchResultCollector();
	new SearchEngine().search(
		getWorkspace(), 
		"d6.X.CONSTANT", 
		FIELD,
		REFERENCES, 
		SearchEngine.createJavaSearchScope(new IJavaElement[] {
			getPackageFragment("JavaSearch", "src", "d6")
		}), 
		resultCollector);
	assertEquals(
		"src/d6/Y.java d6.Y.T [CONSTANT]",
		resultCollector.toString());
}
/**
 * Regression test for 1GBK7B2: ITPJCORE:WINNT - package references: could be more precise
 */
public void testAccuratePackageReference() throws JavaModelException, CoreException {
	IPackageFragment pkg = getPackageFragment("JavaSearch", "src", "p3.p2");
	JavaSearchResultCollector resultCollector = new JavaSearchResultCollector();
	new SearchEngine().search(
		getWorkspace(), 
		pkg, 
		REFERENCES, 
		getJavaSearchScope(), 
		resultCollector);
	assertEquals(
		"src/PackageReference/K.java [p3.p2]", 
		resultCollector.toString());
}
/**
 * Type reference test.
 */
public void testAccurateTypeReference() throws CoreException {
	JavaSearchResultCollector resultCollector = new JavaSearchResultCollector();
	new SearchEngine().search(
		getWorkspace(), 
		"d5.X", 
		TYPE,
		REFERENCES, 
		SearchEngine.createJavaSearchScope(new IJavaElement[] {
			getPackageFragment("JavaSearch", "src", "d5")
		}), 
		resultCollector);
	assertEquals(
		"src/d5/Y.java d5.Y.T [d5.X]\n" +
		"src/d5/Y.java d5.Y.c [d5.X]\n" +
		"src/d5/Y.java d5.Y.o [d5.X]",
		resultCollector.toString());
}
/**
 * Constructor declaration in jar file test.
 */
public void testConstructorDeclarationInJar() throws JavaModelException, CoreException {
	IType type = getClassFile("JavaSearch", "MyJar.jar", "p1", "A.class").getType();
	IMethod method = type.getMethod("A", new String[] {"Ljava.lang.String;"});
	JavaSearchResultCollector resultCollector = new JavaSearchResultCollector();
	new SearchEngine().search(
		getWorkspace(), 
		method, 
		DECLARATIONS, 
		getJavaSearchScope(), 
		resultCollector);
	assertEquals(
		"MyJar.jar p1.A(java.lang.String) [No source]", 
		resultCollector.toString());
}
/**
 * Constructor reference using an explicit constructor call.
 */
public void testConstructorReferenceExplicitConstructorCall1() throws JavaModelException, CoreException {
	IType type = getCompilationUnit("JavaSearch", "src", "p", "Y.java").getType("Y");
	IMethod method = type.getMethod("Y", new String[] {"I"});
	JavaSearchResultCollector resultCollector = new JavaSearchResultCollector();
	new SearchEngine().search(
		getWorkspace(), 
		method, 
		REFERENCES, 
		getJavaSearchScope(), 
		resultCollector);
	assertEquals(
		"src/p/Z.java p.Z(int) [super(i)]", 
		resultCollector.toString());
}
/**
 * Constructor reference using an explicit constructor call.
 */
public void testConstructorReferenceExplicitConstructorCall2() throws JavaModelException, CoreException {
	IType type = getCompilationUnit("JavaSearch", "src", "p", "X.java").getType("X");
	IMethod method = type.getMethod("X", new String[] {"I"});
	JavaSearchResultCollector resultCollector = new JavaSearchResultCollector();
	new SearchEngine().search(
		getWorkspace(), 
		method, 
		REFERENCES, 
		getJavaSearchScope(), 
		resultCollector);
	assertEquals(
		"src/p/Y.java p.Y(int) [super(i)]\n" +
		"src/p/Y.java p.Y(boolean) [super(1)]", 
		resultCollector.toString());
}
/**
 * Constructor reference using an implicit constructor call.
 * (regression test for bug 23112 search: need a way to search for references to the implicit non-arg constructor)
 */
public void testConstructorReferenceImplicitConstructorCall1() throws JavaModelException, CoreException {
	IType type = getCompilationUnit("JavaSearch", "src", "c7", "X.java").getType("X");
	IMethod method = type.getMethod("X", new String[] {});
	JavaSearchResultCollector resultCollector = new JavaSearchResultCollector();
	new SearchEngine().search(
		getWorkspace(), 
		method, 
		REFERENCES, 
		getJavaSearchScope(), 
		resultCollector);
	assertEquals(
		"src/c7/Y.java c7.Y() [Y]", 
		resultCollector.toString());
}
/**
 * Constructor reference using an implicit constructor call.
 * (regression test for bug 23112 search: need a way to search for references to the implicit non-arg constructor)
 */
public void testConstructorReferenceImplicitConstructorCall2() throws JavaModelException, CoreException {
	JavaSearchResultCollector resultCollector = new JavaSearchResultCollector();
	new SearchEngine().search(
		getWorkspace(), 
		"c8.X()", 
		CONSTRUCTOR,
		REFERENCES, 
		getJavaSearchScope(), 
		resultCollector);
	assertEquals(
		"src/c8/Y.java c8.Y [Y]", 
		resultCollector.toString());
}
/**
 * Constructor reference in a field initializer.
 * (regression test for PR 1GKZ8VZ: ITPJCORE:WINNT - Search - did not find references to member constructor)
 */
public void testConstructorReferenceInFieldInitializer() throws JavaModelException, CoreException {
	IType type = getCompilationUnit("JavaSearch", "src", "", "A.java").getType("A").getType("Inner");
	IMethod method = type.getMethod("Inner", new String[] {"I"});
	JavaSearchResultCollector resultCollector = new JavaSearchResultCollector();
	new SearchEngine().search(
		getWorkspace(), 
		method, 
		REFERENCES, 
		getJavaSearchScope(), 
		resultCollector);
	assertEquals(
		"src/A.java A.field [new Inner(1)]\n" +
		"src/A.java A.field [new Inner(2)]", 
		resultCollector.toString());
}
/**
 * CoreException thrown during accept.
 * (regression test for PR #1G3UI7A)
 */
public void testCoreException() throws JavaModelException, CoreException {
	IType type = getCompilationUnit("JavaSearch", "src", "p", "X.java").getType("X");
	IJavaSearchResultCollector resultCollector = new IJavaSearchResultCollector() {
		public void accept(IResource resource, int start, int end, IJavaElement enclosingElement, int accuracy) throws CoreException {
			throw new CoreException(new JavaModelStatus(-1, "test"));
		}
		public void aboutToStart() {}
		public void done() {}
		public IProgressMonitor getProgressMonitor() {
			return null;
		}
	};
	try {
		new SearchEngine().search(
			getWorkspace(), 
			type, 
			DECLARATIONS, 
			getJavaSearchScope(), 
			resultCollector);
	} catch (JavaModelException e) {
		Throwable wrappedException = e.getException();
		assertTrue("Unexpected wrapped exception", wrappedException instanceof CoreException);
		assertEquals("Unexpected CoreException has been thrown", "test", ((CoreException)wrappedException).getStatus().getMessage());
		return;
	}
	assertTrue("CoreException should have been thrown", false);
}
/**
 * Declaration of accessed fields test.
 * (regression test for bug 6538 searchDeclarationsOf* incorrect)
 */
public void testDeclarationOfAccessedFields1() throws JavaModelException, CoreException {
	IMethod method = 
		getCompilationUnit("JavaSearch", "src", "a5", "B.java").
			getType("C").getMethod("i", new String[] {});
	JavaSearchResultCollector resultCollector = new JavaSearchResultCollector();
	new SearchEngine().searchDeclarationsOfAccessedFields(
		getWorkspace(), 
		method,
		resultCollector
	);
	assertEquals(
		"", 
		resultCollector.toString());
}
/**
 * Declaration of accessed fields test.
 * (regression test for bug 6538 searchDeclarationsOf* incorrect)
 */
public void testDeclarationOfAccessedFields2() throws JavaModelException, CoreException {
	IMethod method = 
		getCompilationUnit("JavaSearch", "src", "a6", "A.java").
			getType("B").getMethod("m", new String[] {});
	JavaSearchResultCollector resultCollector = new JavaSearchResultCollector();
	new SearchEngine().searchDeclarationsOfAccessedFields(
		getWorkspace(), 
		method,
		resultCollector
	);
	assertEquals(
		"src/a6/A.java a6.B.f [f]", 
		resultCollector.toString());
}
/**
 * Declaration of accessed fields test.
 * (regression test for bug 10386 NPE in MatchLocator.lookupType)
 */
public void testDeclarationOfAccessedFields3() throws JavaModelException, CoreException {
	IMethod method = 
		getCompilationUnit("JavaSearch", "src", "b6", "A.java").
			getType("A").getMethod("foo", new String[] {});
	JavaSearchResultCollector resultCollector = new JavaSearchResultCollector();
	new SearchEngine().searchDeclarationsOfAccessedFields(
		getWorkspace(), 
		method,
		resultCollector
	);
	assertEquals(
		"src/b6/A.java b6.A.field [field]", 
		resultCollector.toString());
}
/**
 * Declaration of referenced types test.
 */
public void testDeclarationOfReferencedTypes1() throws JavaModelException, CoreException {
	IMethod method = 
		getCompilationUnit("JavaSearch", "src", "a3", "References.java").
			getType("References").getMethod("foo", new String[] {});
	JavaSearchResultCollector resultCollector = new JavaSearchResultCollector();
	new SearchEngine().searchDeclarationsOfReferencedTypes(
		getWorkspace(), 
		method,
		resultCollector
	);
	assertEquals(
		"src/a3/X.java a3.X [X]\n" +
		"src/a3/Z.java a3.Z [Z]\n" +
		"src/a3/b/A.java a3.b.A [A]\n" +
		"src/a3/b/A.java a3.b.A$B$C [C]\n" +
		"src/a3/b/A.java a3.b.A$B [B]\n" +
		getExternalJCLPathString() + " java.lang.Object\n" +
		"src/a3/Y.java a3.Y [Y]\n" +
		"src/a3/b/B.java a3.b.B [B]", 
		resultCollector.toString());
}
/**
 * Declaration of referenced types test.
 * (Regression test for bug 6779 searchDeclarationsOfReferencedTyped - missing exception types)
 */
public void testDeclarationOfReferencedTypes2() throws CoreException {
	IMethod method = 
		getCompilationUnit("JavaSearch", "src", "a7", "X.java").
			getType("X").getMethod("foo", new String[] {});
	JavaSearchResultCollector resultCollector = new JavaSearchResultCollector();
	new SearchEngine().searchDeclarationsOfReferencedTypes(
		getWorkspace(), 
		method,
		resultCollector
	);
	assertEquals(
		"src/a7/X.java a7.MyException [MyException]", 
		resultCollector.toString());
}
/**
 * Declaration of referenced types test.
 * (Regression test for bug 12649 Missing import after move  )
 */
public void testDeclarationOfReferencedTypes3() throws CoreException {
	ICompilationUnit unit = getCompilationUnit("JavaSearch", "src", "c1", "A.java");
	JavaSearchResultCollector resultCollector = new JavaSearchResultCollector();
	new SearchEngine().searchDeclarationsOfReferencedTypes(
		getWorkspace(), 
		unit,
		resultCollector
	);
	assertEquals(
		"src/c1/I.java c1.I [I]", 
		resultCollector.toString());
}
/**
 * Declaration of referenced types test.
 * (Regression test for bug 12649 Missing import after move  )
 */
public void testDeclarationOfReferencedTypes4() throws CoreException {
	ICompilationUnit unit = getCompilationUnit("JavaSearch", "src", "c1", "B.java");
	JavaSearchResultCollector resultCollector = new JavaSearchResultCollector();
	new SearchEngine().searchDeclarationsOfReferencedTypes(
		getWorkspace(), 
		unit,
		resultCollector
	);
	assertEquals(
		"src/c1/I.java c1.I [I]", 
		resultCollector.toString());
}
/**
 * Declaration of referenced types test.
 * (Regression test for bug 18418 search: searchDeclarationsOfReferencedTypes reports import declarations)
 */
public void testDeclarationOfReferencedTypes5() throws CoreException {
	ICompilationUnit unit = getCompilationUnit("JavaSearch", "src", "c2", "A.java");
	JavaSearchResultCollector resultCollector = new JavaSearchResultCollector();
	new SearchEngine().searchDeclarationsOfReferencedTypes(
		getWorkspace(), 
		unit,
		resultCollector
	);
	assertEquals(
		"src/c3/C.java c3.C [C]", 
		resultCollector.toString());
}
/**
 * Declaration of referenced types test.
 * (Regression test for bug 24934 Move top level doesn't optimize the imports[refactoring])
 */
public void testDeclarationOfReferencedTypes6() throws CoreException {
	ICompilationUnit unit = getCompilationUnit("JavaSearch", "src", "d1", "X.java");
	IType innerType = unit.getType("X").getType("Inner");
	JavaSearchResultCollector resultCollector = new JavaSearchResultCollector();
	new SearchEngine().searchDeclarationsOfReferencedTypes(
		getWorkspace(), 
		innerType,
		resultCollector
	);
	assertEquals(
		"src/d2/Y.java d2.Y [Y]", 
		resultCollector.toString());
}
/**
 * Declaration of referenced types test.
 * (Regression test for bug 37438 searchenging NPE in searchDeclarationsOfReferencedTypes 
)
 */
public void testDeclarationOfReferencedTypes7() throws CoreException {
	IPackageFragment pkg = getPackageFragment("JavaSearch", "src", "r7");
	JavaSearchResultCollector resultCollector = new JavaSearchResultCollector();
	new SearchEngine().searchDeclarationsOfReferencedTypes(
		getWorkspace(), 
		pkg,
		resultCollector
	);
	assertEquals(
		"", 
		resultCollector.toString());
}

/**
 * Declaration of sent messages test.
 * (regression test for bug 6538 searchDeclarationsOf* incorrect)
 */
public void testDeclarationOfSentMessages() throws JavaModelException, CoreException {
	IMethod method = 
		getCompilationUnit("JavaSearch", "src", "a5", "B.java").
			getType("C").getMethod("i", new String[] {});
	JavaSearchResultCollector resultCollector = new JavaSearchResultCollector();
	new SearchEngine().searchDeclarationsOfSentMessages(
		getWorkspace(), 
		method,
		resultCollector
	);
	assertEquals(
		"", 
		resultCollector.toString());
}
/**
 * Java search scope on java element in external jar test.
 */
public void testExternalJarScope() throws CoreException, IOException {
	IWorkspace workspace = ResourcesPlugin.getWorkspace();
	File workspaceLocation = new File(workspace.getRoot().getLocation().toOSString());
	File minimalJar = new File(workspaceLocation, "JavaSearch/MyJar.jar");
	File externalJar = new File(workspaceLocation.getParentFile(), "MyJar.jar");
	IJavaProject project = this.getJavaProject("JavaSearch");
	IClasspathEntry[] classpath = project.getRawClasspath();
	try {
		copy(minimalJar, externalJar);
		int length = classpath.length;
		IClasspathEntry[] newClasspath = new IClasspathEntry[length];
		System.arraycopy(classpath, 0, newClasspath, 0, length-1);
		String externalPath = externalJar.getAbsolutePath();
		newClasspath[length-1] = JavaCore.newLibraryEntry(new Path(externalPath), new Path(externalPath), null, false);
		project.setRawClasspath(newClasspath, null);
		
		IPackageFragment pkg = this.getPackageFragment("JavaSearch", externalPath, "p0");
		IJavaSearchScope scope = SearchEngine.createJavaSearchScope(new IJavaElement[] {pkg});
		JavaSearchResultCollector resultCollector = new JavaSearchResultCollector();
		new SearchEngine().search(
			workspace, 
			"X",
			TYPE,
			DECLARATIONS,
			scope,
			resultCollector);
		assertEquals(
			externalJar.getCanonicalPath()+ " p0.X",
			resultCollector.toString());
			
		IClassFile classFile = pkg.getClassFile("X.class");
		scope = SearchEngine.createJavaSearchScope(new IJavaElement[] {classFile});
		resultCollector = new JavaSearchResultCollector();
		new SearchEngine().search(
			workspace, 
			classFile.getType(),
			DECLARATIONS,
			scope,
			resultCollector);
		assertEquals(
			externalJar.getCanonicalPath()+ " p0.X",
			resultCollector.toString());
		
	} finally {
		externalJar.delete();
		project.setRawClasspath(classpath, null);
	}
	
}


/**
 * Field declaration with array type test.
 * (regression test for PR 1GKEG73: ITPJCORE:WIN2000 - search (136): missing field declaration)
 */
public void testFieldDeclarationArrayType() throws JavaModelException, CoreException {
	IType type = getCompilationUnit("JavaSearch", "src", "", "B.java").getType("B");
	IField field = type.getField("open");
	JavaSearchResultCollector resultCollector = new JavaSearchResultCollector();
	new SearchEngine().search(
		getWorkspace(), 
		field, 
		DECLARATIONS, 
		getJavaSearchScope(), 
		resultCollector);
	assertEquals(
		"src/B.java B.open [open]", 
		resultCollector.toString());
}
/**
 * Field declaration in jar file test.
 */
public void testFieldDeclarationInJar() throws JavaModelException, CoreException {
	IType type = getClassFile("JavaSearch", "MyJar.jar", "p1", "A.class").getType();
	IField field = type.getField("field");
	JavaSearchResultCollector resultCollector = new JavaSearchResultCollector();
	new SearchEngine().search(
		getWorkspace(), 
		field, 
		DECLARATIONS, 
		getJavaSearchScope(), 
		resultCollector);
	assertEquals(
		"MyJar.jar p1.A.field [No source]", 
		resultCollector.toString());
}
/**
 * Field declaration with wild card test.
 * (regression test for bug 21763 Problem in Java search [search]  )
 */
public void testFieldDeclarationWithWildCard() throws JavaModelException, CoreException {
	JavaSearchResultCollector resultCollector = new JavaSearchResultCollector();
	new SearchEngine().search(
		getWorkspace(), 
		"class*path",
		FIELD,
		DECLARATIONS, 
		getJavaSearchScope(), 
		resultCollector);
	assertEquals(
		"src/c5/Test.java c5.Test.class_path [class_path]", 
		resultCollector.toString());
}
/**
 * Multiple field references in one ast test.
 * (regression test for PR 1GD79XM: ITPJCORE:WINNT - Search - search for field references - not all found)
 */
public void testMultipleFieldReference() throws JavaModelException, CoreException {
	IType type = getCompilationUnit("JavaSearch", "src", "p5", "A.java").getType("A");
	IField field = type.getField("x");
	JavaSearchResultCollector resultCollector = new JavaSearchResultCollector();
	new SearchEngine().search(
		getWorkspace(), 
		field, 
		REFERENCES, 
		getJavaSearchScope(), 
		resultCollector);
	assertEquals(
		"src/p5/A.java p5.A.k() -> void [x]\n" +
		"src/p5/A.java p5.A.k() -> void [x]\n" +
		"src/p5/A.java p5.A.k() -> void [x]", 
		resultCollector.toString());
}
/**
 * Field reference in inner class test.
 * (regression test for PR 1GL11J6: ITPJCORE:WIN2000 - search: missing field references (nested types))
 */
public void testFieldReferenceInInnerClass() throws JavaModelException, CoreException {
	IType type = getCompilationUnit("JavaSearch", "src", "", "O.java").getType("O");
	IField field = type.getField("y");
	JavaSearchResultCollector resultCollector = new JavaSearchResultCollector();
	new SearchEngine().search(
		getWorkspace(), 
		field, 
		REFERENCES, 
		getJavaSearchScope(), 
		resultCollector);
	assertEquals(
		"src/O.java O$I.y() -> void [y]", 
		resultCollector.toString());
}
/**
 * Field reference test.
 * (regression test for bug #3433 search: missing field occurrecnces (1GKZ8J6))
 */
public void testFieldReference() throws JavaModelException, CoreException {
	IType type = getCompilationUnit("JavaSearch", "src", "p8", "A.java").getType("A");
	IField field = type.getField("g");
	JavaSearchResultCollector resultCollector = new JavaSearchResultCollector();
	new SearchEngine().search(
		getWorkspace(), 
		field, 
		REFERENCES, 
		getJavaSearchScope(), 
		resultCollector);
	assertEquals(
		"src/p8/A.java p8.A.m() -> void [g]\n" +
		"src/p8/A.java p8.B.m() -> void [g]", 
		resultCollector.toString());
}
/**
 * Field reference test.
 * (regression test for PR 1GK8TXE: ITPJCORE:WIN2000 - search: missing field reference)
 */
public void testFieldReference2() throws JavaModelException, CoreException {
	IType type = getCompilationUnit("JavaSearch", "src", "p9", "X.java").getType("X");
	IField field = type.getField("f");
	JavaSearchResultCollector resultCollector = new JavaSearchResultCollector();
	new SearchEngine().search(
		getWorkspace(), 
		field, 
		REFERENCES, 
		getJavaSearchScope(), 
		resultCollector);
	assertEquals(
		"src/p9/X.java p9.X.m() -> void [f]", 
		resultCollector.toString());
}
/**
 * Field reference test.
 * (regression test for bug 5821 Refactor > Rename renames local variable instead of member in case of name clash  )
 */
public void testFieldReference3() throws JavaModelException, CoreException {
	IType type = getCompilationUnit("JavaSearch", "src", "q8", "EclipseTest.java").getType("EclipseTest");
	IField field = type.getField("test");
	JavaSearchResultCollector resultCollector = new JavaSearchResultCollector();
	new SearchEngine().search(
		getWorkspace(), 
		field, 
		REFERENCES, 
		getJavaSearchScope(), 
		resultCollector);
	assertEquals(
		"src/q8/EclipseTest.java q8.EclipseTest.main(String[]) -> void [test]", 
		resultCollector.toString());
}
/**
 * Field reference test.
 * (regression test for bug 5923 Search for "length" field refs finds [].length)
 */
public void testFieldReference4() throws JavaModelException, CoreException {
	IType type = getCompilationUnit("JavaSearch", "src", "a2", "X.java").getType("X");
	IField field = type.getField("length");
	JavaSearchResultCollector resultCollector = new JavaSearchResultCollector();
	new SearchEngine().search(
		getWorkspace(), 
		field, 
		REFERENCES, 
		getJavaSearchScope(), 
		resultCollector);
	assertEquals(
		"src/a2/X.java a2.X.foo() -> void [length]", 
		resultCollector.toString());
}
/**
 * Field reference test.
 * (regression test for bug 7987 Field reference search should do lookup in 1.4 mode)
 */
public void testFieldReference5() throws JavaModelException, CoreException {
	IType type = getCompilationUnit("JavaSearch", "src", "b1", "A.java").getType("A");
	IField field = type.getField("x");
	
	// Set 1.4 compliance level (no constant yet)
	Hashtable options = JavaCore.getOptions();
	String currentOption = (String)options.get("org.eclipse.jdt.core.compiler.compliance");
	options.put("org.eclipse.jdt.core.compiler.compliance", "1.4");
	JavaCore.setOptions(options);
	
	try {
		JavaSearchResultCollector resultCollector = new JavaSearchResultCollector();
		new SearchEngine().search(
			getWorkspace(), 
			field, 
			REFERENCES, 
			getJavaSearchScope(), 
			resultCollector);
		assertEquals(
			"src/b1/B.java b1.B.foo() -> void [x]", 
			resultCollector.toString());
	} finally {
		// Restore compliance level
		options.put("org.eclipse.jdt.core.compiler.compliance", currentOption);
		JavaCore.setOptions(options);
	}
}
/**
 * Field reference test.
 * (regression test for bug 20693 Finding references to variables does not find all occurances)
 */
public void testFieldReference6() throws JavaModelException, CoreException {
	IType type = getCompilationUnit("JavaSearch", "src", "c4", "X.java").getType("X");
	IField field = type.getField("x");
	
	JavaSearchResultCollector resultCollector = new JavaSearchResultCollector();
	new SearchEngine().search(
		getWorkspace(), 
		field, 
		REFERENCES, 
		getJavaSearchScope(), 
		resultCollector);
	assertEquals(
		"src/c4/X.java c4.X.foo() -> int [x]", 
		resultCollector.toString());
}
/**
 * Field reference in anonymous class test.
 * (regression test for PR 1GL12XE: ITPJCORE:WIN2000 - search: missing field references in inner class)
 */
public void testFieldReferenceInAnonymousClass() throws JavaModelException, CoreException {
	IType type = getCompilationUnit("JavaSearch", "src", "", "D.java").getType("D");
	IField field = type.getField("h");
	JavaSearchResultCollector resultCollector = new JavaSearchResultCollector();
	new SearchEngine().search(
		getWorkspace(), 
		field, 
		REFERENCES, 
		getJavaSearchScope(), 
		resultCollector);
	assertEquals(
		"src/D.java D.g() -> void [h]", 
		resultCollector.toString());
}
/**
 * Field reference in brackets test.
 * (regression test for bug 23329 search: incorrect range for type references in brackets)
 */
public void testFieldReferenceInBrackets() throws JavaModelException, CoreException {
	IType type = getCompilationUnit("JavaSearch", "src", "s3", "A.java").getType("A");
	IField field = type.getField("field");
	JavaSearchResultCollector resultCollector = new JavaSearchResultCollector();
	new SearchEngine().search(
		getWorkspace(), 
		field, 
		REFERENCES, 
		getJavaSearchScope(), 
		resultCollector);
	assertEquals(
		"src/s3/A.java s3.A.bar() -> int [field]",
		resultCollector.toString());
}
/**
 * Field reference through subclass test.
 * (regression test for PR 1GKB9YH: ITPJCORE:WIN2000 - search for field refs - incorrect results)
 */
public void testFieldReferenceThroughSubclass() throws JavaModelException, CoreException {
	IType type = getCompilationUnit("JavaSearch", "src", "p6", "A.java").getType("A");
	IField field = type.getField("f");
	JavaSearchResultCollector resultCollector = new JavaSearchResultCollector();
	new SearchEngine().search(
		getWorkspace(), 
		field, 
		REFERENCES, 
		getJavaSearchScope(), 
		resultCollector);
	assertEquals(
		"src/p6/A.java p6.A.m() -> void [f]\n" +
		"src/p6/A.java p6.B.m() -> void [f]\n" +
		"src/p6/A.java p6.B.m() -> void [f]", 
		resultCollector.toString());
		
	type = getCompilationUnit("JavaSearch", "src", "p6", "A.java").getType("AA");
	field = type.getField("f");
	resultCollector = new JavaSearchResultCollector();
	new SearchEngine().search(
		getWorkspace(), 
		field, 
		REFERENCES, 
		getJavaSearchScope(), 
		resultCollector);
	assertEquals(
		"src/p6/A.java p6.B.m() -> void [f]", 
		resultCollector.toString());
		
}
/**
 * Hierarchy scope test.
 * (regression test for bug 3445 search: type hierarchy scope incorrect (1GLC8VS))
 */
public void testHierarchyScope() throws JavaModelException, CoreException {
	ICompilationUnit cu = this. getCompilationUnit("JavaSearch", "src", "a9", "A.java");
	IType type = cu.getType("C");
	IJavaSearchScope scope = SearchEngine.createHierarchyScope(type);
	assertTrue("a9.C should be included in hierarchy scope", scope.encloses(type));
	assertTrue("a9.A should be included in hierarchy scope", scope.encloses(cu.getType("A")));
	assertTrue("a9.B should be included in hierarchy scope", scope.encloses(cu.getType("B")));
	assertTrue("a9/A.java should be included in hierarchy scope", scope.encloses(cu.getUnderlyingResource().getFullPath().toString()));
}
/**
 * Type reference test.
 * (Regression test for bug 9642 Search - missing inaccurate type matches)
 */
public void testInnacurateTypeReference1() throws JavaModelException, CoreException {
	JavaSearchResultCollector resultCollector = new JavaSearchResultCollector();
	new SearchEngine().search(
		getWorkspace(), 
		"Zork", 
		TYPE,
		REFERENCES, 
		SearchEngine.createJavaSearchScope(new IJavaElement[] {
			getPackageFragment("JavaSearch", "src", "b5")
		}), 
		resultCollector);
	assertEquals(
		"src/b5/A.java [Zork]\n" +
		"src/b5/A.java b5.A.{} [Zork]\n" +
		"src/b5/A.java b5.A.{} [Zork]\n" +
		"src/b5/A.java b5.A.{} [Zork]",
		resultCollector.toString());
}
/**
 * Type reference test.
 * (Regression test for bug 9642 Search - missing inaccurate type matches)
 */
public void testInnacurateTypeReference2() throws JavaModelException, CoreException {
	JavaSearchResultCollector resultCollector = new JavaSearchResultCollector();
	new SearchEngine().search(
		getWorkspace(), 
		"p.Zork", 
		TYPE,
		REFERENCES, 
		SearchEngine.createJavaSearchScope(new IJavaElement[] {
			getPackageFragment("JavaSearch", "src", "b5")
		}), 
		resultCollector);
	assertEquals(
		"src/b5/A.java b5.A.{} [Zork]\n" +
		"src/b5/A.java b5.A.{} [Zork]\n" +
		"src/b5/A.java b5.A.{} [Zork]",
		resultCollector.toString());
}
/**
 * Type reference test.
 * (Regression test for bug 21485  NPE when doing a reference search to a package)
 */
public void testInnacurateTypeReference3() throws CoreException {
	IType type = getCompilationUnit("JavaSearch", "src", "r3", "A21485.java").getType("A21485");
	JavaSearchResultCollector resultCollector = new JavaSearchResultCollector();
	resultCollector.showAccuracy = true;
	new SearchEngine().search(
		getWorkspace(), 
		type, 
		REFERENCES, 
		getJavaSearchScope(), 
		resultCollector);
	assertEquals(
		"src/r4/B21485.java [A21485] POTENTIAL_MATCH\n" +
		"src/r4/B21485.java r4.B21485 [A21485] POTENTIAL_MATCH",
		resultCollector.toString());
}


/**
 * Inner method declaration test.
 */
public void testInnerMethodDeclaration() throws JavaModelException, CoreException {
	IType type = getCompilationUnit("JavaSearch", "src", "p", "X.java").getType("X").getType("Inner");
	IMethod method = type.getMethod("foo", new String[] {});
	JavaSearchResultCollector resultCollector = new JavaSearchResultCollector();
	new SearchEngine().search(
		getWorkspace(), 
		method, 
		DECLARATIONS, 
		getJavaSearchScope(),  
		resultCollector);
	assertEquals(
		"src/p/X.java p.X$Inner.foo() -> String [foo]", 
		resultCollector.toString());
}
/**
 * Inner method reference test.
 */
public void testInnerMethodReference() throws JavaModelException, CoreException {
	IType type = getCompilationUnit("JavaSearch", "src", "p", "X.java").getType("X").getType("Inner");
	IMethod method = type.getMethod("foo", new String[] {});
	JavaSearchResultCollector resultCollector = new JavaSearchResultCollector();
	new SearchEngine().search(
		getWorkspace(), 
		method, 
		REFERENCES, 
		getJavaSearchScope(),  
		resultCollector);
	assertEquals(
		"src/p/A.java p.A.foo(int, String, X) -> void [foo()]", 
		resultCollector.toString());
}
/**
 * Interface implementors test.
 */
public void testInterfaceImplementors() throws JavaModelException, CoreException {
	// implementors of an interface
	IType type = getCompilationUnit("JavaSearch", "src", "p", "I.java").getType("I");
	JavaSearchResultCollector resultCollector = new JavaSearchResultCollector();
	new SearchEngine().search(
		getWorkspace(), 
		type, 
		IMPLEMENTORS, 
		getJavaSearchScope(),  
		resultCollector);
	assertEquals(
		"src/InterfaceImplementors.java InterfaceImplementors [p.I]\n" +
		"src/p/X.java p.X [I]", 
		resultCollector.toString());

	// implementors of a class should give no match
	// (regression test for 1G5HBQA: ITPJUI:WINNT - Search - search for implementors of a class finds subclasses)
	type = getCompilationUnit("JavaSearch", "src", "p", "X.java").getType("X");
	resultCollector = new JavaSearchResultCollector();
	new SearchEngine().search(
		getWorkspace(), 
		type, 
		IMPLEMENTORS, 
		getJavaSearchScope(),  
		resultCollector);
	assertEquals(
		"", 
		resultCollector.toString());	
}
/**
 * Interface implementors test.
 * (regression test for bug 22102 Not all implementors found for IPartListener)
 */
public void testInterfaceImplementors2() throws JavaModelException, CoreException {
	// implementors of an interface
	IType type = getCompilationUnit("JavaSearch", "src", "r2", "I.java").getType("I");
	JavaSearchResultCollector resultCollector = new JavaSearchResultCollector();
	new SearchEngine().search(
		getWorkspace(), 
		type, 
		IMPLEMENTORS, 
		getJavaSearchScope(),  
		resultCollector);
	assertEquals(
		"src/r2/X.java r2.X.field [I]", 
		resultCollector.toString());
}
/**
 * Long declaration (>255) test.
 * (regression test for bug 25859 Error doing Java Search)
 */
public void testLongDeclaration() throws JavaModelException, CoreException {
	JavaSearchResultCollector resultCollector = new JavaSearchResultCollector();
	new SearchEngine().search(
		getWorkspace(), 
		"AbcdefghijklmnopqrstuvwxyzAbcdefghijklmnopqrstuvwxyzAbcdefghijklmnopqrstuvwxyzAbcdefghijklmnopqrstuvwxyzAbcdefghijklmnopqrstuvwxyzAbcdefghijklmnopqrstuvwxyzAbcdefghijklmnopqrstuvwxyzAbcdefghijklmnopqrstuvwxyzAbcdefghijklmnopqrstuvwxyzAbcdefghijklmnopqrstuvwxyzAbcdefghijklmnopqrstuvwxyz", 
		TYPE,
		DECLARATIONS, 
		getJavaSearchScope(),  
		resultCollector);
	assertEquals(
		"src/c9/X.java c9.AbcdefghijklmnopqrstuvwxyzAbcdefghijklmnopqrstuvwxyzAbcdefghijklmnopqrstuvwxyzAbcdefghijklmnopqrstuvwxyzAbcdefghijklmnopqrstuvwxyzAbcdefghijklmnopqrstuvwxyzAbcdefghijklmnopqrstuvwxyzAbcdefghijklmnopqrstuvwxyzAbcdefghijklmnopqrstuvwxyzAbcdefghijklmnopqrstuvwxyzAbcdefghijklmnopqrstuvwxyz [AbcdefghijklmnopqrstuvwxyzAbcdefghijklmnopqrstuvwxyzAbcdefghijklmnopqrstuvwxyzAbcdefghijklmnopqrstuvwxyzAbcdefghijklmnopqrstuvwxyzAbcdefghijklmnopqrstuvwxyzAbcdefghijklmnopqrstuvwxyzAbcdefghijklmnopqrstuvwxyzAbcdefghijklmnopqrstuvwxyzAbcdefghijklmnopqrstuvwxyzAbcdefghijklmnopqrstuvwxyz]", 
		resultCollector.toString());
}
/**
 * Memeber type declaration test.
 * (regression test for bug 9992 Member class declaration not found)
 */
public void testMemberTypeDeclaration() throws JavaModelException, CoreException {
	IJavaSearchScope scope = SearchEngine.createJavaSearchScope(new IJavaElement[]{
		this.getPackageFragment("JavaSearch", "src", "b4")
	});
	JavaSearchResultCollector resultCollector = new JavaSearchResultCollector();
	new SearchEngine().search(
		getWorkspace(), 
		"*.A.B",
		TYPE,
		DECLARATIONS, 
		scope, 
		resultCollector);
	assertEquals(
		"src/b4/A.java b4.A$B [B]", 
		resultCollector.toString());
}
/**
 * Member type reference test.
 */
public void testMemberTypeReference() throws JavaModelException, CoreException {
	// references to second level member type
	JavaSearchResultCollector resultCollector = new JavaSearchResultCollector();
	resultCollector.showAccuracy = true;
	new SearchEngine().search(
		getWorkspace(), 
		"BMember",
		TYPE,
		REFERENCES, 
		getJavaSearchScope(), 
		resultCollector);
	assertEquals(
		"References to type BMember",
		"src/MemberTypeReference/Azz.java MemberTypeReference.Azz.poo() -> void [B.BMember] EXACT_MATCH\n" +
		"src/MemberTypeReference/Azz.java MemberTypeReference.Azz$AzzMember [BMember] EXACT_MATCH\n" +
		"src/MemberTypeReference/Azz.java MemberTypeReference.X.val [Azz.AzzMember.BMember] EXACT_MATCH\n" +
		"src/MemberTypeReference/B.java MemberTypeReference.B.foo() -> void [Azz.AzzMember.BMember] EXACT_MATCH",
		resultCollector.toString());

	// references to first level member type
	resultCollector = new JavaSearchResultCollector();
	resultCollector.showAccuracy = true;
	new SearchEngine().search(
		getWorkspace(), 
		"AzzMember",
		TYPE,
		REFERENCES, 
		getJavaSearchScope(), 
		resultCollector);
	assertEquals(
		"References to type AzzMember",
		"src/MemberTypeReference/Azz.java MemberTypeReference.X.val [Azz.AzzMember] EXACT_MATCH\n" +
		"src/MemberTypeReference/B.java MemberTypeReference.B.foo() -> void [Azz.AzzMember] EXACT_MATCH",
		resultCollector.toString());

	// no reference to a field with same name as member type
	resultCollector = new JavaSearchResultCollector();
	resultCollector.showAccuracy = true;
	new SearchEngine().search(
		getWorkspace(), 
		"BMember",
		FIELD,
		REFERENCES, 
		getJavaSearchScope(), 
		resultCollector);
	assertEquals(
		"References to field BMember",
		"",
		resultCollector.toString());
}
/**
 * Member type reference test.
 * (regression test for PR 1GL0MN9: ITPJCORE:WIN2000 - search: not consistent results for nested types)
 */
public void testMemberTypeReference2() throws JavaModelException, CoreException {
	IType type = getCompilationUnit("JavaSearch", "src", "a", "A.java").getType("A").getType("X");
	JavaSearchResultCollector resultCollector = new JavaSearchResultCollector();
	new SearchEngine().search(
		getWorkspace(), 
		type, 
		REFERENCES, 
		getJavaSearchScope(), 
		resultCollector);
	assertEquals(
		"src/a/A.java a.B.ax [A.X]\n" +
		"src/a/A.java a.B.sx [S.X]", 
		resultCollector.toString());
}
/**
 * Method declaration in hierarchy test.
 */
public void testMethodDeclarationInHierarchyScope1() throws JavaModelException, CoreException {
	IType type = getCompilationUnit("JavaSearch", "src", "p", "X.java").getType("X");
	JavaSearchResultCollector resultCollector = new JavaSearchResultCollector();
	new SearchEngine().search(
		getWorkspace(), 
		"foo",
		METHOD,
		DECLARATIONS, 
		SearchEngine.createHierarchyScope(type), 
		resultCollector);
	assertEquals(
		"src/p/X.java p.X.foo(int, String, X) -> void [foo]\n" +
		"src/p/Z.java p.Z.foo(int, String, X) -> void [foo]", 
		resultCollector.toString());
}
/**
 * Method declaration in hierarchy that contains elements in external jar.
 * (regression test for PR #1G2E4F1)
 */
public void testMethodDeclarationInHierarchyScope2() throws JavaModelException, CoreException {
	IType type = getCompilationUnit("JavaSearch", "src", "p", "X.java").getType("X");
	IMethod method = type.getMethod("foo", new String[] {"I", "QString;", "QX;"});
	JavaSearchResultCollector resultCollector = new JavaSearchResultCollector();
	new SearchEngine().search(
		getWorkspace(), 
		method,
		DECLARATIONS, 
		SearchEngine.createHierarchyScope(type), // java.lang.Object is in external jcl
		resultCollector);
	assertEquals(
		"src/p/X.java p.X.foo(int, String, X) -> void [foo]\n" +
		"src/p/Z.java p.Z.foo(int, String, X) -> void [foo]", 
		resultCollector.toString());
}
/**
 * Method declaration in hierarchy on a secondary type.
 */
public void testMethodDeclarationInHierarchyScope3() throws JavaModelException, CoreException {
	IType type = getCompilationUnit("JavaSearch", "src", "d3", "A.java").getType("B");
	IMethod method = type.getMethod("foo", new String[] {});
	JavaSearchResultCollector resultCollector = new JavaSearchResultCollector();
	new SearchEngine().search(
		getWorkspace(), 
		method,
		DECLARATIONS, 
		SearchEngine.createHierarchyScope(type),
		resultCollector);
	assertEquals(
		"src/d3/A.java d3.B.foo() -> void [foo]", 
		resultCollector.toString());
}
/**
 * Method declaration in field initialzer.
 * (regression test for bug 24346 Method declaration not found in field initializer  )
 */
public void testMethodDeclarationInInitializer() throws CoreException {
	JavaSearchResultCollector resultCollector = new JavaSearchResultCollector();
	new SearchEngine().search(
		getWorkspace(), 
		"foo24346",
		METHOD,
		DECLARATIONS, 
		getJavaSearchScope(),
		resultCollector);
	assertEquals(
		"src/c6/X.java c6.X.x [foo24346]", 
		resultCollector.toString());
}
/**
 * Method declaration in jar file test.
 */
public void testMethodDeclarationInJar() throws JavaModelException, CoreException {
	IType type = getClassFile("JavaSearch", "MyJar.jar", "p1", "A.class").getType();
	IMethod method = type.getMethod("foo", new String[] {"Ljava.lang.String;"});
	JavaSearchResultCollector resultCollector = new JavaSearchResultCollector();
	new SearchEngine().search(
		getWorkspace(), 
		method, 
		DECLARATIONS, 
		getJavaSearchScope(), 
		resultCollector);
	// System.out.println(displayString(resultCollector.toString(), 2));
	assertEquals(
		"MyJar.jar p1.A.foo(java.lang.String) -> boolean [No source]", 
		resultCollector.toString());
}
/**
 * Method declaration in package test.
 * (regression tets for PR #1G2KA97)
 */
public void testMethodDeclarationInPackageScope() throws JavaModelException, CoreException {
	IType type = getCompilationUnit("JavaSearch", "src", "p", "X.java").getType("X");
	IJavaSearchScope scope = SearchEngine.createJavaSearchScope(new IJavaElement[] {type.getPackageFragment()});
	JavaSearchResultCollector resultCollector = new JavaSearchResultCollector();
	new SearchEngine().search(
		getWorkspace(), 
		"main(String[])",
		METHOD,
		DECLARATIONS, 
		scope, 
		resultCollector);
	assertEquals(
		"src/p/A.java p.A.main(String[]) -> void [main]", 
		resultCollector.toString());
}
/**
 * Type declaration using a package scope test.
 * (check that subpackages are not included)
 */
public void testTypeDeclarationInPackageScope() throws JavaModelException, CoreException {
	IType type = getCompilationUnit("JavaSearch", "src", "p3", "X.java").getType("X");
	IJavaSearchScope scope = SearchEngine.createJavaSearchScope(new IJavaElement[] {type.getPackageFragment()});
	JavaSearchResultCollector resultCollector = new JavaSearchResultCollector();
	new SearchEngine().search(
		getWorkspace(), 
		"X",
		TYPE,
		DECLARATIONS, 
		scope, 
		resultCollector);
	assertEquals(
		"src/p3/X.java p3.X [X]", 
		resultCollector.toString());
}
/**
 * Type declaration using a binary package scope test.
 * (check that subpackages are not included)
 */
public void testTypeDeclarationInPackageScope2() throws JavaModelException, CoreException {
	IType type = getClassFile("JavaSearch", "MyJar.jar", "p0", "X.class").getType();
	IJavaSearchScope scope = SearchEngine.createJavaSearchScope(new IJavaElement[] {type.getPackageFragment()});
	JavaSearchResultCollector resultCollector = new JavaSearchResultCollector();
	new SearchEngine().search(
		getJavaProject("JavaSearch").getProject().getWorkspace(), 
		"X",
		TYPE,
		DECLARATIONS, 
		scope, 
		resultCollector);
	assertEquals(
		"MyJar.jar p0.X [No source]", 
		resultCollector.toString());
}
/**
 * Method reference through super test.
 */
public void testMethodReferenceThroughSuper() throws JavaModelException, CoreException {
	IType type = getCompilationUnit("JavaSearch", "src", "sd", "AQ.java").getType("AQ");
	IMethod method = type.getMethod("k", new String[] {});
	JavaSearchResultCollector resultCollector = new JavaSearchResultCollector();
	new SearchEngine().search(
		getWorkspace(), 
		method, 
		REFERENCES, 
		getJavaSearchScope(), 
		resultCollector);
	assertEquals(
		"src/sd/AQ.java sd.AQE.k() -> void [k()]", 
		resultCollector.toString());
}
/**
 * Method reference test.
 * (regression test for bug 5068 search: missing method reference)
 */
public void testMethodReference1() throws JavaModelException, CoreException {
	IType type = getCompilationUnit("JavaSearch", "src", "q5", "AQ.java").getType("I");
	IMethod method = type.getMethod("k", new String[] {});
	JavaSearchResultCollector resultCollector = new JavaSearchResultCollector();
	new SearchEngine().search(
		getWorkspace(), 
		method, 
		REFERENCES, 
		getJavaSearchScope(), 
		resultCollector);
	assertEquals(
		"src/q5/AQ.java q5.T.m() -> void [k()]", 
		resultCollector.toString());
}
/**
 * Method reference test.
 * (regression test for bug 5069 search: method reference in super missing)
 */
public void testMethodReference2() throws JavaModelException, CoreException {
	IType type = getCompilationUnit("JavaSearch", "src", "q6", "CD.java").getType("AQ");
	IMethod method = type.getMethod("k", new String[] {});
	JavaSearchResultCollector resultCollector = new JavaSearchResultCollector();
	new SearchEngine().search(
		getWorkspace(), 
		method, 
		REFERENCES, 
		getJavaSearchScope(), 
		resultCollector);
	assertEquals(
		"src/q6/CD.java q6.AQE.k() -> void [k()]", 
		resultCollector.toString());
}
/**
 * Method reference test.
 * (regression test for bug 5070 search: missing interface method reference  )
 */
public void testMethodReference3() throws JavaModelException, CoreException {
	IType type = getCompilationUnit("JavaSearch", "src", "q7", "AQ.java").getType("I");
	IMethod method = type.getMethod("k", new String[] {});
	JavaSearchResultCollector resultCollector = new JavaSearchResultCollector();
	new SearchEngine().search(
		getWorkspace(), 
		method, 
		REFERENCES, 
		getJavaSearchScope(), 
		resultCollector);
	assertEquals(
		"src/q7/AQ.java q7.D.h() -> void [k()]", 
		resultCollector.toString());
}
/**
 * Method reference test.
 * (regression test for bug 8928 Unable to find references or declarations of methods that use static inner classes in the signature)
 */
public void testMethodReference4() throws JavaModelException, CoreException {
	IType type = getCompilationUnit("JavaSearch", "src", "b2", "Y.java").getType("Y");
	IMethod method = type.getMethod("foo", new String[] {"QX.Inner;"});
	JavaSearchResultCollector resultCollector = new JavaSearchResultCollector();
	new SearchEngine().search(
		getWorkspace(), 
		method, 
		REFERENCES, 
		getJavaSearchScope(), 
		resultCollector);
	assertEquals(
		"src/b2/Z.java b2.Z.bar() -> void [foo(inner)]", 
		resultCollector.toString());
}
/**
 * Method reference through array test.
 * (regression test for 1GHDA2V: ITPJCORE:WINNT - ClassCastException when doing a search)
 */
public void testMethodReferenceThroughArray() throws JavaModelException, CoreException {
	IType type = getClassFile("JavaSearch", getExternalJCLPathString(), "java.lang", "Object.class").getType();
	IMethod method = type.getMethod("clone", new String[] {});
	JavaSearchResultCollector resultCollector = new JavaSearchResultCollector();
	new SearchEngine().search(
		getWorkspace(), 
		method, 
		REFERENCES, 
		getJavaSearchScope(), 
		resultCollector);
	assertEquals(
		"src/E.java E.foo() -> Object [clone()]", 
		resultCollector.toString());
}
/**
 * Method reference in inner class test.
 */
public void testMethodReferenceInInnerClass() throws JavaModelException, CoreException {
	IType type = getCompilationUnit("JavaSearch", "src", "", "CA.java").getType("CA");
	IMethod method = type.getMethod("m", new String[] {});
	JavaSearchResultCollector resultCollector = new JavaSearchResultCollector();
	new SearchEngine().search(
		getWorkspace(), 
		method, 
		REFERENCES, 
		getJavaSearchScope(), 
		resultCollector);
	assertEquals(
		"src/CA.java CA$CB.f() -> void [m()]\n" +
		"src/CA.java CA$CB$CC.f() -> void [m()]", 
		resultCollector.toString());
}
/**
 * Method reference in anonymous class test.
 * (regression test for PR 1GGNOTF: ITPJCORE:WINNT - Search doesn't find method referenced in anonymous inner class)
 */
public void testMethodReferenceInAnonymousClass() throws JavaModelException, CoreException {
	IType type = getCompilationUnit("JavaSearch", "src", "", "PR_1GGNOTF.java").getType("PR_1GGNOTF");
	IMethod method = type.getMethod("method", new String[] {});
	JavaSearchResultCollector resultCollector = new JavaSearchResultCollector();
	new SearchEngine().search(
		getWorkspace(), 
		method, 
		REFERENCES, 
		getJavaSearchScope(), 
		resultCollector);
	assertEquals(
		"src/PR_1GGNOTF.java PR_1GGNOTF.method2() -> void [method()]", 
		resultCollector.toString());
}
/**
 * Member type named "Object" reference test.
 * (regression test for 1G4GHPS: ITPJUI:WINNT - Strange error message in search)
 */
public void testObjectMemberTypeReference() throws JavaModelException, CoreException {
	IType type = getCompilationUnit("JavaSearch", "src", "ObjectMemberTypeReference", "A.java")
		.getType("A")
		.getType("Object");
	JavaSearchResultCollector resultCollector = new JavaSearchResultCollector();
	resultCollector.showAccuracy = true;
	new SearchEngine().search(
		getWorkspace(), 
		type, 
		REFERENCES, 
		getJavaSearchScope(), 
		resultCollector);
	assertEquals(
		"src/ObjectMemberTypeReference/A.java ObjectMemberTypeReference.A.foo() -> void [Object] EXACT_MATCH",
		resultCollector.toString());
}
/**
 * OrPattern test.
 * (regression test for bug 5862 search : too many matches on search with OrPattern)
 */
public void testOrPattern() throws CoreException {
	IMethod leftMethod = getCompilationUnit("JavaSearch", "src", "q9", "I.java")
		.getType("I").getMethod("m", new String[] {});
	ISearchPattern leftPattern = SearchEngine.createSearchPattern(leftMethod, ALL_OCCURRENCES);
	IMethod rightMethod = getCompilationUnit("JavaSearch", "src", "q9", "I.java")
		.getType("A1").getMethod("m", new String[] {});
	ISearchPattern rightPattern = SearchEngine.createSearchPattern(rightMethod, ALL_OCCURRENCES);
	ISearchPattern orPattern = SearchEngine.createOrSearchPattern(leftPattern, rightPattern);
	JavaSearchResultCollector resultCollector = new JavaSearchResultCollector();
	resultCollector.showAccuracy = true;
	new SearchEngine().search(
		getWorkspace(), 
		orPattern,
		getJavaSearchScope(),
		resultCollector);
	assertEquals(
		"src/q9/I.java q9.I.m() -> void [m] EXACT_MATCH\n" +
		"src/q9/I.java q9.A1.m() -> void [m] EXACT_MATCH",
		resultCollector.toString());
}
/**
 * Package reference test.
 * (regression test for PR 1GK90H4: ITPJCORE:WIN2000 - search: missing package reference)
 */
public void testPackageReference1() throws JavaModelException, CoreException {
	IPackageFragment pkg = getPackageFragment("JavaSearch", "src", "q2");
	JavaSearchResultCollector resultCollector = new JavaSearchResultCollector();
	new SearchEngine().search(
		getWorkspace(), 
		pkg, 
		REFERENCES, 
		getJavaSearchScope(), 
		resultCollector);
	assertEquals(
		"src/q1/B.java q1.B.m(AA) -> void [q2]", 
		resultCollector.toString());
}
/**
 * Package reference test.
 * (regression test for bug 17906 Rename package fails when inner classes are imported)
 */
public void testPackageReference2() throws JavaModelException, CoreException {
	IPackageFragment pkg = getPackageFragment("JavaSearch", "src", "b8");
	JavaSearchResultCollector resultCollector = new JavaSearchResultCollector();
	new SearchEngine().search(
		getWorkspace(), 
		pkg, 
		REFERENCES, 
		getJavaSearchScope(), 
		resultCollector);
	assertEquals(
		"src/b9/Foo.java [b8]", 
		resultCollector.toString());
}

/**
 * Test pattern match package references
 */
public void testPatternMatchPackageReference() throws JavaModelException, CoreException {
	JavaSearchResultCollector resultCollector = new JavaSearchResultCollector();
	new SearchEngine().search(
		getWorkspace(), 
		"*p2.*",
		PACKAGE,
		REFERENCES, 
		getJavaSearchScope(), 
		resultCollector);
	assertEquals(
		"src/PackageReference/A.java [p3.p2.p]\n" +
		"src/PackageReference/B.java [p3.p2.p]\n" +
		"src/PackageReference/C.java PackageReference.C [p3.p2.p]\n" +
		"src/PackageReference/D.java PackageReference.D.x [p3.p2.p]\n" +
		"src/PackageReference/E.java PackageReference.E.x [p3.p2.p]\n" +
		"src/PackageReference/F.java PackageReference.F.foo() -> p3.p2.p.X [p3.p2.p]\n" +
		"src/PackageReference/G.java PackageReference.G.foo(p3.p2.p.X) -> void [p3.p2.p]\n" +
		"src/PackageReference/H.java PackageReference.H.foo() -> void [p3.p2.p]\n" +
		"src/PackageReference/I.java PackageReference.I.foo() -> void [p3.p2.p]\n" +
		"src/PackageReference/J.java PackageReference.J.foo() -> void [p3.p2.p]", 
		resultCollector.toString());
}
/**
 * Test pattern match type declaration
 * (regression test for bug 17210 No match found when query contains '?')
 */
public void testPatternMatchTypeDeclaration() throws CoreException {
	JavaSearchResultCollector resultCollector = new JavaSearchResultCollector();
	new SearchEngine().search(
		getWorkspace(), 
		"X?Z",
		TYPE,
		DECLARATIONS, 
		getJavaSearchScope(), 
		resultCollector);
	assertEquals("src/r5/XYZ.java r5.XYZ [XYZ]", resultCollector.toString());
}
/**
 * Test pattern match type reference in binary
 * (regression test for bug 24741 Search does not find patterned type reference in binary project  )
 */
public void testPatternMatchTypeReference() throws CoreException {
	JavaSearchResultCollector resultCollector = new JavaSearchResultCollector();
	new SearchEngine().search(
		getWorkspace(), 
		"p24741.*",
		TYPE,
		REFERENCES, 
		getJavaSearchScope(), 
		resultCollector);
	assertEquals(
		"test24741.jar q24741.B", 
		resultCollector.toString());
}
/**
 * Test that we find potential matches in binaries even if we can't resolve the entire
 * class file.
 * (Regression test for 1G4IN3E: ITPJCORE:WINNT - AbortCompilation using J9 to search for class declaration) 
 */
public void testPotentialMatchInBinary() throws JavaModelException, CoreException {
	IJavaProject project = this.getJavaProject("JavaSearch");
	IClasspathEntry[] classpath = project.getRawClasspath();
	try {
		// add AbortCompilation.jar to classpath
		int length = classpath.length;
		IClasspathEntry[] newClasspath = new IClasspathEntry[length+1];
		System.arraycopy(classpath, 0, newClasspath, 0, length);
		newClasspath[length] = JavaCore.newLibraryEntry(new Path("/JavaSearch/AbortCompilation.jar"), null, null);
		project.setRawClasspath(newClasspath, null);
		
		// potential match for a field declaration
		JavaSearchResultCollector resultCollector = new JavaSearchResultCollector();
		resultCollector.showAccuracy = true;
		new SearchEngine().search(
			getWorkspace(),
			"MissingFieldType.*",
			FIELD, 
			DECLARATIONS, 
			getJavaSearchScope(), 
			resultCollector);
		assertEquals(
			"AbortCompilation.jar AbortCompilation.MissingFieldType.field [No source] POTENTIAL_MATCH\n" +
			"AbortCompilation.jar AbortCompilation.MissingFieldType.missing [No source] POTENTIAL_MATCH\n" +
			"AbortCompilation.jar AbortCompilation.MissingFieldType.otherField [No source] POTENTIAL_MATCH", 
			resultCollector.toString());
	
		// potential match for a method declaration
		resultCollector = new JavaSearchResultCollector();
		resultCollector.showAccuracy = true;
		new SearchEngine().search(
			getWorkspace(),
			"MissingArgumentType.foo*",
			METHOD, 
			DECLARATIONS, 
			getJavaSearchScope(), 
			resultCollector);
		assertEquals(
			"AbortCompilation.jar AbortCompilation.MissingArgumentType.foo() -> void [No source] POTENTIAL_MATCH\n" +
			"AbortCompilation.jar AbortCompilation.MissingArgumentType.foo(java.util.EventListener) -> void [No source] POTENTIAL_MATCH\n" +
			"AbortCompilation.jar AbortCompilation.MissingArgumentType.foo2() -> void [No source] POTENTIAL_MATCH", 
			resultCollector.toString());
	
		// potential match for a type declaration
		resultCollector = new JavaSearchResultCollector();
		resultCollector.showAccuracy = true;
		new SearchEngine().search(
			getWorkspace(),
			"Missing*",
			TYPE, 
			DECLARATIONS, 
			getJavaSearchScope(), 
			resultCollector);
		assertEquals(
			"AbortCompilation.jar AbortCompilation.EnclosingType$MissingEnclosingType [No source] EXACT_MATCH\n" +
			"AbortCompilation.jar AbortCompilation.MissingArgumentType [No source] EXACT_MATCH\n" +
			"AbortCompilation.jar AbortCompilation.MissingFieldType [No source] EXACT_MATCH", 
			resultCollector.toString());
	} finally {
		// reset classpath
		project.setRawClasspath(classpath, null);
	}
}
/**
 * Read and write access reference in compound expression test.
 * (regression test for bug 6158 Search - Prefix and postfix expression not found as write reference)
 */
public void testReadWriteFieldReferenceInCompoundExpression() throws JavaModelException, CoreException {
	IType type = getCompilationUnit("JavaSearch", "src", "a4", "X.java").getType("X");
	IField field = type.getField("field");
	JavaSearchResultCollector resultCollector = new JavaSearchResultCollector();
	
	// Read reference
	new SearchEngine().search(
		getWorkspace(), 
		field, 
		READ_ACCESSES, 
		getJavaSearchScope(), 
		resultCollector);
	assertEquals(
		"src/a4/X.java a4.X.foo() -> void [field]", 
		resultCollector.toString());
		
	// Write reference
	resultCollector = new JavaSearchResultCollector();
	new SearchEngine().search(
		getWorkspace(), 
		field, 
		WRITE_ACCESSES, 
		getJavaSearchScope(), 
		resultCollector);
	assertEquals(
		"src/a4/X.java a4.X.foo() -> void [field]", 
		resultCollector.toString());
		
}
/**
 * Simple constructor declaration test.
 */
public void testSimpleConstructorDeclaration() throws JavaModelException, CoreException {
	IType type = getCompilationUnit("JavaSearch", "src", "p", "A.java").getType("A");
	IMethod constructor = type.getMethod("A", new String[] {"QX;"});
	JavaSearchResultCollector resultCollector = new JavaSearchResultCollector();
	new SearchEngine().search(
		getWorkspace(), 
		constructor, 
		DECLARATIONS, 
		getJavaSearchScope(), 
		resultCollector);
	assertEquals("src/p/A.java p.A(X) [A]", resultCollector.toString());
}
/**
 * Simple constructor reference test.
 */
public void testSimpleConstructorReference1() throws JavaModelException, CoreException {
	IType type = getCompilationUnit("JavaSearch", "src", "p", "A.java").getType("A");
	IMethod constructor = type.getMethod("A", new String[] {"QX;"});
	JavaSearchResultCollector resultCollector = new JavaSearchResultCollector();
	new SearchEngine().search(
		getWorkspace(), 
		constructor, 
		REFERENCES, 
		getJavaSearchScope(), 
		resultCollector);
	assertEquals("src/Test.java Test.main(String[]) -> void [new p.A(y)]", resultCollector.toString());
}
/**
 * Simple constructor reference test.
 */
public void testSimpleConstructorReference2() throws JavaModelException, CoreException {
	JavaSearchResultCollector resultCollector = new JavaSearchResultCollector();
	new SearchEngine().search(
		getWorkspace(), 
		"p.A(X)",
		CONSTRUCTOR,
		REFERENCES, 
		getJavaSearchScope(), 
		resultCollector);
	assertEquals("src/Test.java Test.main(String[]) -> void [new p.A(y)]", resultCollector.toString());
}
/**
 * Simple declarations of sent messages test.
 */
public void testSimpleDeclarationsOfSentMessages() throws JavaModelException, CoreException {
	ICompilationUnit cu = getCompilationUnit("JavaSearch", "src", "", "Test.java");
	JavaSearchResultCollector resultCollector = new JavaSearchResultCollector();
	new SearchEngine().searchDeclarationsOfSentMessages(
		getWorkspace(), 
		cu, 
		resultCollector);
	assertEquals(
		"src/p/X.java p.X.foo(int, String, X) -> void [foo(int i, String s, X x)]\n" +
		"src/p/Y.java p.Y.bar() -> void [bar()]\n" +
		"src/p/Z.java p.Z.foo(int, String, X) -> void [foo(int i, String s, X x)]\n" +
		"src/p/A.java p.A.foo(int, String, X) -> void [foo()]", 
		resultCollector.toString());
}
/**
 * Simple field declaration test.
 */
public void testSimpleFieldDeclaration() throws JavaModelException, CoreException {
	IType type = getCompilationUnit("JavaSearch", "src", "p", "A.java").getType("A");
	IField field = type.getField("x");
	JavaSearchResultCollector resultCollector = new JavaSearchResultCollector();
	new SearchEngine().search(
		getWorkspace(), 
		field, 
		DECLARATIONS, 
		getJavaSearchScope(), 
		resultCollector);
	assertEquals(
		"src/p/A.java p.A.x [x]", 
		resultCollector.toString());
}
/**
 * Simple field reference test.
 */
public void testSimpleFieldReference() throws JavaModelException, CoreException {
	IType type = getCompilationUnit("JavaSearch", "src", "p", "A.java").getType("A");
	IField field = type.getField("x");
	JavaSearchResultCollector resultCollector = new JavaSearchResultCollector();
	new SearchEngine().search(
		getWorkspace(), 
		field, 
		REFERENCES, 
		getJavaSearchScope(), 
		resultCollector);
	assertEquals(
		"src/Test.java Test.main(String[]) -> void [x]\n" +
		"src/p/A.java p.A(X) [x]", 
		resultCollector.toString());
}
/**
 * Simple write field access reference test.
 */
public void testSimpleWriteFieldReference() throws JavaModelException, CoreException {
	IType type = getCompilationUnit("JavaSearch", "src", "p", "A.java").getType("A");
	IField field = type.getField("x");
	JavaSearchResultCollector resultCollector = new JavaSearchResultCollector();
	new SearchEngine().search(
		getWorkspace(), 
		field, 
		WRITE_ACCESSES, 
		getJavaSearchScope(), 
		resultCollector);
	assertEquals(
		"src/p/A.java p.A(X) [x]", 
		resultCollector.toString());
}
/**
 * Sub-cu java search scope test.
 * (regression test for bug 9041 search: cannot create a sub-cu scope)
 */
public void testSubCUSearchScope1() throws JavaModelException, CoreException {
	IType type = getCompilationUnit("JavaSearch", "src", "b3", "X.java").getType("X");
	IJavaSearchScope scope = SearchEngine.createJavaSearchScope(new IJavaElement[] {type});
	JavaSearchResultCollector resultCollector = new JavaSearchResultCollector();
	new SearchEngine().search(
		getWorkspace(), 
		type,
		REFERENCES, 
		scope, 
		resultCollector);
	assertEquals(
		"src/b3/X.java b3.X.field [X]\n" +
		"src/b3/X.java b3.X.foo() -> Object [X]\n" +
		"src/b3/X.java b3.X$Y.field2 [X]\n" +
		"src/b3/X.java b3.X$Y.foo2() -> Object [X]", 
		resultCollector.toString());
}
/**
 * Sub-cu java search scope test.
 * (regression test for bug 9041 search: cannot create a sub-cu scope)
 */
public void testSubCUSearchScope2() throws JavaModelException, CoreException {
	IType type = getCompilationUnit("JavaSearch", "src", "b3", "X.java").getType("X");
	IJavaSearchScope scope = SearchEngine.createJavaSearchScope(new IJavaElement[] {type.getField("field")});
	JavaSearchResultCollector resultCollector = new JavaSearchResultCollector();
	new SearchEngine().search(
		getWorkspace(), 
		type,
		REFERENCES, 
		scope, 
		resultCollector);
	assertEquals(
		"src/b3/X.java b3.X.field [X]", 
		resultCollector.toString());
}
/**
 * Sub-cu java search scope test.
 * (regression test for bug 9041 search: cannot create a sub-cu scope)
 */
public void testSubCUSearchScope3() throws JavaModelException, CoreException {
	IType type = getCompilationUnit("JavaSearch", "src", "b3", "X.java").getType("X");
	IJavaSearchScope scope = SearchEngine.createJavaSearchScope(new IJavaElement[] {type.getType("Y")});
	JavaSearchResultCollector resultCollector = new JavaSearchResultCollector();
	new SearchEngine().search(
		getWorkspace(), 
		type,
		REFERENCES, 
		scope, 
		resultCollector);
	assertEquals(
		"src/b3/X.java b3.X$Y.field2 [X]\n" +
		"src/b3/X.java b3.X$Y.foo2() -> Object [X]", 
		resultCollector.toString());
}
/**
 * Type declaration test.
 * (regression test for bug 29524 Search for declaration via patterns adds '"*")
 */
public void testTypeDeclaration() throws JavaModelException, CoreException {
	IPackageFragment pkg = this.getPackageFragment("JavaSearch", "src", "d8");
	IJavaSearchScope scope = SearchEngine.createJavaSearchScope(new IJavaElement[] {pkg});
	JavaSearchResultCollector resultCollector = new JavaSearchResultCollector();
	new SearchEngine().search(
		getWorkspace(), 
		"A",
		TYPE,
		DECLARATIONS, 
		scope, 
		resultCollector);
	assertEquals("src/d8/A.java d8.A [A]", resultCollector.toString());
}
/**
 * Simple method declaration test.
 */
public void testSimpleMethodDeclaration() throws JavaModelException, CoreException {
	IType type = getCompilationUnit("JavaSearch", "src", "p", "X.java").getType("X");
	IMethod method = type.getMethod("foo", new String[] {"I", "QString;", "QX;"});
	JavaSearchResultCollector resultCollector = new JavaSearchResultCollector();
	new SearchEngine().search(
		getWorkspace(), 
		method, 
		DECLARATIONS, 
		getJavaSearchScope(), 
		resultCollector);
	assertEquals(
		"src/p/X.java p.X.foo(int, String, X) -> void [foo]\n" +
		"src/p/Z.java p.Z.foo(int, String, X) -> void [foo]", 
		resultCollector.toString());
}
/**
 * Simple method reference test.
 */
public void testSimpleMethodReference() throws JavaModelException, CoreException {
	IType type = getCompilationUnit("JavaSearch", "src", "p", "X.java").getType("X");
	IMethod method = type.getMethod("foo", new String[] {"I", "QString;", "QX;"});
	JavaSearchResultCollector resultCollector = new JavaSearchResultCollector();
	new SearchEngine().search(
		getWorkspace(), 
		method, 
		REFERENCES, 
		getJavaSearchScope(), 
		resultCollector);
	assertEquals(
		"src/Test.java Test.main(String[]) -> void [foo(1, \"a\", y)]\n" +
		"src/Test.java Test.main(String[]) -> void [foo(1, \"a\", z)]\n" +
		"src/p/Z.java p.Z.foo(int, String, X) -> void [foo(i, s, new Y(true))]", 
		resultCollector.toString());
}
/**
 * Simple package declaration test.
 */
public void testSimplePackageDeclaration() throws JavaModelException, CoreException {
	IPackageFragment pkg = getPackageFragment("JavaSearch", "src", "p");
	JavaSearchResultCollector resultCollector = new JavaSearchResultCollector();
	new SearchEngine().search(
		getWorkspace(), 
		pkg, 
		DECLARATIONS, 
		getJavaSearchScope(), 
		resultCollector);
	assertEquals(
		"src/p p", 
		resultCollector.toString());
}
/**
 * Simple package reference test.
 */
public void testSimplePackageReference() throws JavaModelException, CoreException {
	IPackageFragment pkg = getPackageFragment("JavaSearch", "src", "p");
	JavaSearchResultCollector resultCollector = new JavaSearchResultCollector();
	new SearchEngine().search(
		getWorkspace(), 
		pkg, 
		REFERENCES, 
		getJavaSearchScope(), 
		resultCollector);
	assertEquals(
		"src/InterfaceImplementors.java InterfaceImplementors [p]\n" +
		"src/Test.java Test.main(String[]) -> void [p]\n" +
		"src/Test.java Test.main(String[]) -> void [p]\n" +
		"src/Test.java Test.main(String[]) -> void [p]\n" +
		"src/Test.java Test.main(String[]) -> void [p]\n" +
		"src/Test.java Test.main(String[]) -> void [p]\n" +
		"src/Test.java Test.main(String[]) -> void [p]\n" +
		"src/Test.java Test.main(String[]) -> void [p]\n" +
		"src/TypeReferenceInImport/X.java [p]", 
		resultCollector.toString());
}
/**
 * Simple field read access reference test.
 */
public void testSimpleReadFieldReference() throws JavaModelException, CoreException {
	IType type = getCompilationUnit("JavaSearch", "src", "p", "A.java").getType("A");
	IField field = type.getField("x");
	JavaSearchResultCollector resultCollector = new JavaSearchResultCollector();
	new SearchEngine().search(
		getWorkspace(), 
		field, 
		READ_ACCESSES, 
		getJavaSearchScope(), 
		resultCollector);
	assertEquals(
		"src/Test.java Test.main(String[]) -> void [x]", 
		resultCollector.toString());
}
/**
 * Simple type declaration test.
 */
public void testSimpleTypeDeclaration() throws JavaModelException, CoreException {
	IType type = getCompilationUnit("JavaSearch", "src", "p", "X.java").getType("X");
	JavaSearchResultCollector resultCollector = new JavaSearchResultCollector();
	new SearchEngine().search(
		getWorkspace(), 
		type,
		DECLARATIONS, 
		getJavaSearchScope(), 
		resultCollector);
	assertEquals("src/p/X.java p.X [X]", resultCollector.toString());
}
/**
 * Simple type reference test.
 */
public void testSimpleTypeReference() throws JavaModelException, CoreException {
	IType type = getCompilationUnit("JavaSearch", "src", "p", "X.java").getType("X");
	JavaSearchResultCollector resultCollector = new JavaSearchResultCollector();
	new SearchEngine().search(
		getWorkspace(), 
		type, 
		REFERENCES, 
		getJavaSearchScope(), 
		resultCollector);
	assertEquals(
		"src/p/A.java p.A.x [X]\n" +
		"src/p/A.java p.A(X) [X]\n" +
		"src/p/A.java p.A.foo(int, String, X) -> void [X]\n" +
		"src/p/X.java p.X() [X]\n" +
		"src/p/X.java p.X.foo(int, String, X) -> void [X]\n" +
		"src/p/Y.java p.Y [X]\n" +
		"src/p/Z.java p.Z.foo(int, String, X) -> void [X]", 
		resultCollector.toString());
}
/**
 * Static field reference test.
 * (regression test for PR #1G2P5EP)
 */
public void testStaticFieldReference() throws JavaModelException, CoreException {
	IType type = getCompilationUnit("JavaSearch", "src", "p", "A.java").getType("A");
	IField field = type.getField("DEBUG");
	JavaSearchResultCollector resultCollector = new JavaSearchResultCollector();
	new SearchEngine().search(
		getWorkspace(), 
		field, 
		REFERENCES, 
		getJavaSearchScope(), 
		resultCollector);
	assertEquals(
		"src/p/A.java p.A.foo() -> void [DEBUG]", 
		resultCollector.toString());
}
/**
 * Static method reference test.
 */
public void testStaticMethodReference1() throws JavaModelException, CoreException {
	IType type = getCompilationUnit("JavaSearch", "src", "p", "Y.java").getType("Y");
	IMethod method = type.getMethod("bar", new String[] {});
	JavaSearchResultCollector resultCollector = new JavaSearchResultCollector();
	new SearchEngine().search(
		getWorkspace(), 
		method, 
		REFERENCES, 
		getJavaSearchScope(), 
		resultCollector);
	assertEquals(
		"src/Test.java Test.main(String[]) -> void [bar()]", 
		resultCollector.toString());
}
/**
 * Static method reference test.
 */
public void testStaticMethodReference2() throws JavaModelException, CoreException {
	IType type = getCompilationUnit("JavaSearch", "src", "p", "X.java").getType("X");
	IMethod method = type.getMethod("bar", new String[] {});
	JavaSearchResultCollector resultCollector = new JavaSearchResultCollector();
	new SearchEngine().search(
		getWorkspace(), 
		method, 
		REFERENCES, 
		getJavaSearchScope(), 
		resultCollector);
	assertEquals(
		"", 
		resultCollector.toString());
}
/**
 * Type declaration in jar file test.
 */
public void testTypeDeclarationInJar() throws JavaModelException, CoreException {
	IType type = getClassFile("JavaSearch", "MyJar.jar", "p1", "A.class").getType();
	JavaSearchResultCollector resultCollector = new JavaSearchResultCollector();
	new SearchEngine().search(
		getWorkspace(), 
		type, 
		DECLARATIONS, 
		getJavaSearchScope(), 
		resultCollector);
	assertEquals(
		"MyJar.jar p1.A [No source]", 
		resultCollector.toString());
}
/**
 * Type declaration in jar file and in anonymous class test.
 * (regression test for 20631 Declaration of local binary type not found)
 */
public void testTypeDeclarationInJar2() throws JavaModelException, CoreException {
	IPackageFragmentRoot root = getPackageFragmentRoot("JavaSearch", "test20631.jar");
	IJavaSearchScope scope = SearchEngine.createJavaSearchScope(new IJavaElement[] {root});
	JavaSearchResultCollector resultCollector = new JavaSearchResultCollector();
	new SearchEngine().search(
		getWorkspace(), 
		"Y",
		TYPE, 
		DECLARATIONS, 
		scope, 
		resultCollector);
	assertEquals(
		"test20631.jar X$1$Y", 
		resultCollector.toString());
}
/**
 * Type ocurrence test.
 * (regression test for PR 1GKAQJS: ITPJCORE:WIN2000 - search: incorrect results for nested types)
 */
public void testTypeOccurence() throws JavaModelException, CoreException {
	IType type = getCompilationUnit("JavaSearch", "src", "r", "A.java").getType("A").getType("X");
	JavaSearchResultCollector resultCollector = new JavaSearchResultCollector();
	new SearchEngine().search(
		getWorkspace(), 
		type, 
		ALL_OCCURRENCES, 
		getJavaSearchScope(), 
		resultCollector);
	assertEquals(
		"src/r/A.java r.A.m() -> A [X]\n" +
		"src/r/A.java r.A$X [X]\n" +
		"src/r/A.java r.A$X(X) [X]\n" +
		"src/r/A.java r.A$X(X) [X]\n" +
		"src/r/A.java r.B.ax [A.X]\n" +
		"src/r/A.java r.B.ax [X]",
		resultCollector.toString());
}
/**
 * Type ocuurence in unresolvable import test.
 * (regression test for bug 37166 NPE in SearchEngine when matching type against ProblemReferenceBinding )
 */
public void testTypeOccurence2() throws CoreException {
	IType type = getCompilationUnit("JavaSearch", "src", "r8", "B.java").getType("B");
	IJavaSearchScope scope = SearchEngine.createJavaSearchScope(new IJavaElement[] {type.getPackageFragment()});
	JavaSearchResultCollector resultCollector = new JavaSearchResultCollector();
	new SearchEngine().search(
		getWorkspace(), 
		type, 
		ALL_OCCURRENCES, 
		scope, 
		resultCollector);
	assertEquals(
		"src/r8/A.java [r8.B]",
		resultCollector.toString());
}
/**
 * Type name with $ ocurrence test.
 * (regression test for bug 3310 Smoke 124: Compile errors introduced with rename refactoring (1GFBK2G))
 */
public void testTypeOccurenceWithDollar() throws JavaModelException, CoreException {
	IType type = getCompilationUnit("JavaSearch", "src", "q3", "A$B.java").getType("A$B");
	JavaSearchResultCollector resultCollector = new JavaSearchResultCollector();
	new SearchEngine().search(
		getWorkspace(), 
		type, 
		ALL_OCCURRENCES, 
		getJavaSearchScope(), 
		resultCollector);
	assertEquals(
		"src/q3/A$B.java q3.A$B [A$B]\n" +
		"src/q4/C.java q4.C.foo() -> Object [q3.A$B]",
		resultCollector.toString());
}
/**
 * Type reference test.
 * (Regression test for PR 1GK7K17: ITPJCORE:WIN2000 - search: missing type reference)
 */
public void testTypeReference1() throws JavaModelException, CoreException {
	IType type = getCompilationUnit("JavaSearch", "src", "", "X.java").getType("X");
	JavaSearchResultCollector resultCollector = new JavaSearchResultCollector();
	new SearchEngine().search(
		getWorkspace(), 
		type, 
		REFERENCES, 
		getJavaSearchScope(), 
		resultCollector);
	assertEquals(
		"src/X.java AA() [X]",
		resultCollector.toString());
}
/**
 * Type reference test.
 * (Regression test for bug 29516 SearchEngine regressions in 20030114)
 */
public void testTypeReference2() throws JavaModelException, CoreException {
	IType type = getCompilationUnit("JavaSearch", "src", "d7", "A.java").getType("A");
	JavaSearchResultCollector resultCollector = new JavaSearchResultCollector();
	new SearchEngine().search(
		getWorkspace(), 
		type, 
		REFERENCES, 
		getJavaSearchScope(), 
		resultCollector);
	assertEquals(
		"src/d7/A.java d7.A.A [A]\n" +
		"src/d7/A.java d7.A.A(A) -> A [A]\n" +
		"src/d7/A.java d7.A.A(A) -> A [A]",
		resultCollector.toString());
}
/**
 * Type reference test.
 * (Regression test for bug 31985 NPE searching non-qualified and case insensitive type ref)
 */
public void testTypeReference3() throws JavaModelException, CoreException {
	ISearchPattern pattern = SearchEngine.createSearchPattern("x31985", TYPE, REFERENCES, false);
	JavaSearchResultCollector resultCollector = new JavaSearchResultCollector();
	resultCollector.showAccuracy = true;
	new SearchEngine().search(
		getWorkspace(), 
		pattern,
		getJavaSearchScope(), 
		resultCollector);
	assertEquals(
		"src/e3/X31985.java e3.X31985.CONSTANT [X31985] EXACT_MATCH\n" +
		"src/e3/Y31985.java e3.Y31985.foo() -> Object [X31985] EXACT_MATCH",
		resultCollector.toString());
}
/**
 * Type reference test.
 * (Regression test for bug 31997 Refactoring d.n. work for projects with brackets in name.)
 */
public void testTypeReference4() throws JavaModelException, CoreException {
	IType type = getCompilationUnit("JavaSearch", "otherSrc()", "", "X31997.java").getType("X31997");
	JavaSearchResultCollector resultCollector = new JavaSearchResultCollector();
	new SearchEngine().search(
		getWorkspace(), 
		type, 
		REFERENCES, 
		getJavaSearchScope(), 
		resultCollector);
	assertEquals(
		"otherSrc()/Y31997.java Y31997 [X31997]",
		resultCollector.toString());
}
/**
 * Type reference as a single name reference test.
 */
public void testTypeReferenceAsSingleNameReference() throws JavaModelException, CoreException {
	IType type = getCompilationUnit("JavaSearch", "src", "", "TypeReferenceAsSingleNameReference.java").getType("TypeReferenceAsSingleNameReference");
	JavaSearchResultCollector resultCollector = new JavaSearchResultCollector();
	new SearchEngine().search(
		getWorkspace(), 
		type, 
		REFERENCES, 
		getJavaSearchScope(), 
		resultCollector);
	assertEquals(
		"src/TypeReferenceAsSingleNameReference.java TypeReferenceAsSingleNameReference.hasReference() -> void [TypeReferenceAsSingleNameReference]\n" +
		"src/TypeReferenceAsSingleNameReference.java TypeReferenceAsSingleNameReference.hasReference() -> void [TypeReferenceAsSingleNameReference]",
		resultCollector.toString());
}
/**
 * Type reference in array test.
 * (regression test for PR #1GAL424)
 */
public void testTypeReferenceInArray() throws JavaModelException, CoreException {
	IType type = getCompilationUnit("JavaSearch", "src", "TypeReferenceInArray", "A.java").getType("A");
	JavaSearchResultCollector resultCollector = new JavaSearchResultCollector();
	new SearchEngine().search(
		getWorkspace(), 
		type, 
		REFERENCES, 
		getJavaSearchScope(), 
		resultCollector);
	assertEquals(
		"src/TypeReferenceInArray/A.java TypeReferenceInArray.A.a [A]\n" +
		"src/TypeReferenceInArray/A.java TypeReferenceInArray.A.b [TypeReferenceInArray.A]",
		resultCollector.toString());
}
/**
 * Type reference in array test.
 * (regression test for bug 3230 Search - Too many type references for query ending with * (1GAZVGI)  )
 */
public void testTypeReferenceInArray2() throws JavaModelException, CoreException {
	IType type = getCompilationUnit("JavaSearch", "src", "s1", "X.java").getType("X");
	JavaSearchResultCollector resultCollector = new JavaSearchResultCollector();
	new SearchEngine().search(
		getWorkspace(), 
		type, 
		REFERENCES, 
		getJavaSearchScope(), 
		resultCollector);
	assertEquals(
		"src/s1/Y.java s1.Y.f [X]",
		resultCollector.toString());
}
/**
 * Type reference in cast test.
 * (regression test for bug 23329 search: incorrect range for type references in brackets)
 */
public void testTypeReferenceInCast() throws JavaModelException, CoreException {
	IType type = getCompilationUnit("JavaSearch", "src", "s3", "A.java").getType("B");
	JavaSearchResultCollector resultCollector = new JavaSearchResultCollector();
	new SearchEngine().search(
		getWorkspace(), 
		type, 
		REFERENCES, 
		getJavaSearchScope(), 
		resultCollector);
	assertEquals(
		"src/s3/A.java s3.A.foo() -> Object [B]",
		resultCollector.toString());
}
/**
 * Type reference in hierarchy test.
 * (regression test for bug 28236 Search for refs to class in hierarchy matches class outside hierarchy )
 */
public void testTypeReferenceInHierarchy() throws JavaModelException, CoreException {
	IType type = getCompilationUnit("JavaSearch", "src", "d9.p1", "A.java").getType("A");
	JavaSearchResultCollector resultCollector = new JavaSearchResultCollector();
	IJavaSearchScope scope = SearchEngine.createHierarchyScope(type);
	new SearchEngine().search(
		getWorkspace(), 
		type, 
		REFERENCES, 
		scope, 
		resultCollector);
	assertEquals(
		"",
		resultCollector.toString());
}
/**
 * Type reference in import test.
 * (regression test for PR #1GA7PAS)
 */
public void testTypeReferenceInImport() throws JavaModelException, CoreException {
	IType type = getCompilationUnit("JavaSearch", "src", "p2", "Z.java").getType("Z");
	JavaSearchResultCollector resultCollector = new JavaSearchResultCollector();
	new SearchEngine().search(
		getWorkspace(), 
		type, 
		REFERENCES, 
		getJavaSearchScope(), 
		resultCollector);
	assertEquals(
		"src/TypeReferenceInImport/X.java [p2.Z]",
		resultCollector.toString());
}
/**
 * Type reference in import test.
 * (regression test for bug 23077 search: does not find type references in some imports)
 */
public void testTypeReferenceInImport2() throws JavaModelException, CoreException {
	IType type = getCompilationUnit("JavaSearch", "src", "r6", "A.java").getType("A");
	JavaSearchResultCollector resultCollector = new JavaSearchResultCollector();
	new SearchEngine().search(
		getWorkspace(), 
		type, 
		REFERENCES, 
		getJavaSearchScope(), 
		resultCollector);
	assertEquals(
		"src/r6/B.java [r6.A]\n" +
		"src/r6/B.java [r6.A]\n" +
		"src/r6/B.java [r6.A]\n" +
		"src/r6/B.java [r6.A]\n" +
		"src/r6/B.java [r6.A]\n" +
		"src/r6/B.java [r6.A]",
		resultCollector.toString());
}
/**
 * Type reference in initializer test.
 * (regression test for PR #1G4GO4O)
 */
public void testTypeReferenceInInitializer() throws JavaModelException, CoreException {
	IType type = getCompilationUnit("JavaSearch", "src", "", "Test.java").getType("Test");
	JavaSearchResultCollector resultCollector = new JavaSearchResultCollector();
	new SearchEngine().search(
		getWorkspace(), 
		type, 
		REFERENCES, 
		getJavaSearchScope(), 
		resultCollector);
	assertEquals(
		"src/Test.java Test.static {} [Test]\n" +
		"src/Test.java Test.static {} [Test]\n" +
		"src/Test.java Test.{} [Test]",
		resultCollector.toString());
}
/**
 * Type reference inside a qualified name reference test.
 * (Regression test for PR #1G4TSC0)
 */
public void testTypeReferenceInQualifiedNameReference() throws JavaModelException, CoreException {
	IType type = getCompilationUnit("JavaSearch", "src", "p", "A.java").getType("A");
	JavaSearchResultCollector resultCollector = new JavaSearchResultCollector();
	new SearchEngine().search(
		getWorkspace(), 
		type, 
		REFERENCES, 
		getJavaSearchScope(), 
		resultCollector);
	assertEquals(
		"src/Test.java Test.main(String[]) -> void [p.A]\n" +
		"src/Test.java Test.main(String[]) -> void [p.A]\n" +
		"src/p/A.java p.A.foo() -> void [A]",
		resultCollector.toString());
}
/**
 * Type reference inside a qualified name reference test.
 * (Regression test for PR #1GLBP65)
 */
public void testTypeReferenceInQualifiedNameReference2() throws JavaModelException, CoreException {
	IType type = getCompilationUnit("JavaSearch", "src", "p4", "A.java").getType("A");
	JavaSearchResultCollector resultCollector = new JavaSearchResultCollector();
	new SearchEngine().search(
		getWorkspace(), 
		type, 
		REFERENCES, 
		getJavaSearchScope(), 
		resultCollector);
	assertEquals(
		"src/p4/A.java p4.A.A [A]\n" +
		"src/p4/A.java p4.X.x() -> void [p4.A]\n" +
		"src/p4/A.java p4.X [p4.A]",
		resultCollector.toString());
}
/**
 * Type reference inside a qualified name reference test.
 * (Regression test for PR 1GL9UMH: ITPJCORE:WIN2000 - search: missing type occurrences)
 */
public void testTypeReferenceInQualifiedNameReference3() throws JavaModelException, CoreException {
	IType type = getCompilationUnit("JavaSearch", "src", "", "W.java").getType("W");
	JavaSearchResultCollector resultCollector = new JavaSearchResultCollector();
	new SearchEngine().search(
		getWorkspace(), 
		type, 
		REFERENCES, 
		getJavaSearchScope(), 
		resultCollector);
	assertEquals(
		"src/W.java W.m() -> int [W]",
		resultCollector.toString());
}
/**
 * Type reference inside a qualified name reference test.
 * (Regression test for bug 16751 Renaming a class doesn't update all references  )
 */
public void testTypeReferenceInQualifiedNameReference4() throws CoreException {
	IType type = getCompilationUnit("JavaSearch", "src", "b7", "X.java").getType("SubClass");
	JavaSearchResultCollector resultCollector = new JavaSearchResultCollector();
	new SearchEngine().search(
		getWorkspace(), 
		type, 
		REFERENCES, 
		getJavaSearchScope(), 
		resultCollector);
	assertEquals(
		"src/b7/X.java b7.Test.main(String[]) -> void [SubClass]",
		resultCollector.toString());
}
/**
 * Type reference in a throw clause test.
 * (Regression test for bug 6779 searchDeclarationsOfReferencedTyped - missing exception types)
 */
public void testTypeReferenceInThrows() throws JavaModelException, CoreException {
	IType type = getCompilationUnit("JavaSearch", "src", "a7", "X.java").getType("MyException");
	JavaSearchResultCollector resultCollector = new JavaSearchResultCollector();
	resultCollector.showAccuracy = true;
	new SearchEngine().search(
		getWorkspace(), 
		type, 
		REFERENCES, 
		getJavaSearchScope(), 
		resultCollector);
	assertEquals(
		"src/a7/X.java a7.X.foo() -> void [MyException] EXACT_MATCH",
		resultCollector.toString());
}
/**
 * Type reference test (not case sensitive)
 */
public void testTypeReferenceNotCaseSensitive() throws JavaModelException, CoreException {
	IPackageFragment pkg = getPackageFragment("JavaSearch", "src", "d4");
	IJavaSearchScope scope = SearchEngine.createJavaSearchScope(new IJavaElement[] {pkg});
	ISearchPattern pattern = SearchEngine.createSearchPattern("Y", TYPE, REFERENCES, false);
	JavaSearchResultCollector resultCollector = new JavaSearchResultCollector();
	new SearchEngine().search(
		getWorkspace(), 
		pattern, 
		scope,
		resultCollector);
	assertEquals(
		"src/d4/X.java d4.X.foo() -> Object [Y]",
		resultCollector.toString());
}
/**
 * Type reference in a folder that is not in the classpath.
 * (regression test for PR #1G5N8KS)
 */
public void testTypeReferenceNotInClasspath() throws JavaModelException, CoreException {
	IType type = getCompilationUnit("JavaSearch", "src", "p", "X.java").getType("X");
	JavaSearchResultCollector resultCollector = new JavaSearchResultCollector();
	new SearchEngine().search(
		getWorkspace(), 
		type, 
		REFERENCES, 
		getJavaSearchScope(), 
		resultCollector);
	assertEquals(
		"src/p/A.java p.A.x [X]\n" +
		"src/p/A.java p.A(X) [X]\n" +
		"src/p/A.java p.A.foo(int, String, X) -> void [X]\n" +
		"src/p/X.java p.X() [X]\n" +
		"src/p/X.java p.X.foo(int, String, X) -> void [X]\n" +
		"src/p/Y.java p.Y [X]\n" +
		"src/p/Z.java p.Z.foo(int, String, X) -> void [X]",
		resultCollector.toString());
}
/**
 * Type reference with recovery test.
 * (Regression test for bug 29366 Search reporting invalid inaccurate match )
 */
public void testTypeReferenceWithRecovery() throws JavaModelException, CoreException {
	IType type = getCompilationUnit("JavaSearch", "src", "e1", "A29366.java").getType("A29366");
	JavaSearchResultCollector resultCollector = new JavaSearchResultCollector();
	resultCollector.showAccuracy = true;
	new SearchEngine().search(
		getWorkspace(), 
		type, 
		REFERENCES, 
		getJavaSearchScope(), 
		resultCollector);
	assertEquals(
		"src/e1/A29366.java e1.A29366.foo() -> void [A29366] EXACT_MATCH",
		resultCollector.toString());
}
/**
 * Negative type reference test.
 * (regression test for 1G52F7P: ITPJCORE:WINNT - Search - finds bogus references to class)
 */
public void testNegativeTypeReference() throws JavaModelException, CoreException {
	IType type = getCompilationUnit("JavaSearch", "src", "p7", "A.java").getType("A");
	JavaSearchResultCollector resultCollector = new JavaSearchResultCollector();
	new SearchEngine().search(
		getWorkspace(), 
		type, 
		REFERENCES, 
		getJavaSearchScope(), 
		resultCollector);
	assertEquals(
		"",
		resultCollector.toString());
}

/**
 * Various package declarations test.
 */
public void testVariousPackageDeclarations() throws JavaModelException, CoreException {
	JavaSearchResultCollector resultCollector = new JavaSearchResultCollector();
	new SearchEngine().search(
		getWorkspace(), 
		"p3*",
		PACKAGE, 
		DECLARATIONS, 
		getJavaSearchScope(), 
		resultCollector);
	assertEquals(
		"src/p3 p3\n" +
		"src/p3/p2/p p3.p2.p", 
		resultCollector.toString());
}
/**
 * Various package reference test.
 */
public void testVariousPackageReference() throws JavaModelException, CoreException {
	IPackageFragment pkg = getPackageFragment("JavaSearch", "src", "p3.p2.p");
	JavaSearchResultCollector resultCollector = new JavaSearchResultCollector();
	new SearchEngine().search(
		getWorkspace(), 
		pkg, 
		REFERENCES, 
		getJavaSearchScope(), 
		resultCollector);
	assertEquals(
		"src/PackageReference/A.java [p3.p2.p]\n" +
		"src/PackageReference/B.java [p3.p2.p]\n" +
		"src/PackageReference/C.java PackageReference.C [p3.p2.p]\n" +
		"src/PackageReference/D.java PackageReference.D.x [p3.p2.p]\n" +
		"src/PackageReference/E.java PackageReference.E.x [p3.p2.p]\n" +
		"src/PackageReference/F.java PackageReference.F.foo() -> p3.p2.p.X [p3.p2.p]\n" +
		"src/PackageReference/G.java PackageReference.G.foo(p3.p2.p.X) -> void [p3.p2.p]\n" +
		"src/PackageReference/H.java PackageReference.H.foo() -> void [p3.p2.p]\n" +
		"src/PackageReference/I.java PackageReference.I.foo() -> void [p3.p2.p]\n" +
		"src/PackageReference/J.java PackageReference.J.foo() -> void [p3.p2.p]", 
		resultCollector.toString());
}
/**
 * Type reference inside an argument, a return type or a field type.
 * (Regression test for PR #1GA7QA1)
 */
public void testVariousTypeReferences() throws JavaModelException, CoreException {
	IType type = getCompilationUnit("JavaSearch", "src", "NoReference", "A.java").getType("A");
	JavaSearchResultCollector resultCollector = new JavaSearchResultCollector();
	new SearchEngine().search(
		getWorkspace(), 
		type, 
		REFERENCES, 
		getJavaSearchScope(), 
		resultCollector);
	assertEquals(
		"", // no reference should be found
		resultCollector.toString());
}
/**
 * Write access reference in a qualified name reference test.
 * (regression test for bug 7344 Search - write acces give wrong result)
 */
public void testReadWriteAccessInQualifiedNameReference() throws JavaModelException, CoreException {
	IType type = getCompilationUnit("JavaSearch", "src", "a8", "A.java").getType("A");
	IField field = type.getField("a");
	JavaSearchResultCollector resultCollector = new JavaSearchResultCollector();
	
	resultCollector = new JavaSearchResultCollector();
	new SearchEngine().search(
		getWorkspace(), 
		field, 
		WRITE_ACCESSES, 
		getJavaSearchScope(), 
		resultCollector);
	assertEquals(
		"", 
		resultCollector.toString());
		
}
}