Reformat incremental-compilation-impl tests

compiler/incremental-compilation-impl/test/org/jetbrains/kotlin/incremental/AbstractIncrementalCompilerRunnerTestBase.kt

@@ -32,7 +32,7 @@ abstract class AbstractIncrementalCompilerRunnerTestBase<Args : CommonCompilerAr
         val testDir = File(path)
 
         fun Iterable<File>.relativePaths() =
-                map { it.relativeTo(workingDir).path.replace('\\', '/') }
+            map { it.relativeTo(workingDir).path.replace('\\', '/') }
 
         val srcDir = File(workingDir, "src").apply { mkdirs() }
         val cacheDir = File(workingDir, "incremental-data").apply { mkdirs() }
@@ -50,10 +50,12 @@ abstract class AbstractIncrementalCompilerRunnerTestBase<Args : CommonCompilerAr
         // modifications
         val buildLogFile = buildLogFinder.findBuildLog(testDir) ?: throw IllegalStateException("build log file not found in $workingDir")
         val buildLogSteps = parseTestBuildLog(buildLogFile)
-        val modifications = getModificationsToPerform(testDir,
+        val modifications = getModificationsToPerform(
-                                                      moduleNames = null,
+            testDir,
-                                                      allowNoFilesWithSuffixInTestData = false,
+            moduleNames = null,
-                                                      touchPolicy = TouchPolicy.CHECKSUM)
+            allowNoFilesWithSuffixInTestData = false,
+            touchPolicy = TouchPolicy.CHECKSUM
+        )
 
         assert(modifications.size == buildLogSteps.size) {
             "Modifications count (${modifications.size}) != expected build log steps count (${buildLogSteps.size})"
@@ -73,7 +75,14 @@ abstract class AbstractIncrementalCompilerRunnerTestBase<Args : CommonCompilerAr
             val (_, compiledSources, compileErrors) = make(cacheDir, sourceRoots, args)
 
             expectedSB.appendLine(stepLogAsString(step, buildLogStep.compiledKotlinFiles, buildLogStep.compileErrors))
-            expectedSBWithoutErrors.appendLine(stepLogAsString(step, buildLogStep.compiledKotlinFiles, buildLogStep.compileErrors, includeErrors = false))
+            expectedSBWithoutErrors.appendLine(
+                stepLogAsString(
+                    step,
+                    buildLogStep.compiledKotlinFiles,
+                    buildLogStep.compileErrors,
+                    includeErrors = false
+                )
+            )
             actualSB.appendLine(stepLogAsString(step, compiledSources.relativePaths(), compileErrors))
             actualSBWithoutErrors.appendLine(stepLogAsString(step, compiledSources.relativePaths(), compileErrors, includeErrors = false))
             step++
@@ -83,14 +92,13 @@ abstract class AbstractIncrementalCompilerRunnerTestBase<Args : CommonCompilerAr
             if (BuildLogFinder.isJpsLogFile(buildLogFile)) {
                 // JPS logs should be updated carefully, because standalone logs are a bit different (no removed classes, iterations, etc)
                 Assert.assertEquals(expectedSB.toString(), actualSB.toString())
-            }
+            } else {
-            else {
                 UsefulTestCase.assertSameLinesWithFile(buildLogFile.canonicalPath, actualSB.toString(), false)
             }
         }
 
         // todo: also compare caches
-        run rebuildAndCompareOutput@ {
+        run rebuildAndCompareOutput@{
             val rebuildOutDir = File(workingDir, "rebuild-out").apply { mkdirs() }
             val rebuildCacheDir = File(workingDir, "rebuild-cache").apply { mkdirs() }
             val rebuildResult = make(rebuildCacheDir, sourceRoots, createCompilerArguments(rebuildOutDir, testDir))

compiler/incremental-compilation-impl/test/org/jetbrains/kotlin/incremental/AbstractIncrementalJsCompilerRunnerTest.kt

@@ -35,9 +35,9 @@ abstract class AbstractIncrementalJsCompilerRunnerTest : AbstractIncrementalComp
         get() = super.buildLogFinder.copy(isJsEnabled = true)
 
     override fun createCompilerArguments(destinationDir: File, testDir: File): K2JSCompilerArguments =
-            K2JSCompilerArguments().apply {
+        K2JSCompilerArguments().apply {
-                outputFile = File(destinationDir, "${testDir.name}.js").path
+            outputFile = File(destinationDir, "${testDir.name}.js").path
-                sourceMap = true
+            sourceMap = true
-                metaInfo = true
+            metaInfo = true
-            }
+        }
 }

compiler/incremental-compilation-impl/test/org/jetbrains/kotlin/incremental/AbstractIncrementalJsCompilerRunnerWithFriendModulesDisabledTest.kt

@@ -21,7 +21,7 @@ import java.io.File
 
 abstract class AbstractIncrementalJsCompilerRunnerWithFriendModulesDisabledTest : AbstractIncrementalJsCompilerRunnerTest() {
     override fun createCompilerArguments(destinationDir: File, testDir: File): K2JSCompilerArguments =
-            super.createCompilerArguments(destinationDir, testDir).apply {
+        super.createCompilerArguments(destinationDir, testDir).apply {
-                friendModulesDisabled = true
+            friendModulesDisabled = true
-            }
+        }
 }

compiler/incremental-compilation-impl/test/org/jetbrains/kotlin/incremental/AbstractIncrementalJvmCompilerRunnerTest.kt

@@ -57,7 +57,8 @@ abstract class AbstractIncrementalJvmCompilerRunnerTest : AbstractIncrementalCom
         }
         val args = arrayOf("-cp", javaClasspath,
                            "-d", javaDestinationDir.canonicalPath,
-                           *javaSources.map { it.canonicalPath }.toTypedArray())
+                           *javaSources.map { it.canonicalPath }.toTypedArray()
+        )
 
         val err = ByteArrayOutputStream()
         val javac = ToolProvider.getSystemJavaCompiler()
@@ -69,15 +70,15 @@ abstract class AbstractIncrementalJvmCompilerRunnerTest : AbstractIncrementalCom
     }
 
     override fun createCompilerArguments(destinationDir: File, testDir: File): K2JVMCompilerArguments =
-            K2JVMCompilerArguments().apply {
+        K2JVMCompilerArguments().apply {
-                moduleName = testDir.name
+            moduleName = testDir.name
-                destination = destinationDir.path
+            destination = destinationDir.path
-                classpath = compileClasspath
+            classpath = compileClasspath
-            }
+        }
 
     private val compileClasspath =
-            listOf(
+        listOf(
-                kotlinStdlibJvm,
+            kotlinStdlibJvm,
-                KotlinTestUtils.getAnnotationsJar()
+            KotlinTestUtils.getAnnotationsJar()
-            ).joinToString(File.pathSeparator) { it.canonicalPath }
+        ).joinToString(File.pathSeparator) { it.canonicalPath }
 }

compiler/incremental-compilation-impl/test/org/jetbrains/kotlin/incremental/AbstractIncrementalMultiplatformJsCompilerRunnerTest.kt

@@ -17,7 +17,6 @@
 package org.jetbrains.kotlin.incremental
 
 import org.jetbrains.kotlin.cli.common.arguments.K2JSCompilerArguments
-import org.jetbrains.kotlin.cli.common.arguments.K2JVMCompilerArguments
 import java.io.File
 
 abstract class AbstractIncrementalMultiplatformJsCompilerRunnerTest : AbstractIncrementalJsCompilerRunnerTest() {

compiler/incremental-compilation-impl/test/org/jetbrains/kotlin/incremental/BuildDiffsStorageTest.kt

@@ -22,7 +22,6 @@ import org.junit.Assert
 import org.junit.Before
 import org.junit.Test
 import java.io.File
-import java.io.OutputStream
 import java.util.*
 
 class BuildDiffsStorageTest {
@@ -45,8 +44,10 @@ class BuildDiffsStorageTest {
         val fqNames = listOf(FqName("fizz.Buzz"))
         val diff = BuildDifference(100, true, DirtyData(lookupSymbols, fqNames))
         val diffs = BuildDiffsStorage(listOf(diff))
-        Assert.assertEquals("BuildDiffsStorage(buildDiffs=[BuildDifference(ts=100, isIncremental=true, dirtyData=DirtyData(dirtyLookupSymbols=[LookupSymbol(name=foo, scope=bar)], dirtyClassesFqNames=[fizz.Buzz]))])",
+        Assert.assertEquals(
-                            diffs.toString())
+            "BuildDiffsStorage(buildDiffs=[BuildDifference(ts=100, isIncremental=true, dirtyData=DirtyData(dirtyLookupSymbols=[LookupSymbol(name=foo, scope=bar)], dirtyClassesFqNames=[fizz.Buzz]))])",
+            diffs.toString()
+        )
     }
 
     @Test
@@ -87,8 +88,7 @@ class BuildDiffsStorageTest {
             BuildDiffsStorage.CURRENT_VERSION++
             val diffsDeserialized = BuildDiffsStorage.readFromFile(storageFile, reporter = null)
             Assert.assertEquals(null, diffsDeserialized)
-        }
+        } finally {
-        finally {
             BuildDiffsStorage.CURRENT_VERSION = versionBackup
         }
     }

compiler/incremental-compilation-impl/test/org/jetbrains/kotlin/incremental/snapshots/FileSnapshotMapTest.kt

@@ -2,7 +2,7 @@ package org.jetbrains.kotlin.incremental.snapshots
 
 import org.jetbrains.kotlin.TestWithWorkingDir
 import org.junit.After
-import org.junit.Assert.*
+import org.junit.Assert.assertArrayEquals
 import org.junit.Before
 import org.junit.Test
 import java.io.File
@@ -37,12 +37,16 @@ class FileSnapshotMapTest : TestWithWorkingDir() {
 
         val diff1 = snapshotMap.compareAndUpdate(src.filesWithExt("txt"))
 
-        assertArrayEquals("diff1.removed",
+        assertArrayEquals(
-                diff1.removed.toSortedPaths(),
+            "diff1.removed",
-                emptyArray<String>())
+            diff1.removed.toSortedPaths(),
-        assertArrayEquals("diff1.newOrModified",
+            emptyArray<String>()
-                diff1.modified.toSortedPaths(),
+        )
-                listOf(removedTxt, unchangedTxt, changedTxt).toSortedPaths())
+        assertArrayEquals(
+            "diff1.newOrModified",
+            diff1.modified.toSortedPaths(),
+            listOf(removedTxt, unchangedTxt, changedTxt).toSortedPaths()
+        )
 
         removedTxt.delete()
         unchangedTxt.writeText("unchanged")
@@ -50,17 +54,21 @@ class FileSnapshotMapTest : TestWithWorkingDir() {
         val newTxt = File(foo, "new.txt").apply { writeText("new") }
 
         val diff2 = snapshotMap.compareAndUpdate(src.filesWithExt("txt"))
-        assertArrayEquals("diff2.removed",
+        assertArrayEquals(
-                diff2.removed.toSortedPaths(),
+            "diff2.removed",
-                listOf(removedTxt).toSortedPaths())
+            diff2.removed.toSortedPaths(),
-        assertArrayEquals("diff2.newOrModified",
+            listOf(removedTxt).toSortedPaths()
-                diff2.modified.toSortedPaths(),
+        )
-                listOf(newTxt, changedTxt).toSortedPaths())
+        assertArrayEquals(
+            "diff2.newOrModified",
+            diff2.modified.toSortedPaths(),
+            listOf(newTxt, changedTxt).toSortedPaths()
+        )
     }
 
     private fun Iterable<File>.toSortedPaths(): Array<String> =
-            map { it.canonicalPath }.sorted().toTypedArray()
+        map { it.canonicalPath }.sorted().toTypedArray()
 
     private fun File.filesWithExt(ext: String): Iterable<File> =
-            walk().filter { it.isFile && it.extension.equals(ext, ignoreCase = true) }.toList()
+        walk().filter { it.isFile && it.extension.equals(ext, ignoreCase = true) }.toList()
 }

compiler/incremental-compilation-impl/test/org/jetbrains/kotlin/incremental/snapshots/FileSnapshotTest.kt

@@ -1,13 +1,13 @@
 package org.jetbrains.kotlin.incremental.snapshots
 
 import org.jetbrains.kotlin.TestWithWorkingDir
-import org.junit.Assert.*
+import org.junit.Assert.assertNotEquals
 import org.junit.Test
 import java.io.*
 
 class FileSnapshotTest : TestWithWorkingDir() {
     private val fileSnapshotProvider: FileSnapshotProvider
-            get() = SimpleFileSnapshotProviderImpl()
+        get() = SimpleFileSnapshotProviderImpl()
 
     @Test
     fun testExternalizer() {

compiler/incremental-compilation-impl/test/org/jetbrains/kotlin/incremental/testLogsParsingUtil.kt

@@ -24,9 +24,9 @@ private const val END_COMPILED_FILES = "End of files"
 private const val BEGIN_ERRORS = "COMPILATION FAILED"
 
 class BuildStep(
-        val compiledKotlinFiles: MutableSet<String> = hashSetOf(),
+    val compiledKotlinFiles: MutableSet<String> = hashSetOf(),
-        val compiledJavaFiles: MutableSet<String> = hashSetOf(),
+    val compiledJavaFiles: MutableSet<String> = hashSetOf(),
-        val compileErrors: MutableList<String> = arrayListOf()
+    val compileErrors: MutableList<String> = arrayListOf()
 ) {
     val compileSucceeded: Boolean
         get() = compileErrors.isEmpty()
@@ -69,11 +69,9 @@ fun parseTestBuildLog(file: File): List<BuildStep> {
 
                 if (path.endsWith(".kt")) {
                     compiledKotlinFiles.add(path)
-                }
+                } else if (path.endsWith(".java")) {
-                else if (path.endsWith(".java")) {
                     compiledJavaFiles.add(path)
-                }
+                } else {
-                else {
                     throw IllegalStateException("Expected .kt or .java file, got: $path")
                 }
             }
@@ -109,7 +107,7 @@ fun dumpBuildLog(buildSteps: Iterable<BuildStep>): String {
             sb.appendln()
         }
 
-        sb.appendln("================ Step #${i+1} =================")
+        sb.appendln("================ Step #${i + 1} =================")
         sb.appendln()
         sb.appendln(BEGIN_COMPILED_FILES)
         step.compiledKotlinFiles.sorted().forEach { sb.appendln(it) }

compiler/incremental-compilation-impl/test/org/jetbrains/kotlin/incremental/utils/TestCompilationResult.kt

@@ -20,12 +20,12 @@ import org.jetbrains.kotlin.cli.common.ExitCode
 import java.io.File
 
 data class TestCompilationResult(
-        val exitCode: ExitCode,
+    val exitCode: ExitCode,
-        val compiledSources: Iterable<File>,
+    val compiledSources: Iterable<File>,
-        val compileErrors: Collection<String>
+    val compileErrors: Collection<String>
 ) {
     constructor(
-            icReporter: TestICReporter,
+        icReporter: TestICReporter,
-            messageCollector: TestMessageCollector
+        messageCollector: TestMessageCollector
     ) : this(icReporter.exitCode, icReporter.compiledSources, messageCollector.errors)
 }

compiler/incremental-compilation-impl/test/org/jetbrains/kotlin/incremental/utils/TestMessageCollector.kt

@@ -19,7 +19,7 @@ package org.jetbrains.kotlin.incremental.utils
 import org.jetbrains.kotlin.cli.common.messages.CompilerMessageLocation
 import org.jetbrains.kotlin.cli.common.messages.CompilerMessageSeverity
 import org.jetbrains.kotlin.cli.common.messages.MessageCollector
-import java.util.ArrayList
+import java.util.*
 
 class TestMessageCollector : MessageCollector {
     val errors = ArrayList<String>()
@@ -35,5 +35,5 @@ class TestMessageCollector : MessageCollector {
     }
 
     override fun hasErrors(): Boolean =
-            errors.isNotEmpty()
+        errors.isNotEmpty()
 }