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:

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

    /**

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;

        app.writeSources(file("src/input"))
        degenerateInputSources()

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

model {
    components {
        main(NativeExecutableSpec) {
            sources {
                c.generatedBy tasks.generateCSources
            }
        }
    }
}
"""

        then:
        executableBuilt(app)
    }

    @ToBeFixedForConfigurationCache
    def "can configure the binaries of a C++ application"() {
        given:
        buildFile << """
apply plugin: "cpp"

model {
    components {
        main(NativeExecutableSpec) {
            binaries.all {
                cppCompiler.define 'ENABLE_GREETING'
            }
        }
    }
}
"""

        and:
        file("src/main/cpp/helloworld.cpp") << """

    }

    def "skips building executable binary with no source"() {
        given:
        buildFile << """
apply plugin: "cpp"
model {
    components {
        main(NativeExecutableSpec)
    }
}
"""

        when:
        succeeds "mainExecutable"

        then:
        executable("build/binaries/mainExecutable/main").assertDoesNotExist()
    }

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

        when:
        succeeds "installMainExecutable"

    def "creating visual studio multiple time gives the same result"() {
        given:
        app.writeSources(file("src/main"))
        buildFile << """
model {
    components {
        main(NativeExecutableSpec)
    }
}
"""
        when:
        run "visualStudio"
        def filtersFileContent = filtersFile("mainExe.vcxproj.filters").file.text