0 * _
    }

    def dependsOnUnionOfDependenciesOfSourceCollections() {
        def task1 = Stub(Task)
        def task2 = Stub(Task)
        def task3 = Stub(Task)
        def source1 = Stub(FileCollectionInternal)
        def source2 = Stub(FileCollectionInternal)

        given:
        source1.visitDependencies(_) >> { TaskDependencyResolveContext context ->

        given:
        def listenerManager = Mock(ListenerManager)
        def notifyAction = Mock(Action)
        def daemonScanInfo = new DefaultDaemonScanInfo(Stub(DaemonRunningStats), 0, false, Stub(DaemonRegistry), listenerManager)
        DaemonExpirationListener daemonExpirationListener
        BuildListener buildListener

        when:
        daemonScanInfo.notifyOnUnhealthy(notifyAction)

        def variant = Stub(ResolvedGraphVariant)
        variant.nodeId >> componentId

        def component = Stub(DependencyGraphComponent)
        _ * component.resultId >> componentId
        _ * component.selectionReason >> reason
        _ * component.resolveState >> componentState
        _ * component.selectedVariants >> [variant]

        def node = Stub(DependencyGraphNode)

import spock.lang.Specification
import spock.lang.Subject

import java.nio.file.Path

class TwoStageByUrlCachedExternalResourceIndexTest extends Specification {
    Path readOnlyPath = Stub(Path)
    File artifact = Stub(File)
    ExternalResourceMetaData metadata = Stub(ExternalResourceMetaData)

    CachedExternalResourceIndex<String> readIndex = Mock(CachedExternalResourceIndex)

import spock.lang.Specification
import spock.lang.Subject

import java.nio.file.Path

class TwoStageModuleArtifactCacheTest extends Specification {
    Path readOnlyPath = Stub(Path)
    File artifact = Stub(File)
    HashCode hashCode = Stub(HashCode)
    def key = Stub(ArtifactAtRepositoryKey)

    def readCache = Mock(ModuleArtifactCache)
    def writeCache = Mock(ModuleArtifactCache)

    @Subject

    def modelRegistry = Stub(ModelRegistry)
    def osFamily = Stub(OperatingSystemFamily)
    def machineArchitecture = Stub(MachineArchitecture)
    def targetMachine = Stub(TargetMachine) {
        getArchitecture() >> machineArchitecture
        getOperatingSystemFamily() >> osFamily
    }
    def os = Stub(OperatingSystemInternal)
    def arch = Stub(ArchitectureInternal)

package org.gradle.integtests.resource.s3.fixtures.stub

import groovy.transform.ToString

@ToString
class HttpStub {
    StubRequest request
    StubResponse response

    static stubInteraction(Closure<?> closure) {
        closure.resolveStrategy = Closure.DELEGATE_FIRST
        HttpStub stub = new HttpStub()
        closure.delegate = stub
        closure()
        stub
    }

    def request(Closure<?> closure){

        _ * gradle.settings >> Stub(SettingsInternal)
        def services = new DefaultServiceRegistry()
        services.add(gradle)
        services.add(buildFactory)
        services.add(controller)
        services.add(Stub(DocumentationRegistry))
        services.add(Stub(BuildTreeWorkGraphController))
        _ * buildTree.services >> services

        def buildId = Stub(BuildIdentifier) {

        0 * staleAddressDetector._
    }

    def "dispatches messages"() {
        def message = Stub(Message)

        when:
        connection.dispatch(message)

        then:
        1 * delegate.dispatch(message)
        0 * staleAddressDetector._
    }

    def "receives messages"() {
        def message = Stub(Message)

        given:
        delegate.receive() >> message

        when:

    }

    def "can add executable"() {
        expect:
        def exe = testSuite.addExecutable("Foo", identity, Stub(CppPlatform), Stub(NativeToolChainInternal), Stub(PlatformToolProvider))
        exe.name == 'testFooExecutable'
    }

    private NativeVariantIdentity getIdentity() {
        return Stub(NativeVariantIdentity) {
            getTargetMachine() >> targetMachine(OperatingSystemFamily.WINDOWS, MachineArchitecture.X86_64)