class ExecutableClosure {
 public:
  explicit ExecutableClosure(
      ClientType* client, ExecutableType* executable,
      const XlaCompiler::CompilationResult* compilation_result,
      ResourceVarsSnapshot resource_var_snapshots, int num_constant_args)
      : client_(client),
        executable_(executable),
        compilation_result_(compilation_result),
        resource_var_snapshots_(std::move(resource_var_snapshots)),

// needed, [path/filepath.EvalSymlinks] might help.
//
// Executable returns an absolute path unless an error occurred.
//
// The main use case is finding resources located relative to an
// executable.
func Executable() (string, error) {
	return executable()

  auto executable1 = std::make_unique<FakeExecutable>("foo_exe");
  auto executable2 = std::make_unique<FakeExecutable>("bar_exe");
  cache->Store(key1, DeviceCompileState::kCompiled,
               errors::InvalidArgument("Invalid argument."),
               std::move(compilation_result1), std::move(executable1));
  cache->Store(key2, DeviceCompileState::kCompiling, absl::OkStatus(),

        this.pathEntries.addAll(pathEntries);
        executables.clear();
    }

    public void path(File pathEntry) {
        pathEntries.add(pathEntry);
        executables.clear();
    }

    public CommandLineToolSearchResult locate(ToolType key, String exeName) {
        File executable = executables.get(exeName);
        if (executable == null) {
            executable = findExecutable(operatingSystem, exeName);

  TF_ASSIGN_OR_RETURN(
      auto executables,
      client_->Compile(*result.computation, argument_layouts, build_options));
  TF_RET_CHECK(executables.size() == 1);
  return std::move(executables[0]);
}

absl::StatusOr<std::string> XlaDeviceCompilerClient::SerializeExecutable(
    const xla::LocalExecutable& executable) {
  if (executable.executable() == nullptr) {
    return errors::FailedPrecondition(

//go:build wasm

package exec

import (
	"errors"
)

// ErrNotFound is the error resulting if a path search failed to find an executable file.
var ErrNotFound = errors.New("executable file not found in $PATH")

// LookPath searches for an executable named file in the
// directories named by the PATH environment variable.
// If file contains a slash, it is tried directly and the PATH is not consulted.

        then:
        executable("build/exe/main/arm/main").arch.name == "x86"
        executable("build/exe/main/arm/main").exec().out == helloWorldApp.frenchOutput

        executable("build/exe/main/i386/main").arch.name == "x86"
        executable("build/exe/main/i386/main").exec().out == helloWorldApp.englishOutput

        executable("build/exe/main/sparc/main").exec().out == helloWorldApp.englishOutput

template <typename ExecutableType>
int64_t ExecutableSize(const ExecutableType* executable) {
  return 0;
}

template <>
inline int64_t ExecutableSize<xla::LocalExecutable>(
    const xla::LocalExecutable* executable) {
  if (executable != nullptr && executable->executable() != nullptr) {
    return executable->executable()->SizeOfGeneratedCodeInBytes();
  }

  return 0;
}

template <>

        // Relying on the layout of the toolchain distribution: <JAVA HOME>/bin/<executable>
        return resolveExecutable(executable).getParentFile().getParentFile();
    }


    public static void validateExecutable(@Nullable String executable, String executableDescription, File referenceFile, String referenceDescription) {
        if (executable == null) {
            return;
        }

# 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