const XlaCompiler::CompilationResult* result;
  xla::PjRtLoadedExecutable* executable;
  CompileToExecutable(args, &result, &executable);

  std::vector<const Tensor*> inputs;
  inputs.push_back(a);
  inputs.push_back(b);
  TF_ASSERT_OK_AND_ASSIGN(auto execute_outputs,
                          RunExecutable(inputs, {}, result, executable));

  TF_EXPECT_OK(PopulateCtxOutputsFromPjRtExecutableOutputs(

  *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()) {

  MockXlaCompilerClient mock_client;
  TF_ASSERT_OK_AND_ASSIGN(auto executable, BuildSampleExecutable());
  TF_EXPECT_OK(persistor.TryToPersistExecutable(
      /*signature_hash=*/123, "signature_string", DefaultXlaOptions(),
      compilation_result_add_, *executable, &mock_client));

  auto key =
      CreateCacheKey(/*signature_hash=*/123, compilation_result_add_,

    }

    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)

    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 {

        where:
        when                                  | tool    | javaHome  | executable | errorFor
        "java home disagrees with executable" | null    | "other"   | "current"  | "executable"
        "tool disagrees with executable"      | "other" | null      | "current"  | "executable"
        "tool disagrees with java home"       | "other" | "current" | null       | "javaHome"

    snapshot_ptrs.emplace(p.first,
                          p.second.has_value() ? &p.second.value() : nullptr);
  }

  const xla::HloInputOutputAliasConfig& input_output_alias =
      executable->executable()->module().input_output_alias_config();
  absl::StatusOr<std::vector<xla::ExecutionInput>> execution_inputs =
      launch_context.PopulateInputs(ctx, result, snapshot_ptrs,

        def javaCompile = project.tasks.create("compileJava", JavaCompile)
        javaCompile.destinationDirectory.set(new File("tmp"))
        def executable = Jvm.current().javacExecutable.absolutePath

        when:
        javaCompile.options.fork = true
        javaCompile.options.forkOptions.executable = executable
        def spec = javaCompile.createSpec()

        File executable = commandLocation(command);
        if (executable.isFile()) {
            return executable;
        }

        if (userSupplied) { //then we want to validate strictly
            throw new JavaHomeException(String.format("The supplied javaHome seems to be invalid."
                + " I cannot find the %s executable. Tried location: %s", command, executable.getAbsolutePath()));

  if (run_synchronous) {
    execution_output =
        executable->Run(std::move(execution_inputs), run_options);
  } else {
    execution_output =
        executable->RunAsync(std::move(execution_inputs), run_options);
  }

  auto elapsed = env->NowMicros() - start_time;
  VLOG(2) << "Elapsed time for Xla Executable Run: " << elapsed << "us";
  return execution_output;
}

absl::StatusOr<