// 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()

  EXPECT_TRUE(cache_value->executable != nullptr);
  EXPECT_EQ(cache_value->executable->data, "foo_exe");
}

TEST(DeviceCompilationCacheTest, StoreLookupOrCreate) {
  auto cache = std::make_unique<Cache>();

  TF_ASSERT_OK_AND_ASSIGN(auto key, BuildSampleSignature("foo"));
  auto compilation_result = std::make_unique<XlaCompiler::CompilationResult>();
  auto executable = std::make_unique<FakeExecutable>("foo_exe");

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

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

        "test"        | "executable" | []                                         | null       | "test/executable"
        "test"        | "executable" | ["one", "two"]                             | null       | "test/executable/one/two"
        "mainLibrary" | "executable" | ["enterpriseEdition", "osx_x64", "static"] | null       | "mainLibrary/executable/enterpriseEdition/osx_x64/static"

        def binary = new File("any")
        when:
        def metadata = metadataProvider(compiler).getCompilerMetaData([]) { it.executable(binary) }

        then:
        interaction compilerShouldBeExecuted

        when:
        def newMetadata = metadataProvider(compiler).getCompilerMetaData([]) { it.executable(binary) }

        then:
        0 * _
        newMetadata.is(metadata)

        where:

    /**
     * Returns the name of the executable to use.
     *
     * @return The executable.
     */
    String getExecutable();

    /**
     * Sets the name of the executable to use.
     *
     * @param executable The executable. Must not be null.
     * @since 4.0
     */
    void setExecutable(String executable);

    /**
     * Sets the name of the executable to use.
     *

  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(