double abs_error) {
  auto num_inputs = inputs.size();
  std::vector<AbstractTensorHandle*> outputs(num_inputs);
  auto s = RunModel(grad_model, ctx, inputs, absl::MakeSpan(outputs),
                    /*use_function=*/use_function);
  ASSERT_EQ(errors::OK, s.code()) << s.message();

  for (int i = 0; i < num_inputs; ++i) {
    if (!outputs[i]) continue;

  const Node* identity_node = node_name_index.at("identity_op");
  EXPECT_EQ(identity_node->op_def().name(), "Identity");
  EXPECT_EQ(identity_node->attrs().FindByString("T")->type(), DT_FLOAT);

  EXPECT_EQ(identity_node->num_inputs(), 1);
  const Node* identity_input_node = nullptr;
  TF_EXPECT_OK(identity_node->input_node(0, &identity_input_node));
  EXPECT_EQ(identity_input_node->name(), "_arg0");

namespace tensorflow {

namespace {

class WhileLoopTest : public ::testing::Test {
 protected:
  WhileLoopTest() : scope_(Scope::NewRootScope()) {}

  void Init(int num_inputs, DataType dtype = DT_INT32) {
    for (int i = 0; i < num_inputs; ++i) {
      inputs_.push_back(ops::Placeholder(scope_, dtype));
    }
  }

  void CreateLoop(const ops::CondGraphBuilderFn& cond,

               absl::StatusMessageAsCStr(status));
}

void TF_ExecuteOperation(TF_AbstractOp* op, int num_inputs,
                         TF_AbstractTensor* const* inputs, TF_OutputList* o,
                         TF_Status* s) {
  for (int i = 0; i < num_inputs; i++) {
    tsl::Set_TF_Status_from_Status(s, unwrap(op)->AddInput(unwrap(inputs[i])));
    if (TF_GetCode(s) != TF_OK) {
      return;

  ASSERT_TRUE(status.ok()) << status.ToString();

  EXPECT_EQ("XTimesY", kernel_->name());
  EXPECT_EQ("XTimesY", kernel_->type_string());

  EXPECT_EQ(2, kernel_->num_inputs());
  EXPECT_EQ(DT_FLOAT, kernel_->input_type(0));
  EXPECT_EQ(DT_RESOURCE, kernel_->input_type(1));
  EXPECT_EQ(DEVICE_MEMORY, kernel_->input_memory_types()[0]);
  EXPECT_EQ(HOST_MEMORY, kernel_->input_memory_types()[1]);

        absl::AbortedError(
            "The `ids` and `calibration_methods` must have the same size."));

    // Check the number and type of inputs.
    OP_REQUIRES(context, context->num_inputs() == ids_.size() * 3,
                absl::AbortedError("The number of inputs must be  three times "
                                   "the size of the `ids` list."));
    for (int i = 0; i < ids_.size(); ++i) {

  }
  return absl::OkStatus();
}

std::vector<int> GetResourceVariableIndicesFromContext(OpKernelContext* ctx) {
  std::vector<int> out;
  for (int64 i = 0; i < ctx->num_inputs(); i++) {
    if (ctx->input(i).dtype() == DT_RESOURCE) {
      out.push_back(i);
    }
  }
  return out;
}

Status CreateVariableInfoLookup(
    absl::Span<VariableInfo const> variable_args,

const std::vector<AttrView>& OpView::Attributes() const {
  return argument_attrs_;
}

const std::vector<OpArgumentView>& OpView::AllArguments() const {
  return all_arguments_;
}

int OpView::NumInputs() const { return input_args_.size(); }

int OpView::NumOutputs() const { return output_args_.size(); }

ArgView OpView::OnlyInput() const {
  CHECK_EQ(input_args_.size(), 1);  // Crash OK
  return input_args_.front();