import org.gradle.api.Incubating;
import org.gradle.platform.base.ApplicationSpec;

/**
 * Definition of a native executable component that is to be built by Gradle.
 */
@Incubating
public interface NativeExecutableSpec extends ApplicationSpec, NativeComponentSpec, TargetedNativeComponent {
    

Laura Kassovic <******@****.***> 1701107622 -0800

    }

    @ToBeFixedForConfigurationCache
    def "compile and link executable"() {
        given:
        buildFile << """
            model {
                components {
                    main(NativeExecutableSpec)
                }
            }
        """

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

        when:
        run "mainExecutable"

        then:

import org.gradle.api.NamedDomainObjectContainer;
import org.gradle.nativeplatform.NativeExecutableSpec;
import org.gradle.nativeplatform.NativeLibrarySpec;
import org.gradle.nativeplatform.NativeComponentExtension;

public class DefaultNativeComponentExtension implements NativeComponentExtension {
    private final NamedDomainObjectContainer<NativeExecutableSpec> executables;
    private final NamedDomainObjectContainer<NativeLibrarySpec> libraries;

public interface NativeComponentExtension {
    /**
     * The {@link NativeExecutableSpec} components produced by the build.
     */
    NamedDomainObjectContainer<NativeExecutableSpec> getExecutables();

    /**
     * Configure the {@link NativeExecutableSpec} components produced by the build.
     */
    void executables(Action<? super NamedDomainObjectContainer<? super NativeExecutableSpec>> action);

    /**

model {
    components { comp ->
        helloApi(NativeLibrarySpec)
        hello(NativeLibrarySpec) {
            sources {
                cpp.lib ${notation}
            }
        }
        main(NativeExecutableSpec) {
            sources {
                cpp.lib ${notation}
                cpp.lib library: 'hello'
            }
        }
    }
}
"""

        when:
        succeeds "installMainExecutable"

    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() {

            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)
    }