// `variables` are the input arguments to the computation, usually read from the
// OpKernelContext, `ctx`. Requires the device-appropriate `pjrt_client` and the
// `compilation_result` used to build the `executable`.
Status RunPjRtExecutable(
    const std::vector<const Tensor*>& inputs,
    const std::vector<VariableInfo>& variables,
    const XlaCompiler::CompilationResult& compilation_result,

  }
  return RunPjRtExecutable(/*num_missing_prefix_ctx_inputs=*/0, inputs,
                           variable_snapshots, variables, compilation_result,
                           pjrt_client, executable, ctx);
}

// TODO(b/289421064): Add unit test for this.
Status RunPjRtExecutable(
    int num_missing_prefix_ctx_inputs, const std::vector<const Tensor*>& inputs,

  EXPECT_TRUE(options.untuple_result);
  EXPECT_FALSE(options.strict_shape_checking);
  EXPECT_TRUE(options.use_major_to_minor_data_layout_for_callbacks);
}

TEST_F(PjRtExecutionUtilTest, RunPjRtExecutable) {
  XlaOpRegistry::RegisterCompilationKernels();
  TF_EXPECT_OK(NodeDefBuilder("AddV2", "AddV2")
                   .Input(FakeInput(DT_INT32))
                   .Input(FakeInput(DT_INT32))

    VLOG(2) << "result != nullptr: " << (result != nullptr);
    VLOG(2) << "pjrt_executable != nullptr: " << (pjrt_executable != nullptr);
    VLOG(2) << "Executing with PJRT ...";

    OP_REQUIRES_OK(ctx, RunPjRtExecutable(inputs, variables, *result,
                                          pjrt_device_compiler->client(),
                                          pjrt_executable, ctx));

    VLOG(2) << "Completed executing with PJRT!";

            done);
        OP_REQUIRES_OK_ASYNC(ctx, LockVariables(absl::MakeSpan(variable_infos)),
                             done);
        OP_REQUIRES_OK_ASYNC(
            ctx,
            RunPjRtExecutable(inputs, variable_infos, *compilation_result,
                              pjrt_client, pjrt_executable, ctx),
            done);
      }
      VLOG(2) << "Done executing with PJRT.";
      done();
    };