Refactor some of the tests for loading descriptors.

Move most of the logic to LoadDescriptorUtil and refactor to avoid duplication. More descriptive names for LoadDescriptorUtil methods. Minor code improvements.
2012-08-23 12:38:08 +04:00
parent 4457c7b6ba
commit f3dd54e70f
6 changed files with 134 additions and 140 deletions
@@ -58,7 +58,7 @@ public class GenerationUtils {


    @NotNull
-    private static GenerationState compileFilesGetGenerationState(@NotNull AnalyzeExhaust analyzeExhaust, @NotNull List<JetFile> files) {
+    public static GenerationState compileFilesGetGenerationState(@NotNull AnalyzeExhaust analyzeExhaust, @NotNull List<JetFile> files) {
        analyzeExhaust.throwIfError();
        GenerationState state = new GenerationState(ClassBuilderFactories.TEST, analyzeExhaust, files);
        state.compileCorrectFiles(CompilationErrorHandler.THROW_EXCEPTION);
@@ -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.<AnalyzerScriptParameter>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 {
@@ -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<File> javaFiles, File tmpdir, Disposable disposable)
+    public static NamespaceDescriptor compileJavaAndExtractTestNamespaceFromBinary(
+            @NotNull Collection<File> javaFiles,
+            @NotNull File outDir,
+            @NotNull Disposable disposable
+    )
            throws IOException {
+        compileJavaToDir(javaFiles, outDir);
+        return extractTestNamespaceFromBinaries(outDir, disposable);
+    }
+
+    private static void compileJavaToDir(@NotNull Collection<File> 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<? extends JavaFileObject> javaFileObjectsFromFiles = fileManager.getJavaFileObjectsFromFiles(javaFiles);
            List<String> 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.<AnalyzerScriptParameter>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;
+        }
    }
 }
@@ -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);
    }
@@ -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 {
@@ -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 {
            }
        });
    }
-    
+
 }