import static org.apache.maven.lifecycle.internal.stub.ProjectDependencyGraphStub.A;
import static org.apache.maven.lifecycle.internal.stub.ProjectDependencyGraphStub.B;
import static org.apache.maven.lifecycle.internal.stub.ProjectDependencyGraphStub.C;
import static org.apache.maven.lifecycle.internal.stub.ProjectDependencyGraphStub.X;
import static org.apache.maven.lifecycle.internal.stub.ProjectDependencyGraphStub.Y;

    def "has no default import library location when platform does not produce one"() {
        def toolChain = Stub(NativeToolChainInternal)
        def platform = Stub(NativePlatformInternal)
        def provider = Stub(PlatformToolProvider)
        toolChain.select(platform) >> provider
        provider.producesImportLibrary() >> false

        when:

        expect:
        library.apiDependencies == project.configurations.api
    }

    def "can create static binary"() {
        def targetPlatform = Stub(SwiftPlatform)
        def toolChain = Stub(NativeToolChainInternal)
        def platformToolProvider = Stub(PlatformToolProvider)

        expect:
        def binary = library.addStaticLibrary(identity, true, targetPlatform, toolChain, platformToolProvider)

            Stub(BuildIdentifier),
            Stub(Path),
            Stub(Path),
            'test project'
        )
        def mid = DefaultModuleVersionIdentifier.newId("foo", "bar", "1.0")
        org.gradle.internal.Factory<String> broken = { "too bad" }
        def dep = new DefaultUnresolvedDependencyResult(
            Stub(ComponentSelector), false,

        1 * writeStore.add(key, action)
        0 * readStore.add(key, action)
    }

    def "searches in both read and write stores"() {
        setup:
        def r1 = Stub(LocallyAvailableResource)
        def r2 = Stub(LocallyAvailableResource)
        def r3 = Stub(LocallyAvailableResource)
        1 * writeStore.search(key) >> {
            [r1] as Set
        }
        1 * readStore.search(key) >> {
            [r2, r3] as Set

        },
        Mock(WorkerDaemonFactory),
        Mock(JavaForkOptionsFactory),
        Mock(ExecHandleFactory),
        Stub(AnnotationProcessorDetector),
        Stub(ClassPathRegistry),
        Stub(ActionExecutionSpecFactory),
        Stub(InternalProblems),
        Stub(ProjectCacheDir)
    )

    def "creates in-process compiler when JavaCompileSpec is provided"() {
        expect:

        app.implementationDependencies == project.configurations['implementation']
    }

    def "can create executable binary"() {
        def targetPlatform = Stub(SwiftPlatform)
        def toolChain = Stub(NativeToolChainInternal)
        def platformToolProvider = Stub(PlatformToolProvider)

        expect:
        def binary = app.addExecutable(identity, true, targetPlatform, toolChain, platformToolProvider)

                result1 = cache.get("key", producer, Stub(Runnable))
            }
            start {
                result2 = cache.get("key", producer, Stub(Runnable))
            }
            start {
                result3 = cache.get("key", producer, Stub(Runnable))
            }
            start {
                result4 = cache.get("key", producer, Stub(Runnable))
            }
        }

        then:

    }

    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

        def taskDescriptor = Stub(InternalTaskWithExtraInfoDescriptor)
        _ * taskDescriptor.getId() >> ':dummy'
        _ * taskDescriptor.getName() >> 'some task'
        _ * taskDescriptor.getParentId() >> null
        _ * taskDescriptor.getTaskPath() >> ':some:path'
        _ * taskDescriptor.getDependencies() >> [Stub(InternalOperationDescriptor)]

        def startEvent = Stub(InternalOperationStartedProgressEvent)