private final NativeExecutableFileSpec executable = new NativeExecutableFileSpec();

    @Override
    public NativeExecutableSpec getComponent() {
        return getComponentAs(NativeExecutableSpec.class);
    }

    @Override
    public NativeExecutableSpec getApplication() {
        return getComponentAs(NativeExecutableSpec.class);
    }

    @Override
    public NativeExecutableFileSpec getExecutable() {

                    }
                }
            }
        }
    }
    components {
        main(NativeExecutableSpec) {
            sources {
                cpp.lib library: 'hello'
            }
        }
        mainStatic(NativeExecutableSpec) {
            sources {
                cpp {
                    source.srcDir "src/main/cpp"

            ext.debug = true
        }
        integration {
            ext.debug = true
        }
        release {
            ext.debug = false
        }
    }
    components {
        main(NativeExecutableSpec) {
            binaries.all { binary ->
                if (toolChain in Gcc && buildType.debug) {
                    cppCompiler.args "-g"
                }
                if (toolChain in VisualCpp) {

        app.executable.writeSources(file("src/main"))
        app.library.writeSources(file("src/library"))

        buildFile << """
apply plugin: 'c'

model {
    components {
        main(NativeExecutableSpec) {
            sources {
                library(CSourceSet) {
                    source.srcDir "src/library/c"
                    exportedHeaders.srcDir "src/library/headers"
                }

        given:
        app.writeSources(file('src/main'))

        and:
        buildFile << """
            model {
                components {
                    main(NativeExecutableSpec)
                }
            }
         """

        expect:
        succeeds "mainExecutable"
        executable("build/exe/main/main").exec().out == app.expectedOutput(toolChain)
    }

        and:
        createDirs("exe", "other")
        settingsFile.text = "include ':exe', ':other'"
        buildFile << """
project(":exe") {
    model {
        components {
            main(NativeExecutableSpec) {
                sources {
                    cpp.lib ${dependencyNotation}
                }
            }
            hello(NativeLibrarySpec)
        }
    }
}
project(":other") {
    model {

import org.gradle.language.base.LanguageSourceSet
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.platform.base.PlatformBaseSpecification

abstract class AbstractNativeComponentPluginTest extends PlatformBaseSpecification {

        project.model {
            components {
                test(NativeExecutableSpec) {
                    targetPlatform "platform"
                }
            }
        }

        then:
        NativeExecutableSpec executable = single(components.values()) as NativeExecutableSpec
        NativeExecutableBinarySpec executableBinary = single(binaries) as NativeExecutableBinarySpec

import org.gradle.nativeplatform.NativeExecutableSpec
import org.gradle.platform.base.component.BaseComponentFixtures
import org.gradle.platform.base.internal.DefaultComponentSpecIdentifier
import spock.lang.Specification

class DefaultNativeExecutableSpecTest extends Specification {

        settingsFile << """
            include ':exe', ':lib'
        """
        file("exe", "build.gradle") << """
            model {
                components {
                    main(NativeExecutableSpec) {
                        sources {
                            cpp.lib project: ':lib', library: 'hello', linkage: 'static'
                        }
                    }
                }
            }