Output arg0 = ops::_Arg(s.WithOpName("arg0"), DT_INT32, 0);
  Output arg1 = ops::_Arg(s.WithOpName("arg1"), DT_FLOAT, 1);
  Output arg2 = ops::_Arg(s.WithOpName("arg2"), DT_INT32, 2);
  Output add = ops::Add(s.WithOpName("add"), arg0, arg0);
  auto ret0 = ops::_Retval(s.WithOpName("ret0"), add, 0);
  auto ret1 = ops::_Retval(s.WithOpName("ret1"), arg1, 1);

  Output a = ops::Placeholder(root.WithOpName("a"), DT_FLOAT);
  Output b = ops::Shape(in_cluster_and.WithOpName("b"), a);
  Output c = ops::Rank(in_cluster_and.WithOpName("c"), b);
  Output d = ops::Size(in_cluster_and.WithOpName("d"), c);
  (void)ops::Shape(in_cluster_and.WithOpName("e"), d);

  auto graph = std::make_unique<Graph>(OpRegistry::Global());

  auto q0 = FIFOQueue(root.WithOpName(kQueueName), {DataType::DT_FLOAT});
  Output rnd = RandomNormal(root.WithOpName("rnd"), {1, 1}, DataType::DT_FLOAT);
  Output square = Square(root.WithOpName(kSquareOpName), rnd);
  auto enqueue0 = QueueEnqueue(root.WithOpName(kEnqueueOp0), q0, {square});
  auto close0 = QueueClose(root.WithOpName(kCloseOp0), q0);
  auto cancel0 = QueueClose(root.WithOpName(kCancelOp0), q0,

  // "identity" = "add"
  tensorflow::Scope s = tensorflow::Scope::NewRootScope();
  Output const_0 = ops::Const(s.WithOpName("const_0"), 1, {2});
  Output const_1 = ops::Const(s.WithOpName("const_1"), 2, {2});
  Output add = ops::Add(s.WithOpName("add"), const_0, const_1);
  Output identity = ops::Identity(s.WithOpName("identity"), add);
  Graph g(OpRegistry::Global());
  TF_CHECK_OK(s.ToGraph(&g));

    }

    DCHECK_EQ(slice_inputs.size_as_vector[i], -1);

    Output begin_i = ops::Slice(
        host_scope.WithOpName("begin_", i), slice_inputs.begin,
        constant_pool.Get1DHostConstant(i), constant_pool.Get1DHostConstant(1));

    Output input_shape_i = ops::Slice(
        host_scope.WithOpName("input_shape_", i), input_shape,
        constant_pool.Get1DHostConstant(i), constant_pool.Get1DHostConstant(1));

  Output init_value = ops::Placeholder(root.WithOpName("init"), DT_FLOAT);
  Output loop_cond = ops::Placeholder(root.WithOpName("init"), DT_BOOL);
  Output enter_value =
      ops::internal::Enter(root.WithOpName("enter"), init_value, "fr");
  ops::Merge iv(root.WithOpName("iv"), {enter_value, enter_value});
  ops::Switch latch(root.WithOpName("latch"), iv.output, loop_cond);

  auto x = ops::Const(root.WithOpName("x"), 1);
  EXPECT_EQ(x.node()->name(), "x");
  auto x_1 = ops::Const(root.WithOpName("x"), 1);
  EXPECT_EQ(x_1.node()->name(), "x_1");

  Scope child = root.NewSubScope("c");
  auto c_y = ops::Const(child.WithOpName("y"), 1);
  EXPECT_EQ(c_y.node()->name(), "c/y");
  auto c_y_1 = ops::Const(child.WithOpName("y"), 1);
  EXPECT_EQ(c_y_1.node()->name(), "c/y_1");
}

  // x = [1.0; 1.0]
  auto x = Const(root.WithOpName("x"), {{1.f}, {1.f}});
  // y = a * x
  auto y = MatMul(root.WithOpName("y"), a, x);
  // y2 = y.^2
  auto y2 = Square(root, y);
  // y2_sum = sum(y2)
  auto y2_sum = Sum(root, y2, 0);
  // y_norm = sqrt(y2_sum)
  auto y_norm = Sqrt(root, y2_sum);
  // y_normalized = y ./ y_norm
  auto y_normalized = Div(root.WithOpName("y_normalized"), y, y_norm);
  Tensor out;

  EXPECT_EQ(c_c.control_deps().size(), 3);
}

TEST(ScopeTest, CreateOutput) {
  Scope root = Scope::NewRootScope();
  Output a = ops::Placeholder(root.WithOpName("a"), DT_FLOAT);
  Output add;
  ASSERT_TRUE(
      CreateOutputWithScope("Add", {a, a}, root.WithOpName("add"), &add).ok());
  EXPECT_EQ(add.node()->name(), "add");
  EXPECT_EQ(add.node()->type_string(), "Add");
}

  std::unique_ptr<Graph> graph(new Graph(OpRegistry::Global()));
  Scope scope = Scope::NewRootScope().ExitOnError();
  auto a = ops::_Arg(scope.WithOpName("A"), DT_INT32, 0);
  auto b = ops::_Arg(scope.WithOpName("B"), DT_INT32, 1);
  auto c = ops::Add(scope.WithOpName("C"), a, b);
  auto d = ops::_Retval(scope.WithOpName("D"), c, 0);
  TF_RETURN_IF_ERROR(scope.ToGraph(graph.get()));
  return graph;
}