const Graph& graph,
               const FunctionLibraryDefinition& function_library),
              (const, override));

  // Just modify MLIR module so that we can check whether original TF graph
  // has changed or not.
  Status Run(const std::string& function_name, const ConfigProto& config_proto,
             mlir::ModuleOp module, const Graph& graph,

  std::unique_ptr<Graph> graph;
  TF_RETURN_IF_ERROR(ConvertMlirToGraph(module, configs, &graph, &flib_def));

  // If the entry function is exported to flib, then no graph is constructed.
  // Construct one in that case.
  if (configs.export_entry_func_to_flib) {
    graph = std::make_unique<Graph>(OpRegistry::Global());
    TF_RETURN_IF_ERROR(
        graph->mutable_flib_def()->AddLibrary(std::move(flib_def)));

  std::unique_ptr<Graph> graph;
  TF_RETURN_IF_ERROR(ConvertMlirToGraph(module, configs, &graph, &flib_def));

  // If the entry function is exported to flib, then no graph is constructed.
  // Construct one in that case.
  if (configs.export_entry_func_to_flib) {
    graph = std::make_unique<Graph>(OpRegistry::Global());
    TF_RETURN_IF_ERROR(
        graph->mutable_flib_def()->AddLibrary(std::move(flib_def)));

    }
  }
  return absl::OkStatus();
}

}  // namespace

Status InferShapes(Graph* graph, const std::map<int, InferredShape>& arg_shapes,
                   const tensorflow::FunctionLibraryDefinition* fnlib_def,
                   GraphShapeInfo* shape_info) {
  ShapeRefiner shape_refiner(graph->versions(), graph->op_registry());
  shape_refiner.set_require_shape_inference_fns(false);

// -----

// Check that tf_executor.graph does not accept any operand.
func.func @graph_with_invalid_op(%arg0: tensor<*xf32>) {
  "tf_executor.graph" (%arg0) ({}) : (tensor<*xf32>) -> ()
// expected-error@-1 {{'tf_executor.graph' op requires zero operands}}
  func.return
}

// -----

// Check that an empty graph is invalid (it needs a region).
func.func @empty_graph() {
 "tf_executor.graph" () ({

        taskGraphOps[0].details.buildPath == ":buildB"
        taskGraphOps[0].parentId == treeTaskGraphOps[0].id
        taskGraphOps[1].displayName == "Calculate task graph (:buildC)"
        taskGraphOps[1].details.buildPath == ":buildC"
        taskGraphOps[1].parentId == treeTaskGraphOps[0].id
        taskGraphOps[2].displayName == "Calculate task graph"

  // ValueGraph-level accessors
  //

  /** Returns all nodes in this graph, in the order specified by {@link #nodeOrder()}. */
  @Override
  Set<N> nodes();

  /** Returns all edges in this graph. */
  @Override
  Set<EndpointPair<N>> edges();

  /**
   * Returns a live view of this graph as a {@link Graph}. The resulting {@link Graph} will have an

        treeTaskGraphOps[0].parentId == buildSrcOps[0].id
        treeTaskGraphOps[1].displayName == "Calculate build tree task graph"
        treeTaskGraphOps[1].parentId == root.id

        def taskGraphOps = operations.all(CalculateTaskGraphBuildOperationType)
        taskGraphOps.size() == 3
        taskGraphOps[0].displayName == "Calculate task graph (:buildB:buildSrc)"

  TF_EXPECT_OK(builder.ToGraphDef(&graph_def));
  std::unique_ptr<Graph> graph(new Graph(flib_def_.get()));
  TF_CHECK_OK(GraphDefBuilderToGraph(builder, graph.get()));

  auto while_node_it = std::find_if(
      graph->nodes().begin(), graph->nodes().end(),
      [&](const Node* n) { return n->name() == kFunctionalWhileNodeName; });
  EXPECT_NE(while_node_it, graph->nodes().end());

  auto* flib_runtime = GetFunctionLibraryRuntime();

	return true
}

// disqualify records why the dependencies of m cannot be included in the module
// graph if reached from a part of the graph with the given pruning.
//
// Since the pruned graph is a subgraph of the unpruned graph, disqualifying a
// module from a pruned part of the graph also disqualifies it in the unpruned
// parts.