}

    def "can add a test bundle"() {
        expect:
        def exe = testSuite.addBundle(identity, Stub(SwiftPlatform), Stub(NativeToolChainInternal), Stub(PlatformToolProvider))
        exe.name == 'testExecutable'
    }

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

        def config = Stub(ConfigurationInternal) {
            getOutgoing() >> outgoing
            getExtendsFrom() >> [Stub(ConfigurationInternal) {
                getOutgoing() >> Stub(ConfigurationPublications) {
                    getArtifacts() >> artifacts2
                }
            }]
        }

        def artifact1 = Stub(TaskProvider)
        def artifact2 = Stub(File)

    GradleInternal build = Stub(GradleInternal)
    ConfigurationTargetIdentifier configurationTargetIdentifier = Stub(ConfigurationTargetIdentifier)
    FileOperations fileOperationsMock = Stub(FileOperations)
    ProviderFactory propertyStateFactoryMock = Stub(ProviderFactory)
    ProcessOperations processOperationsMock = Stub(ProcessOperations)

        def lister = new InstantiatingAction<ComponentMetadataListerDetails>(DefaultConfigurableRules.of(Stub(ConfigurableRule)), TestUtil.instantiatorFactory().inject(), Stub(InstantiatingAction.ExceptionHandler))

        when:
        builder.projectsLoaded(Stub(BuildAction), Stub(IntermediateResultHandler))
        builder.projectsLoaded(Stub(BuildAction), Stub(IntermediateResultHandler))

        then:
        IllegalArgumentException e1 = thrown()
        e1.message == 'ProjectsLoadedAction has already been added. Only one action per phase is allowed.'

        when:
        builder.buildFinished(Stub(BuildAction), Stub(IntermediateResultHandler))

    }

    def "union of a spec is that spec"() {
        def spec = Stub(Spec)

        expect:
        Specs.union(spec) == spec
        Specs.union([spec]) == spec
    }

    def "union of multiple specs is OrSpec"() {
        def spec1 = Stub(Spec)
        def spec2 = Stub(Spec)

        expect:
        def union1 = Specs.union(spec1, spec2)
        union1 instanceof OrSpec

        def delegateOriginMetadata = Stub(OriginMetadata)
        def delegateOutputFiles = ImmutableSortedMap.of()
        def delegateOutputState = Stub(ExecutionOutputState) {
            getOriginMetadata() >> delegateOriginMetadata
            getOutputFilesProducedByWork() >> delegateOutputFiles
        }
        def delegateResult = Stub(CachingResult) {

        def selector = Stub(ModuleComponentSelector)

        when:
        def spec = store.locateVcsFor(selector)

        then:
        spec == null
        0 * factory._
    }

    def "does nothing when no rule accepts selector"() {
        def selector = Stub(ModuleComponentSelector)
        def mapping = new DefaultVcsMapping(selector, Stub(VersionControlSpecFactory))

    ModuleComponentArtifactIdentifier artifactIdentifier = Stub() {
        getDisplayName() >> '<some-artifact>'
    }
    ModuleComponentArtifactMetadata artifact = Stub() {
        getId() >> artifactIdentifier
    }
    ModuleSource moduleSource = Mock()
    File downloadedFile = Mock(File)
    CacheAwareExternalResourceAccessor resourceAccessor = Stub()

func cgoLookupHost(ctx context.Context, name string) (addrs []string, err error) {
	panic("cgo stub: cgo not available")
}

func cgoLookupPort(ctx context.Context, network, service string) (port int, err error) {
	panic("cgo stub: cgo not available")
}

func cgoLookupIP(ctx context.Context, network, name string) (addrs []IPAddr, err error) {
	panic("cgo stub: cgo not available")
}