auto compilation_result2 = std::make_unique<XlaCompiler::CompilationResult>();
  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));

  const XlaCompiler::CompilationResult* compilation_result = nullptr;
  xla::LocalExecutable* xla_executable = nullptr;

  TF_EXPECT_OK(xla_device_compiler->CompileIfNeeded(
      options, fn, args, XlaCompiler::CompileOptions{},
      DeviceCompileMode::kStrict, profiler_, &compilation_result,
      &xla_executable));

  EXPECT_TRUE(compilation_result != nullptr);
  EXPECT_TRUE(xla_executable != nullptr);

              executable.get());

      int64_t hlo_module_size = 0;
      if (compilation_result != nullptr &&
          compilation_result->computation != nullptr) {
        hlo_module_size =
            compilation_result->computation->proto().ByteSizeLong();
      }

      return absl::StrCat(

}

void RunInThreadPoolIfCollectivesPresent(
    const XlaCompiler::CompilationResult& compilation_result,
    std::function<void()> execution_fn) {
  // If we are using collectives, we need to run in a separate threadpool.
  if (compilation_result.collective_info.has_value()) {
    GetOrCreateThreadPoolForCollective(*compilation_result.collective_info)
        ->Schedule(execution_fn);
  } else {

      DeviceCompileMode::kStrict, /*has_ref_vars=*/true,
      /*may_alias_resource_update=*/true, device_setup.flr(), &resource_mgr,
      &compilation_result, &pjrt_client, &pjrt_executable));

  EXPECT_TRUE(compilation_result != nullptr);
  EXPECT_TRUE(pjrt_executable != nullptr);
  EXPECT_TRUE(pjrt_client != nullptr);
}

TEST(PjrtCompileUtilTest, CompileToPjRtLoadedExecutableWithOpKernelContext) {
  DeviceSetup device_setup;

    OpKernelContext* ctx,
    const XlaCompiler::CompilationResult& compilation_result,
    int missing_ctx_input_prefix) {
  std::vector<VariableInfo> out;
  out.reserve(compilation_result.resource_updates.size());
  for (int i = 0; i < compilation_result.resource_updates.size(); ++i) {
    const XlaCompiler::ResourceUpdate& write =
        compilation_result.resource_updates[i];

        arg_shapes, arg_core_mapping, per_core_arg_shapes, client,
        compilation_result.get()));

    DumpHloCompilationResult("legalize_tf_fallback.hlo",
                             compilation_result.get())
        .IgnoreError();
    return *compilation_result;
  }

  auto combined_bridge_status = internal::LegalizeTfToHlo(

    const std::vector<XlaCompiler::Argument>& args,
    DeviceCompileMode compile_mode, bool has_ref_vars,
    bool may_alias_resource_update, FunctionLibraryRuntime* flr,
    ResourceMgr* rm, const XlaCompiler::CompilationResult** compilation_result,
    xla::PjRtClient** client, xla::PjRtLoadedExecutable** executable) {
  PjRtDeviceCompiler* pjrt_device_compiler;
  DeviceCompilationProfiler* profiler;

  }

  DisableXlaCompilation();

  xla::LocalClient* client = xla::ClientLibrary::LocalClientOrDie();
  DeviceType device_type = DeviceType(DEVICE_CPU_XLA_JIT);

  const XlaCompiler::CompilationResult* compilation_result;
  xla::LocalExecutable* executable;

  using XlaDeviceExecutablePersistor =
      DeviceExecutablePersistor<xla::LocalExecutable, xla::LocalClient>;

    const XlaCompiler::CompilationResult* compilation_result, int output_num);

// Converts input tensors and variables which are parameters of the
// XlaComputation into PjRtBuffers to be fed as input to the
// PjRtLoadedExecutable.
//
// Assumes that the first `num_missing_prefix_ctx_inputs` inputs to the
// compilation_result are missing in `inputs` and adjusts indexing into `inputs`
// accordingly.