}

        buildFile << """
model {
    platforms {
        x86 {
            architecture "i386"
        }
    }
    components {
        main(NativeExecutableSpec) {
            targetPlatform "x86"
            binaries.all {
                linker.args "-v"
            }
        }
    }
}
            """
        then:
        succeeds "mainExecutable"

    @ToBeFixedForConfigurationCache
    def "build fails when compilation fails"() {
        given:
        buildFile << """
model {
    components {
        main(NativeExecutableSpec)
    }
}
         """

        and:
        file("src/main/cpp/broken.cpp") << """
        #include <iostream>

        'broken
"""

        expect:
        fails "mainExecutable"

    }

    @ToBeFixedForConfigurationCache
    def "dependencies of 2 language source sets are not shared when compiling"() {
        given:
        buildFile << """
model {
    components {
        main(NativeExecutableSpec) {
            sources {
                cpp {
                    lib library: 'lib1', linkage: 'api'
                }
                otherCpp(CppSourceSet) {

 * limitations under the License.
 */
package org.gradle.nativeplatform.internal;

import org.gradle.nativeplatform.NativeExecutableSpec;

public class DefaultNativeExecutableSpec extends AbstractTargetedNativeComponentSpec implements NativeExecutableSpec {
    @Override
    protected String getTypeName() {
        return "native executable";
    }

import org.gradle.language.assembler.tasks.Assemble
import org.gradle.model.ModelMap
import org.gradle.nativeplatform.NativeBinary
import org.gradle.nativeplatform.NativeExecutableBinarySpec
import org.gradle.nativeplatform.NativeExecutableSpec
import org.gradle.nativeplatform.NativeLibrarySpec
import org.gradle.nativeplatform.SharedLibraryBinarySpec
import org.gradle.nativeplatform.StaticLibraryBinarySpec
import org.gradle.platform.base.PlatformBaseSpecification

plugins {
    id 'cpp'
}

model {
    components {
        main(NativeExecutableSpec) {
            sources {
                cpp {
                    lib project: ':lib', library: 'main'
                }
            }
        }
    }

         * The install task.
         */
        Task getInstall();
    }

    /**
     * {@inheritDoc}
     */
    @Override
    NativeExecutableSpec getApplication();

    /**
     * {@inheritDoc}
     */
    @Override
    NativeExecutableSpec getComponent();

    /**
     * Native Installation location for a native executable.
     */
    NativeInstallationSpec getInstallation();

    /**

        buildFile << """
plugins {
    id 'c'
    id 'cunit-test-suite'
}

model {
    toolChains {
        ${toolChain.buildScriptConfig}
    }
    components {
        someExe(NativeExecutableSpec)
    }
    testSuites {
        someExeTest(CUnitTestSuiteSpec)
    }
}
"""
        when:
        fails "components"

        then:

        given:
        buildFile << """
apply plugin: "cpp"
model {
    components {
        helloStatic(NativeLibrarySpec)
        helloShared(NativeLibrarySpec)
        main(NativeExecutableSpec) {
            sources {
                cpp.lib library: 'helloStatic', linkage: 'static'
                cpp.lib library: 'helloShared', linkage: 'shared'
            }
        }
    }
}
"""

            // we need to reapply the 32-bit platform config for cygwin64 and mingw64
            ${toolChain.platformSpecificToolChainConfiguration()}
        }
    }
    components {
        main(NativeExecutableSpec)
    }
}
        """

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

        when:
        run "mainExecutable"

        then: