b3783e 'JetLiteFixture uses CoreEnvironment...' reverted

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

 package org.jetbrains.jet;
 
-import com.intellij.core.CoreEnvironment;
-import com.intellij.lang.Language;
+import com.intellij.ide.startup.impl.StartupManagerImpl;
+import com.intellij.lang.*;
+import com.intellij.lang.impl.PsiBuilderFactoryImpl;
+import com.intellij.mock.*;
+import com.intellij.openapi.Disposable;
+import com.intellij.openapi.editor.Document;
+import com.intellij.openapi.editor.EditorFactory;
+import com.intellij.openapi.fileEditor.FileDocumentManager;
+import com.intellij.openapi.fileEditor.impl.FileDocumentManagerImpl;
 import com.intellij.openapi.fileEditor.impl.LoadTextUtil;
+import com.intellij.openapi.fileTypes.FileTypeFactory;
+import com.intellij.openapi.fileTypes.FileTypeManager;
+import com.intellij.openapi.options.SchemesManagerFactory;
+import com.intellij.openapi.progress.impl.ProgressManagerImpl;
+import com.intellij.openapi.startup.StartupManager;
+import com.intellij.openapi.util.Disposer;
 import com.intellij.openapi.util.io.FileUtil;
 import com.intellij.openapi.util.text.StringUtil;
 import com.intellij.openapi.vfs.CharsetToolkit;
-import com.intellij.psi.PsiElement;
-import com.intellij.psi.PsiElementVisitor;
-import com.intellij.psi.PsiFile;
-import com.intellij.psi.PsiFileFactory;
+import com.intellij.psi.*;
+import com.intellij.psi.impl.PsiCachedValuesFactory;
 import com.intellij.psi.impl.PsiFileFactoryImpl;
+import com.intellij.psi.impl.source.resolve.reference.ReferenceProvidersRegistry;
+import com.intellij.psi.impl.source.resolve.reference.ReferenceProvidersRegistryImpl;
+import com.intellij.psi.util.CachedValuesManager;
 import com.intellij.testFramework.LightVirtualFile;
+import com.intellij.testFramework.MockSchemesManagerFactory;
+import com.intellij.testFramework.PlatformLiteFixture;
 import com.intellij.testFramework.TestDataFile;
-import com.intellij.testFramework.UsefulTestCase;
+import com.intellij.util.CachedValuesManagerImpl;
+import com.intellij.util.Function;
+import com.intellij.util.messages.MessageBus;
+import com.intellij.util.messages.MessageBusFactory;
 import org.jetbrains.annotations.NonNls;
 import org.jetbrains.jet.lang.parsing.JetParserDefinition;
-import org.jetbrains.jet.plugin.JetFileType;
-import org.jetbrains.jet.plugin.JetLanguage;
+import org.picocontainer.MutablePicoContainer;
+import org.picocontainer.PicoContainer;
+import org.picocontainer.PicoInitializationException;
+import org.picocontainer.PicoIntrospectionException;
+import org.picocontainer.defaults.AbstractComponentAdapter;
 
 import java.io.File;
 import java.io.IOException;
@@ -25,17 +47,20 @@ import java.io.IOException;
 /**
  * @author abreslav
  */
-public abstract class JetLiteFixture extends UsefulTestCase {
+public abstract class JetLiteFixture extends PlatformLiteFixture {
     protected String myFileExt;
     @NonNls
     protected final String myFullDataPath;
     protected PsiFile myFile;
+    private MockPsiManager myPsiManager;
+    private PsiFileFactoryImpl myFileFactory;
     protected Language myLanguage;
-    private CoreEnvironment myEnvironment;
+    protected final ParserDefinition[] myDefinitions;
 
     public JetLiteFixture(@NonNls String dataPath) {
         myFileExt = "jet";
         myFullDataPath = getTestDataPath() + "/" + dataPath;
+        myDefinitions = new ParserDefinition[] {new JetParserDefinition()};
     }
 
     protected String getTestDataPath() {
@@ -45,17 +70,57 @@ public abstract class JetLiteFixture extends UsefulTestCase {
     @Override
     protected void setUp() throws Exception {
         super.setUp();
-        myEnvironment = new CoreEnvironment(getTestRootDisposable());
-        myEnvironment.registerFileType(JetFileType.INSTANCE, ".jet");
-        myLanguage = JetLanguage.INSTANCE;
-        myEnvironment.registerParserDefinition(new JetParserDefinition());
+        initApplication();
+        getApplication().getPicoContainer().registerComponent(new AbstractComponentAdapter("com.intellij.openapi.progress.ProgressManager", Object.class) {
+            @Override
+            public Object getComponentInstance(PicoContainer container) throws PicoInitializationException, PicoIntrospectionException {
+                return new ProgressManagerImpl(getApplication());
+            }
+
+            @Override
+            public void verify(PicoContainer container) throws PicoIntrospectionException {
+            }
+        });
+        myProject = disposeOnTearDown(new MockProjectEx(getTestRootDisposable()));
+        myPsiManager = new MockPsiManager(myProject);
+        myFileFactory = new PsiFileFactoryImpl(myPsiManager);
+        final MutablePicoContainer appContainer = getApplication().getPicoContainer();
+        registerComponentInstance(appContainer, MessageBus.class, MessageBusFactory.newMessageBus(getApplication()));
+        registerComponentInstance(appContainer, SchemesManagerFactory.class, new MockSchemesManagerFactory());
+        final MockEditorFactory editorFactory = new MockEditorFactory();
+        registerComponentInstance(appContainer, EditorFactory.class, editorFactory);
+        registerComponentInstance(appContainer, FileDocumentManager.class, new MockFileDocumentManagerImpl(new Function<CharSequence, Document>() {
+            @Override
+            public Document fun(CharSequence charSequence) {
+                return editorFactory.createDocument(charSequence);
+            }
+        }, FileDocumentManagerImpl.DOCUMENT_KEY));
+        registerComponentInstance(appContainer, PsiDocumentManager.class, new MockPsiDocumentManager());
+        myLanguage = myLanguage == null && myDefinitions != null && myDefinitions.length > 0
+                     ? myDefinitions[0].getFileNodeType().getLanguage()
+                     : myLanguage;
+        registerComponentInstance(appContainer, FileTypeManager.class, new MockFileTypeManager(new MockLanguageFileType(myLanguage, myFileExt)));
+        registerApplicationService(PsiBuilderFactory.class, new PsiBuilderFactoryImpl());
+        registerApplicationService(DefaultASTFactory.class, new DefaultASTFactoryImpl());
+        registerApplicationService(ReferenceProvidersRegistry.class, new ReferenceProvidersRegistryImpl());
+        myProject.registerService(CachedValuesManager.class, new CachedValuesManagerImpl(myProject, new PsiCachedValuesFactory(myPsiManager)));
+        myProject.registerService(PsiManager.class, myPsiManager);
+        myProject.registerService(StartupManager.class, new StartupManagerImpl(myProject));
+        myProject.registerService(PsiFileFactory.class, new PsiFileFactoryImpl(myPsiManager));
+
+        registerExtensionPoint(FileTypeFactory.FILE_TYPE_FACTORY_EP, FileTypeFactory.class);
+
+        for (ParserDefinition definition : myDefinitions) {
+            addExplicitExtension(LanguageParserDefinitions.INSTANCE, definition.getFileNodeType().getLanguage(), definition);
+        }
     }
 
     @Override
     protected void tearDown() throws Exception {
-        myFile = null;
-        myEnvironment = null;
         super.tearDown();
+        myFile = null;
+        myProject = null;
+        myPsiManager = null;
     }
 
     protected String loadFile(@NonNls @TestDataFile String name) throws IOException {
@@ -76,8 +141,7 @@ public abstract class JetLiteFixture extends UsefulTestCase {
     protected PsiFile createFile(@NonNls String name, String text) {
         LightVirtualFile virtualFile = new LightVirtualFile(name, myLanguage, text);
         virtualFile.setCharset(CharsetToolkit.UTF8_CHARSET);
-        PsiFileFactoryImpl psiFileFactory = (PsiFileFactoryImpl) PsiFileFactory.getInstance(myEnvironment.getProject());
-        return psiFileFactory.trySetupPsiForFile(virtualFile, myLanguage, true, false);
+        return myFileFactory.trySetupPsiForFile(virtualFile, myLanguage, true, false);
     }
 
     protected static void ensureParsed(PsiFile file) {
@@ -89,6 +153,26 @@ public abstract class JetLiteFixture extends UsefulTestCase {
         });
     }
 
+    protected <T> void registerApplicationService(final Class<T> aClass, T object) {
+        getApplication().registerService(aClass, object);
+        Disposer.register(myProject, new Disposable() {
+            @Override
+            public void dispose() {
+                getApplication().getPicoContainer().unregisterComponent(aClass.getName());
+            }
+        });
+    }
+
+    protected <T> void addExplicitExtension(final LanguageExtension<T> instance, final Language language, final T object) {
+        instance.addExplicitExtension(language, object);
+        Disposer.register(myProject, new Disposable() {
+            @Override
+            public void dispose() {
+                instance.removeExplicitExtension(language, object);
+            }
+        });
+    }
+
     protected void prepareForTest(String name) throws IOException {
         String text = loadFile(name + "." + myFileExt);
         createAndCheckPsiFile(name, text);