12a52ff7399c9fd98bebe1705c6ee05bb0e67262
[idea/community.git] / platform / testFramework / src / com / intellij / testFramework / fixtures / impl / CodeInsightTestFixtureImpl.java
1 /*
2  * Copyright 2000-2009 JetBrains s.r.o.
3  *
4  * Licensed under the Apache License, Version 2.0 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at
7  *
8  * http://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  */
16
17 package com.intellij.testFramework.fixtures.impl;
18
19 import com.intellij.analysis.AnalysisScope;
20 import com.intellij.codeHighlighting.HighlightDisplayLevel;
21 import com.intellij.codeHighlighting.TextEditorHighlightingPass;
22 import com.intellij.codeInsight.CodeInsightActionHandler;
23 import com.intellij.codeInsight.TargetElementUtilBase;
24 import com.intellij.codeInsight.completion.CodeCompletionHandlerBase;
25 import com.intellij.codeInsight.completion.CompletionContext;
26 import com.intellij.codeInsight.completion.CompletionProgressIndicator;
27 import com.intellij.codeInsight.completion.CompletionType;
28 import com.intellij.codeInsight.daemon.DaemonCodeAnalyzer;
29 import com.intellij.codeInsight.daemon.DaemonCodeAnalyzerSettings;
30 import com.intellij.codeInsight.daemon.HighlightDisplayKey;
31 import com.intellij.codeInsight.daemon.impl.*;
32 import com.intellij.codeInsight.intention.IntentionAction;
33 import com.intellij.codeInsight.intention.impl.ShowIntentionActionsHandler;
34 import com.intellij.codeInsight.lookup.LookupElement;
35 import com.intellij.codeInsight.lookup.LookupManager;
36 import com.intellij.codeInsight.lookup.impl.LookupImpl;
37 import com.intellij.codeInspection.*;
38 import com.intellij.codeInspection.ex.*;
39 import com.intellij.facet.Facet;
40 import com.intellij.facet.FacetManager;
41 import com.intellij.find.FindManager;
42 import com.intellij.find.findUsages.FindUsagesHandler;
43 import com.intellij.find.findUsages.FindUsagesOptions;
44 import com.intellij.find.impl.FindManagerImpl;
45 import com.intellij.ide.DataManager;
46 import com.intellij.lang.annotation.HighlightSeverity;
47 import com.intellij.openapi.Disposable;
48 import com.intellij.openapi.actionSystem.DataContext;
49 import com.intellij.openapi.actionSystem.IdeActions;
50 import com.intellij.openapi.application.ApplicationManager;
51 import com.intellij.openapi.application.ModalityState;
52 import com.intellij.openapi.application.Result;
53 import com.intellij.openapi.command.WriteCommandAction;
54 import com.intellij.openapi.editor.Document;
55 import com.intellij.openapi.editor.Editor;
56 import com.intellij.openapi.editor.EditorFactory;
57 import com.intellij.openapi.editor.RangeMarker;
58 import com.intellij.openapi.editor.actionSystem.EditorActionManager;
59 import com.intellij.openapi.editor.ex.DocumentEx;
60 import com.intellij.openapi.editor.ex.util.EditorUtil;
61 import com.intellij.openapi.editor.markup.GutterIconRenderer;
62 import com.intellij.openapi.editor.markup.RangeHighlighter;
63 import com.intellij.openapi.extensions.ExtensionPoint;
64 import com.intellij.openapi.extensions.ExtensionPointName;
65 import com.intellij.openapi.extensions.ExtensionsArea;
66 import com.intellij.openapi.fileEditor.FileEditorManager;
67 import com.intellij.openapi.fileEditor.OpenFileDescriptor;
68 import com.intellij.openapi.fileEditor.impl.text.TextEditorProvider;
69 import com.intellij.openapi.fileTypes.FileType;
70 import com.intellij.openapi.fileTypes.FileTypeManager;
71 import com.intellij.openapi.module.Module;
72 import com.intellij.openapi.progress.ProgressIndicator;
73 import com.intellij.openapi.progress.ProgressManager;
74 import com.intellij.openapi.project.DumbServiceImpl;
75 import com.intellij.openapi.project.Project;
76 import com.intellij.openapi.util.*;
77 import com.intellij.openapi.util.io.FileUtil;
78 import com.intellij.openapi.util.text.StringUtil;
79 import com.intellij.openapi.vfs.LocalFileSystem;
80 import com.intellij.openapi.vfs.VfsUtil;
81 import com.intellij.openapi.vfs.VirtualFile;
82 import com.intellij.openapi.vfs.VirtualFileFilter;
83 import com.intellij.profile.codeInspection.InspectionProfileManager;
84 import com.intellij.profile.codeInspection.InspectionProjectProfileManager;
85 import com.intellij.psi.*;
86 import com.intellij.psi.impl.PsiManagerImpl;
87 import com.intellij.psi.impl.cache.impl.todo.TodoIndex;
88 import com.intellij.psi.impl.source.PostprocessReformattingAspect;
89 import com.intellij.psi.impl.source.PsiFileImpl;
90 import com.intellij.psi.impl.source.resolve.FileContextUtil;
91 import com.intellij.psi.impl.source.tree.injected.InjectedLanguageUtil;
92 import com.intellij.psi.search.GlobalSearchScope;
93 import com.intellij.psi.search.UsageSearchContext;
94 import com.intellij.psi.stubs.StubUpdatingIndex;
95 import com.intellij.psi.util.PsiUtilBase;
96 import com.intellij.refactoring.move.moveFilesOrDirectories.MoveFilesOrDirectoriesProcessor;
97 import com.intellij.refactoring.rename.RenameProcessor;
98 import com.intellij.refactoring.rename.RenamePsiElementProcessor;
99 import com.intellij.testFramework.*;
100 import com.intellij.testFramework.fixtures.*;
101 import com.intellij.usageView.UsageInfo;
102 import com.intellij.util.ArrayUtil;
103 import com.intellij.util.CommonProcessors;
104 import com.intellij.util.Function;
105 import com.intellij.util.SmartList;
106 import com.intellij.util.containers.ContainerUtil;
107 import com.intellij.util.indexing.FileBasedIndex;
108 import gnu.trove.THashMap;
109 import junit.framework.Assert;
110 import org.jetbrains.annotations.NonNls;
111 import org.jetbrains.annotations.NotNull;
112 import org.jetbrains.annotations.Nullable;
113
114 import javax.swing.*;
115 import java.io.File;
116 import java.io.IOException;
117 import java.io.OutputStream;
118 import java.util.*;
119
120 /**
121  * @author Dmitry Avdeev
122  */
123 @SuppressWarnings({"TestMethodWithIncorrectSignature"})
124 public class CodeInsightTestFixtureImpl extends BaseFixture implements CodeInsightTestFixture {
125
126   @NonNls private static final String PROFILE = "Configurable";
127
128   private PsiManagerImpl myPsiManager;
129   private PsiFile myFile;
130   private Editor myEditor;
131   private String myTestDataPath;
132   private boolean myEmptyLookup;
133
134   private InspectionProfileEntry[] myInspections;
135   private final Map<String, InspectionProfileEntry> myAvailableTools = new THashMap<String, InspectionProfileEntry>();
136   private final Map<String, InspectionTool> myAvailableLocalTools = new THashMap<String, InspectionTool>();
137
138   private final TempDirTestFixture myTempDirFixture;
139   protected final IdeaProjectTestFixture myProjectFixture;
140   @NonNls private static final String XXX = "XXX";
141   private PsiElement myFileContext;
142   private final FileTreeAccessFilter myJavaFilesFilter = new FileTreeAccessFilter();
143
144   public CodeInsightTestFixtureImpl(IdeaProjectTestFixture projectFixture, TempDirTestFixture tempDirTestFixture) {
145     myProjectFixture = projectFixture;
146     myTempDirFixture = tempDirTestFixture;
147   }
148
149   public void setTestDataPath(String dataPath) {
150     myTestDataPath = dataPath;
151   }
152
153   public String getTempDirPath() {
154     return myTempDirFixture.getTempDirPath();
155   }
156
157   public TempDirTestFixture getTempDirFixture() {
158     return myTempDirFixture;
159   }
160
161   public VirtualFile copyFileToProject(@NonNls final String sourceFilePath, @NonNls final String targetPath) throws IOException {
162     File fromFile = new File(getTestDataPath() + "/" + sourceFilePath);
163     if (!fromFile.exists()) {
164       fromFile = new File(sourceFilePath);
165     }
166
167     if (myTempDirFixture instanceof LightTempDirTestFixtureImpl) {
168       VirtualFile fromVFile = LocalFileSystem.getInstance().refreshAndFindFileByIoFile(fromFile);
169       if (fromVFile == null) {
170         fromVFile = myTempDirFixture.getFile(sourceFilePath);
171       }
172       assert fromVFile != null: "can't find testdata file " + sourceFilePath;
173       return myTempDirFixture.copyFile(fromVFile, targetPath);
174     }
175     final File destFile = new File(getTempDirPath() + "/" + targetPath);
176     if (!destFile.exists()) {
177
178       if (fromFile.isDirectory()) {
179         destFile.mkdirs();
180       }
181       else {
182         FileUtil.copy(fromFile, destFile);
183       }
184     }
185     final VirtualFile file = LocalFileSystem.getInstance().refreshAndFindFileByIoFile(destFile);
186     Assert.assertNotNull(file);
187     return file;
188   }
189
190   public VirtualFile copyDirectoryToProject(@NonNls final String sourceFilePath, @NonNls final String targetPath) throws IOException {
191     assert getTestDataPath() != null: "test data path not specified";
192     final File fromFile = new File(getTestDataPath() + "/" + sourceFilePath);
193     if (myTempDirFixture instanceof LightTempDirTestFixtureImpl) {
194       return myTempDirFixture.copyAll(fromFile.getPath(), targetPath);
195     }
196     else {
197       final File destFile = new File(getTempDirPath() + "/" + targetPath);
198       FileUtil.copyDir(fromFile, destFile);
199       final VirtualFile file = LocalFileSystem.getInstance().refreshAndFindFileByIoFile(destFile);
200       Assert.assertNotNull(file);
201       file.refresh(false, true);
202       return file;
203     }
204   }
205
206   public VirtualFile copyFileToProject(@NonNls final String sourceFilePath) throws IOException {
207     return copyFileToProject(sourceFilePath, sourceFilePath);
208   }
209
210   public void enableInspections(InspectionProfileEntry... inspections) {
211     myInspections = inspections;
212     if (isInitialized()) {
213       configureInspections(myInspections);
214     }
215   }
216
217   private boolean isInitialized() {
218     return myPsiManager != null;
219   }
220
221   public void enableInspections(final Class<? extends LocalInspectionTool>... inspections) {
222     final ArrayList<LocalInspectionTool> tools = new ArrayList<LocalInspectionTool>();
223     for (Class clazz: inspections) {
224       try {
225         LocalInspectionTool inspection = (LocalInspectionTool)clazz.getConstructor().newInstance();
226         tools.add(inspection);
227       }
228       catch (Exception e) {
229         throw new RuntimeException("Cannot instantiate " + clazz);
230       }
231     }
232     enableInspections(tools.toArray(new LocalInspectionTool[tools.size()]));
233   }
234
235   public void disableInspections(InspectionProfileEntry... inspections) {
236     myAvailableTools.clear();
237     myAvailableLocalTools.clear();
238     final ArrayList<InspectionProfileEntry> tools = new ArrayList<InspectionProfileEntry>(Arrays.asList(myInspections));
239     for (Iterator<InspectionProfileEntry> i = tools.iterator(); i.hasNext();) {
240       final InspectionProfileEntry tool = i.next();
241       for (InspectionProfileEntry toRemove: inspections) {
242         if (tool.getShortName().equals(toRemove.getShortName())) {
243           i.remove();
244           break;
245         }
246       }
247     }
248     myInspections = tools.toArray(new InspectionProfileEntry[tools.size()]);
249     configureInspections(myInspections);
250   }
251
252   public void enableInspections(InspectionToolProvider... providers) {
253     final ArrayList<LocalInspectionTool> tools = new ArrayList<LocalInspectionTool>();
254     for (InspectionToolProvider provider: providers) {
255       for (Class clazz: provider.getInspectionClasses()) {
256         try {
257           LocalInspectionTool inspection = (LocalInspectionTool)clazz.getConstructor().newInstance();
258           tools.add(inspection);
259         }
260         catch (Exception e) {
261           throw new RuntimeException("Cannot instantiate " + clazz);
262         }
263       }
264     }
265     myInspections = tools.toArray(new LocalInspectionTool[tools.size()]);
266     configureInspections(myInspections);
267   }
268
269   public long testHighlighting(final boolean checkWarnings,
270                                final boolean checkInfos,
271                                final boolean checkWeakWarnings,
272                                final String... filePaths) throws Exception {
273     final Ref<Long> duration = new Ref<Long>();
274     new WriteCommandAction.Simple(myProjectFixture.getProject()) {
275
276       protected void run() throws Exception {
277         if (filePaths.length > 0) {
278           configureByFilesInner(filePaths);
279         }
280         collectAndCheckHighlightings(checkWarnings, checkInfos, checkWeakWarnings, duration);
281       }
282     }.execute().throwException();
283     return duration.get().longValue();
284   }
285
286   public long testHighlightingAllFiles(final boolean checkWarnings,
287                                        final boolean checkInfos,
288                                        final boolean checkWeakWarnings,
289                                        @NonNls final String... filePaths) throws Exception {
290     final ArrayList<VirtualFile> files = new ArrayList<VirtualFile>();
291     for (String path : filePaths) {
292       files.add(copyFileToProject(path));
293     }
294     return testHighlightingAllFiles(checkWarnings, checkInfos, checkWeakWarnings, VfsUtil.toVirtualFileArray(files));
295   }
296
297   public long testHighlightingAllFiles(final boolean checkWarnings,
298                                final boolean checkInfos,
299                                final boolean checkWeakWarnings,
300                                @NonNls final VirtualFile... files) throws Exception {
301     final Ref<Long> duration = new Ref<Long>();
302     new WriteCommandAction.Simple(myProjectFixture.getProject()) {
303
304       protected void run() throws Exception {
305         collectAndCheckHighlightings(checkWarnings, checkInfos, checkWeakWarnings, duration, files);
306       }
307     }.execute().throwException();
308     return duration.get().longValue();
309   }
310
311   private void collectAndCheckHighlightings(final boolean checkWarnings, final boolean checkInfos, final boolean checkWeakWarnings, final Ref<Long> duration,
312                                             final VirtualFile[] files) {
313     final List<Trinity<PsiFile, Editor, ExpectedHighlightingData>> datas = ContainerUtil.map2List(files, new Function<VirtualFile, Trinity<PsiFile, Editor, ExpectedHighlightingData>>() {
314       public Trinity<PsiFile, Editor, ExpectedHighlightingData> fun(final VirtualFile file) {
315         final PsiFile psiFile = myPsiManager.findFile(file);
316         assertNotNull(psiFile);
317         final Document document = PsiDocumentManager.getInstance(getProject()).getDocument(psiFile);
318         assertNotNull(document);
319         return Trinity.create(psiFile, createEditor(file), new ExpectedHighlightingData(document, checkWarnings, checkWeakWarnings, checkInfos, psiFile));
320       }
321     });
322     for (Trinity<PsiFile, Editor, ExpectedHighlightingData> trinity : datas) {
323       myEditor = trinity.second;
324       myFile = trinity.first;
325       collectAndCheckHighlightings(trinity.third, duration);
326     }
327   }
328
329   public long checkHighlighting(final boolean checkWarnings, final boolean checkInfos, final boolean checkWeakWarnings) throws Exception {
330     final Ref<Long> duration = new Ref<Long>();
331     new WriteCommandAction.Simple(myProjectFixture.getProject()) {
332       protected void run() throws Exception {
333         collectAndCheckHighlightings(checkWarnings, checkInfos, checkWeakWarnings, duration);
334       }
335     }.execute().throwException();
336     return duration.get().longValue();
337   }
338
339   public long checkHighlighting() throws Exception {
340     return checkHighlighting(true, true, true);
341   }
342
343   public long testHighlighting(final String... filePaths) throws Exception {
344     return testHighlighting(true, true, true, filePaths);
345   }
346
347   public long testHighlighting(final boolean checkWarnings, final boolean checkInfos, final boolean checkWeakWarnings, final VirtualFile file) throws Exception {
348     final Ref<Long> duration = new Ref<Long>();
349     new WriteCommandAction.Simple(myProjectFixture.getProject()) {
350       protected void run() throws Exception {
351         openFileInEditor(file);
352         collectAndCheckHighlightings(checkWarnings, checkInfos, checkWeakWarnings, duration);
353       }
354     }.execute().throwException();
355     return duration.get().longValue();
356   }
357
358   public void openFileInEditor(@NotNull final VirtualFile file) {
359     myFile = myPsiManager.findFile(file);
360     myEditor = createEditor(file);
361   }
362
363   public void testInspection(String testDir, InspectionTool tool) throws Exception {
364     VirtualFile sourceDir = copyDirectoryToProject(new File(testDir, "src").getPath(), "src");
365     AnalysisScope scope = new AnalysisScope(getPsiManager().findDirectory(sourceDir));
366
367     InspectionManagerEx inspectionManager = (InspectionManagerEx) InspectionManager.getInstance(getProject());
368     final GlobalInspectionContextImpl globalContext = inspectionManager.createNewGlobalContext(!(myProjectFixture instanceof LightIdeaTestFixture));
369     globalContext.setCurrentScope(scope);
370     scope.invalidate();
371
372     InspectionTestUtil.runTool(tool, scope, globalContext, inspectionManager);
373     InspectionTestUtil.compareToolResults(tool, false, new File(getTestDataPath(), testDir).getPath());
374   }
375
376   @Nullable
377   public PsiReference getReferenceAtCaretPosition(final String... filePaths) throws Exception {
378     new WriteCommandAction<PsiReference>(myProjectFixture.getProject()) {
379       protected void run(final Result<PsiReference> result) throws Exception {
380         configureByFilesInner(filePaths);
381       }
382     }.execute().throwException();
383     return getFile().findReferenceAt(myEditor.getCaretModel().getOffset());
384   }
385
386   @NotNull
387   public PsiReference getReferenceAtCaretPositionWithAssertion(final String... filePaths) throws Exception {
388     final PsiReference reference = getReferenceAtCaretPosition(filePaths);
389     assert reference != null: "no reference found at " + myEditor.getCaretModel().getLogicalPosition();
390     return reference;
391   }
392
393   @NotNull
394   public List<IntentionAction> getAvailableIntentions(final String... filePaths) throws Exception {
395
396     return new WriteCommandAction<List<IntentionAction>>(myProjectFixture.getProject()) {
397       protected void run(final Result<List<IntentionAction>> result) throws Exception {
398         configureByFilesInner(filePaths);
399         result.setResult(getAvailableIntentions());
400       }
401     }.execute().getResultObject();
402   }
403
404   @NotNull
405   public List<IntentionAction> getAllQuickFixes(@NonNls final String... filePaths) {
406     return new WriteCommandAction<List<IntentionAction>>(myProjectFixture.getProject()) {
407       protected void run(final Result<List<IntentionAction>> result) throws Exception {
408         configureByFilesInner(filePaths);
409         List<HighlightInfo> infos = doHighlighting();
410         ArrayList<IntentionAction> actions = new ArrayList<IntentionAction>();
411         for (HighlightInfo info : infos) {
412           for (Pair<HighlightInfo.IntentionActionDescriptor, TextRange> pair : info.quickFixActionRanges) {
413             actions.add(pair.getFirst().getAction());
414           }
415         }
416         result.setResult(actions);
417       }
418     }.execute().getResultObject();
419   }
420
421   @NotNull
422   public List<IntentionAction> getAvailableIntentions() {
423     doHighlighting();
424     return getAvailableIntentions(myEditor, myFile);
425   }
426
427   public List<IntentionAction> filterAvailableIntentions(@NotNull final String hint) throws Exception {
428     final List<IntentionAction> availableIntentions = getAvailableIntentions();
429     return ContainerUtil.findAll(availableIntentions, new Condition<IntentionAction>() {
430       public boolean value(final IntentionAction intentionAction) {
431         return intentionAction.getText().startsWith(hint);
432       }
433     });
434   }
435
436   public IntentionAction findSingleIntention(@NotNull final String hint) throws Exception {
437     final List<IntentionAction> list = filterAvailableIntentions(hint);
438     if (list.size() != 1) {
439       Assert.fail(StringUtil.join(getAvailableIntentions(), new Function<IntentionAction, String>() {
440         public String fun(final IntentionAction intentionAction) {
441           return intentionAction.getText();
442         }
443       }, ", "));
444     }
445     return UsefulTestCase.assertOneElement(list);
446   }
447
448   public IntentionAction getAvailableIntention(final String intentionName, final String... filePaths) throws Exception {
449     List<IntentionAction> intentions = getAvailableIntentions(filePaths);
450     return CodeInsightTestUtil.findIntentionByText(intentions, intentionName);
451   }
452
453   public void launchAction(@NotNull final IntentionAction action) throws Exception {
454     new WriteCommandAction(myProjectFixture.getProject()) {
455       protected void run(final Result result) throws Exception {
456         ShowIntentionActionsHandler.chooseActionAndInvoke(getFile(), getEditor(), action, action.getText());
457       }
458     }.execute().throwException();
459
460   }
461
462   public void testCompletion(final String[] filesBefore, final String fileAfter) throws Exception {
463     assertInitialized();
464     configureByFiles(filesBefore);
465     final LookupElement[] items = complete(CompletionType.BASIC);
466     if (items != null) {
467       System.out.println("items = " + Arrays.toString(items));
468     }
469     checkResultByFile(fileAfter);
470   }
471
472   protected void assertInitialized() {
473     Assert.assertNotNull("setUp() hasn't been called", myPsiManager);
474   }
475
476   public void testCompletion(String fileBefore, String fileAfter, final String... additionalFiles) throws Exception {
477     testCompletion(ArrayUtil.reverseArray(ArrayUtil.append(additionalFiles, fileBefore)), fileAfter);
478   }
479
480   public void testCompletionVariants(final String fileBefore, final String... expectedItems) throws Exception {
481     assertInitialized();
482     final List<String> result = getCompletionVariants(fileBefore);
483     UsefulTestCase.assertSameElements(result, expectedItems);
484   }
485
486   public List<String> getCompletionVariants(final String... filesBefore) throws Exception {
487     assertInitialized();
488     configureByFiles(filesBefore);
489     final LookupElement[] items = complete(CompletionType.BASIC);
490     Assert.assertNotNull("No lookup was shown, probably there was only one lookup element that was inserted automatically", items);
491     return getLookupElementStrings();
492   }
493
494   @Nullable
495   public List<String> getLookupElementStrings() {
496     assertInitialized();
497     final LookupElement[] elements = getLookupElements();
498     if (elements == null) return null;
499
500     return ContainerUtil.map(elements, new Function<LookupElement, String>() {
501       public String fun(final LookupElement lookupItem) {
502         return lookupItem.getLookupString();
503       }
504     });
505   }
506
507   public void testRename(final String fileBefore, final String fileAfter, final String newName, final String... additionalFiles) throws Exception {
508     assertInitialized();
509     configureByFiles(ArrayUtil.reverseArray(ArrayUtil.append(additionalFiles, fileBefore)));
510     testRename(fileAfter, newName);
511   }
512
513   public void testRename(final String fileAfter, final String newName) throws Exception {
514     renameElementAtCaret(newName);
515     checkResultByFile(fileAfter);
516   }
517
518   public void renameElementAtCaret(final String newName) throws Exception {
519     assertInitialized();
520     final PsiElement element = TargetElementUtilBase.findTargetElement(getCompletionEditor(), TargetElementUtilBase.REFERENCED_ELEMENT_ACCEPTED |
521                                                                                         TargetElementUtilBase.ELEMENT_NAME_ACCEPTED);
522     assert element != null : "element not found in file " + myFile.getName() + " at caret position, offset " +
523                              myEditor.getCaretModel().getOffset();
524     renameElement(element, newName);
525   }
526
527   public void renameElement(final PsiElement element, final String newName) throws Exception {
528     final boolean searchInComments = false;
529     final boolean searchTextOccurrences = false;
530     renameElement(element, newName, searchInComments, searchTextOccurrences);
531   }
532
533   public void renameElement(final PsiElement element,
534                              final String newName,
535                              final boolean searchInComments,
536                              final boolean searchTextOccurrences) throws Exception {
537     new WriteCommandAction.Simple(myProjectFixture.getProject()) {
538       protected void run() throws Exception {
539         final PsiElement substitution = RenamePsiElementProcessor.forElement(element).substituteElementToRename(element, myEditor);
540         new RenameProcessor(myProjectFixture.getProject(), substitution, newName, searchInComments, searchTextOccurrences).run();
541      }
542     }.execute().throwException();
543   }
544
545   public void type(final char c) {
546     assertInitialized();
547     new WriteCommandAction(getProject()) {
548       protected void run(Result result) throws Exception {
549         EditorActionManager actionManager = EditorActionManager.getInstance();
550         final DataContext dataContext = DataManager.getInstance().getDataContext();
551         if (c == '\b') {
552           performEditorAction(IdeActions.ACTION_EDITOR_BACKSPACE);
553           return;
554         }
555         if (c == '\n') {
556           if (LookupManager.getActiveLookup(getEditor()) != null) {
557             performEditorAction(IdeActions.ACTION_CHOOSE_LOOKUP_ITEM);
558             return;
559           }
560
561           performEditorAction(IdeActions.ACTION_EDITOR_ENTER);
562           return;
563         }
564         if (c == '\t') {
565           if (LookupManager.getInstance(getProject()).getActiveLookup() != null) {
566             performEditorAction(IdeActions.ACTION_CHOOSE_LOOKUP_ITEM_REPLACE);
567             return;
568           }
569         }
570
571         actionManager.getTypedAction().actionPerformed(getEditor(), c, dataContext);
572       }
573     }.execute();
574   }
575
576   public void performEditorAction(final String actionId) {
577     assertInitialized();
578     final DataContext dataContext = DataManager.getInstance().getDataContext();
579     EditorActionManager actionManager = EditorActionManager.getInstance();
580     actionManager.getActionHandler(actionId).execute(getEditor(), dataContext);
581   }
582
583   public Collection<UsageInfo> testFindUsages(@NonNls final String... fileNames) throws Exception {
584     assertInitialized();
585     configureByFiles(fileNames);
586     final PsiElement targetElement = TargetElementUtilBase
587       .findTargetElement(getEditor(), TargetElementUtilBase.ELEMENT_NAME_ACCEPTED | TargetElementUtilBase.REFERENCED_ELEMENT_ACCEPTED);
588     assert targetElement != null : "Cannot find referenced element";
589     return findUsages(targetElement);
590   }
591
592   public Collection<UsageInfo> findUsages(@NotNull final PsiElement targetElement) {
593     final Project project = getProject();
594     final FindUsagesHandler handler = ((FindManagerImpl)FindManager.getInstance(project)).getFindUsagesManager().getFindUsagesHandler(targetElement, false);
595
596     final CommonProcessors.CollectProcessor<UsageInfo> processor = new CommonProcessors.CollectProcessor<UsageInfo>();
597     final FindUsagesOptions options = new FindUsagesOptions(project, null);
598     options.isUsages = true;
599     assert handler != null : "Cannot find handler for: " + targetElement;
600     final PsiElement[] psiElements = ArrayUtil.mergeArrays(handler.getPrimaryElements(), handler.getSecondaryElements(), PsiElement.class);
601     for (PsiElement psiElement : psiElements) {
602       handler.processElementUsages(psiElement, processor, options);
603     }
604     return processor.getResults();
605   }
606
607   public void moveFile(@NonNls final String filePath, @NonNls final String to, final String... additionalFiles) throws Exception {
608     assertInitialized();
609     final Project project = myProjectFixture.getProject();
610     new WriteCommandAction.Simple(project) {
611       protected void run() throws Exception {
612         configureByFiles(ArrayUtil.reverseArray(ArrayUtil.append(additionalFiles, filePath)));
613         final VirtualFile file = findFileInTempDir(to);
614         assert file.isDirectory() : to + " is not a directory";
615         final PsiDirectory directory = myPsiManager.findDirectory(file);
616         new MoveFilesOrDirectoriesProcessor(project, new PsiElement[] {myFile}, directory,
617                                             false, false, null, null).run();
618       }
619     }.execute().throwException();
620
621   }
622
623   @Nullable
624   public GutterIconRenderer findGutter(final String filePath) throws Exception {
625     assertInitialized();
626     final Project project = myProjectFixture.getProject();
627     final Ref<GutterIconRenderer> result = new Ref<GutterIconRenderer>();
628     new WriteCommandAction.Simple(project) {
629
630       protected void run() throws Exception {
631         final int offset = configureByFilesInner(filePath);
632
633         final Collection<HighlightInfo> infos = doHighlighting();
634         for (HighlightInfo info :infos) {
635           if (info.endOffset >= offset && info.startOffset <= offset) {
636             final GutterIconRenderer renderer = info.getGutterIconRenderer();
637             if (renderer != null) {
638               result.set(renderer);
639               return;
640             }
641           }
642         }
643
644       }
645     }.execute().throwException();
646     return result.get();
647   }
648
649   @NotNull
650   public Collection<GutterIconRenderer> findAllGutters(final String filePath) throws Exception {
651     assertInitialized();
652     final Project project = myProjectFixture.getProject();
653     final SortedMap<Integer, List<GutterIconRenderer>> result = new TreeMap<Integer, List<GutterIconRenderer>>();
654     new WriteCommandAction.Simple(project) {
655
656       protected void run() throws Exception {
657         configureByFilesInner(filePath);
658
659         for (HighlightInfo info : doHighlighting()) {
660           addGutterIconRenderer(info.getGutterIconRenderer(), info.startOffset);
661         }
662
663         for (final RangeHighlighter highlighter : myEditor.getDocument().getMarkupModel(project).getAllHighlighters()) {
664           addGutterIconRenderer(highlighter.getGutterIconRenderer(), highlighter.getStartOffset());
665         }
666       }
667
668       private void addGutterIconRenderer(final GutterIconRenderer renderer, final int offset) {
669         if (renderer == null) return;
670
671         List<GutterIconRenderer> renderers = result.get(offset);
672         if (renderers == null) {
673           result.put(offset, renderers = new SmartList<GutterIconRenderer>());
674         }
675         renderers.add(renderer);
676       }
677
678     }.execute().throwException();
679     return ContainerUtil.concat(result.values());
680   }
681
682
683   public PsiFile addFileToProject(@NonNls final String relativePath, @NonNls final String fileText) throws IOException {
684     assertInitialized();
685     return addFileToProject(getTempDirPath(), relativePath, fileText);
686   }
687
688   protected PsiFile addFileToProject(String rootPath, String relativePath, String fileText) throws IOException {
689     if (myTempDirFixture instanceof LightTempDirTestFixtureImpl) {
690       final VirtualFile file = myTempDirFixture.createFile(relativePath, fileText);
691       return PsiManager.getInstance(getProject()).findFile(file);
692     }
693
694     return ((HeavyIdeaTestFixture)myProjectFixture).addFileToProject(rootPath, relativePath, fileText);
695   }
696
697   public <T> void registerExtension(final ExtensionsArea area, final ExtensionPointName<T> epName, final T extension) {
698     assertInitialized();
699     final ExtensionPoint<T> extensionPoint = area.getExtensionPoint(epName);
700     extensionPoint.registerExtension(extension);
701     disposeOnTearDown(new Disposable() {
702       public void dispose() {
703         extensionPoint.unregisterExtension(extension);
704       }
705     });
706   }
707
708   public PsiManager getPsiManager() {
709     return myPsiManager;
710   }
711
712   public LookupElement[] complete(final CompletionType type) {
713     assertInitialized();
714     myEmptyLookup = false;
715     new WriteCommandAction(getProject()) {
716       protected void run(Result result) throws Exception {
717         final CodeInsightActionHandler handler = new CodeCompletionHandlerBase(type) {
718           protected PsiFile createFileCopy(final PsiFile file) {
719             final PsiFile copy = super.createFileCopy(file);
720             if (myFileContext != null) {
721               final PsiElement contextCopy = myFileContext.copy();
722               final PsiFile containingFile = contextCopy.getContainingFile();
723               if (containingFile instanceof PsiFileImpl) {
724                 ((PsiFileImpl)containingFile).setOriginalFile(myFileContext.getContainingFile());
725               }
726               setContext(copy, contextCopy);
727             }
728             return copy;
729           }
730
731           @Override
732           protected void completionFinished(final int offset1, final int offset2, final CompletionContext context, final CompletionProgressIndicator indicator,
733                                             final LookupElement[] items) {
734             myEmptyLookup = items.length == 0;
735             super.completionFinished(offset1, offset2, context, indicator, items);
736           }
737         };
738         Editor editor = getCompletionEditor();
739         handler.invoke(getProject(), editor, PsiUtilBase.getPsiFileInEditor(editor, getProject()));
740       }
741     }.execute();
742     return getLookupElements();
743   }
744
745   @Nullable
746   protected Editor getCompletionEditor() {
747     return InjectedLanguageUtil.getEditorForInjectedLanguageNoCommit(myEditor, myFile);
748   }
749
750   @Nullable
751   public LookupElement[] completeBasic() {
752     return complete(CompletionType.BASIC);
753   }
754
755   @Nullable
756   public LookupElement[] getLookupElements() {
757     LookupImpl lookup = (LookupImpl)LookupManager.getActiveLookup(myEditor);
758     if (lookup == null) {
759       return myEmptyLookup ? LookupElement.EMPTY_ARRAY : null;
760     }
761     else {
762       final List<LookupElement> list = lookup.getItems();
763       return list.toArray(new LookupElement[list.size()]);
764     }
765   }
766
767   public void checkResult(final String text) throws IOException {
768     checkResult(text, false);
769   }
770
771   public void checkResult(String text, boolean stripTrailingSpaces) throws IOException {
772     PsiDocumentManager.getInstance(getProject()).commitAllDocuments();
773     EditorUtil.fillVirtualSpaceUntilCaret(myEditor);
774     checkResult("TEXT", stripTrailingSpaces, SelectionAndCaretMarkupLoader.fromText(text, getProject()), myFile.getText());
775   }
776
777   public void checkResultByFile(final String expectedFile) throws Exception {
778     checkResultByFile(expectedFile, false);
779   }
780
781   public void checkResultByFile(final String expectedFile, final boolean ignoreTrailingWhitespaces) throws Exception {
782     assertInitialized();
783     new WriteCommandAction.Simple(myProjectFixture.getProject()) {
784
785       protected void run() throws Exception {
786         checkResultByFile(expectedFile, myFile, ignoreTrailingWhitespaces);
787       }
788     }.execute().throwException();
789   }
790
791   public void checkResultByFile(final String filePath, final String expectedFile, final boolean ignoreTrailingWhitespaces) throws Exception {
792     assertInitialized();
793
794     new WriteCommandAction.Simple(myProjectFixture.getProject()) {
795
796       protected void run() throws Exception {
797         final VirtualFile copy = findFileInTempDir(filePath.replace(File.separatorChar, '/'));
798         final PsiFile psiFile = myPsiManager.findFile(copy);
799         assert psiFile != null;
800         checkResultByFile(expectedFile, psiFile, ignoreTrailingWhitespaces);
801       }
802     }.execute().throwException();
803   }
804
805   public void setUp() throws Exception {
806     super.setUp();
807
808     myProjectFixture.setUp();
809     myTempDirFixture.setUp();
810     myPsiManager = (PsiManagerImpl)PsiManager.getInstance(getProject());
811     configureInspections(myInspections == null ? new LocalInspectionTool[0] : myInspections);
812     DaemonCodeAnalyzerSettings.getInstance().setImportHintEnabled(false);
813   }
814
815   private void enableInspectionTool(InspectionProfileEntry tool){
816     final String shortName = tool.getShortName();
817     final HighlightDisplayKey key = HighlightDisplayKey.find(shortName);
818     if (key == null){
819       String id = tool instanceof LocalInspectionTool ? ((LocalInspectionTool)tool).getID() : shortName;
820       HighlightDisplayKey.register(shortName, tool.getDisplayName(), id);
821     }
822     myAvailableTools.put(shortName, tool);
823     myAvailableLocalTools.put(shortName, tool instanceof LocalInspectionTool ?
824                                          new LocalInspectionToolWrapper((LocalInspectionTool)tool) :
825                                          (InspectionTool)tool);
826   }
827
828   private void configureInspections(final InspectionProfileEntry[] tools) {
829     for (InspectionProfileEntry tool : tools) {
830       enableInspectionTool(tool);
831     }
832
833     final InspectionProfileImpl profile = new InspectionProfileImpl(PROFILE) {
834       @NotNull
835       public ModifiableModel getModifiableModel() {
836         mySource = this;
837         return this;
838       }
839
840       @NotNull
841       public InspectionProfileEntry[] getInspectionTools(PsiElement element) {
842         final Collection<InspectionTool> tools = myAvailableLocalTools.values();
843         return tools.toArray(new InspectionTool[tools.size()]);
844       }
845
846       @Override
847       public List<ToolsImpl> getAllEnabledInspectionTools() {
848         List<ToolsImpl> result = new ArrayList<ToolsImpl>();
849         for (InspectionProfileEntry entry : getInspectionTools(null)) {
850           result.add(new ToolsImpl(entry, entry.getDefaultLevel(), true));
851         }
852         return result;
853       }
854
855       public boolean isToolEnabled(HighlightDisplayKey key, PsiElement element) {
856         return key != null && key.toString() != null && myAvailableTools.containsKey(key.toString());
857       }
858
859       public HighlightDisplayLevel getErrorLevel(@NotNull HighlightDisplayKey key, PsiElement element) {
860         final InspectionProfileEntry entry = myAvailableTools.get(key.toString());
861         return entry != null ? entry.getDefaultLevel() : HighlightDisplayLevel.WARNING;
862       }
863
864       public InspectionTool getInspectionTool(@NotNull String shortName, @NotNull PsiElement element) {
865         return myAvailableLocalTools.get(shortName);
866       }
867     };
868     final InspectionProfileManager inspectionProfileManager = InspectionProfileManager.getInstance();
869     inspectionProfileManager.addProfile(profile);
870     Disposer.register(getProject(), new Disposable() {
871       public void dispose() {
872         inspectionProfileManager.deleteProfile(PROFILE);
873       }
874     });
875     inspectionProfileManager.setRootProfile(profile.getName());
876     InspectionProjectProfileManager.getInstance(getProject()).updateProfile(profile);
877     InspectionProjectProfileManager.getInstance(getProject()).setProjectProfile(profile.getName());
878   }
879
880   public void tearDown() throws Exception {
881     if (SwingUtilities.isEventDispatchThread()) {
882       LookupManager.getInstance(getProject()).hideActiveLookup();
883     }
884     else {
885       ApplicationManager.getApplication().invokeAndWait(new Runnable() {
886         public void run() {
887           LookupManager.getInstance(getProject()).hideActiveLookup();
888         }
889       }, ModalityState.NON_MODAL);
890     }
891
892     FileEditorManager editorManager = FileEditorManager.getInstance(getProject());
893     VirtualFile[] openFiles = editorManager.getOpenFiles();
894     for (VirtualFile openFile : openFiles) {
895       editorManager.closeFile(openFile);
896     }
897
898     myProjectFixture.tearDown();
899     myTempDirFixture.tearDown();
900
901     super.tearDown();
902   }
903
904   private int configureByFilesInner(@NonNls String... filePaths) throws IOException {
905     assertInitialized();
906     myFile = null;
907     myEditor = null;
908     for (int i = filePaths.length - 1; i > 0; i--) {
909       configureByFileInner(filePaths[i]);
910     }
911     return configureByFileInner(filePaths[0]);
912   }
913
914   public void configureByFile(final String file) throws IOException {
915     assertInitialized();
916     new WriteCommandAction.Simple(getProject()) {
917       protected void run() throws Exception {
918         configureByFilesInner(file);
919       }
920     }.execute();
921   }
922
923   public void configureByFiles(@NonNls final String... files) throws Exception {
924     new WriteCommandAction.Simple(getProject()) {
925       protected void run() throws Exception {
926         configureByFilesInner(files);
927       }
928     }.execute();
929   }
930
931   public PsiFile configureByText(final FileType fileType, @NonNls final String text) throws IOException {
932     assertInitialized();
933     final String extension = fileType.getDefaultExtension();
934     final FileTypeManager fileTypeManager = FileTypeManager.getInstance();
935     if (fileTypeManager.getFileTypeByExtension(extension) != fileType) {
936       new WriteCommandAction(getProject()) {
937         protected void run(Result result) throws Exception {
938           fileTypeManager.associateExtension(fileType, extension);
939         }
940       }.execute();
941     }
942     final VirtualFile vFile;
943     if (myTempDirFixture instanceof LightTempDirTestFixtureImpl) {
944       final VirtualFile root = LightPlatformTestCase.getSourceRoot();
945       root.refresh(false, false);
946       vFile = root.findOrCreateChildData(this, "aaa." + extension);
947     }
948     else{
949       final File tempFile = File.createTempFile("aaa", "." + extension, new File(getTempDirPath()));
950       vFile = LocalFileSystem.getInstance().refreshAndFindFileByIoFile(tempFile);
951     }
952     VfsUtil.saveText(vFile, text);
953     configureInner(vFile, SelectionAndCaretMarkupLoader.fromFile(vFile, getProject()));
954     return myFile;
955   }
956
957   public PsiFile configureByText(String fileName, @NonNls String text) throws IOException {
958     return configureByText(FileTypeManager.getInstance().getFileTypeByFileName(fileName), text);
959   }
960
961   public Document getDocument(final PsiFile file) {
962     assertInitialized();
963     return PsiDocumentManager.getInstance(getProject()).getDocument(file);
964   }
965
966   public void setFileContext(@Nullable final PsiElement context) {
967     myFileContext = context;
968     setContext(myFile, context);
969   }
970
971   /**
972    *
973    * @param filePath
974    * @return caret offset or -1 if caret marker does not present
975    * @throws IOException
976    */
977   private int configureByFileInner(@NonNls String filePath) throws IOException {
978     assertInitialized();
979     final VirtualFile file = copyFileToProject(filePath);
980     return configureByFileInner(file);
981   }
982
983   public int configureFromTempProjectFile(final String filePath) throws IOException {
984     return configureByFileInner(findFileInTempDir(filePath));
985   }
986
987   public void configureFromExistingVirtualFile(VirtualFile f) throws IOException {
988     configureByFileInner(f);
989   }
990
991   private int configureByFileInner(final VirtualFile copy) throws IOException {
992     return configureInner(copy, SelectionAndCaretMarkupLoader.fromFile(copy, getProject()));
993   }
994
995   private int configureInner(@NotNull final VirtualFile copy, final SelectionAndCaretMarkupLoader loader) {
996     assertInitialized();
997     try {
998       final OutputStream outputStream = copy.getOutputStream(null, 0, 0);
999       outputStream.write(loader.newFileText.getBytes());
1000       outputStream.close();
1001     }
1002     catch (IOException e) {
1003       throw new RuntimeException(e);
1004     }
1005     myFile = myPsiManager.findFile(copy);
1006     setContext(myFile, myFileContext);
1007     myEditor = createEditor(copy);
1008     assert myEditor != null : "Editor couldn't be created for file: " + copy.getPath() + ", use copyFileToProject(..) method for this file instead of configureByFile(..)" ;
1009     int offset = -1;
1010     if (loader.caretMarker != null) {
1011       offset = loader.caretMarker.getStartOffset();
1012       myEditor.getCaretModel().moveToOffset(offset);
1013     }
1014     if (loader.selStartMarker != null && loader.selEndMarker != null) {
1015       myEditor.getSelectionModel().setSelection(loader.selStartMarker.getStartOffset(), loader.selEndMarker.getStartOffset());
1016     }
1017
1018     Module module = getModule();
1019     if (module != null) {
1020       for (Facet facet : FacetManager.getInstance(module).getAllFacets()) {
1021         module.getMessageBus().syncPublisher(FacetManager.FACETS_TOPIC).facetConfigurationChanged(facet);
1022       }
1023     }
1024
1025     return offset;
1026   }
1027
1028   private static void setContext(final PsiFile file, final PsiElement context) {
1029     if (file != null && context != null) {
1030       file.putUserData(FileContextUtil.INJECTED_IN_ELEMENT, new IdentitySmartPointer<PsiElement>(context));
1031     }
1032   }
1033
1034   public VirtualFile findFileInTempDir(final String filePath) {
1035     if (myTempDirFixture instanceof LightTempDirTestFixtureImpl) {
1036       return myTempDirFixture.getFile(filePath);
1037     }
1038     String fullPath = getTempDirPath() + "/" + filePath;
1039
1040     final VirtualFile copy = LocalFileSystem.getInstance().refreshAndFindFileByPath(fullPath.replace(File.separatorChar, '/'));
1041     assert copy != null : "file " + fullPath + " not found";
1042     return copy;
1043   }
1044
1045   @Nullable
1046   private Editor createEditor(VirtualFile file) {
1047     final Project project = getProject();
1048     final FileEditorManager instance = FileEditorManager.getInstance(project);
1049     if (file.getFileType().isBinary()) {
1050       return null;
1051     }
1052     return instance.openTextEditor(new OpenFileDescriptor(project, file, 0), false);
1053   }
1054
1055   private void collectAndCheckHighlightings(boolean checkWarnings, boolean checkInfos, boolean checkWeakWarnings, Ref<Long> duration)
1056     throws Exception {
1057     ExpectedHighlightingData data = new ExpectedHighlightingData(myEditor.getDocument(), checkWarnings, checkWeakWarnings, checkInfos, myFile);
1058
1059     collectAndCheckHighlightings(data, duration);
1060   }
1061
1062   private void collectAndCheckHighlightings(final ExpectedHighlightingData data, final Ref<Long> duration) {
1063     final Project project = getProject();
1064     PsiDocumentManager.getInstance(project).commitAllDocuments();
1065
1066     ((PsiFileImpl)myFile).calcTreeElement(); //to load text
1067
1068     //to initialize caches
1069     myPsiManager.getCacheManager().getFilesWithWord(XXX, UsageSearchContext.IN_COMMENTS, GlobalSearchScope.allScope(project), true);
1070
1071     ((PsiManagerImpl)PsiManager.getInstance(project)).setAssertOnFileLoadingFilter(myJavaFilesFilter);
1072
1073     final long start = System.currentTimeMillis();
1074 //    ProfilingUtil.startCPUProfiling();
1075     List<HighlightInfo> infos = doHighlighting();
1076     removeDuplicatedRangesForInjected(infos);
1077     final long elapsed = System.currentTimeMillis() - start;
1078     duration.set(duration.isNull()? elapsed : duration.get().longValue() + elapsed);
1079 //    ProfilingUtil.captureCPUSnapshot("testing");
1080
1081     ((PsiManagerImpl)PsiManager.getInstance(project)).setAssertOnFileLoadingFilter(VirtualFileFilter.NONE);
1082
1083     data.checkResult(infos, myEditor.getDocument().getText());
1084   }
1085
1086   private static void removeDuplicatedRangesForInjected(List<HighlightInfo> infos) {
1087     Collections.sort(infos, new Comparator<HighlightInfo>() {
1088       public int compare(HighlightInfo o1, HighlightInfo o2) {
1089         final int i = o2.startOffset - o1.startOffset;
1090         return i != 0 ? i : o1.getSeverity().myVal - o2.getSeverity().myVal;
1091       }
1092     });
1093     HighlightInfo prevInfo = null;
1094     for (Iterator<HighlightInfo> it = infos.iterator(); it.hasNext();) {
1095       final HighlightInfo info = it.next();
1096       if (prevInfo != null &&
1097           info.getSeverity() == HighlightSeverity.INFORMATION &&
1098           info.description == null &&
1099           info.startOffset == prevInfo.startOffset &&
1100           info.endOffset == prevInfo.endOffset) {
1101         it.remove();
1102       }
1103       prevInfo = info.getSeverity() == HighlightInfoType.INJECTED_FRAGMENT_SEVERITY ? info : null;
1104     }
1105   }
1106
1107   @NotNull
1108   public List<HighlightInfo> doHighlighting() {
1109     final Project project = myProjectFixture.getProject();
1110     PsiDocumentManager.getInstance(project).commitAllDocuments();
1111
1112     return
1113     ApplicationManager.getApplication().runReadAction(new Computable<List<HighlightInfo>>() {
1114       public List<HighlightInfo> compute() {
1115         return instantiateAndRun(getFile(), getEditor(), ArrayUtil.EMPTY_INT_ARRAY, false);
1116       }
1117     });
1118   }
1119
1120   @NotNull
1121   public static List<HighlightInfo> instantiateAndRun(PsiFile file, Editor editor, int[] toIgnore, boolean allowDirt) {
1122     Project project = file.getProject();
1123     ensureIndexesUpToDate(project);
1124     DaemonCodeAnalyzerImpl codeAnalyzer = (DaemonCodeAnalyzerImpl)DaemonCodeAnalyzer.getInstance(project);
1125     FileStatusMap fileStatusMap = codeAnalyzer.getFileStatusMap();
1126     for (int ignoreId : toIgnore) {
1127       fileStatusMap.markFileUpToDate(editor.getDocument(), file, ignoreId);
1128     }
1129     fileStatusMap.allowDirt(allowDirt);
1130     try {
1131       TextEditorBackgroundHighlighter highlighter = (TextEditorBackgroundHighlighter)TextEditorProvider.getInstance().getTextEditor(editor).getBackgroundHighlighter();
1132       final List<TextEditorHighlightingPass> passes = highlighter.getPasses(toIgnore);
1133       final ProgressIndicator progress = new DaemonProgressIndicator();
1134       ProgressManager.getInstance().runProcess(new Runnable() {
1135         public void run() {
1136           for (TextEditorHighlightingPass pass : passes) {
1137             pass.collectInformation(progress);
1138             pass.applyInformationToEditor();
1139           }
1140         }
1141       }, progress);
1142       List<HighlightInfo> infos = DaemonCodeAnalyzerImpl.getHighlights(editor.getDocument(), project);
1143       return infos == null ? Collections.<HighlightInfo>emptyList() : new ArrayList<HighlightInfo>(infos);
1144     }
1145     finally {
1146       fileStatusMap.allowDirt(true);
1147       codeAnalyzer.clearPasses();
1148     }
1149   }
1150
1151   private static void ensureIndexesUpToDate(Project project) {
1152     FileBasedIndex.getInstance().ensureUpToDate(StubUpdatingIndex.INDEX_ID, project, null);
1153     FileBasedIndex.getInstance().ensureUpToDate(TodoIndex.NAME, project, null);
1154     assertTrue(!DumbServiceImpl.getInstance(project).isDumb());
1155   }
1156
1157   public String getTestDataPath() {
1158     return myTestDataPath;
1159   }
1160
1161   public Project getProject() {
1162     return myProjectFixture.getProject();
1163   }
1164
1165   public Module getModule() {
1166     return myProjectFixture.getModule();
1167   }
1168
1169   public Editor getEditor() {
1170     return myEditor;
1171   }
1172
1173   public PsiFile getFile() {
1174     return myFile;
1175   }
1176
1177   public static List<IntentionAction> getAvailableIntentions(final Editor editor, final PsiFile file) {
1178     return ApplicationManager.getApplication().runReadAction(new Computable<List<IntentionAction>>() {
1179       public List<IntentionAction> compute() {
1180         return doGetAvailableIntentions(editor, file);
1181       }
1182     });
1183   }
1184
1185   private static List<IntentionAction> doGetAvailableIntentions(Editor editor, PsiFile file) {
1186     ShowIntentionsPass.IntentionsInfo intentions = new ShowIntentionsPass.IntentionsInfo();
1187     ShowIntentionsPass.getActionsToShow(editor, file, intentions, -1);
1188     List<HighlightInfo.IntentionActionDescriptor> descriptors = new ArrayList<HighlightInfo.IntentionActionDescriptor>();
1189     descriptors.addAll(intentions.intentionsToShow);
1190     descriptors.addAll(intentions.errorFixesToShow);
1191     descriptors.addAll(intentions.inspectionFixesToShow);
1192     descriptors.addAll(intentions.guttersToShow);
1193
1194     PsiElement element = file.findElementAt(editor.getCaretModel().getOffset());
1195     List<IntentionAction> result = new ArrayList<IntentionAction>();
1196
1197     List<HighlightInfo> infos = DaemonCodeAnalyzerImpl.getFileLevelHighlights(file.getProject(), file);
1198     for (HighlightInfo info : infos) {
1199       for (Pair<HighlightInfo.IntentionActionDescriptor, TextRange> pair : info.quickFixActionRanges) {
1200         HighlightInfo.IntentionActionDescriptor actionInGroup = pair.first;
1201         if (actionInGroup.getAction().isAvailable(file.getProject(), editor, file)) {
1202           descriptors.add(actionInGroup);
1203         }
1204       }
1205     }
1206
1207     // add all intention options for simplicity
1208     for (HighlightInfo.IntentionActionDescriptor descriptor : descriptors) {
1209       result.add(descriptor.getAction());
1210       List<IntentionAction> options = descriptor.getOptions(element);
1211       if (options != null) {
1212         for (IntentionAction option : options) {
1213           if (option.isAvailable(file.getProject(), editor, file)) {
1214             result.add(option);
1215           }
1216         }
1217       }
1218     }
1219     return result;
1220   }
1221
1222   public void allowTreeAccessForFile(final VirtualFile file) {
1223     myJavaFilesFilter.allowTreeAccessForFile(file);
1224   }
1225
1226   public void allowTreeAccessForAllFiles() {
1227     myJavaFilesFilter.allowTreeAccessForAllFiles();
1228   }
1229
1230   static class SelectionAndCaretMarkupLoader {
1231     final String newFileText;
1232     final RangeMarker caretMarker;
1233     final RangeMarker selStartMarker;
1234     final RangeMarker selEndMarker;
1235
1236     static SelectionAndCaretMarkupLoader fromFile(String path, Project project) throws IOException {
1237       return new SelectionAndCaretMarkupLoader(StringUtil.convertLineSeparators(new String(FileUtil.loadFileText(new File(path)))), project);
1238     }
1239     static SelectionAndCaretMarkupLoader fromFile(VirtualFile file, Project project) throws IOException {
1240       return new SelectionAndCaretMarkupLoader(StringUtil.convertLineSeparators(VfsUtil.loadText(file)), project);
1241     }
1242
1243     static SelectionAndCaretMarkupLoader fromText(String text, Project project) {
1244       return new SelectionAndCaretMarkupLoader(text, project);
1245     }
1246
1247     private SelectionAndCaretMarkupLoader(String fileText, Project project) {
1248       final Document document = EditorFactory.getInstance().createDocument(fileText);
1249
1250       int caretIndex = fileText.indexOf(CARET_MARKER);
1251       int selStartIndex = fileText.indexOf(SELECTION_START_MARKER);
1252       int selEndIndex = fileText.indexOf(SELECTION_END_MARKER);
1253
1254       caretMarker = caretIndex >= 0 ? document.createRangeMarker(caretIndex, caretIndex) : null;
1255       selStartMarker = selStartIndex >= 0 ? document.createRangeMarker(selStartIndex, selStartIndex) : null;
1256       selEndMarker = selEndIndex >= 0 ? document.createRangeMarker(selEndIndex, selEndIndex) : null;
1257
1258       new WriteCommandAction(project) {
1259         protected void run(Result result) throws Exception {
1260           if (caretMarker != null) {
1261             document.deleteString(caretMarker.getStartOffset(), caretMarker.getStartOffset() + CARET_MARKER.length());
1262           }
1263           if (selStartMarker != null) {
1264             document.deleteString(selStartMarker.getStartOffset(), selStartMarker.getStartOffset() + SELECTION_START_MARKER.length());
1265           }
1266           if (selEndMarker != null) {
1267             document.deleteString(selEndMarker.getStartOffset(), selEndMarker.getStartOffset() + SELECTION_END_MARKER.length());
1268           }
1269         }
1270       }.execute();
1271
1272       newFileText = document.getText();
1273     }
1274
1275   }
1276   private void checkResultByFile(@NonNls String expectedFile,
1277                                  @NotNull PsiFile originalFile,
1278                                  boolean stripTrailingSpaces) throws IOException {
1279     if (!stripTrailingSpaces) {
1280       EditorUtil.fillVirtualSpaceUntilCaret(myEditor);
1281     }
1282     PsiDocumentManager.getInstance(getProject()).commitAllDocuments();
1283     checkResult(expectedFile, stripTrailingSpaces, SelectionAndCaretMarkupLoader.fromFile(getTestDataPath() + "/" + expectedFile, getProject()), originalFile.getText());
1284   }
1285
1286   private void checkResult(final String expectedFile,
1287                            final boolean stripTrailingSpaces,
1288                            final SelectionAndCaretMarkupLoader loader,
1289                            String actualText) {
1290     assertInitialized();
1291     Project project = myProjectFixture.getProject();
1292
1293     project.getComponent(PostprocessReformattingAspect.class).doPostponedFormatting();
1294     if (stripTrailingSpaces) {
1295       actualText = stripTrailingSpaces(actualText);
1296     }
1297
1298     PsiDocumentManager.getInstance(project).commitAllDocuments();
1299
1300     String newFileText1 = loader.newFileText;
1301     if (stripTrailingSpaces) {
1302       newFileText1 = stripTrailingSpaces(newFileText1);
1303     }
1304
1305     actualText = StringUtil.convertLineSeparators(actualText);
1306
1307     //noinspection HardCodedStringLiteral
1308     Assert.assertEquals("Text mismatch in file " + expectedFile, newFileText1, actualText);
1309
1310     if (loader.caretMarker != null) {
1311       int caretLine = StringUtil.offsetToLineNumber(loader.newFileText, loader.caretMarker.getStartOffset());
1312       int caretCol = loader.caretMarker.getStartOffset() - StringUtil.lineColToOffset(loader.newFileText, caretLine, 0);
1313
1314       Assert.assertEquals("caretLine", caretLine + 1, myEditor.getCaretModel().getLogicalPosition().line + 1);
1315       Assert.assertEquals("caretColumn", caretCol + 1, myEditor.getCaretModel().getLogicalPosition().column + 1);
1316     }
1317
1318     if (loader.selStartMarker != null && loader.selEndMarker != null) {
1319       int selStartLine = StringUtil.offsetToLineNumber(loader.newFileText, loader.selStartMarker.getStartOffset());
1320       int selStartCol = loader.selStartMarker.getStartOffset() - StringUtil.lineColToOffset(loader.newFileText, selStartLine, 0);
1321
1322       int selEndLine = StringUtil.offsetToLineNumber(loader.newFileText, loader.selEndMarker.getEndOffset());
1323       int selEndCol = loader.selEndMarker.getEndOffset() - StringUtil.lineColToOffset(loader.newFileText, selEndLine, 0);
1324
1325       Assert.assertEquals("selectionStartLine", selStartLine + 1,
1326                           StringUtil.offsetToLineNumber(loader.newFileText, myEditor.getSelectionModel().getSelectionStart()) + 1);
1327
1328       Assert.assertEquals("selectionStartCol", selStartCol + 1, myEditor.getSelectionModel().getSelectionStart() -
1329                                                                 StringUtil.lineColToOffset(loader.newFileText, selStartLine, 0) + 1);
1330
1331       Assert.assertEquals("selectionEndLine", selEndLine + 1,
1332                           StringUtil.offsetToLineNumber(loader.newFileText, myEditor.getSelectionModel().getSelectionEnd()) + 1);
1333
1334       Assert.assertEquals("selectionEndCol", selEndCol + 1,
1335                           myEditor.getSelectionModel().getSelectionEnd() - StringUtil.lineColToOffset(loader.newFileText, selEndLine, 0) +
1336                           1);
1337     }
1338     else if (myEditor != null) {
1339       Assert.assertTrue("has no selection", !myEditor.getSelectionModel().hasSelection());
1340     }
1341   }
1342
1343   private static String stripTrailingSpaces(String actualText) {
1344     final Document document = EditorFactory.getInstance().createDocument(actualText);
1345     ((DocumentEx)document).stripTrailingSpaces(false);
1346     actualText = document.getText();
1347     return actualText;
1348   }
1349
1350 }