*/
@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')
    }

        def repo2 = mavenHttpRepo("repo2")
        def projectA1 = repo1.module('group', 'projectA', '1.1').publish()
        def projectA2 = repo2.module('group', 'projectA', '1.5').publish()

        executer.withArgument("-D${SOCKET_TIMEOUT_SYSTEM_PROPERTY}=1000")

        buildFile << createBuildFile(repo1.uri, repo2.uri)

        when:
        repo1.getModuleMetaData("group", "projectA").expectGet()

                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)
        }
    }

                'init.gradle'("""
                    // init script
                    ${this.instrument('"init"')}
                """)
            }
        }

        when:
        executer.withArgument('-Igradle/init.gradle')
        run 'help'

        then:
        def scripts = scriptDetails()
        scripts.size() == 2
        hasScript('init', scripts)

                }
            }
        """

        and:
        buildFile << junitBasedBuildScript()
        buildFile << addOpens()

        expect:
        executer.withArgument("--info")
        succeeds("test")
    }

    def "generated Gradle API JAR in custom Gradle user home is reused across multiple invocations"() {
        requireOwnGradleUserHomeDir()

        given:

        executer.inDirectory(dslDir).withArgument("-PmySkipTests")
        def result = succeeds("build")

        then:
        result.assertTaskSkipped(":test")

        when: "run second time to restore from configuration cache if it is enabled"
        executer.inDirectory(dslDir).withArgument("-PmySkipTests")
        def secondResult = succeeds("build")

        then: