void "can declare a strict dependency onto an external component"() {
        given:
        repository {
            'org:foo:1.0'()
        }

        buildFile << """
            dependencies {
                conf('org:foo:1.0!!')
            }
        """

        when:
        repositoryInteractions {
            'org:foo:1.0' {

    MetadataArtifactResolveTestFixture(TestFile buildFile, String config = "compile") {
        this.buildFile = buildFile
        this.config = config
    }

    void basicSetup() {
        buildFile << """
configurations {
    $config
}

dependencies {
    $config '$id.displayName'
}
"""
    }

    void configureChangingModule() {
        buildFile << """

        def buildC = singleProjectBuild("buildC") {
            buildFile << """
                apply plugin: 'java'
            """
        }
        def buildB = singleProjectBuild("buildB") {
            settingsFile << """
                includeBuild('${buildC.toURI()}')
            """
            buildFile << """
                apply plugin: 'java'

        withMultipleActionTaskTypeInBuildScript()
    }

    def "multiple work items can be executed in parallel in #isolationMode (wait for results: #waitForResults)"() {
        given:
        buildFile << """
            task parallelWorkTask(type: MultipleWorkItemTask) {
                isolationMode = '$isolationMode'
                doLast {
                    submitWorkItem("workItem0")

class BuildLogicFunctionalTest extends Specification {

    // tag::clean-build-cache[]
    @TempDir File testProjectDir
    File buildFile
    File localBuildCacheDirectory

    def setup() {
        localBuildCacheDirectory = new File(testProjectDir, 'local-cache')
        buildFile = new File(testProjectDir,'settings.gradle') << """
            buildCache {
                local {

import static org.gradle.workers.fixtures.WorkerExecutorFixture.ISOLATION_MODES

class WorkerExecutorParametersIntegrationTest extends AbstractIntegrationSpec {
    def setup() {
        buildFile << """
            import org.gradle.workers.WorkerExecutor

            class ParameterTask extends DefaultTask {
                private final WorkerExecutor workerExecutor

                @Internal

    }

    def 'resolve maven module with non-existing custom packaging artifact - applies java plugin'() {
        given:
        buildFile.text = '''plugins {
            id 'java'
        }
        '''.stripIndent() + buildFile.text

        buildFile << """
            dependencies {
                // this POM declares packaging of 'hk2-jar', but the artifact is 'jar'

    def "setup"() {
        buildFile << """
@Managed
interface SampleComponent extends ComponentSpec {
    String getVersion()
    void setVersion(String version)
}
"""
    }

    def "plugin declares custom component"() {
        when:
        buildWithCustomComponentPlugin()

        and:
        buildFile << '''
model {
    tasks {
        create("checkModel") {

    def "setup"() {
        buildFile << """
@Managed
interface SampleBinary extends BinarySpec {
    String getVersion()
    void setVersion(String version)
}
"""
    }

    def "custom managed binary type can be registered and created"() {
        when:
        buildWithCustomBinaryPlugin()

        and:
        buildFile << '''
model {
    tasks {
        checkModel(Task) {

    }

    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