public static boolean inheritsITestListener(@NotNull PsiClass psiClass) {
final Project project = psiClass.getProject();
final PsiClass aListenerClass =
JavaPsiFacade.getInstance(project)
.findClass(ITestNGListener.class.getName(), GlobalSearchScope.allScope(project));
return aListenerClass != null && psiClass.isInheritor(aListenerClass, true);
}
/** @return were javadoc params used */
public static void collectAnnotationValues(
final Map<String, Collection<String>> results, PsiMethod[] psiMethods, PsiClass... classes) {
final Set<String> test = new HashSet<>(1);
test.add(TEST_ANNOTATION_FQN);
ContainerUtil.addAll(test, CONFIG_ANNOTATIONS_FQN);
if (psiMethods != null) {
for (final PsiMethod psiMethod : psiMethods) {
ApplicationManager.getApplication()
.runReadAction(
() ->
appendAnnotationAttributeValues(
results, AnnotationUtil.findAnnotation(psiMethod, test), psiMethod));
}
} else {
for (final PsiClass psiClass : classes) {
ApplicationManager.getApplication()
.runReadAction(
() -> {
if (psiClass != null && hasTest(psiClass)) {
appendAnnotationAttributeValues(
results, AnnotationUtil.findAnnotation(psiClass, test), psiClass);
PsiMethod[] methods = psiClass.getMethods();
for (PsiMethod method : methods) {
if (method != null) {
appendAnnotationAttributeValues(
results, AnnotationUtil.findAnnotation(method, test), method);
}
}
}
});
}
}
}
/**
* Filter the specified collection of classes to return only ones that contain any of the
* specified values in the specified annotation parameter. For example, this method can be used to
* return all classes that contain all tesng annotations that are in the groups 'foo' or 'bar'.
*/
public static Map<PsiClass, Collection<PsiMethod>> filterAnnotations(
String parameter, Set<String> values, Collection<PsiClass> classes) {
Map<PsiClass, Collection<PsiMethod>> results = new HashMap<>();
Set<String> test = new HashSet<>(1);
test.add(TEST_ANNOTATION_FQN);
ContainerUtil.addAll(test, CONFIG_ANNOTATIONS_FQN);
for (PsiClass psiClass : classes) {
if (isBrokenPsiClass(psiClass)) continue;
PsiAnnotation annotation;
try {
annotation = AnnotationUtil.findAnnotation(psiClass, test);
} catch (Exception e) {
LOGGER.error(
"Exception trying to findAnnotation on "
+ psiClass.getClass().getName()
+ ".\n\n"
+ e.getMessage());
annotation = null;
}
if (annotation != null) {
if (isAnnotatedWithParameter(annotation, parameter, values)) {
results.put(psiClass, new LinkedHashSet<>());
}
} else {
Collection<String> matches =
extractAnnotationValuesFromJavaDoc(getTextJavaDoc(psiClass), parameter);
for (String s : matches) {
if (values.contains(s)) {
results.put(psiClass, new LinkedHashSet<>());
break;
}
}
}
// we already have the class, no need to look through its methods
PsiMethod[] methods = psiClass.getMethods();
for (PsiMethod method : methods) {
if (method != null) {
annotation = AnnotationUtil.findAnnotation(method, test);
if (annotation != null) {
if (isAnnotatedWithParameter(annotation, parameter, values)) {
if (results.get(psiClass) == null) results.put(psiClass, new LinkedHashSet<>());
results.get(psiClass).add(method);
}
} else {
Collection<String> matches =
extractAnnotationValuesFromJavaDoc(getTextJavaDoc(psiClass), parameter);
for (String s : matches) {
if (values.contains(s)) {
results.get(psiClass).add(method);
}
}
}
}
}
}
return results;
}
public static boolean inheritsJUnitTestCase(PsiClass psiClass) {
PsiClass current = psiClass;
while (current != null) {
PsiClass[] supers = current.getSupers();
if (supers.length > 0) {
PsiClass parent = supers[0];
if ("junit.framework.TestCase".equals(parent.getQualifiedName())) return true;
current = parent;
// handle typo where class extends itself
if (current == psiClass) return false;
} else {
current = null;
}
}
return false;
}
public static boolean containsJunitAnnotions(PsiClass psiClass) {
if (psiClass != null) {
for (PsiMethod method : psiClass.getMethods()) {
if (containsJunitAnnotions(method)) {
return true;
}
}
}
return false;
}
public static boolean hasTest(
PsiModifierListOwner element,
boolean checkHierarchy,
boolean checkDisabled,
boolean checkJavadoc) {
// LanguageLevel effectiveLanguageLevel = element.getManager().getEffectiveLanguageLevel();
// boolean is15 = effectiveLanguageLevel != LanguageLevel.JDK_1_4 && effectiveLanguageLevel !=
// LanguageLevel.JDK_1_3;
boolean hasAnnotation =
AnnotationUtil.isAnnotated(element, TEST_ANNOTATION_FQN, checkHierarchy, true);
if (hasAnnotation) {
if (checkDisabled) {
PsiAnnotation annotation =
AnnotationUtil.findAnnotation(element, true, TEST_ANNOTATION_FQN);
if (annotation != null) {
if (isDisabled(annotation)) return false;
}
}
return true;
}
if (element instanceof PsiDocCommentOwner
&& checkJavadoc
&& getTextJavaDoc((PsiDocCommentOwner) element) != null) return true;
// now we check all methods for the test annotation
if (element instanceof PsiClass) {
PsiClass psiClass = (PsiClass) element;
for (PsiMethod method : psiClass.getAllMethods()) {
PsiAnnotation annotation = AnnotationUtil.findAnnotation(method, true, TEST_ANNOTATION_FQN);
if (annotation != null) {
if (checkDisabled) {
if (isDisabled(annotation)) continue;
}
return true;
}
if (AnnotationUtil.isAnnotated(method, FACTORY_ANNOTATION_FQN, false, true)) return true;
if (checkJavadoc && getTextJavaDoc(method) != null) return true;
}
return false;
} else if (element instanceof PsiMethod) {
// even if it has a global test, we ignore private and static methods
if (element.hasModifierProperty(PsiModifier.PRIVATE)
|| element.hasModifierProperty(PsiModifier.STATIC)) {
return false;
}
// if it's a method, we check if the class it's in has a global @Test annotation
PsiClass psiClass = ((PsiMethod) element).getContainingClass();
if (psiClass != null) {
final PsiAnnotation annotation =
checkHierarchy
? AnnotationUtil.findAnnotationInHierarchy(
psiClass, Collections.singleton(TEST_ANNOTATION_FQN))
: AnnotationUtil.findAnnotation(psiClass, true, TEST_ANNOTATION_FQN);
if (annotation != null) {
if (checkDisabled && isDisabled(annotation)) return false;
return !hasConfig(element);
} else if (checkJavadoc && getTextJavaDoc(psiClass) != null) return true;
}
}
return false;
}