EXPECT_EQ(root.GetUniqueNameForOp("foo_1"), "foo_1_1");
  EXPECT_EQ(root.GetUniqueNameForOp("foo_2"), "foo_2");
  EXPECT_EQ(root.GetUniqueNameForOp("foo"), "foo_3");
  EXPECT_EQ(root.GetUniqueNameForOp("foo_2"), "foo_2_1");
}

TEST(ScopeTest, HierarchicalNames) {
  Scope root = Scope::NewRootScope();
  Scope child = root.NewSubScope("child");
  EXPECT_EQ(child.GetUniqueNameForOp("add"), "child/add");

  // can be directly called here instead of adding the Cast op to the graph.
  auto orig_const = AsNodeOut(scope, orig_const_output);
  const auto cast_op_name = scope.GetUniqueNameForOp("Cast");

  auto cast_builder = NodeBuilder(cast_op_name, "Cast")
                          .Input(orig_const)
                          .Attr("DstT", DataTypeToEnum<DstT>::v());
  scope.UpdateBuilder(&cast_builder);

  std::shared_ptr<NameMap> name_map_ = nullptr;
  std::shared_ptr<ShapeRefiner> refiner_ = nullptr;

  // If scope_used_ is not nullptr, op_name_ should be empty and
  // GetUniqueNameForOp can only be called once on this scope. More calls to
  // GetUniqueNameForOp will cause an error status to be set on this scope.
  std::shared_ptr<bool> scope_used_ = nullptr;

  const std::vector<Operation> control_deps_;

template <typename T>
Output ConstHelper(const Scope& scope, const T& value, DataType dtype) {
  if (!scope.ok()) return Output();

  Node* ret;
  Graph* graph = scope.graph();
  const string unique_name = scope.GetUniqueNameForOp("Const");
  auto builder = NodeBuilder(unique_name, "Const")
                     .Attr("value", value)
                     .Attr("dtype", dtype);
  scope.UpdateBuilder(&builder);

                                  next_output_index, dtype);

  std::vector<NodeBuilder::NodeOut> input_list({enter_input, next_input});
  const string unique_name = scope.GetUniqueNameForOp("Merge");
  NodeBuilder builder = NodeBuilder(unique_name, "Merge").Input(input_list);
  scope.UpdateBuilder(&builder);

  Node* merge_node;
  TF_RETURN_IF_ERROR(builder.Finalize(scope.graph(), &merge_node));