Reformat :kotlin-gradle-plugin-integration-tests

libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/kotlin/org/jetbrains/kotlin/gradle/AbstractKotlinAndroidGradleTests.kt

@@ -1,6 +1,5 @@
 package org.jetbrains.kotlin.gradle
 
-import org.gradle.util.VersionNumber
 import org.jetbrains.kotlin.gradle.util.getFileByName
 import org.jetbrains.kotlin.gradle.util.getFilesByNames
 import org.jetbrains.kotlin.gradle.util.isLegacyAndroidGradleVersion
@@ -10,7 +9,9 @@ import org.junit.Test
 import java.io.File
 
 
-class KotlinAndroidGradleIT : AbstractKotlinAndroidGradleTests(gradleVersion = GradleVersionRequired.AtLeast("3.4"), androidGradlePluginVersion = "2.3.0")
+class KotlinAndroidGradleIT :
+    AbstractKotlinAndroidGradleTests(gradleVersion = GradleVersionRequired.AtLeast("3.4"), androidGradlePluginVersion = "2.3.0")
+
 class KotlinAndroidWithJackGradleIT : AbstractKotlinAndroidWithJackGradleTests(androidGradlePluginVersion = "2.3.+")
 
 // TODO If we there is a way to fetch the latest Android plugin version, test against the latest version
@@ -56,8 +57,10 @@ abstract class AbstractKotlinAndroidGradleTests(
 ) : BaseGradleIT() {
 
     override fun defaultBuildOptions() =
-            super.defaultBuildOptions().copy(androidHome = KotlinTestUtils.findAndroidSdk(),
+        super.defaultBuildOptions().copy(
-                                             androidGradlePluginVersion = androidGradlePluginVersion)
+            androidHome = KotlinTestUtils.findAndroidSdk(),
+            androidGradlePluginVersion = androidGradlePluginVersion
+        )
 
     @Test
     fun testSimpleCompile() {
@@ -132,11 +135,13 @@ abstract class AbstractKotlinAndroidGradleTests(
         }
 
         val getSomethingKt = project.projectDir.walk().filter { it.isFile && it.name.endsWith("getSomething.kt") }.first()
-        getSomethingKt.writeText("""
+        getSomethingKt.writeText(
+            """
 package foo
 
 fun getSomething() = 10
-""")
+"""
+        )
 
         project.build("assembleDebug", options = options) {
             assertSuccessful()
@@ -174,8 +179,12 @@ fun getSomething() = 10
         }
 
         val androidModuleKt = project.projectDir.getFileByName("AndroidModule.kt")
-        androidModuleKt.modify { it.replace("fun provideApplicationContext(): Context {",
+        androidModuleKt.modify {
-                                            "fun provideApplicationContext(): Context? {") }
+            it.replace(
+                "fun provideApplicationContext(): Context {",
+                "fun provideApplicationContext(): Context? {"
+            )
+        }
         // rebuilt because DaggerApplicationComponent.java was regenerated
         val baseApplicationKt = project.projectDir.getFileByName("BaseApplication.kt")
         // rebuilt because BuildConfig.java was regenerated (timestamp was changed)
@@ -183,11 +192,13 @@ fun getSomething() = 10
 
         project.build(":app:assembleDebug", options = options) {
             assertSuccessful()
-            assertCompiledKotlinSources(project.relativize(
+            assertCompiledKotlinSources(
+                project.relativize(
                     androidModuleKt,
                     baseApplicationKt,
                     useBuildConfigJavaKt
-            ))
+                )
+            )
         }
     }
 
@@ -310,8 +321,10 @@ abstract class AbstractKotlinAndroidWithJackGradleTests(
     fun getEnvJDK_18() = System.getenv()["JDK_18"]
 
     override fun defaultBuildOptions() =
-            super.defaultBuildOptions().copy(androidHome = KotlinTestUtils.findAndroidSdk(),
+        super.defaultBuildOptions().copy(
-                    androidGradlePluginVersion = androidGradlePluginVersion, javaHome = File(getEnvJDK_18()))
+            androidHome = KotlinTestUtils.findAndroidSdk(),
+            androidGradlePluginVersion = androidGradlePluginVersion, javaHome = File(getEnvJDK_18())
+        )
 
     @Test
     fun testSimpleCompile() {

libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/kotlin/org/jetbrains/kotlin/gradle/BaseGradleIT.kt

@@ -223,12 +223,18 @@ abstract class BaseGradleIT {
 
         private fun getCompiledFiles(regex: Regex, output: String) = regex.findAll(output)
             .asIterable()
-                .flatMap { it.groups[1]!!.value.split(", ")
+            .flatMap {
-                .map { File(project.projectDir, it).canonicalFile } }
+                it.groups[1]!!.value.split(", ")
+                    .map { File(project.projectDir, it).canonicalFile }
+            }
 
         fun getCompiledKotlinSources(output: String) = getCompiledFiles(kotlinSourcesListRegex, output)
 
-        val compiledJavaSources: Iterable<File> by lazy { javaSourcesListRegex.findAll(output).asIterable().flatMap { it.groups[1]!!.value.split(" ").filter { it.endsWith(".java", ignoreCase = true) }.map { File(it).canonicalFile } } }
+        val compiledJavaSources: Iterable<File> by lazy {
+            javaSourcesListRegex.findAll(output).asIterable().flatMap {
+                it.groups[1]!!.value.split(" ").filter { it.endsWith(".java", ignoreCase = true) }.map { File(it).canonicalFile }
+            }
+        }
     }
 
     // Basically the same as `Project.build`, tells gradle to wait for debug on 5005 port
@@ -254,8 +260,7 @@ abstract class BaseGradleIT {
         val result = runProcess(cmd, projectDir, env, options)
         try {
             CompiledProject(this, result.output, result.exitCode).check()
-        }
+        } catch (t: Throwable) {
-        catch (t: Throwable) {
             // to prevent duplication of output
             if (!options.forceOutputToStdout) {
                 System.out.println(result.output)
@@ -370,10 +375,17 @@ abstract class BaseGradleIT {
         return this
     }
 
-    fun CompiledProject.assertContainFiles(expected: Iterable<String>, actual: Iterable<String>, messagePrefix: String = ""): CompiledProject {
+    fun CompiledProject.assertContainFiles(
+        expected: Iterable<String>,
+        actual: Iterable<String>,
+        messagePrefix: String = ""
+    ): CompiledProject {
         val expectedNormalized = expected.map(::normalizePath).toSortedSet()
         val actualNormalized = actual.map(::normalizePath).toSortedSet()
-        assertTrue(actualNormalized.containsAll(expectedNormalized), messagePrefix + "expected files: ${expectedNormalized.joinToString()}\n  !in actual files: ${actualNormalized.joinToString()}")
+        assertTrue(
+            actualNormalized.containsAll(expectedNormalized),
+            messagePrefix + "expected files: ${expectedNormalized.joinToString()}\n  !in actual files: ${actualNormalized.joinToString()}"
+        )
         return this
     }
 
@@ -412,7 +424,8 @@ abstract class BaseGradleIT {
     fun CompiledProject.assertCompiledKotlinSources(
         sources: Iterable<String>,
         weakTesting: Boolean = false,
-            tasks: List<String>) {
+        tasks: List<String>
+    ) {
         for (task in tasks) {
             assertCompiledKotlinSources(sources, weakTesting, getOutputForTask(task), suffix = " in task ${task}")
         }
@@ -428,8 +441,7 @@ abstract class BaseGradleIT {
         val actualSources = getCompiledKotlinSources(output).projectRelativePaths(this.project)
         return if (weakTesting) {
             assertContainFiles(expectedSources, actualSources, messagePrefix)
-        }
+        } else {
-        else {
             assertSameFiles(expectedSources, actualSources, messagePrefix)
         }
     }
@@ -496,7 +508,7 @@ abstract class BaseGradleIT {
             add("-Pkotlin_version=" + options.kotlinVersion)
             options.incremental?.let { add("-Pkotlin.incremental=$it") }
             options.usePreciseJavaTracking?.let { add("-Pkotlin.incremental.usePreciseJavaTracking=$it") }
-                options.androidGradlePluginVersion?.let { add("-Pandroid_tools_version=$it")}
+            options.androidGradlePluginVersion?.let { add("-Pandroid_tools_version=$it") }
             if (options.debug) {
                 add("-Dorg.gradle.debug=true")
             }

libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/kotlin/org/jetbrains/kotlin/gradle/BaseMultiGradleVersionIT.kt

@@ -7,7 +7,8 @@ import org.junit.runners.Parameterized.Parameters
 
 @RunWith(Parameterized::class)
 abstract class BaseMultiGradleVersionIT : BaseGradleIT() {
-    @Parameter lateinit var gradleVersionString: String
+    @Parameter
+    lateinit var gradleVersionString: String
 
     protected val gradleVersion get() = GradleVersionRequired.Exact(gradleVersionString)
 

libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/kotlin/org/jetbrains/kotlin/gradle/BuildCacheIT.kt

@@ -145,11 +145,13 @@ class BuildCacheIT : BaseGradleIT() {
             assertContains("Caching disabled for task ':kaptKotlin': 'Caching is disabled by default for kapt")
         }
 
-        File(projectDir, "build.gradle").appendText("\n" + """
+        File(projectDir, "build.gradle").appendText(
+            "\n" + """
             afterEvaluate {
                 kaptKotlin.useBuildCache = true
             }
-            """.trimIndent())
+            """.trimIndent()
+        )
 
         build("clean", "build") {
             assertSuccessful()

libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/kotlin/org/jetbrains/kotlin/gradle/BuildCacheRelocationIT.kt

@@ -31,7 +31,8 @@ class BuildCacheRelocationIT : BaseGradleIT() {
         super.defaultBuildOptions().copy(
             withBuildCache = true,
             androidGradlePluginVersion = "3.0.0",
-                    androidHome = KotlinTestUtils.findAndroidSdk())
+            androidHome = KotlinTestUtils.findAndroidSdk()
+        )
 
     @Parameterized.Parameter
     lateinit var testCase: TestCase
@@ -70,8 +71,7 @@ class BuildCacheRelocationIT : BaseGradleIT() {
                 assertEquals(firstOutputHashes, secondOutputHashes)
                 cacheableTaskNames.forEach { assertContains(":$it FROM-CACHE") }
             }
-        }
+        } finally {
-        finally {
             workingDir = originalWorkingDir
             workingDirs.forEach { it.deleteRecursively() }
         }
@@ -82,7 +82,8 @@ class BuildCacheRelocationIT : BaseGradleIT() {
         val cacheableTaskNames: List<String>,
         val projectDirectoryPrefix: String? = null,
         val outputRootPaths: List<String> = listOf("build"),
-            val initProject: Project.() -> Unit = { }) {
+        val initProject: Project.() -> Unit = { }
+    ) {
 
         override fun toString(): String = (projectDirectoryPrefix?.plus("/") ?: "") + projectName
 
@@ -96,12 +97,14 @@ class BuildCacheRelocationIT : BaseGradleIT() {
         @JvmStatic
         @Parameterized.Parameters(name = "project: {0}")
         fun testCases(): List<Array<TestCase>> = listOf(
-                TestCase("simpleProject",
+            TestCase(
+                "simpleProject",
                 cacheableTaskNames = listOf("compileKotlin", "compileTestKotlin")
             ),
             TestCase("simple", projectDirectoryPrefix = "kapt2",
                      cacheableTaskNames = listOf(
-                                 "kaptKotlin", "kaptGenerateStubsKotlin", "compileKotlin", "compileTestKotlin", "compileJava"),
+                         "kaptKotlin", "kaptGenerateStubsKotlin", "compileKotlin", "compileTestKotlin", "compileJava"
+                     ),
                      initProject = { File(projectDir, "build.gradle").appendText("\nkapt.useBuildCache = true") }
             ),
             TestCase("kotlin2JsDceProject",
@@ -120,7 +123,8 @@ class BuildCacheRelocationIT : BaseGradleIT() {
             TestCase("multiplatformProject",
                      cacheableTaskNames = listOf(
                          "lib:compileKotlinCommon", "libJvm:compileKotlin", "libJvm:compileTestKotlin",
-                                 "libJs:compileKotlin2Js", "libJs:compileTestKotlin2Js"),
+                         "libJs:compileKotlin2Js", "libJs:compileTestKotlin2Js"
+                     ),
                      outputRootPaths = listOf("lib", "libJvm", "libJs").map { "$it/build" }
             ),
             TestCase("AndroidProject",

libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/kotlin/org/jetbrains/kotlin/gradle/ClassFileIsRemovedIT.kt

@@ -41,7 +41,7 @@ class ClassFileIsRemovedIT : BaseGradleIT() {
         }
     }
 
-    fun doTest(buildOptions: BuildOptions, transformDummy: (File)->Unit) {
+    fun doTest(buildOptions: BuildOptions, transformDummy: (File) -> Unit) {
         val project = Project("kotlinInJavaRoot")
         project.build("build", options = buildOptions) {
             assertSuccessful()

libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/kotlin/org/jetbrains/kotlin/gradle/CoroutinesIT.kt

@@ -21,7 +21,7 @@ import org.jetbrains.kotlin.gradle.util.modify
 import org.junit.Test
 import java.io.File
 
-class CoroutinesIT: BaseGradleIT() {
+class CoroutinesIT : BaseGradleIT() {
     companion object {
         private const val LOCAL_PROPERTIES = "local.properties"
         private const val GRADLE_PROPERTIES = "gradle.properties"

libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/kotlin/org/jetbrains/kotlin/gradle/ExecutionStrategyIT.kt

@@ -9,8 +9,10 @@ class ExecutionStrategyJsIT : ExecutionStrategyIT() {
     override fun setupProject(project: Project) {
         super.setupProject(project)
         val buildGradle = File(project.projectDir, "app/build.gradle")
-        buildGradle.modify { it.replace("apply plugin: \"kotlin\"", "apply plugin: \"kotlin2js\"") +
+        buildGradle.modify {
-                "\ncompileKotlin2Js.kotlinOptions.outputFile = \"web/js/out.js\"" }
+            it.replace("apply plugin: \"kotlin\"", "apply plugin: \"kotlin2js\"") +
+                    "\ncompileKotlin2Js.kotlinOptions.outputFile = \"web/js/out.js\""
+        }
     }
 
     override fun CompiledProject.checkOutput() {

libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/kotlin/org/jetbrains/kotlin/gradle/IncrementalCompilationMultiProjectIT.kt

@@ -14,10 +14,12 @@ class IncrementalCompilationMultiProjectIT : BaseGradleIT() {
     }
 
     private fun androidBuildOptions() =
-            BuildOptions(withDaemon = true,
+        BuildOptions(
+            withDaemon = true,
             androidHome = KotlinTestUtils.findAndroidSdk(),
             androidGradlePluginVersion = ANDROID_GRADLE_PLUGIN_VERSION,
-                         incremental = true)
+            incremental = true
+        )
 
     override fun defaultBuildOptions(): BuildOptions =
         super.defaultBuildOptions().copy(withDaemon = true, incremental = true)
@@ -66,14 +68,16 @@ class IncrementalCompilationMultiProjectIT : BaseGradleIT() {
         }
 
         val aKt = project.projectDir.getFileByName("A.kt")
-        aKt.writeText("""
+        aKt.writeText(
+            """
 package bar
 
 open class A {
     fun a() {}
     fun newA() {}
 }
-""")
+"""
+        )
 
         project.build("build") {
             assertSuccessful()
@@ -97,7 +101,8 @@ open class A {
             assertFailed()
             val affectedSources = project.projectDir.getFilesByNames(
                 "B.kt", "barUseAB.kt", "barUseB.kt",
-                    "BB.kt", "fooCallUseAB.kt", "fooUseB.kt")
+                "BB.kt", "fooCallUseAB.kt", "fooUseB.kt"
+            )
             val relativePaths = project.relativize(affectedSources)
             assertCompiledKotlinSources(relativePaths, weakTesting = false)
         }
@@ -176,11 +181,13 @@ open class A {
 
         val libGroovySrcBar = File(lib, "src/main/groovy/bar").apply { mkdirs() }
         val groovyClass = File(libGroovySrcBar, "GroovyClass.groovy")
-        groovyClass.writeText("""
+        groovyClass.writeText(
+            """
             package bar
 
             class GroovyClass {}
-        """)
+        """
+        )
 
         project.build("build") {
             assertSuccessful()
@@ -273,19 +280,21 @@ abstract class IncrementalCompilationJavaChangesBase(val usePreciseJavaTracking:
 
     protected val trackedJavaClass = "TrackedJavaClass.java"
     private val javaClass = "JavaClass.java"
-    protected val changeBody: (String)->String = { it.replace("Hello, World!", "Hello, World!!!!")  }
+    protected val changeBody: (String) -> String = { it.replace("Hello, World!", "Hello, World!!!!") }
-    protected val changeSignature: (String)->String = { it.replace("String getString", "Object getString")  }
+    protected val changeSignature: (String) -> String = { it.replace("String getString", "Object getString") }
 
     @Test
     fun testModifySignatureJavaInLib() {
-        doTest(javaClass, changeBody,
+        doTest(
+            javaClass, changeBody,
             expectedAffectedSources = listOf("JavaClassChild.kt", "useJavaClass.kt", "useJavaClassFooMethodUsage.kt")
         )
     }
 
     @Test
     fun testModifyBodyJavaInLib() {
-        doTest(javaClass, changeBody,
+        doTest(
+            javaClass, changeBody,
             expectedAffectedSources = listOf("JavaClassChild.kt", "useJavaClass.kt", "useJavaClassFooMethodUsage.kt")
         )
     }
@@ -295,7 +304,7 @@ abstract class IncrementalCompilationJavaChangesBase(val usePreciseJavaTracking:
 
     protected fun doTest(
         fileToModify: String,
-            transformFile: (String)->String,
+        transformFile: (String) -> String,
         expectedAffectedSources: Collection<String>
     ) {
         val project = Project("incrementalMultiproject")

libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/kotlin/org/jetbrains/kotlin/gradle/Kapt3AndroidIT.kt

@@ -19,10 +19,12 @@ open class Kapt3AndroidIT : Kapt3BaseIT() {
         get() = "2.3.0"
 
     private fun androidBuildOptions() =
-            BuildOptions(withDaemon = true,
+        BuildOptions(
+            withDaemon = true,
             androidHome = KotlinTestUtils.findAndroidSdk(),
             androidGradlePluginVersion = androidGradlePluginVersion,
-                         freeCommandLineArgs = listOf("-Pkapt.verbose=true"))
+            freeCommandLineArgs = listOf("-Pkapt.verbose=true")
+        )
 
     override fun defaultBuildOptions() = androidBuildOptions()
 

libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/kotlin/org/jetbrains/kotlin/gradle/Kapt3IT.kt

@@ -129,9 +129,11 @@ open class Kapt3IT : Kapt3BaseIT() {
         Project("arguments", directoryPrefix = "kapt2").build("build") {
             assertSuccessful()
             assertKaptSuccessful()
-            assertContains("Options: {suffix=Customized, justColon=:, justEquals==, containsColon=a:b, " +
+            assertContains(
+                "Options: {suffix=Customized, justColon=:, justEquals==, containsColon=a:b, " +
                         "containsEquals=a=b, startsWithColon=:a, startsWithEquals==a, endsWithColon=a:, " +
-                    "endsWithEquals=a:, withSpace=a b c,")
+                        "endsWithEquals=a:, withSpace=a b c,"
+            )
             assertContains("-Xmaxerrs=500, -Xlint:all=-Xlint:all") // Javac options test
             assertFileExists("build/generated/source/kapt/main/example/TestClassCustomized.java")
             assertFileExists(kotlinClassesDir() + "example/TestClass.class")
@@ -252,7 +254,7 @@ open class Kapt3IT : Kapt3BaseIT() {
 
         // add annotation
         val exampleAnn = "@example.ExampleAnnotation "
-        internalDummyKt.modify { it.addBeforeSubstring(exampleAnn, "internal class InternalDummy")}
+        internalDummyKt.modify { it.addBeforeSubstring(exampleAnn, "internal class InternalDummy") }
 
         project.build("classes", options = options) {
             assertSuccessful()
@@ -260,7 +262,7 @@ open class Kapt3IT : Kapt3BaseIT() {
         }
 
         // remove annotation
-        internalDummyKt.modify { it.replace(exampleAnn, "")}
+        internalDummyKt.modify { it.replace(exampleAnn, "") }
 
         project.build("classes", options = options) {
             assertSuccessful()
@@ -391,8 +393,10 @@ open class Kapt3IT : Kapt3BaseIT() {
 
         project.build("build") {
             assertSuccessful()
-            assertNotContains(":example:kaptKotlin UP-TO-DATE",
+            assertNotContains(
-                              ":example:kaptGenerateStubsKotlin UP-TO-DATE")
+                ":example:kaptKotlin UP-TO-DATE",
+                ":example:kaptGenerateStubsKotlin UP-TO-DATE"
+            )
 
             assertContains("Additional warning message from AP")
         }

libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/kotlin/org/jetbrains/kotlin/gradle/KaptIT.kt

@@ -6,7 +6,7 @@ import org.jetbrains.kotlin.gradle.util.modify
 import org.junit.Test
 import java.io.File
 
-class KaptIT: BaseGradleIT() {
+class KaptIT : BaseGradleIT() {
 
     @Test
     fun testSimple() {

libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/kotlin/org/jetbrains/kotlin/gradle/KaptIncrementalIT.kt

@@ -11,7 +11,7 @@ class KaptIncrementalWithStubsIT : KaptIncrementalBaseIT(shouldUseStubs = true)
 
 class Kapt3Incremental : KaptIncrementalBaseIT(shouldUseStubs = false, useKapt3 = true)
 
-abstract class KaptIncrementalBaseIT(val shouldUseStubs: Boolean, val useKapt3: Boolean = false): BaseGradleIT() {
+abstract class KaptIncrementalBaseIT(val shouldUseStubs: Boolean, val useKapt3: Boolean = false) : BaseGradleIT() {
     init {
         if (useKapt3) {
             assert(!shouldUseStubs)
@@ -65,12 +65,16 @@ abstract class KaptIncrementalBaseIT(val shouldUseStubs: Boolean, val useKapt3:
 
         project.build("build") {
             assertSuccessful()
-            assertContains(":compileKotlin UP-TO-DATE",
+            assertContains(
-                           ":compileJava UP-TO-DATE")
+                ":compileKotlin UP-TO-DATE",
+                ":compileJava UP-TO-DATE"
+            )
 
             if (useKapt3) {
-                assertContains(":kaptKotlin UP-TO-DATE",
+                assertContains(
-                               ":kaptGenerateStubsKotlin UP-TO-DATE")
+                    ":kaptKotlin UP-TO-DATE",
+                    ":kaptGenerateStubsKotlin UP-TO-DATE"
+                )
             }
 
             if (shouldUseStubs) {
@@ -171,7 +175,7 @@ abstract class KaptIncrementalBaseIT(val shouldUseStubs: Boolean, val useKapt3:
             }
         }
 
-        with (project.projectDir) {
+        with(project.projectDir) {
             getFileByName("B.kt").delete()
             getFileByName("useB.kt").delete()
         }
@@ -222,14 +226,14 @@ abstract class KaptIncrementalBaseIT(val shouldUseStubs: Boolean, val useKapt3:
                 assertCompiledKotlinSources(project.relativize(bKt, useBKt), tasks = listOf("kaptGenerateStubsKotlin"))
 
                 // java removal is detected
-                assertCompiledKotlinSources(project.relativize(project.projectDir.allKotlinFiles()),
+                assertCompiledKotlinSources(
-                        tasks = listOf("compileKotlin"))
+                    project.relativize(project.projectDir.allKotlinFiles()),
-            }
+                    tasks = listOf("compileKotlin")
-            else if (shouldUseStubs) {
+                )
+            } else if (shouldUseStubs) {
                 // java removal is detected
                 assertCompiledKotlinSources(project.relativize(project.projectDir.allKotlinFiles()))
-            }
+            } else {
-            else {
                 val useBKt = project.projectDir.getFileByName("useB.kt")
                 assertCompiledKotlinSources(project.relativize(bKt, useBKt))
             }
@@ -262,8 +266,10 @@ abstract class KaptIncrementalBaseIT(val shouldUseStubs: Boolean, val useKapt3:
         weakTesting: Boolean = false
     ) {
         if (useKapt3) {
-            assertCompiledKotlinSources(sources, weakTesting,
+            assertCompiledKotlinSources(
-                    tasks = listOf("compileKotlin", "kaptGenerateStubsKotlin"))
+                sources, weakTesting,
+                tasks = listOf("compileKotlin", "kaptGenerateStubsKotlin")
+            )
         } else {
             assertCompiledKotlinSources(sources, weakTesting)
         }
@@ -271,8 +277,10 @@ abstract class KaptIncrementalBaseIT(val shouldUseStubs: Boolean, val useKapt3:
 
     private fun CompiledProject.assertKapt3FullyExecuted() {
         if (useKapt3) {
-            assertNotContains(":kaptKotlin UP-TO-DATE",
+            assertNotContains(
-                    ":kaptGenerateStubsKotlin UP-TO-DATE")
+                ":kaptKotlin UP-TO-DATE",
+                ":kaptGenerateStubsKotlin UP-TO-DATE"
+            )
         }
     }
 
@@ -300,8 +308,7 @@ abstract class KaptIncrementalBaseIT(val shouldUseStubs: Boolean, val useKapt3:
 
         if (shouldUseStubs) {
             assertContains(usingStubs)
-        }
+        } else {
-        else {
             assertNotContains(usingStubs)
         }
     }

libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/kotlin/org/jetbrains/kotlin/gradle/Kotlin2JsGradlePluginIT.kt

@@ -25,7 +25,8 @@ class Kotlin2JsGradlePluginIT : BaseGradleIT() {
                 ":libraryProject:compileKotlin2Js"
             )
 
-            listOf("mainProject/web/js/app.js",
+            listOf(
+                "mainProject/web/js/app.js",
                 "mainProject/web/js/lib/kotlin.js",
                 "libraryProject/build/kotlin2js/main/test-library.js",
                 "mainProject/web/js/app.js.map"
@@ -67,8 +68,10 @@ class Kotlin2JsGradlePluginIT : BaseGradleIT() {
             val jarPath = "build/libs/kotlin2JsNoOutputFileProject.jar"
             assertFileExists(jarPath)
             val jar = ZipFile(fileInWorkingDir(jarPath))
-            assertEquals(1, jar.entries().asSequence().count { it.name == "kotlin2JsNoOutputFileProject.js" },
+            assertEquals(
-                         "The jar should contain an entry `kotlin2JsNoOutputFileProject.js` with no duplicates")
+                1, jar.entries().asSequence().count { it.name == "kotlin2JsNoOutputFileProject.js" },
+                "The jar should contain an entry `kotlin2JsNoOutputFileProject.js` with no duplicates"
+            )
         }
     }
 
@@ -83,8 +86,10 @@ class Kotlin2JsGradlePluginIT : BaseGradleIT() {
             val jarPath = "build/libs/kotlin2JsModuleKind.jar"
             assertFileExists(jarPath)
             val jar = ZipFile(fileInWorkingDir(jarPath))
-            assertEquals(1, jar.entries().asSequence().count { it.name == "app.js" },
+            assertEquals(
-                         "The jar should contain an entry `app.js` with no duplicates")
+                1, jar.entries().asSequence().count { it.name == "app.js" },
+                "The jar should contain an entry `app.js` with no duplicates"
+            )
         }
     }
 
@@ -152,8 +157,10 @@ class Kotlin2JsGradlePluginIT : BaseGradleIT() {
             val jarPath = "build/libs/kotlin2JsProjectWithCustomSourceset-inttests.jar"
             assertFileExists(jarPath)
             val jar = ZipFile(fileInWorkingDir(jarPath))
-            assertEquals(1, jar.entries().asSequence().count { it.name == "module-inttests.js" },
+            assertEquals(
-                         "The jar should contain an entry `module-inttests.js` with no duplicates")
+                1, jar.entries().asSequence().count { it.name == "module-inttests.js" },
+                "The jar should contain an entry `module-inttests.js` with no duplicates"
+            )
         }
     }
 

libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/kotlin/org/jetbrains/kotlin/gradle/KotlinDaemonIT.kt

@@ -45,7 +45,11 @@ class KotlinDaemonIT : BaseGradleIT() {
             assert(createdSessions.size == 1) { "Created multiple sessions per build ${createdSessions.joinToString()}" }
 
             val existingSessions = output.findAllStringsPrefixed(EXISTING_SESSION_FILE_PREFIX)
-            Assert.assertArrayEquals("Existing sessions don't match created sessions for two module projects", createdSessions, existingSessions)
+            Assert.assertArrayEquals(
+                "Existing sessions don't match created sessions for two module projects",
+                createdSessions,
+                existingSessions
+            )
 
             val deletedSessions = output.findAllStringsPrefixed(DELETED_SESSION_FILE_PREFIX)
             Assert.assertArrayEquals("Deleted sessions don't match created sessions", createdSessions, deletedSessions)

libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/kotlin/org/jetbrains/kotlin/gradle/KotlinGradlePluginIT.kt

@@ -28,7 +28,7 @@ import kotlin.test.assertNotEquals
 import kotlin.test.assertNotNull
 import kotlin.test.assertTrue
 
-class KotlinGradleIT: BaseGradleIT() {
+class KotlinGradleIT : BaseGradleIT() {
 
     @Test
     fun testCrossCompile() {
@@ -42,7 +42,12 @@ class KotlinGradleIT: BaseGradleIT() {
 
         project.build("compileDeployKotlin", "build") {
             assertSuccessful()
-            assertContains(":compileKotlin UP-TO-DATE", ":compileTestKotlin UP-TO-DATE", ":compileDeployKotlin UP-TO-DATE", ":compileJava UP-TO-DATE")
+            assertContains(
+                ":compileKotlin UP-TO-DATE",
+                ":compileTestKotlin UP-TO-DATE",
+                ":compileDeployKotlin UP-TO-DATE",
+                ":compileJava UP-TO-DATE"
+            )
         }
     }
 
@@ -131,15 +136,16 @@ class KotlinGradleIT: BaseGradleIT() {
             val totalMaximum = usedMemory.max()!!
 
             val maxGrowth = totalMaximum - establishedMaximum
-            assertTrue(maxGrowth <= MEMORY_MAX_GROWTH_LIMIT_KB,
+            assertTrue(
-                    "Maximum used memory over series of builds growth $maxGrowth (from $establishedMaximum to $totalMaximum) kb > $MEMORY_MAX_GROWTH_LIMIT_KB kb")
+                maxGrowth <= MEMORY_MAX_GROWTH_LIMIT_KB,
+                "Maximum used memory over series of builds growth $maxGrowth (from $establishedMaximum to $totalMaximum) kb > $MEMORY_MAX_GROWTH_LIMIT_KB kb"
+            )
 
             // testing that nothing remains locked by daemon, see KT-9440
             project.build(userVariantArg, "clean", options = BaseGradleIT.BuildOptions(withDaemon = true)) {
                 assertSuccessful()
             }
-        }
+        } finally {
-        finally {
             exitTestDaemon()
         }
     }
@@ -194,8 +200,10 @@ class KotlinGradleIT: BaseGradleIT() {
         project.build("build", options = options) {
             assertSuccessful()
             assertNoWarnings()
-            val affectedSources = project.projectDir.getFilesByNames("Greeter.kt", "KotlinGreetingJoiner.kt",
+            val affectedSources = project.projectDir.getFilesByNames(
-                    "TestGreeter.kt", "TestKotlinGreetingJoiner.kt")
+                "Greeter.kt", "KotlinGreetingJoiner.kt",
+                "TestGreeter.kt", "TestKotlinGreetingJoiner.kt"
+            )
             assertCompiledKotlinSources(project.relativize(affectedSources), weakTesting = false)
         }
     }
@@ -520,7 +528,8 @@ class KotlinGradleIT: BaseGradleIT() {
                         apiVersion = '$apiVersion'
                     }
                 }
-            """.trimIndent())
+            """.trimIndent()
+            )
         }
 
         assert(buildGradleContentCopy.indexOf("languageVersion") < 0) { "build.gradle should not contain 'languageVersion'" }
@@ -606,16 +615,19 @@ class KotlinGradleIT: BaseGradleIT() {
             // Check that the Java source in a non-full-depth package structure was located correctly:
             checkBytecodeContains(
                 File(project.projectDir, kotlinClassesDir() + "my/pack/name/app/MyApp.class"),
-                    "my/pack/name/util/JUtil.util")
+                "my/pack/name/util/JUtil.util"
+            )
         }
     }
 
     @Test
     fun testDisableSeparateClassesDirs() {
 
-        fun CompiledProject.check(copyClassesToJavaOutput: Boolean?,
+        fun CompiledProject.check(
+            copyClassesToJavaOutput: Boolean?,
             expectBuildCacheWarning: Boolean,
-                                  expectGradleLowVersionWarning: Boolean) {
+            expectGradleLowVersionWarning: Boolean
+        ) {
 
             val separateDirPath = kotlinClassesDir() + "demo/KotlinGreetingJoiner.class"
             val singleDirPath = javaClassesDir() + "demo/KotlinGreetingJoiner.class"
@@ -645,20 +657,26 @@ class KotlinGradleIT: BaseGradleIT() {
 
         Project("simpleProject", GradleVersionRequired.Exact("4.0")).apply {
             build("build") {
-                check(copyClassesToJavaOutput = false,
+                check(
+                    copyClassesToJavaOutput = false,
                     expectBuildCacheWarning = false,
-                        expectGradleLowVersionWarning = false)
+                    expectGradleLowVersionWarning = false
+                )
             }
             File(projectDir, "build.gradle").appendText("\nkotlin.copyClassesToJavaOutput = true")
             build("clean", "build") {
-                check(copyClassesToJavaOutput = true,
+                check(
+                    copyClassesToJavaOutput = true,
                     expectBuildCacheWarning = false,
-                        expectGradleLowVersionWarning = false)
+                    expectGradleLowVersionWarning = false
+                )
             }
             build("clean", "build", options = defaultBuildOptions().copy(withBuildCache = true)) {
-                check(copyClassesToJavaOutput = true,
+                check(
+                    copyClassesToJavaOutput = true,
                     expectBuildCacheWarning = true,
-                        expectGradleLowVersionWarning = false)
+                    expectGradleLowVersionWarning = false
+                )
             }
             projectDir.deleteRecursively()
         }
@@ -667,9 +685,11 @@ class KotlinGradleIT: BaseGradleIT() {
             setupWorkingDir()
             File(projectDir, "build.gradle").appendText("\nkotlin.copyClassesToJavaOutput = true")
             build("build") {
-                check(copyClassesToJavaOutput = null,
+                check(
+                    copyClassesToJavaOutput = null,
                     expectBuildCacheWarning = false,
-                        expectGradleLowVersionWarning = true)
+                    expectGradleLowVersionWarning = true
+                )
             }
         }
     }
@@ -678,7 +698,8 @@ class KotlinGradleIT: BaseGradleIT() {
     fun testSrcDirTaskDependency() {
         Project("simpleProject", GradleVersionRequired.AtLeast("4.1")).apply {
             setupWorkingDir()
-            File(projectDir, "build.gradle").appendText("""${'\n'}
+            File(projectDir, "build.gradle").appendText(
+                """${'\n'}
                 task generateSources {
                     outputs.dir('generated')
                     doLast {
@@ -692,10 +713,13 @@ class KotlinGradleIT: BaseGradleIT() {
                     }
                 }
                 sourceSets.main.java.srcDir(tasks.generateSources)
-                """.trimIndent())
+                """.trimIndent()
-            File(projectDir, "src/main/kotlin/helloWorld.kt").appendText("""${'\n'}
+            )
+            File(projectDir, "src/main/kotlin/helloWorld.kt").appendText(
+                """${'\n'}
                 fun usageOfGeneratedSource() = test.TestClass()
-                """.trimIndent())
+                """.trimIndent()
+            )
 
             build("build") {
                 assertSuccessful()
@@ -712,7 +736,8 @@ class KotlinGradleIT: BaseGradleIT() {
             File(projectDir, additionalSrcDir).mkdirs()
             File(projectDir, "$additionalSrcDir/additionalSource.kt").writeText("fun hello() = 123")
 
-            File(projectDir, "build.gradle").appendText("""${'\n'}
+            File(projectDir, "build.gradle").appendText(
+                """${'\n'}
                 task sourcesJar(type: Jar) {
                     from sourceSets.main.allSource
                     classifier 'source'
@@ -720,7 +745,8 @@ class KotlinGradleIT: BaseGradleIT() {
                 }
 
                 sourceSets.main.kotlin.srcDir('$additionalSrcDir') // test that additional srcDir is included
-                """.trimIndent())
+                """.trimIndent()
+            )
 
             build("sourcesJar") {
                 assertSuccessful()

libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/kotlin/org/jetbrains/kotlin/gradle/KotlinGradlePluginMultiVersionIT.kt

@@ -113,7 +113,8 @@ class KotlinGradlePluginMultiVersionIT : BaseMultiGradleVersionIT() {
         }
     }
 
-    @Test fun testApplyPluginFromBuildSrc() {
+    @Test
+    fun testApplyPluginFromBuildSrc() {
         val project = Project("kotlinProjectWithBuildSrc", gradleVersion)
         project.setupWorkingDir()
         File(project.projectDir, "buildSrc/build.gradle").modify { it.replace("\$kotlin_version", KOTLIN_VERSION) }
@@ -135,8 +136,10 @@ class KotlinGradlePluginMultiVersionIT : BaseMultiGradleVersionIT() {
     fun testJavaLibraryCompatibility() {
         val project = Project("javaLibraryProject", gradleVersion)
 
-        Assume.assumeTrue("The java-library plugin is supported only in Gradle 3.4+ (current: $gradleVersion)",
+        Assume.assumeTrue(
-                project.testGradleVersionAtLeast("3.4"))
+            "The java-library plugin is supported only in Gradle 3.4+ (current: $gradleVersion)",
+            project.testGradleVersionAtLeast("3.4")
+        )
 
         val compileKotlinTasks = listOf(":libA:compileKotlin", ":libB:compileKotlin", ":app:compileKotlin")
         project.build("build") {

libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/kotlin/org/jetbrains/kotlin/gradle/MultiplatformGradleIT.kt

@@ -33,12 +33,14 @@ class MultiplatformGradleIT : BaseGradleIT() {
 
         project.build("build") {
             assertSuccessful()
-            assertContains(":lib:compileKotlinCommon",
+            assertContains(
+                ":lib:compileKotlinCommon",
                 ":lib:compileTestKotlinCommon",
                 ":libJvm:compileKotlin",
                 ":libJvm:compileTestKotlin",
                 ":libJs:compileKotlin2Js",
-                           ":libJs:compileTestKotlin2Js")
+                ":libJs:compileTestKotlin2Js"
+            )
             assertFileExists("lib/build/classes/kotlin/main/foo/PlatformClass.kotlin_metadata")
             assertFileExists("lib/build/classes/kotlin/test/foo/PlatformTest.kotlin_metadata")
             assertFileExists("libJvm/build/classes/kotlin/main/foo/PlatformClass.class")
@@ -74,7 +76,8 @@ class MultiplatformGradleIT : BaseGradleIT() {
 
             File(projectDir, "lib/build.gradle").appendText(
                 "\ncompileKotlinCommon.kotlinOptions.freeCompilerArgs = ['-Xno-inline']" +
-                    "\ncompileKotlinCommon.kotlinOptions.suppressWarnings = true")
+                        "\ncompileKotlinCommon.kotlinOptions.suppressWarnings = true"
+            )
 
             build("build") {
                 assertSuccessful()
@@ -205,7 +208,8 @@ class MultiplatformGradleIT : BaseGradleIT() {
     @Test
     fun testCommonModuleAsTransitiveDependency() = with(Project("multiplatformProject")) {
         setupWorkingDir()
-        gradleBuildScript("libJvm").appendText("""
+        gradleBuildScript("libJvm").appendText(
+            """
             ${'\n'}
             task printCompileConfiguration(type: DefaultTask) {
                 doFirst {
@@ -214,7 +218,8 @@ class MultiplatformGradleIT : BaseGradleIT() {
                     }
                 }
             }
-            """.trimIndent())
+            """.trimIndent()
+        )
 
         build("printCompileConfiguration") {
             assertSuccessful()
@@ -242,7 +247,8 @@ class MultiplatformGradleIT : BaseGradleIT() {
         setupWorkingDir()
         val successMarker = "Found JavaCompile task:"
 
-        gradleBuildScript("lib").appendText("\n" + """
+        gradleBuildScript("lib").appendText(
+            "\n" + """
             afterEvaluate {
                 println('$successMarker ' + tasks.getByName('compileJava').path)
                 println('$successMarker ' + tasks.getByName('compileTestJava').path)

libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/kotlin/org/jetbrains/kotlin/gradle/PluginsDslIT.kt

@@ -38,7 +38,8 @@ class PluginsDslIT : BaseGradleIT() {
             "org.jetbrains.kotlin.allopen.gradle.AllOpenGradleSubplugin",
             "org.jetbrains.kotlin.allopen.gradle.SpringGradleSubplugin",
             "org.jetbrains.kotlin.noarg.gradle.NoArgGradleSubplugin",
-                "org.jetbrains.kotlin.noarg.gradle.KotlinJpaSubplugin")
+            "org.jetbrains.kotlin.noarg.gradle.KotlinJpaSubplugin"
+        )
 
         project.build("build") {
             assertSuccessful()
@@ -97,10 +98,7 @@ class PluginsDslIT : BaseGradleIT() {
 private object MavenLocalUrlProvider {
     /** The URL that points to the Gradle's mavenLocal() repository. */
     val mavenLocalUrl by lazy {
-        val path = propertyMavenLocalRepoPath ?:
+        val path = propertyMavenLocalRepoPath ?: homeSettingsLocalRepoPath ?: m2HomeSettingsLocalRepoPath ?: defaultM2RepoPath
-                homeSettingsLocalRepoPath ?:
-                m2HomeSettingsLocalRepoPath ?:
-                defaultM2RepoPath
         File(path).toURI().toString()
     }
 

libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/kotlin/org/jetbrains/kotlin/gradle/SimpleKotlinGradleIT.kt

@@ -24,7 +24,12 @@ class SimpleKotlinGradleIT : BaseGradleIT() {
 
         project.build("compileDeployKotlin", "build") {
             assertSuccessful()
-            assertContains(":compileKotlin UP-TO-DATE", ":compileTestKotlin UP-TO-DATE", ":compileDeployKotlin UP-TO-DATE", ":compileJava UP-TO-DATE")
+            assertContains(
+                ":compileKotlin UP-TO-DATE",
+                ":compileTestKotlin UP-TO-DATE",
+                ":compileDeployKotlin UP-TO-DATE",
+                ":compileJava UP-TO-DATE"
+            )
         }
     }
 
@@ -60,6 +65,7 @@ class SimpleKotlinGradleIT : BaseGradleIT() {
             assertContains("This type is sealed")
         }
     }
+
     @Test
     fun testJvmTarget() {
         Project("jvmTarget").build("build") {
@@ -115,13 +121,17 @@ class SimpleKotlinGradleIT : BaseGradleIT() {
             assertTrue(openClass.exists())
             assertTrue(closedClass.exists())
 
-            checkBytecodeContains(openClass,
+            checkBytecodeContains(
+                openClass,
                 "public class test/OpenClass {",
-                    "public method()V")
+                "public method()V"
+            )
 
-            checkBytecodeContains(closedClass,
+            checkBytecodeContains(
+                closedClass,
                 "public final class test/ClosedClass {",
-                    "public final method()V")
+                "public final method()V"
+            )
         }
     }
 
@@ -136,13 +146,17 @@ class SimpleKotlinGradleIT : BaseGradleIT() {
             assertTrue(openClass.exists())
             assertTrue(closedClass.exists())
 
-            checkBytecodeContains(openClass,
+            checkBytecodeContains(
+                openClass,
                 "public class test/OpenClass {",
-                    "public method()V")
+                "public method()V"
+            )
 
-            checkBytecodeContains(closedClass,
+            checkBytecodeContains(
+                closedClass,
                 "public final class test/ClosedClass {",
-                    "public final method()V")
+                "public final method()V"
+            )
         }
     }
 

libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/kotlin/org/jetbrains/kotlin/gradle/UpToDatenessIT.kt

@@ -10,26 +10,36 @@ import java.io.File
 class UpToDateIT : BaseGradleIT() {
     @Test
     fun testLanguageVersionChange() {
-        testMutations(*propertyMutationChain("compileKotlin.kotlinOptions.languageVersion",
+        testMutations(
-                                             "null", "'1.1'", "'1.0'", "null"))
+            *propertyMutationChain(
+                "compileKotlin.kotlinOptions.languageVersion",
+                "null", "'1.1'", "'1.0'", "null"
+            )
+        )
     }
 
     @Test
     fun testApiVersionChange() {
-        testMutations(*propertyMutationChain("compileKotlin.kotlinOptions.apiVersion",
+        testMutations(
-                                             "null", "'1.1'", "'1.0'", "null"))
+            *propertyMutationChain(
+                "compileKotlin.kotlinOptions.apiVersion",
+                "null", "'1.1'", "'1.0'", "null"
+            )
+        )
     }
 
     @Test
     fun testOther() {
-        testMutations(emptyMutation,
+        testMutations(
+            emptyMutation,
             OptionMutation("compileKotlin.kotlinOptions.jvmTarget", "'1.6'", "'1.8'"),
             OptionMutation("compileKotlin.kotlinOptions.freeCompilerArgs", "[]", "['-Xallow-kotlin-package']"),
             OptionMutation("kotlin.experimental.coroutines", "'error'", "'enable'"),
             OptionMutation("archivesBaseName", "'someName'", "'otherName'"),
             subpluginOptionMutation,
             externalOutputMutation,
-                      compilerClasspathMutation)
+            compilerClasspathMutation
+        )
     }
 
     private fun testMutations(vararg mutations: ProjectMutation) {
@@ -44,8 +54,7 @@ class UpToDateIT : BaseGradleIT() {
                 try {
                     assertSuccessful()
                     it.checkAfterRebuild(this)
-                }
+                } catch (e: Throwable) {
-                catch (e: Throwable) {
                     throw RuntimeException("Mutation '${it.name}' has failed", e)
                 }
             }
@@ -103,11 +112,13 @@ class UpToDateIT : BaseGradleIT() {
         override val name: String get() = "subpluginOptionMutation"
 
         override fun initProject(project: Project) = with(project) {
-            buildGradle.appendText("\n" + """
+            buildGradle.appendText(
+                "\n" + """
                 buildscript { dependencies { classpath "org.jetbrains.kotlin:kotlin-allopen:${'$'}kotlin_version" } }
                 apply plugin: "kotlin-allopen"
                 allOpen { annotation("allopen.Foo"); annotation("allopen.Bar") }
-            """.trimIndent())
+            """.trimIndent()
+            )
         }
 
         override fun mutateProject(project: Project) = with(project) {

libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/kotlin/org/jetbrains/kotlin/gradle/util/fileUtil.kt

@@ -21,7 +21,7 @@ fun File.allJavaFiles(): Iterable<File> =
 fun File.allFilesWithExtension(ext: String): Iterable<File> =
     walk().filter { it.isFile && it.extension.equals(ext, ignoreCase = true) }.toList()
 
-fun File.modify(transform: (String)->String) {
+fun File.modify(transform: (String) -> String) {
     writeText(transform(readText()))
 }
 

libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/kotlin/org/jetbrains/kotlin/jps/BaseIncrementalGradleIT.kt

@@ -42,13 +42,15 @@ abstract class BaseIncrementalGradleIT : BaseGradleIT() {
             assertReportExists()
         }
 
-        val buildLogFile = buildLogFinder.findBuildLog(resourcesRoot) ?:
+        val buildLogFile =
-                throw IllegalStateException("build log file not found in $resourcesRoot")
+            buildLogFinder.findBuildLog(resourcesRoot) ?: throw IllegalStateException("build log file not found in $resourcesRoot")
         val buildLogSteps = parseTestBuildLog(buildLogFile)
-        val modifications = getModificationsToPerform(resourcesRoot,
+        val modifications = getModificationsToPerform(
+            resourcesRoot,
             moduleNames = null,
             allowNoFilesWithSuffixInTestData = false,
-                                                      touchPolicy = TouchPolicy.CHECKSUM)
+            touchPolicy = TouchPolicy.CHECKSUM
+        )
 
         assert(modifications.size == buildLogSteps.size) {
             "Modifications count (${modifications.size}) != expected build log steps count (${buildLogSteps.size})"
@@ -67,14 +69,17 @@ abstract class BaseIncrementalGradleIT : BaseGradleIT() {
         rebuildAndCompareOutput(rebuildSucceedExpected = buildLogSteps.last().compileSucceeded)
     }
 
-    private fun JpsTestProject.buildAndAssertStageResults(expected: BuildStep, options: BuildOptions = defaultBuildOptions(), weakTesting: Boolean = false) {
+    private fun JpsTestProject.buildAndAssertStageResults(
+        expected: BuildStep,
+        options: BuildOptions = defaultBuildOptions(),
+        weakTesting: Boolean = false
+    ) {
         build("build", options = options) {
             if (expected.compileSucceeded) {
                 assertSuccessful()
                 assertCompiledJavaSources(expected.compiledJavaFiles, weakTesting)
                 assertCompiledKotlinSources(expected.compiledKotlinFiles, weakTesting)
-            }
+            } else {
-            else {
                 assertFailed()
             }
         }

libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/kotlin/org/jetbrains/kotlin/jps/KotlinGradlePluginJpsParametrizedIT.kt

@@ -5,6 +5,7 @@ import org.junit.Test
 import org.junit.runner.RunWith
 import org.junit.runners.Parameterized
 import java.io.File
+
 @RunWith(Parameterized::class)
 class KotlinGradlePluginJpsParametrizedIT : BaseIncrementalGradleIT() {
 
@@ -23,10 +24,12 @@ class KotlinGradlePluginJpsParametrizedIT : BaseIncrementalGradleIT() {
     companion object {
 
         private val jpsResourcesPath = File("../../../jps-plugin/testData/incremental")
-        private val ignoredDirs = setOf(File(jpsResourcesPath, "cacheVersionChanged"),
+        private val ignoredDirs = setOf(
+            File(jpsResourcesPath, "cacheVersionChanged"),
             File(jpsResourcesPath, "changeIncrementalOption"),
             File(jpsResourcesPath, "custom"),
-                                        File(jpsResourcesPath, "lookupTracker"))
+            File(jpsResourcesPath, "lookupTracker")
+        )
         private val buildLogFinder = BuildLogFinder(isGradleEnabled = true)
 
         @Suppress("unused")