From 86cc1db6097b7a1faa885a85e9614798df306534 Mon Sep 17 00:00:00 2001 From: "Pavel V. Talanov" Date: Sun, 11 Nov 2012 13:52:15 +0400 Subject: [PATCH] Refactor: extract superclass from AnnotationJavaDescriptorResolverTest --- .../AbstractJavaResolverDescriptorTest.java | 72 +++++++++++++++++++ .../AnnotationJavaDescriptorResolverTest.java | 54 +++----------- 2 files changed, 80 insertions(+), 46 deletions(-) create mode 100644 compiler/tests/org/jetbrains/jet/jvm/compiler/AbstractJavaResolverDescriptorTest.java diff --git a/compiler/tests/org/jetbrains/jet/jvm/compiler/AbstractJavaResolverDescriptorTest.java b/compiler/tests/org/jetbrains/jet/jvm/compiler/AbstractJavaResolverDescriptorTest.java new file mode 100644 index 00000000000..9068668c23e --- /dev/null +++ b/compiler/tests/org/jetbrains/jet/jvm/compiler/AbstractJavaResolverDescriptorTest.java @@ -0,0 +1,72 @@ +/* + * Copyright 2010-2012 JetBrains s.r.o. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.jetbrains.jet.jvm.compiler; + +import org.jetbrains.annotations.NotNull; +import org.jetbrains.annotations.Nullable; +import org.jetbrains.jet.CompileCompilerDependenciesTest; +import org.jetbrains.jet.ConfigurationKind; +import org.jetbrains.jet.JetTestUtils; +import org.jetbrains.jet.TestJdkKind; +import org.jetbrains.jet.cli.jvm.compiler.JetCoreEnvironment; +import org.jetbrains.jet.di.InjectorForJavaSemanticServices; +import org.jetbrains.jet.lang.resolve.java.JavaDescriptorResolver; +import org.jetbrains.jet.test.TestCaseWithTmpdir; + +import java.io.File; +import java.io.IOException; +import java.util.ArrayList; +import java.util.Collections; +import java.util.List; + +public abstract class AbstractJavaResolverDescriptorTest extends TestCaseWithTmpdir { + + protected JavaDescriptorResolver javaDescriptorResolver; + + protected void compileJavaFile(@NotNull String fileRelativePath, @Nullable String classPath) + throws IOException { + File javaFile = new File(getPath() + fileRelativePath); + assertNotNull(javaFile); + List options = new ArrayList(); + options.add("-d"); + options.add(tmpdir.getPath()); + if (classPath != null) { + options.add("-cp"); + options.add(classPath); + } + JetTestUtils.compileJavaFiles(Collections.singleton(javaFile), options); + } + + @NotNull + protected abstract String getPath(); + + + @Override + public void setUp() throws Exception { + super.setUp(); + setUpJavaDescriptorResolver(); + } + + private void setUpJavaDescriptorResolver() { + JetCoreEnvironment jetCoreEnvironment = + new JetCoreEnvironment(myTestRootDisposable, CompileCompilerDependenciesTest.compilerConfigurationForTests( + ConfigurationKind.JDK_ONLY, TestJdkKind.MOCK_JDK, JetTestUtils.getAnnotationsJar(), tmpdir)); + + InjectorForJavaSemanticServices injector = new InjectorForJavaSemanticServices(jetCoreEnvironment.getProject()); + javaDescriptorResolver = injector.getJavaDescriptorResolver(); + } +} diff --git a/compiler/tests/org/jetbrains/jet/jvm/compiler/AnnotationJavaDescriptorResolverTest.java b/compiler/tests/org/jetbrains/jet/jvm/compiler/AnnotationJavaDescriptorResolverTest.java index 44f955ae959..b967cb5020d 100644 --- a/compiler/tests/org/jetbrains/jet/jvm/compiler/AnnotationJavaDescriptorResolverTest.java +++ b/compiler/tests/org/jetbrains/jet/jvm/compiler/AnnotationJavaDescriptorResolverTest.java @@ -17,31 +17,22 @@ package org.jetbrains.jet.jvm.compiler; import org.jetbrains.annotations.NotNull; -import org.jetbrains.annotations.Nullable; -import org.jetbrains.jet.CompileCompilerDependenciesTest; import org.jetbrains.jet.ConfigurationKind; -import org.jetbrains.jet.JetTestUtils; -import org.jetbrains.jet.TestJdkKind; -import org.jetbrains.jet.cli.jvm.compiler.JetCoreEnvironment; -import org.jetbrains.jet.di.InjectorForJavaSemanticServices; import org.jetbrains.jet.lang.descriptors.ClassDescriptor; import org.jetbrains.jet.lang.descriptors.ValueParameterDescriptor; import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor; import org.jetbrains.jet.lang.resolve.constants.AnnotationValue; import org.jetbrains.jet.lang.resolve.constants.ArrayValue; import org.jetbrains.jet.lang.resolve.constants.CompileTimeConstant; -import org.jetbrains.jet.lang.resolve.java.JavaDescriptorResolver; import org.jetbrains.jet.lang.resolve.name.FqName; import org.jetbrains.jet.lang.resolve.name.Name; import org.jetbrains.jet.lang.types.JetType; import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns; import org.jetbrains.jet.resolve.DescriptorRenderer; -import org.jetbrains.jet.test.TestCaseWithTmpdir; +import org.jetbrains.jet.JetTestUtils; import java.io.File; import java.io.IOException; -import java.util.ArrayList; -import java.util.Collections; import java.util.List; import static org.jetbrains.jet.lang.resolve.java.DescriptorResolverUtils.getValueParameterDescriptorForAnnotationParameter; @@ -49,13 +40,11 @@ import static org.jetbrains.jet.lang.resolve.java.DescriptorResolverUtils.getVal /** * @author Natalia Ukhorskaya */ -public class AnnotationJavaDescriptorResolverTest extends TestCaseWithTmpdir { +public class AnnotationJavaDescriptorResolverTest extends AbstractJavaResolverDescriptorTest { private static final String PATH = "compiler/testData/javaDescriptorResolver/annotations/"; private static final String DEFAULT_PACKAGE = "annotations"; - private JavaDescriptorResolver javaDescriptorResolver; - public void testCustomAnnotationWithKotlinEnum() throws IOException { File testFile = new File(PATH + "kotlinEnum.kt"); @@ -74,7 +63,6 @@ public class AnnotationJavaDescriptorResolverTest extends TestCaseWithTmpdir { builder.append(annotationsPath.getAbsolutePath()); } - setUpJavaDescriptorResolver(); compileJavaFile("customAnnotationWithKotlinEnum.java", builder.toString()); String annotationTypeName = DEFAULT_PACKAGE + ".MyAnnotation"; @@ -85,7 +73,6 @@ public class AnnotationJavaDescriptorResolverTest extends TestCaseWithTmpdir { } public void testCustomAnnotation() throws IOException { - setUpJavaDescriptorResolver(); compileJavaFile("customAnnotation.java", null); String annotationTypeName = DEFAULT_PACKAGE + ".MyAnnotation"; AnnotationDescriptor annotation = getAnnotationInClassByType("MyTest", annotationTypeName); @@ -95,7 +82,6 @@ public class AnnotationJavaDescriptorResolverTest extends TestCaseWithTmpdir { } public void testCustomAnnotationWithDefaultParameter() throws IOException { - setUpJavaDescriptorResolver(); compileJavaFile("customAnnotationWithDefaultParameter.java", null); String annotationTypeName = DEFAULT_PACKAGE + ".MyAnnotation"; AnnotationDescriptor annotation = getAnnotationInClassByType("MyTest", annotationTypeName); @@ -107,7 +93,6 @@ public class AnnotationJavaDescriptorResolverTest extends TestCaseWithTmpdir { } public void testAnnotationWithAnnotationInParam() throws IOException { - setUpJavaDescriptorResolver(); compileJavaFile("annotationWithAnnotationInParam.java", null); String annotationTypeName = DEFAULT_PACKAGE + ".MyAnnotationWithParam"; AnnotationDescriptor annotation = getAnnotationInClassByType("A", @@ -136,7 +121,6 @@ public class AnnotationJavaDescriptorResolverTest extends TestCaseWithTmpdir { } public void testRecursiveAnnotation() throws IOException { - setUpJavaDescriptorResolver(); compileJavaFile("recursiveAnnotation.java", null); String annotationTypeName = DEFAULT_PACKAGE + ".B"; AnnotationDescriptor annotation = getAnnotationInClassByType("A", annotationTypeName); @@ -153,7 +137,6 @@ public class AnnotationJavaDescriptorResolverTest extends TestCaseWithTmpdir { } public void testRecursiveAnnotation2() throws IOException { - setUpJavaDescriptorResolver(); compileJavaFile("recursiveAnnotation2.java", null); String annotationTypeName = DEFAULT_PACKAGE + ".A"; AnnotationDescriptor annotation = getAnnotationInClassByType("B", annotationTypeName); @@ -164,7 +147,6 @@ public class AnnotationJavaDescriptorResolverTest extends TestCaseWithTmpdir { } public void testAnnotationWithEnumInParam() throws IOException { - setUpJavaDescriptorResolver(); compileJavaFile("annotationWithEnumInParam.java", null); String annotationTypeName = "java.lang.annotation.Retention"; AnnotationDescriptor annotation = getAnnotationInClassByType("retentionAnnotation", annotationTypeName); @@ -173,7 +155,6 @@ public class AnnotationJavaDescriptorResolverTest extends TestCaseWithTmpdir { } public void testAnnotationWithArrayOfEnumInParam() throws IOException { - setUpJavaDescriptorResolver(); compileJavaFile("annotationWithArrayOfEnumInParam.java", null); String annotationTypeName = "java.lang.annotation.Target"; AnnotationDescriptor annotation = getAnnotationInClassByType("targetAnnotation", annotationTypeName); @@ -187,7 +168,6 @@ public class AnnotationJavaDescriptorResolverTest extends TestCaseWithTmpdir { } public void testAnnotationWithArrayOfStringInParam() throws IOException { - setUpJavaDescriptorResolver(); compileJavaFile("annotationWithArrayOfStringInParam.java", null); String annotationTypeName = DEFAULT_PACKAGE + ".MyAnnotation"; AnnotationDescriptor annotation = getAnnotationInClassByType("A", annotationTypeName); @@ -200,7 +180,6 @@ public class AnnotationJavaDescriptorResolverTest extends TestCaseWithTmpdir { } public void testAnnotationWithEmptyArrayInParam() throws IOException { - setUpJavaDescriptorResolver(); compileJavaFile("annotationWithEmptyArrayInParam.java", null); String annotationTypeName = DEFAULT_PACKAGE + ".MyAnnotation"; AnnotationDescriptor annotation = getAnnotationInClassByType("A", annotationTypeName); @@ -213,29 +192,6 @@ public class AnnotationJavaDescriptorResolverTest extends TestCaseWithTmpdir { checkArrayCompileTimeConstant((ArrayValue) actualCompileTimeConstant, "jet.Array?", "jet.String", values); } - private void compileJavaFile(@NotNull String fileRelativePath, @Nullable String classPath) - throws IOException { - File javaFile = new File(PATH + fileRelativePath); - assertNotNull(javaFile); - List options = new ArrayList(); - options.add("-d"); - options.add(tmpdir.getPath()); - if (classPath != null) { - options.add("-cp"); - options.add(classPath); - } - JetTestUtils.compileJavaFiles(Collections.singleton(javaFile), options); - } - - private void setUpJavaDescriptorResolver() { - JetCoreEnvironment jetCoreEnvironment = - new JetCoreEnvironment(myTestRootDisposable, CompileCompilerDependenciesTest.compilerConfigurationForTests( - ConfigurationKind.JDK_ONLY, TestJdkKind.MOCK_JDK, JetTestUtils.getAnnotationsJar(), tmpdir)); - - InjectorForJavaSemanticServices injector = new InjectorForJavaSemanticServices(jetCoreEnvironment.getProject()); - javaDescriptorResolver = injector.getJavaDescriptorResolver(); - } - private static void compareJetTypeWithClass(@NotNull JetType actualType, @NotNull String expectedType) { assertEquals(expectedType, DescriptorRenderer.TEXT.renderType(actualType)); } @@ -313,4 +269,10 @@ public class AnnotationJavaDescriptorResolverTest extends TestCaseWithTmpdir { i++; } } + + @NotNull + @Override + protected String getPath() { + return PATH; + } }