}

    def "adds link and install task for executable"() {
        def executable = Stub(DefaultSwiftExecutable)
        def executableFile = project.objects.fileProperty()
        executable.name >> name
        executable.names >> Names.of(name)
        executable.module >> Providers.of("TestApp")
        executable.baseName >> Providers.of("test_app")
        executable.executableFile >> executableFile

    }

    @Override
    default void setExecutable(String executable) {
        getDelegate().setExecutable(executable);
    }

    @Override
    default void setExecutable(Object executable) {
        getDelegate().setExecutable(executable);
    }

    @Override
    default ProcessForkOptions executable(Object executable) {
        getDelegate().executable(executable);
        return this;
    }

    @Override

        then:
        executedAndNotSkipped ":main${NativePlatformsTestFixture.defaultPlatformName.capitalize()}Executable"
        notExecuted ":mainUnknownExecutable"

        and:
        executable("build/exe/main/${NativePlatformsTestFixture.defaultPlatformName}/main").assertExists()
        executable("build/exe/main/unknown/main").assertDoesNotExist()
    }

    @ToBeFixedForConfigurationCache

    }

    def "can build debug and release variant of the executable"() {
        given:
        def app = new SwiftAppWithOptionalFeature()
        def debugBinary = executable("build/exe/main/debug/App")
        def releaseBinary = executable("build/exe/main/release/App")
        settingsFile << "rootProject.name = 'app'"
        app.writeToProject(testDirectory)

    private final File workingDir;
    private final String executable;
    private final int javaMajorVersion;
    private final Iterable<File> classpath;
    private final Iterable<File> modulePath;
    private final List<String> jvmArgs;
    private final Map<String, String> environment;

    DefaultTestTaskForkOptions(
        File workingDir,
        String executable,
        int javaMajorVersion,
        Iterable<File> classpath,

 */
public class GnupgSettings {

    private String executable;
    private File homeDir;
    private File optionsFile;
    private String keyName;
    private String passphrase;
    private boolean useLegacyGpg;

    public void setExecutable(String executable) {
        this.executable = executable;
    }

    public String getExecutable() {
        if (executable == null) {
            return defaultExecutable();

        flavor: flavor 'default'
        target platform: platform '$currentNative'
        component under test: native executable 'someExe'
        binary under test: executable 'someExe:executable'
        tool chain: Tool chain 'clang' (Clang)
        executable file: build/exe/someExeTest/someExeTest
"""
    }

    case IrExportStage::OPTIMIZED_HLO:
    case IrExportStage::OPTIMIZED_HLO_SERIALIZED: {
      TF_ASSIGN_OR_RETURN(std::unique_ptr<xla::LocalExecutable> executable,
                          BuildExecutable(local_client, result, options));
      xla::Executable* new_executable = executable->executable();
      if (stage == IrExportStage::OPTIMIZED_HLO_SERIALIZED) {
        return new_executable->module().ToProto().SerializeAsString();
      } else {

            }
"""
        app.library.writeToProject(file("greeter"))
        app.executable.writeToProject(file("app"))

        when:
        succeeds "assemble"

        then:
        executable("app/build/exe/main/debug/app").assertExists()
        file("app/build/obj/main/debug").assertHasDescendants(expectIntermediateDescendants(app.executable.original))
        installation("app/build/install/main/debug").assertInstalled()

import org.gradle.api.Incubating;

/**
 * An executable tool used for GCC that allows customizing the executable.
 */
@Incubating
public interface GccCommandLineToolConfiguration extends CommandLineToolConfiguration {
    /**
     * The name of the executable file for this tool.
     */
    String getExecutable();

    /**
     * Set the name of the executable file for this tool.