core/tests/org.eclipse.dltk.core.tests/src/org/eclipse/dltk/core/tests/model/AbstractDLTKSearchTests.java - dltk/org.eclipse.dltk.core - Git at Google

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

 import java.io.File;
 import java.io.IOException;
 import java.util.ArrayList;
 import java.util.List;

 import org.eclipse.core.resources.IFile;
 import org.eclipse.core.resources.IProject;
 import org.eclipse.core.resources.IResource;
 import org.eclipse.core.runtime.CoreException;
 import org.eclipse.core.runtime.IPath;
 import org.eclipse.core.runtime.Path;
 import org.eclipse.dltk.compiler.CharOperation;
 import org.eclipse.dltk.core.DLTKLanguageManager;
 import org.eclipse.dltk.core.IField;
 import org.eclipse.dltk.core.IMethod;
 import org.eclipse.dltk.core.IModelElement;
 import org.eclipse.dltk.core.IProjectFragment;
 import org.eclipse.dltk.core.IScriptFolder;
 import org.eclipse.dltk.core.IScriptProject;
 import org.eclipse.dltk.core.IScriptProjectFilenames;
 import org.eclipse.dltk.core.ISourceModule;
 import org.eclipse.dltk.core.IType;
 import org.eclipse.dltk.core.ModelException;
 import org.eclipse.dltk.core.search.IDLTKSearchConstants;
 import org.eclipse.dltk.core.search.IDLTKSearchScope;
 import org.eclipse.dltk.core.search.MethodReferenceMatch;
 import org.eclipse.dltk.core.search.SearchEngine;
 import org.eclipse.dltk.core.search.SearchMatch;
 import org.eclipse.dltk.core.search.SearchParticipant;
 import org.eclipse.dltk.core.search.SearchPattern;
 import org.eclipse.dltk.core.search.SearchRequestor;
 import org.eclipse.dltk.internal.core.ScriptFolder;
 import org.eclipse.dltk.internal.core.SourceRefElement;
 import org.eclipse.dltk.internal.core.util.Util;

 /**
  * Abstract class for Script Search tests.
  */
 public class AbstractDLTKSearchTests extends AbstractModelTests
 		implements IDLTKSearchConstants, IScriptProjectFilenames {

 	public static List<?> JAVA_SEARCH_SUITES = null;
 	protected IScriptProject SCRIPT_PROJECT;
 	protected static boolean COPY_DIRS = true;
 	protected static int EXACT_RULE = SearchPattern.R_EXACT_MATCH
 			| SearchPattern.R_CASE_SENSITIVE;
 	protected static int EQUIVALENT_RULE = EXACT_RULE
 			| SearchPattern.R_EQUIVALENT_MATCH;
 	protected static int ERASURE_RULE = EXACT_RULE
 			| SearchPattern.R_ERASURE_MATCH;
 	protected static int RAW_RULE = EXACT_RULE | SearchPattern.R_ERASURE_MATCH
 			| SearchPattern.R_EQUIVALENT_MATCH;

 	// ISourceModule[] workingCopies;
 	// boolean discard;

 	/**
 	 * Collects results as a string.
 	 */
 	public static class DLTKSearchResultCollector extends SearchRequestor {
 		protected SearchMatch match;
 		public StringBuffer results = new StringBuffer(), line;
 		public boolean showAccuracy;
 		public boolean showContext;
 		public boolean showRule;
 		public boolean showInsideDoc;
 		public boolean showPotential = true;
 		public boolean showProject;
 		public boolean showSynthetic;
 		public int count = 0;

 		@Override
 		public void acceptSearchMatch(SearchMatch searchMatch)
 				throws CoreException {
 			count++;
 			this.match = searchMatch;
 			writeLine();
 			writeLineToResult();
 		}

 		protected void writeLineToResult() {
 			if (match.getAccuracy() == SearchMatch.A_ACCURATE
 					|| showPotential) {
 				if (results.length() > 0)
 					results.append("\n");
 				results.append(line);
 			}
 		}

 		protected void writeLine() throws CoreException {
 			try {
 				IResource resource = match.getResource();
 				IModelElement element = getElement(match);
 				line = new StringBuffer(getPathString(resource, element));
 				if (this.showProject) {
 					IProject project = element.getScriptProject().getProject();
 					line.append(" [in ");
 					line.append(project.getName());
 					line.append("]");
 				}
 				ISourceModule unit = null;
 				if (element instanceof IMethod) {
 					line.append(" ");
 					IMethod method = (IMethod) element;
 					append(method);
 					unit = method.getSourceModule();
 				} else if (element instanceof IType) {
 					line.append(" ");
 					IType type = (IType) element;
 					append(type);
 					unit = type.getSourceModule();
 				} else if (element instanceof IField) {
 					line.append(" ");
 					IField field = (IField) element;
 					append(field);
 					unit = field.getSourceModule();
 				} else if (element instanceof IScriptFolder) {
 					line.append(" ");
 					append((IScriptFolder) element);
 				}
 				// else if (element instanceof IImportDeclaration) {
 				// IImportDeclaration importDeclaration =
 				// (IImportDeclaration)element;
 				// unit =
 				// (ISourceModule)importDeclaration.getAncestor(IModelElement.COMPILATION_UNIT);
 				// } else if (element instanceof IPackageDeclaration) {
 				// IPackageDeclaration packageDeclaration =
 				// (IPackageDeclaration)element;
 				// unit =
 				// (ISourceModule)packageDeclaration.getAncestor(IModelElement.COMPILATION_UNIT);
 				// }
 				if (resource instanceof IFile) {
 					char[] contents = getSource(resource, element, unit);
 					int start = match.getOffset();
 					int end = start + match.getLength();
 					if (start == -1
 							|| (contents != null && contents.length > 0)) { // retrieving
 						// attached
 						// source
 						// not
 						// implemented
 						// here
 						line.append(" [");
 						if (start > -1) {
 							if (this.showContext) {
 								int lineStart1 = CharOperation.lastIndexOf('\n',
 										contents, 0, start);
 								int lineStart2 = CharOperation.lastIndexOf('\r',
 										contents, 0, start);
 								int lineStart = Math.max(lineStart1, lineStart2)
 										+ 1;
 								line.append(CharOperation.subarray(contents,
 										lineStart, start));
 								line.append("<");
 							}
 							line.append(CharOperation.subarray(contents, start,
 									end));
 							if (this.showContext) {
 								line.append(">");
 								int lineEnd1 = CharOperation.indexOf('\n',
 										contents, end);
 								int lineEnd2 = CharOperation.indexOf('\r',
 										contents, end);
 								int lineEnd = lineEnd1 > 0 && lineEnd2 > 0
 										? Math.min(lineEnd1, lineEnd2)
 										: Math.max(lineEnd1, lineEnd2);
 								if (lineEnd == -1)
 									lineEnd = contents.length;
 								line.append(CharOperation.subarray(contents,
 										end, lineEnd));
 							}
 						} else {
 							line.append("No source");
 						}
 						line.append("]");
 					}
 				}
 				if (this.showAccuracy) {
 					line.append(" ");
 					if (match.getAccuracy() == SearchMatch.A_ACCURATE) {
 						if (this.showRule) {
 							if (match.isExact()) {
 								line.append("EXACT_");
 							} else if (match.isEquivalent()) {
 								line.append("EQUIVALENT_");
 							} else if (match.isErasure()) {
 								line.append("ERASURE_");
 							} else {
 								line.append("INVALID_RULE_");
 							}
 							if (match.isRaw()) {
 								line.append("RAW_");
 							}
 						} else {
 							line.append("EXACT_");
 						}
 						line.append("MATCH");
 					} else {
 						line.append("POTENTIAL_MATCH");
 					}
 				}
 				if (this.showInsideDoc) {
 					line.append(" ");
 					if (match.isInsideDocComment()) {
 						line.append("INSIDE_JAVADOC");
 					} else {
 						line.append("OUTSIDE_JAVADOC");
 					}
 				}
 				if (this.showSynthetic) {
 					if (match instanceof MethodReferenceMatch) {
 						MethodReferenceMatch methRef = (MethodReferenceMatch) match;
 						if (methRef.isSynthetic()) {
 							line.append(" SYNTHETIC");
 						}
 					}
 				}
 			} catch (ModelException e) {
 				results.append("\n");
 				results.append(e.toString());
 			}
 		}

 		protected void append(IField field) throws ModelException {
 			IType type = field.getDeclaringType();
 			if (type != null) {
 				append(type);
 				line.append("$");
 			}
 			line.append(field.getElementName());
 		}

 		private void append(IMethod method) throws ModelException {
 			if (!method.isConstructor()) {
 				// line.append(Signature.toString(method.getReturnType()));
 				line.append(" ");
 			}
 			append(method.getDeclaringType());
 			if (!method.isConstructor()) {
 				line.append("$");
 				line.append(method.getElementName());
 			}
 			line.append("(");
 			String[] parameters = method.getParameterNames();
 			for (int i = 0, length = parameters.length; i < length; i++) {
 				if (i < length - 1) {
 					// line.append(Signature.toString(parameters[i]));
 					line.append(parameters[i]);
 					line.append(", "); //$NON-NLS-1$
 				} else {
 					// line.append(Signature.toString(parameters[i]));
 					line.append(parameters[i]);
 				}
 			}
 			line.append(")");
 		}

 		private void append(IScriptFolder pkg) {
 			line.append(pkg.getElementName());
 		}

 		private void append(IType type) throws ModelException {
 			if (type == null) {
 				return;
 			}
 			IModelElement parent = type.getParent();
 			boolean isLocal = false;
 			switch (parent.getElementType()) {
 			case IModelElement.SOURCE_MODULE:
 				IScriptFolder pkg = type.getScriptFolder();
 				append(pkg);
 				if (!pkg.getElementName()
 						.equals(IScriptFolder.DEFAULT_FOLDER_NAME)) {
 					line.append(IScriptFolder.PACKAGE_DELIMITER);
 				}
 				break;
 			case IModelElement.TYPE:
 				append((IType) parent);
 				line.append("$");
 				break;
 			case IModelElement.FIELD:
 				append((IField) parent);
 				isLocal = true;
 				break;
 			case IModelElement.METHOD:
 				append((IMethod) parent);
 				isLocal = true;
 				break;
 			}
 			if (isLocal) {
 				line.append(":");
 			}
 			String typeName = type.getElementName();
 			if (typeName.length() == 0) {
 				line.append("<anonymous>");
 			} else {
 				line.append(typeName);
 			}
 			if (isLocal) {
 				line.append("#");
 				line.append(((SourceRefElement) type).occurrenceCount);
 			}
 		}

 		protected IModelElement getElement(SearchMatch searchMatch) {
 			return (IModelElement) searchMatch.getElement();
 		}

 		protected String getPathString(IResource resource,
 				IModelElement element) {
 			String pathString;
 			if (resource != null) {
 				IPath path = resource.getProjectRelativePath();
 				if (path.segmentCount() == 0) {
 					IModelElement root = element;
 					while (root != null
 							&& !(root instanceof IProjectFragment)) {
 						root = root.getParent();
 					}
 					if (root != null) {
 						IProjectFragment pkgFragmentRoot = (IProjectFragment) root;
 						if (pkgFragmentRoot.isExternal()) {
 							pathString = pkgFragmentRoot.getPath().toOSString();
 						} else {
 							pathString = pkgFragmentRoot.getPath().toString();
 						}
 					} else {
 						pathString = "";
 					}
 				} else {
 					pathString = path.toString();
 				}
 			} else {
 				pathString = element.getPath().toString();
 			}
 			return pathString;
 		}

 		protected char[] getSource(IResource resource, IModelElement element,
 				ISourceModule unit) throws CoreException {
 			char[] contents = CharOperation.NO_CHAR;
 			if (Util.isValidSourceModule(resource) && element != null) {
 				ISourceModule cu = (ISourceModule) element
 						.getAncestor(IModelElement.SOURCE_MODULE);
 				if (cu != null && cu.isWorkingCopy()) {
 					// working copy
 					contents = unit.getBuffer().getCharacters();
 				}
 			}
 			return contents;
 		}

 		@Override
 		public String toString() {
 			return results.toString();
 		}
 	}

 	protected DLTKSearchResultCollector resultCollector;

 	public AbstractDLTKSearchTests(String pluginName, String name) {
 		this(pluginName, name, 2);
 	}

 	public AbstractDLTKSearchTests(String pluginName, String name, int tabs) {
 		super(pluginName, name);
 		this.displayName = true;
 		this.tabs = tabs;
 	}

 	protected void assertSearchResults(String expected) {
 		assertSearchResults(expected, resultCollector);
 	}

 	protected void assertSearchResults(String expected,
 			DLTKSearchResultCollector collector) {
 		assertSearchResults("Unexpected search results", expected, collector);
 	}

 	protected void assertSearchResults(String message, String expected,
 			DLTKSearchResultCollector collector) {
 		String actual = collector.toString();
 		if (!expected.equals(actual)) {
 			if (this.displayName) {
 				System.out.print(getName());
 				System.out.print(" got ");
 				if (collector.count == 0)
 					System.out.println("no result!");
 				else {
 					System.out.print(collector.count);
 					System.out.print(" result");
 					if (collector.count == 1)
 						System.out.println(":");
 					else
 						System.out.println("s:");
 				}
 			}
 			if (!displayName || collector.count > 0) {
 				System.out.print(actual);
 				System.out.println(this.endChar);
 			}
 			if (this.workingCopies != null) {
 				int length = this.workingCopies.length;
 				String[] sources = new String[length * 2];
 				for (int i = 0; i < length; i++) {
 					sources[i * 2] = this.workingCopies[i].getPath().toString();
 					try {
 						sources[i * 2 + 1] = this.workingCopies[i].getSource();
 					} catch (ModelException e) {
 						// ignore
 					}
 				}
 				System.out.println(
 						"--------------------------------------------------------------------------------");
 				for (int i = 0; i < length; i += 2) {
 					System.out.println(sources[i]);
 					System.out.println(sources[i + 1]);
 				}
 			}
 		}
 		assertEquals(message, expected, actual);
 	}

 	@Override
 	protected void copyDirectory(File sourceDir, File targetDir)
 			throws IOException {
 		if (COPY_DIRS) {
 			super.copyDirectory(sourceDir, targetDir);
 		} else {
 			targetDir.mkdirs();
 			File sourceFile = new File(sourceDir, PROJECT_FILENAME);
 			File targetFile = new File(targetDir, PROJECT_FILENAME);
 			targetFile.createNewFile();
 			copy(sourceFile, targetFile);
 			sourceFile = new File(sourceDir, BUILDPATH_FILENAME);
 			targetFile = new File(targetDir, BUILDPATH_FILENAME);
 			targetFile.createNewFile();
 			copy(sourceFile, targetFile);
 		}
 	}

 	protected IDLTKSearchScope getSearchScope(String project) {
 		return SearchEngine.createSearchScope(getScriptProject(project));
 	}

 	protected IDLTKSearchScope getSearchScope(IModelElement element) {
 		return SearchEngine.createSearchScope(element);
 	}

 	protected IDLTKSearchScope getScriptSearchPackageScope(String projectName,
 			String packageName, boolean addSubpackages) throws ModelException {
 		IScriptFolder fragment = getScriptFolder(projectName, "src",
 				new Path(packageName));
 		if (fragment == null)
 			return null;
 		IModelElement[] searchPackages = null;
 		if (addSubpackages) {
 			// Create list of package with first found one
 			List<IScriptFolder> packages = new ArrayList<>();
 			packages.add(fragment);
 			// Add all possible subpackages
 			IModelElement[] children = ((IProjectFragment) fragment.getParent())
 					.getChildren();
 			String[] names = ((ScriptFolder) fragment).getRelativePath()
 					.segments();
 			int namesLength = names.length;
 			nextPackage: for (int i = 0, length = children.length; i < length; i++) {
 				ScriptFolder currentPackage = (ScriptFolder) children[i];
 				String[] otherNames = currentPackage.getRelativePath()
 						.segments();
 				if (otherNames.length <= namesLength)
 					continue nextPackage;
 				for (int j = 0; j < namesLength; j++) {
 					if (!names[j].equals(otherNames[j]))
 						continue nextPackage;
 				}
 				packages.add(currentPackage);
 			}
 			searchPackages = new IModelElement[packages.size()];
 			packages.toArray(searchPackages);
 		} else {
 			searchPackages = new IModelElement[1];
 			searchPackages[0] = fragment;
 		}
 		return SearchEngine.createSearchScope(searchPackages,
 				DLTKLanguageManager
 						.getLanguageToolkit(getScriptProject(projectName)));
 	}

 	IDLTKSearchScope getScriptSearchCUScope(String projectName,
 			String packageName, String cuName) throws ModelException {
 		ISourceModule cu = getSourceModule(projectName, "src",
 				new Path(packageName).append(cuName));
 		return SearchEngine.createSearchScope(cu);
 	}

 	protected void search(IModelElement element, int limitTo,
 			IDLTKSearchScope scope) throws CoreException {
 		search(element, limitTo, EXACT_RULE, scope, resultCollector);
 	}

 	IDLTKSearchScope getSearchWorkingCopiesScope(ISourceModule workingCopy)
 			throws ModelException {
 		return SearchEngine.createSearchScope(workingCopy);
 	}

 	// IDLTKSearchScope getSearchWorkingCopiesScope() throws ModelException {
 	// return SearchEngine.createSearchScope(this.workingCopies);
 	// }

 	protected void search(IModelElement element, int limitTo, int matchRule,
 			IDLTKSearchScope scope) throws CoreException {
 		search(element, limitTo, matchRule, scope, resultCollector);
 	}

 	protected void search(IModelElement element, int limitTo, int matchRule,
 			IDLTKSearchScope scope, SearchRequestor requestor)
 			throws CoreException {
 		SearchPattern pattern = SearchPattern.createPattern(element, limitTo,
 				matchRule, scope.getLanguageToolkit());
 		assertNotNull("Pattern should not be null", pattern);
 		new SearchEngine().search(pattern,
 				new SearchParticipant[] {
 						SearchEngine.getDefaultSearchParticipant() },
 				scope, requestor, null);
 	}

 	protected void search(SearchPattern searchPattern, IDLTKSearchScope scope,
 			SearchRequestor requestor) throws CoreException {
 		new SearchEngine().search(searchPattern,
 				new SearchParticipant[] {
 						SearchEngine.getDefaultSearchParticipant() },
 				scope, requestor, null);
 	}

 	protected void search(String patternString, int searchFor, int limitTo,
 			IDLTKSearchScope scope) throws CoreException {
 		search(patternString, searchFor, limitTo, EXACT_RULE, scope,
 				resultCollector);
 	}

 	protected void search(String patternString, int searchFor, int limitTo,
 			int matchRule, IDLTKSearchScope scope) throws CoreException {
 		search(patternString, searchFor, limitTo, matchRule, scope,
 				resultCollector);
 	}

 	protected void search(String patternString, int searchFor, int limitTo,
 			int matchRule, IDLTKSearchScope scope, SearchRequestor requestor)
 			throws CoreException {
 		if (patternString.indexOf('*') != -1
 				|| patternString.indexOf('?') != -1) {
 			matchRule |= SearchPattern.R_PATTERN_MATCH;
 		}
 		SearchPattern pattern = SearchPattern.createPattern(patternString,
 				searchFor, limitTo, matchRule, scope.getLanguageToolkit());
 		assertNotNull("Pattern should not be null", pattern);
 		new SearchEngine().search(pattern,
 				new SearchParticipant[] {
 						SearchEngine.getDefaultSearchParticipant() },
 				scope, requestor, null);
 	}

 	// Search for sources only.
 	protected List<?> searchSourceOnly(IModelElement element, int limitTo,
 			int matchRule, IDLTKSearchScope scope) throws CoreException {
 		SearchPattern pattern = SearchPattern.createPattern(element, limitTo,
 				matchRule, scope.getLanguageToolkit());
 		assertNotNull("Pattern should not be null", pattern);
 		return new SearchEngine().searchSourceOnly(pattern,
 				new SearchParticipant[] {
 						SearchEngine.getDefaultSearchParticipant() },
 				scope, null);
 	}

 	protected List<?> searchSourceOnly(SearchPattern searchPattern,
 			IDLTKSearchScope scope) throws CoreException {
 		return new SearchEngine().searchSourceOnly(searchPattern,
 				new SearchParticipant[] {
 						SearchEngine.getDefaultSearchParticipant() },
 				scope, null);
 	}

 	protected List<?> searchSourceOnly(String patternString, int searchFor,
 			int limitTo, IDLTKSearchScope scope) throws CoreException {
 		return searchSourceOnly(patternString, searchFor, limitTo, EXACT_RULE,
 				scope);
 	}

 	protected List<?> searchSourceOnly(String patternString, int searchFor,
 			int limitTo, int matchRule, IDLTKSearchScope scope)
 			throws CoreException {
 		if (patternString.indexOf('*') != -1
 				|| patternString.indexOf('?') != -1) {
 			matchRule |= SearchPattern.R_PATTERN_MATCH;
 		}
 		SearchPattern pattern = SearchPattern.createPattern(patternString,
 				searchFor, limitTo, matchRule, scope.getLanguageToolkit());
 		assertNotNull("Pattern should not be null", pattern);
 		return new SearchEngine().searchSourceOnly(pattern,
 				new SearchParticipant[] {
 						SearchEngine.getDefaultSearchParticipant() },
 				scope, null);
 	}

 	// /
 	protected void searchDeclarationsOfAccessedFields(
 			IModelElement enclosingElement, SearchRequestor requestor)
 			throws ModelException {
 		new SearchEngine().searchDeclarationsOfAccessedFields(enclosingElement,
 				requestor, null);
 	}

 	protected void searchDeclarationsOfReferencedTypes(
 			IModelElement enclosingElement, SearchRequestor requestor)
 			throws ModelException {
 		new SearchEngine().searchDeclarationsOfReferencedTypes(enclosingElement,
 				requestor, null);
 	}

 	protected void searchDeclarationsOfSentMessages(
 			IModelElement enclosingElement, SearchRequestor requestor)
 			throws ModelException {
 		new SearchEngine().searchDeclarationsOfSentMessages(enclosingElement,
 				requestor, null);
 	}

 	@Override
 	protected void setUp() throws Exception {
 		super.setUp();
 		this.resultCollector = new DLTKSearchResultCollector();
 	}
 }
	/*******************************************************************************
	* Copyright (c) 2000, 2017 IBM Corporation and others.
	* All rights reserved. This program and the accompanying materials
	* are made available under the terms of the Eclipse Public License v1.0
	* which accompanies this distribution, and is available at
	* http://www.eclipse.org/legal/epl-v10.html
	*
	*******************************************************************************/
	package org.eclipse.dltk.core.tests.model;

	import java.io.File;
	import java.io.IOException;
	import java.util.ArrayList;
	import java.util.List;

	import org.eclipse.core.resources.IFile;
	import org.eclipse.core.resources.IProject;
	import org.eclipse.core.resources.IResource;
	import org.eclipse.core.runtime.CoreException;
	import org.eclipse.core.runtime.IPath;
	import org.eclipse.core.runtime.Path;
	import org.eclipse.dltk.compiler.CharOperation;
	import org.eclipse.dltk.core.DLTKLanguageManager;
	import org.eclipse.dltk.core.IField;
	import org.eclipse.dltk.core.IMethod;
	import org.eclipse.dltk.core.IModelElement;
	import org.eclipse.dltk.core.IProjectFragment;
	import org.eclipse.dltk.core.IScriptFolder;
	import org.eclipse.dltk.core.IScriptProject;
	import org.eclipse.dltk.core.IScriptProjectFilenames;
	import org.eclipse.dltk.core.ISourceModule;
	import org.eclipse.dltk.core.IType;
	import org.eclipse.dltk.core.ModelException;
	import org.eclipse.dltk.core.search.IDLTKSearchConstants;
	import org.eclipse.dltk.core.search.IDLTKSearchScope;
	import org.eclipse.dltk.core.search.MethodReferenceMatch;
	import org.eclipse.dltk.core.search.SearchEngine;
	import org.eclipse.dltk.core.search.SearchMatch;
	import org.eclipse.dltk.core.search.SearchParticipant;
	import org.eclipse.dltk.core.search.SearchPattern;
	import org.eclipse.dltk.core.search.SearchRequestor;
	import org.eclipse.dltk.internal.core.ScriptFolder;
	import org.eclipse.dltk.internal.core.SourceRefElement;
	import org.eclipse.dltk.internal.core.util.Util;

	/**
	* Abstract class for Script Search tests.
	*/
	public class AbstractDLTKSearchTests extends AbstractModelTests
	implements IDLTKSearchConstants, IScriptProjectFilenames {

	public static List<?> JAVA_SEARCH_SUITES = null;
	protected IScriptProject SCRIPT_PROJECT;
	protected static boolean COPY_DIRS = true;
	protected static int EXACT_RULE = SearchPattern.R_EXACT_MATCH
	\| SearchPattern.R_CASE_SENSITIVE;
	protected static int EQUIVALENT_RULE = EXACT_RULE
	\| SearchPattern.R_EQUIVALENT_MATCH;
	protected static int ERASURE_RULE = EXACT_RULE
	\| SearchPattern.R_ERASURE_MATCH;
	protected static int RAW_RULE = EXACT_RULE \| SearchPattern.R_ERASURE_MATCH
	\| SearchPattern.R_EQUIVALENT_MATCH;

	// ISourceModule[] workingCopies;
	// boolean discard;

	/**
	* Collects results as a string.
	*/
	public static class DLTKSearchResultCollector extends SearchRequestor {
	protected SearchMatch match;
	public StringBuffer results = new StringBuffer(), line;
	public boolean showAccuracy;
	public boolean showContext;
	public boolean showRule;
	public boolean showInsideDoc;
	public boolean showPotential = true;
	public boolean showProject;
	public boolean showSynthetic;
	public int count = 0;

	@Override
	public void acceptSearchMatch(SearchMatch searchMatch)
	throws CoreException {
	count++;
	this.match = searchMatch;
	writeLine();
	writeLineToResult();
	}

	protected void writeLineToResult() {
	if (match.getAccuracy() == SearchMatch.A_ACCURATE
	\|\| showPotential) {
	if (results.length() > 0)
	results.append("\n");
	results.append(line);
	}
	}

	protected void writeLine() throws CoreException {
	try {
	IResource resource = match.getResource();
	IModelElement element = getElement(match);
	line = new StringBuffer(getPathString(resource, element));
	if (this.showProject) {
	IProject project = element.getScriptProject().getProject();
	line.append(" [in ");
	line.append(project.getName());
	line.append("]");
	}
	ISourceModule unit = null;
	if (element instanceof IMethod) {
	line.append(" ");
	IMethod method = (IMethod) element;
	append(method);
	unit = method.getSourceModule();
	} else if (element instanceof IType) {
	line.append(" ");
	IType type = (IType) element;
	append(type);
	unit = type.getSourceModule();
	} else if (element instanceof IField) {
	line.append(" ");
	IField field = (IField) element;
	append(field);
	unit = field.getSourceModule();
	} else if (element instanceof IScriptFolder) {
	line.append(" ");
	append((IScriptFolder) element);
	}
	// else if (element instanceof IImportDeclaration) {
	// IImportDeclaration importDeclaration =
	// (IImportDeclaration)element;
	// unit =
	// (ISourceModule)importDeclaration.getAncestor(IModelElement.COMPILATION_UNIT);
	// } else if (element instanceof IPackageDeclaration) {
	// IPackageDeclaration packageDeclaration =
	// (IPackageDeclaration)element;
	// unit =
	// (ISourceModule)packageDeclaration.getAncestor(IModelElement.COMPILATION_UNIT);
	// }
	if (resource instanceof IFile) {
	char[] contents = getSource(resource, element, unit);
	int start = match.getOffset();
	int end = start + match.getLength();
	if (start == -1
	\|\| (contents != null && contents.length > 0)) { // retrieving
	// attached
	// source
	// not
	// implemented
	// here
	line.append(" [");
	if (start > -1) {
	if (this.showContext) {
	int lineStart1 = CharOperation.lastIndexOf('\n',
	contents, 0, start);
	int lineStart2 = CharOperation.lastIndexOf('\r',
	contents, 0, start);
	int lineStart = Math.max(lineStart1, lineStart2)
	+ 1;
	line.append(CharOperation.subarray(contents,
	lineStart, start));
	line.append("<");
	}
	line.append(CharOperation.subarray(contents, start,
	end));
	if (this.showContext) {
	line.append(">");
	int lineEnd1 = CharOperation.indexOf('\n',
	contents, end);
	int lineEnd2 = CharOperation.indexOf('\r',
	contents, end);
	int lineEnd = lineEnd1 > 0 && lineEnd2 > 0
	? Math.min(lineEnd1, lineEnd2)
	: Math.max(lineEnd1, lineEnd2);
	if (lineEnd == -1)
	lineEnd = contents.length;
	line.append(CharOperation.subarray(contents,
	end, lineEnd));
	}
	} else {
	line.append("No source");
	}
	line.append("]");
	}
	}
	if (this.showAccuracy) {
	line.append(" ");
	if (match.getAccuracy() == SearchMatch.A_ACCURATE) {
	if (this.showRule) {
	if (match.isExact()) {
	line.append("EXACT_");
	} else if (match.isEquivalent()) {
	line.append("EQUIVALENT_");
	} else if (match.isErasure()) {
	line.append("ERASURE_");
	} else {
	line.append("INVALID_RULE_");
	}
	if (match.isRaw()) {
	line.append("RAW_");
	}
	} else {
	line.append("EXACT_");
	}
	line.append("MATCH");
	} else {
	line.append("POTENTIAL_MATCH");
	}
	}
	if (this.showInsideDoc) {
	line.append(" ");
	if (match.isInsideDocComment()) {
	line.append("INSIDE_JAVADOC");
	} else {
	line.append("OUTSIDE_JAVADOC");
	}
	}
	if (this.showSynthetic) {
	if (match instanceof MethodReferenceMatch) {
	MethodReferenceMatch methRef = (MethodReferenceMatch) match;
	if (methRef.isSynthetic()) {
	line.append(" SYNTHETIC");
	}
	}
	}
	} catch (ModelException e) {
	results.append("\n");
	results.append(e.toString());
	}
	}

	protected void append(IField field) throws ModelException {
	IType type = field.getDeclaringType();
	if (type != null) {
	append(type);
	line.append("$");
	}
	line.append(field.getElementName());
	}

	private void append(IMethod method) throws ModelException {
	if (!method.isConstructor()) {
	// line.append(Signature.toString(method.getReturnType()));
	line.append(" ");
	}
	append(method.getDeclaringType());
	if (!method.isConstructor()) {
	line.append("$");
	line.append(method.getElementName());
	}
	line.append("(");
	String[] parameters = method.getParameterNames();
	for (int i = 0, length = parameters.length; i < length; i++) {
	if (i < length - 1) {
	// line.append(Signature.toString(parameters[i]));
	line.append(parameters[i]);
	line.append(", "); //$NON-NLS-1$
	} else {
	// line.append(Signature.toString(parameters[i]));
	line.append(parameters[i]);
	}
	}
	line.append(")");
	}

	private void append(IScriptFolder pkg) {
	line.append(pkg.getElementName());
	}

	private void append(IType type) throws ModelException {
	if (type == null) {
	return;
	}
	IModelElement parent = type.getParent();
	boolean isLocal = false;
	switch (parent.getElementType()) {
	case IModelElement.SOURCE_MODULE:
	IScriptFolder pkg = type.getScriptFolder();
	append(pkg);
	if (!pkg.getElementName()
	.equals(IScriptFolder.DEFAULT_FOLDER_NAME)) {
	line.append(IScriptFolder.PACKAGE_DELIMITER);
	}
	break;
	case IModelElement.TYPE:
	append((IType) parent);
	line.append("$");
	break;
	case IModelElement.FIELD:
	append((IField) parent);
	isLocal = true;
	break;
	case IModelElement.METHOD:
	append((IMethod) parent);
	isLocal = true;
	break;
	}
	if (isLocal) {
	line.append(":");
	}
	String typeName = type.getElementName();
	if (typeName.length() == 0) {
	line.append("<anonymous>");
	} else {
	line.append(typeName);
	}
	if (isLocal) {
	line.append("#");
	line.append(((SourceRefElement) type).occurrenceCount);
	}
	}

	protected IModelElement getElement(SearchMatch searchMatch) {
	return (IModelElement) searchMatch.getElement();
	}

	protected String getPathString(IResource resource,
	IModelElement element) {
	String pathString;
	if (resource != null) {
	IPath path = resource.getProjectRelativePath();
	if (path.segmentCount() == 0) {
	IModelElement root = element;
	while (root != null
	&& !(root instanceof IProjectFragment)) {
	root = root.getParent();
	}
	if (root != null) {
	IProjectFragment pkgFragmentRoot = (IProjectFragment) root;
	if (pkgFragmentRoot.isExternal()) {
	pathString = pkgFragmentRoot.getPath().toOSString();
	} else {
	pathString = pkgFragmentRoot.getPath().toString();
	}
	} else {
	pathString = "";
	}
	} else {
	pathString = path.toString();
	}
	} else {
	pathString = element.getPath().toString();
	}
	return pathString;
	}

	protected char[] getSource(IResource resource, IModelElement element,
	ISourceModule unit) throws CoreException {
	char[] contents = CharOperation.NO_CHAR;
	if (Util.isValidSourceModule(resource) && element != null) {
	ISourceModule cu = (ISourceModule) element
	.getAncestor(IModelElement.SOURCE_MODULE);
	if (cu != null && cu.isWorkingCopy()) {
	// working copy
	contents = unit.getBuffer().getCharacters();
	}
	}
	return contents;
	}

	@Override
	public String toString() {
	return results.toString();
	}
	}

	protected DLTKSearchResultCollector resultCollector;

	public AbstractDLTKSearchTests(String pluginName, String name) {
	this(pluginName, name, 2);
	}

	public AbstractDLTKSearchTests(String pluginName, String name, int tabs) {
	super(pluginName, name);
	this.displayName = true;
	this.tabs = tabs;
	}

	protected void assertSearchResults(String expected) {
	assertSearchResults(expected, resultCollector);
	}

	protected void assertSearchResults(String expected,
	DLTKSearchResultCollector collector) {
	assertSearchResults("Unexpected search results", expected, collector);
	}

	protected void assertSearchResults(String message, String expected,
	DLTKSearchResultCollector collector) {
	String actual = collector.toString();
	if (!expected.equals(actual)) {
	if (this.displayName) {
	System.out.print(getName());
	System.out.print(" got ");
	if (collector.count == 0)
	System.out.println("no result!");
	else {
	System.out.print(collector.count);
	System.out.print(" result");
	if (collector.count == 1)
	System.out.println(":");
	else
	System.out.println("s:");
	}
	}
	if (!displayName \|\| collector.count > 0) {
	System.out.print(actual);
	System.out.println(this.endChar);
	}
	if (this.workingCopies != null) {
	int length = this.workingCopies.length;
	String[] sources = new String[length * 2];
	for (int i = 0; i < length; i++) {
	sources[i * 2] = this.workingCopies[i].getPath().toString();
	try {
	sources[i * 2 + 1] = this.workingCopies[i].getSource();
	} catch (ModelException e) {
	// ignore
	}
	}
	System.out.println(
	"--------------------------------------------------------------------------------");
	for (int i = 0; i < length; i += 2) {
	System.out.println(sources[i]);
	System.out.println(sources[i + 1]);
	}
	}
	}
	assertEquals(message, expected, actual);
	}

	@Override
	protected void copyDirectory(File sourceDir, File targetDir)
	throws IOException {
	if (COPY_DIRS) {
	super.copyDirectory(sourceDir, targetDir);
	} else {
	targetDir.mkdirs();
	File sourceFile = new File(sourceDir, PROJECT_FILENAME);
	File targetFile = new File(targetDir, PROJECT_FILENAME);
	targetFile.createNewFile();
	copy(sourceFile, targetFile);
	sourceFile = new File(sourceDir, BUILDPATH_FILENAME);
	targetFile = new File(targetDir, BUILDPATH_FILENAME);
	targetFile.createNewFile();
	copy(sourceFile, targetFile);
	}
	}

	protected IDLTKSearchScope getSearchScope(String project) {
	return SearchEngine.createSearchScope(getScriptProject(project));
	}

	protected IDLTKSearchScope getSearchScope(IModelElement element) {
	return SearchEngine.createSearchScope(element);
	}

	protected IDLTKSearchScope getScriptSearchPackageScope(String projectName,
	String packageName, boolean addSubpackages) throws ModelException {
	IScriptFolder fragment = getScriptFolder(projectName, "src",
	new Path(packageName));
	if (fragment == null)
	return null;
	IModelElement[] searchPackages = null;
	if (addSubpackages) {
	// Create list of package with first found one
	List<IScriptFolder> packages = new ArrayList<>();
	packages.add(fragment);
	// Add all possible subpackages
	IModelElement[] children = ((IProjectFragment) fragment.getParent())
	.getChildren();
	String[] names = ((ScriptFolder) fragment).getRelativePath()
	.segments();
	int namesLength = names.length;
	nextPackage: for (int i = 0, length = children.length; i < length; i++) {
	ScriptFolder currentPackage = (ScriptFolder) children[i];
	String[] otherNames = currentPackage.getRelativePath()
	.segments();
	if (otherNames.length <= namesLength)
	continue nextPackage;
	for (int j = 0; j < namesLength; j++) {
	if (!names[j].equals(otherNames[j]))
	continue nextPackage;
	}
	packages.add(currentPackage);
	}
	searchPackages = new IModelElement[packages.size()];
	packages.toArray(searchPackages);
	} else {
	searchPackages = new IModelElement[1];
	searchPackages[0] = fragment;
	}
	return SearchEngine.createSearchScope(searchPackages,
	DLTKLanguageManager
	.getLanguageToolkit(getScriptProject(projectName)));
	}

	IDLTKSearchScope getScriptSearchCUScope(String projectName,
	String packageName, String cuName) throws ModelException {
	ISourceModule cu = getSourceModule(projectName, "src",
	new Path(packageName).append(cuName));
	return SearchEngine.createSearchScope(cu);
	}

	protected void search(IModelElement element, int limitTo,
	IDLTKSearchScope scope) throws CoreException {
	search(element, limitTo, EXACT_RULE, scope, resultCollector);
	}

	IDLTKSearchScope getSearchWorkingCopiesScope(ISourceModule workingCopy)
	throws ModelException {
	return SearchEngine.createSearchScope(workingCopy);
	}

	// IDLTKSearchScope getSearchWorkingCopiesScope() throws ModelException {
	// return SearchEngine.createSearchScope(this.workingCopies);
	// }

	protected void search(IModelElement element, int limitTo, int matchRule,
	IDLTKSearchScope scope) throws CoreException {
	search(element, limitTo, matchRule, scope, resultCollector);
	}

	protected void search(IModelElement element, int limitTo, int matchRule,
	IDLTKSearchScope scope, SearchRequestor requestor)
	throws CoreException {
	SearchPattern pattern = SearchPattern.createPattern(element, limitTo,
	matchRule, scope.getLanguageToolkit());
	assertNotNull("Pattern should not be null", pattern);
	new SearchEngine().search(pattern,
	new SearchParticipant[] {
	SearchEngine.getDefaultSearchParticipant() },
	scope, requestor, null);
	}

	protected void search(SearchPattern searchPattern, IDLTKSearchScope scope,
	SearchRequestor requestor) throws CoreException {
	new SearchEngine().search(searchPattern,
	new SearchParticipant[] {
	SearchEngine.getDefaultSearchParticipant() },
	scope, requestor, null);
	}

	protected void search(String patternString, int searchFor, int limitTo,
	IDLTKSearchScope scope) throws CoreException {
	search(patternString, searchFor, limitTo, EXACT_RULE, scope,
	resultCollector);
	}

	protected void search(String patternString, int searchFor, int limitTo,
	int matchRule, IDLTKSearchScope scope) throws CoreException {
	search(patternString, searchFor, limitTo, matchRule, scope,
	resultCollector);
	}

	protected void search(String patternString, int searchFor, int limitTo,
	int matchRule, IDLTKSearchScope scope, SearchRequestor requestor)
	throws CoreException {
	if (patternString.indexOf('*') != -1
	\|\| patternString.indexOf('?') != -1) {
	matchRule \|= SearchPattern.R_PATTERN_MATCH;
	}
	SearchPattern pattern = SearchPattern.createPattern(patternString,
	searchFor, limitTo, matchRule, scope.getLanguageToolkit());
	assertNotNull("Pattern should not be null", pattern);
	new SearchEngine().search(pattern,
	new SearchParticipant[] {
	SearchEngine.getDefaultSearchParticipant() },
	scope, requestor, null);
	}

	// Search for sources only.
	protected List<?> searchSourceOnly(IModelElement element, int limitTo,
	int matchRule, IDLTKSearchScope scope) throws CoreException {
	SearchPattern pattern = SearchPattern.createPattern(element, limitTo,
	matchRule, scope.getLanguageToolkit());
	assertNotNull("Pattern should not be null", pattern);
	return new SearchEngine().searchSourceOnly(pattern,
	new SearchParticipant[] {
	SearchEngine.getDefaultSearchParticipant() },
	scope, null);
	}

	protected List<?> searchSourceOnly(SearchPattern searchPattern,
	IDLTKSearchScope scope) throws CoreException {
	return new SearchEngine().searchSourceOnly(searchPattern,
	new SearchParticipant[] {
	SearchEngine.getDefaultSearchParticipant() },
	scope, null);
	}

	protected List<?> searchSourceOnly(String patternString, int searchFor,
	int limitTo, IDLTKSearchScope scope) throws CoreException {
	return searchSourceOnly(patternString, searchFor, limitTo, EXACT_RULE,
	scope);
	}

	protected List<?> searchSourceOnly(String patternString, int searchFor,
	int limitTo, int matchRule, IDLTKSearchScope scope)
	throws CoreException {
	if (patternString.indexOf('*') != -1
	\|\| patternString.indexOf('?') != -1) {
	matchRule \|= SearchPattern.R_PATTERN_MATCH;
	}
	SearchPattern pattern = SearchPattern.createPattern(patternString,
	searchFor, limitTo, matchRule, scope.getLanguageToolkit());
	assertNotNull("Pattern should not be null", pattern);
	return new SearchEngine().searchSourceOnly(pattern,
	new SearchParticipant[] {
	SearchEngine.getDefaultSearchParticipant() },
	scope, null);
	}

	// /
	protected void searchDeclarationsOfAccessedFields(
	IModelElement enclosingElement, SearchRequestor requestor)
	throws ModelException {
	new SearchEngine().searchDeclarationsOfAccessedFields(enclosingElement,
	requestor, null);
	}

	protected void searchDeclarationsOfReferencedTypes(
	IModelElement enclosingElement, SearchRequestor requestor)
	throws ModelException {
	new SearchEngine().searchDeclarationsOfReferencedTypes(enclosingElement,
	requestor, null);
	}

	protected void searchDeclarationsOfSentMessages(
	IModelElement enclosingElement, SearchRequestor requestor)
	throws ModelException {
	new SearchEngine().searchDeclarationsOfSentMessages(enclosingElement,
	requestor, null);
	}

	@Override
	protected void setUp() throws Exception {
	super.setUp();
	this.resultCollector = new DLTKSearchResultCollector();
	}
	}