diff --git a/compiler/tests/org/jetbrains/jet/codegen/GenerationUtils.java b/compiler/tests/org/jetbrains/jet/codegen/GenerationUtils.java index 321cdd86fec..baa77d6c1c1 100644 --- a/compiler/tests/org/jetbrains/jet/codegen/GenerationUtils.java +++ b/compiler/tests/org/jetbrains/jet/codegen/GenerationUtils.java @@ -58,7 +58,7 @@ public class GenerationUtils { @NotNull - private static GenerationState compileFilesGetGenerationState(@NotNull AnalyzeExhaust analyzeExhaust, @NotNull List files) { + public static GenerationState compileFilesGetGenerationState(@NotNull AnalyzeExhaust analyzeExhaust, @NotNull List files) { analyzeExhaust.throwIfError(); GenerationState state = new GenerationState(ClassBuilderFactories.TEST, analyzeExhaust, files); state.compileCorrectFiles(CompilationErrorHandler.THROW_EXCEPTION); diff --git a/compiler/tests/org/jetbrains/jet/jvm/compiler/AbstractReadJavaBinaryClassTest.java b/compiler/tests/org/jetbrains/jet/jvm/compiler/AbstractReadJavaBinaryClassTest.java index 0fe535130b9..1572e1c216a 100644 --- a/compiler/tests/org/jetbrains/jet/jvm/compiler/AbstractReadJavaBinaryClassTest.java +++ b/compiler/tests/org/jetbrains/jet/jvm/compiler/AbstractReadJavaBinaryClassTest.java @@ -16,23 +16,11 @@ package org.jetbrains.jet.jvm.compiler; -import com.intellij.openapi.util.io.FileUtil; import org.jetbrains.annotations.NotNull; -import org.jetbrains.jet.ConfigurationKind; -import org.jetbrains.jet.JetTestUtils; -import org.jetbrains.jet.cli.jvm.compiler.JetCoreEnvironment; -import org.jetbrains.jet.lang.BuiltinsScopeExtensionMode; import org.jetbrains.jet.lang.descriptors.NamespaceDescriptor; -import org.jetbrains.jet.lang.psi.JetFile; -import org.jetbrains.jet.lang.resolve.AnalyzerScriptParameter; -import org.jetbrains.jet.lang.resolve.BindingContext; -import org.jetbrains.jet.lang.resolve.java.AnalyzerFacadeForJVM; -import org.jetbrains.jet.lang.resolve.name.FqName; -import org.jetbrains.jet.lang.resolve.name.Name; import org.jetbrains.jet.test.TestCaseWithTmpdir; import org.jetbrains.jet.test.generator.SimpleTestClassModel; import org.jetbrains.jet.test.generator.TestGenerator; -import org.jetbrains.jet.test.util.NamespaceComparator; import org.junit.Assert; import java.io.File; @@ -40,6 +28,11 @@ import java.io.IOException; import java.util.Arrays; import java.util.Collections; +import static org.jetbrains.jet.jvm.compiler.LoadDescriptorUtil.analyzeKotlinAndExtractTestNamespace; +import static org.jetbrains.jet.jvm.compiler.LoadDescriptorUtil.compileJavaAndExtractTestNamespaceFromBinary; +import static org.jetbrains.jet.test.util.NamespaceComparator.DONT_INCLUDE_METHODS_OF_OBJECT; +import static org.jetbrains.jet.test.util.NamespaceComparator.compareNamespaces; + /** * @author Stepan Koltsov */ @@ -50,22 +43,10 @@ public abstract class AbstractReadJavaBinaryClassTest extends TestCaseWithTmpdir File javaFile = new File(javaFileName); File ktFile = new File(javaFile.getPath().replaceFirst("\\.java$", ".kt")); File txtFile = new File(javaFile.getPath().replaceFirst("\\.java$", ".txt")); - NamespaceDescriptor nsa = analyzeKotlin(ktFile); - NamespaceDescriptor nsb = LoadDescriptorUtil.compileJava(Collections.singletonList(javaFile), tmpdir, myTestRootDisposable); - NamespaceComparator.compareNamespaces(nsa, nsb, NamespaceComparator.DONT_INCLUDE_METHODS_OF_OBJECT, txtFile); - } - - @NotNull - private NamespaceDescriptor analyzeKotlin(File ktFile) throws Exception { - JetCoreEnvironment jetCoreEnvironment = JetTestUtils.createEnvironmentWithMockJdkAndIdeaAnnotations(myTestRootDisposable, ConfigurationKind.JDK_ONLY); - - String text = FileUtil.loadFile(ktFile); - - JetFile psiFile = JetTestUtils.createFile(ktFile.getName(), text, jetCoreEnvironment.getProject()); - - BindingContext bindingContext = AnalyzerFacadeForJVM.analyzeOneFileWithJavaIntegrationAndCheckForErrors( - psiFile, Collections.emptyList(), BuiltinsScopeExtensionMode.ALL).getBindingContext(); - return bindingContext.get(BindingContext.FQNAME_TO_NAMESPACE_DESCRIPTOR, FqName.topLevel(Name.identifier("test"))); + NamespaceDescriptor nsa = analyzeKotlinAndExtractTestNamespace(ktFile, myTestRootDisposable); + NamespaceDescriptor nsb = compileJavaAndExtractTestNamespaceFromBinary(Collections.singletonList(javaFile), + tmpdir, myTestRootDisposable); + compareNamespaces(nsa, nsb, DONT_INCLUDE_METHODS_OF_OBJECT, txtFile); } public static void main(String[] args) throws IOException { diff --git a/compiler/tests/org/jetbrains/jet/jvm/compiler/LoadDescriptorUtil.java b/compiler/tests/org/jetbrains/jet/jvm/compiler/LoadDescriptorUtil.java index 1874fb46d36..7ba2974490c 100644 --- a/compiler/tests/org/jetbrains/jet/jvm/compiler/LoadDescriptorUtil.java +++ b/compiler/tests/org/jetbrains/jet/jvm/compiler/LoadDescriptorUtil.java @@ -24,18 +24,21 @@ import org.jetbrains.jet.CompileCompilerDependenciesTest; import org.jetbrains.jet.ConfigurationKind; import org.jetbrains.jet.JetTestUtils; import org.jetbrains.jet.TestJdkKind; +import org.jetbrains.jet.analyzer.AnalyzeExhaust; import org.jetbrains.jet.cli.jvm.compiler.CompileEnvironmentUtil; import org.jetbrains.jet.cli.jvm.compiler.JetCoreEnvironment; import org.jetbrains.jet.codegen.ClassFileFactory; import org.jetbrains.jet.codegen.GenerationState; import org.jetbrains.jet.codegen.GenerationUtils; import org.jetbrains.jet.codegen.forTestCompile.ForTestCompileRuntime; +import org.jetbrains.jet.config.CompilerConfiguration; import org.jetbrains.jet.di.InjectorForJavaSemanticServices; import org.jetbrains.jet.lang.BuiltinsScopeExtensionMode; import org.jetbrains.jet.lang.descriptors.NamespaceDescriptor; import org.jetbrains.jet.lang.psi.JetFile; -import org.jetbrains.jet.lang.psi.JetPsiFactory; +import org.jetbrains.jet.lang.resolve.AnalyzerScriptParameter; import org.jetbrains.jet.lang.resolve.BindingContext; +import org.jetbrains.jet.lang.resolve.java.AnalyzerFacadeForJVM; import org.jetbrains.jet.lang.resolve.java.DescriptorSearchRule; import org.jetbrains.jet.lang.resolve.java.JavaDescriptorResolver; import org.jetbrains.jet.lang.resolve.name.FqName; @@ -46,43 +49,76 @@ import javax.tools.*; import java.io.File; import java.io.IOException; import java.nio.charset.Charset; -import java.util.Arrays; -import java.util.Collection; -import java.util.List; -import java.util.Locale; +import java.util.*; + +import static org.jetbrains.jet.JetTestUtils.createEnvironmentWithMockJdkAndIdeaAnnotations; +import static org.jetbrains.jet.lang.psi.JetPsiFactory.createFile; /** * @author Pavel Talanov */ public final class LoadDescriptorUtil { + + @NotNull + public static final FqName TEST_PACKAGE_FQNAME = FqName.topLevel(Name.identifier("test")); + private LoadDescriptorUtil() { } @NotNull - public static NamespaceDescriptor compileKotlin(@NotNull File kotlinFile, File tmpdir, Disposable disposable) + public static NamespaceDescriptor compileKotlinAndExtractTestNamespaceDescriptorFromBinary( + @NotNull File kotlinFile, + @NotNull File outDir, + @NotNull Disposable disposable + ) throws IOException { - JetCoreEnvironment jetCoreEnvironment = JetTestUtils.createEnvironmentWithMockJdkAndIdeaAnnotations(disposable, ConfigurationKind.JDK_ONLY); - JetFile psiFile = JetPsiFactory.createFile(jetCoreEnvironment.getProject(), FileUtil.loadFile(kotlinFile, true)); - GenerationState state = GenerationUtils.compileFileGetGenerationStateForTest(psiFile); + compileKotlinToDirAndGetAnalyzeExhaust(kotlinFile, outDir, disposable); + return extractTestNamespaceFromBinaries(outDir, disposable); + } + + @NotNull + public static AnalyzeExhaust compileKotlinToDirAndGetAnalyzeExhaust( + @NotNull File kotlinFile, + @NotNull File outDir, + @NotNull Disposable disposable + ) throws IOException { + JetFileAndExhaust fileAndExhaust = JetFileAndExhaust.createJetFileAndAnalyze(kotlinFile, disposable); + GenerationState state = GenerationUtils.compileFilesGetGenerationState(fileAndExhaust.getExhaust(), Collections.singletonList( + fileAndExhaust.getJetFile())); ClassFileFactory classFileFactory = state.getFactory(); - CompileEnvironmentUtil.writeToOutputDirectory(classFileFactory, tmpdir); - NamespaceDescriptor namespaceFromSource = state.getBindingContext().get(BindingContext.FILE_TO_NAMESPACE, psiFile); - Assert.assertEquals("test", namespaceFromSource.getName().getName()); + CompileEnvironmentUtil.writeToOutputDirectory(classFileFactory, outDir); + return fileAndExhaust.getExhaust(); + } + + @NotNull + public static NamespaceDescriptor extractTestNamespaceFromBinaries(@NotNull File outDir, @NotNull Disposable disposable) { Disposer.dispose(disposable); - jetCoreEnvironment = new JetCoreEnvironment(disposable, CompileCompilerDependenciesTest.compilerConfigurationForTests( - ConfigurationKind.JDK_ONLY, TestJdkKind.MOCK_JDK, JetTestUtils.getAnnotationsJar(), tmpdir, - ForTestCompileRuntime.runtimeJarForTests())); - + CompilerConfiguration configuration = CompileCompilerDependenciesTest.compilerConfigurationForTests( + ConfigurationKind.JDK_ONLY, TestJdkKind.MOCK_JDK, JetTestUtils.getAnnotationsJar(), outDir, + ForTestCompileRuntime.runtimeJarForTests()); + JetCoreEnvironment jetCoreEnvironment = new JetCoreEnvironment(disposable, configuration); InjectorForJavaSemanticServices injector = new InjectorForJavaSemanticServices(BuiltinsScopeExtensionMode.ALL, jetCoreEnvironment.getProject()); JavaDescriptorResolver javaDescriptorResolver = injector.getJavaDescriptorResolver(); - return javaDescriptorResolver.resolveNamespace(FqName.topLevel(Name.identifier("test")), DescriptorSearchRule.ERROR_IF_FOUND_IN_KOTLIN); + NamespaceDescriptor namespaceDescriptor = + javaDescriptorResolver.resolveNamespace(TEST_PACKAGE_FQNAME, DescriptorSearchRule.ERROR_IF_FOUND_IN_KOTLIN); + assert namespaceDescriptor != null; + return namespaceDescriptor; } - + @NotNull - public static NamespaceDescriptor compileJava(@NotNull Collection javaFiles, File tmpdir, Disposable disposable) + public static NamespaceDescriptor compileJavaAndExtractTestNamespaceFromBinary( + @NotNull Collection javaFiles, + @NotNull File outDir, + @NotNull Disposable disposable + ) throws IOException { + compileJavaToDir(javaFiles, outDir); + return extractTestNamespaceFromBinaries(outDir, disposable); + } + + private static void compileJavaToDir(@NotNull Collection javaFiles, @NotNull File ourDir) throws IOException { JavaCompiler javaCompiler = ToolProvider.getSystemJavaCompiler(); StandardJavaFileManager fileManager = javaCompiler.getStandardFileManager(null, Locale.ENGLISH, Charset.forName("utf-8")); @@ -90,7 +126,7 @@ public final class LoadDescriptorUtil { Iterable javaFileObjectsFromFiles = fileManager.getJavaFileObjectsFromFiles(javaFiles); List options = Arrays.asList( "-classpath", "out/production/runtime" + File.pathSeparator + JetTestUtils.getAnnotationsJar().getPath(), - "-d", tmpdir.getPath() + "-d", ourDir.getPath() ); JavaCompiler.CompilationTask task = javaCompiler.getTask(null, fileManager, null, options, null, javaFileObjectsFromFiles); @@ -99,14 +135,45 @@ public final class LoadDescriptorUtil { finally { fileManager.close(); } + } - JetCoreEnvironment jetCoreEnvironment = new JetCoreEnvironment(disposable, CompileCompilerDependenciesTest. - compilerConfigurationForTests(ConfigurationKind.JDK_ONLY, TestJdkKind.MOCK_JDK, JetTestUtils.getAnnotationsJar(), tmpdir, - new File("out/production/runtime"))); + @NotNull + public static NamespaceDescriptor analyzeKotlinAndExtractTestNamespace(@NotNull File ktFile, @NotNull Disposable disposable) throws Exception { + JetFileAndExhaust fileAndExhaust = JetFileAndExhaust.createJetFileAndAnalyze(ktFile, disposable); + //noinspection ConstantConditions + return fileAndExhaust.getExhaust().getBindingContext().get(BindingContext.FQNAME_TO_NAMESPACE_DESCRIPTOR, TEST_PACKAGE_FQNAME); + } - InjectorForJavaSemanticServices injector = new InjectorForJavaSemanticServices(BuiltinsScopeExtensionMode.ALL, - jetCoreEnvironment.getProject()); - JavaDescriptorResolver javaDescriptorResolver = injector.getJavaDescriptorResolver(); - return javaDescriptorResolver.resolveNamespace(FqName.topLevel(Name.identifier("test")), DescriptorSearchRule.ERROR_IF_FOUND_IN_KOTLIN); + private static class JetFileAndExhaust { + + @NotNull + public static JetFileAndExhaust createJetFileAndAnalyze(@NotNull File kotlinFile, @NotNull Disposable disposable) + throws IOException { + JetCoreEnvironment jetCoreEnvironment = createEnvironmentWithMockJdkAndIdeaAnnotations(disposable, ConfigurationKind.JDK_ONLY); + JetFile jetFile = createFile(jetCoreEnvironment.getProject(), FileUtil.loadFile(kotlinFile, true)); + AnalyzeExhaust exhaust = AnalyzerFacadeForJVM.analyzeOneFileWithJavaIntegrationAndCheckForErrors( + jetFile, Collections.emptyList(), BuiltinsScopeExtensionMode.ALL); + return new JetFileAndExhaust(jetFile, exhaust); + } + + @NotNull + private final JetFile jetFile; + @NotNull + private final AnalyzeExhaust exhaust; + + private JetFileAndExhaust(@NotNull JetFile file, @NotNull AnalyzeExhaust exhaust) { + jetFile = file; + this.exhaust = exhaust; + } + + @NotNull + public JetFile getJetFile() { + return jetFile; + } + + @NotNull + public AnalyzeExhaust getExhaust() { + return exhaust; + } } } diff --git a/compiler/tests/org/jetbrains/jet/jvm/compiler/LoadJavaDescriptorsTest.java b/compiler/tests/org/jetbrains/jet/jvm/compiler/LoadJavaDescriptorsTest.java index c59fc812dc3..b3093ff9c77 100644 --- a/compiler/tests/org/jetbrains/jet/jvm/compiler/LoadJavaDescriptorsTest.java +++ b/compiler/tests/org/jetbrains/jet/jvm/compiler/LoadJavaDescriptorsTest.java @@ -30,12 +30,14 @@ import java.io.File; import java.util.Arrays; import java.util.Collection; +import static org.jetbrains.jet.jvm.compiler.LoadDescriptorUtil.compileJavaAndExtractTestNamespaceFromBinary; + /** * @author Pavel Talanov */ public final class LoadJavaDescriptorsTest extends KotlinTestWithEnvironment { @NotNull - private final String PATH = "compiler/testData/loadJavaDescriptors"; + private static final String PATH = "compiler/testData/loadJavaDescriptors"; @Override protected JetCoreEnvironment createEnvironment() { @@ -51,7 +53,7 @@ public final class LoadJavaDescriptorsTest extends KotlinTestWithEnvironment { }); File expected = new File(expectedFileName); File tmpDir = JetTestUtils.tmpDir(expected.getName()); - NamespaceDescriptor javaNamespaceDescriptor = LoadDescriptorUtil.compileJava(files, tmpDir, getTestRootDisposable()); + NamespaceDescriptor javaNamespaceDescriptor = compileJavaAndExtractTestNamespaceFromBinary(files, tmpDir, getTestRootDisposable()); //NOTE: comparing namespace to file (hack) NamespaceComparator.compareNamespaces(javaNamespaceDescriptor, javaNamespaceDescriptor, NamespaceComparator.DONT_INCLUDE_METHODS_OF_OBJECT, expected); } diff --git a/compiler/tests/org/jetbrains/jet/jvm/compiler/LoadKotlinDescriptorsTest.java b/compiler/tests/org/jetbrains/jet/jvm/compiler/LoadKotlinDescriptorsTest.java index fc54a4a7afc..f4e81b97c9a 100644 --- a/compiler/tests/org/jetbrains/jet/jvm/compiler/LoadKotlinDescriptorsTest.java +++ b/compiler/tests/org/jetbrains/jet/jvm/compiler/LoadKotlinDescriptorsTest.java @@ -16,50 +16,28 @@ package org.jetbrains.jet.jvm.compiler; -import com.google.common.base.Function; -import com.google.common.collect.Collections2; -import com.intellij.openapi.util.Disposer; -import com.intellij.openapi.util.io.FileUtil; -import junit.framework.Assert; import org.jetbrains.annotations.NotNull; -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.CompileEnvironmentUtil; -import org.jetbrains.jet.cli.jvm.compiler.JetCoreEnvironment; -import org.jetbrains.jet.codegen.ClassFileFactory; -import org.jetbrains.jet.codegen.GenerationState; -import org.jetbrains.jet.codegen.GenerationUtils; -import org.jetbrains.jet.codegen.forTestCompile.ForTestCompileRuntime; -import org.jetbrains.jet.di.InjectorForJavaSemanticServices; -import org.jetbrains.jet.lang.BuiltinsScopeExtensionMode; import org.jetbrains.jet.lang.descriptors.NamespaceDescriptor; -import org.jetbrains.jet.lang.psi.JetFile; -import org.jetbrains.jet.lang.psi.JetPsiFactory; -import org.jetbrains.jet.lang.resolve.BindingContext; -import org.jetbrains.jet.lang.resolve.java.DescriptorSearchRule; -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.test.TestCaseWithTmpdir; -import org.jetbrains.jet.test.util.NamespaceComparator; import java.io.File; -import java.util.Arrays; -import java.util.Collection; + +import static org.jetbrains.jet.jvm.compiler.LoadDescriptorUtil.compileKotlinAndExtractTestNamespaceDescriptorFromBinary; +import static org.jetbrains.jet.test.util.NamespaceComparator.DONT_INCLUDE_METHODS_OF_OBJECT; +import static org.jetbrains.jet.test.util.NamespaceComparator.compareNamespaces; /** * @author Pavel Talanov */ public final class LoadKotlinDescriptorsTest extends TestCaseWithTmpdir { @NotNull - private final String PATH = "compiler/testData/loadKotlinDescriptors"; + private static final String PATH = "compiler/testData/loadKotlinDescriptors"; private void doTest(@NotNull String expectedFileName, @NotNull String kotlinFileName) throws Exception { - NamespaceDescriptor namespaceFromClass = LoadDescriptorUtil.compileKotlin(new File(kotlinFileName), tmpdir, myTestRootDisposable); + NamespaceDescriptor namespaceFromClass = + compileKotlinAndExtractTestNamespaceDescriptorFromBinary(new File(kotlinFileName), tmpdir, myTestRootDisposable); - NamespaceComparator.compareNamespaces(namespaceFromClass, namespaceFromClass, NamespaceComparator.DONT_INCLUDE_METHODS_OF_OBJECT, new File(expectedFileName)); + compareNamespaces(namespaceFromClass, namespaceFromClass, DONT_INCLUDE_METHODS_OF_OBJECT, new File(expectedFileName)); } public void testSimpleEnum() throws Exception { diff --git a/compiler/tests/org/jetbrains/jet/jvm/compiler/ReadKotlinBinaryClassTest.java b/compiler/tests/org/jetbrains/jet/jvm/compiler/ReadKotlinBinaryClassTest.java index 006bc2bb61a..c5770a03aa1 100644 --- a/compiler/tests/org/jetbrains/jet/jvm/compiler/ReadKotlinBinaryClassTest.java +++ b/compiler/tests/org/jetbrains/jet/jvm/compiler/ReadKotlinBinaryClassTest.java @@ -16,49 +16,36 @@ package org.jetbrains.jet.jvm.compiler; -import com.intellij.openapi.util.Disposer; -import com.intellij.openapi.util.io.FileUtil; -import com.intellij.openapi.vfs.CharsetToolkit; -import com.intellij.psi.PsiFileFactory; -import com.intellij.psi.impl.PsiFileFactoryImpl; -import com.intellij.testFramework.LightVirtualFile; import junit.framework.Assert; import junit.framework.Test; import org.jetbrains.annotations.NotNull; -import org.jetbrains.jet.*; -import org.jetbrains.jet.cli.jvm.compiler.CompileEnvironmentUtil; -import org.jetbrains.jet.cli.jvm.compiler.JetCoreEnvironment; -import org.jetbrains.jet.codegen.ClassFileFactory; -import org.jetbrains.jet.codegen.GenerationState; -import org.jetbrains.jet.codegen.GenerationUtils; -import org.jetbrains.jet.codegen.forTestCompile.ForTestCompileRuntime; -import org.jetbrains.jet.di.InjectorForJavaSemanticServices; -import org.jetbrains.jet.lang.BuiltinsScopeExtensionMode; +import org.jetbrains.jet.JetTestCaseBuilder; +import org.jetbrains.jet.analyzer.AnalyzeExhaust; import org.jetbrains.jet.lang.descriptors.NamespaceDescriptor; -import org.jetbrains.jet.lang.psi.JetFile; import org.jetbrains.jet.lang.resolve.BindingContext; -import org.jetbrains.jet.lang.resolve.java.DescriptorSearchRule; -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.plugin.JetLanguage; import org.jetbrains.jet.test.TestCaseWithTmpdir; import org.jetbrains.jet.test.util.NamespaceComparator; import java.io.File; +import static org.jetbrains.jet.jvm.compiler.LoadDescriptorUtil.TEST_PACKAGE_FQNAME; +import static org.jetbrains.jet.jvm.compiler.LoadDescriptorUtil.compileKotlinToDirAndGetAnalyzeExhaust; +import static org.jetbrains.jet.test.util.NamespaceComparator.compareNamespaces; + /** * Compile Kotlin and then parse model from .class files. * * @author Stepan Koltsov */ -public class ReadKotlinBinaryClassTest extends TestCaseWithTmpdir { - - private JetCoreEnvironment jetCoreEnvironment; +@SuppressWarnings("JUnitTestCaseWithNoTests") +public final class ReadKotlinBinaryClassTest extends TestCaseWithTmpdir { + @NotNull private final File testFile; + @NotNull private final File txtFile; + @SuppressWarnings("JUnitTestCaseWithNonTrivialConstructors") public ReadKotlinBinaryClassTest(@NotNull File testFile) { this.testFile = testFile; this.txtFile = new File(testFile.getPath().replaceFirst("\\.kt$", ".txt")); @@ -67,35 +54,14 @@ public class ReadKotlinBinaryClassTest extends TestCaseWithTmpdir { @Override public void runTest() throws Exception { - jetCoreEnvironment = JetTestUtils.createEnvironmentWithMockJdkAndIdeaAnnotations(myTestRootDisposable, ConfigurationKind.JDK_ONLY); - - String text = FileUtil.loadFile(testFile); - - JetFile psiFile = JetTestUtils.createFile(testFile.getName(), text, jetCoreEnvironment.getProject()); - - GenerationState state = GenerationUtils.compileFileGetGenerationStateForTest(psiFile); - - ClassFileFactory classFileFactory = state.getFactory(); - - CompileEnvironmentUtil.writeToOutputDirectory(classFileFactory, tmpdir); - - NamespaceDescriptor namespaceFromSource = state.getBindingContext().get(BindingContext.FILE_TO_NAMESPACE, psiFile); + AnalyzeExhaust exhaust = compileKotlinToDirAndGetAnalyzeExhaust(testFile, tmpdir, getTestRootDisposable()); + NamespaceDescriptor namespaceFromSource = exhaust.getBindingContext().get(BindingContext.FQNAME_TO_NAMESPACE_DESCRIPTOR, + TEST_PACKAGE_FQNAME); + assert namespaceFromSource != null; Assert.assertEquals("test", namespaceFromSource.getName().getName()); - - Disposer.dispose(myTestRootDisposable); - - - jetCoreEnvironment = new JetCoreEnvironment(myTestRootDisposable, CompileCompilerDependenciesTest.compilerConfigurationForTests( - ConfigurationKind.JDK_ONLY, TestJdkKind.MOCK_JDK, JetTestUtils.getAnnotationsJar(), tmpdir, - ForTestCompileRuntime.runtimeJarForTests())); - - InjectorForJavaSemanticServices injector = new InjectorForJavaSemanticServices(BuiltinsScopeExtensionMode.ALL, - jetCoreEnvironment.getProject()); - JavaDescriptorResolver javaDescriptorResolver = injector.getJavaDescriptorResolver(); - NamespaceDescriptor namespaceFromClass = javaDescriptorResolver.resolveNamespace(FqName.topLevel(Name.identifier("test")), DescriptorSearchRule.ERROR_IF_FOUND_IN_KOTLIN); - - NamespaceComparator.compareNamespaces(namespaceFromSource, namespaceFromClass, NamespaceComparator.DONT_INCLUDE_METHODS_OF_OBJECT, txtFile); + NamespaceDescriptor namespaceFromClass = LoadDescriptorUtil.extractTestNamespaceFromBinaries(tmpdir, getTestRootDisposable()); + compareNamespaces(namespaceFromSource, namespaceFromClass, NamespaceComparator.DONT_INCLUDE_METHODS_OF_OBJECT, txtFile); } public static Test suite() { @@ -107,5 +73,5 @@ public class ReadKotlinBinaryClassTest extends TestCaseWithTmpdir { } }); } - + }