if (stream != nullptr) {
    options.device_ordinal = stream->parent()->device_ordinal();
  }
  options.device_type = xla_device_compiler.device_type();
  options.flib_def = function_library.GetFunctionLibraryDefinition();
  options.graph_def_version = function_library.graph_def_version();
  options.allow_cpu_custom_calls =
      (platform_info.platform_id() == se::host::kHostPlatformId);

  // The module contains an XLA function, as well as a while body and a while
  // condition within the XLA function.
  EXPECT_EQ(fallback_state->process_function_library_runtime()
                .GetFunctionLibraryDefinition()
                ->num_functions(),
            3);
}

TEST(SavedModelTest, ConvertTfMlirToBefExportingXlaReduceWindow) {
  std::string saved_model_mlir_path = tensorflow::GetDataDependencyFilepath(

  std::shared_ptr<const tensorflow::NodeProperties> props;
  absl::Status status = tensorflow::NodeProperties::CreateFromNodeDef(
      *nodedef_or.value(),
      params_.function_library->GetFunctionLibraryDefinition(), &props);
  if (!status.ok()) {
    return op_->emitRemark()
           << "failed to create NodeProperties: " << status.ToString();
  }
  tensorflow::OpKernel* op_kernel_raw;

    options = GenerateCompilerOptionsForTfrtTpu(*xla_device_compiler, *flr);
  } else {
    options.device_type = compilation_device_type;
    options.flib_def = flr->GetFunctionLibraryDefinition();
    options.graph_def_version = flr->graph_def_version();
    options.allow_cpu_custom_calls =
        (platform_info.platform_id() == se::host::kHostPlatformId);

CallTargetListTy GetCallTargetListFromNode(
    const Node& n, FunctionLibraryRuntime* lib_runtime) {
  const FunctionLibraryDefinition& flib_def =
      *lib_runtime->GetFunctionLibraryDefinition();
  if (flib_def.Find(n.type_string())) {
    NameAttrList callee;
    callee.set_name(n.type_string());
    *callee.mutable_attr() = n.def().attr();
    return {callee};
  }

    TF_Status* status) {
  auto* cc_ctx = reinterpret_cast<::tensorflow::OpKernelContext*>(ctx);
  auto fdef_lib =
      cc_ctx->function_library()->GetFunctionLibraryDefinition()->ToProto();
  auto cc_status =
      tensorflow::MessageToBuffer(fdef_lib, serialized_function_def_library);
  tensorflow::Set_TF_Status_from_Status(status, cc_status);
}

    LogNotCompilable(node, uncompilable_reason);
    return false;
  }

  string uncompilable_reason;
  if (IsFunctionCall(*lib_runtime->GetFunctionLibraryDefinition(), node)) {
    if (!IsCompilableCall(node.def(), lib_runtime, stack_trace,
                          encapsulating_function, uncompilable_nodes)) {
      LogNotCompilable(node, "unsupported function");