plugins/org.eclipse.dltk.ruby.testing/src/org/eclipse/dltk/ruby/testing/internal/testunit/TestUnitTestRunnerUI.java - dltk/org.eclipse.dltk.ruby - Git at Google

 /*******************************************************************************
  * Copyright (c) 2008, 2016 xored software, Inc. 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
  *
  * Contributors:
  *     xored software, Inc. - initial API and Implementation (Alex Panchenko)
  *******************************************************************************/
 package org.eclipse.dltk.ruby.testing.internal.testunit;

 import java.util.ArrayList;
 import java.util.HashSet;
 import java.util.Iterator;
 import java.util.List;
 import java.util.Set;
 import java.util.Stack;
 import java.util.regex.Pattern;

 import org.eclipse.core.resources.IFile;
 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.ast.ASTNode;
 import org.eclipse.dltk.ast.declarations.ModuleDeclaration;
 import org.eclipse.dltk.ast.declarations.TypeDeclaration;
 import org.eclipse.dltk.ast.expressions.CallExpression;
 import org.eclipse.dltk.ast.expressions.StringLiteral;
 import org.eclipse.dltk.compiler.util.Util;
 import org.eclipse.dltk.core.DLTKCore;
 import org.eclipse.dltk.core.IMethod;
 import org.eclipse.dltk.core.IProjectFragment;
 import org.eclipse.dltk.core.IScriptProject;
 import org.eclipse.dltk.core.ISourceModule;
 import org.eclipse.dltk.core.ISourceRange;
 import org.eclipse.dltk.core.IType;
 import org.eclipse.dltk.core.ModelException;
 import org.eclipse.dltk.core.SourceRange;
 import org.eclipse.dltk.core.environment.EnvironmentPathUtils;
 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.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.ruby.ast.RubyCallArgument;
 import org.eclipse.dltk.ruby.core.utils.RubySyntaxUtils;
 import org.eclipse.dltk.ruby.internal.debug.ui.console.RubyConsoleSourceModuleLookup;
 import org.eclipse.dltk.ruby.testing.internal.AbstractRubyTestRunnerUI;
 import org.eclipse.dltk.ruby.testing.internal.AbstractRubyTestingEngine;
 import org.eclipse.dltk.ruby.testing.internal.AbstractTestingEngineValidateVisitor;
 import org.eclipse.dltk.ruby.testing.internal.ResolverUtils;
 import org.eclipse.dltk.ruby.testing.internal.RubyTestingPlugin;
 import org.eclipse.dltk.testing.DLTKTestingMessages;
 import org.eclipse.dltk.testing.TestElementResolution;
 import org.eclipse.dltk.testing.model.ITestCaseElement;
 import org.eclipse.dltk.testing.model.ITestSuiteElement;
 import org.eclipse.osgi.util.NLS;

 public class TestUnitTestRunnerUI extends AbstractRubyTestRunnerUI {

 	private static final char CLASS_BEGIN = '(';
 	private static final char CLASS_END = ')';

 	/**
 	 * @param testingEngine
 	 */
 	public TestUnitTestRunnerUI(AbstractRubyTestingEngine testingEngine,
 			IScriptProject project) {
 		super(testingEngine, project);
 	}

 	@Override
 	public String getTestCaseLabel(ITestCaseElement caseElement, boolean full) {
 		final String testName = caseElement.getTestName();
 		int index = testName.lastIndexOf(CLASS_BEGIN);
 		if (index > 0) {
 			final int braceIndex = index;
 			while (index > 0
 					&& Character.isWhitespace(testName.charAt(index - 1))) {
 				--index;
 			}
 			if (full) {
 				int end = testName.length();
 				if (end > braceIndex + 1
 						&& testName.charAt(end - 1) == CLASS_END) {
 					--end;
 				}
 				final String template = DLTKTestingMessages.TestSessionLabelProvider_testMethodName_className;
 				return NLS.bind(template, testName.substring(braceIndex + 1,
 						end), testName.substring(0, index));
 			} else {
 				return testName.substring(0, index);
 			}
 		} else {
 			return testName;
 		}
 	}

 	@Override
 	public String getTestStartedMessage(ITestCaseElement caseElement) {
 		final String testName = caseElement.getTestName();
 		int index = testName.lastIndexOf(CLASS_BEGIN);
 		if (index > 0) {
 			int end = testName.length();
 			if (end > index && testName.charAt(end - 1) == CLASS_END) {
 				--end;
 			}
 			final String className = testName.substring(index + 1, end);
 			while (index > 0
 					&& Character.isWhitespace(testName.charAt(index - 1))) {
 				--index;
 			}
 			final String method = testName.substring(0, index);
 			return NLS.bind(
 					DLTKTestingMessages.TestRunnerViewPart_message_started,
 					className, method);
 		} else {
 			return testName;
 		}
 	}

 	private static final String SHOULDA_TEST_PREFIX = "test:"; //$NON-NLS-1$

 	@Override
 	protected TestElementResolution resolveTestCase(ITestCaseElement testCase) {
 		final String testName = testCase.getTestName();
 		if (testName.length() == 0) {
 			return null;
 		}
 		final int pos = testName.lastIndexOf(CLASS_BEGIN);
 		if (!(pos > 0 && testName.charAt(testName.length() - 1) == CLASS_END)) {
 			return null;
 		}
 		final String className = testName.substring(pos + 1,
 				testName.length() - 1);
 		if (!RubySyntaxUtils.isValidClass(className)) {
 			return null;
 		}
 		final String methodName = testName.substring(0, pos).trim();
 		if (RubySyntaxUtils.isRubyMethodName(methodName)) {
 			final IMethod method = findMethod(className, methodName);
 			if (method != null) {
 				return new TestElementResolution(method, ResolverUtils
 						.getSourceRange(method));
 			}
 		}
 		final List types = findClasses(className);
 		if (types == null) {
 			return null;
 		}
 		if (methodName.startsWith(SHOULDA_TEST_PREFIX)) {
 			String shouldName = methodName.substring(
 					SHOULDA_TEST_PREFIX.length()).trim();
 			if (shouldName.length() != 0
 					&& shouldName.charAt(shouldName.length() - 1) == '.') {
 				shouldName = shouldName.substring(0, shouldName.length() - 1)
 						.trim();
 			}
 			if (shouldName.length() != 0) {
 				final Set<IFile> resources = new HashSet<IFile>();
 				for (Iterator i = types.iterator(); i.hasNext();) {
 					final IType type = (IType) i.next();
 					final IResource resource = type.getResource();
 					if (resource != null && resource instanceof IFile) {
 						resources.add((IFile) resource);
 					}
 				}
 				if (resources.isEmpty()) {
 					return null;
 				}
 				for (Iterator<IFile> i = resources.iterator(); i.hasNext();) {
 					final ISourceModule module = (ISourceModule) DLTKCore.create(i.next());
 					final TestElementResolution resolution = findShould(module,
 							className, shouldName);
 					if (resolution != null) {
 						return resolution;
 					}
 				}
 			}
 		}
 		return null;
 	}

 	private static class ShouldLocator extends
 			AbstractTestingEngineValidateVisitor {

 		private static final String TWO_COLONS = "::"; //$NON-NLS-1$

 		private final String className;
 		private final String shouldName;

 		private ISourceRange range = null;

 		/**
 		 * @param className
 		 * @param shouldName
 		 */
 		public ShouldLocator(String className, String shouldName) {
 			this.className = className;
 			this.shouldName = shouldName;
 		}

 		final Stack<Boolean> typeMatches = new Stack<Boolean>();

 		@Override
 		public boolean visit(TypeDeclaration s) throws Exception {
 			final String enclosingName = s.getEnclosingTypeName();
 			final String fullName;
 			if (enclosingName.length() == 0) {
 				fullName = s.getName();
 			} else {
 				fullName = enclosingName.replaceAll("\\$", TWO_COLONS) + TWO_COLONS + s.getName(); //$NON-NLS-1$
 			}
 			typeMatches.push(Boolean.valueOf(className.equals(fullName)));
 			return true;
 		}

 		@Override
 		public boolean endvisit(TypeDeclaration s) throws Exception {
 			typeMatches.pop();
 			return true;
 		}

 		private boolean isMatchedType() {
 			for (int i = 0, size = typeMatches.size(); i < size; ++i) {
 				Boolean value = typeMatches.get(i);
 				if (value.booleanValue()) {
 					return true;
 				}
 			}
 			return false;
 		}

 		final Stack<CallExpression> calls = new Stack<CallExpression>();

 		@Override
 		public boolean visitGeneral(ASTNode node) throws Exception {
 			if (isMatchedType() && range == null) {
 				if (node instanceof CallExpression) {
 					final CallExpression call = (CallExpression) node;
 					if (isMethodCall(call, ShouldaUtils.METHODS)
 							&& call.getArgs().getChilds().size() >= 1) {
 						final Object arg0 = call.getArgs().getChilds().get(0);
 						if (arg0 instanceof RubyCallArgument) {
 							final RubyCallArgument callArg = (RubyCallArgument) arg0;
 							if (callArg.getValue() instanceof StringLiteral) {
 								calls.push(call);
 								if (isShouldMatched()) {
 									range = new SourceRange(call.sourceStart(),
 											callArg.sourceEnd()
 													- call.sourceStart());
 								}
 							}
 						}
 					}
 				}
 			}
 			return super.visitGeneral(node);
 		}

 		/**
 		 * @return
 		 */
 		private boolean isShouldMatched() {
 			if (isShouldMatched(shouldName)) {
 				return true;
 			}
 			final String noTestClassName = className.replaceAll(
 					"Test", Util.EMPTY_STRING); //$NON-NLS-1$
 			if (startsWith(shouldName, noTestClassName)) {
 				return isShouldMatched(shouldName.substring(
 						noTestClassName.length()).trim());
 			}
 			return false;
 		}

 		private boolean startsWith(final String value, final String substring) {
 			return value.length() > substring.length()
 					&& value.startsWith(substring)
 					&& Character.isWhitespace(value.charAt(substring.length()));
 		}

 		/**
 		 * @param value
 		 * @return
 		 */
 		private boolean isShouldMatched(String value) {
 			for (int i = 0; i < calls.size(); ++i) {
 				final CallExpression call = calls.get(i);
 				if (ShouldaUtils.SHOULD.equals(call.getName())) {
 					if (!startsWith(value, ShouldaUtils.SHOULD)) {
 						return false;
 					}
 					value = value.substring(ShouldaUtils.SHOULD.length())
 							.trim();
 					final RubyCallArgument callArg = (RubyCallArgument) call
 							.getArgs().getChilds().get(0);
 					final String literal = ((StringLiteral) callArg.getValue())
 							.getValue();
 					if (value.equals(literal)) {
 						return true;
 					}
 				} else if (ShouldaUtils.CONTEXT.equals(call.getName())) {
 					final RubyCallArgument callArg = (RubyCallArgument) call
 							.getArgs().getChilds().get(0);
 					final String literal = ((StringLiteral) callArg.getValue())
 							.getValue().trim();
 					if (!startsWith(value, literal)) {
 						return false;
 					}
 					value = value.substring(literal.length()).trim();
 				}
 			}
 			return false;
 		}

 		@Override
 		public void endvisitGeneral(ASTNode node) throws Exception {
 			if (!calls.isEmpty() && calls.peek() == node) {
 				calls.pop();
 			}
 			super.endvisitGeneral(node);
 		}
 	}

 	/**
 	 * @param module
 	 * @param className
 	 * @param shouldName
 	 * @return
 	 */
 	private TestElementResolution findShould(ISourceModule module,
 			String className, String shouldName) {
 		final ModuleDeclaration declaration = ResolverUtils.parse(module);
 		if (declaration != null) {
 			try {
 				final ShouldLocator locator = new ShouldLocator(className,
 						shouldName);
 				declaration.traverse(locator);
 				if (locator.range != null) {
 					final ISourceRange range = ResolverUtils.adjustRange(module
 							.getSource(), locator.range);
 					return new TestElementResolution(module, range);
 				}
 			} catch (Exception e) {
 				final String msg = "Error in findShould()"; //$NON-NLS-1$
 				RubyTestingPlugin.error(msg, e);
 			}
 		}
 		return null;
 	}

 	@Override
 	protected TestElementResolution resolveTestSuite(ITestSuiteElement element) {
 		final String className = element.getSuiteTypeName();
 		if (RubySyntaxUtils.isValidClass(className)) {
 			final List types = findClasses(className);
 			if (types != null) {
 				final IType type = (IType) types.get(0);
 				return new TestElementResolution(type, ResolverUtils
 						.getSourceRange(type));
 			}
 		}
 		return null;
 	}

 	private static final class TypeSearchRequestor extends SearchRequestor {
 		final List<Object> types = new ArrayList<Object>();

 		@Override
 		public void acceptSearchMatch(SearchMatch match) throws CoreException {
 			types.add(match.getElement());
 		}
 	}

 	private static final class MethodRequestor extends SearchRequestor {
 		IMethod method = null;

 		@Override
 		public void acceptSearchMatch(SearchMatch match) throws CoreException {
 			method = (IMethod) match.getElement();
 		}
 	}

 	/**
 	 * @param className
 	 * @param methodName
 	 * @return
 	 */
 	private IMethod findMethod(String className, String methodName) {
 		final IDLTKSearchScope scope = getSearchScope();
 		final String sPattern = className + "::" + methodName; //$NON-NLS-1$
 		SearchPattern pattern = SearchPattern.createPattern(sPattern,
 				IDLTKSearchConstants.METHOD, IDLTKSearchConstants.DECLARATIONS,
 				SearchPattern.R_EXACT_MATCH | SearchPattern.R_CASE_SENSITIVE,
 				scope.getLanguageToolkit());
 		try {
 			final MethodRequestor requestor = new MethodRequestor();
 			new SearchEngine().search(pattern,
 					new SearchParticipant[] { SearchEngine
 							.getDefaultSearchParticipant() }, scope, requestor,
 					null);
 			return requestor.method;
 		} catch (CoreException e) {
 			final String msg = "Error in findMethod({0}::{1})"; //$NON-NLS-1$
 			RubyTestingPlugin.error(NLS.bind(msg, className, methodName), e);
 		}
 		return null;
 	}

 	/**
 	 * @param className
 	 */
 	private List findClasses(String className) {
 		final IDLTKSearchScope scope = getSearchScope();
 		SearchPattern pattern = SearchPattern.createPattern(className,
 				IDLTKSearchConstants.TYPE, IDLTKSearchConstants.DECLARATIONS,
 				SearchPattern.R_EXACT_MATCH | SearchPattern.R_CASE_SENSITIVE,
 				scope.getLanguageToolkit());
 		try {
 			final TypeSearchRequestor requestor = new TypeSearchRequestor();
 			new SearchEngine().search(pattern,
 					new SearchParticipant[] { SearchEngine
 							.getDefaultSearchParticipant() }, scope, requestor,
 					null);
 			if (!requestor.types.isEmpty()) {
 				return requestor.types;
 			}
 		} catch (CoreException e) {
 			final String msg = "Error in findClasses({0})"; //$NON-NLS-1$
 			RubyTestingPlugin.error(NLS.bind(msg, className), e);
 		}
 		return null;
 	}

 	private static final String[] TEST_UNIT = { "test", "unit" }; //$NON-NLS-1$ //$NON-NLS-2$

 	private boolean testFragmentPath(IPath fragmentPath, IPath path) {
 		if (pathEquality.isPrefixOf(fragmentPath, path)
 				&& path.segmentCount() > fragmentPath.segmentCount()
 						+ TEST_UNIT.length) {
 			for (int j = 0; j < TEST_UNIT.length; ++j) {
 				if (!TEST_UNIT[j].equals(path.segment(fragmentPath
 						.segmentCount()
 						+ j))) {
 					return false;
 				}
 			}
 			return true;
 		}
 		return false;
 	}

 	private static String buildRegex() {
 		final String slash = "[\\\\/]"; //$NON-NLS-1$
 		return slash + "gems" + slash + "Shoulda-[\\w\\.]+" + slash + "lib" //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
 				+ slash;
 	}

 	private static final Pattern GEM_SHOULDA_LIB = Pattern
 			.compile(buildRegex());

 	@Override
 	protected boolean selectLine(String line) {
 		final String filename = extractFileName(line);
 		if (filename == null) {
 			return true;
 		}
 		if (filename.endsWith(TestUnitTestingEngine.TEST_UNIT_RUNNER)) {
 			return false;
 		}
 		if (GEM_SHOULDA_LIB.matcher(filename).find()) {
 			return false;
 		}
 		final IPath path = new Path(filename);
 		try {
 			final IProjectFragment[] fragments = project.getProjectFragments();
 			for (int i = 0; i < fragments.length; ++i) {
 				final IProjectFragment fragment = fragments[i];
 				if (fragment.isExternal()
 						&& testFragmentPath(EnvironmentPathUtils
 								.getLocalPath(fragment.getPath()), path)
 						&& RubyConsoleSourceModuleLookup.isIncluded(fragment,
 								path)) {
 					return false;
 				}
 			}
 		} catch (ModelException e) {
 			return true;
 		}
 		return true;
 	}
 }
	/*******************************************************************************
	* Copyright (c) 2008, 2016 xored software, Inc. 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
	*
	* Contributors:
	* xored software, Inc. - initial API and Implementation (Alex Panchenko)
	*******************************************************************************/
	package org.eclipse.dltk.ruby.testing.internal.testunit;

	import java.util.ArrayList;
	import java.util.HashSet;
	import java.util.Iterator;
	import java.util.List;
	import java.util.Set;
	import java.util.Stack;
	import java.util.regex.Pattern;

	import org.eclipse.core.resources.IFile;
	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.ast.ASTNode;
	import org.eclipse.dltk.ast.declarations.ModuleDeclaration;
	import org.eclipse.dltk.ast.declarations.TypeDeclaration;
	import org.eclipse.dltk.ast.expressions.CallExpression;
	import org.eclipse.dltk.ast.expressions.StringLiteral;
	import org.eclipse.dltk.compiler.util.Util;
	import org.eclipse.dltk.core.DLTKCore;
	import org.eclipse.dltk.core.IMethod;
	import org.eclipse.dltk.core.IProjectFragment;
	import org.eclipse.dltk.core.IScriptProject;
	import org.eclipse.dltk.core.ISourceModule;
	import org.eclipse.dltk.core.ISourceRange;
	import org.eclipse.dltk.core.IType;
	import org.eclipse.dltk.core.ModelException;
	import org.eclipse.dltk.core.SourceRange;
	import org.eclipse.dltk.core.environment.EnvironmentPathUtils;
	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.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.ruby.ast.RubyCallArgument;
	import org.eclipse.dltk.ruby.core.utils.RubySyntaxUtils;
	import org.eclipse.dltk.ruby.internal.debug.ui.console.RubyConsoleSourceModuleLookup;
	import org.eclipse.dltk.ruby.testing.internal.AbstractRubyTestRunnerUI;
	import org.eclipse.dltk.ruby.testing.internal.AbstractRubyTestingEngine;
	import org.eclipse.dltk.ruby.testing.internal.AbstractTestingEngineValidateVisitor;
	import org.eclipse.dltk.ruby.testing.internal.ResolverUtils;
	import org.eclipse.dltk.ruby.testing.internal.RubyTestingPlugin;
	import org.eclipse.dltk.testing.DLTKTestingMessages;
	import org.eclipse.dltk.testing.TestElementResolution;
	import org.eclipse.dltk.testing.model.ITestCaseElement;
	import org.eclipse.dltk.testing.model.ITestSuiteElement;
	import org.eclipse.osgi.util.NLS;

	public class TestUnitTestRunnerUI extends AbstractRubyTestRunnerUI {

	private static final char CLASS_BEGIN = '(';
	private static final char CLASS_END = ')';

	/**
	* @param testingEngine
	*/
	public TestUnitTestRunnerUI(AbstractRubyTestingEngine testingEngine,
	IScriptProject project) {
	super(testingEngine, project);
	}

	@Override
	public String getTestCaseLabel(ITestCaseElement caseElement, boolean full) {
	final String testName = caseElement.getTestName();
	int index = testName.lastIndexOf(CLASS_BEGIN);
	if (index > 0) {
	final int braceIndex = index;
	while (index > 0
	&& Character.isWhitespace(testName.charAt(index - 1))) {
	--index;
	}
	if (full) {
	int end = testName.length();
	if (end > braceIndex + 1
	&& testName.charAt(end - 1) == CLASS_END) {
	--end;
	}
	final String template = DLTKTestingMessages.TestSessionLabelProvider_testMethodName_className;
	return NLS.bind(template, testName.substring(braceIndex + 1,
	end), testName.substring(0, index));
	} else {
	return testName.substring(0, index);
	}
	} else {
	return testName;
	}
	}

	@Override
	public String getTestStartedMessage(ITestCaseElement caseElement) {
	final String testName = caseElement.getTestName();
	int index = testName.lastIndexOf(CLASS_BEGIN);
	if (index > 0) {
	int end = testName.length();
	if (end > index && testName.charAt(end - 1) == CLASS_END) {
	--end;
	}
	final String className = testName.substring(index + 1, end);
	while (index > 0
	&& Character.isWhitespace(testName.charAt(index - 1))) {
	--index;
	}
	final String method = testName.substring(0, index);
	return NLS.bind(
	DLTKTestingMessages.TestRunnerViewPart_message_started,
	className, method);
	} else {
	return testName;
	}
	}

	private static final String SHOULDA_TEST_PREFIX = "test:"; //$NON-NLS-1$

	@Override
	protected TestElementResolution resolveTestCase(ITestCaseElement testCase) {
	final String testName = testCase.getTestName();
	if (testName.length() == 0) {
	return null;
	}
	final int pos = testName.lastIndexOf(CLASS_BEGIN);
	if (!(pos > 0 && testName.charAt(testName.length() - 1) == CLASS_END)) {
	return null;
	}
	final String className = testName.substring(pos + 1,
	testName.length() - 1);
	if (!RubySyntaxUtils.isValidClass(className)) {
	return null;
	}
	final String methodName = testName.substring(0, pos).trim();
	if (RubySyntaxUtils.isRubyMethodName(methodName)) {
	final IMethod method = findMethod(className, methodName);
	if (method != null) {
	return new TestElementResolution(method, ResolverUtils
	.getSourceRange(method));
	}
	}
	final List types = findClasses(className);
	if (types == null) {
	return null;
	}
	if (methodName.startsWith(SHOULDA_TEST_PREFIX)) {
	String shouldName = methodName.substring(
	SHOULDA_TEST_PREFIX.length()).trim();
	if (shouldName.length() != 0
	&& shouldName.charAt(shouldName.length() - 1) == '.') {
	shouldName = shouldName.substring(0, shouldName.length() - 1)
	.trim();
	}
	if (shouldName.length() != 0) {
	final Set<IFile> resources = new HashSet<IFile>();
	for (Iterator i = types.iterator(); i.hasNext();) {
	final IType type = (IType) i.next();
	final IResource resource = type.getResource();
	if (resource != null && resource instanceof IFile) {
	resources.add((IFile) resource);
	}
	}
	if (resources.isEmpty()) {
	return null;
	}
	for (Iterator<IFile> i = resources.iterator(); i.hasNext();) {
	final ISourceModule module = (ISourceModule) DLTKCore.create(i.next());
	final TestElementResolution resolution = findShould(module,
	className, shouldName);
	if (resolution != null) {
	return resolution;
	}
	}
	}
	}
	return null;
	}

	private static class ShouldLocator extends
	AbstractTestingEngineValidateVisitor {

	private static final String TWO_COLONS = "::"; //$NON-NLS-1$

	private final String className;
	private final String shouldName;

	private ISourceRange range = null;

	/**
	* @param className
	* @param shouldName
	*/
	public ShouldLocator(String className, String shouldName) {
	this.className = className;
	this.shouldName = shouldName;
	}

	final Stack<Boolean> typeMatches = new Stack<Boolean>();

	@Override
	public boolean visit(TypeDeclaration s) throws Exception {
	final String enclosingName = s.getEnclosingTypeName();
	final String fullName;
	if (enclosingName.length() == 0) {
	fullName = s.getName();
	} else {
	fullName = enclosingName.replaceAll("\\$", TWO_COLONS) + TWO_COLONS + s.getName(); //$NON-NLS-1$
	}
	typeMatches.push(Boolean.valueOf(className.equals(fullName)));
	return true;
	}

	@Override
	public boolean endvisit(TypeDeclaration s) throws Exception {
	typeMatches.pop();
	return true;
	}

	private boolean isMatchedType() {
	for (int i = 0, size = typeMatches.size(); i < size; ++i) {
	Boolean value = typeMatches.get(i);
	if (value.booleanValue()) {
	return true;
	}
	}
	return false;
	}

	final Stack<CallExpression> calls = new Stack<CallExpression>();

	@Override
	public boolean visitGeneral(ASTNode node) throws Exception {
	if (isMatchedType() && range == null) {
	if (node instanceof CallExpression) {
	final CallExpression call = (CallExpression) node;
	if (isMethodCall(call, ShouldaUtils.METHODS)
	&& call.getArgs().getChilds().size() >= 1) {
	final Object arg0 = call.getArgs().getChilds().get(0);
	if (arg0 instanceof RubyCallArgument) {
	final RubyCallArgument callArg = (RubyCallArgument) arg0;
	if (callArg.getValue() instanceof StringLiteral) {
	calls.push(call);
	if (isShouldMatched()) {
	range = new SourceRange(call.sourceStart(),
	callArg.sourceEnd()
	- call.sourceStart());
	}
	}
	}
	}
	}
	}
	return super.visitGeneral(node);
	}

	/**
	* @return
	*/
	private boolean isShouldMatched() {
	if (isShouldMatched(shouldName)) {
	return true;
	}
	final String noTestClassName = className.replaceAll(
	"Test", Util.EMPTY_STRING); //$NON-NLS-1$
	if (startsWith(shouldName, noTestClassName)) {
	return isShouldMatched(shouldName.substring(
	noTestClassName.length()).trim());
	}
	return false;
	}

	private boolean startsWith(final String value, final String substring) {
	return value.length() > substring.length()
	&& value.startsWith(substring)
	&& Character.isWhitespace(value.charAt(substring.length()));
	}

	/**
	* @param value
	* @return
	*/
	private boolean isShouldMatched(String value) {
	for (int i = 0; i < calls.size(); ++i) {
	final CallExpression call = calls.get(i);
	if (ShouldaUtils.SHOULD.equals(call.getName())) {
	if (!startsWith(value, ShouldaUtils.SHOULD)) {
	return false;
	}
	value = value.substring(ShouldaUtils.SHOULD.length())
	.trim();
	final RubyCallArgument callArg = (RubyCallArgument) call
	.getArgs().getChilds().get(0);
	final String literal = ((StringLiteral) callArg.getValue())
	.getValue();
	if (value.equals(literal)) {
	return true;
	}
	} else if (ShouldaUtils.CONTEXT.equals(call.getName())) {
	final RubyCallArgument callArg = (RubyCallArgument) call
	.getArgs().getChilds().get(0);
	final String literal = ((StringLiteral) callArg.getValue())
	.getValue().trim();
	if (!startsWith(value, literal)) {
	return false;
	}
	value = value.substring(literal.length()).trim();
	}
	}
	return false;
	}

	@Override
	public void endvisitGeneral(ASTNode node) throws Exception {
	if (!calls.isEmpty() && calls.peek() == node) {
	calls.pop();
	}
	super.endvisitGeneral(node);
	}
	}

	/**
	* @param module
	* @param className
	* @param shouldName
	* @return
	*/
	private TestElementResolution findShould(ISourceModule module,
	String className, String shouldName) {
	final ModuleDeclaration declaration = ResolverUtils.parse(module);
	if (declaration != null) {
	try {
	final ShouldLocator locator = new ShouldLocator(className,
	shouldName);
	declaration.traverse(locator);
	if (locator.range != null) {
	final ISourceRange range = ResolverUtils.adjustRange(module
	.getSource(), locator.range);
	return new TestElementResolution(module, range);
	}
	} catch (Exception e) {
	final String msg = "Error in findShould()"; //$NON-NLS-1$
	RubyTestingPlugin.error(msg, e);
	}
	}
	return null;
	}

	@Override
	protected TestElementResolution resolveTestSuite(ITestSuiteElement element) {
	final String className = element.getSuiteTypeName();
	if (RubySyntaxUtils.isValidClass(className)) {
	final List types = findClasses(className);
	if (types != null) {
	final IType type = (IType) types.get(0);
	return new TestElementResolution(type, ResolverUtils
	.getSourceRange(type));
	}
	}
	return null;
	}

	private static final class TypeSearchRequestor extends SearchRequestor {
	final List<Object> types = new ArrayList<Object>();

	@Override
	public void acceptSearchMatch(SearchMatch match) throws CoreException {
	types.add(match.getElement());
	}
	}

	private static final class MethodRequestor extends SearchRequestor {
	IMethod method = null;

	@Override
	public void acceptSearchMatch(SearchMatch match) throws CoreException {
	method = (IMethod) match.getElement();
	}
	}

	/**
	* @param className
	* @param methodName
	* @return
	*/
	private IMethod findMethod(String className, String methodName) {
	final IDLTKSearchScope scope = getSearchScope();
	final String sPattern = className + "::" + methodName; //$NON-NLS-1$
	SearchPattern pattern = SearchPattern.createPattern(sPattern,
	IDLTKSearchConstants.METHOD, IDLTKSearchConstants.DECLARATIONS,
	SearchPattern.R_EXACT_MATCH \| SearchPattern.R_CASE_SENSITIVE,
	scope.getLanguageToolkit());
	try {
	final MethodRequestor requestor = new MethodRequestor();
	new SearchEngine().search(pattern,
	new SearchParticipant[] { SearchEngine
	.getDefaultSearchParticipant() }, scope, requestor,
	null);
	return requestor.method;
	} catch (CoreException e) {
	final String msg = "Error in findMethod({0}::{1})"; //$NON-NLS-1$
	RubyTestingPlugin.error(NLS.bind(msg, className, methodName), e);
	}
	return null;
	}

	/**
	* @param className
	*/
	private List findClasses(String className) {
	final IDLTKSearchScope scope = getSearchScope();
	SearchPattern pattern = SearchPattern.createPattern(className,
	IDLTKSearchConstants.TYPE, IDLTKSearchConstants.DECLARATIONS,
	SearchPattern.R_EXACT_MATCH \| SearchPattern.R_CASE_SENSITIVE,
	scope.getLanguageToolkit());
	try {
	final TypeSearchRequestor requestor = new TypeSearchRequestor();
	new SearchEngine().search(pattern,
	new SearchParticipant[] { SearchEngine
	.getDefaultSearchParticipant() }, scope, requestor,
	null);
	if (!requestor.types.isEmpty()) {
	return requestor.types;
	}
	} catch (CoreException e) {
	final String msg = "Error in findClasses({0})"; //$NON-NLS-1$
	RubyTestingPlugin.error(NLS.bind(msg, className), e);
	}
	return null;
	}

	private static final String[] TEST_UNIT = { "test", "unit" }; //$NON-NLS-1$ //$NON-NLS-2$

	private boolean testFragmentPath(IPath fragmentPath, IPath path) {
	if (pathEquality.isPrefixOf(fragmentPath, path)
	&& path.segmentCount() > fragmentPath.segmentCount()
	+ TEST_UNIT.length) {
	for (int j = 0; j < TEST_UNIT.length; ++j) {
	if (!TEST_UNIT[j].equals(path.segment(fragmentPath
	.segmentCount()
	+ j))) {
	return false;
	}
	}
	return true;
	}
	return false;
	}

	private static String buildRegex() {
	final String slash = "[\\\\/]"; //$NON-NLS-1$
	return slash + "gems" + slash + "Shoulda-[\\w\\.]+" + slash + "lib" //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
	+ slash;
	}

	private static final Pattern GEM_SHOULDA_LIB = Pattern
	.compile(buildRegex());

	@Override
	protected boolean selectLine(String line) {
	final String filename = extractFileName(line);
	if (filename == null) {
	return true;
	}
	if (filename.endsWith(TestUnitTestingEngine.TEST_UNIT_RUNNER)) {
	return false;
	}
	if (GEM_SHOULDA_LIB.matcher(filename).find()) {
	return false;
	}
	final IPath path = new Path(filename);
	try {
	final IProjectFragment[] fragments = project.getProjectFragments();
	for (int i = 0; i < fragments.length; ++i) {
	final IProjectFragment fragment = fragments[i];
	if (fragment.isExternal()
	&& testFragmentPath(EnvironmentPathUtils
	.getLocalPath(fragment.getPath()), path)
	&& RubyConsoleSourceModuleLookup.isIncluded(fragment,
	path)) {
	return false;
	}
	}
	} catch (ModelException e) {
	return true;
	}
	return true;
	}
	}