when:
        buildFile << """
    gradle.taskGraph.beforeTask {
        throw new RuntimeException("beforeTask failure")
    }
    task test
"""
        then:
        fails('test')
        failure.assertHasDescription("Execution failed for task ':test'.")
                .assertHasCause("beforeTask failure")
                .assertHasFileName("Build file '${buildFile}'")
                .assertHasLineNumber(3)

        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++) {

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

        when:
        fails()

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

    }

    def "first included build can not see project plugins contributed to root by second included build"() {
        when:
        buildFile << """
            plugins {
                id("${build1.projectPluginId}")
            }
        """

        build1.buildFile.setText("""
            plugins {
                id("groovy-gradle-plugin")
                id("${build2.projectPluginId}")
            }

        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("""

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

    @Requires(UnitTestPreconditions.IsGroovy3)
    def "produces sensible error when bad code is supplied in component selection rule with Groovy 3"() {
        def lines = buildFile.readLines().size()
        buildFile << """
            dependencies {
                conf "org.utils:api:1.2"
            }

            configurations.all {
                resolutionStrategy {

        withLister([testA: [1, 2, 3]])
        given:
        repository {
            'org:testA:1'()
            'org:testA:2'()
            'org:testA:3'()
        }
        buildFile << """
            dependencies {
                conf "org:testA:+"
            }
        """

        when:
        repositoryInteractions {
            'org:testA:3' {
                expectResolve()