.filter(CppExecutable.class::isInstance)
                    .map(CppExecutable.class::cast)
                    .filter(binary -> !binary.isOptimized() && Architectures.forInput(binary.getTargetMachine().getArchitecture().getName()).equals(DefaultNativePlatform.host().getArchitecture()))
                    .findFirst()
                    .orElseGet(() -> application.getBinaries().get().stream()

/**
 * A target platform for building Swift binaries.
 *
 * @since 5.2
 */
public interface SwiftPlatform {
    /**
     * Returns the target machine for this platform.
     */
    TargetMachine getTargetMachine();

    /**
     * Returns the Swift language level to use to compile the source files.
     */
    SwiftVersion getSourceCompatibility();

        this.targetMachine = targetMachine;
        this.nativePlatform = nativePlatform;
    }

    @Override
    public TargetMachine getTargetMachine() {
        return targetMachine;
    }

    public NativePlatform getNativePlatform() {
        return nativePlatform;
    }

        }
    }

    public boolean isDebuggable() {
        return debuggable;
    }

    public boolean isOptimized() {
        return optimized;
    }

    public TargetMachine getTargetMachine() {
        return targetMachine;
    }

    public Linkage getLinkage() {
        return linkage;
    }

    @Override
    public ModuleVersionIdentifier getCoordinates() {

        }

        @Override
        boolean isOptimized() {
            throw new UnsupportedOperationException()
        }

        @Override
        TargetMachine getTargetMachine() {
            throw new UnsupportedOperationException()
        }

        @Override
        NativeToolChain getToolChain() {
            throw new UnsupportedOperationException()
        }
    }

        exe.name == 'testExecutable'
    }

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

    private TargetMachine targetMachine(String os, String arch) {
        def objectFactory = TestUtil.objectFactory()

    }

    private NativeVariantIdentity getIdentity() {
        return Stub(NativeVariantIdentity) {
            getName() >> "debug"
            isDebuggable() >> true
            getTargetMachine() >> targetMachine(OperatingSystemFamily.MACOS, MachineArchitecture.X86_64)
        }
    }

    private TargetMachine targetMachine(String os, String arch) {
        def objectFactory = TestUtil.objectFactory()

        def toolChain = Mock(NativeToolChainInternal)
        def toolProvider = Mock(PlatformToolProvider)
        def requestPlatform = Stub(CppPlatform) {
            getTargetMachine() >> targetMachine
        }

        given:
        modelRegistry.realize(_, NativeToolChainRegistryInternal) >> registry
        machineArchitecture.name >> architecture

        when:

                task.getOptimized().set(binary.isOptimized());
                if (binary.isTestable()) {
                    task.getCompilerArgs().add("-enable-testing");
                }
                if (binary.getTargetMachine().getOperatingSystemFamily().isMacOs()) {
                    task.getCompilerArgs().add("-sdk");
                    task.getCompilerArgs().add(locator.find().getAbsolutePath());
                }

        // TODO Check that TargetMachine from NativeVariantIdentity is the same as the one from CppPlatform
        return Stub(NativeVariantIdentity) {
            getName() >> "debug"
            getTargetMachine() >> targetMachine(OperatingSystemFamily.WINDOWS, MachineArchitecture.X86_64)
            isDebuggable() >> true
            isOptimized() >> false
        }
    }