def "does not fail when calling get() after producer task has completed"() {
        given:
        def property = propertyWithCompletedProducer()
        def provider = property.map { Integer.parseInt(it) }

        when:
        provider.get()

        then:
        0 * progressEventEmitter._
    }

    def "fails when calling getOrNull() before producer task has completed"() {
        given:

    def startParameter = Mock(StartParameterInternal)
    def action = Mock(SerializedPayload)
    def clientSubscriptions = Mock(BuildEventSubscriptions)
    def payloadSerializer = Mock(PayloadSerializer)
    def gradle = Stub(GradleInternal)
    def buildController = Mock(BuildTreeLifecycleController) {
        getGradle() >> this.gradle
    }
    def modelController = Stub(BuildTreeModelController)

class JavaExecTest extends AbstractProjectBuilderSpec {

    def 'Jvm arguments are empty by default'() {
        when:
        def task = project.tasks.create("run", JavaExec)

        then:
        task.jvmArgs != null
        task.jvmArgs.isEmpty()
    }

    def 'fails if custom executable does not exist'() {
        def task = project.tasks.create("run", JavaExec)
        def invalidExecutable = temporaryFolder.file("invalid")

    }

    def "calls delegate for binary files with #description"() {
        def file = file('foo') << contents
        def delegate = Mock(LineEndingNormalizingFileSystemLocationSnapshotHasher)
        def hasher = LineEndingNormalizingFileSystemLocationSnapshotHasher.wrap(delegate, LineEndingSensitivity.NORMALIZE_LINE_ENDINGS)
        def snapshot = this.snapshot(file)

        when:

        given:
        def c = new TestConfigurable()
        def b = new Bean()

        when:
        def action = ConfigureUtil.configureUsing { prop = "p" }
        action.execute(c)
        action.execute(b)

        then:
        c.props.prop == "p"
        b.prop == "p"
    }

    def createsIsolatedActionThatCanConfigureObjects() {
        given:
        def c = new TestConfigurable()

    def providerFactory = new DefaultProviderFactory()

    def "cannot create provider for null value"() {
        when:
        providerFactory.provider(null)

        then:
        def t = thrown(IllegalArgumentException)
        t.message == 'Value cannot be null'
    }

    def "can create provider for #type"() {
        when:
        def provider = providerFactory.provider({ value })

    }

    def "exposes authorized service"() {
        def allServices = Mock(ServiceLookup)
        def params = Stub(SomeParams)
        def service = Stub(serviceType)
        _ * allServices.find(serviceType) >> service

        def injectedServices = scheme.servicesForImplementation(params, allServices)

        when:
        def result = injectedServices.find(serviceType)

        then:

    def artifactNotationParser = Stub(NotationParser)
    def capabilityNotationParser = Stub(NotationParser)
    def fileCollectionFactory = TestFiles.fileCollectionFactory()
    def attributesFactory = AttributeTestUtil.attributesFactory()
    def displayName = Describables.of("<config>")
    def publications = new DefaultConfigurationPublications(displayName, artifacts, {

import spock.lang.Specification

class MergeProviderTest extends Specification {

    def objects = TestUtil.objectFactory()
    def providers = TestUtil.providerFactory()

    def "provides all values"() {
        given:
        def provider1 = new MergeProvider([providers.provider { "a" }])
        def provider2 = new MergeProvider([providers.provider { "a" }, providers.provider { "b" }])

        expect:

    def serializer = new TransportableActionExecutionSpecSerializer()
    def outputStream = new ByteArrayOutputStream()
    def encoder = new KryoBackedEncoder(outputStream)
    def bytes = [ (byte) 1, (byte) 2, (byte) 3 ] as byte[]
    def usesInternalServices = true

    def "can serialize and deserialize a spec with a hierarchical classloader structure"() {