buildFile << """
plugins {
    id 'cpp'
    id 'google-test-test-suite'
}

model {
    toolChains {
        ${toolChain.buildScriptConfig}
    }
    components {
        someExe(NativeExecutableSpec)
    }
    testSuites {
        someExeTest(GoogleTestTestSuiteSpec) {
            testing \$.components.someExe
        }
    }
}
"""
        when:
        succeeds "components"

    }

    def "fails with decent error message with visual studio toolchain"() {
        given:
        buildFile << """
model {
    components {
        main(NativeExecutableSpec)
    }
}
        """

        and:
        helloWorldApp.writeSources(file("src/main"))

        when:
        fails "compileMainExecutableMainObjc"

        then:

                }
                linker.withArguments { args ->
                    args.remove "CUSTOM"
                }
            }
        }
    }
    components {
        main(NativeExecutableSpec) {
            binaries.all {
                cppCompiler.args "CUSTOM"
                linker.args "CUSTOM"
            }
        }
    }
}
        """
        and:

import org.gradle.nativeplatform.toolchain.NativeToolChain;

import java.io.File;

/**
 * Specifies how to build and where to place a native executable file.
 *
 * <p>TODO:HH resolve naming conflict with existing NativeExecutableSpec</p>
 */
@Incubating @UnmanagedStruct
public class NativeExecutableFileSpec {

    private File file;
    private NativeToolChain toolChain;

    public File getFile() {
        return file;
    }

    def setup() {
        buildFile << """
apply plugin: 'c'

model {
    toolChains {
        ${toolChain.buildScriptConfig}
    }
    components {
        main(NativeExecutableSpec)
    }
}
"""

        helloWorldApp.executable.writeSources(file("src/main"))
        helloWorldApp.library.writeSources(file("src/main"))
    }

    def testApp = new PlatformDetectingTestApp()
    def os = OperatingSystem.current()

    def setup() {
        buildFile << """
plugins {
    id 'cpp'
}
model {
    components {
        main(NativeExecutableSpec)
    }
}
"""

        testApp.writeSources(file("src/main"))
    }

    @ToBeFixedForConfigurationCache
    def "can create installation for a different os than the current one"() {

                        binaries.all {
                            lib library: 'greetings' , linkage: 'static'
                        }
                    }
                    main(NativeExecutableSpec) {
                        binaries.all {
                            lib library: 'hello'
                        }
                    }
                }
            }
        '''.stripIndent()

    toolChains {
        ${x86ToolChain.buildScriptConfig}
        ${sparcToolChain.buildScriptConfig}
        ${sparcToolChain.id} {
            target("sparc")
        }
    }
    components {
        main(NativeExecutableSpec) {
            targetPlatform "i386"
            targetPlatform "sparc"
        }
    }
}
"""

        then:
        succeeds 'mainI386Executable', 'mainSparcExecutable'

        and:

    def setup() {
        buildFile << """
apply plugin: 'c'

model {
    toolChains {
        ${toolChain.buildScriptConfig}
    }
    components {
        main(NativeExecutableSpec) {
            binaries.all {
                lib library: 'hello', linkage: 'static'
            }
        }
        hello(NativeLibrarySpec)
    }
}
"""

    def "test executable"() {
        def executableFile = new NativeExecutableFileSpec();
        def installation = new NativeInstallationSpec();
        def binary = initBinary(NativeExecutableBinarySpecInternal, NativeExecutableSpec)
        binary.executable >> executableFile
        binary.installation >> installation

        when:
        toolProvider.getExecutableName("base_name") >> "exe_name"

        and: