diff --git a/compiler/tests/org/jetbrains/kotlin/codegen/AbstractCheckLocalVariablesTableTest.java b/compiler/tests/org/jetbrains/kotlin/codegen/AbstractCheckLocalVariablesTableTest.java
index 5e60c94e873..019da24d9e9 100644
--- a/compiler/tests/org/jetbrains/kotlin/codegen/AbstractCheckLocalVariablesTableTest.java
+++ b/compiler/tests/org/jetbrains/kotlin/codegen/AbstractCheckLocalVariablesTableTest.java
@@ -69,7 +69,7 @@ public abstract class AbstractCheckLocalVariablesTableTest extends TestCaseWithT
 
         JetFile psiFile = JetTestUtils.createFile(ktFile.getName(), text, jetCoreEnvironment.getProject());
 
-        OutputFileCollection outputFiles = GenerationUtils.compileFileGetClassFileFactoryForTest(psiFile);
+        OutputFileCollection outputFiles = GenerationUtils.compileFileGetClassFileFactoryForTest(psiFile, jetCoreEnvironment);
 
         String classAndMethod = parseClassAndMethodSignature();
         String[] split = classAndMethod.split("\\.");
diff --git a/compiler/tests/org/jetbrains/kotlin/codegen/AbstractLineNumberTest.java b/compiler/tests/org/jetbrains/kotlin/codegen/AbstractLineNumberTest.java
index 5b07cd101d5..fc44f5083bc 100644
--- a/compiler/tests/org/jetbrains/kotlin/codegen/AbstractLineNumberTest.java
+++ b/compiler/tests/org/jetbrains/kotlin/codegen/AbstractLineNumberTest.java
@@ -20,6 +20,7 @@ import com.google.common.collect.Lists;
 import com.google.common.collect.Maps;
 import com.intellij.openapi.util.io.FileUtil;
 import com.intellij.openapi.util.text.StringUtil;
+import kotlin.Pair;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.kotlin.backend.common.output.OutputFile;
 import org.jetbrains.kotlin.backend.common.output.OutputFileCollection;
@@ -74,12 +75,13 @@ public class AbstractLineNumberTest extends TestCaseWithTmpdir {
                                                "package test;\n\npublic fun " + LINE_NUMBER_FUN + "(): Int = 0\n",
                                                environment.getProject());
 
-        OutputFileCollection outputFiles = GenerationUtils.compileFileGetClassFileFactoryForTest(psiFile);
+        OutputFileCollection outputFiles =
+                GenerationUtils.compileFileGetClassFileFactoryForTest(psiFile, environment);
         OutputUtilsPackage.writeAllTo(outputFiles, tmpdir);
     }
 
     @NotNull
-    private JetFile createPsiFile(@NotNull String filename) {
+    private Pair<JetFile, KotlinCoreEnvironment> createPsiFile(@NotNull String filename) {
         File file = new File(filename);
         KotlinCoreEnvironment environment = createEnvironment();
 
@@ -91,12 +93,15 @@ public class AbstractLineNumberTest extends TestCaseWithTmpdir {
             throw UtilsPackage.rethrow(e);
         }
 
-        return JetTestUtils.createFile(file.getName(), text, environment.getProject());
+        return new Pair(JetTestUtils.createFile(file.getName(), text, environment.getProject()), environment);
     }
 
     private void doTest(@NotNull String filename, boolean custom) {
-        JetFile psiFile = createPsiFile(filename);
-        GenerationState state = GenerationUtils.compileFileGetGenerationStateForTest(psiFile);
+        Pair<JetFile, KotlinCoreEnvironment> fileAndEnv = createPsiFile(filename);
+        JetFile psiFile = fileAndEnv.getFirst();
+        KotlinCoreEnvironment environment = fileAndEnv.getSecond();
+
+        GenerationState state = GenerationUtils.compileFileGetGenerationStateForTest(psiFile, environment);
 
         List<Integer> expectedLineNumbers;
         List<Integer> actualLineNumbers;
@@ -241,8 +246,8 @@ public class AbstractLineNumberTest extends TestCaseWithTmpdir {
     }
 
     public void testStaticDelegate() {
-        JetFile foo = createPsiFile(getTestDataPath() + "/staticDelegate/foo.kt");
-        JetFile bar = createPsiFile(getTestDataPath() + "/staticDelegate/bar.kt");
+        JetFile foo = createPsiFile(getTestDataPath() + "/staticDelegate/foo.kt").getFirst();
+        JetFile bar = createPsiFile(getTestDataPath() + "/staticDelegate/bar.kt").getFirst();
         GenerationState state = GenerationUtils.compileManyFilesGetGenerationStateForTest(foo.getProject(), Arrays.asList(foo, bar));
         OutputFile file = state.getFactory().get(PackageClassUtils.getPackageClassName(FqName.ROOT) + ".class");
         assertNotNull(file);
diff --git a/compiler/tests/org/jetbrains/kotlin/codegen/GenerationUtils.java b/compiler/tests/org/jetbrains/kotlin/codegen/GenerationUtils.java
index 3a7ccebb0eb..60c194bc33b 100644
--- a/compiler/tests/org/jetbrains/kotlin/codegen/GenerationUtils.java
+++ b/compiler/tests/org/jetbrains/kotlin/codegen/GenerationUtils.java
@@ -19,8 +19,11 @@ package org.jetbrains.kotlin.codegen;
 import com.intellij.openapi.project.Project;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.kotlin.analyzer.AnalysisResult;
+import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment;
 import org.jetbrains.kotlin.codegen.state.GenerationState;
+import org.jetbrains.kotlin.load.java.lazy.PackageMappingProvider;
 import org.jetbrains.kotlin.psi.JetFile;
+import org.jetbrains.kotlin.resolve.lazy.JvmPackageMappingProvider;
 import org.jetbrains.kotlin.resolve.lazy.JvmResolveUtil;
 
 import java.util.Collections;
@@ -32,20 +35,33 @@ public class GenerationUtils {
     }
 
     @NotNull
-    public static ClassFileFactory compileFileGetClassFileFactoryForTest(@NotNull JetFile psiFile) {
-        return compileFileGetGenerationStateForTest(psiFile).getFactory();
+    public static ClassFileFactory compileFileGetClassFileFactoryForTest(
+            @NotNull JetFile psiFile,
+            @NotNull KotlinCoreEnvironment environment
+    ) {
+        return compileFileGetGenerationStateForTest(psiFile, environment).getFactory();
     }
 
     @NotNull
-    public static GenerationState compileFileGetGenerationStateForTest(@NotNull JetFile psiFile) {
-        AnalysisResult analysisResult = JvmResolveUtil.analyzeOneFileWithJavaIntegrationAndCheckForErrors(psiFile);
+    public static GenerationState compileFileGetGenerationStateForTest(
+            @NotNull JetFile psiFile,
+            @NotNull KotlinCoreEnvironment environment
+    ) {
+        AnalysisResult analysisResult =
+                JvmResolveUtil.analyzeOneFileWithJavaIntegrationAndCheckForErrors(psiFile, new JvmPackageMappingProvider(environment));
         return compileFilesGetGenerationState(psiFile.getProject(), analysisResult, Collections.singletonList(psiFile));
     }
 
     @NotNull
     public static GenerationState compileManyFilesGetGenerationStateForTest(@NotNull Project project, @NotNull List<JetFile> files) {
+        return compileManyFilesGetGenerationStateForTest(project, files, PackageMappingProvider.EMPTY);
+    }
+
+    @NotNull
+    public static GenerationState compileManyFilesGetGenerationStateForTest(@NotNull Project project, @NotNull List<JetFile> files,
+            @NotNull PackageMappingProvider packageMappingProvider) {
         AnalysisResult analysisResult = JvmResolveUtil.analyzeFilesWithJavaIntegrationAndCheckForErrors(
-                project, files);
+                project, files, packageMappingProvider);
         return compileFilesGetGenerationState(project, analysisResult, files);
     }
 
diff --git a/compiler/tests/org/jetbrains/kotlin/codegen/flags/AbstractWriteFlagsTest.java b/compiler/tests/org/jetbrains/kotlin/codegen/flags/AbstractWriteFlagsTest.java
index 5f0e35bc590..3b56e8d2178 100644
--- a/compiler/tests/org/jetbrains/kotlin/codegen/flags/AbstractWriteFlagsTest.java
+++ b/compiler/tests/org/jetbrains/kotlin/codegen/flags/AbstractWriteFlagsTest.java
@@ -77,7 +77,7 @@ public abstract class AbstractWriteFlagsTest extends UsefulTestCase {
 
         JetFile psiFile = JetTestUtils.createFile(ktFile.getName(), fileText, jetCoreEnvironment.getProject());
 
-        OutputFileCollection outputFiles = GenerationUtils.compileFileGetClassFileFactoryForTest(psiFile);
+        OutputFileCollection outputFiles = GenerationUtils.compileFileGetClassFileFactoryForTest(psiFile, jetCoreEnvironment);
 
         List<TestedObject> testedObjects = parseExpectedTestedObject(fileText);
         for (TestedObject testedObject : testedObjects) {
diff --git a/compiler/tests/org/jetbrains/kotlin/codegen/generated/AbstractBlackBoxCodegenTest.java b/compiler/tests/org/jetbrains/kotlin/codegen/generated/AbstractBlackBoxCodegenTest.java
index da32322e406..253d70c2d49 100644
--- a/compiler/tests/org/jetbrains/kotlin/codegen/generated/AbstractBlackBoxCodegenTest.java
+++ b/compiler/tests/org/jetbrains/kotlin/codegen/generated/AbstractBlackBoxCodegenTest.java
@@ -29,6 +29,7 @@ import org.jetbrains.kotlin.codegen.CodegenTestCase;
 import org.jetbrains.kotlin.codegen.GenerationUtils;
 import org.jetbrains.kotlin.config.CompilerConfiguration;
 import org.jetbrains.kotlin.psi.JetFile;
+import org.jetbrains.kotlin.resolve.lazy.JvmPackageMappingProvider;
 import org.jetbrains.kotlin.test.ConfigurationKind;
 import org.jetbrains.kotlin.test.InTextDirectivesUtils;
 import org.jetbrains.kotlin.test.JetTestUtils;
@@ -153,7 +154,8 @@ public abstract class AbstractBlackBoxCodegenTest extends CodegenTestCase {
         myEnvironment = KotlinCoreEnvironment.createForTests(getTestRootDisposable(), configuration, EnvironmentConfigFiles.JVM_CONFIG_FILES);
         loadFiles(ArrayUtil.toStringArray(ktFilePaths));
         classFileFactory =
-                GenerationUtils.compileManyFilesGetGenerationStateForTest(myEnvironment.getProject(), myFiles.getPsiFiles()).getFactory();
+                GenerationUtils.compileManyFilesGetGenerationStateForTest(myEnvironment.getProject(), myFiles.getPsiFiles(),
+                                                                          new JvmPackageMappingProvider(myEnvironment)).getFactory();
         File kotlinOut = JetTestUtils.tmpDir(toString());
         OutputUtilsPackage.writeAllTo(classFileFactory, kotlinOut);
 
diff --git a/compiler/tests/org/jetbrains/kotlin/jvm/compiler/AbstractCompileJavaAgainstKotlinTest.java b/compiler/tests/org/jetbrains/kotlin/jvm/compiler/AbstractCompileJavaAgainstKotlinTest.java
index f6e5926af81..011bd87837a 100644
--- a/compiler/tests/org/jetbrains/kotlin/jvm/compiler/AbstractCompileJavaAgainstKotlinTest.java
+++ b/compiler/tests/org/jetbrains/kotlin/jvm/compiler/AbstractCompileJavaAgainstKotlinTest.java
@@ -81,7 +81,7 @@ public abstract class AbstractCompileJavaAgainstKotlinTest extends TestCaseWithT
                 EnvironmentConfigFiles.JVM_CONFIG_FILES
         );
 
-        AnalysisResult exhaust = JvmResolveUtil.analyzeFilesWithJavaIntegration(environment.getProject(), Collections.<JetFile>emptySet());
+        AnalysisResult exhaust = JvmResolveUtil.analyzeFilesWithJavaIntegration(environment.getProject(), Collections.<JetFile>emptySet(), environment);
         PackageViewDescriptor packageView = exhaust.getModuleDescriptor().getPackage(LoadDescriptorUtil.TEST_PACKAGE_FQNAME);
         assertFalse(packageView.isEmpty());
 
diff --git a/compiler/tests/org/jetbrains/kotlin/jvm/compiler/AbstractCompileKotlinAgainstKotlinTest.java b/compiler/tests/org/jetbrains/kotlin/jvm/compiler/AbstractCompileKotlinAgainstKotlinTest.java
index faa39f8e78f..05a74a274e4 100644
--- a/compiler/tests/org/jetbrains/kotlin/jvm/compiler/AbstractCompileKotlinAgainstKotlinTest.java
+++ b/compiler/tests/org/jetbrains/kotlin/jvm/compiler/AbstractCompileKotlinAgainstKotlinTest.java
@@ -107,7 +107,7 @@ public abstract class AbstractCompileKotlinAgainstKotlinTest extends TestCaseWit
 
         JetFile psiFile = JetTestUtils.createFile(file.getName(), text, jetCoreEnvironment.getProject());
 
-        ClassFileFactory outputFiles = GenerationUtils.compileFileGetClassFileFactoryForTest(psiFile);
+        ClassFileFactory outputFiles = GenerationUtils.compileFileGetClassFileFactoryForTest(psiFile, jetCoreEnvironment);
 
         OutputUtilsPackage.writeAllTo(outputFiles, outputDir);
 
diff --git a/compiler/tests/org/jetbrains/kotlin/jvm/compiler/AbstractWriteSignatureTest.kt b/compiler/tests/org/jetbrains/kotlin/jvm/compiler/AbstractWriteSignatureTest.kt
index 1b8bdf5741b..b49783dfca6 100644
--- a/compiler/tests/org/jetbrains/kotlin/jvm/compiler/AbstractWriteSignatureTest.kt
+++ b/compiler/tests/org/jetbrains/kotlin/jvm/compiler/AbstractWriteSignatureTest.kt
@@ -23,6 +23,7 @@ import com.intellij.openapi.util.io.FileUtil
 import org.jetbrains.kotlin.cli.common.output.outputUtils.writeAllTo
 import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment
 import org.jetbrains.kotlin.codegen.GenerationUtils
+import org.jetbrains.kotlin.resolve.lazy.JvmPackageMappingProvider
 import org.jetbrains.kotlin.test.JetTestUtils
 import org.jetbrains.kotlin.test.TestCaseWithTmpdir
 import org.jetbrains.kotlin.utils.join
@@ -56,7 +57,7 @@ public abstract class AbstractWriteSignatureTest : TestCaseWithTmpdir() {
 
         val psiFile = JetTestUtils.createFile(ktFile.getName(), text, jetCoreEnvironment!!.project)
 
-        val outputFiles = GenerationUtils.compileFileGetClassFileFactoryForTest(psiFile)
+        val outputFiles = GenerationUtils.compileFileGetClassFileFactoryForTest(psiFile, jetCoreEnvironment!!)
 
         outputFiles.writeAllTo(tmpdir)
 
diff --git a/compiler/tests/org/jetbrains/kotlin/jvm/runtime/AbstractJvmRuntimeDescriptorLoaderTest.kt b/compiler/tests/org/jetbrains/kotlin/jvm/runtime/AbstractJvmRuntimeDescriptorLoaderTest.kt
index 23e6e5ce3ef..1672b1fbb92 100644
--- a/compiler/tests/org/jetbrains/kotlin/jvm/runtime/AbstractJvmRuntimeDescriptorLoaderTest.kt
+++ b/compiler/tests/org/jetbrains/kotlin/jvm/runtime/AbstractJvmRuntimeDescriptorLoaderTest.kt
@@ -35,6 +35,7 @@ import org.jetbrains.kotlin.renderer.DescriptorRendererModifier
 import org.jetbrains.kotlin.renderer.OverrideRenderingPolicy
 import org.jetbrains.kotlin.renderer.ParameterNameRenderingPolicy
 import org.jetbrains.kotlin.resolve.DescriptorUtils
+import org.jetbrains.kotlin.resolve.lazy.JvmPackageMappingProvider
 import org.jetbrains.kotlin.resolve.scopes.*
 import org.jetbrains.kotlin.serialization.deserialization.findClassAcrossModuleDependencies
 import org.jetbrains.kotlin.test.*
@@ -123,7 +124,7 @@ public abstract class AbstractJvmRuntimeDescriptorLoaderTest : TestCaseWithTmpdi
                         myTestRootDisposable, ConfigurationKind.ALL, jdkKind
                 )
                 val jetFile = JetTestUtils.createFile(file.getPath(), text, environment.project)
-                GenerationUtils.compileFileGetClassFileFactoryForTest(jetFile).writeAllTo(tmpdir)
+                GenerationUtils.compileFileGetClassFileFactoryForTest(jetFile, environment).writeAllTo(tmpdir)
             }
         }
     }
diff --git a/compiler/tests/org/jetbrains/kotlin/resolve/ExpectedResolveData.java b/compiler/tests/org/jetbrains/kotlin/resolve/ExpectedResolveData.java
index c3b8141483b..947454ff7ff 100644
--- a/compiler/tests/org/jetbrains/kotlin/resolve/ExpectedResolveData.java
+++ b/compiler/tests/org/jetbrains/kotlin/resolve/ExpectedResolveData.java
@@ -26,6 +26,7 @@ import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.kotlin.analyzer.AnalysisResult;
 import org.jetbrains.kotlin.builtins.KotlinBuiltIns;
+import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment;
 import org.jetbrains.kotlin.descriptors.*;
 import org.jetbrains.kotlin.diagnostics.Diagnostic;
 import org.jetbrains.kotlin.diagnostics.DiagnosticUtils;
@@ -131,15 +132,14 @@ public abstract class ExpectedResolveData {
 
     protected abstract JetFile createJetFile(String fileName, String text);
 
-    protected BindingContext analyze(List<JetFile> files) {
+    protected static BindingContext analyze(List<JetFile> files, KotlinCoreEnvironment environment) {
         if (files.isEmpty()) {
             System.err.println("Suspicious: no files");
             return BindingContext.EMPTY;
         }
 
         Project project = files.iterator().next().getProject();
-        AnalysisResult analysisResult = JvmResolveUtil.analyzeFilesWithJavaIntegration(
-                project, files);
+        AnalysisResult analysisResult = JvmResolveUtil.analyzeFilesWithJavaIntegration(project, files, environment);
         return analysisResult.getBindingContext();
     }
 
diff --git a/compiler/tests/org/jetbrains/kotlin/resolve/ExtensibleResolveTestCase.java b/compiler/tests/org/jetbrains/kotlin/resolve/ExtensibleResolveTestCase.java
index bb5255784b6..ff60ddc1ac1 100644
--- a/compiler/tests/org/jetbrains/kotlin/resolve/ExtensibleResolveTestCase.java
+++ b/compiler/tests/org/jetbrains/kotlin/resolve/ExtensibleResolveTestCase.java
@@ -60,6 +60,6 @@ public abstract class ExtensibleResolveTestCase extends JetLiteFixture {
                 return expectedResolveData.createFileFromMarkedUpText(fileName, text);
             }
         });
-        expectedResolveData.checkResult(expectedResolveData.analyze(files));
+        expectedResolveData.checkResult(ExpectedResolveData.analyze(files, getEnvironment()));
     }
 }
diff --git a/compiler/tests/org/jetbrains/kotlin/resolve/annotation/AnnotationDescriptorResolveWithoutAnalyzeBodyTest.kt b/compiler/tests/org/jetbrains/kotlin/resolve/annotation/AnnotationDescriptorResolveWithoutAnalyzeBodyTest.kt
index 9a1ec9a71b2..9e3586be40e 100644
--- a/compiler/tests/org/jetbrains/kotlin/resolve/annotation/AnnotationDescriptorResolveWithoutAnalyzeBodyTest.kt
+++ b/compiler/tests/org/jetbrains/kotlin/resolve/annotation/AnnotationDescriptorResolveWithoutAnalyzeBodyTest.kt
@@ -26,5 +26,6 @@ class AnnotationDescriptorResolveWithoutAnalyzeBodyTest : AnnotationDescriptorRe
         checkAnnotationOnAllExceptLocalDeclarations(content, expectedAnnotation)
     }
 
-    override fun analyzeFile(ktFile: JetFile): AnalysisResult = JvmResolveUtil.analyzeFilesWithJavaIntegration(ktFile.getProject(), setOf(ktFile));
+    override fun analyzeFile(ktFile: JetFile): AnalysisResult =
+            JvmResolveUtil.analyzeFilesWithJavaIntegration(ktFile.getProject(), setOf(ktFile), environment);
 }
diff --git a/compiler/tests/org/jetbrains/kotlin/resolve/lazy/JvmResolveUtil.java b/compiler/tests/org/jetbrains/kotlin/resolve/lazy/JvmResolveUtil.java
index 177b6614a9e..4fbe6462d6d 100644
--- a/compiler/tests/org/jetbrains/kotlin/resolve/lazy/JvmResolveUtil.java
+++ b/compiler/tests/org/jetbrains/kotlin/resolve/lazy/JvmResolveUtil.java
@@ -20,6 +20,7 @@ import com.intellij.openapi.project.Project;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.kotlin.analyzer.AnalysisResult;
 import org.jetbrains.kotlin.cli.jvm.compiler.CliLightClassGenerationSupport;
+import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment;
 import org.jetbrains.kotlin.context.ModuleContext;
 import org.jetbrains.kotlin.load.java.lazy.PackageMappingProvider;
 import org.jetbrains.kotlin.psi.JetFile;
@@ -33,18 +34,28 @@ import java.util.Collections;
 public class JvmResolveUtil {
     @NotNull
     public static AnalysisResult analyzeOneFileWithJavaIntegrationAndCheckForErrors(@NotNull JetFile file) {
+        return analyzeOneFileWithJavaIntegrationAndCheckForErrors(file, PackageMappingProvider.EMPTY);
+    }
+
+    @NotNull
+    public static AnalysisResult analyzeOneFileWithJavaIntegrationAndCheckForErrors(@NotNull JetFile file, @NotNull PackageMappingProvider provider) {
         AnalyzingUtils.checkForSyntacticErrors(file);
 
-        AnalysisResult analysisResult = analyzeOneFileWithJavaIntegration(file);
+        AnalysisResult analysisResult = analyzeOneFileWithJavaIntegration(file, provider);
 
         AnalyzingUtils.throwExceptionOnErrors(analysisResult.getBindingContext());
 
         return analysisResult;
     }
 
+    @NotNull
+    public static AnalysisResult analyzeOneFileWithJavaIntegration(@NotNull JetFile file,  @NotNull PackageMappingProvider provider) {
+        return analyzeFilesWithJavaIntegration(file.getProject(), Collections.singleton(file), provider);
+    }
+
     @NotNull
     public static AnalysisResult analyzeOneFileWithJavaIntegration(@NotNull JetFile file) {
-        return analyzeFilesWithJavaIntegration(file.getProject(), Collections.singleton(file));
+        return analyzeOneFileWithJavaIntegration(file, PackageMappingProvider.EMPTY);
     }
 
     @NotNull
@@ -75,9 +86,10 @@ public class JvmResolveUtil {
     @NotNull
     public static AnalysisResult analyzeFilesWithJavaIntegration(
             @NotNull Project project,
-            @NotNull Collection<JetFile> files
+            @NotNull Collection<JetFile> files,
+            @NotNull KotlinCoreEnvironment environment
     ) {
-        return analyzeFilesWithJavaIntegration(project, files, PackageMappingProvider.EMPTY);
+        return analyzeFilesWithJavaIntegration(project, files, new JvmPackageMappingProvider(environment));
     }
 
     @NotNull
diff --git a/compiler/tests/org/jetbrains/kotlin/types/AbstractJetTypeBindingTest.kt b/compiler/tests/org/jetbrains/kotlin/types/AbstractJetTypeBindingTest.kt
index 536d9ef7c8e..513b01d3bb4 100644
--- a/compiler/tests/org/jetbrains/kotlin/types/AbstractJetTypeBindingTest.kt
+++ b/compiler/tests/org/jetbrains/kotlin/types/AbstractJetTypeBindingTest.kt
@@ -36,7 +36,7 @@ abstract class AbstractJetTypeBindingTest : JetLiteFixture() {
         val testFile = File(path)
         val testKtFile = loadJetFile(getProject(), testFile)
 
-        val analyzeResult = JvmResolveUtil.analyzeFilesWithJavaIntegration(getProject(), listOf(testKtFile))
+        val analyzeResult = JvmResolveUtil.analyzeFilesWithJavaIntegration(getProject(), listOf(testKtFile), environment)
 
         val testDeclaration = testKtFile.getDeclarations().last()!! as JetCallableDeclaration