}

    def arm64() {
        def platform = Stub(NativePlatformInternal)
        def architecture = Stub(ArchitectureInternal)
        platform.architecture >> architecture
        architecture.isArm64() >> true
        platform
    }

    def x64() {
        def platform = Stub(NativePlatformInternal)
        def architecture = Stub(ArchitectureInternal)
        platform.architecture >> architecture

import spock.lang.Specification

class DefaultPrebuiltStaticLibraryBinaryTest extends Specification {
    def prebuiltLibrary = Stub(PrebuiltLibrary) {
        getName() >> "lib"
    }
    def binary = new DefaultPrebuiltStaticLibraryBinary("name", prebuiltLibrary, Stub(BuildType), Stub(NativePlatform), Stub(Flavor), TestFiles.fileCollectionFactory())

    def "has useful string representation"() {
        expect:

    public MetadataResolutionException() {
        // TODO Auto-generated constructor stub
    }

    public MetadataResolutionException(String message) {
        super(message);
        // TODO Auto-generated constructor stub
    }

    public MetadataResolutionException(Throwable cause) {
        super(cause);
        // TODO Auto-generated constructor stub
    }

    def target = Stub(DependencyMetadata)
    def selector = Stub(ProjectComponentSelector)
    def dep = new DefaultProjectDependencyMetadata(selector, target)

    def "returns this when same target requested"() {
        expect:
        dep.withTarget(selector).is(dep)
    }

    def "delegates when different target requested"() {
        def requested = Stub(ComponentSelector)

        def ruleAction = Stub(RuleAction) {
            getInputTypes() >> { [String] }
        }

        expect:
        ruleValidator.validate(ruleAction) == ruleAction
    }

    def "accepts valid type with multiple valid types"() {
        def ruleValidator = new DefaultRuleActionValidator(String, Long)
        def ruleAction = Stub(RuleAction) {
            getInputTypes() >> { [parameterType] }

        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