Convert MultiFileIntentionTest to light fixture test case

idea/tests/org/jetbrains/kotlin/idea/intentions/AbstractMultiFileIntentionTest.kt

@@ -19,86 +19,86 @@ package org.jetbrains.kotlin.idea.intentions
 import com.google.gson.JsonObject
 import com.google.gson.JsonParser
 import com.intellij.codeInsight.intention.IntentionAction
-import com.intellij.openapi.editor.EditorFactory
 import com.intellij.openapi.fileEditor.FileDocumentManager
+import com.intellij.openapi.fileEditor.impl.LoadTextUtil
 import com.intellij.openapi.util.io.FileUtil
+import com.intellij.openapi.vfs.LocalFileSystem
+import com.intellij.openapi.vfs.VirtualFile
 import com.intellij.psi.PsiDocumentManager
-import com.intellij.psi.PsiManager
 import com.intellij.refactoring.util.CommonRefactoringUtil
+import com.intellij.testFramework.LightProjectDescriptor
+import com.intellij.testFramework.PlatformTestUtil
+import com.intellij.testFramework.UsefulTestCase
 import junit.framework.TestCase
 import org.jetbrains.kotlin.idea.jsonUtils.getNullableString
 import org.jetbrains.kotlin.idea.jsonUtils.getString
-import org.jetbrains.kotlin.idea.test.ConfigLibraryUtil
+import org.jetbrains.kotlin.idea.test.KotlinLightCodeInsightFixtureTestCase
-import org.jetbrains.kotlin.idea.test.KotlinMultiFileTestCase
+import org.jetbrains.kotlin.idea.test.KotlinLightProjectDescriptor
-import org.jetbrains.kotlin.idea.test.PluginTestCaseBase
+import org.jetbrains.kotlin.idea.test.KotlinWithJdkAndRuntimeLightProjectDescriptor
-import org.jetbrains.kotlin.idea.test.extractMarkerOffset
 import org.jetbrains.kotlin.idea.util.application.executeWriteCommand
 import org.jetbrains.kotlin.test.KotlinTestUtils
 import org.junit.Assert
 import java.io.File
 
-abstract class AbstractMultiFileIntentionTest : KotlinMultiFileTestCase() {
+abstract class AbstractMultiFileIntentionTest : KotlinLightCodeInsightFixtureTestCase() {
+    override fun getProjectDescriptor(): LightProjectDescriptor {
+        if (KotlinTestUtils.isAllFilesPresentTest(getTestName(false))) return super.getProjectDescriptor()
+        val testFile = File(testDataPath, fileName())
+        val config = JsonParser().parse(FileUtil.loadFile(testFile, true)) as JsonObject
+        val withRuntime = config["withRuntime"]?.asBoolean ?: false
+        return if (withRuntime)
+            KotlinWithJdkAndRuntimeLightProjectDescriptor.INSTANCE
+        else
+            KotlinLightProjectDescriptor.INSTANCE
+    }
+
     protected fun doTest(path: String) {
-        val config = JsonParser().parse(FileUtil.loadFile(File(path), true)) as JsonObject
+        val testFile = File(path)
+        val config = JsonParser().parse(FileUtil.loadFile(testFile, true)) as JsonObject
         val mainFilePath = config.getString("mainFile")
         val intentionAction = Class.forName(config.getString("intentionClass")).newInstance() as IntentionAction
         val isApplicableExpected = config["isApplicable"]?.asBoolean ?: true
 
-        val withRuntime = config["withRuntime"]?.asBoolean ?: false
+        doTest(path) { rootDir ->
-        if (withRuntime) {
+            val mainFile = myFixture.configureFromTempProjectFile(mainFilePath)
-            ConfigLibraryUtil.configureKotlinRuntimeAndSdk(myModule, PluginTestCaseBase.mockJdk())
-        }
-
-        doTest({ rootDir, _ ->
-                   val mainFile = rootDir.findFileByRelativePath(mainFilePath)!!
             val conflictFile = rootDir.findFileByRelativePath("$mainFilePath.conflicts")
-                   val document = FileDocumentManager.getInstance().getDocument(mainFile)!!
-                   val editor = EditorFactory.getInstance()!!.createEditor(document, project!!)!!
-                   editor.caretModel.moveToOffset(document.extractMarkerOffset(project))
-                   val mainPsiFile = PsiManager.getInstance(project!!).findFile(mainFile)!!
 
             try {
                 Assert.assertTrue("isAvailable() for ${intentionAction::class.java} should return $isApplicableExpected",
-                                         isApplicableExpected == intentionAction.isAvailable(project, editor, mainPsiFile))
+                                  isApplicableExpected == intentionAction.isAvailable(project, editor, mainFile))
                 config.getNullableString("intentionText")?.let {
                     TestCase.assertEquals("Intention text mismatch", it, intentionAction.text)
                 }
 
                 if (isApplicableExpected) {
                     project.executeWriteCommand(intentionAction.text) {
-                               intentionAction.invoke(project, editor, mainPsiFile)
+                        intentionAction.invoke(project, editor, mainFile)
                     }
                 }
 
                 assert(conflictFile == null) { "Conflict file $conflictFile should not exist" }
             }
             catch (e: CommonRefactoringUtil.RefactoringErrorHintException) {
-                       KotlinTestUtils.assertEqualsToFile(File(conflictFile!!.path), e.message!!)
+                val expectedConflicts = LoadTextUtil.loadText(conflictFile!!).toString().trim()
+                assertEquals(expectedConflicts, e.message)
             }
-                   finally {
+       }
-                       PsiDocumentManager.getInstance(project!!).commitAllDocuments()
+    }
+
+    protected fun doTest(path: String, action: (VirtualFile) -> Unit) {
+        val beforeDir = path.removePrefix(testDataPath).substringBeforeLast('/') + "/before"
+        val beforeVFile = myFixture.copyDirectoryToProject(beforeDir, "")
+        PsiDocumentManager.getInstance(myFixture.project).commitAllDocuments()
+
+        val afterDir = beforeDir.substringBeforeLast("/") + "/after"
+        val afterDirIOFile = File(testDataPath, afterDir)
+        val afterVFile = LocalFileSystem.getInstance().findFileByIoFile(afterDirIOFile)!!
+        UsefulTestCase.refreshRecursively(afterVFile)
+
+        action(beforeVFile)
+
+        PsiDocumentManager.getInstance(project).commitAllDocuments()
         FileDocumentManager.getInstance().saveAllDocuments()
-
+        PlatformTestUtil.assertDirectoriesEqual(beforeVFile, afterVFile)
-                       EditorFactory.getInstance()!!.releaseEditor(editor)
-
-                       if (withRuntime) {
-                           ConfigLibraryUtil.unConfigureKotlinRuntimeAndSdk(myModule, PluginTestCaseBase.mockJdk())
-                       }
-                   }
-               },
-               getTestDirName(true))
-    }
-
-    protected fun getTestDirName(lowercaseFirstLetter : Boolean) : String {
-        val testName = getTestName(lowercaseFirstLetter)
-        return testName.substring(0, testName.lastIndexOf('_')).replace('_', '/')
-    }
-
-    override fun getTestRoot() : String {
-        return "/multiFileIntentions/"
-    }
-
-    override fun getTestDataPath() : String {
-        return PluginTestCaseBase.getTestDataPathBase()
     }
 }