file("run.sh") << '''#!/bin/sh
# convert paths into absolute Unix-like paths
BUILD_FILE=$(cygpath --absolute --unix build.gradle)
SRC_DIR=$(cygpath --absolute --unix src)
# pass them to the generated start script
build/install/sample/bin/sample "$BUILD_FILE" "$SRC_DIR"
'''
        buildFile << """
task execStartScript(type: Exec) {
    commandLine 'cmd.exe', '/d', '/c', 'sh', 'run.sh'
}
"""

class TaskExecutionIntegrationTest extends AbstractIntegrationSpec implements TasksWithInputsAndOutputs {

    @UnsupportedWithConfigurationCache
    def taskCanAccessTaskGraph() {
        buildFile << """
            boolean notified = false
            task a(dependsOn: 'b') {
                doLast { task ->
                    assert notified
                    assert gradle.taskGraph.hasTask(task)

        given:
        buildA.buildFile << """
            dependencies {
                implementation "org.test:buildB:1.0"
            }
        """
        buildB.buildFile << """
            dependencies {
                implementation "org.test:buildC:1.0"
            }
        """
        def buildC = singleProjectBuild("buildC") {
            buildFile << """
                apply plugin: 'java'

        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:
        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:

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

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"

        then:
        targetDir.file(settingsFile).exists()
        !targetDir.file(buildFile).exists()

        def buildLogicDir = targetDir.file(incubating ? "build-logic" : "buildSrc")
        assertBuildLogicSources(dsl, language, buildLogicDir, settingsFile, buildFile, javaMajorVersion)

        assertApplicationProjectsSources(buildFile, language, "org.example.", ext)

        when:
        succeeds "build"

        buildFile """
            interface Thing extends Named { }

            def t = objects.newInstance(Thing, "thingName")
            assert t.name == "thingName"
"""

        expect:
        succeeds()
    }

    def "plugin can create instance of abstract class with name property"() {
        buildFile """
            abstract class Thing {

        buildFile << """
            task unspecified(type: UnspecifiedCacheabilityTask) {}
        """
        when:
        withBuildCache().run "unspecified"
        then:
        assertCachingDisabledFor NOT_ENABLED_FOR_TASK, "Caching has not been enabled for the task"
    }

    def "cacheability for a cacheable task is null"() {
        buildFile << """