Base classes for tests put into order:

* KotlinTestWithEnvironmentManagement — methods for creating envirnoments tied up to test root disposable (automatically disposed on teadDown())
* KotlinTestWithEnvironment — a test with one environment (created by an abstract method)

Also, utilities for laz yresolve tests moved to LazyResolveTestUtil

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

@@ -1,40 +0,0 @@
-/*
- * Copyright 2010-2012 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.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package org.jetbrains.jet;
-
-import com.intellij.openapi.project.Project;
-import org.jetbrains.annotations.NotNull;
-
-/**
- * @author abreslav
- */
-public abstract class KotlinTestWithDefaultEnvironment extends KotlinTestWithEnvironmentManagement {
-    private JetCoreEnvironmentWithDisposable regularEnvironment;
-
-    @NotNull
-    public JetCoreEnvironmentWithDisposable getRegularEnvironment() {
-        if (regularEnvironment == null) {
-            regularEnvironment = new JetCoreEnvironmentWithDisposable(ConfigurationKind.ALL);
-        }
-        return regularEnvironment;
-    }
-
-    @NotNull
-    protected Project getProject() {
-        return getRegularEnvironment().project;
-    }
-}

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

@@ -16,49 +16,25 @@
 
 package org.jetbrains.jet;
 
-import com.intellij.openapi.Disposable;
-import com.intellij.openapi.project.Project;
-import com.intellij.openapi.util.Disposer;
-import junit.framework.TestCase;
+import com.intellij.testFramework.UsefulTestCase;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.jet.cli.jvm.compiler.JetCoreEnvironment;
 
 /**
  * @author abreslav
  */
-public abstract class KotlinTestWithEnvironmentManagement extends TestCase {
+public abstract class KotlinTestWithEnvironmentManagement extends UsefulTestCase {
     static {
         System.setProperty("java.awt.headless", "true");
     }
 
-    private final Disposable rootDisposable = new Disposable() {
-        @Override
-        public void dispose() {
-        }
-    };
-
-    public class JetCoreEnvironmentWithDisposable {
-        public final JetCoreEnvironment jetCoreEnvironment;
-
-        public final Project project;
-
-        public JetCoreEnvironmentWithDisposable(@NotNull ConfigurationKind configurationKind) {
-            this(configurationKind, true);
-        }
-
-        public JetCoreEnvironmentWithDisposable(@NotNull ConfigurationKind configurationKind, boolean mockJdk) {
-            this.jetCoreEnvironment = new JetCoreEnvironment(rootDisposable,
-                            CompileCompilerDependenciesTest.compilerConfigurationForTests(configurationKind, mockJdk)
-                    );
-            this.project = jetCoreEnvironment.getProject();
-        }
-
+    protected JetCoreEnvironment createEnvironmentWithMockJdk(@NotNull ConfigurationKind configurationKind) {
+        return createEnvironmentWithJdk(configurationKind, true);
     }
 
-    @Override
-    public void tearDown() throws Exception {
-        Disposer.dispose(rootDisposable);
-        super.tearDown();
+    protected JetCoreEnvironment createEnvironmentWithJdk(@NotNull ConfigurationKind configurationKind, boolean mockJdk) {
+        return new JetCoreEnvironment(getTestRootDisposable(),
+                                    CompileCompilerDependenciesTest.compilerConfigurationForTests(configurationKind, mockJdk)
+                            );
     }
-
 }

compiler/tests/org/jetbrains/jet/lang/resolve/lazy/AbstractLazyResolveDescriptorRendererTest.java

@@ -22,7 +22,9 @@ import com.intellij.openapi.editor.impl.DocumentImpl;
 import com.intellij.openapi.util.io.FileUtil;
 import com.intellij.psi.PsiElement;
 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.di.InjectorForTopDownAnalyzer;
 import org.jetbrains.jet.lang.descriptors.*;
 import org.jetbrains.jet.lang.psi.*;
@@ -42,12 +44,16 @@ import java.util.List;
 /**
  * @author abreslav
  */
-public abstract class AbstractLazyResolveDescriptorRendererTest extends AbstractLazyResolveTest {
+public abstract class AbstractLazyResolveDescriptorRendererTest extends KotlinTestWithEnvironment {
 
+    @Override
+    protected JetCoreEnvironment createEnvironment() {
+        return createEnvironmentWithMockJdk(ConfigurationKind.ALL);
+    }
 
     protected void doTest(@NotNull String testFile) throws IOException {
 
-        InjectorForTopDownAnalyzer injectorForTopDownAnalyzer = getEagerInjectorForTopDownAnalyzer(getRegularEnvironment().jetCoreEnvironment);
+        InjectorForTopDownAnalyzer injectorForTopDownAnalyzer = LazyResolveTestUtil.getEagerInjectorForTopDownAnalyzer(getEnvironment());
 
         JetFile psiFile = JetPsiFactory.createFile(getProject(), FileUtil.loadFile(new File(testFile), true));
         Collection<JetFile> files = Lists.newArrayList(psiFile);

compiler/tests/org/jetbrains/jet/lang/resolve/lazy/AbstractLazyResolveDiagnosticsTest.java

@@ -0,0 +1,32 @@
+/*
+ * Copyright 2010-2012 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.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.jetbrains.jet.lang.resolve.lazy;
+
+import org.jetbrains.jet.ConfigurationKind;
+import org.jetbrains.jet.cli.jvm.compiler.JetCoreEnvironment;
+
+/**
+ * @author abreslav
+ */
+public class AbstractLazyResolveDiagnosticsTest extends KotlinTestWithEnvironment {
+    @Override
+    protected JetCoreEnvironment createEnvironment() {
+        return createEnvironmentWithMockJdk(ConfigurationKind.ALL);
+    }
+
+
+}

compiler/tests/org/jetbrains/jet/lang/resolve/lazy/AbstractLazyResolveNamespaceComparingTest.java

@@ -22,6 +22,7 @@ import com.intellij.openapi.util.io.FileUtil;
 import com.intellij.util.Function;
 import org.jetbrains.jet.ConfigurationKind;
 import org.jetbrains.jet.JetTestUtils;
+import org.jetbrains.jet.cli.jvm.compiler.JetCoreEnvironment;
 import org.jetbrains.jet.jvm.compiler.NamespaceComparator;
 import org.jetbrains.jet.lang.descriptors.ModuleDescriptor;
 import org.jetbrains.jet.lang.descriptors.NamespaceDescriptor;
@@ -39,7 +40,13 @@ import java.util.List;
 /**
  * @author abreslav
  */
-public abstract class AbstractLazyResolveNamespaceComparingTest extends AbstractLazyResolveTest {
+public abstract class AbstractLazyResolveNamespaceComparingTest extends KotlinTestWithEnvironment {
+
+    @Override
+    protected JetCoreEnvironment createEnvironment() {
+        return createEnvironmentWithMockJdk(ConfigurationKind.JDK_ONLY);
+    }
+
     protected void doTest(
             String testFileName,
             Function<Pair<ModuleDescriptor, ModuleDescriptor>, Pair<NamespaceDescriptor, NamespaceDescriptor>> transform,
@@ -73,8 +80,8 @@ public abstract class AbstractLazyResolveNamespaceComparingTest extends Abstract
             Predicate<NamespaceDescriptor> filterJetNamespace,
             File serializeResultsTo
     ) {
-        ModuleDescriptor module = resolveEagerly(files, new JetCoreEnvironmentWithDisposable(ConfigurationKind.JDK_ONLY).jetCoreEnvironment);
-        ModuleDescriptor lazyModule = resolveLazily(files, new JetCoreEnvironmentWithDisposable(ConfigurationKind.JDK_ONLY).jetCoreEnvironment);
+        ModuleDescriptor module = LazyResolveTestUtil.resolveEagerly(files, getEnvironment());
+        ModuleDescriptor lazyModule = LazyResolveTestUtil.resolveLazily(files, getEnvironment());
 
         Pair<NamespaceDescriptor, NamespaceDescriptor> namespacesToCompare = transform.fun(Pair.create(module, lazyModule));
 

compiler/tests/org/jetbrains/jet/lang/resolve/lazy/KotlinTestWithEnvironment.java

@@ -14,42 +14,40 @@
  * limitations under the License.
  */
 
-package org.jetbrains.k2js.test;
+package org.jetbrains.jet.lang.resolve.lazy;
 
 import com.intellij.openapi.project.Project;
-import com.intellij.testFramework.UsefulTestCase;
 import org.jetbrains.annotations.NotNull;
-import org.jetbrains.annotations.Nullable;
+import org.jetbrains.jet.KotlinTestWithEnvironmentManagement;
 import org.jetbrains.jet.cli.jvm.compiler.JetCoreEnvironment;
-import org.jetbrains.jet.config.CompilerConfiguration;
 
 /**
- * @author Pavel Talanov
+ * @author abreslav
  */
-public abstract class TestWithEnvironment extends UsefulTestCase {
-
-    @Nullable
-    protected JetCoreEnvironment myEnvironment;
-
-    @NotNull
-    public Project getProject() {
-        assert myEnvironment != null : "Environment should be created beforehand.";
-        return myEnvironment.getProject();
-    }
+public abstract class KotlinTestWithEnvironment extends KotlinTestWithEnvironmentManagement {
+    private JetCoreEnvironment environment;
 
     @Override
     protected void setUp() throws Exception {
         super.setUp();
-        createEnvironmentWithMockJdkAndIdeaAnnotations();
+        environment = createEnvironment();
     }
 
     @Override
     protected void tearDown() throws Exception {
-        myEnvironment = null;
+        environment = null;
         super.tearDown();
     }
 
-    protected void createEnvironmentWithMockJdkAndIdeaAnnotations() {
-        myEnvironment = JetCoreEnvironment.createCoreEnvironmentForJVM(getTestRootDisposable(), new CompilerConfiguration());
+    protected abstract JetCoreEnvironment createEnvironment();
+
+    @NotNull
+    public JetCoreEnvironment getEnvironment() {
+        return environment;
+    }
+
+    @NotNull
+    public Project getProject() {
+        return getEnvironment().getProject();
     }
 }

compiler/tests/org/jetbrains/jet/lang/resolve/lazy/LazyResolveBuiltinClassesTest.java

@@ -23,6 +23,8 @@ import com.google.common.collect.Sets;
 import com.intellij.openapi.util.io.FileUtil;
 import com.intellij.util.Function;
 import org.jetbrains.annotations.NotNull;
+import org.jetbrains.jet.ConfigurationKind;
+import org.jetbrains.jet.cli.jvm.compiler.JetCoreEnvironment;
 import org.jetbrains.jet.jvm.compiler.NamespaceComparator;
 import org.jetbrains.jet.lang.DefaultModuleConfiguration;
 import org.jetbrains.jet.lang.ModuleConfiguration;
@@ -49,7 +51,12 @@ import java.util.Map;
 /**
  * @author abreslav
  */
-public class LazyResolveBuiltinClassesTest extends AbstractLazyResolveTest {
+public class LazyResolveBuiltinClassesTest extends KotlinTestWithEnvironment {
+    @Override
+    protected JetCoreEnvironment createEnvironment() {
+        return createEnvironmentWithMockJdk(ConfigurationKind.JDK_ONLY);
+    }
+
     @Test
     public void testJetStandardLibrary() throws Exception {
         List<JetFile> files = Lists.newArrayList();

compiler/tests/org/jetbrains/jet/lang/resolve/lazy/LazyResolveStdlibLoadingTest.java

@@ -24,6 +24,8 @@ import com.intellij.openapi.util.io.FileUtil;
 import com.intellij.util.Function;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.jet.ConfigurationKind;
+import org.jetbrains.jet.KotlinTestWithEnvironmentManagement;
+import org.jetbrains.jet.cli.jvm.compiler.JetCoreEnvironment;
 import org.jetbrains.jet.jvm.compiler.NamespaceComparator;
 import org.jetbrains.jet.lang.descriptors.ModuleDescriptor;
 import org.jetbrains.jet.lang.descriptors.NamespaceDescriptor;
@@ -38,15 +40,15 @@ import java.util.regex.Pattern;
 /**
  * @author abreslav
  */
-public class LazyResolveStdlibLoadingTest extends AbstractLazyResolveTest {
+public class LazyResolveStdlibLoadingTest extends KotlinTestWithEnvironmentManagement {
 
     private static final File STD_LIB_SRC = new File("libraries/stdlib/src");
-    private JetCoreEnvironmentWithDisposable stdlibEnvironment;
+    private JetCoreEnvironment stdlibEnvironment;
 
     @Override
     protected void setUp() throws Exception {
         super.setUp();
-        stdlibEnvironment = new JetCoreEnvironmentWithDisposable(ConfigurationKind.JDK_AND_ANNOTATIONS, false);
+        stdlibEnvironment = createEnvironmentWithJdk(ConfigurationKind.JDK_AND_ANNOTATIONS, false);
     }
 
     protected void doTestForGivenFiles(
@@ -55,8 +57,8 @@ public class LazyResolveStdlibLoadingTest extends AbstractLazyResolveTest {
             List<JetFile> files,
             Predicate<NamespaceDescriptor> filterJetNamespace
     ) {
-        ModuleDescriptor module = resolveEagerly(files, new JetCoreEnvironmentWithDisposable(ConfigurationKind.JDK_AND_ANNOTATIONS, false).jetCoreEnvironment);
-        ModuleDescriptor lazyModule = resolveLazily(files, stdlibEnvironment.jetCoreEnvironment);
+        ModuleDescriptor module = LazyResolveTestUtil.resolveEagerly(files, stdlibEnvironment);
+        ModuleDescriptor lazyModule = LazyResolveTestUtil.resolveLazily(files, stdlibEnvironment);
 
         Pair<NamespaceDescriptor, NamespaceDescriptor> namespacesToCompare = transform.fun(Pair.create(module, lazyModule));
 
@@ -76,26 +78,19 @@ public class LazyResolveStdlibLoadingTest extends AbstractLazyResolveTest {
                 //convertToJetFiles(collectKtFiles(new File("compiler/testData/lazyResolve/namespaceComparatorWithJavaMerge"))),
                 convertToJetFiles(collectKtFiles(STD_LIB_SRC)),
                 Predicates.<NamespaceDescriptor>alwaysTrue()
-                //new Predicate<NamespaceDescriptor>() {
-                //    @Override
-                //    public boolean apply(NamespaceDescriptor descriptor) {
-                //        return Name.identifier("jet").equals(descriptor.getName());
-                //    }
-                //},
-                //new File("compiler/testData/lazyResolve/namespaceComparatorWithJavaMerge/stdlib-log.txt")
         );
     }
 
     private List<JetFile> convertToJetFiles(List<File> files) throws IOException {
         List<JetFile> jetFiles = Lists.newArrayList();
         for (File file : files) {
-            JetFile jetFile = JetPsiFactory.createFile(getProject(), file.getName(), FileUtil.loadFile(file, true));
+            JetFile jetFile = JetPsiFactory.createFile(stdlibEnvironment.getProject(), file.getName(), FileUtil.loadFile(file, true));
             jetFiles.add(jetFile);
         }
         return jetFiles;
     }
 
-    private List<File> collectKtFiles(@NotNull File root) {
+    private static List<File> collectKtFiles(@NotNull File root) {
         List<File> files = Lists.newArrayList();
         FileUtil.collectMatchedFiles(root, Pattern.compile(".*?.kt"), files);
         return files;

compiler/tests/org/jetbrains/jet/lang/resolve/lazy/LazyResolveTestUtil.java

@@ -21,7 +21,6 @@ import com.google.common.base.Predicates;
 import com.intellij.openapi.project.Project;
 import com.intellij.psi.PsiFile;
 import org.jetbrains.annotations.NotNull;
-import org.jetbrains.jet.KotlinTestWithDefaultEnvironment;
 import org.jetbrains.jet.cli.jvm.compiler.JetCoreEnvironment;
 import org.jetbrains.jet.di.InjectorForJavaDescriptorResolver;
 import org.jetbrains.jet.di.InjectorForTopDownAnalyzer;
@@ -50,32 +49,31 @@ import java.util.List;
 /**
  * @author abreslav
  */
-public abstract class AbstractLazyResolveTest extends KotlinTestWithDefaultEnvironment {
-
-    protected InjectorForTopDownAnalyzer getEagerInjectorForTopDownAnalyzer(JetCoreEnvironment environment) {
+public class LazyResolveTestUtil {
+    public static InjectorForTopDownAnalyzer getEagerInjectorForTopDownAnalyzer(JetCoreEnvironment environment) {
         ModuleDescriptor eagerModuleForLazy = new ModuleDescriptor(Name.special("<eager module for lazy>"));
 
         InjectorForTopDownAnalyzer tdaInjectorForLazy = createInjectorForTDA(eagerModuleForLazy, environment);
         // This line is required fro the 'jet' namespace to be filled in with functions
         tdaInjectorForLazy.getTopDownAnalyzer().analyzeFiles(
-                Collections.singletonList(JetPsiFactory.createFile(getProject(), "")), Collections.<AnalyzerScriptParameter>emptyList());
+                Collections.singletonList(JetPsiFactory.createFile(environment.getProject(), "")), Collections.<AnalyzerScriptParameter>emptyList());
         return tdaInjectorForLazy;
     }
 
-    protected InjectorForTopDownAnalyzer createInjectorForTDA(ModuleDescriptor module, JetCoreEnvironment environment) {
+    public static InjectorForTopDownAnalyzer createInjectorForTDA(ModuleDescriptor module, JetCoreEnvironment environment) {
         TopDownAnalysisParameters params = new TopDownAnalysisParameters(
                 Predicates.<PsiFile>alwaysTrue(), false, false, Collections.<AnalyzerScriptParameter>emptyList());
         return new InjectorForTopDownAnalyzerForJvm(environment.getProject(), params, new BindingTraceContext(), module, BuiltinsScopeExtensionMode.ALL);
     }
 
-    protected ModuleDescriptor resolveEagerly(List<JetFile> files, JetCoreEnvironment environment) {
+    public static ModuleDescriptor resolveEagerly(List<JetFile> files, JetCoreEnvironment environment) {
         ModuleDescriptor module = new ModuleDescriptor(Name.special("<test module>"));
         InjectorForTopDownAnalyzer injector = createInjectorForTDA(module, environment);
         injector.getTopDownAnalyzer().analyzeFiles(files, Collections.<AnalyzerScriptParameter>emptyList());
         return module;
     }
 
-    protected ModuleDescriptor resolveLazily(List<JetFile> files, JetCoreEnvironment environment) {
+    public static ModuleDescriptor resolveLazily(List<JetFile> files, JetCoreEnvironment environment) {
         ModuleDescriptor javaModule = new ModuleDescriptor(Name.special("<lazy module>"));
 
         final Project project = environment.getProject();
@@ -124,5 +122,4 @@ public abstract class AbstractLazyResolveTest extends KotlinTestWithDefaultEnvir
                 session = new ResolveSession(project, lazyModule, moduleConfiguration, declarationProviderFactory);
         return lazyModule;
     }
-
 }

js/js.tests/test/org/jetbrains/k2js/test/BasicTest.java

@@ -20,6 +20,9 @@ import com.google.common.collect.Lists;
 import com.intellij.openapi.util.io.FileUtil;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.jet.JetTestUtils;
+import org.jetbrains.jet.cli.jvm.compiler.JetCoreEnvironment;
+import org.jetbrains.jet.config.CompilerConfiguration;
+import org.jetbrains.jet.lang.resolve.lazy.KotlinTestWithEnvironment;
 import org.jetbrains.k2js.config.EcmaVersion;
 import org.jetbrains.k2js.facade.MainCallParameters;
 import org.jetbrains.k2js.test.config.TestConfig;
@@ -38,7 +41,7 @@ import static org.jetbrains.k2js.test.utils.JsTestUtils.convertFileNameToDotJsFi
 /**
  * @author Pavel Talanov
  */
-public abstract class BasicTest extends TestWithEnvironment {
+public abstract class BasicTest extends KotlinTestWithEnvironment {
 
     private static final boolean DELETE_OUT = false;
     private static final String TEST_FILES = "js/js.translator/testFiles/";
@@ -56,6 +59,11 @@ public abstract class BasicTest extends TestWithEnvironment {
         this.mainDirectory = main;
     }
 
+    @Override
+    protected JetCoreEnvironment createEnvironment() {
+        return JetCoreEnvironment.createCoreEnvironmentForJVM(getTestRootDisposable(), new CompilerConfiguration());
+    }
+
     @NotNull
     public String getMainDirectory() {
         return mainDirectory;