code: def input_expected_output(input_combo):
      """
      This fixture returns the inputs and expected results from the
      betweenness_centrality algo based on cuGraph betweenness_centrality) which can
      be used for validation.
      """
  
      input_data_path = input_combo["graph_file"]
      normalized = input_combo["normalized"]
      endpoints = input_combo["endpoints"]
      random_state = input_combo["subset_seed"]
      subset_size = input_combo["subset_size"]
      directed = input_combo["directed"]
      vertex_list_type = input_combo["vertex_list_type"]
  
      G = utils.generate_cugraph_graph_from_file(
          input_data_path, directed=directed
      )
  
      if subset_size is None:
          k = subset_size
      elif isinstance(subset_size, int):
          # Select random vertices
          k = G.select_random_vertices(
              random_state=random_state, num_vertices=subset_size
          )
          if vertex_list_type is list:
              k = k.to_arrow().to_pylist()
  
          print("the seeds are \n", k)
          if vertex_list_type is int:
              # This internally sample k vertices in betweenness centrality.
              # Since the nodes that will be sampled by each implementation will
              # be random, therefore sample all vertices which will make the test
              # consistent.
              k = len(G.nodes())
  
      input_combo["k"] = k
  
      sg_cugraph_bc = cugraph.betweenness_centrality(
          G,
          k=k,
          normalized=normalized,
          endpoints=endpoints,
          random_state=random_state,
      )
      # 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_bc = sg_cugraph_bc.sort_values("vertex").reset_index(
          drop=True
      )
  
      input_combo["sg_cugraph_results"] = sg_cugraph_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"],
      )
  
      dg = cugraph.Graph(directed=directed)
      dg.from_dask_cudf_edgelist(
          ddf,
          source="src",
          destination="dst",
          edge_attr="value",
          renumber=True,
          store_transposed=True,
      )
  
      input_combo["MGGraph"] = dg
  
      return input_combo
  
file_path: cugraph/python/cugraph/cugraph/tests/centrality/test_betweenness_centrality_mg.py
imports: import gc
  import pytest
  import dask_cudf
  import cupy
  import cudf
  import cugraph
  import cugraph.dask
  from cugraph.testing import utils
  from pylibcugraph.testing import gen_fixture_params_product
label_desc: Use image node_id 3 for calling a global function with example usage: input_expected_output(input_combo) and returns: input_combo