private Compiler<StaticLibraryArchiverSpec> createCompiler() {
        NativePlatformInternal targetPlatform = Cast.cast(NativePlatformInternal.class, this.targetPlatform.get());
        NativeToolChainInternal toolChain = Cast.cast(NativeToolChainInternal.class, getToolChain().get());
        PlatformToolProvider toolProvider = toolChain.select(targetPlatform);
        return toolProvider.newCompiler(StaticLibraryArchiverSpec.class);
    }

@Incubating @HasInternalProtocol
public interface PlatformAwareComponentSpec extends VariantComponentSpec {
    /**
     * Specifies a platform that this component should be built be for.
     */
    void targetPlatform(String targetPlatform);

        this.toolChain = toolChain;
    }

    @Override
    public NativePlatform getTargetPlatform() {
        return targetPlatform;
    }

    @Override
    public void setTargetPlatform(NativePlatform targetPlatform) {
        this.targetPlatform = targetPlatform;
    }

    @Override
    public BuildType getBuildType() {
        return buildType;
    }

    @Override

    def "can add a test executable"() {
        def targetPlatform = Stub(SwiftPlatform)
        def toolChain = Stub(NativeToolChainInternal)
        def platformToolProvider = Stub(PlatformToolProvider)

        expect:
        def exe = testSuite.addExecutable(identity, targetPlatform, toolChain, platformToolProvider)
        exe.name == 'testExecutable'
        exe.targetPlatform == targetPlatform
        exe.toolChain == toolChain

apply plugin: 'google-test'

model {
    // google test libs are only built for 32-bit
    platforms {
        x86 {
            architecture "x86"
        }
    }
    components {
        all {
            targetPlatform "x86"
        }
    }
    components {
<%
components.each { component ->
    out.println """
        ${component.name}(${component.type}) {
            binaries.all {"""
    component.deps.each { dep ->

    }

    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)
        binary.name == "mainDebug"
        binary.debuggable

 */

package org.jetbrains.kotlin.analysis.project.structure.impl

import org.jetbrains.kotlin.platform.TargetPlatform

internal interface KtModuleWithPlatform {
    val platform: TargetPlatform

 */
@DisableCachingByDefault(because = "Not worth caching")
public abstract class InstallExecutable extends DefaultTask {
    private final Property<NativePlatform> targetPlatform;
    private final Property<NativeToolChain> toolChain;
    private final DirectoryProperty installDirectory;
    private final RegularFileProperty executable;
    private final RegularFileProperty installedExecutable;

        SwiftStaticLibrary result = objectFactory.newInstance(DefaultSwiftStaticLibrary.class, getNames().append(identity.getName()), getModule(), testable, getSwiftSource(), getImplementationDependencies(), targetPlatform, toolChain, platformToolProvider, identity);
        getBinaries().add(result);

        DefaultCppSharedLibrary result = objectFactory.newInstance(DefaultCppSharedLibrary.class, getNames().append(identity.getName()), getBaseName(), getCppSource(), getAllHeaderDirs(), getImplementationDependencies(), targetPlatform, toolChain, platformToolProvider, identity);