struct TensorProtoHelpers {
   public:
    static ::tensorflow::TensorProto GenerateTensorProto() {
      ::tensorflow::TensorProto tensor_proto;
      tensor_proto.mutable_tensor_shape()->add_dim()->set_size(2);
      tensor_proto.mutable_tensor_shape()->add_dim()->set_size(3);
      tensor_proto.set_dtype(DT_INT32);
      tensor_proto.add_int_val(1);
      tensor_proto.add_int_val(2);
      tensor_proto.add_int_val(3);

    auto etype = complex_type.getElementType();
    if (etype.isF32()) {
      tensorflow::TensorProto repr;
      repr.set_dtype(tensorflow::DT_COMPLEX64);

      tensorflow::TensorShapeProto* shape = repr.mutable_tensor_shape();
      shape->set_unknown_rank(false);
      shape->add_dim()->set_size(int64_t{1});
      std::string content;
      auto complex_value = std::complex<float>(static_cast<float>(value), 0.0f);

}

TEST(ConstOpTest, FromProto) {
  Scope root = Scope::NewRootScope();
  TensorProto proto;
  proto.set_dtype(DT_DOUBLE);
  TensorShape({2, 2}).AsProto(proto.mutable_tensor_shape());
  for (int i = 0; i < 4; ++i) {
    proto.add_double_val(static_cast<double>(i));
  }
  auto c = ops::ConstFromProto(root, proto);
  TF_CHECK_OK(root.status());

    // Attribute for that proto, and finally splat the Attribute.

    TensorProto tensor_copy = input_tensor;
    auto* shape = tensor_copy.mutable_tensor_shape();
    shape->clear_dim();
    shape->add_dim()->set_size(1);

    TF_ASSIGN_OR_RETURN(ElementsAttr single_attr,
                        ConvertTensorProto(tensor_copy, builder));

  // them 42. Our conversion routine should not materialize these elements when
  // creating the Attribute. If it tries to, we'll crash OOM here.
  TensorProto tensor;
  tensor.set_dtype(DT_FLOAT);
  tensor.mutable_tensor_shape()->add_dim()->set_size(1ULL << 35);
  tensor.add_float_val(42.0);

  mlir::MLIRContext context;
  mlir::Builder builder(&context);
  TF_ASSERT_OK_AND_ASSIGN(mlir::ElementsAttr attribute,

          DataType dtype = n->output_type(0);
          AddNodeAttr("dtype", dtype, &const_def);
          TensorProto value;
          value.set_dtype(dtype);
          value.mutable_tensor_shape()->add_dim()->set_size(
              shape_proto.dim_size());
          for (const auto& dim : shape_proto.dim()) {
            if (dtype == DT_INT32) {
              value.add_int_val(dim.size());

    const TensorT& tensor, const std::vector<uint8_t>& buffer) {
  tensorflow::TensorProto ret;
  ret.set_dtype(TflTypeToTfType(tensor.type));

  tensorflow::TensorShapeProto* shape = ret.mutable_tensor_shape();
  shape->set_unknown_rank(false);
  for (auto dim : tensor.shape) {
    shape->add_dim()->set_size(int64_t{dim});
  }
  // TensorFlow Lite uses tflite::DynamicBufer to encode vector of strings.

  tensorflow::TensorProto repr = tfl::ConvertTfliteConstTensor(tensor, buffer);
  repr.clear_tensor_shape();
  if (tfl::IsQuantized(tensor)) {
    repr.mutable_tensor_shape()->add_dim()->set_size(buffer.size());
    repr.set_dtype(tensorflow::DT_INT8);
  } else {
    repr.mutable_tensor_shape()->add_dim()->set_size(
        buffer.size() / (shaped_type.getElementTypeBitWidth() / CHAR_BIT));
  }

    tensorflow::TensorProto tensor_proto;
    tensor_proto.set_dtype(tensorflow::DT_INT32);
    tensorflow::TensorShapeProto shape;
    shape.add_dim()->set_size(2);
    *tensor_proto.mutable_tensor_shape() = shape;
    for (int i = 0; i < 2; ++i) {
      tensor_proto.add_int_val(1);
    }
    NodeDef const_def;
    TF_CHECK_OK(NodeDefBuilder("const", "Const")
                    .Attr("dtype", DT_INT32)

                         const TensorShapeProto& shape, Graph* graph_out) {
  DataType data_type = src_node->output_type(src_port);
  TensorProto dummy_proto;
  dummy_proto.set_dtype(data_type);
  *dummy_proto.mutable_tensor_shape() = shape;
  // Don't set any value field in the proto, since it is only going to be used
  // for shape inference.

  GraphDefBuilder::Options options(graph_out, /*status=*/nullptr);