code: def test_mg_uniform_neighbor_sample_simple(dask_client, input_combo):
      dg = input_combo["MGGraph"]
  
      input_df = dg.input_df
      result_nbr = uniform_neighbor_sample(
          dg,
          input_combo["start_list"],
          input_combo["fanout_vals"],
          with_replacement=input_combo["with_replacement"],
      )
  
      # multi edges are dropped to easily verify that each edge in the
      # results is present in the input dataframe
      result_nbr = result_nbr.drop_duplicates()
  
      # FIXME: The indices are not included in the comparison because garbage
      # value are intermittently retuned. This observation is observed when
      # passing float weights
      join = result_nbr.merge(
          input_df,
          left_on=[*result_nbr.columns[:2]],
          right_on=[*input_df.columns[:2]],
      )
  
      if len(result_nbr) != len(join):
          join2 = input_df.merge(
              result_nbr,
              how="right",
              left_on=[*input_df.columns],
              right_on=[*result_nbr.columns],
          )
          # The left part of the datasets shows which edge is missing from the
          # right part where the left and right part are respectively the
          # uniform-neighbor-sample results and the input dataframe.
          difference = (
              join2.sort_values([*result_nbr.columns])
              .compute()
              .to_pandas()
              .query("src.isnull()", engine="python")
          )
  
          invalid_edge = difference[difference.columns[:3]]
          raise Exception(
              f"\nThe edges below from uniform-neighbor-sample "
              f"are invalid\n {invalid_edge}"
          )
  
      # Ensure the right indices type is returned
      assert result_nbr["indices"].dtype == input_combo["indices_type"]
  
      sampled_vertex_result = (
          dask_cudf.concat(
              [result_nbr["sources"], result_nbr["destinations"]]
          )
          .drop_duplicates()
          .compute()
          .reset_index(drop=True)
      )
  
      sampled_vertex_result = sampled_vertex_result.to_pandas()
      start_list = input_combo["start_list"].to_pandas()
  
      if not set(start_list).issubset(set(sampled_vertex_result)):
          missing_vertex = set(start_list) - set(sampled_vertex_result)
          missing_vertex = list(missing_vertex)
          # compute the out-degree of the missing vertices
          out_degree = dg.out_degree(missing_vertex)
  
          out_degree = out_degree[out_degree.degree != 0]
          # If the missing vertices have outgoing edges, return an error
          if len(out_degree) != 0:
              missing_vertex = (
                  out_degree["vertex"].compute().to_pandas().to_list()
              )
              raise Exception(
                  f"vertex {missing_vertex} is missing from "
                  f"uniform neighbor sampling results"
              )
  
imports: import gc
  import random
  import os
  import pytest
  import pandas
  import cupy
  import cudf
  import cugraph
  import dask_cudf
  import cugraph.dask
  from cugraph.testing import UNDIRECTED_DATASETS
  from cugraph.dask import uniform_neighbor_sample
  from cugraph.dask.common.mg_utils import is_single_gpu
  from cugraph.datasets import email_Eu_core, small_tree
  from pylibcugraph.testing.utils import gen_fixture_params_product
label_desc: Use image node_id 3 for calling a global function with example usage: test_mg_uniform_neighbor_sample_simple(dask_client, input_combo) without return types