Do not reset fork options when using toolchains

tbroyer · tbroyer · commit c032f7da20f4 · 2021-07-04T14:17:51.000+02:00
Fixes #64
diff --git a/src/main/kotlin/net/ltgt/gradle/errorprone/ErrorPronePlugin.kt b/src/main/kotlin/net/ltgt/gradle/errorprone/ErrorPronePlugin.kt
@@ -92,11 +92,7 @@ Add a dependency to com.google.errorprone:javac with the appropriate version cor
 
         val noJavacDependencyNotified = AtomicBoolean()
         fun JavaCompile.configureErrorProneJavac() {
-            if (!options.isFork) {
-                options.isFork = true
-                // reset forkOptions in case they were configured
-                options.forkOptions = ForkOptions()
-            }
+            ensureForking()
             javacConfiguration.asPath.also {
                 if (it.isNotBlank()) {
                     options.forkOptions.jvmArgs!!.add("-Xbootclasspath/p:$it")
@@ -190,13 +186,20 @@ Add a dependency to com.google.errorprone:javac with the appropriate version cor
         }
     }
 
-    private fun JavaCompile.configureForJava16plus() {
-        // https://github.com/google/error-prone/issues/1157#issuecomment-769289564
+    private fun JavaCompile.ensureForking() {
         if (!options.isFork) {
             options.isFork = true
-            // reset forkOptions in case they were configured
-            options.forkOptions = ForkOptions()
+            // See org.gradle.api.internal.tasks.compile.AbstractJavaCompileSpecFactory#isCurrentVmOurToolchain
+            // reset forkOptions in case they were configured, but only when not using a toolchain
+            if (!HAS_TOOLCHAINS || !javaCompiler.isPresent) {
+                options.forkOptions = ForkOptions()
+            }
         }
+    }
+
+    private fun JavaCompile.configureForJava16plus() {
+        // https://github.com/google/error-prone/issues/1157#issuecomment-769289564
+        ensureForking()
         options.forkOptions.jvmArgs!!.addAll(JVM_ARGS_STRONG_ENCAPSULATION)
     }
 }
diff --git a/src/test/kotlin/net/ltgt/gradle/errorprone/Java8IntegrationTest.kt b/src/test/kotlin/net/ltgt/gradle/errorprone/Java8IntegrationTest.kt
@@ -52,6 +52,7 @@ class Java8IntegrationTest : AbstractPluginIntegrationTest() {
                 }
             }
             compileJava.finalizedBy(displayCompileJavaOptions)
+            compileJava.options.forkOptions.jvmArgs!!.add("-XshowSettings")
             """.trimIndent()
         )
         if (JavaVersion.current().isJava16Compatible && GradleVersion.version(testGradleVersion) < GradleVersion.version("7.0")) {
@@ -78,7 +79,8 @@ class Java8IntegrationTest : AbstractPluginIntegrationTest() {
             // then
             assertThat(result.task(":compileJava")?.outcome).isEqualTo(TaskOutcome.SUCCESS)
             assertThat(result.output).contains(NOT_FORKED)
-            assertThat(result.output).doesNotContain(JVM_ARG)
+            // Check that the configured jvm arg is preserved
+            assertThat(result.output).contains(jvmArg("-XshowSettings"))
         }
 
         // Test a forked task
@@ -96,7 +98,9 @@ class Java8IntegrationTest : AbstractPluginIntegrationTest() {
             // then
             assertThat(result.task(":compileJava")?.outcome).isEqualTo(TaskOutcome.SUCCESS)
             assertThat(result.output).contains(FORKED)
-            assertThat(result.output).doesNotContain(JVM_ARG)
+            assertThat(result.output).doesNotContain(JVM_ARG_BOOTCLASSPATH)
+            // Check that the configured jvm arg is preserved
+            assertThat(result.output).contains(jvmArg("-XshowSettings"))
         }
     }
 
@@ -131,6 +135,8 @@ class Java8IntegrationTest : AbstractPluginIntegrationTest() {
             assertThat(result.task(":compileJava")?.outcome).isEqualTo(TaskOutcome.SUCCESS)
             assertThat(result.output).contains(FORKED)
             assertThat(result.output).contains(JVM_ARGS_STRONG_ENCAPSULATION)
+            // Check that the configured jvm arg is removed
+            assertThat(result.output).doesNotContain(jvmArg("-XshowSettings"))
         }
 
         // check that it doesn't mess with task avoidance
@@ -160,7 +166,9 @@ class Java8IntegrationTest : AbstractPluginIntegrationTest() {
         // then
         assertThat(result.task(":compileJava")?.outcome).isEqualTo(TaskOutcome.SUCCESS)
         assertThat(result.output).contains(NOT_FORKED)
-        assertThat(result.output).doesNotContain(JVM_ARG)
+        assertThat(result.output).doesNotContain(JVM_ARG_BOOTCLASSPATH)
+        // Check that the configured jvm arg is preserved
+        assertThat(result.output).contains(jvmArg("-XshowSettings"))
     }
 
     @Test
@@ -173,7 +181,6 @@ class Java8IntegrationTest : AbstractPluginIntegrationTest() {
 
             compileJava.apply {
                 options.isFork = true
-                options.forkOptions.jvmArgs!!.add("-XshowSettings")
             }
             """.trimIndent()
         )
@@ -219,7 +226,9 @@ class Java8IntegrationTest : AbstractPluginIntegrationTest() {
         // then
         assertThat(result.task(":compileJava")?.outcome).isNotNull()
         assertThat(result.output).contains(FORKED)
-        assertThat(result.output).doesNotContain(JVM_ARG)
+        assertThat(result.output).doesNotContain(JVM_ARG_BOOTCLASSPATH)
+        // Check that the configured jvm arg is preserved
+        assertThat(result.output).contains(jvmArg("-XshowSettings"))
     }
 
     @Test
@@ -258,6 +267,8 @@ class Java8IntegrationTest : AbstractPluginIntegrationTest() {
         assertThat(result.task(":compileJava")?.outcome).isNotNull()
         assertThat(result.output).contains(FORKED)
         assertThat(result.output).doesNotContain(JVM_ARG_BOOTCLASSPATH)
+        // Check that the configured jvm arg is preserved
+        assertThat(result.output).contains(jvmArg("-XshowSettings"))
     }
 
     @Test
@@ -279,6 +290,8 @@ class Java8IntegrationTest : AbstractPluginIntegrationTest() {
             assertThat(result.output).contains(ErrorPronePlugin.NO_JAVAC_DEPENDENCY_WARNING_MESSAGE)
             assertThat(result.output).contains(FORKED)
             assertThat(result.output).doesNotContain(JVM_ARG_BOOTCLASSPATH)
+            // Check that the configured jvm arg is removed
+            assertThat(result.output).doesNotContain(jvmArg("-XshowSettings"))
         }
 
         // check that adding back the dependency fixes compilation (so it was indeed caused by missing dependency) and silences the warning
@@ -300,6 +313,8 @@ class Java8IntegrationTest : AbstractPluginIntegrationTest() {
             assertThat(result.output).doesNotContain(ErrorPronePlugin.NO_JAVAC_DEPENDENCY_WARNING_MESSAGE)
             assertThat(result.output).contains(FORKED)
             assertThat(result.output).containsMatch(JVM_ARG_BOOTCLASSPATH_ERRORPRONE_JAVAC)
+            // Check that the configured jvm arg is removed
+            assertThat(result.output).doesNotContain(jvmArg("-XshowSettings"))
         }
     }
 
@@ -354,6 +369,8 @@ class Java8IntegrationTest : AbstractPluginIntegrationTest() {
             assertThat(result.task(":compileJava")?.outcome).isEqualTo(TaskOutcome.SUCCESS)
             assertThat(result.output).contains(FORKED)
             assertThat(result.output).containsMatch(JVM_ARG_BOOTCLASSPATH_ERRORPRONE_JAVAC)
+            // Check that the configured jvm arg is removed
+            assertThat(result.output).doesNotContain(jvmArg("-XshowSettings"))
         }
 
         // Move the errorproneJavac dependency: first remove it, then add it back… differently
diff --git a/src/test/kotlin/net/ltgt/gradle/errorprone/ToolchainsIntegrationTest.kt b/src/test/kotlin/net/ltgt/gradle/errorprone/ToolchainsIntegrationTest.kt
@@ -68,6 +68,7 @@ class ToolchainsIntegrationTest : AbstractPluginIntegrationTest() {
                 }
                 compileJava {
                     finalizedBy(displayCompileJavaOptions)
+                    options.forkOptions.jvmArgs!!.add("-XshowSettings")
                 }
             }
             """.trimIndent()
@@ -164,7 +165,10 @@ class ToolchainsIntegrationTest : AbstractPluginIntegrationTest() {
             result.assumeToolchainAvailable()
             assertThat(result.task(":compileJava")?.outcome).isEqualTo(TaskOutcome.SUCCESS)
             assertThat(result.output).contains(NOT_FORKED)
-            assertThat(result.output).doesNotContain(JVM_ARG)
+            assertThat(result.output).doesNotContain(JVM_ARG_BOOTCLASSPATH)
+            assertThat(result.output).doesNotContain(JVM_ARGS_STRONG_ENCAPSULATION)
+            // Check that the configured jvm arg is preserved
+            assertThat(result.output).contains(jvmArg("-XshowSettings"))
         }
 
         // Test a forked task
@@ -183,7 +187,10 @@ class ToolchainsIntegrationTest : AbstractPluginIntegrationTest() {
             result.assumeToolchainAvailable()
             assertThat(result.task(":compileJava")?.outcome).isEqualTo(TaskOutcome.SUCCESS)
             assertThat(result.output).contains(FORKED)
-            assertThat(result.output).doesNotContain(JVM_ARG)
+            assertThat(result.output).doesNotContain(JVM_ARG_BOOTCLASSPATH)
+            assertThat(result.output).doesNotContain(JVM_ARGS_STRONG_ENCAPSULATION)
+            // Check that the configured jvm arg is preserved
+            assertThat(result.output).contains(jvmArg("-XshowSettings"))
         }
     }
 
@@ -208,6 +215,8 @@ class ToolchainsIntegrationTest : AbstractPluginIntegrationTest() {
             assertThat(result.task(":compileJava")?.outcome).isEqualTo(TaskOutcome.SUCCESS)
             assertThat(result.output).contains(FORKED)
             assertThat(result.output).containsMatch(JVM_ARG_BOOTCLASSPATH_ERRORPRONE_JAVAC)
+            // Check that the configured jvm arg is preserved
+            assertThat(result.output).contains(jvmArg("-XshowSettings"))
         }
 
         // check that it doesn't mess with task avoidance
@@ -241,6 +250,8 @@ class ToolchainsIntegrationTest : AbstractPluginIntegrationTest() {
             assertThat(result.task(":compileJava")?.outcome).isEqualTo(TaskOutcome.SUCCESS)
             assertThat(result.output).contains(FORKED)
             assertThat(result.output).contains(JVM_ARGS_STRONG_ENCAPSULATION)
+            // Check that the configured jvm arg is preserved
+            assertThat(result.output).contains(jvmArg("-XshowSettings"))
         }
 
         // check that it doesn't mess with task avoidance
@@ -276,7 +287,10 @@ class ToolchainsIntegrationTest : AbstractPluginIntegrationTest() {
         result.assumeToolchainAvailable()
         assertThat(result.task(":compileJava")?.outcome).isEqualTo(TaskOutcome.SUCCESS)
         assertThat(result.output).contains(NOT_FORKED)
-        assertThat(result.output).doesNotContain(JVM_ARG)
+        assertThat(result.output).doesNotContain(JVM_ARG_BOOTCLASSPATH)
+        assertThat(result.output).doesNotContain(JVM_ARGS_STRONG_ENCAPSULATION)
+        // Check that the configured jvm arg is preserved
+        assertThat(result.output).contains(jvmArg("-XshowSettings"))
     }
 
     @Test
@@ -313,7 +327,10 @@ class ToolchainsIntegrationTest : AbstractPluginIntegrationTest() {
         result.assumeToolchainAvailable()
         assertThat(result.task(":compileJava")?.outcome).isEqualTo(TaskOutcome.SUCCESS)
         assertThat(result.output).contains(NOT_FORKED)
-        assertThat(result.output).doesNotContain(JVM_ARG)
+        assertThat(result.output).doesNotContain(JVM_ARG_BOOTCLASSPATH)
+        assertThat(result.output).doesNotContain(JVM_ARGS_STRONG_ENCAPSULATION)
+        // Check that the configured jvm arg is preserved
+        assertThat(result.output).contains(jvmArg("-XshowSettings"))
     }
 
     @Test
@@ -330,7 +347,6 @@ class ToolchainsIntegrationTest : AbstractPluginIntegrationTest() {
 
             tasks.compileJava {
                 options.isFork = true
-                options.forkOptions.jvmArgs!!.add("-XshowSettings")
             }
             """.trimIndent()
         )
@@ -375,6 +391,8 @@ class ToolchainsIntegrationTest : AbstractPluginIntegrationTest() {
             assertThat(result.output).contains(ErrorPronePlugin.NO_JAVAC_DEPENDENCY_WARNING_MESSAGE)
             assertThat(result.output).contains(FORKED)
             assertThat(result.output).doesNotContain(JVM_ARG_BOOTCLASSPATH)
+            // Check that the configured jvm arg is preserved
+            assertThat(result.output).contains(jvmArg("-XshowSettings"))
         }
 
         // check that adding back the dependency fixes compilation (so it was indeed caused by missing dependency) and silences the warning
@@ -397,6 +415,8 @@ class ToolchainsIntegrationTest : AbstractPluginIntegrationTest() {
             assertThat(result.output).doesNotContain(ErrorPronePlugin.NO_JAVAC_DEPENDENCY_WARNING_MESSAGE)
             assertThat(result.output).contains(FORKED)
             assertThat(result.output).containsMatch(JVM_ARG_BOOTCLASSPATH_ERRORPRONE_JAVAC)
+            // Check that the configured jvm arg is preserved
+            assertThat(result.output).contains(jvmArg("-XshowSettings"))
         }
     }
 
@@ -427,6 +447,8 @@ class ToolchainsIntegrationTest : AbstractPluginIntegrationTest() {
             assertThat(result.task(":compileJava")?.outcome).isEqualTo(TaskOutcome.SUCCESS)
             assertThat(result.output).doesNotContain(ErrorPronePlugin.NO_JAVAC_DEPENDENCY_WARNING_MESSAGE)
             assertThat(result.output).doesNotContain(JVM_ARG_BOOTCLASSPATH)
+            // Check that the configured jvm arg is preserved
+            assertThat(result.output).contains(jvmArg("-XshowSettings"))
         }
     }
 }

Original file line number	Diff line number	Diff line change
`@@ -52,6 +52,7 @@ class Java8IntegrationTest : AbstractPluginIntegrationTest() {`
`52`	`52`	`}`
`53`	`53`	`}`
`54`	`54`	`compileJava.finalizedBy(displayCompileJavaOptions)`
	`55`	`+ compileJava.options.forkOptions.jvmArgs!!.add("-XshowSettings")`
`55`	`56`	`""".trimIndent()`
`56`	`57`	`)`
`57`	`58`	`if (JavaVersion.current().isJava16Compatible && GradleVersion.version(testGradleVersion) < GradleVersion.version("7.0")) {`
`@@ -78,7 +79,8 @@ class Java8IntegrationTest : AbstractPluginIntegrationTest() {`
`78`	`79`	`// then`
`79`	`80`	`assertThat(result.task(":compileJava")?.outcome).isEqualTo(TaskOutcome.SUCCESS)`
`80`	`81`	`assertThat(result.output).contains(NOT_FORKED)`
`81`		`- assertThat(result.output).doesNotContain(JVM_ARG)`
	`82`	`+ // Check that the configured jvm arg is preserved`
	`83`	`+ assertThat(result.output).contains(jvmArg("-XshowSettings"))`
`82`	`84`	`}`
`83`	`85`
`84`	`86`	`// Test a forked task`
`@@ -96,7 +98,9 @@ class Java8IntegrationTest : AbstractPluginIntegrationTest() {`
`96`	`98`	`// then`
`97`	`99`	`assertThat(result.task(":compileJava")?.outcome).isEqualTo(TaskOutcome.SUCCESS)`
`98`	`100`	`assertThat(result.output).contains(FORKED)`
`99`		`- assertThat(result.output).doesNotContain(JVM_ARG)`
	`101`	`+ assertThat(result.output).doesNotContain(JVM_ARG_BOOTCLASSPATH)`
	`102`	`+ // Check that the configured jvm arg is preserved`
	`103`	`+ assertThat(result.output).contains(jvmArg("-XshowSettings"))`
`100`	`104`	`}`
`101`	`105`	`}`
`102`	`106`
`@@ -131,6 +135,8 @@ class Java8IntegrationTest : AbstractPluginIntegrationTest() {`
`131`	`135`	`assertThat(result.task(":compileJava")?.outcome).isEqualTo(TaskOutcome.SUCCESS)`
`132`	`136`	`assertThat(result.output).contains(FORKED)`
`133`	`137`	`assertThat(result.output).contains(JVM_ARGS_STRONG_ENCAPSULATION)`
	`138`	`+ // Check that the configured jvm arg is removed`
	`139`	`+ assertThat(result.output).doesNotContain(jvmArg("-XshowSettings"))`
`134`	`140`	`}`
`135`	`141`
`136`	`142`	`// check that it doesn't mess with task avoidance`
`@@ -160,7 +166,9 @@ class Java8IntegrationTest : AbstractPluginIntegrationTest() {`
`160`	`166`	`// then`
`161`	`167`	`assertThat(result.task(":compileJava")?.outcome).isEqualTo(TaskOutcome.SUCCESS)`
`162`	`168`	`assertThat(result.output).contains(NOT_FORKED)`
`163`		`- assertThat(result.output).doesNotContain(JVM_ARG)`
	`169`	`+ assertThat(result.output).doesNotContain(JVM_ARG_BOOTCLASSPATH)`
	`170`	`+ // Check that the configured jvm arg is preserved`
	`171`	`+ assertThat(result.output).contains(jvmArg("-XshowSettings"))`
`164`	`172`	`}`
`165`	`173`
`166`	`174`	`@Test`
`@@ -173,7 +181,6 @@ class Java8IntegrationTest : AbstractPluginIntegrationTest() {`
`173`	`181`
`174`	`182`	`compileJava.apply {`
`175`	`183`	`options.isFork = true`
`176`		`- options.forkOptions.jvmArgs!!.add("-XshowSettings")`
`177`	`184`	`}`
`178`	`185`	`""".trimIndent()`
`179`	`186`	`)`
`@@ -219,7 +226,9 @@ class Java8IntegrationTest : AbstractPluginIntegrationTest() {`
`219`	`226`	`// then`
`220`	`227`	`assertThat(result.task(":compileJava")?.outcome).isNotNull()`
`221`	`228`	`assertThat(result.output).contains(FORKED)`
`222`		`- assertThat(result.output).doesNotContain(JVM_ARG)`
	`229`	`+ assertThat(result.output).doesNotContain(JVM_ARG_BOOTCLASSPATH)`
	`230`	`+ // Check that the configured jvm arg is preserved`
	`231`	`+ assertThat(result.output).contains(jvmArg("-XshowSettings"))`
`223`	`232`	`}`
`224`	`233`
`225`	`234`	`@Test`
`@@ -258,6 +267,8 @@ class Java8IntegrationTest : AbstractPluginIntegrationTest() {`
`258`	`267`	`assertThat(result.task(":compileJava")?.outcome).isNotNull()`
`259`	`268`	`assertThat(result.output).contains(FORKED)`
`260`	`269`	`assertThat(result.output).doesNotContain(JVM_ARG_BOOTCLASSPATH)`
	`270`	`+ // Check that the configured jvm arg is preserved`
	`271`	`+ assertThat(result.output).contains(jvmArg("-XshowSettings"))`
`261`	`272`	`}`
`262`	`273`
`263`	`274`	`@Test`
`@@ -279,6 +290,8 @@ class Java8IntegrationTest : AbstractPluginIntegrationTest() {`
`279`	`290`	`assertThat(result.output).contains(ErrorPronePlugin.NO_JAVAC_DEPENDENCY_WARNING_MESSAGE)`
`280`	`291`	`assertThat(result.output).contains(FORKED)`
`281`	`292`	`assertThat(result.output).doesNotContain(JVM_ARG_BOOTCLASSPATH)`
	`293`	`+ // Check that the configured jvm arg is removed`
	`294`	`+ assertThat(result.output).doesNotContain(jvmArg("-XshowSettings"))`
`282`	`295`	`}`
`283`	`296`
`284`	`297`	`// check that adding back the dependency fixes compilation (so it was indeed caused by missing dependency) and silences the warning`
`@@ -300,6 +313,8 @@ class Java8IntegrationTest : AbstractPluginIntegrationTest() {`
`300`	`313`	`assertThat(result.output).doesNotContain(ErrorPronePlugin.NO_JAVAC_DEPENDENCY_WARNING_MESSAGE)`
`301`	`314`	`assertThat(result.output).contains(FORKED)`
`302`	`315`	`assertThat(result.output).containsMatch(JVM_ARG_BOOTCLASSPATH_ERRORPRONE_JAVAC)`
	`316`	`+ // Check that the configured jvm arg is removed`
	`317`	`+ assertThat(result.output).doesNotContain(jvmArg("-XshowSettings"))`
`303`	`318`	`}`
`304`	`319`	`}`
`305`	`320`
`@@ -354,6 +369,8 @@ class Java8IntegrationTest : AbstractPluginIntegrationTest() {`
`354`	`369`	`assertThat(result.task(":compileJava")?.outcome).isEqualTo(TaskOutcome.SUCCESS)`
`355`	`370`	`assertThat(result.output).contains(FORKED)`
`356`	`371`	`assertThat(result.output).containsMatch(JVM_ARG_BOOTCLASSPATH_ERRORPRONE_JAVAC)`
	`372`	`+ // Check that the configured jvm arg is removed`
	`373`	`+ assertThat(result.output).doesNotContain(jvmArg("-XshowSettings"))`
`357`	`374`	`}`
`358`	`375`
`359`	`376`	`// Move the errorproneJavac dependency: first remove it, then add it back… differently`
Original file line number	Diff line number	Diff line change
`@@ -68,6 +68,7 @@ class ToolchainsIntegrationTest : AbstractPluginIntegrationTest() {`
`68`	`68`	`}`
`69`	`69`	`compileJava {`
`70`	`70`	`finalizedBy(displayCompileJavaOptions)`
	`71`	`+ options.forkOptions.jvmArgs!!.add("-XshowSettings")`
`71`	`72`	`}`
`72`	`73`	`}`
`73`	`74`	`""".trimIndent()`
`@@ -164,7 +165,10 @@ class ToolchainsIntegrationTest : AbstractPluginIntegrationTest() {`
`164`	`165`	`result.assumeToolchainAvailable()`
`165`	`166`	`assertThat(result.task(":compileJava")?.outcome).isEqualTo(TaskOutcome.SUCCESS)`
`166`	`167`	`assertThat(result.output).contains(NOT_FORKED)`
`167`		`- assertThat(result.output).doesNotContain(JVM_ARG)`
	`168`	`+ assertThat(result.output).doesNotContain(JVM_ARG_BOOTCLASSPATH)`
	`169`	`+ assertThat(result.output).doesNotContain(JVM_ARGS_STRONG_ENCAPSULATION)`
	`170`	`+ // Check that the configured jvm arg is preserved`
	`171`	`+ assertThat(result.output).contains(jvmArg("-XshowSettings"))`
`168`	`172`	`}`
`169`	`173`
`170`	`174`	`// Test a forked task`
`@@ -183,7 +187,10 @@ class ToolchainsIntegrationTest : AbstractPluginIntegrationTest() {`
`183`	`187`	`result.assumeToolchainAvailable()`
`184`	`188`	`assertThat(result.task(":compileJava")?.outcome).isEqualTo(TaskOutcome.SUCCESS)`
`185`	`189`	`assertThat(result.output).contains(FORKED)`
`186`		`- assertThat(result.output).doesNotContain(JVM_ARG)`
	`190`	`+ assertThat(result.output).doesNotContain(JVM_ARG_BOOTCLASSPATH)`
	`191`	`+ assertThat(result.output).doesNotContain(JVM_ARGS_STRONG_ENCAPSULATION)`
	`192`	`+ // Check that the configured jvm arg is preserved`
	`193`	`+ assertThat(result.output).contains(jvmArg("-XshowSettings"))`
`187`	`194`	`}`
`188`	`195`	`}`
`189`	`196`
`@@ -208,6 +215,8 @@ class ToolchainsIntegrationTest : AbstractPluginIntegrationTest() {`
`208`	`215`	`assertThat(result.task(":compileJava")?.outcome).isEqualTo(TaskOutcome.SUCCESS)`
`209`	`216`	`assertThat(result.output).contains(FORKED)`
`210`	`217`	`assertThat(result.output).containsMatch(JVM_ARG_BOOTCLASSPATH_ERRORPRONE_JAVAC)`
	`218`	`+ // Check that the configured jvm arg is preserved`
	`219`	`+ assertThat(result.output).contains(jvmArg("-XshowSettings"))`
`211`	`220`	`}`
`212`	`221`
`213`	`222`	`// check that it doesn't mess with task avoidance`
`@@ -241,6 +250,8 @@ class ToolchainsIntegrationTest : AbstractPluginIntegrationTest() {`
`241`	`250`	`assertThat(result.task(":compileJava")?.outcome).isEqualTo(TaskOutcome.SUCCESS)`
`242`	`251`	`assertThat(result.output).contains(FORKED)`
`243`	`252`	`assertThat(result.output).contains(JVM_ARGS_STRONG_ENCAPSULATION)`
	`253`	`+ // Check that the configured jvm arg is preserved`
	`254`	`+ assertThat(result.output).contains(jvmArg("-XshowSettings"))`
`244`	`255`	`}`
`245`	`256`
`246`	`257`	`// check that it doesn't mess with task avoidance`
`@@ -276,7 +287,10 @@ class ToolchainsIntegrationTest : AbstractPluginIntegrationTest() {`
`276`	`287`	`result.assumeToolchainAvailable()`
`277`	`288`	`assertThat(result.task(":compileJava")?.outcome).isEqualTo(TaskOutcome.SUCCESS)`
`278`	`289`	`assertThat(result.output).contains(NOT_FORKED)`
`279`		`- assertThat(result.output).doesNotContain(JVM_ARG)`
	`290`	`+ assertThat(result.output).doesNotContain(JVM_ARG_BOOTCLASSPATH)`
	`291`	`+ assertThat(result.output).doesNotContain(JVM_ARGS_STRONG_ENCAPSULATION)`
	`292`	`+ // Check that the configured jvm arg is preserved`
	`293`	`+ assertThat(result.output).contains(jvmArg("-XshowSettings"))`
`280`	`294`	`}`
`281`	`295`
`282`	`296`	`@Test`
`@@ -313,7 +327,10 @@ class ToolchainsIntegrationTest : AbstractPluginIntegrationTest() {`
`313`	`327`	`result.assumeToolchainAvailable()`
`314`	`328`	`assertThat(result.task(":compileJava")?.outcome).isEqualTo(TaskOutcome.SUCCESS)`
`315`	`329`	`assertThat(result.output).contains(NOT_FORKED)`
`316`		`- assertThat(result.output).doesNotContain(JVM_ARG)`
	`330`	`+ assertThat(result.output).doesNotContain(JVM_ARG_BOOTCLASSPATH)`
	`331`	`+ assertThat(result.output).doesNotContain(JVM_ARGS_STRONG_ENCAPSULATION)`
	`332`	`+ // Check that the configured jvm arg is preserved`
	`333`	`+ assertThat(result.output).contains(jvmArg("-XshowSettings"))`
`317`	`334`	`}`
`318`	`335`
`319`	`336`	`@Test`
`@@ -330,7 +347,6 @@ class ToolchainsIntegrationTest : AbstractPluginIntegrationTest() {`
`330`	`347`
`331`	`348`	`tasks.compileJava {`
`332`	`349`	`options.isFork = true`
`333`		`- options.forkOptions.jvmArgs!!.add("-XshowSettings")`
`334`	`350`	`}`
`335`	`351`	`""".trimIndent()`
`336`	`352`	`)`
`@@ -375,6 +391,8 @@ class ToolchainsIntegrationTest : AbstractPluginIntegrationTest() {`
`375`	`391`	`assertThat(result.output).contains(ErrorPronePlugin.NO_JAVAC_DEPENDENCY_WARNING_MESSAGE)`
`376`	`392`	`assertThat(result.output).contains(FORKED)`
`377`	`393`	`assertThat(result.output).doesNotContain(JVM_ARG_BOOTCLASSPATH)`
	`394`	`+ // Check that the configured jvm arg is preserved`
	`395`	`+ assertThat(result.output).contains(jvmArg("-XshowSettings"))`
`378`	`396`	`}`
`379`	`397`
`380`	`398`	`// check that adding back the dependency fixes compilation (so it was indeed caused by missing dependency) and silences the warning`
`@@ -397,6 +415,8 @@ class ToolchainsIntegrationTest : AbstractPluginIntegrationTest() {`
`397`	`415`	`assertThat(result.output).doesNotContain(ErrorPronePlugin.NO_JAVAC_DEPENDENCY_WARNING_MESSAGE)`
`398`	`416`	`assertThat(result.output).contains(FORKED)`
`399`	`417`	`assertThat(result.output).containsMatch(JVM_ARG_BOOTCLASSPATH_ERRORPRONE_JAVAC)`
	`418`	`+ // Check that the configured jvm arg is preserved`
	`419`	`+ assertThat(result.output).contains(jvmArg("-XshowSettings"))`
`400`	`420`	`}`
`401`	`421`	`}`
`402`	`422`
`@@ -427,6 +447,8 @@ class ToolchainsIntegrationTest : AbstractPluginIntegrationTest() {`
`427`	`447`	`assertThat(result.task(":compileJava")?.outcome).isEqualTo(TaskOutcome.SUCCESS)`
`428`	`448`	`assertThat(result.output).doesNotContain(ErrorPronePlugin.NO_JAVAC_DEPENDENCY_WARNING_MESSAGE)`
`429`	`449`	`assertThat(result.output).doesNotContain(JVM_ARG_BOOTCLASSPATH)`
	`450`	`+ // Check that the configured jvm arg is preserved`
	`451`	`+ assertThat(result.output).contains(jvmArg("-XshowSettings"))`
`430`	`452`	`}`
`431`	`453`	`}`
`432`	`454`	`}`