farewell green items in completion
[idea/community.git] / platform / testFramework / src / com / intellij / testFramework / fixtures / impl / CodeInsightTestFixtureImpl.java
1 /*
2  * Copyright 2000-2011 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.codeInsight.TargetElementUtilBase;
22 import com.intellij.codeInsight.completion.CodeCompletionHandlerBase;
23 import com.intellij.codeInsight.completion.CompletionProgressIndicator;
24 import com.intellij.codeInsight.completion.CompletionType;
25 import com.intellij.codeInsight.daemon.DaemonCodeAnalyzer;
26 import com.intellij.codeInsight.daemon.DaemonCodeAnalyzerSettings;
27 import com.intellij.codeInsight.daemon.HighlightDisplayKey;
28 import com.intellij.codeInsight.daemon.impl.DaemonCodeAnalyzerImpl;
29 import com.intellij.codeInsight.daemon.impl.HighlightInfo;
30 import com.intellij.codeInsight.daemon.impl.HighlightInfoType;
31 import com.intellij.codeInsight.daemon.impl.ShowIntentionsPass;
32 import com.intellij.codeInsight.folding.CodeFoldingManager;
33 import com.intellij.codeInsight.highlighting.actions.HighlightUsagesAction;
34 import com.intellij.codeInsight.intention.IntentionAction;
35 import com.intellij.codeInsight.intention.impl.ShowIntentionActionsHandler;
36 import com.intellij.codeInsight.lookup.LookupElement;
37 import com.intellij.codeInsight.lookup.LookupManager;
38 import com.intellij.codeInsight.lookup.impl.LookupImpl;
39 import com.intellij.codeInspection.*;
40 import com.intellij.codeInspection.ex.*;
41 import com.intellij.facet.Facet;
42 import com.intellij.facet.FacetManager;
43 import com.intellij.find.FindManager;
44 import com.intellij.find.findUsages.FindUsagesHandler;
45 import com.intellij.find.findUsages.FindUsagesOptions;
46 import com.intellij.find.impl.FindManagerImpl;
47 import com.intellij.ide.DataManager;
48 import com.intellij.ide.startup.StartupManagerEx;
49 import com.intellij.ide.startup.impl.StartupManagerImpl;
50 import com.intellij.ide.structureView.StructureViewBuilder;
51 import com.intellij.ide.structureView.newStructureView.StructureViewComponent;
52 import com.intellij.internal.DumpLookupElementWeights;
53 import com.intellij.lang.LanguageStructureViewBuilder;
54 import com.intellij.openapi.Disposable;
55 import com.intellij.openapi.actionSystem.*;
56 import com.intellij.openapi.actionSystem.ex.ActionManagerEx;
57 import com.intellij.openapi.application.ApplicationManager;
58 import com.intellij.openapi.application.Result;
59 import com.intellij.openapi.command.CommandProcessor;
60 import com.intellij.openapi.command.WriteCommandAction;
61 import com.intellij.openapi.editor.*;
62 import com.intellij.openapi.editor.actionSystem.DocCommandGroupId;
63 import com.intellij.openapi.editor.actionSystem.EditorActionManager;
64 import com.intellij.openapi.editor.ex.EditorEx;
65 import com.intellij.openapi.editor.ex.util.EditorUtil;
66 import com.intellij.openapi.editor.impl.DocumentImpl;
67 import com.intellij.openapi.editor.impl.DocumentMarkupModel;
68 import com.intellij.openapi.editor.markup.GutterIconRenderer;
69 import com.intellij.openapi.editor.markup.RangeHighlighter;
70 import com.intellij.openapi.extensions.ExtensionPoint;
71 import com.intellij.openapi.extensions.ExtensionPointName;
72 import com.intellij.openapi.extensions.Extensions;
73 import com.intellij.openapi.extensions.ExtensionsArea;
74 import com.intellij.openapi.fileEditor.*;
75 import com.intellij.openapi.fileEditor.impl.text.TextEditorProvider;
76 import com.intellij.openapi.fileTypes.FileType;
77 import com.intellij.openapi.fileTypes.FileTypeManager;
78 import com.intellij.openapi.fileTypes.StdFileTypes;
79 import com.intellij.openapi.module.Module;
80 import com.intellij.openapi.project.DumbService;
81 import com.intellij.openapi.project.Project;
82 import com.intellij.openapi.util.*;
83 import com.intellij.openapi.util.io.FileUtil;
84 import com.intellij.openapi.util.text.StringUtil;
85 import com.intellij.openapi.vfs.LocalFileSystem;
86 import com.intellij.openapi.vfs.VfsUtil;
87 import com.intellij.openapi.vfs.VirtualFile;
88 import com.intellij.openapi.vfs.VirtualFileFilter;
89 import com.intellij.profile.codeInspection.InspectionProfileManager;
90 import com.intellij.profile.codeInspection.InspectionProjectProfileManager;
91 import com.intellij.psi.*;
92 import com.intellij.psi.codeStyle.CodeStyleSettingsManager;
93 import com.intellij.psi.impl.PsiManagerImpl;
94 import com.intellij.psi.impl.PsiModificationTrackerImpl;
95 import com.intellij.psi.impl.cache.CacheManager;
96 import com.intellij.psi.impl.cache.impl.todo.TodoIndex;
97 import com.intellij.psi.impl.source.PostprocessReformattingAspect;
98 import com.intellij.psi.impl.source.PsiFileImpl;
99 import com.intellij.psi.impl.source.tree.injected.InjectedLanguageUtil;
100 import com.intellij.psi.search.GlobalSearchScope;
101 import com.intellij.psi.search.UsageSearchContext;
102 import com.intellij.psi.statistics.StatisticsManager;
103 import com.intellij.psi.statistics.impl.StatisticsManagerImpl;
104 import com.intellij.psi.stubs.StubUpdatingIndex;
105 import com.intellij.psi.util.PsiTreeUtil;
106 import com.intellij.refactoring.move.moveFilesOrDirectories.MoveFilesOrDirectoriesProcessor;
107 import com.intellij.refactoring.rename.RenameProcessor;
108 import com.intellij.refactoring.rename.RenamePsiElementProcessor;
109 import com.intellij.testFramework.*;
110 import com.intellij.testFramework.fixtures.*;
111 import com.intellij.usageView.UsageInfo;
112 import com.intellij.util.*;
113 import com.intellij.util.containers.ContainerUtil;
114 import com.intellij.util.indexing.FileBasedIndex;
115 import com.intellij.util.ui.UIUtil;
116 import gnu.trove.THashMap;
117 import junit.framework.Assert;
118 import org.jetbrains.annotations.NonNls;
119 import org.jetbrains.annotations.NotNull;
120 import org.jetbrains.annotations.Nullable;
121
122 import javax.swing.*;
123 import java.io.File;
124 import java.io.IOException;
125 import java.util.*;
126
127 /**
128  * @author Dmitry Avdeev
129  */
130 @SuppressWarnings({"TestMethodWithIncorrectSignature", "JUnitTestCaseWithNoTests", "JUnitTestClassNamingConvention"})
131 public class CodeInsightTestFixtureImpl extends BaseFixture implements CodeInsightTestFixture {
132
133   @NonNls private static final String PROFILE = "Configurable";
134
135   private static final Function<IntentionAction,String> INTENTION_NAME_FUN = new Function<IntentionAction, String>() {
136     @Override
137     public String fun(final IntentionAction intentionAction) {
138       return "\"" + intentionAction.getText() + "\"";
139     }
140   };
141
142   private PsiManagerImpl myPsiManager;
143   private PsiFile myFile;
144   private Editor myEditor;
145   private String myTestDataPath;
146   private boolean myEmptyLookup;
147
148   private InspectionProfileEntry[] myInspections;
149   private final Map<String, InspectionProfileEntry> myAvailableTools = new THashMap<String, InspectionProfileEntry>();
150   private final Map<String, InspectionTool> myAvailableLocalTools = new THashMap<String, InspectionTool>();
151
152   private final TempDirTestFixture myTempDirFixture;
153   protected final IdeaProjectTestFixture myProjectFixture;
154   @NonNls private static final String XXX = "XXX";
155   private final FileTreeAccessFilter myJavaFilesFilter = new FileTreeAccessFilter();
156   private boolean myAllowDirt;
157   private final Map<String, LocalInspectionEP> myExtensions = new HashMap<String, LocalInspectionEP>();
158
159   public CodeInsightTestFixtureImpl(IdeaProjectTestFixture projectFixture, TempDirTestFixture tempDirTestFixture) {
160     myProjectFixture = projectFixture;
161     myTempDirFixture = tempDirTestFixture;
162   }
163
164   @Override
165   public void setTestDataPath(String dataPath) {
166     myTestDataPath = dataPath;
167   }
168
169   @Override
170   public String getTempDirPath() {
171     return myTempDirFixture.getTempDirPath();
172   }
173
174   @Override
175   public TempDirTestFixture getTempDirFixture() {
176     return myTempDirFixture;
177   }
178
179   @Override
180   public VirtualFile copyFileToProject(@NonNls final String sourceFilePath, @NonNls final String targetPath) {
181     File fromFile = new File(getTestDataPath() + "/" + sourceFilePath);
182     if (!fromFile.exists()) {
183       fromFile = new File(sourceFilePath);
184     }
185
186     if (myTempDirFixture instanceof LightTempDirTestFixtureImpl) {
187       VirtualFile fromVFile = LocalFileSystem.getInstance().refreshAndFindFileByIoFile(fromFile);
188       if (fromVFile == null) {
189         fromVFile = myTempDirFixture.getFile(sourceFilePath);
190       }
191       assert fromVFile != null : "can't find test data file " + sourceFilePath + " (" + getTestDataPath() + ")";
192       return myTempDirFixture.copyFile(fromVFile, targetPath);
193     }
194
195     final File destFile = new File(getTempDirPath() + "/" + targetPath);
196     if (!destFile.exists()) {
197       if (fromFile.isDirectory()) {
198         assert destFile.mkdirs() : destFile;
199       }
200       else {
201         if (!fromFile.exists()) {
202           fail("Cannot find source file: '"+sourceFilePath+"'. getTestDataPath()='"+getTestDataPath()+"'. getHomePath()='"+getHomePath()+"'.");
203         }
204         try {
205           FileUtil.copy(fromFile, destFile);
206         }
207         catch (IOException e) {
208           throw new RuntimeException("Cannot copy " + fromFile + " to " + destFile, e);
209         }
210       }
211     }
212
213     final VirtualFile file = LocalFileSystem.getInstance().refreshAndFindFileByIoFile(destFile);
214     assert file != null : destFile;
215     return file;
216   }
217
218   @Override
219   public VirtualFile copyDirectoryToProject(@NonNls final String sourceFilePath, @NonNls final String targetPath) {
220     assert getTestDataPath() != null : "test data path not specified";
221     final File fromFile = new File(getTestDataPath() + "/" + sourceFilePath);
222     if (myTempDirFixture instanceof LightTempDirTestFixtureImpl) {
223       return myTempDirFixture.copyAll(fromFile.getPath(), targetPath);
224     }
225     else {
226       final File destFile = new File(getTempDirPath() + "/" + targetPath);
227       try {
228         FileUtil.copyDir(fromFile, destFile);
229       }
230       catch (IOException e) {
231         throw new RuntimeException(e);
232       }
233       final VirtualFile file = LocalFileSystem.getInstance().refreshAndFindFileByIoFile(destFile);
234       Assert.assertNotNull(file);
235       file.refresh(false, true);
236       return file;
237     }
238   }
239
240   @Override
241   public VirtualFile copyFileToProject(@NonNls final String sourceFilePath) {
242     return copyFileToProject(sourceFilePath, sourceFilePath);
243   }
244
245   @Override
246   public void enableInspections(InspectionProfileEntry... inspections) {
247     myInspections = inspections;
248     if (isInitialized()) {
249       configureInspections(myInspections);
250     }
251   }
252
253   private boolean isInitialized() {
254     return myPsiManager != null;
255   }
256
257   @Override
258   public void enableInspections(final Class<? extends LocalInspectionTool>... inspections) {
259     final ArrayList<LocalInspectionTool> tools = new ArrayList<LocalInspectionTool>();
260     for (Class clazz : inspections) {
261       try {
262         LocalInspectionTool inspection = (LocalInspectionTool)clazz.getConstructor().newInstance();
263         tools.add(inspection);
264       }
265       catch (Exception e) {
266         throw new RuntimeException("Cannot instantiate " + clazz);
267       }
268     }
269     enableInspections(tools.toArray(new LocalInspectionTool[tools.size()]));
270   }
271
272   @Override
273   public void disableInspections(InspectionProfileEntry... inspections) {
274     myAvailableTools.clear();
275     myAvailableLocalTools.clear();
276     final ArrayList<InspectionProfileEntry> tools = new ArrayList<InspectionProfileEntry>(Arrays.asList(myInspections));
277     for (Iterator<InspectionProfileEntry> i = tools.iterator(); i.hasNext();) {
278       final InspectionProfileEntry tool = i.next();
279       for (InspectionProfileEntry toRemove : inspections) {
280         if (tool.getShortName().equals(toRemove.getShortName())) {
281           i.remove();
282           break;
283         }
284       }
285     }
286     myInspections = tools.toArray(new InspectionProfileEntry[tools.size()]);
287     configureInspections(myInspections);
288   }
289
290   @Override
291   public void enableInspections(InspectionToolProvider... providers) {
292     final ArrayList<LocalInspectionTool> tools = new ArrayList<LocalInspectionTool>();
293     for (InspectionToolProvider provider : providers) {
294       for (Class clazz : provider.getInspectionClasses()) {
295         try {
296           Object o = clazz.getConstructor().newInstance();
297           if (o instanceof LocalInspectionTool) {
298             LocalInspectionTool inspection = (LocalInspectionTool)o;
299             tools.add(inspection);
300           }
301         }
302         catch (Exception e) {
303           throw new RuntimeException("Cannot instantiate " + clazz, e);
304         }
305       }
306     }
307     myInspections = tools.toArray(new LocalInspectionTool[tools.size()]);
308     configureInspections(myInspections);
309   }
310
311   @Override
312   public long testHighlighting(final boolean checkWarnings,
313                                final boolean checkInfos,
314                                final boolean checkWeakWarnings,
315                                final String... filePaths) {
316     final Ref<Long> duration = new Ref<Long>();
317     if (filePaths.length > 0) {
318       configureByFilesInner(filePaths);
319     }
320     try {
321       collectAndCheckHighlightings(checkWarnings, checkInfos, checkWeakWarnings, duration);
322     }
323     catch (Exception e) {
324       throw new RuntimeException(e);
325     }
326     return duration.get().longValue();
327   }
328
329   @Override
330   public long testHighlightingAllFiles(final boolean checkWarnings,
331                                        final boolean checkInfos,
332                                        final boolean checkWeakWarnings,
333                                        @NonNls final String... filePaths) {
334     final ArrayList<VirtualFile> files = new ArrayList<VirtualFile>();
335     for (String path : filePaths) {
336       files.add(copyFileToProject(path));
337     }
338     return testHighlightingAllFiles(checkWarnings, checkInfos, checkWeakWarnings, VfsUtil.toVirtualFileArray(files));
339   }
340
341   @Override
342   public long testHighlightingAllFiles(final boolean checkWarnings,
343                                        final boolean checkInfos,
344                                        final boolean checkWeakWarnings,
345                                        @NonNls final VirtualFile... files) {
346     final Ref<Long> duration = new Ref<Long>();
347     collectAndCheckHighlightings(checkWarnings, checkInfos, checkWeakWarnings, duration, files);
348     return duration.get().longValue();
349   }
350
351   private void collectAndCheckHighlightings(final boolean checkWarnings,
352                                             final boolean checkInfos,
353                                             final boolean checkWeakWarnings,
354                                             final Ref<Long> duration,
355                                             final VirtualFile[] files) {
356     final List<Trinity<PsiFile, Editor, ExpectedHighlightingData>> datas =
357       ContainerUtil.map2List(files, new Function<VirtualFile, Trinity<PsiFile, Editor, ExpectedHighlightingData>>() {
358         @Override
359         public Trinity<PsiFile, Editor, ExpectedHighlightingData> fun(final VirtualFile file) {
360           final PsiFile psiFile = myPsiManager.findFile(file);
361           assertNotNull(psiFile);
362           final Document document = PsiDocumentManager.getInstance(getProject()).getDocument(psiFile);
363           assertNotNull(document);
364           ExpectedHighlightingData data = new ExpectedHighlightingData(document, checkWarnings, checkWeakWarnings, checkInfos, psiFile);
365           data.init();
366           return Trinity.create(psiFile, createEditor(file), data);
367         }
368       });
369     for (Trinity<PsiFile, Editor, ExpectedHighlightingData> trinity : datas) {
370       myEditor = trinity.second;
371       myFile = trinity.first;
372       collectAndCheckHighlightings(trinity.third, duration);
373     }
374   }
375
376   @Override
377   public long checkHighlighting(final boolean checkWarnings, final boolean checkInfos, final boolean checkWeakWarnings) {
378     final Ref<Long> duration = new Ref<Long>();
379     try {
380       collectAndCheckHighlightings(checkWarnings, checkInfos, checkWeakWarnings, duration);
381     }
382     catch (Exception e) {
383       throw new RuntimeException(e);
384     }
385     return duration.get().longValue();
386   }
387
388   @Override
389   public long checkHighlighting() {
390     return checkHighlighting(true, true, true);
391   }
392
393   @Override
394   public long testHighlighting(final String... filePaths) {
395     return testHighlighting(true, true, true, filePaths);
396   }
397
398   @Override
399   public long testHighlighting(final boolean checkWarnings,
400                                final boolean checkInfos,
401                                final boolean checkWeakWarnings,
402                                final VirtualFile file) {
403     final Ref<Long> duration = new Ref<Long>();
404     openFileInEditor(file);
405     try {
406       collectAndCheckHighlightings(checkWarnings, checkInfos, checkWeakWarnings, duration);
407     }
408     catch (Exception e) {
409       throw new RuntimeException(e);
410     }
411     return duration.get().longValue();
412   }
413
414   @Override
415   public HighlightTestInfo testFile(@NonNls @NotNull String... filePath) {
416     return new HighlightTestInfo(getTestRootDisposable(), filePath){
417       @Override
418       public HighlightTestInfo doTest() throws Exception {
419         configureByFiles(filePaths);
420         ExpectedHighlightingData data = new ExpectedHighlightingData(myEditor.getDocument(), checkWarnings, checkWeakWarnings, checkInfos, myFile);
421         if (checkSymbolNames) data.checkSymbolNames();
422         data.init();
423         collectAndCheckHighlightings(data, Ref.create(0L));
424         return this;
425       }
426     };
427   }
428
429   public void openFileInEditor(@NotNull final VirtualFile file) {
430     myFile = myPsiManager.findFile(file);
431     myEditor = createEditor(file);
432   }
433
434   @Override
435   public void testInspection(String testDir, InspectionTool tool) {
436     VirtualFile sourceDir = copyDirectoryToProject(new File(testDir, "src").getPath(), "src");
437     AnalysisScope scope = new AnalysisScope(getPsiManager().findDirectory(sourceDir));
438
439     scope.invalidate();
440
441     InspectionManagerEx inspectionManager = (InspectionManagerEx)InspectionManager.getInstance(getProject());
442     GlobalInspectionContextImpl globalContext = createGlobalContextForTool(scope, getProject(), inspectionManager, tool);
443
444     InspectionTestUtil.runTool(tool, scope, globalContext, inspectionManager);
445     InspectionTestUtil.compareToolResults(tool, false, new File(getTestDataPath(), testDir).getPath());
446   }
447
448   public static GlobalInspectionContextImpl createGlobalContextForTool(AnalysisScope scope,
449                                                                        final Project project,
450                                                                        final InspectionManagerEx inspectionManager,
451                                                                        final InspectionTool... tools) {
452     final GlobalInspectionContextImpl globalContext = new GlobalInspectionContextImpl(project, inspectionManager.getContentManager()){
453       @Override
454       protected List<ToolsImpl> getUsedTools() {
455         List<ToolsImpl> result = new ArrayList<ToolsImpl>();
456         for (InspectionTool tool : tools) {
457           result.add(new ToolsImpl(tool, tool.getDefaultLevel(), true));
458         }
459         return result;
460       }
461
462       @Override
463       public boolean isToCheckMember(PsiElement element, InspectionProfileEntry tool) {
464         return true;
465       }
466     };
467     globalContext.setCurrentScope(scope);
468     return globalContext;
469   }
470
471   @Override
472   @Nullable
473   public PsiReference getReferenceAtCaretPosition(final String... filePaths) {
474     if (filePaths.length > 0) {
475       configureByFilesInner(filePaths);
476     }
477     return getFile().findReferenceAt(myEditor.getCaretModel().getOffset());
478   }
479
480   @Override
481   @NotNull
482   public PsiReference getReferenceAtCaretPositionWithAssertion(final String... filePaths) {
483     final PsiReference reference = getReferenceAtCaretPosition(filePaths);
484     assert reference != null : "no reference found at " + myEditor.getCaretModel().getLogicalPosition();
485     return reference;
486   }
487
488   @Override
489   @NotNull
490   public List<IntentionAction> getAvailableIntentions(final String... filePaths) {
491     if (filePaths.length > 0) {
492       configureByFilesInner(filePaths);
493     }
494     return getAvailableIntentions();
495   }
496
497   @Override
498   @NotNull
499   public List<IntentionAction> getAllQuickFixes(@NonNls final String... filePaths) {
500     if (filePaths.length != 0) {
501       configureByFilesInner(filePaths);
502     }
503     List<HighlightInfo> infos = doHighlighting();
504     ArrayList<IntentionAction> actions = new ArrayList<IntentionAction>();
505     for (HighlightInfo info : infos) {
506       for (Pair<HighlightInfo.IntentionActionDescriptor, TextRange> pair : info.quickFixActionRanges) {
507         actions.add(pair.getFirst().getAction());
508       }
509     }
510     return actions;
511   }
512
513   @Override
514   @NotNull
515   public List<IntentionAction> getAvailableIntentions() {
516     doHighlighting();
517     return getAvailableIntentions(myEditor, myFile);
518   }
519
520   @Override
521   public List<IntentionAction> filterAvailableIntentions(@NotNull final String hint) {
522     final List<IntentionAction> availableIntentions = getAvailableIntentions();
523     return ContainerUtil.findAll(availableIntentions, new Condition<IntentionAction>() {
524       @Override
525       public boolean value(final IntentionAction intentionAction) {
526         return intentionAction.getText().startsWith(hint);
527       }
528     });
529   }
530
531   @Override
532   public IntentionAction findSingleIntention(@NotNull final String hint) {
533     final List<IntentionAction> list = filterAvailableIntentions(hint);
534     if (list.isEmpty()) {
535       Assert.fail("\"" + hint + "\" not in [" + StringUtil.join(getAvailableIntentions(), INTENTION_NAME_FUN, ", ") + "]");
536     }
537     else if (list.size() > 1) {
538       Assert.fail("Too many intention found for \"" + hint + "\": [" + StringUtil.join(list, INTENTION_NAME_FUN, ", ") + "]");
539     }
540     return UsefulTestCase.assertOneElement(list);
541   }
542
543   @Override
544   public IntentionAction getAvailableIntention(final String intentionName, final String... filePaths) {
545     List<IntentionAction> intentions = getAvailableIntentions(filePaths);
546     return CodeInsightTestUtil.findIntentionByText(intentions, intentionName);
547   }
548
549   @Override
550   public void launchAction(@NotNull final IntentionAction action) {
551     ShowIntentionActionsHandler.chooseActionAndInvoke(getFile(), getEditor(), action, action.getText());
552   }
553
554   @Override
555   public void testCompletion(final String[] filesBefore, final String fileAfter) {
556     assertInitialized();
557     configureByFiles(filesBefore);
558     complete(CompletionType.BASIC);
559     checkResultByFile(fileAfter);
560   }
561
562   protected void assertInitialized() {
563     Assert.assertNotNull("setUp() hasn't been called", myPsiManager);
564   }
565
566   @Override
567   public void testCompletion(String fileBefore, String fileAfter, final String... additionalFiles) {
568     testCompletion(ArrayUtil.reverseArray(ArrayUtil.append(additionalFiles, fileBefore)), fileAfter);
569   }
570
571   @Override
572   public void testCompletionVariants(final String fileBefore, final String... expectedItems) {
573     assertInitialized();
574     final List<String> result = getCompletionVariants(fileBefore);
575     Assert.assertNotNull(result);
576     UsefulTestCase.assertSameElements(result, expectedItems);
577   }
578
579   @Override
580   public List<String> getCompletionVariants(final String... filesBefore) {
581     assertInitialized();
582     configureByFiles(filesBefore);
583     final LookupElement[] items = complete(CompletionType.BASIC);
584     Assert.assertNotNull("No lookup was shown, probably there was only one lookup element that was inserted automatically", items);
585     return getLookupElementStrings();
586   }
587
588   @Override
589   @Nullable
590   public List<String> getLookupElementStrings() {
591     assertInitialized();
592     final LookupElement[] elements = getLookupElements();
593     if (elements == null) return null;
594
595     return ContainerUtil.map(elements, new Function<LookupElement, String>() {
596       @Override
597       public String fun(final LookupElement lookupItem) {
598         return lookupItem.getLookupString();
599       }
600     });
601   }
602
603   @Override
604   public void testRename(final String fileBefore, final String fileAfter, final String newName, final String... additionalFiles) {
605     assertInitialized();
606     configureByFiles(ArrayUtil.reverseArray(ArrayUtil.append(additionalFiles, fileBefore)));
607     testRename(fileAfter, newName);
608   }
609
610   @Override
611   public void testRename(final String fileAfter, final String newName) {
612     renameElementAtCaret(newName);
613     checkResultByFile(fileAfter);
614   }
615
616   @Override
617   @NotNull
618   public PsiElement getElementAtCaret() {
619     assertInitialized();
620     final PsiElement element = TargetElementUtilBase.findTargetElement(getCompletionEditor(),
621                                                                        TargetElementUtilBase.REFERENCED_ELEMENT_ACCEPTED |
622                                                                        TargetElementUtilBase.ELEMENT_NAME_ACCEPTED);
623     assert element != null : "element not found in file " +
624                              myFile.getName() +
625                              " at caret position, offset " +
626                              myEditor.getCaretModel().getOffset();
627     return element;
628   }
629
630   @Override
631   public void renameElementAtCaret(final String newName) {
632     renameElement(getElementAtCaret(), newName);
633   }
634
635   @Override
636   public void renameElement(final PsiElement element, final String newName) {
637     final boolean searchInComments = false;
638     final boolean searchTextOccurrences = false;
639     renameElement(element, newName, searchInComments, searchTextOccurrences);
640   }
641
642   @Override
643   public void renameElement(final PsiElement element,
644                             final String newName,
645                             final boolean searchInComments,
646                             final boolean searchTextOccurrences) {
647     final PsiElement substitution = RenamePsiElementProcessor.forElement(element).substituteElementToRename(element, myEditor);
648     if (substitution == null) return;
649     new RenameProcessor(getProject(), substitution, newName, searchInComments, searchTextOccurrences).run();
650   }
651
652   @Override
653   public <T extends PsiElement> T findElementByText(String text, Class<T> elementClass) {
654     int pos = PsiDocumentManager.getInstance(getProject()).getDocument(getFile()).getText().indexOf(text);
655     assert pos >= 0 : "text not found in file";
656     return PsiTreeUtil.getParentOfType(getFile().findElementAt(pos), elementClass);
657   }
658
659   @Override
660   public void type(final char c) {
661     assertInitialized();
662     UIUtil.invokeAndWaitIfNeeded(new Runnable() {
663       @Override
664       public void run() {
665         final EditorActionManager actionManager = EditorActionManager.getInstance();
666         if (c == '\b') {
667           performEditorAction(IdeActions.ACTION_EDITOR_BACKSPACE);
668           return;
669         }
670         if (c == '\n') {
671           if (_performEditorAction(IdeActions.ACTION_CHOOSE_LOOKUP_ITEM)) {
672             return;
673           }
674
675           performEditorAction(IdeActions.ACTION_EDITOR_ENTER);
676           return;
677         }
678         if (c == '\t') {
679           if (_performEditorAction(IdeActions.ACTION_CHOOSE_LOOKUP_ITEM_REPLACE)) {
680             return;
681           }
682           if (_performEditorAction(IdeActions.ACTION_EXPAND_LIVE_TEMPLATE_BY_TAB)) {
683             return;
684           }
685           if (_performEditorAction(IdeActions.ACTION_EDITOR_TAB)) {
686             return;
687           }
688         }
689
690         CommandProcessor.getInstance().executeCommand(getProject(), new Runnable() {
691           @Override
692           public void run() {
693             CommandProcessor.getInstance().setCurrentCommandGroupId(myEditor.getDocument());
694             ActionManagerEx.getInstanceEx().fireBeforeEditorTyping(c, getEditorDataContext());
695             actionManager.getTypedAction().actionPerformed(getEditor(), c, getEditorDataContext());
696           }
697         }, null, DocCommandGroupId.noneGroupId(myEditor.getDocument()));
698       }
699     });
700   }
701
702   private DataContext getEditorDataContext() {
703     return ((EditorEx)myEditor).getDataContext();
704   }
705
706   @Override
707   public void type(String s) {
708     for (int i = 0; i < s.length(); i++) {
709       type(s.charAt(i));
710     }
711   }
712
713   @Override
714   public void performEditorAction(final String actionId) {
715     assertInitialized();
716     _performEditorAction(actionId);
717   }
718
719   private boolean _performEditorAction(String actionId) {
720     final DataContext dataContext = getEditorDataContext();
721
722     ActionManagerEx managerEx = ActionManagerEx.getInstanceEx();
723     AnAction action = managerEx.getAction(actionId);
724     AnActionEvent event = new AnActionEvent(null, dataContext, ActionPlaces.UNKNOWN, new Presentation(), managerEx, 0);
725
726     action.update(event);
727
728     if (!event.getPresentation().isEnabled()) {
729       return false;
730     }
731
732     managerEx.fireBeforeActionPerformed(action, dataContext, event);
733
734     action.actionPerformed(event);
735
736     managerEx.fireAfterActionPerformed(action, dataContext, event);
737     return true;
738   }
739
740   @Override
741   public Presentation testAction(AnAction action) {
742     DataContext context = DataManager.getInstance().getDataContext();
743     TestActionEvent e = new TestActionEvent(context, action);
744     action.beforeActionPerformedUpdate(e);
745     if (e.getPresentation().isEnabled() && e.getPresentation().isVisible()) {
746       action.actionPerformed(e);
747     }
748     return e.getPresentation();
749   }
750
751   @Override
752   public Collection<UsageInfo> testFindUsages(@NonNls final String... fileNames) {
753     assertInitialized();
754     configureByFiles(fileNames);
755     final PsiElement targetElement = TargetElementUtilBase
756       .findTargetElement(getEditor(), TargetElementUtilBase.ELEMENT_NAME_ACCEPTED | TargetElementUtilBase.REFERENCED_ELEMENT_ACCEPTED);
757     assert targetElement != null : "Cannot find referenced element";
758     return findUsages(targetElement);
759   }
760
761   @Override
762   public Collection<UsageInfo> findUsages(@NotNull final PsiElement targetElement) {
763     final Project project = getProject();
764     final FindUsagesHandler handler =
765       ((FindManagerImpl)FindManager.getInstance(project)).getFindUsagesManager().getFindUsagesHandler(targetElement, false);
766
767     final CommonProcessors.CollectProcessor<UsageInfo> processor = new CommonProcessors.CollectProcessor<UsageInfo>();
768     assert handler != null : "Cannot find handler for: " + targetElement;
769     final PsiElement[] psiElements = ArrayUtil.mergeArrays(handler.getPrimaryElements(), handler.getSecondaryElements());
770     final FindUsagesOptions options = handler.getFindUsagesOptions(null);
771     for (PsiElement psiElement : psiElements) {
772       handler.processElementUsages(psiElement, processor, options);
773     }
774     return processor.getResults();
775   }
776
777   @Override
778   public RangeHighlighter[] testHighlightUsages(final String... files) {
779     configureByFiles(files);
780     testAction(new HighlightUsagesAction());
781     final Editor editor = getEditor();
782     //final Editor editor = PlatformDataKeys.EDITOR.getData(DataManager.getInstance().getDataContext());
783     //assert editor != null;
784     //HighlightUsagesHandler.invoke(getProject(), editor, getFile());
785     return editor.getMarkupModel().getAllHighlighters();
786   }
787
788   @Override
789   public void moveFile(@NonNls final String filePath, @NonNls final String to, final String... additionalFiles) {
790     assertInitialized();
791     final Project project = getProject();
792     new WriteCommandAction.Simple(project) {
793       @Override
794       protected void run() throws Exception {
795         configureByFiles(ArrayUtil.reverseArray(ArrayUtil.append(additionalFiles, filePath)));
796         final VirtualFile file = findFileInTempDir(to);
797         assert file != null : "Directory " + to + " not found";
798         assert file.isDirectory() : to + " is not a directory";
799         final PsiDirectory directory = myPsiManager.findDirectory(file);
800         new MoveFilesOrDirectoriesProcessor(project, new PsiElement[]{myFile}, directory,
801                                             false, false, null, null).run();
802       }
803     }.execute().throwException();
804   }
805
806   @Override
807   @Nullable
808   public GutterIconRenderer findGutter(final String filePath) {
809     configureByFilesInner(filePath);
810     int offset = myEditor.getCaretModel().getOffset();
811
812     final Collection<HighlightInfo> infos = doHighlighting();
813     for (HighlightInfo info : infos) {
814       if (info.endOffset >= offset && info.startOffset <= offset) {
815         final GutterIconRenderer renderer = info.getGutterIconRenderer();
816         if (renderer != null) {
817           return renderer;
818         }
819       }
820     }
821     RangeHighlighter[] highlighters = DocumentMarkupModel.forDocument(myEditor.getDocument(), getProject(), true).getAllHighlighters();
822     for (RangeHighlighter highlighter : highlighters) {
823       if (highlighter.getEndOffset() >= offset && highlighter.getStartOffset() <= offset) {
824         GutterIconRenderer renderer = highlighter.getGutterIconRenderer();
825         if (renderer != null) {
826           return renderer;
827         }
828       }
829     }
830     return null;
831   }
832
833   @Override
834   @NotNull
835   public Collection<GutterIconRenderer> findAllGutters(final String filePath) {
836     final Project project = getProject();
837     final SortedMap<Integer, List<GutterIconRenderer>> result = new TreeMap<Integer, List<GutterIconRenderer>>();
838     configureByFilesInner(filePath);
839
840     List<HighlightInfo> infos = doHighlighting();
841     for (HighlightInfo info : infos) {
842       addGutterIconRenderer(info.getGutterIconRenderer(), info.startOffset, result);
843     }
844
845     RangeHighlighter[] highlighters = DocumentMarkupModel.forDocument(myEditor.getDocument(), project, true).getAllHighlighters();
846     for (final RangeHighlighter highlighter : highlighters) {
847       if (!highlighter.isValid()) continue;
848       addGutterIconRenderer(highlighter.getGutterIconRenderer(), highlighter.getStartOffset(), result);
849     }
850     return ContainerUtil.concat(result.values());
851   }
852
853   private static void addGutterIconRenderer(final GutterIconRenderer renderer,
854                                             final int offset,
855                                             SortedMap<Integer, List<GutterIconRenderer>> result) {
856     if (renderer == null) return;
857
858     List<GutterIconRenderer> renderers = result.get(offset);
859     if (renderers == null) {
860       result.put(offset, renderers = new SmartList<GutterIconRenderer>());
861     }
862     renderers.add(renderer);
863   }
864
865
866   @Override
867   public PsiFile addFileToProject(@NonNls final String relativePath, @NonNls final String fileText) {
868     assertInitialized();
869     return addFileToProject(getTempDirPath(), relativePath, fileText);
870   }
871
872   protected PsiFile addFileToProject(String rootPath, String relativePath, String fileText) {
873     try {
874       if (myTempDirFixture instanceof LightTempDirTestFixtureImpl) {
875         final VirtualFile file = myTempDirFixture.createFile(relativePath, fileText);
876         return PsiManager.getInstance(getProject()).findFile(file);
877       }
878
879       return ((HeavyIdeaTestFixture)myProjectFixture).addFileToProject(rootPath, relativePath, fileText);
880     }
881     catch (IOException e) {
882       throw new RuntimeException(e);
883     }
884     finally {
885       ((PsiModificationTrackerImpl)PsiManager.getInstance(getProject()).getModificationTracker()).incCounter();
886     }
887   }
888
889   public <T> void registerExtension(final ExtensionsArea area, final ExtensionPointName<T> epName, final T extension) {
890     assertInitialized();
891     final ExtensionPoint<T> extensionPoint = area.getExtensionPoint(epName);
892     extensionPoint.registerExtension(extension);
893     disposeOnTearDown(new Disposable() {
894       @Override
895       public void dispose() {
896         extensionPoint.unregisterExtension(extension);
897       }
898     });
899   }
900
901   @Override
902   public PsiManager getPsiManager() {
903     return myPsiManager;
904   }
905
906   @Override
907   public LookupElement[] complete(CompletionType type) {
908     return complete(type, 1);
909   }
910
911   @Override
912   public LookupElement[] complete(final CompletionType type, final int invocationCount) {
913     assertInitialized();
914     myEmptyLookup = false;
915     UIUtil.invokeAndWaitIfNeeded(new Runnable() {
916       @Override
917       public void run() {
918         CommandProcessor.getInstance().executeCommand(getProject(), new Runnable() {
919           @Override
920           public void run() {
921             final CodeCompletionHandlerBase handler = new CodeCompletionHandlerBase(type) {
922
923               @Override
924               protected void completionFinished(int offset1,
925                                                 int offset2,
926                                                 CompletionProgressIndicator indicator,
927                                                 LookupElement[] items,
928                                                 boolean hasModifiers) {
929                 myEmptyLookup = items.length == 0;
930                 super.completionFinished(offset1, offset2, indicator, items, hasModifiers);
931               }
932             };
933             Editor editor = getCompletionEditor();
934             handler.invokeCompletion(getProject(), editor, invocationCount, false);
935             PsiDocumentManager.getInstance(getProject()).commitAllDocuments(); // to compare with file text
936           }
937         }, null, null);
938       }
939     });
940
941     return getLookupElements();
942   }
943
944   @Nullable
945   protected Editor getCompletionEditor() {
946     return InjectedLanguageUtil.getEditorForInjectedLanguageNoCommit(myEditor, myFile);
947   }
948
949   @Override
950   @Nullable
951   public LookupElement[] completeBasic() {
952     return complete(CompletionType.BASIC);
953   }
954
955   @Override
956   @Nullable
957   public LookupElement[] getLookupElements() {
958     LookupImpl lookup = getLookup();
959     if (lookup == null) {
960       return myEmptyLookup ? LookupElement.EMPTY_ARRAY : null;
961     }
962     else {
963       final List<LookupElement> list = lookup.getItems();
964       return list.toArray(new LookupElement[list.size()]);
965     }
966   }
967
968   @Override
969   public void checkResult(final String text) {
970     checkResult(text, false);
971   }
972
973   @Override
974   public void checkResult(final String text, final boolean stripTrailingSpaces) {
975     new WriteCommandAction(getProject()) {
976       @Override
977       protected void run(Result result) throws Throwable {
978         PsiDocumentManager.getInstance(getProject()).commitAllDocuments();
979         EditorUtil.fillVirtualSpaceUntilCaret(myEditor);
980         checkResult("TEXT", stripTrailingSpaces, SelectionAndCaretMarkupLoader.fromText(text, getProject()), myFile.getText());
981       }
982     }.execute();
983   }
984
985   @Override
986   public void checkResultByFile(final String expectedFile) {
987     checkResultByFile(expectedFile, false);
988   }
989
990   @Override
991   public void checkResultByFile(final String expectedFile, final boolean ignoreTrailingWhitespaces) {
992     assertInitialized();
993     new WriteCommandAction.Simple(getProject()) {
994
995       @Override
996       protected void run() throws Exception {
997         checkResultByFile(expectedFile, myFile, ignoreTrailingWhitespaces);
998       }
999     }.execute().throwException();
1000   }
1001
1002   @Override
1003   public void checkResultByFile(final String filePath, final String expectedFile, final boolean ignoreTrailingWhitespaces) {
1004     assertInitialized();
1005
1006     new WriteCommandAction.Simple(getProject()) {
1007
1008       @Override
1009       protected void run() throws Exception {
1010         final String path = filePath.replace(File.separatorChar, '/');
1011         final VirtualFile copy = findFileInTempDir(path);
1012         if (copy == null) {
1013           throw new IllegalArgumentException("could not find results file " + path);
1014         }
1015         final PsiFile psiFile = myPsiManager.findFile(copy);
1016         assert psiFile != null;
1017         checkResultByFile(expectedFile, psiFile, ignoreTrailingWhitespaces);
1018       }
1019     }.execute().throwException();
1020   }
1021
1022   @Override
1023   public void setUp() throws Exception {
1024     super.setUp();
1025
1026     myProjectFixture.setUp();
1027     myTempDirFixture.setUp();
1028     myPsiManager = (PsiManagerImpl)PsiManager.getInstance(getProject());
1029     configureInspections(myInspections == null ? LocalInspectionTool.EMPTY_ARRAY : myInspections);
1030
1031     DaemonCodeAnalyzerImpl daemonCodeAnalyzer = (DaemonCodeAnalyzerImpl)DaemonCodeAnalyzer.getInstance(getProject());
1032     daemonCodeAnalyzer.prepareForTest();
1033
1034     DaemonCodeAnalyzerSettings.getInstance().setImportHintEnabled(false);
1035     ensureIndexesUpToDate(getProject());
1036     ((StartupManagerImpl)StartupManagerEx.getInstanceEx(getProject())).runPostStartupActivities();
1037     LocalInspectionEP[] extensions = Extensions.getExtensions(LocalInspectionEP.LOCAL_INSPECTION);
1038     for (LocalInspectionEP extension : extensions) {
1039       myExtensions.put(extension.shortName, extension);
1040     }
1041   }
1042
1043   @Override
1044   public void tearDown() throws Exception {
1045     ((StatisticsManagerImpl)StatisticsManager.getInstance()).clearStatistics();
1046
1047     FileEditorManager editorManager = FileEditorManager.getInstance(getProject());
1048     VirtualFile[] openFiles = editorManager.getOpenFiles();
1049     for (VirtualFile openFile : openFiles) {
1050       editorManager.closeFile(openFile);
1051     }
1052
1053     myEditor = null;
1054     myFile = null;
1055     myPsiManager = null;
1056     myInspections = null;
1057     myAvailableLocalTools.clear();
1058     myAvailableTools.clear();
1059
1060     myProjectFixture.tearDown();
1061     myTempDirFixture.tearDown();
1062
1063     super.tearDown();
1064   }
1065
1066   private void enableInspectionTool(InspectionProfileEntry tool) {
1067     final String shortName = tool.getShortName();
1068     final HighlightDisplayKey key = HighlightDisplayKey.find(shortName);
1069     if (key == null) {
1070       String id = tool instanceof LocalInspectionTool ? ((LocalInspectionTool)tool).getID() : shortName;
1071       HighlightDisplayKey.register(shortName, tool.getDisplayName(), id);
1072     }
1073     myAvailableTools.put(shortName, tool);
1074     InspectionTool inspectionTool;
1075     if (tool instanceof LocalInspectionTool) {
1076       LocalInspectionEP ep = myExtensions.get(tool.getShortName());
1077       inspectionTool = new LocalInspectionToolWrapper((LocalInspectionTool)tool, ep);
1078     }
1079     else {
1080       inspectionTool = (InspectionTool)tool;
1081     }
1082     myAvailableLocalTools.put(shortName, inspectionTool);
1083   }
1084
1085   private void configureInspections(final InspectionProfileEntry[] tools) {
1086     for (InspectionProfileEntry tool : tools) {
1087       enableInspectionTool(tool);
1088     }
1089
1090     final InspectionProfileImpl profile = new InspectionProfileImpl(PROFILE) {
1091       @Override
1092       @NotNull
1093       public ModifiableModel getModifiableModel() {
1094         mySource = this;
1095         return this;
1096       }
1097
1098       @Override
1099       @NotNull
1100       public InspectionProfileEntry[] getInspectionTools(PsiElement element) {
1101         final Collection<InspectionTool> tools = myAvailableLocalTools.values();
1102         return tools.toArray(new InspectionTool[tools.size()]);
1103       }
1104
1105       @Override
1106       public List<ToolsImpl> getAllEnabledInspectionTools(Project project) {
1107         List<ToolsImpl> result = new ArrayList<ToolsImpl>();
1108         for (InspectionProfileEntry entry : getInspectionTools(null)) {
1109           result.add(new ToolsImpl(entry, entry.getDefaultLevel(), true));
1110         }
1111         return result;
1112       }
1113
1114       @Override
1115       public boolean isToolEnabled(HighlightDisplayKey key, PsiElement element) {
1116         return key != null && key.toString() != null && myAvailableTools.containsKey(key.toString());
1117       }
1118
1119       @Override
1120       public InspectionProfileEntry getInspectionTool(@NotNull String shortName) {
1121         return myAvailableTools.get(shortName);
1122       }
1123
1124       @Override
1125       public HighlightDisplayLevel getErrorLevel(@NotNull HighlightDisplayKey key, PsiElement element) {
1126         final InspectionProfileEntry entry = myAvailableTools.get(key.toString());
1127         return entry != null ? entry.getDefaultLevel() : HighlightDisplayLevel.WARNING;
1128       }
1129
1130       @Override
1131       public InspectionTool getInspectionTool(@NotNull String shortName, @NotNull PsiElement element) {
1132         return myAvailableLocalTools.get(shortName);
1133       }
1134     };
1135     final InspectionProfileManager inspectionProfileManager = InspectionProfileManager.getInstance();
1136     inspectionProfileManager.addProfile(profile);
1137     Disposer.register(getTestRootDisposable(), new Disposable() {
1138       @Override
1139       public void dispose() {
1140         inspectionProfileManager.deleteProfile(PROFILE);
1141       }
1142     });
1143     inspectionProfileManager.setRootProfile(profile.getName());
1144     InspectionProjectProfileManager.getInstance(getProject()).updateProfile(profile);
1145     InspectionProjectProfileManager.getInstance(getProject()).setProjectProfile(profile.getName());
1146   }
1147
1148   private PsiFile[] configureByFilesInner(@NonNls String... filePaths) {
1149     assertInitialized();
1150     myFile = null;
1151     myEditor = null;
1152     PsiFile[] psiFiles = new PsiFile[filePaths.length];
1153     for (int i = filePaths.length - 1; i >= 0; i--) {
1154       psiFiles[i] = configureByFileInner(filePaths[i]);
1155     }
1156     return psiFiles;
1157   }
1158
1159   @Override
1160   public PsiFile configureByFile(final String file) {
1161     configureByFilesInner(file);
1162     return myFile;
1163   }
1164
1165   @Override
1166   public PsiFile[] configureByFiles(@NonNls final String... files) {
1167     return configureByFilesInner(files);
1168   }
1169
1170   @Override
1171   public PsiFile configureByText(final FileType fileType, @NonNls final String text) {
1172     assertInitialized();
1173     final String extension = fileType.getDefaultExtension();
1174     final FileTypeManager fileTypeManager = FileTypeManager.getInstance();
1175     if (fileTypeManager.getFileTypeByExtension(extension) != fileType) {
1176       new WriteCommandAction(getProject()) {
1177         @Override
1178         protected void run(Result result) throws Exception {
1179           fileTypeManager.associateExtension(fileType, extension);
1180         }
1181       }.execute();
1182     }
1183     final String fileName = "aaa." + extension;
1184     return configureByText(fileName, text);
1185   }
1186
1187   @Override
1188   public PsiFile configureByText(final String fileName, @NonNls final String text) {
1189     assertInitialized();
1190     new WriteCommandAction(getProject()) {
1191       @Override
1192       protected void run(Result result) throws Throwable {
1193         final VirtualFile vFile;
1194         if (myTempDirFixture instanceof LightTempDirTestFixtureImpl) {
1195           final VirtualFile root = LightPlatformTestCase.getSourceRoot();
1196           root.refresh(false, false);
1197           vFile = root.findOrCreateChildData(this, fileName);
1198         }
1199         else {
1200           String prefix = StringUtil.getPackageName(fileName);
1201           if (prefix.length() < 3) {
1202             prefix += "___";
1203           }
1204           final File tempFile = FileUtil.createTempFile(new File(getTempDirPath()), prefix, "." + StringUtil.getShortName(fileName), true);
1205           vFile = LocalFileSystem.getInstance().refreshAndFindFileByIoFile(tempFile);
1206         }
1207         final Document document = FileDocumentManager.getInstance().getCachedDocument(vFile);
1208         if (document != null) {
1209           FileDocumentManager.getInstance().saveDocument(document);
1210         }
1211
1212         VfsUtil.saveText(vFile, text);
1213         configureInner(vFile, SelectionAndCaretMarkupLoader.fromFile(vFile, getProject()));
1214       }
1215     }.execute();
1216     return myFile;
1217   }
1218
1219   @Override
1220   public Document getDocument(final PsiFile file) {
1221     assertInitialized();
1222     return PsiDocumentManager.getInstance(getProject()).getDocument(file);
1223   }
1224
1225   /**
1226    * @param filePath
1227    * @throws IOException
1228    */
1229   private PsiFile configureByFileInner(@NonNls String filePath) {
1230     assertInitialized();
1231     final VirtualFile file = copyFileToProject(filePath);
1232     return configureByFileInner(file);
1233   }
1234
1235   @Override
1236   public PsiFile configureFromTempProjectFile(final String filePath) {
1237     final VirtualFile fileInTempDir = findFileInTempDir(filePath);
1238     if (fileInTempDir == null) {
1239       throw new IllegalArgumentException("Could not find file in temp dir: " + filePath);
1240     }
1241     return configureByFileInner(fileInTempDir);
1242   }
1243
1244   @Override
1245   public void configureFromExistingVirtualFile(VirtualFile f) {
1246     configureByFileInner(f);
1247   }
1248
1249   private PsiFile configureByFileInner(final VirtualFile copy) {
1250     return configureInner(copy, SelectionAndCaretMarkupLoader.fromFile(copy, getProject()));
1251   }
1252
1253   private PsiFile configureInner(@NotNull final VirtualFile copy, final SelectionAndCaretMarkupLoader loader) {
1254     assertInitialized();
1255     new WriteCommandAction.Simple(getProject()) {
1256       public void run() {
1257         try {
1258           copy.setBinaryContent(loader.newFileText.getBytes(copy.getCharset()), 0, 0, null);
1259         }
1260         catch (IOException e) {
1261           throw new RuntimeException(e);
1262         }
1263         myFile = myPsiManager.findFile(copy);
1264         myEditor = createEditor(copy);
1265         assert myEditor != null : "Editor couldn't be created for file: " +
1266                                   copy.getPath() +
1267                                   ", use copyFileToProject(..) method for this file instead of configureByFile(..)";
1268         if (loader.caretMarker != null) {
1269           int offset = loader.caretMarker.getStartOffset();
1270           myEditor.getCaretModel().moveToOffset(offset);
1271         }
1272         if (loader.selStartMarker != null && loader.selEndMarker != null) {
1273           myEditor.getSelectionModel().setSelection(loader.selStartMarker.getStartOffset(), loader.selEndMarker.getStartOffset());
1274         }
1275
1276         Module module = getModule();
1277         if (module != null) {
1278           for (Facet facet : FacetManager.getInstance(module).getAllFacets()) {
1279             module.getMessageBus().syncPublisher(FacetManager.FACETS_TOPIC).facetConfigurationChanged(facet);
1280           }
1281         }
1282       }
1283     }.execute().throwException();
1284
1285
1286     return myFile;
1287   }
1288
1289   @Override
1290   public VirtualFile findFileInTempDir(final String filePath) {
1291     if (myTempDirFixture instanceof LightTempDirTestFixtureImpl) {
1292       return myTempDirFixture.getFile(filePath);
1293     }
1294     String fullPath = getTempDirPath() + "/" + filePath;
1295
1296     final VirtualFile copy = LocalFileSystem.getInstance().refreshAndFindFileByPath(fullPath.replace(File.separatorChar, '/'));
1297     assert copy != null : "file " + fullPath + " not found";
1298     return copy;
1299   }
1300
1301   @Nullable
1302   private Editor createEditor(VirtualFile file) {
1303     final Project project = getProject();
1304     final FileEditorManager instance = FileEditorManager.getInstance(project);
1305     if (file.getFileType().isBinary()) {
1306       return null;
1307     }
1308     return instance.openTextEditor(new OpenFileDescriptor(project, file, 0), false);
1309   }
1310
1311   private void collectAndCheckHighlightings(boolean checkWarnings, boolean checkInfos, boolean checkWeakWarnings, Ref<Long> duration)
1312     throws Exception {
1313     ExpectedHighlightingData data =
1314       new ExpectedHighlightingData(myEditor.getDocument(), checkWarnings, checkWeakWarnings, checkInfos, myFile);
1315     data.init();
1316     collectAndCheckHighlightings(data, duration);
1317   }
1318
1319   private void collectAndCheckHighlightings(final ExpectedHighlightingData data, final Ref<Long> duration) {
1320     final Project project = getProject();
1321     PsiDocumentManager.getInstance(project).commitAllDocuments();
1322
1323     ((PsiFileImpl)myFile).calcTreeElement(); //to load text
1324
1325     //to initialize caches
1326     CacheManager.SERVICE.getInstance(project).getFilesWithWord(XXX, UsageSearchContext.IN_COMMENTS, GlobalSearchScope.allScope(project), true);
1327
1328     List<HighlightInfo> infos;
1329     try {
1330       ((PsiManagerImpl)PsiManager.getInstance(project)).setAssertOnFileLoadingFilter(myJavaFilesFilter);
1331
1332       final long start = System.currentTimeMillis();
1333 //    ProfilingUtil.startCPUProfiling();
1334       infos = doHighlighting();
1335       removeDuplicatedRangesForInjected(infos);
1336       final long elapsed = System.currentTimeMillis() - start;
1337       duration.set(duration.isNull() ? elapsed : duration.get().longValue() + elapsed);
1338 //    ProfilingUtil.captureCPUSnapshot("testing");
1339     }
1340     finally {
1341       ((PsiManagerImpl)PsiManager.getInstance(project)).setAssertOnFileLoadingFilter(VirtualFileFilter.NONE);
1342     }
1343
1344
1345     data.checkResult(infos, myEditor.getDocument().getText());
1346   }
1347
1348   private static void removeDuplicatedRangesForInjected(List<HighlightInfo> infos) {
1349     Collections.sort(infos, new Comparator<HighlightInfo>() {
1350       @Override
1351       public int compare(HighlightInfo o1, HighlightInfo o2) {
1352         final int i = o2.startOffset - o1.startOffset;
1353         return i != 0 ? i : o1.getSeverity().myVal - o2.getSeverity().myVal;
1354       }
1355     });
1356     HighlightInfo prevInfo = null;
1357     for (Iterator<HighlightInfo> it = infos.iterator(); it.hasNext();) {
1358       final HighlightInfo info = it.next();
1359       if (prevInfo != null &&
1360           info.getSeverity() == HighlightInfoType.SYMBOL_TYPE_SEVERITY &&
1361           info.description == null &&
1362           info.startOffset == prevInfo.startOffset &&
1363           info.endOffset == prevInfo.endOffset) {
1364         it.remove();
1365       }
1366       prevInfo = info.type == HighlightInfoType.INJECTED_LANGUAGE_FRAGMENT ? info : null;
1367     }
1368   }
1369
1370   @Override
1371   @NotNull
1372   public List<HighlightInfo> doHighlighting() {
1373     final Project project = getProject();
1374     PsiDocumentManager.getInstance(project).commitAllDocuments();
1375
1376     return instantiateAndRun(getFile(), getEditor(), ArrayUtil.EMPTY_INT_ARRAY, myAllowDirt);
1377   }
1378
1379   @NotNull
1380   public static List<HighlightInfo> instantiateAndRun(@NotNull PsiFile file,
1381                                                       @NotNull Editor editor,
1382                                                       @NotNull int[] toIgnore,
1383                                                       boolean canChangeDocument) {
1384     Project project = file.getProject();
1385     ensureIndexesUpToDate(project);
1386     DaemonCodeAnalyzerImpl codeAnalyzer = (DaemonCodeAnalyzerImpl)DaemonCodeAnalyzer.getInstance(project);
1387     TextEditor textEditor = TextEditorProvider.getInstance().getTextEditor(editor);
1388     List<HighlightInfo> infos = codeAnalyzer.runPasses(file, editor.getDocument(), textEditor, toIgnore, canChangeDocument, null);
1389     infos.addAll(DaemonCodeAnalyzerImpl.getFileLevelHighlights(project, file));
1390     return infos;
1391   }
1392
1393   public static void ensureIndexesUpToDate(Project project) {
1394     if (!DumbService.isDumb(project)) {
1395       FileBasedIndex.getInstance().ensureUpToDate(StubUpdatingIndex.INDEX_ID, project, null);
1396       FileBasedIndex.getInstance().ensureUpToDate(TodoIndex.NAME, project, null);
1397     }
1398   }
1399
1400   @Override
1401   public String getTestDataPath() {
1402     return myTestDataPath;
1403   }
1404
1405   @Override
1406   public Project getProject() {
1407     return myProjectFixture.getProject();
1408   }
1409
1410   @Override
1411   public Module getModule() {
1412     return myProjectFixture.getModule();
1413   }
1414
1415   @Override
1416   public Editor getEditor() {
1417     return myEditor;
1418   }
1419
1420   @Override
1421   public int getCaretOffset() {
1422     return myEditor.getCaretModel().getOffset();
1423   }
1424
1425   @Override
1426   public PsiFile getFile() {
1427     return myFile;
1428   }
1429
1430   public static List<IntentionAction> getAvailableIntentions(@NotNull final Editor editor, @NotNull final PsiFile file) {
1431     return ApplicationManager.getApplication().runReadAction(new Computable<List<IntentionAction>>() {
1432       @Override
1433       public List<IntentionAction> compute() {
1434         return doGetAvailableIntentions(editor, file);
1435       }
1436     });
1437   }
1438
1439   private static List<IntentionAction> doGetAvailableIntentions(@NotNull Editor editor, @NotNull PsiFile file) {
1440     ShowIntentionsPass.IntentionsInfo intentions = new ShowIntentionsPass.IntentionsInfo();
1441     ShowIntentionsPass.getActionsToShow(editor, file, intentions, -1);
1442     List<HighlightInfo.IntentionActionDescriptor> descriptors = new ArrayList<HighlightInfo.IntentionActionDescriptor>();
1443     descriptors.addAll(intentions.intentionsToShow);
1444     descriptors.addAll(intentions.errorFixesToShow);
1445     descriptors.addAll(intentions.inspectionFixesToShow);
1446     descriptors.addAll(intentions.guttersToShow);
1447
1448     PsiElement element = file.findElementAt(editor.getCaretModel().getOffset());
1449     List<IntentionAction> result = new ArrayList<IntentionAction>();
1450
1451     List<HighlightInfo> infos = DaemonCodeAnalyzerImpl.getFileLevelHighlights(file.getProject(), file);
1452     for (HighlightInfo info : infos) {
1453       for (Pair<HighlightInfo.IntentionActionDescriptor, TextRange> pair : info.quickFixActionRanges) {
1454         HighlightInfo.IntentionActionDescriptor actionInGroup = pair.first;
1455         if (actionInGroup.getAction().isAvailable(file.getProject(), editor, file)) {
1456           descriptors.add(actionInGroup);
1457         }
1458       }
1459     }
1460
1461     // add all intention options for simplicity
1462     for (HighlightInfo.IntentionActionDescriptor descriptor : descriptors) {
1463       result.add(descriptor.getAction());
1464       List<IntentionAction> options = descriptor.getOptions(element,editor);
1465       if (options != null) {
1466         for (IntentionAction option : options) {
1467           if (option.isAvailable(file.getProject(), editor, file)) {
1468             result.add(option);
1469           }
1470         }
1471       }
1472     }
1473     return result;
1474   }
1475
1476   @Override
1477   public void allowTreeAccessForFile(final VirtualFile file) {
1478     myJavaFilesFilter.allowTreeAccessForFile(file);
1479   }
1480
1481   @Override
1482   public void allowTreeAccessForAllFiles() {
1483     myJavaFilesFilter.allowTreeAccessForAllFiles();
1484   }
1485
1486   static class SelectionAndCaretMarkupLoader {
1487     final String newFileText;
1488     final RangeMarker caretMarker;
1489     final RangeMarker selStartMarker;
1490     final RangeMarker selEndMarker;
1491
1492     static SelectionAndCaretMarkupLoader fromFile(String path, Project project) throws IOException {
1493       return new SelectionAndCaretMarkupLoader(StringUtil.convertLineSeparators(FileUtil.loadFile(new File(path))),
1494                                                project);
1495     }
1496
1497     static SelectionAndCaretMarkupLoader fromFile(VirtualFile file, Project project) {
1498       final String text;
1499       try {
1500         text = VfsUtil.loadText(file);
1501       }
1502       catch (IOException e) {
1503         throw new RuntimeException(e);
1504       }
1505       return new SelectionAndCaretMarkupLoader(StringUtil.convertLineSeparators(text), project);
1506     }
1507
1508     static SelectionAndCaretMarkupLoader fromText(String text, Project project) {
1509       return new SelectionAndCaretMarkupLoader(text, project);
1510     }
1511
1512     private SelectionAndCaretMarkupLoader(String fileText, Project project) {
1513       final Document document = EditorFactory.getInstance().createDocument(fileText);
1514
1515       int caretIndex = fileText.indexOf(CARET_MARKER);
1516       int selStartIndex = fileText.indexOf(SELECTION_START_MARKER);
1517       int selEndIndex = fileText.indexOf(SELECTION_END_MARKER);
1518
1519       caretMarker = caretIndex >= 0 ? document.createRangeMarker(caretIndex, caretIndex) : null;
1520       selStartMarker = selStartIndex >= 0 ? document.createRangeMarker(selStartIndex, selStartIndex) : null;
1521       selEndMarker = selEndIndex >= 0 ? document.createRangeMarker(selEndIndex, selEndIndex) : null;
1522
1523       new WriteCommandAction(project) {
1524         @Override
1525         protected void run(Result result) throws Exception {
1526           if (caretMarker != null) {
1527             document.deleteString(caretMarker.getStartOffset(), caretMarker.getStartOffset() + CARET_MARKER.length());
1528           }
1529           if (selStartMarker != null) {
1530             document.deleteString(selStartMarker.getStartOffset(), selStartMarker.getStartOffset() + SELECTION_START_MARKER.length());
1531           }
1532           if (selEndMarker != null) {
1533             document.deleteString(selEndMarker.getStartOffset(), selEndMarker.getStartOffset() + SELECTION_END_MARKER.length());
1534           }
1535         }
1536       }.execute();
1537
1538       newFileText = document.getText();
1539     }
1540   }
1541
1542   private void checkResultByFile(@NonNls String expectedFile,
1543                                  @NotNull PsiFile originalFile,
1544                                  boolean stripTrailingSpaces) throws IOException {
1545     if (!stripTrailingSpaces) {
1546       EditorUtil.fillVirtualSpaceUntilCaret(myEditor);
1547     }
1548     PsiDocumentManager.getInstance(getProject()).commitAllDocuments();
1549
1550     final String fileText = originalFile.getText();
1551     final String path = getTestDataPath() + "/" + expectedFile;
1552
1553     /*final VirtualFile result = LocalFileSystem.getInstance().findFileByPath(path);
1554     final int caret = myEditor.getCaretModel().getOffset();
1555     final String newText = myFile == originalFile ? fileText.substring(0, caret) + "<caret>" + fileText.substring(caret) : fileText;
1556     VfsUtil.saveText(result, newText);*/
1557
1558     checkResult(expectedFile, stripTrailingSpaces,
1559                 SelectionAndCaretMarkupLoader.fromFile(path, getProject()), fileText);
1560
1561   }
1562
1563   private void checkResult(final String expectedFile,
1564                            final boolean stripTrailingSpaces,
1565                            final SelectionAndCaretMarkupLoader loader,
1566                            String actualText) {
1567     assertInitialized();
1568     Project project = getProject();
1569
1570     project.getComponent(PostprocessReformattingAspect.class).doPostponedFormatting();
1571     if (stripTrailingSpaces) {
1572       actualText = stripTrailingSpaces(actualText);
1573     }
1574
1575     PsiDocumentManager.getInstance(project).commitAllDocuments();
1576
1577     String newFileText1 = loader.newFileText;
1578     if (stripTrailingSpaces) {
1579       newFileText1 = stripTrailingSpaces(newFileText1);
1580     }
1581
1582     actualText = StringUtil.convertLineSeparators(actualText);
1583
1584     //noinspection HardCodedStringLiteral
1585     Assert.assertEquals("Text mismatch in file " + expectedFile, newFileText1, actualText);
1586
1587     if (loader.caretMarker != null) {
1588       final int tabSize = CodeStyleSettingsManager.getSettings(getProject()).getIndentOptions(StdFileTypes.JAVA).TAB_SIZE;
1589
1590       int caretLine = StringUtil.offsetToLineNumber(loader.newFileText, loader.caretMarker.getStartOffset());
1591       int caretCol = EditorUtil.calcColumnNumber(null, loader.newFileText, StringUtil.lineColToOffset(loader.newFileText, caretLine, 0), loader.caretMarker.getStartOffset(), tabSize);
1592
1593       final int actualLine = myEditor.getCaretModel().getLogicalPosition().line;
1594       final int actualCol = myEditor.getCaretModel().getLogicalPosition().column;
1595       boolean caretPositionEquals = caretLine == actualLine && caretCol == actualCol;
1596       assertTrue("Caret position in " + expectedFile + " differs. Expected " + genCaretPositionPresentation(caretLine, caretCol) +
1597         ". Actual " + genCaretPositionPresentation(actualLine, actualCol), caretPositionEquals);
1598     }
1599
1600     if (loader.selStartMarker != null && loader.selEndMarker != null) {
1601       int selStartLine = StringUtil.offsetToLineNumber(loader.newFileText, loader.selStartMarker.getStartOffset());
1602       int selStartCol = loader.selStartMarker.getStartOffset() - StringUtil.lineColToOffset(loader.newFileText, selStartLine, 0);
1603
1604       int selEndLine = StringUtil.offsetToLineNumber(loader.newFileText, loader.selEndMarker.getEndOffset());
1605       int selEndCol = loader.selEndMarker.getEndOffset() - StringUtil.lineColToOffset(loader.newFileText, selEndLine, 0);
1606
1607       final int selStartLineActual = StringUtil.offsetToLineNumber(loader.newFileText, myEditor.getSelectionModel().getSelectionStart());
1608       final int selStartColActual = myEditor.getSelectionModel().getSelectionStart() - StringUtil.lineColToOffset(loader.newFileText, selStartLineActual, 0);
1609
1610       final int selEndLineActual = StringUtil.offsetToLineNumber(loader.newFileText, myEditor.getSelectionModel().getSelectionEnd());
1611       final int selEndColActual = myEditor.getSelectionModel().getSelectionEnd() - StringUtil.lineColToOffset(loader.newFileText, selEndLineActual, 0);
1612
1613       final boolean selectionEquals = selStartCol == selStartColActual &&
1614                                       selStartLine == selStartLineActual &&
1615                                       selEndCol == selEndColActual &&
1616                                       selEndLine == selEndLineActual;
1617       Assert.assertTrue("selection in " +
1618                           expectedFile +
1619                           " differs. Expected " +
1620                           genSelectionPresentation(selStartLine, selStartCol, selEndLine, selEndCol) +
1621                           ". Actual " +
1622                           genSelectionPresentation(selStartLineActual, selStartColActual, selEndLineActual, selEndColActual),
1623                         selectionEquals);
1624     }
1625     else if (myEditor != null) {
1626       Assert.assertTrue("has no selection in " + expectedFile, !myEditor.getSelectionModel().hasSelection());
1627     }
1628   }
1629
1630   private static String genCaretPositionPresentation(int line, int col) {
1631     line++;
1632     col++;
1633     return "(" + line + ", " + col + ")";
1634   }
1635
1636   private static String genSelectionPresentation(int startLine, int startCol, int endLine, int endCol) {
1637     startCol++;
1638     startLine++;
1639     endCol++;
1640     endLine++;
1641     return "(" + startLine + ", " + startCol + ")-(" + endLine + ", " + endCol + ")";
1642   }
1643
1644   private static String stripTrailingSpaces(String actualText) {
1645     final Document document = EditorFactory.getInstance().createDocument(actualText);
1646     ((DocumentImpl)document).stripTrailingSpaces();
1647     actualText = document.getText();
1648     return actualText;
1649   }
1650
1651   public void canChangeDocumentDuringHighlighting(boolean canI) {
1652     myAllowDirt = canI;
1653   }
1654
1655   private static final String START_FOLD = "<fold\\stext=\'[^\']*\'(\\sexpand=\'[^\']*\')*>";
1656   private static final String END_FOLD = "</fold>";
1657
1658   private class Border implements Comparable<Border> {
1659     public static final boolean LEFT = true;
1660     public static final boolean RIGHT = false;
1661     public boolean mySide;
1662     public int myOffset;
1663     public String myText;
1664     public boolean myIsExpanded;
1665
1666     private Border(boolean side, int offset, String text, boolean isExpanded) {
1667       mySide = side;
1668       myOffset = offset;
1669       myText = text;
1670       myIsExpanded = isExpanded;
1671     }
1672
1673     public boolean isExpanded() {
1674       return myIsExpanded;
1675     }
1676
1677     public boolean isSide() {
1678       return mySide;
1679     }
1680
1681     public int getOffset() {
1682       return myOffset;
1683     }
1684
1685     public String getText() {
1686       return myText;
1687     }
1688
1689     public int compareTo(Border o) {
1690       return getOffset() < o.getOffset() ? 1 : -1;
1691     }
1692   }
1693
1694   private String getFoldingDescription(@NotNull String content, @NotNull String initialFileName,
1695                                        boolean doCheckCollapseStatus) {
1696     configureByText(FileTypeManager.getInstance().getFileTypeByFileName(initialFileName), content);
1697     CodeFoldingManager.getInstance(getProject()).buildInitialFoldings(myEditor);
1698
1699     final FoldingModel model = myEditor.getFoldingModel();
1700     final FoldRegion[] foldingRegions = model.getAllFoldRegions();
1701     final List<Border> borders = new LinkedList<Border>();
1702
1703     for (FoldRegion region : foldingRegions) {
1704       borders.add(new Border(Border.LEFT, region.getStartOffset(), region.getPlaceholderText(), region.isExpanded()));
1705       borders.add(new Border(Border.RIGHT, region.getEndOffset(), "", region.isExpanded()));
1706     }
1707     Collections.sort(borders);
1708
1709     StringBuilder result = new StringBuilder(myEditor.getDocument().getText());
1710     for (Border border : borders) {
1711       result.insert(border.getOffset(), border.isSide() == Border.LEFT ? "<fold text=\'" + border.getText() + "\'" +
1712                                                                          (doCheckCollapseStatus ? " expand=\'" +
1713                                                                                                     border.isExpanded() +
1714                                                                                                     "\'" : "") +
1715                                                                           ">" : END_FOLD);
1716     }
1717
1718     return result.toString();
1719   }
1720
1721   private void testFoldingRegions(final String verificationFileName, boolean doCheckCollapseStatus) {
1722     String expectedContent;
1723     try {
1724       expectedContent = FileUtil.loadFile(new File(verificationFileName));
1725     }
1726     catch (IOException e) {
1727       throw new RuntimeException(e);
1728     }
1729     Assert.assertNotNull(expectedContent);
1730
1731     expectedContent = StringUtil.replace(expectedContent, "\r", "");
1732     final String cleanContent = expectedContent.replaceAll(START_FOLD, "").replaceAll(END_FOLD, "");
1733     final String actual = getFoldingDescription(cleanContent, verificationFileName, doCheckCollapseStatus);
1734
1735     assertEquals(expectedContent, actual);
1736   }
1737
1738   public void testFoldingWithCollapseStatus(final String verificationFileName) {
1739     testFoldingRegions(verificationFileName, true);
1740   }
1741
1742   public void testFolding(final String verificationFileName) {
1743     testFoldingRegions(verificationFileName, false);
1744   }
1745
1746   @Override
1747   public void assertPreferredCompletionItems(final int selected, @NonNls final String... expected) {
1748     final LookupImpl lookup = getLookup();
1749     assertNotNull(lookup);
1750
1751     final JList list = lookup.getList();
1752     List<String> strings = getLookupElementStrings();
1753     assert strings != null;
1754     final List<String> actual = strings.subList(0, Math.min(expected.length, strings.size()));
1755     if (!actual.equals(Arrays.asList(expected))) {
1756       assertOrderedEquals(DumpLookupElementWeights.getLookupElementWeights(lookup), expected);
1757     }
1758     assertEquals(selected, list.getSelectedIndex());
1759   }
1760
1761   @Override
1762   public void testStructureView(Consumer<StructureViewComponent> consumer) {
1763     assert myFile != null : "configure first";
1764
1765     final VirtualFile vFile = myFile.getVirtualFile();
1766     assert vFile != null : "no virtual file for " + myFile;
1767
1768     final FileEditor fileEditor = FileEditorManager.getInstance(getProject()).getSelectedEditor(vFile);
1769     assert fileEditor != null : "editor not opened for " + vFile;
1770
1771     final StructureViewBuilder builder = LanguageStructureViewBuilder.INSTANCE.getStructureViewBuilder(myFile);
1772     assert builder != null : "no builder for " + myFile;
1773
1774     StructureViewComponent component = null;
1775     try {
1776       component = (StructureViewComponent)builder.createStructureView(fileEditor, myProjectFixture.getProject());
1777       consumer.consume(component);
1778     }
1779     finally {
1780       if (component != null) Disposer.dispose(component);
1781     }
1782   }
1783
1784   private LookupImpl getLookup() {
1785     return (LookupImpl)LookupManager.getActiveLookup(myEditor);
1786   }
1787
1788 }