28efa2baae3ff24a2b0a30db9a97b306f0b3029c
[idea/community.git] / java / testFramework / src / com / intellij / codeInsight / CodeInsightTestCase.java
1 /*
2  * Copyright 2000-2015 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 package com.intellij.codeInsight;
17
18 import com.intellij.codeInsight.daemon.DaemonCodeAnalyzer;
19 import com.intellij.injected.editor.EditorWindow;
20 import com.intellij.openapi.Disposable;
21 import com.intellij.openapi.actionSystem.IdeActions;
22 import com.intellij.openapi.application.ApplicationManager;
23 import com.intellij.openapi.application.Result;
24 import com.intellij.openapi.application.WriteAction;
25 import com.intellij.openapi.command.WriteCommandAction;
26 import com.intellij.openapi.command.undo.UndoManager;
27 import com.intellij.openapi.editor.Document;
28 import com.intellij.openapi.editor.Editor;
29 import com.intellij.openapi.editor.EditorFactory;
30 import com.intellij.openapi.editor.LogicalPosition;
31 import com.intellij.openapi.editor.impl.DocumentImpl;
32 import com.intellij.openapi.editor.impl.EditorImpl;
33 import com.intellij.openapi.fileEditor.FileEditorManager;
34 import com.intellij.openapi.fileEditor.OpenFileDescriptor;
35 import com.intellij.openapi.fileEditor.TextEditor;
36 import com.intellij.openapi.fileEditor.impl.text.TextEditorProvider;
37 import com.intellij.openapi.fileTypes.FileType;
38 import com.intellij.openapi.fileTypes.FileTypeManager;
39 import com.intellij.openapi.roots.ContentEntry;
40 import com.intellij.openapi.roots.ModifiableRootModel;
41 import com.intellij.openapi.roots.ModuleRootManager;
42 import com.intellij.openapi.util.Disposer;
43 import com.intellij.openapi.util.io.FileUtil;
44 import com.intellij.openapi.util.text.StringUtil;
45 import com.intellij.openapi.vfs.*;
46 import com.intellij.openapi.vfs.newvfs.impl.VfsRootAccess;
47 import com.intellij.psi.PsiClass;
48 import com.intellij.psi.PsiDocumentManager;
49 import com.intellij.psi.PsiFile;
50 import com.intellij.psi.PsiPackage;
51 import com.intellij.psi.impl.source.PostprocessReformattingAspect;
52 import com.intellij.psi.search.ProjectScope;
53 import com.intellij.testFramework.*;
54 import com.intellij.util.ArrayUtil;
55 import com.intellij.util.Function;
56 import com.intellij.util.containers.ContainerUtil;
57 import org.jetbrains.annotations.NonNls;
58 import org.jetbrains.annotations.NotNull;
59 import org.jetbrains.annotations.Nullable;
60
61 import java.io.File;
62 import java.io.IOException;
63 import java.io.OutputStream;
64 import java.util.ArrayList;
65 import java.util.LinkedHashMap;
66 import java.util.List;
67 import java.util.Map;
68
69 /**
70  * @author Mike
71  */
72 public abstract class CodeInsightTestCase extends PsiTestCase {
73   protected Editor myEditor;
74
75   protected Editor createEditor(@NotNull VirtualFile file) {
76     final FileEditorManager instance = FileEditorManager.getInstance(myProject);
77
78     if (file.getFileType().isBinary()) return null;
79     PsiDocumentManager.getInstance(getProject()).commitAllDocuments();
80     Editor editor = instance.openTextEditor(new OpenFileDescriptor(myProject, file, 0), false);
81     ((EditorImpl)editor).setCaretActive();
82     PsiDocumentManager.getInstance(getProject()).commitAllDocuments();
83     DaemonCodeAnalyzer.getInstance(getProject()).restart();
84
85     return editor;
86   }
87
88   @Override
89   protected void tearDown() throws Exception {
90     try {
91       if (myProject != null) {
92         FileEditorManager editorManager = FileEditorManager.getInstance(myProject);
93         VirtualFile[] openFiles = editorManager.getOpenFiles();
94         for (VirtualFile openFile : openFiles) {
95           editorManager.closeFile(openFile);
96         }
97       }
98     }
99     finally {
100       myEditor = null;
101       super.tearDown();
102     }
103   }
104
105   @Override
106   protected PsiTestData createData() {
107     return new CodeInsightTestData();
108   }
109
110   protected void configureByFile(@NonNls String filePath) throws Exception {
111     configureByFile(filePath, null);
112   }
113
114   /**
115    * @param files the first file will be loaded in editor
116    */
117   protected VirtualFile configureByFiles(@Nullable String projectRoot, @NotNull String... files) throws Exception {
118     if (files.length == 0) return null;
119     final VirtualFile[] vFiles = new VirtualFile[files.length];
120     for (int i = 0; i < files.length; i++) {
121       String path = files[i];
122       final String fullPath = FileUtil.toSystemIndependentName(getTestDataPath() + path);
123       allowRootAccess(fullPath);
124       VirtualFile vFile = LocalFileSystem.getInstance().findFileByPath(fullPath);
125       vFiles[i] = vFile;
126       assertNotNull("file " + fullPath + " not found", vFile);
127     }
128
129     File projectFile = projectRoot == null ? null : new File(getTestDataPath() + projectRoot);
130
131     return configureByFiles(projectFile, vFiles);
132   }
133
134   private void allowRootAccess(final String filePath) {
135     VfsRootAccess.allowRootAccess(filePath);
136     Disposer.register(myTestRootDisposable, new Disposable() {
137       @Override
138       public void dispose() {
139         VfsRootAccess.disallowRootAccess(filePath);
140       }
141     });
142   }
143
144   protected VirtualFile configureByFile(@NonNls String filePath, @Nullable String projectRoot) throws Exception {
145     String fullPath = getTestDataPath() + filePath;
146     allowRootAccess(fullPath);
147
148     final VirtualFile vFile = LocalFileSystem.getInstance().findFileByPath(fullPath.replace(File.separatorChar, '/'));
149     assertNotNull("file " + fullPath + " not found", vFile);
150
151     File projectFile = projectRoot == null ? null : new File(getTestDataPath() + projectRoot);
152
153     return configureByFile(vFile, projectFile);
154   }
155
156   protected PsiFile configureByText(@NotNull FileType fileType, @NonNls @NotNull final String text) {
157     return configureByText(fileType, text, null);
158   }
159
160   protected PsiFile configureByText(@NotNull final FileType fileType, @NonNls @NotNull final String text, @Nullable String _extension) {
161     try {
162       final String extension = _extension == null ? fileType.getDefaultExtension():_extension;
163
164       File dir = createTempDirectory();
165       final File tempFile = FileUtil.createTempFile(dir, "tempFile", "." + extension, true);
166       final FileTypeManager fileTypeManager = FileTypeManager.getInstance();
167       if (fileTypeManager.getFileTypeByExtension(extension) != fileType) {
168         new WriteCommandAction(getProject()) {
169           @Override
170           protected void run(@NotNull Result result) throws Exception {
171             fileTypeManager.associateExtension(fileType, extension);
172           }
173         }.execute();
174       }
175       final VirtualFile vFile = LocalFileSystem.getInstance().refreshAndFindFileByIoFile(tempFile);
176       assert vFile != null;
177       new WriteAction() {
178         @Override
179         protected void run(@NotNull Result result) throws Throwable {
180           vFile.setCharset(CharsetToolkit.UTF8_CHARSET);
181           VfsUtil.saveText(vFile, text);
182         }
183       }.execute();
184
185       final VirtualFile vdir = LocalFileSystem.getInstance().refreshAndFindFileByIoFile(dir);
186
187       PsiTestUtil.addSourceRoot(myModule, vdir);
188
189       configureByExistingFile(vFile);
190
191       assertEquals(fileType, myFile.getVirtualFile().getFileType());
192       return myFile;
193     }
194     catch (IOException e) {
195       throw new RuntimeException(e);
196     }
197   }
198
199
200   protected void configureByFile(@NotNull VirtualFile vFile) throws IOException {
201     configureByFile(vFile, null);
202   }
203
204   protected void configureByExistingFile(@NotNull final VirtualFile virtualFile) {
205     myFile = null;
206     myEditor = null;
207
208     final Editor editor = createEditor(virtualFile);
209
210     final Document document = editor.getDocument();
211     final EditorInfo editorInfo = new EditorInfo(document.getText());
212
213     final String newFileText = editorInfo.getNewFileText();
214     ApplicationManager.getApplication().runWriteAction(new Runnable() {
215       @Override
216       public void run() {
217         if (!document.getText().equals(newFileText)) {
218           document.setText(newFileText);
219         }
220
221         PsiFile file = myPsiManager.findFile(virtualFile);
222         if (myFile == null) myFile = file;
223
224         if (myEditor == null) myEditor = editor;
225
226         editorInfo.applyToEditor(editor);
227       }
228     });
229
230
231     PsiDocumentManager.getInstance(getProject()).commitAllDocuments();
232   }
233
234   protected VirtualFile configureByFiles(@Nullable final File rawProjectRoot, @NotNull final VirtualFile... vFiles) throws IOException {
235     myFile = null;
236     myEditor = null;
237
238     final File toDirIO = createTempDirectory();
239     final VirtualFile toDir = getVirtualFile(toDirIO);
240
241     ApplicationManager.getApplication().runWriteAction(new Runnable() {
242       @Override
243       public void run() {
244         try {
245           final ModuleRootManager rootManager = ModuleRootManager.getInstance(myModule);
246           final ModifiableRootModel rootModel = rootManager.getModifiableModel();
247           if (clearModelBeforeConfiguring()) {
248             rootModel.clear();
249           }
250
251           // auxiliary files should be copied first
252           VirtualFile[] reversed = ArrayUtil.reverseArray(vFiles);
253           Map<VirtualFile, EditorInfo> editorInfos;
254           if (rawProjectRoot != null) {
255             final File projectRoot = rawProjectRoot.getCanonicalFile();
256             FileUtil.copyDir(projectRoot, toDirIO);
257             VirtualFile fromDir = getVirtualFile(projectRoot);
258             editorInfos =
259               copyFilesFillingEditorInfos(fromDir, toDir, ContainerUtil.map2Array(reversed, String.class, new Function<VirtualFile, String>() {
260                 @Override
261                 public String fun(final VirtualFile s) {
262                   return s.getPath().substring(projectRoot.getPath().length());
263                 }
264               }));
265
266             toDir.refresh(false, true);
267           }
268           else {
269             editorInfos = new LinkedHashMap<VirtualFile, EditorInfo>();
270             for (final VirtualFile vFile : reversed) {
271               VirtualFile parent = vFile.getParent();
272               assert parent.isDirectory() : parent;
273               editorInfos.putAll(copyFilesFillingEditorInfos(parent, toDir, vFile.getName()));
274             }
275           }
276
277           boolean sourceRootAdded = false;
278           if (isAddDirToContentRoot()) {
279             final ContentEntry contentEntry = rootModel.addContentEntry(toDir);
280             if (isAddDirToSource()) {
281               sourceRootAdded = true;
282               contentEntry.addSourceFolder(toDir, isAddDirToTests());
283             }
284           }
285           doCommitModel(rootModel);
286           if (sourceRootAdded) {
287             sourceRootAdded(toDir);
288           }
289
290           openEditorsAndActivateLast(editorInfos);
291         }
292         catch (IOException e) {
293           LOG.error(e);
294         }
295       }
296     });
297
298
299     return toDir;
300   }
301
302   protected boolean isAddDirToTests() {
303     return false;
304   }
305
306   protected void doCommitModel(@NotNull ModifiableRootModel rootModel) {
307     rootModel.commit();
308   }
309
310   protected void sourceRootAdded(final VirtualFile dir) {
311   }
312
313   @NotNull
314   protected Map<VirtualFile, EditorInfo> copyFilesFillingEditorInfos(@NotNull String testDataFromDir,
315                                                                      @NotNull VirtualFile toDir,
316                                                                      @NotNull String... relativePaths) throws IOException {
317     if (!testDataFromDir.startsWith("/")) testDataFromDir = "/" + testDataFromDir;
318     return copyFilesFillingEditorInfos(LocalFileSystem.getInstance().refreshAndFindFileByPath(getTestDataPath() + testDataFromDir), toDir, relativePaths);
319   }
320
321   @NotNull
322   protected Map<VirtualFile, EditorInfo> copyFilesFillingEditorInfos(@NotNull VirtualFile fromDir,
323                                                                      @NotNull VirtualFile toDir,
324                                                                      @NotNull String... relativePaths) throws IOException {
325     Map<VirtualFile, EditorInfo> editorInfos = new LinkedHashMap<VirtualFile, EditorInfo>();
326
327     List<OutputStream> streamsToClose = new ArrayList<OutputStream>();
328
329     for (String relativePath : relativePaths) {
330       if (relativePath.startsWith("/")) {
331         relativePath = relativePath.substring(1);
332       }
333       final VirtualFile fromFile = fromDir.findFileByRelativePath(relativePath);
334       assertNotNull(fromDir.getPath() + "/" + relativePath, fromFile);
335       VirtualFile toFile = toDir.findFileByRelativePath(relativePath);
336       if (toFile == null) {
337         final File file = new File(toDir.getPath(), relativePath);
338         FileUtil.createIfDoesntExist(file);
339         toFile = LocalFileSystem.getInstance().refreshAndFindFileByIoFile(file);
340         assertNotNull(file.getCanonicalPath(), toFile);
341       }
342       toFile.putUserData(VfsTestUtil.TEST_DATA_FILE_PATH, FileUtil.toSystemDependentName(fromFile.getPath()));
343       editorInfos.put(toFile, copyContent(fromFile, toFile, streamsToClose));
344     }
345
346     for(int i = streamsToClose.size() -1; i >= 0 ; --i) {
347       streamsToClose.get(i).close();
348     }
349     return editorInfos;
350   }
351
352   private EditorInfo copyContent(@NotNull VirtualFile from, @NotNull VirtualFile to, @NotNull List<OutputStream> streamsToClose) throws IOException {
353     byte[] content = from.getFileType().isBinary() ? from.contentsToByteArray(): null;
354     final String fileText = from.getFileType().isBinary() ? null : StringUtil.convertLineSeparators(VfsUtilCore.loadText(from));
355
356     EditorInfo editorInfo = fileText == null ? null : new EditorInfo(fileText);
357     String newFileText = fileText == null ? null : editorInfo.getNewFileText();
358     doWrite(newFileText, to, content, streamsToClose);
359     return editorInfo;
360   }
361
362   protected final void setActiveEditor(@NotNull Editor editor) {
363     myEditor = editor;
364     myFile = getPsiFile(editor.getDocument());
365   }
366
367   @NotNull
368   protected List<Editor> openEditorsAndActivateLast(@NotNull Map<VirtualFile, EditorInfo> editorInfos) {
369     final List<Editor> list = openEditors(editorInfos);
370     setActiveEditor(list.get(list.size() - 1));
371     return list;
372   }
373
374   @NotNull
375   protected final List<Editor> openEditors(@NotNull final Map<VirtualFile, EditorInfo> editorInfos) {
376     return ContainerUtil.map(editorInfos.keySet(), new Function<VirtualFile, Editor>() {
377       @Override
378       public Editor fun(final VirtualFile newVFile) {
379         PsiFile file = myPsiManager.findFile(newVFile);
380         if (myFile == null) myFile = file;
381
382         Editor editor = createEditor(newVFile);
383         if (myEditor == null) myEditor = editor;
384
385         EditorInfo editorInfo = editorInfos.get(newVFile);
386         if (editorInfo != null) {
387           editorInfo.applyToEditor(editor);
388         }
389         return editor;
390       }
391     });
392   }
393
394   private void doWrite(final String newFileText,
395                        @NotNull VirtualFile newVFile,
396                        byte[] content,
397                        @NotNull List<OutputStream> streamsToClose) throws IOException {
398     if (newFileText == null) {
399       final OutputStream outputStream = newVFile.getOutputStream(this, -1, -1);
400       outputStream.write(content);
401       streamsToClose.add(outputStream);
402     }
403     else {
404       setFileText(newVFile, newFileText);
405     }
406   }
407
408   protected boolean isAddDirToContentRoot() {
409     return true;
410   }
411
412   protected boolean isAddDirToSource() {
413     return true;
414   }
415
416   protected VirtualFile configureByFile(@NotNull VirtualFile vFile, File projectRoot) throws IOException {
417     return configureByFiles(projectRoot, vFile);
418   }
419
420   protected boolean clearModelBeforeConfiguring() {
421     return false;
422   }
423
424   protected void setupCursorAndSelection(@NotNull final Editor editor) {
425     Document document = editor.getDocument();
426     EditorTestUtil.CaretAndSelectionState caretState = EditorTestUtil.extractCaretAndSelectionMarkers(document);
427     EditorTestUtil.setCaretsAndSelection(editor, caretState);
428     PsiDocumentManager.getInstance(myProject).commitAllDocuments();
429   }
430
431   @Override
432   protected void configure(@NotNull String path, String dataName) throws Exception {
433     super.configure(path, dataName);
434
435     myEditor = createEditor(myFile.getVirtualFile());
436
437     CodeInsightTestData data = (CodeInsightTestData) myTestDataBefore;
438
439     LogicalPosition pos = new LogicalPosition(data.getLineNumber() - 1, data.getColumnNumber() - 1);
440     myEditor.getCaretModel().moveToLogicalPosition(pos);
441
442     int selectionEnd;
443     int selectionStart = selectionEnd = myEditor.getCaretModel().getOffset();
444
445     if (data.getSelectionStartColumnNumber() >= 0) {
446       selectionStart = myEditor.logicalPositionToOffset(new LogicalPosition(data.getSelectionEndLineNumber() - 1, data.getSelectionStartColumnNumber() - 1));
447       selectionEnd = myEditor.logicalPositionToOffset(new LogicalPosition(data.getSelectionEndLineNumber() - 1, data.getSelectionEndColumnNumber() - 1));
448     }
449
450     myEditor.getSelectionModel().setSelection(selectionStart, selectionEnd);
451   }
452
453   protected void checkResultByFile(@NonNls @NotNull String filePath) throws Exception {
454     checkResultByFile(filePath, false);
455   }
456
457   protected void checkResultByFile(@NonNls @NotNull final String filePath, final boolean stripTrailingSpaces) throws Exception {
458     new WriteCommandAction<Document>(getProject()) {
459       @SuppressWarnings("ConstantConditions")
460       @Override
461       protected void run(@NotNull Result<Document> result) throws Throwable {
462         getProject().getComponent(PostprocessReformattingAspect.class).doPostponedFormatting();
463         if (stripTrailingSpaces) {
464           ((DocumentImpl)myEditor.getDocument()).stripTrailingSpaces(getProject());
465         }
466
467         PsiDocumentManager.getInstance(myProject).commitAllDocuments();
468
469         String fullPath = getTestDataPath() + filePath;
470         allowRootAccess(fullPath);
471
472         final VirtualFile vFile = LocalFileSystem.getInstance().findFileByPath(fullPath.replace(File.separatorChar, '/'));
473         assertNotNull("Cannot find file " + fullPath, vFile);
474         String ft;
475         try {
476           ft = VfsUtilCore.loadText(vFile);
477         }
478         catch (IOException e) {
479           throw new RuntimeException(e);
480         }
481
482         String fileText = StringUtil.convertLineSeparators(ft);
483         Document document = EditorFactory.getInstance().createDocument(fileText);
484
485         EditorTestUtil.CaretAndSelectionState caretState = EditorTestUtil.extractCaretAndSelectionMarkers(document);
486
487         String newFileText = document.getText();
488         String newFileText1 = newFileText;
489         if (stripTrailingSpaces) {
490           Document document1 = EditorFactory.getInstance().createDocument(newFileText);
491           ((DocumentImpl)document1).stripTrailingSpaces(getProject());
492           newFileText1 = document1.getText();
493         }
494
495         if (myEditor instanceof EditorWindow) {
496           myEditor = ((EditorWindow)myEditor).getDelegate();
497           myFile = PsiDocumentManager.getInstance(getProject()).getPsiFile(myEditor.getDocument());
498         }
499
500         String text = myFile.getText();
501         text = StringUtil.convertLineSeparators(text);
502
503         assertEquals("Text mismatch in file " + filePath, newFileText1, text);
504
505         EditorTestUtil.verifyCaretAndSelectionState(myEditor, caretState);
506       }
507     }.execute();
508   }
509
510   @Override
511   protected void checkResult(String dataName) throws Exception {
512     PsiDocumentManager.getInstance(myProject).commitAllDocuments();
513     super.checkResult(dataName);
514
515     CodeInsightTestData data = (CodeInsightTestData) myTestDataAfter;
516
517     if (data.getColumnNumber() >= 0) {
518       assertEquals(dataName + ":caretColumn", data.getColumnNumber(), myEditor.getCaretModel().getLogicalPosition().column + 1);
519     }
520     if (data.getLineNumber() >= 0) {
521       assertEquals(dataName + ":caretLine", data.getLineNumber(), myEditor.getCaretModel().getLogicalPosition().line + 1);
522     }
523
524     int selectionStart = myEditor.getSelectionModel().getSelectionStart();
525     int selectionEnd = myEditor.getSelectionModel().getSelectionEnd();
526     LogicalPosition startPosition = myEditor.offsetToLogicalPosition(selectionStart);
527     LogicalPosition endPosition = myEditor.offsetToLogicalPosition(selectionEnd);
528
529     if (data.getSelectionStartColumnNumber() >= 0) {
530       assertEquals(dataName + ":selectionStartColumn", data.getSelectionStartColumnNumber(), startPosition.column + 1);
531     }
532     if (data.getSelectionStartLineNumber() >= 0) {
533       assertEquals(dataName + ":selectionStartLine", data.getSelectionStartLineNumber(), startPosition.line + 1);
534     }
535     if (data.getSelectionEndColumnNumber() >= 0) {
536       assertEquals(dataName + ":selectionEndColumn", data.getSelectionEndColumnNumber(), endPosition.column + 1);
537     }
538     if (data.getSelectionEndLineNumber() >= 0) {
539       assertEquals(dataName + ":selectionEndLine", data.getSelectionEndLineNumber(), endPosition.line + 1);
540     }
541   }
542
543   protected VirtualFile getVirtualFile(@NonNls @NotNull String filePath) {
544     String fullPath = getTestDataPath() + filePath;
545     allowRootAccess(fullPath);
546
547     final VirtualFile vFile = LocalFileSystem.getInstance().findFileByPath(fullPath.replace(File.separatorChar, '/'));
548     assertNotNull("file " + fullPath + " not found", vFile);
549     return vFile;
550   }
551
552   @NotNull
553   protected String getTestRoot(){
554     return FileUtil.toSystemIndependentName(getTestDataPath());
555   }
556
557   public Editor getEditor() {
558     return myEditor;
559   }
560
561   protected void type(char c) {
562     LightPlatformCodeInsightTestCase.type(c, getEditor(),getProject());
563   }
564
565   protected void undo() {
566     UndoManager undoManager = UndoManager.getInstance(myProject);
567     TextEditor textEditor = TextEditorProvider.getInstance().getTextEditor(getEditor());
568     undoManager.undo(textEditor);
569   }
570
571   protected void caretLeft() {
572     caretRight(getEditor());
573   }
574   protected void caretLeft(@NotNull Editor editor) {
575     LightPlatformCodeInsightTestCase.executeAction(IdeActions.ACTION_EDITOR_MOVE_CARET_LEFT, editor, getProject());
576   }
577   protected void caretRight() {
578     caretRight(getEditor());
579   }
580   protected void caretRight(@NotNull Editor editor) {
581     LightPlatformCodeInsightTestCase.executeAction(IdeActions.ACTION_EDITOR_MOVE_CARET_RIGHT, editor, getProject());
582   }
583   protected void caretUp() {
584     LightPlatformCodeInsightTestCase.executeAction(IdeActions.ACTION_EDITOR_MOVE_CARET_UP, myEditor, getProject());
585   }
586
587   protected void deleteLine() {
588     LightPlatformCodeInsightTestCase.deleteLine(myEditor,getProject());
589   }
590
591   protected void type(@NonNls @NotNull String s) {
592     for (char c : s.toCharArray()) {
593       type(c);
594     }
595   }
596
597   protected void backspace() {
598     backspace(getEditor());
599   }
600
601   protected void backspace(@NotNull final Editor editor) {
602     LightPlatformCodeInsightTestCase.backspace(editor,getProject());
603   }
604
605   protected void ctrlW() {
606     LightPlatformCodeInsightTestCase.ctrlW(getEditor(),getProject());
607   }
608
609   protected void ctrlD() {
610     LightPlatformCodeInsightTestCase.ctrlD(getEditor(),getProject());
611   }
612
613   protected void delete(@NotNull final Editor editor) {
614     LightPlatformCodeInsightTestCase.delete(editor, getProject());
615   }
616
617   @NotNull
618   protected PsiClass findClass(@NotNull @NonNls final String name) {
619     final PsiClass aClass = myJavaFacade.findClass(name, ProjectScope.getProjectScope(getProject()));
620     assertNotNull("Class " + name + " not found", aClass);
621     return aClass;
622   }
623
624   @NotNull
625   protected PsiPackage findPackage(@NotNull @NonNls final String name) {
626     final PsiPackage aPackage = myJavaFacade.findPackage(name);
627     assertNotNull("Package " + name + " not found", aPackage);
628     return aPackage;
629   }
630 }