From 339a99048246b11810b7ef8a9c66bcd4156b8654 Mon Sep 17 00:00:00 2001 From: Alexander Udalov Date: Fri, 14 Feb 2014 17:32:11 +0400 Subject: [PATCH] Remove ClassLoaderIsolationUtil 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) --- .../jet/codegen/AnnotationGenTest.java | 16 +++---- .../jet/codegen/ClassLoaderIsolationUtil.java | 46 ------------------- .../jet/codegen/CodegenTestCase.java | 16 ++++--- .../jet/codegen/CodegenTestUtil.java | 10 ++++ .../jet/codegen/JUnitUsageGenTest.java | 9 ++-- .../JetValueParameterAnnotationTest.java | 38 +++++++-------- .../codegen/KotlinClassAnnotationTest.java | 10 ++-- .../codegen/KotlinPackageAnnotationTest.java | 11 +++-- .../KotlinPackageFragmentAnnotationTest.java | 9 ++-- 9 files changed, 66 insertions(+), 99 deletions(-) delete mode 100644 compiler/tests/org/jetbrains/jet/codegen/ClassLoaderIsolationUtil.java diff --git a/compiler/tests/org/jetbrains/jet/codegen/AnnotationGenTest.java b/compiler/tests/org/jetbrains/jet/codegen/AnnotationGenTest.java index 3726611eee6..c51c06b7d5f 100644 --- a/compiler/tests/org/jetbrains/jet/codegen/AnnotationGenTest.java +++ b/compiler/tests/org/jetbrains/jet/codegen/AnnotationGenTest.java @@ -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() diff --git a/compiler/tests/org/jetbrains/jet/codegen/ClassLoaderIsolationUtil.java b/compiler/tests/org/jetbrains/jet/codegen/ClassLoaderIsolationUtil.java deleted file mode 100644 index 2a3afca794b..00000000000 --- a/compiler/tests/org/jetbrains/jet/codegen/ClassLoaderIsolationUtil.java +++ /dev/null @@ -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 getAnnotationClass(Class annotationClass, ClassLoader classLoader) { - return (Class) 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; - } -} diff --git a/compiler/tests/org/jetbrains/jet/codegen/CodegenTestCase.java b/compiler/tests/org/jetbrains/jet/codegen/CodegenTestCase.java index 451711b18cf..71c1f851f63 100644 --- a/compiler/tests/org/jetbrains/jet/codegen/CodegenTestCase.java +++ b/compiler/tests/org/jetbrains/jet/codegen/CodegenTestCase.java @@ -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 getCorrespondingAnnotationClass(Class classForName) { - return ClassLoaderIsolationUtil.getAnnotationClass(classForName, initializedClassLoader); - } - - public Class getCorrespondingClass(Class classForName) { - return ClassLoaderIsolationUtil.getClassFromClassLoader(classForName, initializedClassLoader); + @NotNull + public Class loadAnnotationClassQuietly(@NotNull String fqName) { + try { + //noinspection unchecked + return (Class) initializedClassLoader.loadClass(fqName); + } + catch (ClassNotFoundException e) { + throw UtilsPackage.rethrow(e); + } } } diff --git a/compiler/tests/org/jetbrains/jet/codegen/CodegenTestUtil.java b/compiler/tests/org/jetbrains/jet/codegen/CodegenTestUtil.java index 4f117561650..2e611fe9673 100644 --- a/compiler/tests/org/jetbrains/jet/codegen/CodegenTestUtil.java +++ b/compiler/tests/org/jetbrains/jet/codegen/CodegenTestUtil.java @@ -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); + } + } } diff --git a/compiler/tests/org/jetbrains/jet/codegen/JUnitUsageGenTest.java b/compiler/tests/org/jetbrains/jet/codegen/JUnitUsageGenTest.java index c2bceb0165c..d4e139e1b64 100644 --- a/compiler/tests/org/jetbrains/jet/codegen/JUnitUsageGenTest.java +++ b/compiler/tests/org/jetbrains/jet/codegen/JUnitUsageGenTest.java @@ -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()); } } diff --git a/compiler/tests/org/jetbrains/jet/codegen/JetValueParameterAnnotationTest.java b/compiler/tests/org/jetbrains/jet/codegen/JetValueParameterAnnotationTest.java index 4552ed17388..a95ae091b8d 100644 --- a/compiler/tests/org/jetbrains/jet/codegen/JetValueParameterAnnotationTest.java +++ b/compiler/tests/org/jetbrains/jet/codegen/JetValueParameterAnnotationTest.java @@ -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 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")); } } } diff --git a/compiler/tests/org/jetbrains/jet/codegen/KotlinClassAnnotationTest.java b/compiler/tests/org/jetbrains/jet/codegen/KotlinClassAnnotationTest.java index 909f0abe9c7..a5f1fa8ada1 100644 --- a/compiler/tests/org/jetbrains/jet/codegen/KotlinClassAnnotationTest.java +++ b/compiler/tests/org/jetbrains/jet/codegen/KotlinClassAnnotationTest.java @@ -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 annotationClass = getCorrespondingAnnotationClass(KotlinClass.class); + Class 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 callableNames = collectCallableNames(data.getClassProto().getMemberList(), data.getNameResolver()); + Set callableNames = collectCallableNames(classData.getClassProto().getMemberList(), classData.getNameResolver()); assertSameElements(Arrays.asList("foo", "bar"), callableNames); } } diff --git a/compiler/tests/org/jetbrains/jet/codegen/KotlinPackageAnnotationTest.java b/compiler/tests/org/jetbrains/jet/codegen/KotlinPackageAnnotationTest.java index aaa9db1c355..01240ba7fc7 100644 --- a/compiler/tests/org/jetbrains/jet/codegen/KotlinPackageAnnotationTest.java +++ b/compiler/tests/org/jetbrains/jet/codegen/KotlinPackageAnnotationTest.java @@ -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 annotationClass = getCorrespondingAnnotationClass(KotlinPackage.class); + Class 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 callableNames = collectCallableNames(data.getPackageProto().getMemberList(), data.getNameResolver()); + Set callableNames = collectCallableNames(packageData.getPackageProto().getMemberList(), packageData.getNameResolver()); assertSameElements(callableNames, Arrays.asList("foo", "bar")); } diff --git a/compiler/tests/org/jetbrains/jet/codegen/KotlinPackageFragmentAnnotationTest.java b/compiler/tests/org/jetbrains/jet/codegen/KotlinPackageFragmentAnnotationTest.java index 5c0f79b18b3..588a188e2c0 100644 --- a/compiler/tests/org/jetbrains/jet/codegen/KotlinPackageFragmentAnnotationTest.java +++ b/compiler/tests/org/jetbrains/jet/codegen/KotlinPackageFragmentAnnotationTest.java @@ -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 annotationClass = getCorrespondingAnnotationClass(KotlinPackageFragment.class); + Class 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; }