public void testCreateConfiguration() throws IOException, ExecutionException {
Module module1 = getModule1();
PsiClass psiClass = findTestA(module1);
JUnitConfiguration configuration = createConfiguration(psiClass);
assertEquals(
Collections.singleton(module1), ContainerUtilRt.newHashSet(configuration.getModules()));
checkClassName(psiClass.getQualifiedName(), configuration);
assertEquals(psiClass.getName(), configuration.getName());
checkTestObject(JUnitConfiguration.TEST_CLASS, configuration);
Module module2 = getModule2();
Assertion.compareUnordered(new Module[] {module1, module2}, configuration.getValidModules());
PsiClass innerTest = findClass(module1, INNER_TEST_NAME);
configuration =
createJUnitConfiguration(
innerTest, TestClassConfigurationProducer.class, new MapDataContext());
checkClassName(RT_INNER_TEST_NAME, configuration);
checkCanRun(configuration);
PsiMethod[] testMethod = innerTest.findMethodsByName("test", false);
assertEquals(1, testMethod.length);
configuration = createConfiguration(testMethod[0]);
checkClassName(RT_INNER_TEST_NAME, configuration);
checkMethodName("test", configuration);
checkTestObject(JUnitConfiguration.TEST_METHOD, configuration);
checkCanRun(configuration);
PsiMethod mainMethod = innerTest.findMethodsByName("main", false)[0];
ApplicationConfiguration appConfiguration = createConfiguration(mainMethod);
assertEquals(RT_INNER_TEST_NAME, appConfiguration.MAIN_CLASS_NAME);
checkCanRun(configuration);
}
@NotNull
private static List<PsiMethod> findMethodsBySignature(
@NotNull PsiClass aClass,
@NotNull PsiMethod patternMethod,
boolean checkBases,
boolean stopOnFirst) {
final PsiMethod[] methodsByName = aClass.findMethodsByName(patternMethod.getName(), checkBases);
if (methodsByName.length == 0) return Collections.emptyList();
final List<PsiMethod> methods = new SmartList<PsiMethod>();
final MethodSignature patternSignature = patternMethod.getSignature(PsiSubstitutor.EMPTY);
for (final PsiMethod method : methodsByName) {
final PsiClass superClass = method.getContainingClass();
final PsiSubstitutor substitutor;
if (checkBases && !aClass.equals(superClass)) {
substitutor =
TypeConversionUtil.getSuperClassSubstitutor(superClass, aClass, PsiSubstitutor.EMPTY);
} else {
substitutor = PsiSubstitutor.EMPTY;
}
final MethodSignature signature = method.getSignature(substitutor);
if (signature.equals(patternSignature)) {
methods.add(method);
if (stopOnFirst) {
break;
}
}
}
return methods;
}
@Nullable
private static String computeConstantReturnValue(PsiClass languagePsiClass, String methodName) {
final PsiMethod[] methods = languagePsiClass.findMethodsByName(methodName, false);
if (methods.length != 1) {
return null;
}
return getStringConstantExpression(methods[0]);
}
private static boolean areMissingMethodsDeclared(GrReferenceExpression ref) {
PsiType qualifierType = GrReferenceResolveUtil.getQualifierType(ref);
if (!(qualifierType instanceof PsiClassType)) return false;
PsiClass resolved = ((PsiClassType) qualifierType).resolve();
if (resolved == null) return false;
if (ref.getParent() instanceof GrCall) {
PsiMethod[] found = resolved.findMethodsByName("methodMissing", true);
for (PsiMethod method : found) {
if (MissingMethodAndPropertyUtil.isMethodMissing(method)) return true;
}
} else {
PsiMethod[] found = resolved.findMethodsByName("propertyMissing", true);
for (PsiMethod method : found) {
if (MissingMethodAndPropertyUtil.isPropertyMissing(method)) return true;
}
}
return false;
}
@Nullable
private PsiType extractListTypeFromContainingClass(PsiElement element) {
PsiClass listClass = PsiTreeUtil.getParentOfType(element, PsiClass.class);
if (listClass == null) {
return null;
}
final PsiMethod[] getMethods = listClass.findMethodsByName("get", true);
if (getMethods.length == 0) {
return null;
}
final PsiType type = getMethods[0].getReturnType();
if (!(type instanceof PsiClassType)) {
return null;
}
final PsiClassType classType = (PsiClassType) type;
final PsiClass parameterClass = classType.resolve();
if (parameterClass == null) {
return null;
}
PsiClass subClass = null;
while (listClass != null && !listClass.hasTypeParameters()) {
subClass = listClass;
listClass = listClass.getSuperClass();
}
if (listClass == null || subClass == null) {
return TypeUtils.getObjectType(element);
}
final PsiTypeParameter[] typeParameters = listClass.getTypeParameters();
if (!parameterClass.equals(typeParameters[0])) {
return TypeUtils.getObjectType(element);
}
final PsiReferenceList extendsList = subClass.getExtendsList();
if (extendsList == null) {
return null;
}
final PsiJavaCodeReferenceElement[] referenceElements = extendsList.getReferenceElements();
if (referenceElements.length == 0) {
return null;
}
final PsiType[] types = referenceElements[0].getTypeParameters();
if (types.length == 0) {
return TypeUtils.getObjectType(element);
}
return types[0];
}
private boolean hasGoodToString(PsiClass aClass) {
final PsiMethod[] methods =
aClass.findMethodsByName(HardcodedMethodConstants.TO_STRING, true);
for (PsiMethod method : methods) {
final PsiClass containingClass = method.getContainingClass();
if (containingClass == null) {
continue;
}
final String name = containingClass.getQualifiedName();
if (CommonClassNames.JAVA_LANG_OBJECT.equals(name)) {
continue;
}
final PsiParameterList parameterList = method.getParameterList();
if (parameterList.getParametersCount() == 0) {
return true;
}
}
return false;
}
@NotNull
public static List<Pair<PsiMethod, PsiSubstitutor>> findMethodsAndTheirSubstitutorsByName(
@NotNull PsiClass psiClass, String name, boolean checkBases) {
if (!checkBases) {
final PsiMethod[] methodsByName = psiClass.findMethodsByName(name, false);
final List<Pair<PsiMethod, PsiSubstitutor>> ret =
new ArrayList<Pair<PsiMethod, PsiSubstitutor>>(methodsByName.length);
for (final PsiMethod method : methodsByName) {
ret.add(new Pair<PsiMethod, PsiSubstitutor>(method, PsiSubstitutor.EMPTY));
}
return ret;
}
Map<String, List<Pair<PsiMember, PsiSubstitutor>>> map = getMap(psiClass, MemberType.METHOD);
@SuppressWarnings("unchecked")
List<Pair<PsiMethod, PsiSubstitutor>> list = (List) map.get(name);
return list == null
? Collections.<Pair<PsiMethod, PsiSubstitutor>>emptyList()
: Collections.unmodifiableList(list);
}
private static boolean areGroovyObjectMethodsOverridden(GrReferenceExpression ref) {
PsiType qualifierType = GrReferenceResolveUtil.getQualifierType(ref);
if (!(qualifierType instanceof PsiClassType)) return false;
PsiClass resolved = ((PsiClassType) qualifierType).resolve();
if (resolved == null) return false;
PsiClass groovyObject =
JavaPsiFacade.getInstance(ref.getProject())
.findClass(GroovyCommonClassNames.GROOVY_OBJECT, ref.getResolveScope());
if (groovyObject == null) return false;
String methodName;
if (ref.getParent() instanceof GrCall) {
methodName = "invokeMethod";
} else if (PsiUtil.isLValue(ref)) {
methodName = "setProperty";
} else {
methodName = "getProperty";
}
PsiMethod[] patternMethods = groovyObject.findMethodsByName(methodName, false);
if (patternMethods.length != 1) return false;
PsiMethod patternMethod = patternMethods[0];
PsiMethod found = resolved.findMethodBySignature(patternMethod, true);
if (found == null) return false;
PsiClass aClass = found.getContainingClass();
if (aClass == null) return false;
String qname = aClass.getQualifiedName();
if (GroovyCommonClassNames.GROOVY_OBJECT.equals(qname)) return false;
if (GroovyCommonClassNames.GROOVY_OBJECT_SUPPORT.equals(qname)) return false;
return true;
}
public static void prepareWizardData(final WizardData data, PsiClass boundClass)
throws MyException {
final PsiMethod[] allGetDataMethods = boundClass.findMethodsByName("getData", false);
final PsiMethod[] allSetDataMethods = boundClass.findMethodsByName("setData", false);
PsiMethod setDataMethod = null;
PsiClass beanClass = null;
// find get/set pair and bean class
outer:
for (int i = 0; i < allGetDataMethods.length; i++) {
final PsiMethod _getMethod = allGetDataMethods[i];
if (_getMethod.getReturnType() != PsiType.VOID) {
continue;
}
final PsiParameter[] _getMethodParameters = _getMethod.getParameterList().getParameters();
if (_getMethodParameters.length != 1) {
continue;
}
final PsiClass _getParameterClass = getClassByType(_getMethodParameters[0].getType());
if (_getParameterClass == null) {
continue;
}
for (final PsiMethod _setMethod : allSetDataMethods) {
if (_setMethod.getReturnType() != PsiType.VOID) {
continue;
}
final PsiParameter[] _setMethodParameters = _setMethod.getParameterList().getParameters();
if (_setMethodParameters.length != 1) {
continue;
}
final PsiClass _setParameterClass = getClassByType(_setMethodParameters[0].getType());
if (_setParameterClass != _getParameterClass) {
continue;
}
// pair found !!!
setDataMethod = _setMethod;
beanClass = _getParameterClass;
break outer;
}
}
if (beanClass == null) {
// nothing found
return;
}
data.myBindToNewBean = false;
data.myBeanClass = beanClass;
// parse setData() and try to associate fields with bean
{
final PsiCodeBlock body = setDataMethod.getBody();
if (body == null) {
return;
}
final PsiElement[] children = body.getChildren();
for (PsiElement child : children) {
// Parses sequences like: a.foo(b.bar());
final PsiField bindingField;
if (!(child instanceof PsiExpressionStatement)) {
continue;
}
final PsiExpression expression = ((PsiExpressionStatement) child).getExpression();
if (!(expression instanceof PsiMethodCallExpression)) {
continue;
}
final PsiMethodCallExpression callExpression = (PsiMethodCallExpression) expression;
// find binding field ('a')
int index = -1;
{
final PsiElement psiElement = getObjectForWhichMethodWasCalled(callExpression);
if (!(psiElement instanceof PsiField)) {
continue;
}
if (((PsiField) psiElement).getContainingClass() != boundClass) {
continue;
}
bindingField = (PsiField) psiElement;
// find binding for this field
final FormProperty2BeanProperty[] bindings = data.myBindings;
for (int j = 0; j < bindings.length; j++) {
final FormProperty2BeanProperty binding = bindings[j];
if (bindingField
.getName()
.equals(binding.myFormProperty.getLwComponent().getBinding())) {
index = j;
break;
}
}
}
if (index == -1) {
continue;
}
// find 'bar()'
{
final PsiReferenceParameterList parameterList =
callExpression.getMethodExpression().getParameterList();
if (parameterList == null) {
continue;
}
final PsiExpressionList argumentList = callExpression.getArgumentList();
if (argumentList == null) {
continue;
}
final PsiExpression[] expressions = argumentList.getExpressions();
if (expressions == null || expressions.length != 1) {
continue;
}
if (!(expressions[0] instanceof PsiMethodCallExpression)) {
continue;
}
final PsiMethodCallExpression callExpression2 =
((PsiMethodCallExpression) expressions[0]);
// check that 'b' is parameter
final PsiElement psiElement = getObjectForWhichMethodWasCalled(callExpression2);
if (!(psiElement instanceof PsiParameter)) {
continue;
}
final PsiMethod barMethod = ((PsiMethod) callExpression2.getMethodExpression().resolve());
if (barMethod == null) {
continue;
}
if (!PropertyUtil.isSimplePropertyGetter(barMethod)) {
continue;
}
final String propertyName = PropertyUtil.getPropertyName(barMethod);
// There are two possible types: boolean and java.lang.String
String typeName = barMethod.getReturnType().getCanonicalText();
if (!"boolean".equals(typeName) && !"java.lang.String".equals(typeName)) {
continue;
}
data.myBindings[index].myBeanProperty = new BeanProperty(propertyName, typeName);
}
}
}
}
private static boolean processDeclarationsInClassNotCached(
@NotNull PsiClass aClass,
@NotNull PsiScopeProcessor processor,
@NotNull ResolveState state,
@Nullable Set<PsiClass> visited,
PsiElement last,
@NotNull PsiElement place,
boolean isRaw,
@NotNull LanguageLevel languageLevel) {
if (visited == null) visited = new THashSet<PsiClass>();
if (!visited.add(aClass)) return true;
processor.handleEvent(PsiScopeProcessor.Event.SET_DECLARATION_HOLDER, aClass);
final ElementClassHint classHint = processor.getHint(ElementClassHint.KEY);
final NameHint nameHint = processor.getHint(NameHint.KEY);
if (classHint == null || classHint.shouldProcess(ElementClassHint.DeclarationKind.FIELD)) {
if (nameHint != null) {
final PsiField fieldByName = aClass.findFieldByName(nameHint.getName(state), false);
if (fieldByName != null && !processor.execute(fieldByName, state)) return false;
} else {
final PsiField[] fields = aClass.getFields();
for (final PsiField field : fields) {
if (!processor.execute(field, state)) return false;
}
}
}
PsiElementFactory factory = JavaPsiFacade.getInstance(aClass.getProject()).getElementFactory();
if (classHint == null || classHint.shouldProcess(ElementClassHint.DeclarationKind.METHOD)) {
PsiSubstitutor baseSubstitutor = state.get(PsiSubstitutor.KEY);
final PsiMethod[] methods =
nameHint != null
? aClass.findMethodsByName(nameHint.getName(state), false)
: aClass.getMethods();
for (final PsiMethod method : methods) {
PsiSubstitutor finalSubstitutor = checkRaw(isRaw, factory, method, baseSubstitutor);
ResolveState methodState =
finalSubstitutor == baseSubstitutor
? state
: state.put(PsiSubstitutor.KEY, finalSubstitutor);
if (!processor.execute(method, methodState)) return false;
}
}
if (classHint == null || classHint.shouldProcess(ElementClassHint.DeclarationKind.CLASS)) {
if (last != null && last.getParent() == aClass) {
// Parameters
final PsiTypeParameterList list = aClass.getTypeParameterList();
if (list != null
&& !list.processDeclarations(processor, ResolveState.initial(), last, place))
return false;
}
if (!(last instanceof PsiReferenceList) && !(last instanceof PsiModifierList)) {
// Inners
if (nameHint != null) {
final PsiClass inner = aClass.findInnerClassByName(nameHint.getName(state), false);
if (inner != null) {
if (!processor.execute(inner, state)) return false;
}
} else {
final PsiClass[] inners = aClass.getInnerClasses();
for (final PsiClass inner : inners) {
if (!processor.execute(inner, state)) return false;
}
}
}
}
return last instanceof PsiReferenceList
|| processSuperTypes(
aClass, processor, visited, last, place, state, isRaw, factory, languageLevel);
}
