void MutateNodeDefs(tensorflow::GraphDef& graph_def, FuncT&& func) {
  for (tensorflow::NodeDef& node_def : *graph_def.mutable_node()) {
    func(node_def);
  }

  for (tensorflow::FunctionDef& function_def :
       *graph_def.mutable_library()->mutable_function()) {
    for (tensorflow::NodeDef& node_def : *function_def.mutable_node_def()) {
      func(node_def);
    }
  }
}

  MutateNodeDefs(graph_def,
                 [](NodeDef& node_def) { node_def.set_name("bar"); });

  ASSERT_THAT(graph_def.library().function(), SizeIs(1));
  ASSERT_THAT(graph_def.library().function()[0].node_def(), SizeIs(1));
  EXPECT_THAT(graph_def.library().function()[0].node_def()[0].name(),
              StrEq("bar"));
}

}  // namespace

      StringPiece tfr_raw_text, mlir::MLIRContext* mlir_ctx);

  // Decomposes the op in the NodeDef to a set of primitive ops according to the
  // decompose library in the context. Wrap the decomposed result in a
  // FunctionDef.
  absl::StatusOr<FunctionDef> ExpandNode(const NodeDef& node_def,
                                         StringPiece func_name);

  // Runs the decompose passes on the user_module.

    return cpu_allocator();
  }
};

void TestBitcastOp(Tensor* input_tensor, DataType out_type,
                   TensorShape expected_shape, error::Code expected_code) {
  Status status;
  NodeDef def;
  def.set_op("Bitcast");
  def.set_device(DEVICE_CPU);

  AttrValue typeAttr;
  SetAttrValue(input_tensor->dtype(), &typeAttr);

  AttrValue outTypeAttr;
  SetAttrValue(out_type, &outTypeAttr);

#include "tensorflow/core/framework/node_def.pb.h"
#include "tensorflow/core/framework/node_properties.h"
#include "tensorflow/core/lib/core/status.h"

namespace tensorflow {

class FunctionLibraryRuntime;
class OpKernel;

class XlaKernelCreator : public CustomKernelCreator {
 public:
  // Given a NodeDef 'node_def' and the function library runtime 'flr', returns

bool IsPlaceholder(const tensorflow::NodeDef& node_def);

bool IsScalarConst(const tensorflow::NodeDef& node_def, int v);

bool IsAddN(const tensorflow::NodeDef& node_def, int n);

bool IsNeg(const tensorflow::NodeDef& node_def, const string& input);

bool GetGraphDef(TF_Graph* graph, tensorflow::GraphDef* graph_def);

bool GetNodeDef(TF_Operation* oper, tensorflow::NodeDef* node_def);

  std::vector<NodeAndType> nodes;
  for (auto& node : graph.node_def()) {
    nodes.push_back({node.op(), node.attr().at("T").type()});
  }
  return nodes;
}

TEST_F(TFRDecomposeContextTest, FLOAT_1_ins) {
  std::vector<NodeDefBuilder::NodeOut> src_list;
  src_list.emplace_back("input", 0, DT_FLOAT);
  NodeDef test_node;
  auto status = NodeDefBuilder("float_add", "MyAddN")

// ShapedType for the leading values with ShapedType in the results of the
// nodes. Set it to true if the returned NodeDef will be executed by the linked
// TF Eager runtime.
absl::StatusOr<std::unique_ptr<NodeDef>> ConvertTFDialectOpToNodeDef(
    mlir::Operation* inst, llvm::StringRef name,
    bool ignore_unregistered_attrs);

}  // namespace tensorflow

// 'input_permutation' and 'output_permutation' are initialized to the identity
// permutation. 'nodedef' is the NodeDef for the call to the function under
// construction, provided to allow additional attributes to be set.
// The rewrite may also change the NodeDef's operator name, and that
// name will be used as the name of the generated function.
typedef std::function<Status(

func.func @main() {
  // The operation does not have any attributes, but TensorFlow OpDef expects
  // a `dtype` to be added on the NodeDef. We verify that we correctly use the
  // DerivedAttr to populate the NodeDef.
  // CHECK:      key: "dtype"
  // CHECK-NEXT: value {
  // CHECK-NEXT:   type: DT_FLOAT
  // CHECK:   float_val: 2
  // CHECK:      key: "dtype"
  // CHECK-NEXT: value {