MultiFile tests now support java + kotlin testing. // FILE directive now accepts path in source root instead of just name

idea/tests/org/jetbrains/kotlin/idea/quickfix/AbstractQuickFixMultiFileTest.java

@@ -25,6 +25,8 @@ import com.intellij.codeInspection.InspectionEP;
 import com.intellij.codeInspection.InspectionProfileEntry;
 import com.intellij.codeInspection.LocalInspectionEP;
 import com.intellij.ide.highlighter.JavaFileType;
+import com.intellij.openapi.application.Result;
+import com.intellij.openapi.application.WriteAction;
 import com.intellij.openapi.command.CommandProcessor;
 import com.intellij.openapi.extensions.Extensions;
 import com.intellij.openapi.fileTypes.FileType;
@@ -33,8 +35,12 @@ import com.intellij.openapi.projectRoots.Sdk;
 import com.intellij.openapi.util.Pair;
 import com.intellij.openapi.util.io.FileUtil;
 import com.intellij.openapi.util.text.StringUtil;
+import com.intellij.openapi.vfs.CharsetToolkit;
+import com.intellij.openapi.vfs.LocalFileSystem;
+import com.intellij.openapi.vfs.VfsUtil;
 import com.intellij.openapi.vfs.VirtualFile;
 import com.intellij.psi.PsiFile;
+import com.intellij.testFramework.PsiTestUtil;
 import com.intellij.testFramework.VfsTestUtil;
 import com.intellij.util.ArrayUtil;
 import com.intellij.util.containers.ContainerUtil;
@@ -57,10 +63,7 @@ import org.jetbrains.kotlin.test.KotlinTestUtils;
 import java.io.File;
 import java.io.FilenameFilter;
 import java.io.IOException;
-import java.util.ArrayList;
+import java.util.*;
-import java.util.Collection;
-import java.util.List;
-import java.util.Map;
 
 public abstract class AbstractQuickFixMultiFileTest extends KotlinDaemonAnalyzerTestCase {
 
@@ -81,6 +84,66 @@ public abstract class AbstractQuickFixMultiFileTest extends KotlinDaemonAnalyzer
         return mainFileName.replace(".Main.kt", ".").replace(".Main.java", ".");
     }
 
+    protected static FileType guessFileType(TestFile file) {
+        if (file.path.contains("." + KotlinFileType.EXTENSION)) {
+            return KotlinFileType.INSTANCE;
+        }
+        else if (file.path.contains("." + JavaFileType.DEFAULT_EXTENSION)) {
+            return JavaFileType.INSTANCE;
+        }
+        else {
+            return PlainTextFileType.INSTANCE;
+        }
+    }
+
+    /**
+     * @param sourceRootDir Base path of test file(Test source directory)
+     * @param testFile      source of VFile content
+     * @return created VirtualFile
+     */
+    protected static VirtualFile createVirtualFileFromTestFile(File sourceRootDir, final TestFile testFile) {
+        try {
+            assertFalse("Please don't use absolute path for multifile test 'FILE' directive: " + testFile.path,
+                        FileUtil.isAbsolutePlatformIndependent(testFile.path));
+            FileType fileType = guessFileType(testFile);
+            String extension = fileType.getDefaultExtension();
+
+
+            final File fileInSourceRoot = new File(testFile.path);
+            File container = FileUtil.getParentFile(fileInSourceRoot);
+            if (container == null) {
+                container = sourceRootDir;
+            }
+            else {
+                container = new File(sourceRootDir, container.getPath());
+            }
+
+            if (!container.exists()) {
+                assertTrue(container.mkdirs());
+            }
+
+            final File tempFile =
+                    FileUtil.createTempFile(container, FileUtil.getNameWithoutExtension(testFile.path), "." + extension, true);
+
+
+            final VirtualFile vFile = LocalFileSystem.getInstance().refreshAndFindFileByIoFile(tempFile);
+            assert vFile != null;
+            new WriteAction() {
+                @Override
+                protected void run(@NotNull Result result) throws Throwable {
+                    vFile.setCharset(CharsetToolkit.UTF8_CHARSET);
+                    VfsUtil.saveText(vFile, testFile.content);
+                }
+            }.execute();
+
+
+            return vFile;
+        }
+        catch (IOException e) {
+            throw new RuntimeException(e);
+        }
+    }
+
     protected void doTestWithoutExtraFile(String beforeFileName) throws Exception {
         doTest(beforeFileName, false);
     }
@@ -133,18 +196,37 @@ public abstract class AbstractQuickFixMultiFileTest extends KotlinDaemonAnalyzer
         super.tearDown();
     }
 
-    protected FileType guessFileType(TestFile file) {
+    /**
-        if (file.name.contains("." + KotlinFileType.EXTENSION)) {
+     * @param subFiles   subFiles of multiFile test
-            return KotlinFileType.INSTANCE;
+     * @param beforeFile will be added last, as subFiles are dependencies of it
+     */
+    protected void configureMultiFileTest(List<TestFile> subFiles, TestFile beforeFile) {
+        try {
+            File sourceRootDir = createTempDirectory();
+            Map<TestFile, VirtualFile> virtualFiles = new HashMap<TestFile, VirtualFile>();
+
+            for (TestFile file : subFiles) {
+                virtualFiles.put(file, createVirtualFileFromTestFile(sourceRootDir, file));
+            }
+            virtualFiles.put(beforeFile, createVirtualFileFromTestFile(sourceRootDir, beforeFile));
+
+            VirtualFile sourceRootVFile = LocalFileSystem.getInstance().refreshAndFindFileByIoFile(sourceRootDir);
+            PsiTestUtil.addSourceRoot(myModule, sourceRootVFile);
+
+            for (TestFile file : subFiles) {
+                configureByExistingFile(virtualFiles.get(file));
+                assertEquals(guessFileType(file), myFile.getVirtualFile().getFileType());
+            }
+
+            configureByExistingFile(virtualFiles.get(beforeFile));
+            assertEquals(guessFileType(beforeFile), myFile.getVirtualFile().getFileType());
         }
-        else if (file.name.contains("." + JavaFileType.DEFAULT_EXTENSION)) {
+        catch (IOException e) {
-            return JavaFileType.INSTANCE;
+            throw new RuntimeException(e);
-        }
-        else {
-            return PlainTextFileType.INSTANCE;
         }
     }
 
+
     protected void doMultiFileTest(final String beforeFileName) throws Exception {
         String multifileText = FileUtil.loadFile(new File(beforeFileName), true);
 
@@ -168,13 +250,13 @@ public abstract class AbstractQuickFixMultiFileTest extends KotlinDaemonAnalyzer
         final TestFile afterFile = CollectionsKt.firstOrNull(subFiles, new Function1<TestFile, Boolean>() {
             @Override
             public Boolean invoke(TestFile file) {
-                return file.name.contains(".after");
+                return file.path.contains(".after");
             }
         });
         final TestFile beforeFile = CollectionsKt.firstOrNull(subFiles, new Function1<TestFile, Boolean>() {
             @Override
             public Boolean invoke(TestFile file) {
-                return file.name.contains(".before");
+                return file.path.contains(".before");
             }
         });
 
@@ -184,11 +266,7 @@ public abstract class AbstractQuickFixMultiFileTest extends KotlinDaemonAnalyzer
         subFiles.remove(afterFile);
         subFiles.remove(beforeFile);
 
-        for (TestFile file : subFiles) {
+        configureMultiFileTest(subFiles, beforeFile);
-            configureByText(guessFileType(file), file.content);
-        }
-
-        configureByText(guessFileType(beforeFile), beforeFile.content);
 
         CommandProcessor.getInstance().executeCommand(getProject(), new Runnable() {
             @Override
@@ -212,11 +290,11 @@ public abstract class AbstractQuickFixMultiFileTest extends KotlinDaemonAnalyzer
 
                     if (pair.second && !afterText.equals(afterFile.content)) {
                         StringBuilder actualTestFile = new StringBuilder();
-                        actualTestFile.append("// FILE: ").append(beforeFile.name).append("\n").append(beforeFile.content);
+                        actualTestFile.append("// FILE: ").append(beforeFile.path).append("\n").append(beforeFile.content);
                         for (TestFile file : subFiles) {
-                            actualTestFile.append("// FILE: ").append(file.name).append("\n").append(file.content);
+                            actualTestFile.append("// FILE: ").append(file.path).append("\n").append(file.content);
                         }
-                        actualTestFile.append("// FILE: ").append(afterFile.name).append("\n").append(afterText);
+                        actualTestFile.append("// FILE: ").append(afterFile.path).append("\n").append(afterText);
 
                         KotlinTestUtils.assertEqualsToFile(new File(beforeFileName), actualTestFile.toString());
                     }
@@ -406,11 +484,11 @@ public abstract class AbstractQuickFixMultiFileTest extends KotlinDaemonAnalyzer
     }
 
     private static class TestFile {
-        public final String name;
+        public final String path;
         public final String content;
 
-        TestFile(String name, String content) {
+        TestFile(String path, String content) {
-            this.name = name;
+            this.path = path;
             this.content = content;
         }
     }