code: def input_expected_output(input_combo):
      """
      This fixture returns the inputs and expected results from the edge
      betweenness centrality algo.
      (based on cuGraph edge betweenness centrality) which can be used
      for validation.
      """
      directed = input_combo["directed"]
      normalized = input_combo["normalized"]
      k = input_combo["subset_size"]
      subset_seed = 42
      edge_ids = input_combo["include_edge_ids"]
      weight = input_combo["include_weights"]
  
      df = input_combo["graph_file"].get_edgelist()
      if edge_ids:
          if not directed:
              # Edge ids not supported for undirected graph
              return
          dtype = df.dtypes[0]
          edge_id = "edge_id"
          df["edge_id"] = df.index
          df = df.astype(dtype)
  
      else:
          edge_id = None
  
      G = cugraph.Graph(directed=directed)
      G.from_cudf_edgelist(
          df,
          source="src",
          destination="dst",
          weight="wgt",
          edge_id=edge_id,
      )
      if isinstance(k, int):
          k = G.select_random_vertices(subset_seed, k)
  
      input_combo["k"] = k
      # Save the results back to the input_combo dictionary to prevent redundant
      # cuGraph runs. Other tests using the input_combo fixture will look for
      # them, and if not present they will have to re-run the same cuGraph call.
      sg_cugraph_edge_bc = (
          cugraph.edge_betweenness_centrality(G, k, normalized)
          .sort_values(["src", "dst"])
          .reset_index(drop=True)
      )
  
      input_data_path = input_combo["graph_file"].get_path()
  
      input_combo["sg_cugraph_results"] = sg_cugraph_edge_bc
      chunksize = dcg.get_chunksize(input_data_path)
      ddf = dask_cudf.read_csv(
          input_data_path,
          chunksize=chunksize,
          delimiter=" ",
          names=["src", "dst", "value"],
          dtype=["int32", "int32", "float32"],
      )
  
      if weight:
          weight = ddf
      else:
          weight = None
  
      if edge_ids:
          dtype = ddf.dtypes[0]
          edge_id = "edge_id"
          ddf = ddf.assign(idx=1)
          ddf["edge_id"] = ddf.idx.cumsum().astype(dtype) - 1
      else:
          edge_id = None
  
      dg = cugraph.Graph(directed=directed)
  
      dg.from_dask_cudf_edgelist(
          ddf,
          source="src",
          destination="dst",
          weight="value",
          edge_id=edge_id,
          renumber=True,
      )
  
      input_combo["MGGraph"] = dg
      input_combo["include_weights"] = weight
  
      return input_combo
  
file_path: cugraph/python/cugraph/cugraph/tests/centrality/test_edge_betweenness_centrality_mg.py
imports: import gc
  import pytest
  import dask_cudf
  from pylibcugraph.testing.utils import gen_fixture_params_product
  from cugraph.datasets import karate, dolphins
  import cugraph
  import cugraph.dask
label_desc: Use image node_id 3 for calling a global function with example usage: input_expected_output(input_combo) and returns: input_combo