Got rid of post-init adding classpath in all tests.

compiler/tests/org/jetbrains/jet/CompileCompilerDependenciesTest.java

@@ -24,6 +24,9 @@ import org.jetbrains.jet.config.CompilerConfiguration;
 import org.jetbrains.jet.utils.PathUtil;
 import org.junit.Test;
 
+import java.io.File;
+import java.util.Arrays;
+
 import static org.jetbrains.jet.ConfigurationKind.ALL;
 import static org.jetbrains.jet.ConfigurationKind.JDK_AND_ANNOTATIONS;
 import static org.jetbrains.jet.cli.jvm.JVMConfigurationKeys.*;
@@ -48,12 +51,14 @@ public class CompileCompilerDependenciesTest {
         ForTestCompileRuntime.runtimeJarForTests();
     }
 
-    public static CompilerConfiguration compilerConfigurationForTests(@NotNull ConfigurationKind configurationKind, @NotNull TestJdkKind jdkKind) {
+    public static CompilerConfiguration compilerConfigurationForTests(@NotNull ConfigurationKind configurationKind,
+            @NotNull TestJdkKind jdkKind, File... extraClasspath) {
         CompilerConfiguration configuration = new CompilerConfiguration();
         configuration.add(CLASSPATH_KEY, jdkKind == TestJdkKind.MOCK_JDK ? JetTestUtils.findMockJdkRtJar() : PathUtil.findRtJar());
         if (configurationKind == ALL) {
             configuration.add(CLASSPATH_KEY, ForTestCompileRuntime.runtimeJarForTests());
         }
+        configuration.addAll(CLASSPATH_KEY, Arrays.asList(extraClasspath));
 
         if (configurationKind == ALL || configurationKind == JDK_AND_ANNOTATIONS) {
             configuration.add(ANNOTATIONS_PATH_KEY, ForTestPackJdkAnnotations.jdkAnnotationsForTests());

compiler/tests/org/jetbrains/jet/JetTestUtils.java

@@ -195,12 +195,8 @@ public class JetTestUtils {
             @NotNull ConfigurationKind configurationKind,
             @NotNull TestJdkKind jdkKind
     ) {
-        JetCoreEnvironment environment = new JetCoreEnvironment(disposable,
-                                                                CompileCompilerDependenciesTest
-                                                                        .compilerConfigurationForTests(configurationKind, jdkKind)
-        );
-        environment.addToClasspath(getAnnotationsJar());
-        return environment;
+        return new JetCoreEnvironment(disposable, CompileCompilerDependenciesTest.compilerConfigurationForTests(
+                configurationKind, jdkKind, getAnnotationsJar()));
     }
 
     public static File findMockJdkRtJar() {

compiler/tests/org/jetbrains/jet/checkers/AbstractJetDiagnosticsTest.java

@@ -19,16 +19,13 @@ package org.jetbrains.jet.checkers;
 import com.google.common.collect.Lists;
 import com.google.common.io.Files;
 import com.intellij.lang.java.JavaLanguage;
-import com.intellij.openapi.util.Ref;
 import com.intellij.openapi.util.TextRange;
 import com.intellij.openapi.util.io.FileUtil;
 import com.intellij.psi.PsiFile;
 import com.intellij.psi.PsiFileFactory;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
-import org.jetbrains.jet.ConfigurationKind;
-import org.jetbrains.jet.JetLiteFixture;
-import org.jetbrains.jet.JetTestUtils;
+import org.jetbrains.jet.*;
 import org.jetbrains.jet.cli.jvm.compiler.JetCoreEnvironment;
 import org.jetbrains.jet.lang.diagnostics.DiagnosticUtils;
 import org.jetbrains.jet.lang.psi.JetFile;
@@ -48,10 +45,19 @@ public abstract class AbstractJetDiagnosticsTest extends JetLiteFixture {
 
     @Override
     protected JetCoreEnvironment createEnvironment() {
-        return createEnvironmentWithMockJdk(ConfigurationKind.JDK_AND_ANNOTATIONS);
+        File javaFilesDir = new File(FileUtil.getTempDirectory(), "java-files");
+        try {
+            JetTestUtils.mkdirs(javaFilesDir);
+        }
+        catch (IOException e) {
+            throw ExceptionUtils.rethrow(e);
+        }
+        return new JetCoreEnvironment(getTestRootDisposable(), CompileCompilerDependenciesTest.compilerConfigurationForTests(
+                ConfigurationKind.JDK_AND_ANNOTATIONS, TestJdkKind.MOCK_JDK, JetTestUtils.getAnnotationsJar(),
+                javaFilesDir));
     }
 
-    private boolean writeJavaFile(@NotNull String fileName, @NotNull String content, @NotNull File javaFilesDir) {
+    private static boolean writeJavaFile(@NotNull String fileName, @NotNull String content, @NotNull File javaFilesDir) {
         try {
             File javaFile = new File(javaFilesDir, fileName);
             JetTestUtils.mkdirs(javaFile.getParentFile());
@@ -67,25 +73,18 @@ public abstract class AbstractJetDiagnosticsTest extends JetLiteFixture {
         final File javaFilesDir = new File(FileUtil.getTempDirectory(), "java-files");
 
         String expectedText = JetTestUtils.doLoadFile(file);
-        final Ref<Boolean> hasJavaFiles = new Ref<Boolean>(false);
 
         List<TestFile> testFiles =
                 JetTestUtils.createTestFiles(file.getName(), expectedText, new JetTestUtils.TestFileFactory<TestFile>() {
                     @Override
                     public TestFile create(String fileName, String text) {
                         if (fileName.endsWith(".java")) {
-                            hasJavaFiles.set(writeJavaFile(fileName, text, javaFilesDir));
+                            writeJavaFile(fileName, text, javaFilesDir);
                         }
                         return new TestFile(fileName, text);
                     }
                 });
 
-        if (hasJavaFiles.get()) {
-            // According to yole@ the only way to import java files is to write them on disk
-            // -- stepan.koltsov@ 2012-02-29
-            getEnvironment().addToClasspath(javaFilesDir);
-        }
-
         analyzeAndCheck(file, expectedText, testFiles);
     }
 

compiler/tests/org/jetbrains/jet/codegen/CodegenTestCase.java

@@ -25,6 +25,7 @@ import com.intellij.testFramework.UsefulTestCase;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.jet.ConfigurationKind;
+import org.jetbrains.jet.cli.jvm.JVMConfigurationKeys;
 import org.jetbrains.jet.lang.BuiltinsScopeExtensionMode;
 import org.jetbrains.jet.utils.ExceptionUtils;
 import org.jetbrains.jet.JetTestUtils;
@@ -54,7 +55,6 @@ public abstract class CodegenTestCase extends UsefulTestCase {
 
     // for environment and classloader
     protected JetCoreEnvironment myEnvironment;
-    private List<File> extraClasspath = Lists.newArrayList();
     protected CodegenTestFiles myFiles;
 
     protected Object scriptInstance;
@@ -80,11 +80,6 @@ public abstract class CodegenTestCase extends UsefulTestCase {
         myEnvironment = JetTestUtils.createEnvironmentWithFullJdk(getTestRootDisposable());
     }
 
-    protected void addToClasspath(@NotNull File file) {
-        myEnvironment.addToClasspath(file);
-        extraClasspath.add(file);
-    }
-
     protected static void assertThrows(Method foo, Class<? extends Throwable> exceptionClass, Object instance, Object... args) throws IllegalAccessException {
         boolean caught = false;
         try {
@@ -240,7 +235,7 @@ public abstract class CodegenTestCase extends UsefulTestCase {
 
     protected GeneratedClassLoader createClassLoader(ClassFileFactory codegens) {
         List<URL> urls = Lists.newArrayList();
-        for (File file : extraClasspath) {
+        for (File file : myEnvironment.getConfiguration().getList(JVMConfigurationKeys.CLASSPATH_KEY)) {
             try {
                 urls.add(file.toURI().toURL());
             } catch (MalformedURLException e) {

compiler/tests/org/jetbrains/jet/codegen/FunctionGenTest.java

@@ -18,8 +18,11 @@ package org.jetbrains.jet.codegen;
 
 import com.intellij.openapi.util.io.FileUtil;
 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.JetCoreEnvironment;
 
 import java.io.File;
 import java.lang.reflect.InvocationTargetException;
@@ -118,24 +121,26 @@ public class FunctionGenTest extends CodegenTestCase {
         blackBoxFile("functions/invoke.kt");
     }
 
-    private void blackBoxFileWithJava(@NotNull String ktFile) throws Exception {
-        File javaClassesTempDirectory = new File(FileUtil.getTempDirectory(), "java-classes");
-        JetTestUtils.mkdirs(javaClassesTempDirectory);
-        JetTestUtils.compileJavaFile(
-                new File("compiler/testData/codegen/" + ktFile.replaceFirst("\\.kt$", ".java")),
-                javaClassesTempDirectory);
+    public static class WithJavaFunctionGenTest extends CodegenTestCase {
+        private void blackBoxFileWithJava(@NotNull String ktFile) throws Exception {
+            File javaClassesTempDirectory = new File(FileUtil.getTempDirectory(), "java-classes");
+            JetTestUtils.mkdirs(javaClassesTempDirectory);
+            JetTestUtils.compileJavaFile(
+                    new File("compiler/testData/codegen/" + ktFile.replaceFirst("\\.kt$", ".java")),
+                    javaClassesTempDirectory);
 
-        addToClasspath(javaClassesTempDirectory);
+            myEnvironment = new JetCoreEnvironment(getTestRootDisposable(), CompileCompilerDependenciesTest.compilerConfigurationForTests(
+                    ConfigurationKind.JDK_ONLY, TestJdkKind.MOCK_JDK, JetTestUtils.getAnnotationsJar(), javaClassesTempDirectory));
 
-        blackBoxFile(ktFile);
+            blackBoxFile(ktFile);
+        }
+
+        public void testReferencesStaticInnerClassMethod() throws Exception {
+            blackBoxFileWithJava("functions/referencesStaticInnerClassMethod.kt");
+        }
+
+        public void testReferencesStaticInnerClassMethodTwoLevels() throws Exception {
+            blackBoxFileWithJava("functions/referencesStaticInnerClassMethodL2.kt");
+        }
     }
-
-    public void testReferencesStaticInnerClassMethod() throws Exception {
-        blackBoxFileWithJava("functions/referencesStaticInnerClassMethod.kt");
-    }
-
-    public void testReferencesStaticInnerClassMethodTwoLevels() throws Exception {
-        blackBoxFileWithJava("functions/referencesStaticInnerClassMethodL2.kt");
-    }
-
 }

compiler/tests/org/jetbrains/jet/codegen/StdlibTest.java

@@ -16,6 +16,11 @@
 
 package org.jetbrains.jet.codegen;
 
+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.codegen.forTestCompile.ForTestCompileRuntime;
 import org.jetbrains.jet.lang.psi.JetPsiUtil;
 import org.junit.Test;
@@ -35,15 +40,17 @@ public class StdlibTest extends CodegenTestCase {
     @Override
     protected void setUp() throws Exception {
         super.setUp();
-        createEnvironmentWithFullJdk();
-        myEnvironment.addToClasspath(ForTestCompileRuntime.runtimeJarForTests());
         File junitJar = new File("libraries/lib/junit-4.9.jar");
 
         if (!junitJar.exists()) {
             throw new AssertionError();
         }
 
-        myEnvironment.addToClasspath(junitJar);
+        if (myEnvironment != null) {
+            throw new IllegalStateException("must not set up myEnvironemnt twice");
+        }
+        myEnvironment = new JetCoreEnvironment(getTestRootDisposable(), CompileCompilerDependenciesTest.compilerConfigurationForTests(
+                ConfigurationKind.ALL, TestJdkKind.FULL_JDK, JetTestUtils.getAnnotationsJar(), junitJar));
     }
 
     @Override

compiler/tests/org/jetbrains/jet/jvm/compiler/AbstractReadJavaBinaryClassTest.java

@@ -22,8 +22,10 @@ import com.intellij.psi.PsiFileFactory;
 import com.intellij.psi.impl.PsiFileFactoryImpl;
 import com.intellij.testFramework.LightVirtualFile;
 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.JetCoreEnvironment;
 import org.jetbrains.jet.lang.BuiltinsScopeExtensionMode;
 import org.jetbrains.jet.lang.descriptors.NamespaceDescriptor;

compiler/tests/org/jetbrains/jet/jvm/compiler/CompileKotlinAgainstKotlinTest.java

@@ -25,8 +25,7 @@ import com.intellij.testFramework.LightVirtualFile;
 import junit.framework.Assert;
 import junit.framework.Test;
 import org.jetbrains.annotations.NotNull;
-import org.jetbrains.jet.JetTestCaseBuilder;
-import org.jetbrains.jet.JetTestUtils;
+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.*;
@@ -100,9 +99,8 @@ public class CompileKotlinAgainstKotlinTest extends TestCaseWithTmpdir {
     }
 
     private void compileB() throws IOException {
-        JetCoreEnvironment jetCoreEnvironment = JetTestUtils.createEnvironmentWithMockJdkAndIdeaAnnotations(myTestRootDisposable);
-
-        jetCoreEnvironment.addToClasspath(aDir);
+        JetCoreEnvironment jetCoreEnvironment = new JetCoreEnvironment(myTestRootDisposable, CompileCompilerDependenciesTest
+                .compilerConfigurationForTests(ConfigurationKind.ALL, TestJdkKind.MOCK_JDK, JetTestUtils.getAnnotationsJar(), aDir));
 
         String text = FileUtil.loadFile(ktBFile);
 

compiler/tests/org/jetbrains/jet/jvm/compiler/JavaDescriptorResolverTest.java

@@ -17,8 +17,10 @@
 package org.jetbrains.jet.jvm.compiler;
 
 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.JetCoreEnvironment;
 import org.jetbrains.jet.di.InjectorForJavaSemanticServices;
 import org.jetbrains.jet.lang.BuiltinsScopeExtensionMode;
@@ -69,9 +71,9 @@ public class JavaDescriptorResolverTest extends TestCaseWithTmpdir {
     private JavaDescriptorResolver compileFileGetJavaDescriptorResolver(String fileRelativePath) throws IOException {
         JetTestUtils.compileJavaFile(new File("compiler/testData/javaDescriptorResolver/" + fileRelativePath), tmpdir);
 
-        JetCoreEnvironment jetCoreEnvironment = JetTestUtils.createEnvironmentWithMockJdkAndIdeaAnnotations(
-                myTestRootDisposable, ConfigurationKind.JDK_ONLY);
-        jetCoreEnvironment.addToClasspath(tmpdir);
+        JetCoreEnvironment jetCoreEnvironment =
+                new JetCoreEnvironment(myTestRootDisposable, CompileCompilerDependenciesTest.compilerConfigurationForTests(
+                        ConfigurationKind.JDK_ONLY, TestJdkKind.MOCK_JDK, JetTestUtils.getAnnotationsJar(), tmpdir));
 
         InjectorForJavaSemanticServices injector = new InjectorForJavaSemanticServices(BuiltinsScopeExtensionMode.ALL,
                                                                                        jetCoreEnvironment.getProject());

compiler/tests/org/jetbrains/jet/jvm/compiler/LoadJavaDescriptorUtil.java

@@ -18,8 +18,10 @@ package org.jetbrains.jet.jvm.compiler;
 
 import com.intellij.openapi.Disposable;
 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.JetCoreEnvironment;
 import org.jetbrains.jet.di.InjectorForJavaSemanticServices;
 import org.jetbrains.jet.lang.BuiltinsScopeExtensionMode;
@@ -66,10 +68,9 @@ public final class LoadJavaDescriptorUtil {
             fileManager.close();
         }
 
-        JetCoreEnvironment jetCoreEnvironment = JetTestUtils.createEnvironmentWithMockJdkAndIdeaAnnotations(disposable, ConfigurationKind.JDK_ONLY);
-
-        jetCoreEnvironment.addToClasspath(tmpdir);
-        jetCoreEnvironment.addToClasspath(new File("out/production/runtime"));
+        JetCoreEnvironment jetCoreEnvironment = new JetCoreEnvironment(disposable, CompileCompilerDependenciesTest.
+                compilerConfigurationForTests(ConfigurationKind.JDK_ONLY, TestJdkKind.MOCK_JDK, JetTestUtils.getAnnotationsJar(), tmpdir,
+                                              new File("out/production/runtime")));
 
         InjectorForJavaSemanticServices injector = new InjectorForJavaSemanticServices(BuiltinsScopeExtensionMode.ALL,
                                                                                        jetCoreEnvironment.getProject());

compiler/tests/org/jetbrains/jet/jvm/compiler/ReadKotlinBinaryClassTest.java

@@ -25,14 +25,13 @@ import com.intellij.testFramework.LightVirtualFile;
 import junit.framework.Assert;
 import junit.framework.Test;
 import org.jetbrains.annotations.NotNull;
-import org.jetbrains.jet.ConfigurationKind;
-import org.jetbrains.jet.JetTestCaseBuilder;
-import org.jetbrains.jet.JetTestUtils;
+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.lang.descriptors.NamespaceDescriptor;
@@ -89,10 +88,9 @@ public class ReadKotlinBinaryClassTest extends TestCaseWithTmpdir {
         Disposer.dispose(myTestRootDisposable);
 
 
-        jetCoreEnvironment = JetTestUtils.createEnvironmentWithMockJdkAndIdeaAnnotations(myTestRootDisposable, ConfigurationKind.JDK_ONLY);
-
-        jetCoreEnvironment.addToClasspath(tmpdir);
-        jetCoreEnvironment.addToClasspath(new File("out/production/runtime"));
+        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());

compiler/tests/org/jetbrains/jet/jvm/compiler/longTest/ResolveDescriptorsFromExternalLibraries.java

@@ -143,8 +143,8 @@ public class ResolveDescriptorsFromExternalLibraries {
 
         JetCoreEnvironment jetCoreEnvironment;
         if (jar != null) {
-            jetCoreEnvironment = JetTestUtils.createEnvironmentWithMockJdkAndIdeaAnnotations(junk, ConfigurationKind.JDK_AND_ANNOTATIONS);
-            jetCoreEnvironment.addToClasspath(jar);
+            jetCoreEnvironment = new JetCoreEnvironment(junk, CompileCompilerDependenciesTest.compilerConfigurationForTests(
+                    ConfigurationKind.JDK_AND_ANNOTATIONS, TestJdkKind.MOCK_JDK, JetTestUtils.getAnnotationsJar(), jar));
         }
         else {
             CompilerConfiguration configuration =