node {
  name: "Const"
  op: "Const"
  attr {
    key: "dtype"
    value {
      type: DT_INT32
    }
  }
  attr {
    key: "value"
    value {
      tensor {
        dtype: DT_INT32
        tensor_shape {
        }
        int_val: 0
      }
    }
  }
}
node {
  name: "Enter"
  op: "Enter"
  input: "Const"
  attr {
    key: "T"
    value {
      type: DT_INT32
    }
  }

  op: "Const"
  attr {
    key: "dtype"
    value {
      type: DT_FLOAT
    }
  }
  attr {
    key: "value"
    value {
      tensor {
        dtype: DT_FLOAT
        tensor_shape {
          dim {
            size: 3
          }
          dim {
            size: 3
          }
          dim {
            size: 2
          }
          dim {
            size: 2
          }

node {
  name: "tf.Const"
  op: "Const"
  attr {
    key: "dtype"
    value {
      type: DT_INT32
    }
  }
  attr {
    key: "value"
    value {
      tensor {
        dtype: DT_INT32
        tensor_shape {
          dim {
            size: 10
          }
        }
        int_val: 0
      }
    }
  }
  experimental_debug_info {
  }
}
node {
  name: "tf.Const1"
  op: "Const"
  attr {

  void BM_ScalarSummary##name##device(::testing::benchmark::State& state) { \
    TensorShape tensorshape(DIMARGS dims);                                  \
    auto g = BM_ScalarSummaryOp(tensorshape, #tag, value);                  \
    test::Benchmark("cpu", g, /*old_benchmark_api=*/false).Run(state);      \
  }                                                                         \

        key: "dtype"
        value {
          type: DT_FLOAT
        }
      }
      attr {
        key: "value"
        value {
          tensor {
            dtype: DT_FLOAT
            tensor_shape {
            }
            float_val: 7
          }
        }
      }
    }
    ret {
      key: "constant"
      value: "X:output:0"
    }
    # This should be modeled as unit attribute

  attr {
    key: "dtype"
    value {
      type: DT_INT32
    }
  }
  attr {
    key: "value"
    value {
      tensor {
        dtype: DT_INT32
        tensor_shape {
          dim {
            size: 1
          }
        }
        int_val: 0
      }
    }
  }
}
node {
  name: "metrics_2/sparse_categorical_accuracy/ArgMax/dimension"
  op: "Const"

  op: "Const"
  attr {
    key: "dtype"
    value {
      type: DT_FLOAT
    }
  }
  attr {
    key: "value"
    value {
      tensor {
        dtype: DT_FLOAT
        tensor_shape {
        }
        float_val: 2.0
      }
    }
  }
}
node {
  name: "var1_add"
  op: "AssignAddVariableOp"
  input: "arg1"
  input: "var1_add/value"
  attr {
    key: "dtype"

#define TENSORFLOW_COMPILER_MLIR_TF2XLA_INTERNAL_UTILS_TEST_METADATA_CONFIG_H_

#include <variant>
#include <vector>

#include "absl/strings/string_view.h"
#include "tensorflow/core/framework/tensor_shape.h"
#include "tensorflow/core/protobuf/tpu/compile_metadata.pb.h"

namespace tensorflow {
namespace tf2xla {
namespace internal {

// Fills in arg_shapes and metadata_proto with appropriate values based on the

  ASSERT_EQ(tensor.shape().DebugString(), ShapeDebugString(tf_tensor));
}

TEST(ShapeDebugString, RegularShape) { TestShapeMatch(TensorShape({5, 4, 7})); }

TEST(ShapeDebugString, ScalarShape) { TestShapeMatch(TensorShape({})); }

}  // namespace

  op: "Const"
  attr {
    key: "dtype"
    value {
      type: DT_FLOAT
    }
  }
  attr {
    key: "value"
    value {
      tensor {
        dtype: DT_FLOAT
        tensor_shape {
          dim {
            size: 1
          }
          dim {
            size: 1
          }
          dim {
            size: 256
          }
          dim {
            size: 186