private static void checkLeakingParameters(Class<?> jClass) throws IOException {
final HashMap<Method, boolean[]> map = new HashMap<Method, boolean[]>();
// collecting leakedParameters
final ClassReader classReader =
new ClassReader(
new FileInputStream(
jClass.getResource("/" + jClass.getName().replace('.', '/') + ".class").getFile()));
classReader.accept(
new ClassVisitor(Opcodes.ASM5) {
@Override
public MethodVisitor visitMethod(
int access, String name, String desc, String signature, String[] exceptions) {
final MethodNode node =
new MethodNode(Opcodes.ASM5, access, name, desc, signature, exceptions);
final Method method = new Method(classReader.getClassName(), name, desc);
return new MethodVisitor(Opcodes.ASM5, node) {
@Override
public void visitEnd() {
super.visitEnd();
try {
map.put(
method,
LeakingParameters.build(classReader.getClassName(), node, false).parameters);
} catch (AnalyzerException ignore) {
}
}
};
}
},
ClassReader.SKIP_DEBUG | ClassReader.SKIP_FRAMES);
for (java.lang.reflect.Method jMethod : jClass.getDeclaredMethods()) {
Method method =
new Method(
Type.getType(jClass).getInternalName(),
jMethod.getName(),
Type.getMethodDescriptor(jMethod));
Annotation[][] annotations = jMethod.getParameterAnnotations();
for (int i = 0; i < annotations.length; i++) {
boolean isLeaking = false;
Annotation[] parameterAnnotations = annotations[i];
for (Annotation parameterAnnotation : parameterAnnotations) {
if (parameterAnnotation.annotationType() == ExpectLeaking.class) {
isLeaking = true;
}
}
assertEquals(method.toString() + " #" + i, isLeaking, map.get(method)[i]);
}
}
}
private void checkAnnotations(Class<?> javaClass) {
PsiClass psiClass =
myJavaPsiFacade.findClass(
javaClass.getName(), GlobalSearchScope.moduleWithLibrariesScope(myModule));
assertNotNull(psiClass);
for (java.lang.reflect.Method javaMethod : javaClass.getDeclaredMethods()) {
PsiMethod psiMethod = psiClass.findMethodsByName(javaMethod.getName(), false)[0];
Annotation[][] annotations = javaMethod.getParameterAnnotations();
// not-null parameters
params:
for (int i = 0; i < annotations.length; i++) {
Annotation[] parameterAnnotations = annotations[i];
PsiParameter psiParameter = psiMethod.getParameterList().getParameters()[i];
PsiAnnotation inferredAnnotation =
myInferredAnnotationsManager.findInferredAnnotation(
psiParameter, AnnotationUtil.NOT_NULL);
for (Annotation parameterAnnotation : parameterAnnotations) {
if (parameterAnnotation.annotationType() == ExpectNotNull.class) {
assertNotNull(javaMethod.toString() + " " + i, inferredAnnotation);
continue params;
}
}
assertNull(javaMethod.toString() + " " + i, inferredAnnotation);
}
// not-null result
ExpectNotNull expectedAnnotation = javaMethod.getAnnotation(ExpectNotNull.class);
PsiAnnotation actualAnnotation =
myInferredAnnotationsManager.findInferredAnnotation(psiMethod, AnnotationUtil.NOT_NULL);
assertEquals(javaMethod.toString(), expectedAnnotation == null, actualAnnotation == null);
// contracts
ExpectContract expectedContract = javaMethod.getAnnotation(ExpectContract.class);
PsiAnnotation actualContractAnnotation =
myInferredAnnotationsManager.findInferredAnnotation(
psiMethod, ORG_JETBRAINS_ANNOTATIONS_CONTRACT);
assertEquals(expectedContract == null, actualContractAnnotation == null);
if (expectedContract != null) {
String expectedContractValue = expectedContract.value();
String actualContractValue =
AnnotationUtil.getStringAttributeValue(actualContractAnnotation, null);
assertEquals(javaMethod.toString(), expectedContractValue, actualContractValue);
}
}
}