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

{header}<component 2>
""")
    }

    def "renders additional source sets"() {
        def sourceSet1 = Stub(LanguageSourceSet)
        def sourceSet2 = Stub(LanguageSourceSet) {
            getDisplayName() >> "<source set>"
        }
        def component = Stub(SourceComponentSpec) {
            getSources() >> Stub(ModelMap) {
                values() >> [sourceSet1]
            }
        }

        when:

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

        when:
        deps = dependencies.getDependencies(Stub(Task))

        then:
        visited == 2
        deps as List == [dependency]
    }

    def "collection dependencies are live"() {
        def task = Stub(Task)
        def dependency1 = Stub(Task)
        def dependency2 = Stub(Task)
        def dependencySource = Mock(TaskDependencyContainer)

        def dependency2 = dep("group", "module2", "1-beta")
        def artifactSource = Stub(CalculatedValue)
        def ivyArt = Stub(IvyArtifactName)
        def artifactId = Stub(ComponentArtifactIdentifier)
        def otherArtifactId = Stub(ComponentArtifactIdentifier)
        def buildDependencies = Stub(TaskDependencyContainer)

    }
    def mapping = Stub(ModelMapping) {
        getModelIdentifierFromModelType(_) >> { Class type ->
            return Stub(ModelIdentifier) {
                getName() >> type.simpleName
            }
        }
    }
    def delegate = Mock(InternalBuildControllerVersion2)
    def controller = new ParameterAwareBuildControllerAdapter(delegate, adapter, mapping, Stub(VersionDetails), new File("root"))