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:

    @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 {

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

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

        buildFile << """
            allprojects {
                repositories {
                    maven { url '$mavenRepo.uri' }
                }
            }
        """
        createDirs("utils", "core")
        file('settings.gradle') << "include 'utils', 'core'"
        buildFile << '''
            apply plugin: 'java'

    }

    private static File withVariants(File buildFile) {
        buildFile << 'apply plugin: "java"\n'
        buildFile << 'apply plugin: VariantsPlugin\n'
        buildFile
    }

    private static File withExternalDependencies(File buildFile, String dependenciesBlock) {
        buildFile << """
            ${mavenCentralRepository()}
            dependencies {

        goodCode()
        buildFile << """
        pmdMain {
            rulesMinimumPriority = 11
        }
"""
        expect:
        fails("check")
        failure.assertHasCause("Invalid rulesMinimumPriority '11'.  Valid range 1 (highest) to 5 (lowest).")
    }

    def "can configure reporting"() {
        goodCode()
        buildFile << """
            pmdMain {

        and:
        buildFile << configureTargetMachines("machines.os('some-other-family')")

        expect:
        succeeds "help"
    }

    def "fails configuration when no target machine is configured"() {
        given:
        makeSingleProject()
        componentUnderTest.writeToProject(testDirectory)

        and:
        buildFile << configureTargetMachines('')

        expect:

class RuleTaskBridgingIntegrationTest extends AbstractIntegrationSpec implements WithRuleBasedTasks {

    def "can view task container as various view types"() {
        given:
        buildFile << '''
            class MyPlugin extends RuleSource {
                @Mutate
                void applyMessages(ModelMap<Task> tasks) {
                    println "as map: $tasks"