TF_ASSIGN_OR_RETURN(auto executable,
                      client_->Compile(*result.computation,
                                       GetPjRtCompileOptions(options, result)));

  VLOG(2) << "Compiled PJRT executable " << executable->name()
          << " num_replicas " << executable->num_replicas()
          << " num_partitions " << executable->num_partitions();

  return std::move(executable);
}

        when:
        run "mainExecutable"

        then:
        def mainExecutable = executable("build/exe/main/main")
        mainExecutable.assertExists()
        mainExecutable.exec().out == helloWorldApp.englishOutput
    }

    @ToBeFixedForConfigurationCache
    def "build executable with custom compiler arg"() {
        given:
        buildFile << """
            model {
                components {

            assert platformToolChain.assembler.executable == 'clang'
            assert platformToolChain.cCompiler.executable == 'clang'
            assert platformToolChain.cppCompiler.executable == 'clang++'
            assert platformToolChain.objcCompiler.executable == 'clang'
            assert platformToolChain.objcppCompiler.executable == 'clang++'
            assert platformToolChain.linker.executable == 'clang++'

import org.gradle.api.GradleException;

public class ErrorHandlingChangeContainer implements ChangeContainer {
    private final Describable executable;
    private final ChangeContainer delegate;

    public ErrorHandlingChangeContainer(Describable executable, ChangeContainer delegate) {
        this.executable = executable;
        this.delegate = delegate;
    }

    @Override
    public boolean accept(ChangeVisitor visitor) {
        try {

    private final NamedDomainObjectContainer<NativeExecutableSpec> executables;
    private final NamedDomainObjectContainer<NativeLibrarySpec> libraries;

    public DefaultNativeComponentExtension(NamedDomainObjectContainer<NativeExecutableSpec> executables, NamedDomainObjectContainer<NativeLibrarySpec> libraries) {
        this.executables = executables;
        this.libraries = libraries;
    }

    @Override

	checks = append(checks,
		InPathCheck{executable: "crictl", mandatory: false, exec: execer},
		InPathCheck{executable: "conntrack", mandatory: true, exec: execer},
		InPathCheck{executable: "ip", mandatory: true, exec: execer},
		InPathCheck{executable: "iptables", mandatory: true, exec: execer},
		InPathCheck{executable: "mount", mandatory: true, exec: execer},
		InPathCheck{executable: "nsenter", mandatory: true, exec: execer},

    /**
     * @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

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

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