code: def test_uniform_neighbor_sample_edge_properties(
      return_offsets, include_hop_column
  ):
      edgelist_df = cudf.DataFrame(
          {
              "src": cudf.Series(
                  [0, 1, 2, 3, 4, 3, 4, 2, 0, 1, 0, 2], dtype="int32"
              ),
              "dst": cudf.Series(
                  [1, 2, 4, 2, 3, 4, 1, 1, 2, 3, 4, 4], dtype="int32"
              ),
              "eid": cudf.Series(
                  [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11], dtype="int32"
              ),
              "etp": cudf.Series(
                  [0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 0], dtype="int32"
              ),
              "w": [
                  0.0,
                  0.1,
                  0.2,
                  3,
                  0.4,
                  0.5,
                  0.6,
                  0.7,
                  0.8,
                  0.9,
                  0.10,
                  0.11,
              ],
          }
      )
  
      start_df = cudf.DataFrame(
          {
              "seed": cudf.Series([0, 4], dtype="int32"),
              "batch": cudf.Series([0, 1], dtype="int32"),
          }
      )
  
      G = cugraph.MultiGraph(directed=True)
      G.from_cudf_edgelist(
          edgelist_df,
          source="src",
          destination="dst",
          edge_attr=["w", "eid", "etp"],
      )
  
      sampling_results = uniform_neighbor_sample(
          G,
          start_list=start_df,
          fanout_vals=[2, 2],
          with_replacement=False,
          with_edge_properties=True,
          with_batch_ids=True,
          return_offsets=return_offsets,
          include_hop_column=include_hop_column,
      )
      if return_offsets:
          sampling_results, sampling_offsets = sampling_results
  
      edgelist_df.set_index("eid")
      assert (
          edgelist_df.loc[sampling_results.edge_id][
              "w"
          ].values_host.tolist()
          == sampling_results["weight"].values_host.tolist()
      )
      assert (
          edgelist_df.loc[sampling_results.edge_id][
              "etp"
          ].values_host.tolist()
          == sampling_results["edge_type"].values_host.tolist()
      )
      assert (
          edgelist_df.loc[sampling_results.edge_id][
              "src"
          ].values_host.tolist()
          == sampling_results["sources"].values_host.tolist()
      )
      assert (
          edgelist_df.loc[sampling_results.edge_id][
              "dst"
          ].values_host.tolist()
          == sampling_results["destinations"].values_host.tolist()
      )
  
      if include_hop_column:
          assert sampling_results["hop_id"].values_host.tolist() == (
              [0, 0, 1, 1, 1, 1] * 2
          )
      else:
          assert "hop_id" not in sampling_results
  
      if return_offsets:
          assert sampling_offsets[
              "batch_id"
          ].dropna().values_host.tolist() == [0, 1]
          if include_hop_column:
              assert sampling_offsets[
                  "offsets"
              ].dropna().values_host.tolist() == [
                  0,
                  6,
                  12,
              ]
          else:
              assert sampling_offsets[
                  "offsets"
              ].dropna().values_host.tolist() == [
                  0,
                  2,
                  6,
                  8,
                  12,
              ]
      else:
          assert sampling_results["batch_id"].values_host.tolist() == (
              [0] * 6 + [1] * 6
          )
  
imports: import gc
  import random
  import pytest
  import cupy
  import cudf
  import cugraph
  from cugraph import uniform_neighbor_sample
  from cugraph.testing import UNDIRECTED_DATASETS
  from cugraph.datasets import email_Eu_core, small_tree
  from pylibcugraph.testing.utils import gen_fixture_params_product
label_desc: Use image node_id 7 for calling a global function with example usage: test_uniform_neighbor_sample_edge_properties(return_offsets, include_hop_column) without return types