fixture.assertStateLoaded()
    }

    TestFile customType(TestFile dir) {
        def buildFile = dir.file("build.gradle")
        taskTypeWithInputFileCollection(buildFile)
        buildFile << """
            println "configuring project \$project.path"
            configurations {
                implementation {

        validateCompilationProblem(problems, buildFile)
        problems[0].failure.failure.message == "Could not compile build file '$buildFile.absolutePath'."
    }

    static void validateCompilationProblem(List<ProblemEvent> problems, TestFile buildFile) {
        problems.size() == 1
        problems[0].label.label == "Could not compile build file '$buildFile.absolutePath'."

    }

    def "can use GradleRunner to test"() {
        when:
        buildFile << gradleTestKitDependency()
        file("src/test/groovy/Test.groovy") << successfulSpockTest('Test')

        then:
        succeeds 'build'
    }

    def "can use GradleRunner to test concurrently"() {
        when:
        buildFile << gradleTestKitDependency() << """
            test {
                maxParallelForks = 3

    def setup() {
        executer.withArguments("-i")
        buildFile << """
            plugins {
                id("java-library")
            }
            tasks.withType(JavaCompile) {
                options.compilerArgs << '-Xlint:all,-options' << '-Werror'
            }
        """
        buildFile << compilerConfiguration()
    }

    def "can compile good code"() {
        given:

        buildFile << """
            // No plugins applied
            task compile(type: JavaCompile)
        """

        when:
        run("compile")

        then:
        result.assertTasksSkipped(":compile")
    }

    @Issue("GRADLE-3152")
    def "can use the task without applying java-base plugin"() {
        buildFile << """
            task compile(type: JavaCompile) {

    def "does nag when service is used indirectly via another service even if task declares service reference and feature preview is enabled"() {
        given:
        serviceImplementation()
        buildFile """
            abstract class WrapperService implements ${BuildService.name}<${BuildServiceParameters.None.name}> {
                @${ServiceReference.name}('counter')

    }

    @Issue("GRADLE-3312")
    def "can publish to a http repo via redirects"() {
        given:
        buildFile << publicationBuildWithoutCredentials(version, group, mavenRemoteRepo.uri)
        redirectServer.start()
        buildFile.text = publicationBuildWithoutCredentials(version, group, new URI("${redirectServer.uri}/repo"))

    public final BlockingHttpServer blockingServer = new BlockingHttpServer()

    def setup() {
        blockingServer.start()

        createDirs("a", "b")
        settingsFile << 'include "a", "b"'

        buildFile << """
            abstract class SerialPing extends DefaultTask {

                SerialPing() { outputs.upToDateWhen { false } }

                @TaskAction
                void ping() {

        given:
        buildFile << """
            tasks.register("some") {
                doFirst {
                    println(file("broken"))
                }
            }
        """

        when:
        configurationCacheFails ":some"

        then:
        failure.assertHasFileName("Build file '$buildFile'")
        failure.assertHasLineNumber(4)

import static org.gradle.util.internal.TextUtil.escapeString

class FileCollectionIntegrationTest extends AbstractIntegrationSpec implements TasksWithInputsAndOutputs {
    def "can use 'as' operator with #type"() {
        buildFile << """
            def fileCollection = files("input.txt")
            def castValue = fileCollection as $type
            println "Cast value: \$castValue (\${castValue.getClass().name})"