buildFile << """
            configurations {
                a
                b
                b.resolve()
            }
            dependencies { a "a:b:c" }
        """
        expect: succeeds()
    }

    def "allows changing a non-empty configuration that does not affect a resolved configuration"() {
        buildFile << """
            configurations {

        buildFile << """
            javadoc {
                options.stylesheetFile = file('src/not-docs/custom.css')
            }
        """
        succeeds("javadoc")
        then:
        skipped(":javadoc")
    }

    def "can exclude a package by source path"() {
        buildFile << """
            plugins {
                id 'java'

        given:
        buildFile << """
            class Foo0 {
                static final byte[] MEMORY_HOG = new byte[10 * 1024 * 1024]
            }
            task myTask() {
                doLast {
                    println new Foo0()
                }
            }
        """

        expect:
        for(int i = 0; i < 35; i++) {

        given:
        file("input.txt") << "data"
        buildFile << adHocTaskWithInputs()

        expect:
        taskIsNotCached ':adHocTask'
    }

    def "ad hoc tasks are cached when explicitly requested"() {
        given:
        file("input.txt") << "data"
        buildFile << adHocTaskWithInputs()
        buildFile << 'adHocTask { outputs.cacheIf { true } }'

        expect:

        buildFile << """
    gradle.taskGraph.whenReady {
        throw new RuntimeException('broken')
    }
    task a
"""

        when:
        fails()

        then:
        failure.assertHasDescription("broken")
                .assertHasNoCause()
                .assertHasFileName("Build file '$buildFile'")
                .assertHasLineNumber(3)
    }

        fixture.assertStateLoaded()
    }

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

        void writeTo(TestFile buildFile) {
            buildFile << BuilderSupport.prettyPrint("""
                plugins {
                }

                ${sections.collect { it.generateSection(GradleDsl.GROOVY) }.join("\n                ")}
            """)
        }
    }

    class KotlinWriter {
        void writeTo(TestFile buildFile) {
            buildFile << BuilderSupport.prettyPrint("""

        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 buildC = singleProjectBuild('buildC') {
            buildFile << "apply plugin: 'java'"
        }
        includeBuild(buildC)

        buildA.buildFile << """
            dependencies {
                testImplementation 'org.test:buildC'
                testImplementation 'org.test:buildA' // self dependency
            }
        """
        buildB.buildFile << """
            dependencies {

import spock.lang.Issue

class DeferredTaskConfigurationIntegrationTest extends AbstractDeferredTaskDefinitionIntegrationTest {
    def "build logic can configure each task only when required"() {
        buildFile << '''
            tasks.register("task1", SomeTask).configure {
                println "Configure ${path}"
            }
            tasks.named("task1").configure {
                println "Configure again ${path}"