/**
     * @return the executable
     * @throws JavaHomeException when executable cannot be found
     */
    File getJavaExecutable() throws JavaHomeException;

    /**
     * @return the executable
     * @throws JavaHomeException when executable cannot be found
     */
    File getJavacExecutable() throws JavaHomeException;

    /**
     * @return the executable

            }
        """

        when:
        run "mainExecutable"

        then:
        def executable = executable("build/exe/main/main")
        executable.exec().out == "Hello!"
    }

    @ToBeFixedForConfigurationCache
    def "can build debug binaries for a C++ executable"() {
        given:
        buildFile << """
apply plugin: "cpp"

model {
    components {

  *serialized_entry.mutable_hlo_module() = hlo_module;

  // XLA compiler supports exporting executables as an AOT compilation result
  // to avoid running potentially expensive compilation pipeline twice.
  // Check if XLA compiler can export available executable.
  if (auto serialized_executable =
          compiler_client->SerializeExecutable(executable);
      serialized_executable.ok()) {

        def executable = Stub(ConfigurableComponentWithExecutable)
        executable.name >> "windowsDebug"
        executable.names >> Names.of("windowsDebug")
        executable.nativePlatform >> Stub(NativePlatformInternal)
        executable.toolChain >> Stub(NativeToolChainInternal)
        executable.platformToolProvider >> toolProvider
        executable.baseName >> Providers.of("test_app")

        this.executable = objectFactory.fileProperty();
        this.installedExecutable.set(getLibDirectory().map(directory -> directory.file(executable.getAsFile().get().getName())));
        // A further work around for missing ability to skip task when input file is missing (see #getInputFileIfExists below)
        getInputs().file(executable);

                task.getExecutableFile().set(executable.getExecutableFile());
                task.lib(executable.getRuntimeLibraries());
            });

            executable.getInstallTask().set(install);
            executable.getInstallDirectory().set(install.flatMap(task -> task.getInstallDirectory()));
            executable.getOutputs().from(executable.getInstallDirectory());

    private static ChangeContainer errorHandling(Describable executable, ChangeContainer wrapped) {
        return new ErrorHandlingChangeContainer(executable, wrapped);
    }

    private static InputFileChanges errorHandling(Describable executable, InputFileChanges wrapped) {
        ErrorHandlingChangeContainer errorHandlingChangeContainer = new ErrorHandlingChangeContainer(executable, wrapped);

# Build something to create the executable, including several cases
[short] skip

# --------------------- clean executables -------------------------

# case1: test file-named executable 'main'
env GO111MODULE=on

! exists main$GOEXE
go build main.go
exists -exec main$GOEXE
go clean
! exists main$GOEXE

# case2: test module-named executable 'a.b.c'
! exists a.b.c$GOEXE
go build
exists -exec a.b.c$GOEXE
go clean

commands: [{
    execution-subdirectory: plugin
    executable: gradle
    args: publish
},{
    execution-subdirectory: sample-build
    executable: gradle
    args: tasks
},{
    execution-subdirectory: tooling
    executable: gradle
    args: tasks

        private final File executable;

        private DefaultCommandLineGroovyJavaJointCompileSpec(File executable) {
            this.executable = executable;
        }

        @Override
        public File getExecutable() {
            return executable;
        }
    }