JetLiteFixture migrated to use KotlinTestWithEnvironment

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

@@ -17,18 +17,15 @@
 package org.jetbrains.jet;
 
 import com.intellij.openapi.fileEditor.impl.LoadTextUtil;
-import com.intellij.openapi.project.Project;
 import com.intellij.psi.PsiElement;
 import com.intellij.psi.PsiElementVisitor;
 import com.intellij.psi.PsiFile;
 import com.intellij.testFramework.LightVirtualFile;
 import com.intellij.testFramework.TestDataFile;
-import com.intellij.testFramework.UsefulTestCase;
 import org.jetbrains.annotations.NonNls;
-import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
-import org.jetbrains.jet.cli.jvm.compiler.JetCoreEnvironment;
 import org.jetbrains.jet.lang.psi.JetFile;
+import org.jetbrains.jet.lang.resolve.lazy.KotlinTestWithEnvironment;
 import org.junit.Assert;
 
 import java.io.IOException;
@@ -36,11 +33,11 @@ import java.io.IOException;
 /**
  * @author abreslav
  */
-public abstract class JetLiteFixture extends UsefulTestCase {
+public abstract class JetLiteFixture extends KotlinTestWithEnvironment {
     @NonNls
     protected final String myFullDataPath;
-    protected JetFile myFile;
+    private JetFile myFile;
-    protected JetCoreEnvironment myEnvironment;
+
 
     public JetLiteFixture(@NonNls String dataPath) {
         myFullDataPath = getTestDataPath() + "/" + dataPath;
@@ -50,12 +47,12 @@ public abstract class JetLiteFixture extends UsefulTestCase {
         myFullDataPath = getTestDataPath();
     }
 
-    protected String getTestDataPath() {
+    protected JetFile getFile() {
-        return JetTestCaseBuilder.getTestDataPathBase();
+        return myFile;
     }
 
-    public Project getProject() {
+    protected String getTestDataPath() {
-        return myEnvironment.getProject();
+        return JetTestCaseBuilder.getTestDataPathBase();
     }
 
     @Override
@@ -63,31 +60,9 @@ public abstract class JetLiteFixture extends UsefulTestCase {
         super.setUp();
     }
 
-    protected void createEnvironmentWithMockJdkAndIdeaAnnotations() {
-        if (myEnvironment != null) {
-            throw new IllegalStateException("must not set up myEnvironment twice");
-        }
-        myEnvironment = JetTestUtils.createEnvironmentWithMockJdkAndIdeaAnnotations(getTestRootDisposable());
-    }
-
-    protected void createEnvironmentWithMockJdkAndIdeaAnnotations(@NotNull ConfigurationKind configurationKind) {
-        if (myEnvironment != null) {
-            throw new IllegalStateException("must not set up myEnvironment twice");
-        }
-        myEnvironment = JetTestUtils.createEnvironmentWithMockJdkAndIdeaAnnotations(getTestRootDisposable(), configurationKind);
-    }
-
-    protected void createEnvironmentWithFullJdk() {
-        if (myEnvironment != null) {
-            throw new IllegalStateException("must not set up myEnvironment twice");
-        }
-        myEnvironment = JetTestUtils.createEnvironmentWithFullJdk(getTestRootDisposable());
-    }
-
     @Override
     protected void tearDown() throws Exception {
         myFile = null;
-        myEnvironment = null;
         super.tearDown();
     }
 
@@ -100,7 +75,7 @@ public abstract class JetLiteFixture extends UsefulTestCase {
             Assert.assertNotNull(testName);
             fileName = testName + ".jet";
         }
-        return (JetFile) JetTestUtils.createFile(fileName, text, myEnvironment.getProject());
+        return (JetFile) JetTestUtils.createFile(fileName, text, getProject());
     }
 
     protected JetFile loadPsiFile(String name) {

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

@@ -33,8 +33,11 @@ public abstract class KotlinTestWithEnvironmentManagement extends UsefulTestCase
     }
 
     protected JetCoreEnvironment createEnvironmentWithJdk(@NotNull ConfigurationKind configurationKind, boolean mockJdk) {
-        return new JetCoreEnvironment(getTestRootDisposable(),
+        JetCoreEnvironment environment = new JetCoreEnvironment(getTestRootDisposable(),
-                                    CompileCompilerDependenciesTest.compilerConfigurationForTests(configurationKind, mockJdk)
+                                                                CompileCompilerDependenciesTest
-                            );
+                                                                        .compilerConfigurationForTests(configurationKind, mockJdk)
+        );
+        environment.addToClasspath(JetTestUtils.getAnnotationsJar());
+        return environment;
     }
 }

compiler/tests/org/jetbrains/jet/cfg/JetControlFlowTest.java

@@ -30,6 +30,7 @@ import org.jetbrains.jet.JetLiteFixture;
 import org.jetbrains.jet.JetTestCaseBuilder;
 import org.jetbrains.jet.JetTestUtils;
 import org.jetbrains.jet.analyzer.AnalyzeExhaust;
+import org.jetbrains.jet.cli.jvm.compiler.JetCoreEnvironment;
 import org.jetbrains.jet.lang.BuiltinsScopeExtensionMode;
 import org.jetbrains.jet.lang.cfg.pseudocode.*;
 import org.jetbrains.jet.lang.psi.*;
@@ -55,9 +56,8 @@ public class JetControlFlowTest extends JetLiteFixture {
 
 
     @Override
-    protected void setUp() throws Exception {
+    protected JetCoreEnvironment createEnvironment() {
-        super.setUp();
+        return createEnvironmentWithMockJdk(ConfigurationKind.JDK_ONLY);
-        createEnvironmentWithMockJdkAndIdeaAnnotations(ConfigurationKind.JDK_ONLY);
     }
 
     @Override

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

@@ -29,6 +29,7 @@ import org.jetbrains.annotations.NotNull;
 import org.jetbrains.jet.ConfigurationKind;
 import org.jetbrains.jet.JetLiteFixture;
 import org.jetbrains.jet.JetTestUtils;
+import org.jetbrains.jet.cli.jvm.compiler.JetCoreEnvironment;
 import org.jetbrains.jet.lang.BuiltinsScopeExtensionMode;
 import org.jetbrains.jet.lang.diagnostics.DiagnosticUtils;
 import org.jetbrains.jet.lang.psi.JetFile;
@@ -53,9 +54,8 @@ import java.util.List;
 public abstract class AbstractJetDiagnosticsTest extends JetLiteFixture {
 
     @Override
-    protected void setUp() throws Exception {
+    protected JetCoreEnvironment createEnvironment() {
-        super.setUp();
+        return createEnvironmentWithMockJdk(ConfigurationKind.JDK_AND_ANNOTATIONS);
-        createEnvironmentWithMockJdkAndIdeaAnnotations(ConfigurationKind.JDK_AND_ANNOTATIONS);
     }
 
     private boolean writeJavaFile(@NotNull String fileName, @NotNull String content, @NotNull File javaFilesDir) {
@@ -90,7 +90,7 @@ public abstract class AbstractJetDiagnosticsTest extends JetLiteFixture {
         if (hasJavaFiles.get()) {
             // According to yole@ the only way to import java files is to write them on disk
             // -- stepan.koltsov@ 2012-02-29
-            myEnvironment.addToClasspath(javaFilesDir);
+            getEnvironment().addToClasspath(javaFilesDir);
         }
 
         List<JetFile> jetFiles = Lists.newArrayList();

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

@@ -19,7 +19,9 @@ package org.jetbrains.jet.checkers;
 import com.google.common.collect.Lists;
 import com.intellij.psi.PsiFile;
 import org.jetbrains.annotations.NotNull;
+import org.jetbrains.jet.ConfigurationKind;
 import org.jetbrains.jet.JetLiteFixture;
+import org.jetbrains.jet.cli.jvm.compiler.JetCoreEnvironment;
 import org.jetbrains.jet.lang.BuiltinsScopeExtensionMode;
 import org.jetbrains.jet.lang.diagnostics.Diagnostic;
 import org.jetbrains.jet.lang.psi.JetFile;
@@ -40,15 +42,14 @@ public class CheckerTestUtilTest extends JetLiteFixture {
     }
 
     @Override
-    protected void setUp() throws Exception {
+    protected JetCoreEnvironment createEnvironment() {
-        super.setUp();
+        return createEnvironmentWithMockJdk(ConfigurationKind.ALL);
-        createEnvironmentWithMockJdkAndIdeaAnnotations();
     }
 
 
     protected void doTest(TheTest theTest) throws Exception {
         prepareForTest("test");
-        theTest.test(myFile);
+        theTest.test(getFile());
     }
 
     public void testEquals() throws Exception {

compiler/tests/org/jetbrains/jet/resolve/DescriptorRendererTest.java

@@ -23,6 +23,7 @@ import org.jetbrains.jet.JetLiteFixture;
 import org.jetbrains.jet.JetTestCaseBuilder;
 import org.jetbrains.jet.JetTestUtils;
 import org.jetbrains.jet.analyzer.AnalyzeExhaust;
+import org.jetbrains.jet.cli.jvm.compiler.JetCoreEnvironment;
 import org.jetbrains.jet.lang.BuiltinsScopeExtensionMode;
 import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor;
 import org.jetbrains.jet.lang.psi.JetElement;
@@ -44,12 +45,10 @@ import java.util.List;
 public class DescriptorRendererTest extends JetLiteFixture {
 
     @Override
-    protected void setUp() throws Exception {
+    protected JetCoreEnvironment createEnvironment() {
-        super.setUp();
+        return createEnvironmentWithMockJdk(ConfigurationKind.JDK_ONLY);
-        createEnvironmentWithMockJdkAndIdeaAnnotations(ConfigurationKind.JDK_ONLY);
     }
 
-
     public void testGlobalProperties() throws IOException {
         doTest();
     }

compiler/tests/org/jetbrains/jet/resolve/ExtensibleResolveTestCase.java

@@ -20,6 +20,7 @@ import org.jetbrains.annotations.NonNls;
 import org.jetbrains.jet.ConfigurationKind;
 import org.jetbrains.jet.JetLiteFixture;
 import org.jetbrains.jet.JetTestUtils;
+import org.jetbrains.jet.cli.jvm.compiler.JetCoreEnvironment;
 import org.jetbrains.jet.lang.psi.JetFile;
 
 import java.util.List;
@@ -30,12 +31,14 @@ import java.util.List;
 public abstract class ExtensibleResolveTestCase extends JetLiteFixture {
     private ExpectedResolveData expectedResolveData;
 
+    @Override
+    protected JetCoreEnvironment createEnvironment() {
+        return createEnvironmentWithMockJdk(ConfigurationKind.JDK_AND_ANNOTATIONS);
+    }
+
     @Override
     protected void setUp() throws Exception {
         super.setUp();
-
-        createEnvironmentWithMockJdkAndIdeaAnnotations(ConfigurationKind.JDK_AND_ANNOTATIONS);
-
         expectedResolveData = getExpectedResolveData();
     }
 

compiler/tests/org/jetbrains/jet/resolve/JetResolveTest.java

@@ -102,7 +102,7 @@ public class JetResolveTest extends ExtensibleResolveTestCase {
         nameToDeclaration.put("java::java.lang.Number", java_lang_Number);
         nameToDeclaration.put("java::java.lang.Number.intValue()", java_lang_Number.findMethodsByName("intValue", true)[0]);
 
-        return new ExpectedResolveData(nameToDescriptor, nameToDeclaration, myEnvironment) {
+        return new ExpectedResolveData(nameToDescriptor, nameToDeclaration, getEnvironment()) {
             @Override
             protected JetFile createJetFile(String fileName, String text) {
                 return createCheckAndReturnPsiFile(fileName, null, text);

compiler/tests/org/jetbrains/jet/types/JetDefaultModalityModifiersTest.java

@@ -16,9 +16,11 @@
 
 package org.jetbrains.jet.types;
 
+import org.jetbrains.jet.ConfigurationKind;
 import org.jetbrains.jet.JetLiteFixture;
 import org.jetbrains.jet.JetTestUtils;
 import org.jetbrains.jet.analyzer.AnalyzeExhaust;
+import org.jetbrains.jet.cli.jvm.compiler.JetCoreEnvironment;
 import org.jetbrains.jet.di.InjectorForTests;
 import org.jetbrains.jet.lang.BuiltinsScopeExtensionMode;
 import org.jetbrains.jet.lang.descriptors.*;
@@ -43,10 +45,14 @@ import java.util.List;
 public class JetDefaultModalityModifiersTest extends JetLiteFixture {
     private JetDefaultModalityModifiersTestCase tc = new JetDefaultModalityModifiersTestCase();
 
+    @Override
+    protected JetCoreEnvironment createEnvironment() {
+        return createEnvironmentWithMockJdk(ConfigurationKind.ALL);
+    }
+
     @Override
     public void setUp() throws Exception {
         super.setUp();
-        super.createEnvironmentWithMockJdkAndIdeaAnnotations();
         tc.setUp();
     }
 

compiler/tests/org/jetbrains/jet/types/JetOverloadTest.java

@@ -16,9 +16,11 @@
 
 package org.jetbrains.jet.types;
 
+import org.jetbrains.jet.ConfigurationKind;
 import org.jetbrains.jet.JetLiteFixture;
 import org.jetbrains.jet.JetTestCaseBuilder;
 import org.jetbrains.jet.JetTestUtils;
+import org.jetbrains.jet.cli.jvm.compiler.JetCoreEnvironment;
 import org.jetbrains.jet.di.InjectorForTests;
 import org.jetbrains.jet.lang.descriptors.FunctionDescriptor;
 import org.jetbrains.jet.lang.descriptors.ModuleDescriptor;
@@ -38,10 +40,14 @@ public class JetOverloadTest extends JetLiteFixture {
     private JetStandardLibrary library;
     private DescriptorResolver descriptorResolver;
 
+    @Override
+    protected JetCoreEnvironment createEnvironment() {
+        return createEnvironmentWithMockJdk(ConfigurationKind.ALL);
+    }
+
     @Override
     public void setUp() throws Exception {
         super.setUp();
-        createEnvironmentWithMockJdkAndIdeaAnnotations();
         InjectorForTests injector = new InjectorForTests(getProject());
         library = injector.getJetStandardLibrary();
         descriptorResolver = injector.getDescriptorResolver();

compiler/tests/org/jetbrains/jet/types/JetOverridingTest.java

@@ -16,9 +16,11 @@
 
 package org.jetbrains.jet.types;
 
+import org.jetbrains.jet.ConfigurationKind;
 import org.jetbrains.jet.JetLiteFixture;
 import org.jetbrains.jet.JetTestCaseBuilder;
 import org.jetbrains.jet.JetTestUtils;
+import org.jetbrains.jet.cli.jvm.compiler.JetCoreEnvironment;
 import org.jetbrains.jet.di.InjectorForTests;
 import org.jetbrains.jet.lang.descriptors.FunctionDescriptor;
 import org.jetbrains.jet.lang.descriptors.ModuleDescriptor;
@@ -38,10 +40,14 @@ public class JetOverridingTest extends JetLiteFixture {
     private JetStandardLibrary library;
     private DescriptorResolver descriptorResolver;
 
+    @Override
+    protected JetCoreEnvironment createEnvironment() {
+        return createEnvironmentWithMockJdk(ConfigurationKind.ALL);
+    }
+
     @Override
     public void setUp() throws Exception {
         super.setUp();
-        createEnvironmentWithMockJdkAndIdeaAnnotations();
         InjectorForTests injector = new InjectorForTests(getProject());
         library = injector.getJetStandardLibrary();
         descriptorResolver = injector.getDescriptorResolver();

compiler/tests/org/jetbrains/jet/types/JetTypeCheckerTest.java

@@ -20,9 +20,11 @@ import com.google.common.collect.Sets;
 import com.intellij.openapi.project.Project;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
+import org.jetbrains.jet.ConfigurationKind;
 import org.jetbrains.jet.JetLiteFixture;
 import org.jetbrains.jet.JetTestCaseBuilder;
 import org.jetbrains.jet.JetTestUtils;
+import org.jetbrains.jet.cli.jvm.compiler.JetCoreEnvironment;
 import org.jetbrains.jet.di.InjectorForJavaSemanticServices;
 import org.jetbrains.jet.di.InjectorForTests;
 import org.jetbrains.jet.lang.BuiltinsScopeExtensionMode;
@@ -66,12 +68,15 @@ public class JetTypeCheckerTest extends JetLiteFixture {
         super("");
     }
 
+    @Override
+    protected JetCoreEnvironment createEnvironment() {
+        return createEnvironmentWithMockJdk(ConfigurationKind.ALL);
+    }
+
     @Override
     public void setUp() throws Exception {
         super.setUp();
 
-        super.createEnvironmentWithMockJdkAndIdeaAnnotations();
-
         library          = JetStandardLibrary.getInstance();
         classDefinitions = new ClassDefinitions();