azalea/kotlin-fork
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Remove ClassLoaderIsolationUtil

Browse Source 
Minimize usages of jet.* in Java code: this will help in migration of jet.* to
package kotlin. Since tests will work with fq names instead of Class<?>
instances from now on, ClassLoaderIsolationUtil is useless now (except for one
unrelated method, which was moved to CodegenTestUtil)
This commit is contained in:
Alexander Udalov
2014-02-14 17:32:11 +04:00
parent eb7b757e38
commit 339a990482
9 changed files with 66 additions and 99 deletions
Download Patch File Download Diff File Expand all files Collapse all files
compiler/tests/org/jetbrains/jet/codegen/AnnotationGenTest.java
+8 -8
View File
@@ -16,7 +16,7 @@
package org.jetbrains.jet.codegen;
import jet.JetObject;
import com.google.common.collect.Sets;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
import org.jetbrains.jet.ConfigurationKind;
@@ -222,17 +222,17 @@ public class AnnotationGenTest extends CodegenTestCase {
assertNotNull(annotation);
}
public void testSimplestAnnotationClass() throws NoSuchFieldException, NoSuchMethodException {
public void testSimplestAnnotationClass() {
loadText("annotation class A");
Class aClass = generateClass("A");
Class<?> aClass = generateClass("A");
Class[] interfaces = aClass.getInterfaces();
assertEquals(2, interfaces.length);
assertEquals(0, aClass.getDeclaredMethods().length);
Class annotationClass = getCorrespondingClass(Annotation.class);
Class jetObjectClass = getCorrespondingClass(JetObject.class);
assertTrue(annotationClass == interfaces[0] || annotationClass == interfaces[1]);
assertTrue(jetObjectClass == interfaces[0] || jetObjectClass == interfaces[1]);
assertTrue(aClass.isAnnotation());
assertEquals(2, interfaces.length);
assertEquals(
Sets.newHashSet("java.lang.annotation.Annotation", "jet.JetObject"),
Sets.newHashSet(interfaces[0].getName(), interfaces[1].getName())
);
}
public void testAnnotationClassWithStringProperty()
compiler/tests/org/jetbrains/jet/codegen/ClassLoaderIsolationUtil.java
-46
View File
@@ -1,46 +0,0 @@
package org.jetbrains.jet.codegen;
import junit.framework.Assert;
import org.jetbrains.annotations.NotNull;
import java.lang.annotation.Annotation;
import java.lang.reflect.InvocationTargetException;
import static junit.framework.Assert.*;
public class ClassLoaderIsolationUtil {
public static void assertEquals(Class<?> expected, Class<?> actual) {
if (actual == null) {
assertNull(expected);
}
else Assert.assertEquals(getClassFromClassLoader(expected, actual.getClassLoader()), actual);
}
public static Class<? extends Annotation> getAnnotationClass(Class<? extends Annotation> annotationClass, ClassLoader classLoader) {
return (Class<? extends Annotation>) getClassFromClassLoader(annotationClass, classLoader);
}
public static Object getAnnotationAttribute(Object annotation, String name) {
try {
return annotation.getClass().getMethod(name).invoke(annotation);
}
catch (Exception e) {
e.printStackTrace();
fail(e.getMessage());
}
return null;
}
@NotNull
public static Class<?> getClassFromClassLoader(Class<?> classForName, ClassLoader classLoader) {
try {
return classLoader.loadClass(classForName.getName());
}
catch (ClassNotFoundException e) {
e.printStackTrace();
fail(e.getMessage());
}
return null;
}
}
compiler/tests/org/jetbrains/jet/codegen/CodegenTestCase.java
+10 -6
View File
@@ -38,6 +38,7 @@ import org.jetbrains.jet.cli.jvm.compiler.JetCoreEnvironment;
import org.jetbrains.jet.codegen.forTestCompile.ForTestCompileRuntime;
import org.jetbrains.jet.lang.psi.JetPsiUtil;
import org.jetbrains.jet.lang.resolve.name.FqName;
import org.jetbrains.jet.utils.UtilsPackage;
import java.io.File;
import java.io.IOException;
@@ -282,11 +283,14 @@ public abstract class CodegenTestCase extends UsefulTestCase {
return method;
}
public Class<? extends Annotation> getCorrespondingAnnotationClass(Class<? extends Annotation> classForName) {
return ClassLoaderIsolationUtil.getAnnotationClass(classForName, initializedClassLoader);
}
public Class<?> getCorrespondingClass(Class<?> classForName) {
return ClassLoaderIsolationUtil.getClassFromClassLoader(classForName, initializedClassLoader);
@NotNull
public Class<? extends Annotation> loadAnnotationClassQuietly(@NotNull String fqName) {
try {
//noinspection unchecked
return (Class<? extends Annotation>) initializedClassLoader.loadClass(fqName);
}
catch (ClassNotFoundException e) {
throw UtilsPackage.rethrow(e);
}
}
}
compiler/tests/org/jetbrains/jet/codegen/CodegenTestUtil.java
+10
View File
@@ -138,4 +138,14 @@ public class CodegenTestUtil {
}
return r;
}
@Nullable
public static Object getAnnotationAttribute(@NotNull Object annotation, @NotNull String name) {
try {
return annotation.getClass().getMethod(name).invoke(annotation);
}
catch (Exception e) {
throw UtilsPackage.rethrow(e);
}
}
}
compiler/tests/org/jetbrains/jet/codegen/JUnitUsageGenTest.java
+5 -4
View File
@@ -50,9 +50,10 @@ public class JUnitUsageGenTest extends CodegenTestCase {
Class<?> packageClass = generatePackageClass();
Method method = packageClass.getMethod("foo", Method.class);
method.setAccessible(true);
Annotation annotation = method.getAnnotation(getCorrespondingAnnotationClass(Test.class));
assertEquals(ClassLoaderIsolationUtil.getAnnotationAttribute(annotation, "timeout"), 0l);
ClassLoaderIsolationUtil.assertEquals(Test.None.class, (Class<?>) ClassLoaderIsolationUtil.getAnnotationAttribute(annotation,
"expected"));
Annotation annotation = method.getAnnotation(loadAnnotationClassQuietly(Test.class.getName()));
assertEquals(CodegenTestUtil.getAnnotationAttribute(annotation, "timeout"), Long.valueOf(0));
Class<?> expected = (Class<?>) CodegenTestUtil.getAnnotationAttribute(annotation, "expected");
assertNotNull(expected);
assertEquals(Test.None.class.getName(), expected.getName());
}
}
compiler/tests/org/jetbrains/jet/codegen/JetValueParameterAnnotationTest.java
+16 -22
View File
@@ -16,7 +16,6 @@
package org.jetbrains.jet.codegen;
import jet.runtime.typeinfo.JetValueParameter;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.jet.ConfigurationKind;
@@ -30,24 +29,19 @@ public class JetValueParameterAnnotationTest extends CodegenTestCase {
createEnvironmentWithMockJdkAndIdeaAnnotations(ConfigurationKind.JDK_ONLY);
}
private static class ValueParameter {
public final String name;
public final String type;
private ValueParameter(@NotNull String name, @NotNull String type) {
this.name = name;
this.type = type;
}
}
@NotNull
private static JetValueParameter valueParameter(@NotNull final String name, final boolean nullable) {
return new JetValueParameter() {
@Override
public String name() {
return name;
}
@Override
public String type() {
return nullable ? "?" : "";
}
@Override
public Class<? extends Annotation> annotationType() {
return JetValueParameter.class;
}
};
private static ValueParameter valueParameter(@NotNull String name, boolean nullable) {
return new ValueParameter(name, nullable ? "?" : "");
}
public void testOneNotNullParam() {
@@ -95,7 +89,7 @@ public class JetValueParameterAnnotationTest extends CodegenTestCase {
);
}
private void doTest(@NotNull String code, @NotNull JetValueParameter... expected) {
private void doTest(@NotNull String code, @NotNull ValueParameter... expected) {
loadText(code);
Annotation[][] annotations = generateFunction().getParameterAnnotations();
@@ -104,9 +98,9 @@ public class JetValueParameterAnnotationTest extends CodegenTestCase {
for (int i = 0, length = annotations.length; i < length; i++) {
assertSize(1, annotations[i]);
Annotation annotation = annotations[i][0];
ClassLoaderIsolationUtil.assertEquals(JetValueParameter.class, annotation.annotationType());
assertEquals(expected[i].name(), ClassLoaderIsolationUtil.getAnnotationAttribute(annotation, "name"));
assertEquals(expected[i].type(), ClassLoaderIsolationUtil.getAnnotationAttribute(annotation, "type"));
assertEquals("jet.runtime.typeinfo.JetValueParameter", annotation.annotationType().getName());
assertEquals(expected[i].name, CodegenTestUtil.getAnnotationAttribute(annotation, "name"));
assertEquals(expected[i].type, CodegenTestUtil.getAnnotationAttribute(annotation, "type"));
}
}
}
compiler/tests/org/jetbrains/jet/codegen/KotlinClassAnnotationTest.java
+6 -4
View File
@@ -16,10 +16,10 @@
package org.jetbrains.jet.codegen;
import jet.KotlinClass;
import org.jetbrains.jet.ConfigurationKind;
import org.jetbrains.jet.descriptors.serialization.ClassData;
import org.jetbrains.jet.descriptors.serialization.JavaProtoBufUtil;
import org.jetbrains.jet.lang.resolve.java.JvmAnnotationNames;
import org.jetbrains.jet.lang.resolve.name.FqName;
import org.jetbrains.jet.lang.resolve.name.FqNameUnsafe;
@@ -48,13 +48,15 @@ public class KotlinClassAnnotationTest extends CodegenTestCase {
"}\n");
Class aClass = generateClass(PACKAGE_NAME + "." + CLASS_NAME);
Class<? extends Annotation> annotationClass = getCorrespondingAnnotationClass(KotlinClass.class);
Class<? extends Annotation> annotationClass = loadAnnotationClassQuietly(JvmAnnotationNames.KOTLIN_CLASS.asString());
assertTrue(aClass.isAnnotationPresent(annotationClass));
Annotation kotlinClass = aClass.getAnnotation(annotationClass);
ClassData data = JavaProtoBufUtil.readClassDataFrom((String[]) ClassLoaderIsolationUtil.getAnnotationAttribute(kotlinClass, "data"));
String[] data = (String[]) CodegenTestUtil.getAnnotationAttribute(kotlinClass, "data");
assertNotNull(data);
ClassData classData = JavaProtoBufUtil.readClassDataFrom(data);
Set<String> callableNames = collectCallableNames(data.getClassProto().getMemberList(), data.getNameResolver());
Set<String> callableNames = collectCallableNames(classData.getClassProto().getMemberList(), classData.getNameResolver());
assertSameElements(Arrays.asList("foo", "bar"), callableNames);
}
}
compiler/tests/org/jetbrains/jet/codegen/KotlinPackageAnnotationTest.java
+6 -5
View File
@@ -16,13 +16,13 @@
package org.jetbrains.jet.codegen;
import jet.KotlinPackage;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.jet.ConfigurationKind;
import org.jetbrains.jet.descriptors.serialization.JavaProtoBufUtil;
import org.jetbrains.jet.descriptors.serialization.NameResolver;
import org.jetbrains.jet.descriptors.serialization.PackageData;
import org.jetbrains.jet.descriptors.serialization.ProtoBuf;
import org.jetbrains.jet.lang.resolve.java.JvmAnnotationNames;
import org.jetbrains.jet.lang.resolve.java.PackageClassUtils;
import org.jetbrains.jet.lang.resolve.name.FqName;
@@ -52,16 +52,17 @@ public class KotlinPackageAnnotationTest extends CodegenTestCase {
"object C\n");
Class aClass = generateClass(PackageClassUtils.getPackageClassFqName(PACKAGE_NAME).asString());
Class<? extends Annotation> annotationClass = getCorrespondingAnnotationClass(KotlinPackage.class);
Class<? extends Annotation> annotationClass = loadAnnotationClassQuietly(JvmAnnotationNames.KOTLIN_PACKAGE.asString());
assertTrue(aClass.isAnnotationPresent(annotationClass));
assertTrue(aClass.isAnnotationPresent(annotationClass));
Annotation kotlinPackage = aClass.getAnnotation(annotationClass);
PackageData data = JavaProtoBufUtil.readPackageDataFrom((String[]) ClassLoaderIsolationUtil.getAnnotationAttribute(kotlinPackage,
"data"));
String[] data = (String[]) CodegenTestUtil.getAnnotationAttribute(kotlinPackage, "data");
assertNotNull(data);
PackageData packageData = JavaProtoBufUtil.readPackageDataFrom(data);
Set<String> callableNames = collectCallableNames(data.getPackageProto().getMemberList(), data.getNameResolver());
Set<String> callableNames = collectCallableNames(packageData.getPackageProto().getMemberList(), packageData.getNameResolver());
assertSameElements(callableNames, Arrays.asList("foo", "bar"));
}
compiler/tests/org/jetbrains/jet/codegen/KotlinPackageFragmentAnnotationTest.java
+5 -4
View File
@@ -16,11 +16,11 @@
package org.jetbrains.jet.codegen;
import jet.KotlinPackageFragment;
import org.jetbrains.jet.ConfigurationKind;
import org.jetbrains.jet.OutputFile;
import org.jetbrains.jet.OutputFileCollection;
import org.jetbrains.jet.lang.resolve.java.AbiVersionUtil;
import org.jetbrains.jet.lang.resolve.java.JvmAnnotationNames;
import org.jetbrains.jet.lang.resolve.java.JvmClassName;
import org.jetbrains.jet.lang.resolve.java.PackageClassUtils;
import org.jetbrains.jet.lang.resolve.name.FqName;
@@ -49,16 +49,17 @@ public class KotlinPackageFragmentAnnotationTest extends CodegenTestCase {
String fqName = filePath.substring(0, filePath.length() - ".class".length()).replace('/', '.');
Class aClass = generateClass(fqName);
Class<? extends Annotation> annotationClass = getCorrespondingAnnotationClass(KotlinPackageFragment.class);
Class<? extends Annotation> annotationClass = loadAnnotationClassQuietly(JvmAnnotationNames.KOTLIN_PACKAGE_FRAGMENT.asString());
assertTrue("No KotlinPackageFragment annotation on a package fragment",
aClass.isAnnotationPresent(annotationClass));
Annotation kotlinPackageFragment = aClass.getAnnotation(annotationClass);
Integer version = (Integer) CodegenTestUtil.getAnnotationAttribute(kotlinPackageFragment, "abiVersion");
assertNotNull(version);
assertTrue("KotlinPackageFragment annotation is written with an unsupported format",
AbiVersionUtil.isAbiVersionCompatible(
(Integer) ClassLoaderIsolationUtil.getAnnotationAttribute(kotlinPackageFragment, "abiVersion")));
AbiVersionUtil.isAbiVersionCompatible(version));
return;
}