Utility methods moved to a utility class

compiler/android-tests/tests/org/jetbrains/jet/compiler/android/CodegenTestsOnAndroidGenerator.java

@@ -21,7 +21,6 @@ import com.intellij.openapi.util.io.FileUtil;
 import com.intellij.openapi.util.text.StringUtil;
 import com.intellij.testFramework.UsefulTestCase;
 import junit.framework.Assert;
-import org.jetbrains.jet.CompileCompilerDependenciesTest;
 import org.jetbrains.jet.ConfigurationKind;
 import org.jetbrains.jet.JetTestUtils;
 import org.jetbrains.jet.TestJdkKind;
@@ -73,7 +72,7 @@ public class CodegenTestsOnAndroidGenerator extends UsefulTestCase {
             throw new AssertionError();
         }
 
-        environmentWithFullJdkAndJUnit = new JetCoreEnvironment(myTestRootDisposable, CompileCompilerDependenciesTest.compilerConfigurationForTests(
+        environmentWithFullJdkAndJUnit = new JetCoreEnvironment(myTestRootDisposable, JetTestUtils.compilerConfigurationForTests(
                 ConfigurationKind.ALL, TestJdkKind.FULL_JDK, JetTestUtils.getAnnotationsJar(), junitJar));
 
     }

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

@@ -16,24 +16,11 @@
 
 package org.jetbrains.jet;
 
-import org.jetbrains.annotations.NotNull;
 import org.jetbrains.jet.codegen.forTestCompile.ForTestCompileBuiltins;
 import org.jetbrains.jet.codegen.forTestCompile.ForTestCompileRuntime;
 import org.jetbrains.jet.codegen.forTestCompile.ForTestPackJdkAnnotations;
-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 java.util.Collection;
-import java.util.Collections;
-
-import static org.jetbrains.jet.ConfigurationKind.ALL;
-import static org.jetbrains.jet.ConfigurationKind.JDK_AND_ANNOTATIONS;
-import static org.jetbrains.jet.cli.jvm.JVMConfigurationKeys.ANNOTATIONS_PATH_KEY;
-import static org.jetbrains.jet.cli.jvm.JVMConfigurationKeys.CLASSPATH_KEY;
-
 public class CompileCompilerDependenciesTest {
 
     @Test
@@ -50,28 +37,4 @@ public class CompileCompilerDependenciesTest {
     public void compileRuntime() {
         ForTestCompileRuntime.runtimeJarForTests();
     }
-
-    @NotNull
-    public static CompilerConfiguration compilerConfigurationForTests(@NotNull ConfigurationKind configurationKind,
-            @NotNull TestJdkKind jdkKind, File... extraClasspath) {
-        return compilerConfigurationForTests(configurationKind, jdkKind, Arrays.asList(extraClasspath), Collections.<File>emptyList());
-    }
-
-    @NotNull
-    public static CompilerConfiguration compilerConfigurationForTests(@NotNull ConfigurationKind configurationKind,
-            @NotNull TestJdkKind jdkKind, @NotNull Collection<File> extraClasspath, @NotNull Collection<File> priorityClasspath) {
-        CompilerConfiguration configuration = new CompilerConfiguration();
-        configuration.addAll(CLASSPATH_KEY, priorityClasspath);
-        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, extraClasspath);
-
-        if (configurationKind == ALL || configurationKind == JDK_AND_ANNOTATIONS) {
-            configuration.add(ANNOTATIONS_PATH_KEY, ForTestPackJdkAnnotations.jdkAnnotationsForTests());
-        }
-
-        return configuration;
-    }
 }

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

@@ -34,6 +34,9 @@ import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.TestOnly;
 import org.jetbrains.jet.analyzer.AnalyzeExhaust;
 import org.jetbrains.jet.cli.jvm.compiler.JetCoreEnvironment;
+import org.jetbrains.jet.codegen.forTestCompile.ForTestCompileRuntime;
+import org.jetbrains.jet.codegen.forTestCompile.ForTestPackJdkAnnotations;
+import org.jetbrains.jet.config.CompilerConfiguration;
 import org.jetbrains.jet.lang.diagnostics.Diagnostic;
 import org.jetbrains.jet.lang.diagnostics.Severity;
 import org.jetbrains.jet.lang.diagnostics.UnresolvedReferenceDiagnosticFactory;
@@ -52,6 +55,7 @@ import org.jetbrains.jet.util.slicedmap.SlicedMap;
 import org.jetbrains.jet.util.slicedmap.WritableSlice;
 import org.jetbrains.jet.utils.KotlinPaths;
 import org.jetbrains.jet.utils.KotlinPathsFromHomeDir;
+import org.jetbrains.jet.utils.PathUtil;
 import org.junit.Assert;
 
 import javax.tools.*;
@@ -64,6 +68,11 @@ import java.util.*;
 import java.util.regex.Matcher;
 import java.util.regex.Pattern;
 
+import static org.jetbrains.jet.ConfigurationKind.ALL;
+import static org.jetbrains.jet.ConfigurationKind.JDK_AND_ANNOTATIONS;
+import static org.jetbrains.jet.cli.jvm.JVMConfigurationKeys.ANNOTATIONS_PATH_KEY;
+import static org.jetbrains.jet.cli.jvm.JVMConfigurationKeys.CLASSPATH_KEY;
+
 public class JetTestUtils {
     private static List<File> filesToDelete = new ArrayList<File>();
 
@@ -213,7 +222,7 @@ public class JetTestUtils {
             @NotNull ConfigurationKind configurationKind,
             @NotNull TestJdkKind jdkKind
     ) {
-        return new JetCoreEnvironment(disposable, CompileCompilerDependenciesTest.compilerConfigurationForTests(
+        return new JetCoreEnvironment(disposable, compilerConfigurationForTests(
                 configurationKind, jdkKind, getAnnotationsJar()));
     }
 
@@ -300,6 +309,30 @@ public class JetTestUtils {
         return FileUtil.toSystemIndependentName(file.getPath());
     }
 
+    @NotNull
+    public static CompilerConfiguration compilerConfigurationForTests(@NotNull ConfigurationKind configurationKind,
+            @NotNull TestJdkKind jdkKind, File... extraClasspath) {
+        return compilerConfigurationForTests(configurationKind, jdkKind, Arrays.asList(extraClasspath), Collections.<File>emptyList());
+    }
+
+    @NotNull
+    public static CompilerConfiguration compilerConfigurationForTests(@NotNull ConfigurationKind configurationKind,
+            @NotNull TestJdkKind jdkKind, @NotNull Collection<File> extraClasspath, @NotNull Collection<File> priorityClasspath) {
+        CompilerConfiguration configuration = new CompilerConfiguration();
+        configuration.addAll(CLASSPATH_KEY, priorityClasspath);
+        configuration.add(CLASSPATH_KEY, jdkKind == TestJdkKind.MOCK_JDK ? findMockJdkRtJar() : PathUtil.findRtJar());
+        if (configurationKind == ALL) {
+            configuration.add(CLASSPATH_KEY, ForTestCompileRuntime.runtimeJarForTests());
+        }
+        configuration.addAll(CLASSPATH_KEY, extraClasspath);
+
+        if (configurationKind == ALL || configurationKind == JDK_AND_ANNOTATIONS) {
+            configuration.add(ANNOTATIONS_PATH_KEY, ForTestPackJdkAnnotations.jdkAnnotationsForTests());
+        }
+
+        return configuration;
+    }
+
     public interface TestFileFactory<F> {
         F create(String fileName, String text);
     }

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

@@ -52,7 +52,7 @@ public abstract class AbstractJetDiagnosticsTest extends JetLiteFixture {
         }
         return new JetCoreEnvironment(
                 getTestRootDisposable(),
-                CompileCompilerDependenciesTest.compilerConfigurationForTests(
+                JetTestUtils.compilerConfigurationForTests(
                         ConfigurationKind.JDK_AND_ANNOTATIONS,
                         TestJdkKind.MOCK_JDK,
                         Arrays.asList(JetTestUtils.getAnnotationsJar()),

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

@@ -26,7 +26,6 @@ import com.intellij.testFramework.UsefulTestCase;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.asm4.Type;
-import org.jetbrains.jet.CompileCompilerDependenciesTest;
 import org.jetbrains.jet.ConfigurationKind;
 import org.jetbrains.jet.JetTestUtils;
 import org.jetbrains.jet.TestJdkKind;
@@ -292,7 +291,7 @@ public abstract class CodegenTestCase extends UsefulTestCase {
     protected void blackBoxFileWithJava(@NotNull String ktFile, boolean classPathInTheSameClassLoader) throws Exception {
         File javaClassesTempDirectory = compileJava(ktFile.replaceFirst("\\.kt$", ".java"));
 
-        myEnvironment = new JetCoreEnvironment(getTestRootDisposable(), CompileCompilerDependenciesTest.compilerConfigurationForTests(
+        myEnvironment = new JetCoreEnvironment(getTestRootDisposable(), JetTestUtils.compilerConfigurationForTests(
                 ConfigurationKind.JDK_ONLY, TestJdkKind.MOCK_JDK, JetTestUtils.getAnnotationsJar(), javaClassesTempDirectory));
 
         blackBoxFile(ktFile, "OK", classPathInTheSameClassLoader);

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

@@ -21,8 +21,8 @@ import org.jetbrains.asm4.ClassReader;
 import org.jetbrains.asm4.ClassVisitor;
 import org.jetbrains.asm4.MethodVisitor;
 import org.jetbrains.asm4.Opcodes;
-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.JVMConfigurationKeys;
 import org.jetbrains.jet.cli.jvm.compiler.CompileEnvironmentUtil;
@@ -39,7 +39,7 @@ public class GenerateNotNullAssertionsTest extends CodegenTestCase {
     }
 
     private void setUpEnvironment(boolean generateAssertions, boolean generateParamAssertions, File... extraClassPath) {
-        CompilerConfiguration configuration = CompileCompilerDependenciesTest.compilerConfigurationForTests(
+        CompilerConfiguration configuration = JetTestUtils.compilerConfigurationForTests(
                 ConfigurationKind.JDK_ONLY, TestJdkKind.MOCK_JDK, extraClassPath);
 
         configuration.put(JVMConfigurationKeys.GENERATE_NOT_NULL_ASSERTIONS, generateAssertions);
@@ -73,7 +73,7 @@ public class GenerateNotNullAssertionsTest extends CodegenTestCase {
     }
 
     public void testNoAssertionsForKotlinFromBinary() throws Exception {
-        CompilerConfiguration configuration = CompileCompilerDependenciesTest.compilerConfigurationForTests(
+        CompilerConfiguration configuration = JetTestUtils.compilerConfigurationForTests(
                 ConfigurationKind.JDK_ONLY, TestJdkKind.MOCK_JDK);
         JetCoreEnvironment tmpEnvironment = new JetCoreEnvironment(getTestRootDisposable(), configuration);
         GenerationState state = generateCommon(ClassBuilderFactories.TEST, tmpEnvironment,

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

@@ -21,9 +21,7 @@ import com.google.common.collect.Maps;
 import com.intellij.openapi.util.io.FileUtil;
 import com.intellij.openapi.util.text.StringUtil;
 import org.jetbrains.annotations.NotNull;
-import org.jetbrains.annotations.Nullable;
 import org.jetbrains.asm4.*;
-import org.jetbrains.jet.CompileCompilerDependenciesTest;
 import org.jetbrains.jet.ConfigurationKind;
 import org.jetbrains.jet.JetTestUtils;
 import org.jetbrains.jet.TestJdkKind;
@@ -58,7 +56,7 @@ public class LineNumberTest extends TestCaseWithTmpdir {
 
     @NotNull
     private JetCoreEnvironment createEnvironment() {
-        return new JetCoreEnvironment(myTestRootDisposable, CompileCompilerDependenciesTest
+        return new JetCoreEnvironment(myTestRootDisposable, JetTestUtils
                 .compilerConfigurationForTests(ConfigurationKind.JDK_ONLY, TestJdkKind.MOCK_JDK, JetTestUtils.getAnnotationsJar(), tmpdir));
     }
 

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

@@ -16,7 +16,6 @@
 
 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;
@@ -46,7 +45,7 @@ public class StdlibTest extends CodegenTestCase {
         if (myEnvironment != null) {
             throw new IllegalStateException("must not set up myEnvironemnt twice");
         }
-        myEnvironment = new JetCoreEnvironment(getTestRootDisposable(), CompileCompilerDependenciesTest.compilerConfigurationForTests(
+        myEnvironment = new JetCoreEnvironment(getTestRootDisposable(), JetTestUtils.compilerConfigurationForTests(
                 ConfigurationKind.ALL, TestJdkKind.FULL_JDK, JetTestUtils.getAnnotationsJar(), junitJar));
     }
 

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

@@ -20,7 +20,6 @@ import gnu.trove.THashSet;
 import junit.framework.Test;
 import junit.framework.TestCase;
 import junit.framework.TestSuite;
-import org.jetbrains.jet.CompileCompilerDependenciesTest;
 import org.jetbrains.jet.ConfigurationKind;
 import org.jetbrains.jet.JetTestUtils;
 import org.jetbrains.jet.TestJdkKind;
@@ -153,8 +152,8 @@ public class TestlibTest extends CodegenTestCase {
     @Override
     public void setUp() throws Exception {
         super.setUp();
-        CompilerConfiguration configuration = CompileCompilerDependenciesTest.compilerConfigurationForTests(ConfigurationKind.ALL,
+        CompilerConfiguration configuration = JetTestUtils.compilerConfigurationForTests(ConfigurationKind.ALL,
-                                                                                                            TestJdkKind.FULL_JDK);
+                                                                                         TestJdkKind.FULL_JDK);
         configuration.add(JVMConfigurationKeys.CLASSPATH_KEY, JetTestUtils.getAnnotationsJar());
 
         junitJar = new File("libraries/lib/junit-4.9.jar");

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

@@ -1,5 +1,5 @@
 /*
- * Copyright 2010-2012 JetBrains s.r.o.
+ * Copyright 2010-2013 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.
@@ -21,7 +21,6 @@ import com.intellij.openapi.util.Disposer;
 import com.intellij.openapi.util.io.FileUtil;
 import com.intellij.util.ArrayUtil;
 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;
@@ -75,7 +74,7 @@ public abstract class AbstractCompileKotlinAgainstKotlinTest extends TestCaseWit
     }
 
     private void compileB(@NotNull File ktBFile) throws IOException {
-        CompilerConfiguration configurationWithADirInClasspath = CompileCompilerDependenciesTest
+        CompilerConfiguration configurationWithADirInClasspath = JetTestUtils
                 .compilerConfigurationForTests(ConfigurationKind.JDK_ONLY, TestJdkKind.MOCK_JDK, JetTestUtils.getAnnotationsJar(), aDir);
         compileKotlin(ktBFile, bDir, new JetCoreEnvironment(getTestRootDisposable(), configurationWithADirInClasspath),
                       getTestRootDisposable());

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

@@ -18,7 +18,6 @@ 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;
@@ -74,7 +73,7 @@ public abstract class AbstractJavaResolverDescriptorTest extends TestCaseWithTmp
 
     private void setUpJavaDescriptorResolver() {
         JetCoreEnvironment jetCoreEnvironment =
-                new JetCoreEnvironment(myTestRootDisposable, CompileCompilerDependenciesTest.compilerConfigurationForTests(
+                new JetCoreEnvironment(myTestRootDisposable, JetTestUtils.compilerConfigurationForTests(
                         ConfigurationKind.JDK_ONLY, TestJdkKind.MOCK_JDK, JetTestUtils.getAnnotationsJar(), tmpdir));
 
         InjectorForJavaSemanticServices injector = new InjectorForJavaSemanticServices(jetCoreEnvironment.getProject());

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

@@ -21,7 +21,6 @@ import com.intellij.openapi.util.Disposer;
 import com.intellij.openapi.util.Pair;
 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;
@@ -94,7 +93,7 @@ public final class LoadDescriptorUtil {
     ) {
         Disposer.dispose(disposable);
 
-        CompilerConfiguration configuration = CompileCompilerDependenciesTest.compilerConfigurationForTests(
+        CompilerConfiguration configuration = JetTestUtils.compilerConfigurationForTests(
                 configurationKind, TestJdkKind.MOCK_JDK, JetTestUtils.getAnnotationsJar(), outDir,
                 ForTestCompileRuntime.runtimeJarForTests());
         JetCoreEnvironment jetCoreEnvironment = new JetCoreEnvironment(disposable, configuration);

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

@@ -22,7 +22,6 @@ import com.intellij.psi.PsiFile;
 import com.intellij.util.Function;
 import com.intellij.util.containers.ContainerUtil;
 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;
@@ -141,7 +140,7 @@ public final class LoadJavaCustomTest extends KotlinTestWithEnvironment {
         protected JetCoreEnvironment createEnvironment() {
             File dir = new File(PATH + "/subclassingKotlinInJava");
 
-            CompilerConfiguration configuration = CompileCompilerDependenciesTest.compilerConfigurationForTests(
+            CompilerConfiguration configuration = JetTestUtils.compilerConfigurationForTests(
                     ConfigurationKind.JDK_ONLY, TestJdkKind.MOCK_JDK, new File(dir, "java"));
             configuration.put(CommonConfigurationKeys.SOURCE_ROOTS_KEY, Arrays.asList(new File(dir, "kotlin").getAbsolutePath()));
             return new JetCoreEnvironment(getTestRootDisposable(), configuration);

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

@@ -139,12 +139,12 @@ public class ResolveDescriptorsFromExternalLibraries {
 
         JetCoreEnvironment jetCoreEnvironment;
         if (jar != null) {
-            jetCoreEnvironment = new JetCoreEnvironment(junk, CompileCompilerDependenciesTest.compilerConfigurationForTests(
+            jetCoreEnvironment = new JetCoreEnvironment(junk, JetTestUtils.compilerConfigurationForTests(
                     ConfigurationKind.JDK_AND_ANNOTATIONS, TestJdkKind.MOCK_JDK, JetTestUtils.getAnnotationsJar(), jar));
         }
         else {
             CompilerConfiguration configuration =
-                    CompileCompilerDependenciesTest.compilerConfigurationForTests(ConfigurationKind.JDK_AND_ANNOTATIONS, TestJdkKind.FULL_JDK);
+                    JetTestUtils.compilerConfigurationForTests(ConfigurationKind.JDK_AND_ANNOTATIONS, TestJdkKind.FULL_JDK);
             jetCoreEnvironment = new JetCoreEnvironment(junk, configuration);
             if (!PathUtil.findRtJar().equals(jar)) {
                 throw new RuntimeException("rt.jar mismatch: " + jar + ", " + PathUtil.findRtJar());

compiler/tests/org/jetbrains/jet/repl/ReplInterpreterTest.java

@@ -20,8 +20,8 @@ import com.intellij.openapi.Disposable;
 import com.intellij.openapi.util.Disposer;
 import com.intellij.openapi.util.text.StringUtil;
 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.JVMConfigurationKeys;
 import org.jetbrains.jet.cli.jvm.repl.ReplInterpreter;
@@ -51,7 +51,7 @@ public class ReplInterpreterTest {
 
     private void testFile(@NotNull String relativePath) {
         CompilerConfiguration configuration =
-                CompileCompilerDependenciesTest.compilerConfigurationForTests(ConfigurationKind.JDK_ONLY, TestJdkKind.FULL_JDK);
+                JetTestUtils.compilerConfigurationForTests(ConfigurationKind.JDK_ONLY, TestJdkKind.FULL_JDK);
         configuration.add(JVMConfigurationKeys.CLASSPATH_KEY, new File("out/production/runtime"));
         ReplInterpreter repl = new ReplInterpreter(disposable, configuration);