/*******************************************************************************
* Copyright (c) 2012 NumberFour AG
*
* 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
*
* Contributors:
* NumberFour AG - initial API and Implementation (Alex Panchenko)
*******************************************************************************/
package org.eclipse.dltk.core.tests;
import java.io.ByteArrayInputStream;
import java.io.UnsupportedEncodingException;
import org.eclipse.core.resources.IContainer;
import org.eclipse.core.resources.IFile;
import org.eclipse.core.resources.IFolder;
import org.eclipse.core.resources.IMarker;
import org.eclipse.core.resources.IProject;
import org.eclipse.core.resources.IResource;
import org.eclipse.core.resources.IWorkspace;
import org.eclipse.core.resources.IWorkspaceRoot;
import org.eclipse.core.resources.IncrementalProjectBuilder;
import org.eclipse.core.resources.ResourcesPlugin;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IPath;
import org.eclipse.core.runtime.Path;
import org.eclipse.dltk.annotations.Nullable;
import org.eclipse.dltk.core.DLTKCore;
import org.eclipse.dltk.core.IDLTKLanguageToolkit;
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.ISourceModule;
import org.eclipse.dltk.core.ModelException;
import org.eclipse.dltk.core.index2.search.ISearchEngine.SearchFor;
import org.eclipse.dltk.core.search.IDLTKSearchConstants;
import org.eclipse.dltk.core.search.IDLTKSearchScope;
import org.eclipse.dltk.core.search.SearchEngine;
import org.eclipse.dltk.core.search.SearchParticipant;
import org.eclipse.dltk.core.search.SearchPattern;
import org.eclipse.dltk.core.tests.ProjectSetup.Option;
import org.eclipse.dltk.core.tests.model.TestSearchResults;
import org.eclipse.dltk.internal.core.util.Util;
import org.eclipse.dltk.utils.ResourceUtil;
import org.eclipse.osgi.util.NLS;
import org.junit.Assert;
import org.junit.rules.ExternalResource;
public abstract class AbstractProjectSetup extends ExternalResource {
protected boolean isVerbose() {
return false;
}
public abstract IProject get();
public abstract String getProjectName();
/**
* Returns this project as {@link IScriptProject}
*/
public IScriptProject getScriptProject() {
return DLTKCore.create(get());
}
/**
* Returns the specified folder from this project.
*/
public IFolder getFolder(String name) {
return get().getFolder(name);
}
/**
* Returns the specified file from this project.
*/
public IFile getFile(String name) {
return get().getFile(name);
}
/**
* Returns the specified file from this project.
*/
public IFile getFile(IPath path) {
return get().getFile(path);
}
/**
* Returns the specified package fragment root in this project, or
* <code>null</code> if it does not exist. If relative, the rootPath must be
* specified as a project relative path. The empty path refers to the
* package fragment root that is the project folder iteslf. If absolute, the
* rootPath refers to either an external zip, or a resource internal to the
* workspace
*/
public IProjectFragment getProjectFragment(String fragmentPath)
throws ModelException {
final IScriptProject project = getScriptProject();
if (project == null) {
return null;
}
final IPath path = new Path(fragmentPath);
if (path.isAbsolute()) {
final IWorkspaceRoot workspaceRoot = ResourcesPlugin.getWorkspace()
.getRoot();
final IResource resource = workspaceRoot.findMember(path);
if (resource == null) {
return null;
}
// resource in the workspace
return project.getProjectFragment(resource);
} else {
final IProjectFragment[] roots = project.getProjectFragments();
if (roots == null || roots.length == 0) {
return null;
}
for (IProjectFragment root : roots) {
if (root.getUnderlyingResource().getProjectRelativePath()
.equals(path)) {
return root;
}
}
}
return null;
}
/**
* Returns the specified script folder in this project and the given
* fragment, or <code>null</code> if it does not exist. The rootPath must be
* specified as a project relative path. The empty path refers to the
* default package fragment.
*/
public IScriptFolder getScriptFolder(String fragmentPath, String path)
throws ModelException {
return getScriptFolder(fragmentPath, new Path(path));
}
/**
* Returns the specified script folder in this project and the given
* fragment, or <code>null</code> if it does not exist. The rootPath must be
* specified as a project relative path. The empty path refers to the
* default package fragment.
*/
public IScriptFolder getScriptFolder(String fragmentPath, IPath path)
throws ModelException {
final IProjectFragment root = getProjectFragment(fragmentPath);
if (root == null) {
return null;
}
return root.getScriptFolder(path);
}
/**
* Returns the source module with the specified project-related path. The
* module may or may not be present.
*/
public ISourceModule getSourceModule(String path) {
return DLTKCore.createSourceModuleFrom(getFile(path));
}
/**
* Returns the specified source module in this project and the given root
* and folder or <code>null</code> if it does not exist.
*/
public ISourceModule getSourceModule(String rootPath, IPath path)
throws ModelException {
final IScriptFolder folder = getScriptFolder(rootPath,
path.removeLastSegments(1));
if (folder == null) {
return null;
}
return folder.getSourceModule(path.lastSegment());
}
/**
* Returns the specified source module in this project and the given root
* and folder or <code>null</code> if it does not exist.
*/
public ISourceModule getSourceModule(String rootPath, String path)
throws ModelException {
return getSourceModule(rootPath, new Path(path));
}
public String getFileContentsAsString(String name) throws CoreException {
return getFileContentsAsString(getFile(name));
}
public String getFileContentsAsString(IFile file) throws CoreException {
return new String(Util.getResourceContentsAsCharArray(file));
}
/**
* Returns workspace this project belongs to.
*/
public IWorkspace getWorkspace() {
return get().getWorkspace();
}
public TestSearchResults search(IModelElement element, SearchFor searchFor)
throws CoreException {
final SearchPattern pattern = SearchPattern.createPattern(element,
convert(searchFor));
return search(pattern, createSearchScope());
}
public IDLTKSearchScope createSearchScope() {
return SearchEngine.createSearchScope(getScriptProject());
}
private static int convert(SearchFor searchFor) {
switch (searchFor) {
case DECLARATIONS:
return IDLTKSearchConstants.DECLARATIONS;
case REFERENCES:
return IDLTKSearchConstants.REFERENCES;
default:
return IDLTKSearchConstants.ALL_OCCURRENCES;
}
}
private TestSearchResults search(SearchPattern pattern,
IDLTKSearchScope scope) throws CoreException {
Assert.assertNotNull("Pattern should not be null", pattern);
final TestSearchResults results = new TestSearchResults();
final SearchParticipant[] participants = new SearchParticipant[] { SearchEngine
.getDefaultSearchParticipant() };
new SearchEngine().search(pattern, participants, scope, results, null);
return results;
}
/**
* @param patternString
* the given pattern
* @param searchFor
* determines the nature of the searched elements
* <ul>
* <li>{@link IDLTKSearchConstants#CLASS}: only look for classes</li>
* <li>{@link IDLTKSearchConstants#INTERFACE}: only look for
* interfaces</li>
* <li>{@link IDLTKSearchConstants#ENUM}: only look for
* enumeration</li>
* <li>{@link IDLTKSearchConstants#ANNOTATION_TYPE}: only look
* for annotation type</li>
* <li>{@link IDLTKSearchConstants#CLASS_AND_ENUM}: only look for
* classes and enumerations</li>
* <li>{@link IDLTKSearchConstants#CLASS_AND_INTERFACE}: only
* look for classes and interfaces</li>
* <li>{@link IDLTKSearchConstants#TYPE}: look for all types (ie.
* classes, interfaces, enum and annotation types)</li>
* <li>{@link IDLTKSearchConstants#FIELD}: look for fields</li>
* <li>{@link IDLTKSearchConstants#METHOD}: look for methods</li>
* <li>{@link IDLTKSearchConstants#CONSTRUCTOR}: look for
* constructors</li>
* <li>{@link IDLTKSearchConstants#PACKAGE}: look for packages</li>
* </ul>
* @param limitTo
* determines the nature of the expected matches
* <ul>
* <li>{@link IDLTKSearchConstants#DECLARATIONS}: will search
* declarations matching with the corresponding element. In case
* the element is a method, declarations of matching methods in
* subtypes will also be found, allowing to find declarations of
* abstract methods, etc.<br>
* Note that additional flags
* {@link IDLTKSearchConstants#IGNORE_DECLARING_TYPE} and
* {@link IDLTKSearchConstants#IGNORE_RETURN_TYPE} are ignored
* for string patterns. This is due to the fact that client may
* omit to define them in string pattern to have same behavior.</li>
* <li>{@link IDLTKSearchConstants#REFERENCES}: will search
* references to the given element.</li>
* <li>{@link IDLTKSearchConstants#ALL_OCCURRENCES}: will search
* for either declarations or references as specified above.</li>
* <li>{@link IDLTKSearchConstants#IMPLEMENTORS}: for types, will
* find all types which directly implement/extend a given
* interface. Note that types may be only classes or only
* interfaces if {@link IDLTKSearchConstants#CLASS } or
* {@link IDLTKSearchConstants#INTERFACE} is respectively used
* instead of {@link IDLTKSearchConstants#TYPE}.</li>
* </ul>
*/
public TestSearchResults search(String patternString, int searchFor,
int limitTo) throws CoreException {
return search(patternString, searchFor, limitTo,
IDLTKSearchConstantsForTests.EXACT_RULE);
}
/**
* @param patternString
* the given pattern
* @param searchFor
* determines the nature of the searched elements
* <ul>
* <li>{@link IDLTKSearchConstants#CLASS}: only look for classes</li>
* <li>{@link IDLTKSearchConstants#INTERFACE}: only look for
* interfaces</li>
* <li>{@link IDLTKSearchConstants#ENUM}: only look for
* enumeration</li>
* <li>{@link IDLTKSearchConstants#ANNOTATION_TYPE}: only look
* for annotation type</li>
* <li>{@link IDLTKSearchConstants#CLASS_AND_ENUM}: only look for
* classes and enumerations</li>
* <li>{@link IDLTKSearchConstants#CLASS_AND_INTERFACE}: only
* look for classes and interfaces</li>
* <li>{@link IDLTKSearchConstants#TYPE}: look for all types (ie.
* classes, interfaces, enum and annotation types)</li>
* <li>{@link IDLTKSearchConstants#FIELD}: look for fields</li>
* <li>{@link IDLTKSearchConstants#METHOD}: look for methods</li>
* <li>{@link IDLTKSearchConstants#CONSTRUCTOR}: look for
* constructors</li>
* <li>{@link IDLTKSearchConstants#PACKAGE}: look for packages</li>
* </ul>
* @param limitTo
* determines the nature of the expected matches
* <ul>
* <li>{@link IDLTKSearchConstants#DECLARATIONS}: will search
* declarations matching with the corresponding element. In case
* the element is a method, declarations of matching methods in
* subtypes will also be found, allowing to find declarations of
* abstract methods, etc.<br>
* Note that additional flags
* {@link IDLTKSearchConstants#IGNORE_DECLARING_TYPE} and
* {@link IDLTKSearchConstants#IGNORE_RETURN_TYPE} are ignored
* for string patterns. This is due to the fact that client may
* omit to define them in string pattern to have same behavior.</li>
* <li>{@link IDLTKSearchConstants#REFERENCES}: will search
* references to the given element.</li>
* <li>{@link IDLTKSearchConstants#ALL_OCCURRENCES}: will search
* for either declarations or references as specified above.</li>
* <li>{@link IDLTKSearchConstants#IMPLEMENTORS}: for types, will
* find all types which directly implement/extend a given
* interface. Note that types may be only classes or only
* interfaces if {@link IDLTKSearchConstants#CLASS } or
* {@link IDLTKSearchConstants#INTERFACE} is respectively used
* instead of {@link IDLTKSearchConstants#TYPE}.</li>
* </ul>
* @param matchRule
* one of {@link #R_EXACT_MATCH}, {@link #R_PREFIX_MATCH},
* {@link #R_PATTERN_MATCH}, {@link #R_REGEXP_MATCH},
* {@link #R_CAMELCASE_MATCH} combined with one of following
* values: {@link #R_CASE_SENSITIVE}, {@link #R_ERASURE_MATCH} or
* {@link #R_EQUIVALENT_MATCH}. e.g. {@link #R_EXACT_MATCH} |
* {@link #R_CASE_SENSITIVE} if an exact and case sensitive match
* is requested, {@link #R_PREFIX_MATCH} if a prefix non case
* sensitive match is requested or {@link #R_EXACT_MATCH} |
* {@link #R_ERASURE_MATCH} if a non case sensitive and erasure
* match is requested.<br>
* Note that {@link #R_ERASURE_MATCH} or
* {@link #R_EQUIVALENT_MATCH} have no effect on non-generic
* types/methods search.<br>
* Note also that default behavior for generic types/methods
* search is to find exact matches.
*/
protected TestSearchResults search(String patternString, int searchFor,
int limitTo, int matchRule) throws CoreException {
final IDLTKSearchScope scope = createSearchScope();
return search(patternString, searchFor, limitTo, matchRule, scope);
}
/**
* @param patternString
* the given pattern
* @param searchFor
* determines the nature of the searched elements
* <ul>
* <li>{@link IDLTKSearchConstants#CLASS}: only look for classes</li>
* <li>{@link IDLTKSearchConstants#INTERFACE}: only look for
* interfaces</li>
* <li>{@link IDLTKSearchConstants#ENUM}: only look for
* enumeration</li>
* <li>{@link IDLTKSearchConstants#ANNOTATION_TYPE}: only look
* for annotation type</li>
* <li>{@link IDLTKSearchConstants#CLASS_AND_ENUM}: only look for
* classes and enumerations</li>
* <li>{@link IDLTKSearchConstants#CLASS_AND_INTERFACE}: only
* look for classes and interfaces</li>
* <li>{@link IDLTKSearchConstants#TYPE}: look for all types (ie.
* classes, interfaces, enum and annotation types)</li>
* <li>{@link IDLTKSearchConstants#FIELD}: look for fields</li>
* <li>{@link IDLTKSearchConstants#METHOD}: look for methods</li>
* <li>{@link IDLTKSearchConstants#CONSTRUCTOR}: look for
* constructors</li>
* <li>{@link IDLTKSearchConstants#PACKAGE}: look for packages</li>
* </ul>
* @param limitTo
* determines the nature of the expected matches
* <ul>
* <li>{@link IDLTKSearchConstants#DECLARATIONS}: will search
* declarations matching with the corresponding element. In case
* the element is a method, declarations of matching methods in
* subtypes will also be found, allowing to find declarations of
* abstract methods, etc.<br>
* Note that additional flags
* {@link IDLTKSearchConstants#IGNORE_DECLARING_TYPE} and
* {@link IDLTKSearchConstants#IGNORE_RETURN_TYPE} are ignored
* for string patterns. This is due to the fact that client may
* omit to define them in string pattern to have same behavior.</li>
* <li>{@link IDLTKSearchConstants#REFERENCES}: will search
* references to the given element.</li>
* <li>{@link IDLTKSearchConstants#ALL_OCCURRENCES}: will search
* for either declarations or references as specified above.</li>
* <li>{@link IDLTKSearchConstants#IMPLEMENTORS}: for types, will
* find all types which directly implement/extend a given
* interface. Note that types may be only classes or only
* interfaces if {@link IDLTKSearchConstants#CLASS } or
* {@link IDLTKSearchConstants#INTERFACE} is respectively used
* instead of {@link IDLTKSearchConstants#TYPE}.</li>
* </ul>
* @param matchRule
* one of {@link #R_EXACT_MATCH}, {@link #R_PREFIX_MATCH},
* {@link #R_PATTERN_MATCH}, {@link #R_REGEXP_MATCH},
* {@link #R_CAMELCASE_MATCH} combined with one of following
* values: {@link #R_CASE_SENSITIVE}, {@link #R_ERASURE_MATCH} or
* {@link #R_EQUIVALENT_MATCH}. e.g. {@link #R_EXACT_MATCH} |
* {@link #R_CASE_SENSITIVE} if an exact and case sensitive match
* is requested, {@link #R_PREFIX_MATCH} if a prefix non case
* sensitive match is requested or {@link #R_EXACT_MATCH} |
* {@link #R_ERASURE_MATCH} if a non case sensitive and erasure
* match is requested.<br>
* Note that {@link #R_ERASURE_MATCH} or
* {@link #R_EQUIVALENT_MATCH} have no effect on non-generic
* types/methods search.<br>
* Note also that default behavior for generic types/methods
* search is to find exact matches.
* @param scope
*/
public TestSearchResults search(String patternString, int searchFor,
int limitTo, int matchRule, final IDLTKSearchScope scope)
throws CoreException {
if (patternString.indexOf('*') != -1
|| patternString.indexOf('?') != -1) {
matchRule |= SearchPattern.R_PATTERN_MATCH;
}
final IDLTKLanguageToolkit toolkit = scope.getLanguageToolkit();
final SearchPattern pattern = SearchPattern.createPattern(
patternString, searchFor, limitTo, matchRule, toolkit);
return search(pattern, scope);
}
/**
* Returns all the problems of the resource with the specified name.
*/
public IMarker[] findProblems(String resourceName) throws CoreException {
final IResource resource = get().findMember(resourceName);
Assert.assertNotNull(NLS.bind("Resource {0} not found in {1}",
resourceName, getProjectName()), resource);
return ProblemTestUtil.findProblems(resource);
}
/**
* Performs the incremental build in this project.
*/
public void build() throws CoreException {
final long start = System.currentTimeMillis();
get().build(IncrementalProjectBuilder.INCREMENTAL_BUILD, null);
if (isVerbose()) {
System.out.println((System.currentTimeMillis() - start)
+ " ms for incremental build of " + getProjectName()
+ " project");
}
}
/**
* Writes the specified content to the specfied content, creating the file
* and all the parent folders if the don't exist.
*
* @param fileName
* @param contents
* @return
* @throws UnsupportedEncodingException
* @throws CoreException
*/
public IFile writeFile(String fileName, String contents)
throws CoreException {
final IFile file = getFile(fileName);
final byte[] bytes;
try {
bytes = contents.getBytes(file.getCharset());
} catch (UnsupportedEncodingException e) {
throw new IllegalStateException(e);
}
final ByteArrayInputStream input = new ByteArrayInputStream(bytes);
if (file.exists()) {
file.setContents(input, IResource.NONE, null);
} else {
final IContainer parent = file.getParent();
if (parent instanceof IFolder) {
ResourceUtil.createFolder((IFolder) parent, null);
}
file.create(input, IResource.NONE, null);
}
return file;
}
/**
* Deletes all the members in the specified folder. If some members were
* deleted and option == {@link Option#BUILD} then the build operation is
* also executed.
*
* @param folderName
* folder name
* @param option
* {@link Option#BUILD} or <code>null</code>
* @throws CoreException
*/
public void deleteFolderMembers(String folderName, @Nullable Option option)
throws CoreException {
if (option != null) {
if (option != Option.BUILD) {
throw new IllegalArgumentException();
}
}
final IFolder folder = getFolder(folderName);
if (!folder.exists()) {
return;
}
int count = 0;
for (IResource member : folder.members()) {
member.delete(true, null);
++count;
}
if (count != 0 && option == Option.BUILD) {
build();
}
}
protected IWorkspaceRoot getWorkspaceRoot() {
return ResourcesPlugin.getWorkspace().getRoot();
}
}