* {@code Pmd} tasks behave as expected.
 */
class PmdPluginToolchainsIntegrationTest extends AbstractPmdPluginVersionIntegrationTest implements JavaToolchainFixture {

    def setup() {
        executer.withArgument("--info")
    }

    def "uses jdk from toolchains set through java plugin"() {
        Assume.assumeTrue(fileLockingIssuesSolved())
        given:
        goodCode()
        def jdk = setupExecutorForToolchains()

            }
        """

        file("src/main/java/Thing.java") << """
            /** Some thing. */
            public class Thing { }
        """
        executer.withArgument("-Porg.gradle.java.installations.paths=" + jvm.javaHome.absolutePath)
    }

    def "can compile source and run JUnit tests using target Java version"() {
        given:

            }
         """

        and:
        file("src/main/cpp/includeIoStream.cpp") << """
            #include <stdio.h>
            #include <iostream>
        """

        when:
        executer.withArgument("--info")
        run 'mainSharedLibrary'

        then:
        output.contains("Found all include files for ':compileMainSharedLibraryMainCpp'")
    }

    @ToBeFixedForConfigurationCache

        if (JavaVersion.current().isJava9Compatible() && GradleContextualExecuter.isConfigCache()) {
            // For java.util.concurrent.CountDownLatch being serialized reflectively by configuration cache
            executer.withArgument('-Dorg.gradle.jvmargs=--add-opens java.base/java.util.concurrent=ALL-UNNAMED --add-opens java.base/java.util.concurrent.locks=ALL-UNNAMED')
        }

        buildFile << """

 */
@TargetCoverage({ CodeNarcCoverage.ALL })
class CodeNarcPluginToolchainsIntegrationTest extends MultiVersionIntegrationSpec implements JavaToolchainFixture {

    def setup() {
        executer.withArgument("--info")
    }

    def "uses jdk from toolchains set through java plugin"() {
        given:
        def jdk = setupExecutorForToolchains()
        assumeToolchainJdkIsCompatibleWithCodeNarcVersion(jdk.javaVersion)

                    enabled = true
                    url = "$url/"
                }
            }
        """
        executer.withBuildCacheEnabled().withArgument('--offline')

        when:
        succeeds("help")

        then:
        !result().remoteEnabled
    }

    def "remote build cache configuration details is not exposed when disabled"() {

        gradleExecuter.withStdinPipe() >> gradleExecuter
        gradleExecuter.withTasks(_) >> gradleExecuter
        gradleExecuter.withForceInteractive(_) >> gradleExecuter
        gradleExecuter.withArgument(_) >> gradleExecuter
        gradleExecuter.start() >> gradleHandle
        gradleHandle.getErrorOutput() >> ''
        gradleHandle.isRunning() >>> [true, false]
        gradleHandle
    }

            }

            test.${configureTestFramework}
            test.testLogging {
                showStandardStreams = true
            }
        """

        when:
        executer.withArgument('-i')
        succeeds('test')

        then:
        outputContains('message from foo')
    }

                doLast {
                    configurations.compileClasspath.files
                    $queries
                }
            }
        """
        executer.withArgument("--no-configuration-cache") // task uses Configuration API
        run ":populateCache"
        executer.stop()
        copyToReadOnlyCache()
        buildFile.setText("")

        buildFile << """

        List<File> includedBuilds = Lists.newArrayList(includedBuilds)
        includedBuilds.each {
            includeBuild(it)
        }
        for (String arg : arguments) {
            executer.withArgument(arg)
        }
    }

    protected void executed(String... tasks) {
        for (String task : tasks) {
            result.assertTaskExecuted(task)
        }
    }