More accurate environment management in tests

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

@@ -46,13 +46,13 @@ public class AbstractLazyResolveDescriptorRendererTest extends AbstractLazyResol
 
     protected void doTest(@NotNull String testFile) throws IOException {
 
-        InjectorForTopDownAnalyzer injectorForTopDownAnalyzer = getEagerInjectorForTopDownAnalyzer();
+        InjectorForTopDownAnalyzer injectorForTopDownAnalyzer = getEagerInjectorForTopDownAnalyzer(regularEnvironment);
 
-        JetFile psiFile = JetPsiFactory.createFile(project, FileUtil.loadFile(new File(testFile), true));
+        JetFile psiFile = JetPsiFactory.createFile(getProject(), FileUtil.loadFile(new File(testFile), true));
         Collection<JetFile> files = Lists.newArrayList(psiFile);
 
         ModuleDescriptor lazyModule = new ModuleDescriptor(Name.special("<lazy module>"));
-        final ResolveSession resolveSession = new ResolveSession(project, lazyModule, injectorForTopDownAnalyzer.getModuleConfiguration(),
+        final ResolveSession resolveSession = new ResolveSession(getProject(), lazyModule, injectorForTopDownAnalyzer.getModuleConfiguration(),
                                                     new FileBasedDeclarationProviderFactory(files));
 
         final List<DeclarationDescriptor> descriptors = new ArrayList<DeclarationDescriptor>();

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

@@ -20,9 +20,11 @@ import com.google.common.base.Predicate;
 import com.intellij.openapi.util.Pair;
 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.di.InjectorForTopDownAnalyzer;
 import org.jetbrains.jet.jvm.compiler.NamespaceComparator;
+import org.jetbrains.jet.lang.ModuleConfiguration;
 import org.jetbrains.jet.lang.descriptors.ModuleDescriptor;
 import org.jetbrains.jet.lang.descriptors.NamespaceDescriptor;
 import org.jetbrains.jet.lang.psi.JetFile;
@@ -48,7 +50,7 @@ public abstract class AbstractLazyResolveNamespaceComparingTest extends Abstract
                 .createTestFiles(testFileName, FileUtil.loadFile(new File(testFileName), true), new JetTestUtils.TestFileFactory<JetFile>() {
                     @Override
                     public JetFile create(String fileName, String text) {
-                        return JetPsiFactory.createFile(project, fileName, text);
+                        return JetPsiFactory.createFile(getProject(), fileName, text);
                     }
                 });
 
@@ -64,21 +66,15 @@ public abstract class AbstractLazyResolveNamespaceComparingTest extends Abstract
         doTestForGivenFiles(transform, includeMembersOfObject, files, filterJetNamespace, serializeResultsTo);
     }
 
-    protected void doTestForGivenFiles(Function<Pair<ModuleDescriptor, ModuleDescriptor>, Pair<NamespaceDescriptor, NamespaceDescriptor>> transform,
+    protected void doTestForGivenFiles(
+            Function<Pair<ModuleDescriptor, ModuleDescriptor>, Pair<NamespaceDescriptor, NamespaceDescriptor>> transform,
             boolean includeMembersOfObject,
             List<JetFile> files,
             Predicate<NamespaceDescriptor> filterJetNamespace,
-            File serializeResultsTo) {
+            File serializeResultsTo
-        ModuleDescriptor module = new ModuleDescriptor(Name.special("<test module>"));
+    ) {
-        InjectorForTopDownAnalyzer injector = createInjectorForTDA(module);
+        ModuleDescriptor module = resolveEagerly(files, ConfigurationKind.JDK_ONLY);
-
+        ModuleDescriptor lazyModule = resolveLazily(files, ConfigurationKind.JDK_ONLY);
-        InjectorForTopDownAnalyzer tdaInjectorForLazy = getEagerInjectorForTopDownAnalyzer();
-
-        ModuleDescriptor lazyModule = new ModuleDescriptor(Name.special("<lazy module>"));
-        ResolveSession
-                session = new ResolveSession(project, lazyModule, tdaInjectorForLazy.getModuleConfiguration(), new FileBasedDeclarationProviderFactory(files));
-
-        injector.getTopDownAnalyzer().analyzeFiles(files, Collections.<AnalyzerScriptParameter>emptyList());
 
         Pair<NamespaceDescriptor, NamespaceDescriptor> namespacesToCompare = transform.fun(Pair.create(module, lazyModule));
 
@@ -86,6 +82,23 @@ public abstract class AbstractLazyResolveNamespaceComparingTest extends Abstract
                                               includeMembersOfObject, filterJetNamespace, serializeResultsTo);
     }
 
+    private ModuleDescriptor resolveLazily(List<JetFile> files, ConfigurationKind configurationKind) {
+        ModuleDescriptor lazyModule = new ModuleDescriptor(Name.special("<lazy module>"));
+        JetCoreEnvironmentWithDisposable environment = new JetCoreEnvironmentWithDisposable(configurationKind);
+        ModuleConfiguration moduleConfiguration = getEagerInjectorForTopDownAnalyzer(environment).getModuleConfiguration();
+        ResolveSession
+                session = new ResolveSession(getProject(), lazyModule, moduleConfiguration, new FileBasedDeclarationProviderFactory(files));
+        return lazyModule;
+    }
+
+    protected ModuleDescriptor resolveEagerly(List<JetFile> files, ConfigurationKind configurationKind) {
+        ModuleDescriptor module = new ModuleDescriptor(Name.special("<test module>"));
+        JetCoreEnvironmentWithDisposable environment = new JetCoreEnvironmentWithDisposable(configurationKind);
+        InjectorForTopDownAnalyzer injector = createInjectorForTDA(module, environment);
+        injector.getTopDownAnalyzer().analyzeFiles(files, Collections.<AnalyzerScriptParameter>emptyList());
+        return module;
+    }
+
     protected void doTest(String testFileName) throws Exception {
         doTest(testFileName, new Function<Pair<ModuleDescriptor, ModuleDescriptor>, Pair<NamespaceDescriptor, NamespaceDescriptor>>() {
             @Override
@@ -105,8 +118,11 @@ public abstract class AbstractLazyResolveNamespaceComparingTest extends Abstract
             public Pair<NamespaceDescriptor, NamespaceDescriptor> fun(Pair<ModuleDescriptor, ModuleDescriptor> pair) {
                 ModuleDescriptor expectedModule = pair.first;
                 ModuleDescriptor actualModule = pair.second;
-                NamespaceDescriptor actual = theOnlySubPackage(actualModule.getRootNamespace());
+                Name test = Name.identifier("test");
-                NamespaceDescriptor expected = expectedModule.getRootNamespace().getMemberScope().getNamespace(actual.getName());
+                NamespaceDescriptor actual = actualModule.getRootNamespace().getMemberScope().getNamespace(test);
+                NamespaceDescriptor expected = expectedModule.getRootNamespace().getMemberScope().getNamespace(test);
+                //NamespaceDescriptor actual = theOnlySubPackage(actualModule.getRootNamespace());
+                //NamespaceDescriptor expected = expectedModule.getRootNamespace().getMemberScope().getNamespace(actual.getName());
                 return Pair.create(expected, actual);
             }
         }, includeMembersOfObject);

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

@@ -21,8 +21,9 @@ import com.intellij.openapi.Disposable;
 import com.intellij.openapi.project.Project;
 import com.intellij.openapi.util.Disposer;
 import com.intellij.psi.PsiFile;
-import org.jetbrains.jet.CompileCompilerDependenciesTest;
+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.di.InjectorForTopDownAnalyzerForJvm;
@@ -42,16 +43,30 @@ import java.util.Collections;
  * @author abreslav
  */
 public abstract class AbstractLazyResolveTest {
+
     private final Disposable rootDisposable = new Disposable() {
         @Override
         public void dispose() {
         }
     };
 
-    protected final JetCoreEnvironment jetCoreEnvironment = new JetCoreEnvironment(rootDisposable,
+    public class JetCoreEnvironmentWithDisposable {
-            CompileCompilerDependenciesTest.compilerConfigurationForTests(ConfigurationKind.JDK_ONLY, true)
+
-    );
+        public final JetCoreEnvironment jetCoreEnvironment;
-    protected final Project project = jetCoreEnvironment.getProject();
+        public final Project project;
+
+        public JetCoreEnvironmentWithDisposable(@NotNull ConfigurationKind configurationKind) {
+            this.jetCoreEnvironment = JetTestUtils.createEnvironmentWithMockJdkAndIdeaAnnotations(rootDisposable, configurationKind);
+            this.project = jetCoreEnvironment.getProject();
+        }
+
+    }
+
+    protected final JetCoreEnvironmentWithDisposable regularEnvironment = new JetCoreEnvironmentWithDisposable(ConfigurationKind.ALL);
+
+    protected Project getProject() {
+        return regularEnvironment.project;
+    }
 
     @BeforeClass
     public static void setUp() throws Exception {
@@ -63,20 +78,20 @@ public abstract class AbstractLazyResolveTest {
         Disposer.dispose(rootDisposable);
     }
 
-    protected InjectorForTopDownAnalyzer getEagerInjectorForTopDownAnalyzer() {
+    protected InjectorForTopDownAnalyzer getEagerInjectorForTopDownAnalyzer(JetCoreEnvironmentWithDisposable environment) {
         ModuleDescriptor eagerModuleForLazy = new ModuleDescriptor(Name.special("<eager module for lazy>"));
 
-        InjectorForTopDownAnalyzer tdaInjectorForLazy = createInjectorForTDA(eagerModuleForLazy);
+        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(project, "")), Collections.<AnalyzerScriptParameter>emptyList());
+                Collections.singletonList(JetPsiFactory.createFile(getProject(), "")), Collections.<AnalyzerScriptParameter>emptyList());
         return tdaInjectorForLazy;
     }
 
-    protected InjectorForTopDownAnalyzer createInjectorForTDA(ModuleDescriptor module) {
+    protected InjectorForTopDownAnalyzer createInjectorForTDA(ModuleDescriptor module, JetCoreEnvironmentWithDisposable environment) {
         TopDownAnalysisParameters params = new TopDownAnalysisParameters(
                 Predicates.<PsiFile>alwaysTrue(), false, false, Collections.<AnalyzerScriptParameter>emptyList());
-        return new InjectorForTopDownAnalyzerForJvm(project, params, new BindingTraceContext(), module, BuiltinsScopeExtensionMode.ALL);
+        return new InjectorForTopDownAnalyzerForJvm(environment.project, params, new BindingTraceContext(), module, BuiltinsScopeExtensionMode.ALL);
     }
 
 }

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

@@ -62,7 +62,7 @@ public class LazyResolveBuiltinClassesTest extends AbstractLazyResolveTest {
 
         ModuleDescriptor lazyModule = new ModuleDescriptor(Name.special("<lazy module>"));
         ResolveSession session = new ResolveSession(
-                project,
+                getProject(),
                 lazyModule,
                 new SpecialModuleConfiguration(),
                 new FileBasedDeclarationProviderFactory(files),
@@ -88,7 +88,7 @@ public class LazyResolveBuiltinClassesTest extends AbstractLazyResolveTest {
     private void addJetFilesFromDir(List<JetFile> files, File jetDir) throws IOException {
         for (File file : jetDir.listFiles()) {
             if (FileUtil.getExtension(file.getName()).equals("jet")) {
-                files.add(JetPsiFactory.createFile(project, file.getName(), FileUtil.loadFile(file, true)));
+                files.add(JetPsiFactory.createFile(getProject(), file.getName(), FileUtil.loadFile(file, true)));
             }
         }
     }
@@ -97,7 +97,7 @@ public class LazyResolveBuiltinClassesTest extends AbstractLazyResolveTest {
         @Override
         public void addDefaultImports(@NotNull Collection<JetImportDirective> directives) {
             for (ImportPath defaultJetImport : DefaultModuleConfiguration.DEFAULT_JET_IMPORTS) {
-                directives.add(JetPsiFactory.createImportDirective(project, defaultJetImport));
+                directives.add(JetPsiFactory.createImportDirective(getProject(), defaultJetImport));
             }
         }
 

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

@@ -34,7 +34,7 @@ import java.util.Set;
 public class LazyResolveDescriptorRendererTestGenerated {
     public static class Renderer extends AbstractLazyResolveDescriptorRendererTest {
         @Test
-        public void allTestsPresentInRenderer() throws Exception {
+        public void testAllFilesPresentInRenderer() throws Exception {
             allTestsPresent(Renderer.class, new File("compiler/testData/renderer"), true);
         }
         
@@ -103,7 +103,7 @@ public class LazyResolveDescriptorRendererTestGenerated {
     
     public static class DescriptorRenderer extends AbstractLazyResolveDescriptorRendererTest {
         @Test
-        public void allTestsPresentInDescriptorRenderer() throws Exception {
+        public void testAllFilesPresentInDescriptorRenderer() throws Exception {
             allTestsPresent(DescriptorRenderer.class, new File("compiler/testData/lazyResolve/descriptorRenderer"), true);
         }
         

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

@@ -30,12 +30,12 @@ import java.util.Set;
 @Suite.SuiteClasses({
     LazyResolveNamespaceComparingTestGenerated.ReadKotlinBinaryClass.class,    
     LazyResolveNamespaceComparingTestGenerated.ReadJavaBinaryClass.class,    
-    LazyResolveNamespaceComparingTestGenerated.LazyResolve.class    
+    LazyResolveNamespaceComparingTestGenerated.NamespaceComparator.class    
 })
 public class LazyResolveNamespaceComparingTestGenerated {
     public static class ReadKotlinBinaryClass extends AbstractLazyResolveNamespaceComparingTest {
         @Test
-        public void allTestsPresentInReadKotlinBinaryClass() throws Exception {
+        public void testAllFilesPresentInReadKotlinBinaryClass() throws Exception {
             allTestsPresent(ReadKotlinBinaryClass.class, new File("compiler/testData/readKotlinBinaryClass"), true);
         }
         
@@ -769,7 +769,7 @@ public class LazyResolveNamespaceComparingTestGenerated {
     
     public static class ReadJavaBinaryClass extends AbstractLazyResolveNamespaceComparingTest {
         @Test
-        public void allTestsPresentInReadJavaBinaryClass() throws Exception {
+        public void testAllFilesPresentInReadJavaBinaryClass() throws Exception {
             allTestsPresent(ReadJavaBinaryClass.class, new File("compiler/testData/readJavaBinaryClass"), true);
         }
         
@@ -1048,6 +1048,11 @@ public class LazyResolveNamespaceComparingTestGenerated {
             doTestSinglePackage("compiler/testData/readJavaBinaryClass/MethosWithPRefTP.kt");
         }
         
+        @Test
+        public void testModalityOfFakeOverrides() throws Exception {
+            doTestSinglePackage("compiler/testData/readJavaBinaryClass/modality/ModalityOfFakeOverrides.kt");
+        }
+        
         @Test
         public void testMyException() throws Exception {
             doTestSinglePackage("compiler/testData/readJavaBinaryClass/MyException.kt");
@@ -1111,15 +1116,10 @@ public class LazyResolveNamespaceComparingTestGenerated {
         }
     }
     
-    public static class LazyResolve extends AbstractLazyResolveNamespaceComparingTest {
+    public static class NamespaceComparator extends AbstractLazyResolveNamespaceComparingTest {
         @Test
-        public void allTestsPresentInLazyResolve() throws Exception {
+        public void testAllFilesPresentInNamespaceComparator() throws Exception {
-            allTestsPresent(LazyResolve.class, new File("compiler/testData/lazyResolve"), true);
+            allTestsPresent(NamespaceComparator.class, new File("compiler/testData/lazyResolve/namespaceComparator"), true);
-        }
-        
-        @Test
-        public void testClassObject() throws Exception {
-            doTest("compiler/testData/lazyResolve/descriptorRenderer/ClassObject.kt");
         }
         
         @Test

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

@@ -75,7 +75,7 @@ public class LazyResolveTestGenerator {
                                        true,
                                        TestGenerator.filterFilesByExtension(TEST_DATA_FILE_EXTENSION),
                                        "doTestSinglePackage"),
-                    new TestDataSource(new File("compiler/testData/lazyResolve"),
+                    new TestDataSource(new File("compiler/testData/lazyResolve/namespaceComparator"),
                                        true,
                                        TestGenerator.filterFilesByExtension(TEST_DATA_FILE_EXTENSION),
                                        "doTest")