J2K converter testing: added dumping of errors into multifile tests too

j2k/tests/test/org/jetbrains/jet/j2k/test/AbstractJavaToKotlinConverterMultiFileTest.kt

@@ -31,16 +31,18 @@ import org.jetbrains.jet.j2k.JavaToKotlinConverter
 import com.intellij.psi.PsiManager
 import java.util.ArrayList
 import org.jetbrains.jet.j2k.ConverterSettings
+import org.jetbrains.jet.lang.psi.JetFile
 
 public abstract class AbstractJavaToKotlinConverterMultiFileTest() : AbstractJavaToKotlinConverterTest() {
     public fun doTest(dirPath: String) {
         val project = LightPlatformTestCase.getProject()!!
+        val psiManager = PsiManager.getInstance(project)
 
         val javaFiles = File(dirPath).listFiles {(file, name): Boolean -> name.endsWith(".java") }
         val psiFiles = ArrayList<PsiJavaFile>()
         for (javaFile: File in javaFiles) {
             val virtualFile = addFile(javaFile, "test")
-            val psiFile = PsiManager.getInstance(project).findFile(virtualFile) as PsiJavaFile
+            val psiFile = psiManager.findFile(virtualFile) as PsiJavaFile
             psiFiles.add(psiFile)
         }
 
@@ -48,10 +50,17 @@ public abstract class AbstractJavaToKotlinConverterMultiFileTest() : AbstractJav
         val results: List<String> = converter.elementsToKotlin(psiFiles.map { it to J2kPostProcessor(it) })
                 .map { reformat(it, project) }
 
-        for ((i, javaFile) in javaFiles.withIndices()) {
+        fun expectedFile(i: Int) = File(javaFiles[i].getPath().replace(".java", ".kt"))
-            val kotlinPath = javaFile.getPath().replace(".java", ".kt")
+
-            val expectedFile = File(kotlinPath)
+        val jetFiles = ArrayList<JetFile>()
-            JetTestUtils.assertEqualsToFile(expectedFile, results[i])
+        for (i in javaFiles.indices) {
+            deleteFile(psiFiles[i].getVirtualFile())
+            val virtualFile = addFile(results[i], expectedFile(i).getName(), "test")
+            jetFiles.add(psiManager.findFile(virtualFile) as JetFile)
+        }
+
+        for ((i, jetFile) in jetFiles.withIndices()) {
+            JetTestUtils.assertEqualsToFile(expectedFile(i), addErrorsDump(jetFile))
         }
     }
 

j2k/tests/test/org/jetbrains/jet/j2k/test/AbstractJavaToKotlinConverterSingleFileTest.kt

@@ -85,17 +85,12 @@ public abstract class AbstractJavaToKotlinConverterSingleFileTest() : AbstractJa
         val reformatInFun = prefix in setOf("element", "expression", "statement")
 
         var actual = reformat(rawConverted, project, reformatInFun)
-        val kotlinPath = javaPath.replace(".java", ".kt")
 
         if (prefix == "file") {
-            val diagnostics = createKotlinFile(actual).getAnalysisResults().getBindingContext().getDiagnostics()
+            actual = addErrorsDump(createKotlinFile(actual))
-            val errors = diagnostics.filter { it.getSeverity() == Severity.ERROR }
-            if (!errors.isEmpty()) {
-                val header = errors.map { "// ERROR: " + DefaultErrorMessages.RENDERER.render(it).replace('\n', ' ') }.joinToString("\n", postfix = "\n")
-                actual = header + actual
-            }
         }
 
+        val kotlinPath = javaPath.replace(".java", ".kt")
         val expectedFile = File(kotlinPath)
         JetTestUtils.assertEqualsToFile(expectedFile, actual)
     }

j2k/tests/test/org/jetbrains/jet/j2k/test/AbstractJavaToKotlinConverterTest.kt

@@ -27,6 +27,10 @@ import junit.framework.TestCase
 import org.jetbrains.jet.j2k.translateToKotlin
 import com.intellij.openapi.util.Disposer
 import org.jetbrains.jet.j2k.JavaToKotlinTranslator
+import org.jetbrains.jet.lang.diagnostics.Severity
+import org.jetbrains.jet.lang.diagnostics.rendering.DefaultErrorMessages
+import org.jetbrains.jet.lang.psi.JetFile
+import org.jetbrains.jet.plugin.caches.resolve.getAnalysisResults
 import org.jetbrains.jet.JetTestCaseBuilder
 import com.intellij.openapi.vfs.newvfs.impl.VfsRootAccess
 
@@ -49,18 +53,33 @@ public abstract class AbstractJavaToKotlinConverterTest : LightCodeInsightFixtur
         addFile(File("j2k/tests/testData/$fileName"), packageName)
     }
 
-    fun addFile(file: File, packageName: String): VirtualFile {
+    protected fun addFile(file: File, dirName: String): VirtualFile {
+        return addFile(FileUtil.loadFile(file, true), file.getName(), dirName)
+    }
+
+    protected fun addFile(text: String, fileName: String, dirName: String): VirtualFile {
         return ApplicationManager.getApplication()!!.runWriteAction(object: Computable<VirtualFile> {
             override fun compute(): VirtualFile? {
-                val code = FileUtil.loadFile(file, true)
                 val root = LightPlatformTestCase.getSourceRoot()!!
-                val virtualDir = root.findChild(packageName) ?: root.createChildDirectory(null, packageName)
+                val virtualDir = root.findChild(dirName) ?: root.createChildDirectory(null, dirName)
-                val virtualFile = virtualDir.createChildData(null, file.getName())!!
+                val virtualFile = virtualDir.createChildData(null, fileName)!!
-                virtualFile.getOutputStream(null)!!.writer().use { it.write(code) }
+                virtualFile.getOutputStream(null)!!.writer().use { it.write(text) }
                 return virtualFile
             }
         })
     }
+
+    protected fun deleteFile(virtualFile: VirtualFile) {
+        ApplicationManager.getApplication()!!.runWriteAction { virtualFile.delete(this) }
+    }
+
+    protected fun addErrorsDump(jetFile: JetFile): String {
+        val diagnostics = jetFile.getAnalysisResults().getBindingContext().getDiagnostics()
+        val errors = diagnostics.filter { it.getSeverity() == Severity.ERROR }
+        if (errors.isEmpty()) return jetFile.getText()
+        val header = errors.map { "// ERROR: " + DefaultErrorMessages.RENDERER.render(it).replace('\n', ' ') }.joinToString("\n", postfix = "\n")
+        return header + jetFile.getText()
+    }
 }
 
 public abstract class AbstractJavaToKotlinConverterForWebDemoTest() : TestCase() {