code: def test_edge_vector_property(dask_client):
      from cugraph.experimental import MGPropertyGraph
  
      df1 = cudf.DataFrame(
          {
              "src": [0, 1],
              "dst": [1, 2],
              "feat_0": [1, 2],
              "feat_1": [10, 20],
              "feat_2": [10, 20],
          }
      )
      dd1 = dask_cudf.from_cudf(df1, npartitions=2)
      df2 = cudf.DataFrame(
          {
              "src": [2, 3],
              "dst": [1, 2],
              "feat_0": [0.5, 0.2],
              "feat_1": [1.5, 1.2],
          }
      )
      dd2 = dask_cudf.from_cudf(df2, npartitions=2)
      pG = MGPropertyGraph()
      pG.add_edge_data(
          dd1,
          ("src", "dst"),
          vector_properties={"vec1": ["feat_0", "feat_1", "feat_2"]},
      )
      df = pG.get_edge_data()
      expected_columns = {
          pG.edge_id_col_name,
          pG.src_col_name,
          pG.dst_col_name,
          pG.type_col_name,
          "vec1",
      }
      assert set(df.columns) == expected_columns
      expected = df1[["feat_0", "feat_1", "feat_2"]].values
      expected = expected[
          np.lexsort(expected.T)
      ]  # may be jumbled, so sort
  
      pGalt = MGPropertyGraph()
      pGalt.add_edge_data(dd1, ("src", "dst"), vector_property="vec1")
      dfalt = pG.get_edge_data()
  
      for cur_pG, cur_df in [(pG, df), (pGalt, dfalt)]:
          vec1 = cur_pG.edge_vector_property_to_array(
              cur_df, "vec1"
          ).compute()
          vec1 = vec1[np.lexsort(vec1.T)]  # may be jumbled, so sort
          assert_array_equal(vec1, expected)
          vec1 = cur_pG.edge_vector_property_to_array(
              cur_df, "vec1", missing="error"
          ).compute()
          vec1 = vec1[np.lexsort(vec1.T)]  # may be jumbled, so sort
          assert_array_equal(vec1, expected)
  
      pG.add_edge_data(
          dd2,
          ("src", "dst"),
          vector_properties={"vec2": ["feat_0", "feat_1"]},
      )
      df = pG.get_edge_data()
      expected_columns.add("vec2")
      assert set(df.columns) == expected_columns
      expected = df2[["feat_0", "feat_1"]].values
      expected = expected[
          np.lexsort(expected.T)
      ]  # may be jumbled, so sort
      vec2 = pG.edge_vector_property_to_array(df, "vec2").compute()
      vec2 = vec2[np.lexsort(vec2.T)]  # may be jumbled, so sort
      assert_array_equal(vec2, expected)
      with pytest.raises(RuntimeError):
          pG.edge_vector_property_to_array(
              df, "vec2", missing="error"
          ).compute()
  
imports: import gc
  import pytest
  import pandas
  import numpy
  import cudf
  import cugraph
  import dask_cudf
  import cupy
  import cugraph.dask
  from cupy.testing import assert_array_equal
  from cudf.testing import assert_frame_equal, assert_series_equal
  from pylibcugraph.testing.utils import gen_fixture_params_product
  from cugraph.dask.common.mg_utils import is_single_gpu
  from cugraph.datasets import cyber, netscience
label_desc: Use image node_id 28 for calling a global function with example usage: test_edge_vector_property(dask_client) without return types