code: def test_not_connected(self):
      G = nx.complete_graph(6)
      G.add_edge(10, 11)
      G.add_edge(10, 12)
      assert nx.single_source_bellman_ford_path(G, 0) == {
          0: [0],
          1: [0, 1],
          2: [0, 2],
          3: [0, 3],
          4: [0, 4],
          5: [0, 5],
      }
      assert nx.single_source_bellman_ford_path_length(G, 0) == {
          0: 0,
          1: 1,
          2: 1,
          3: 1,
          4: 1,
          5: 1,
      }
      assert nx.single_source_bellman_ford(G, 0) == (
          {0: 0, 1: 1, 2: 1, 3: 1, 4: 1, 5: 1},
          {
              0: [0],
              1: [0, 1],
              2: [0, 2],
              3: [0, 3],
              4: [0, 4],
              5: [0, 5],
          },
      )
      assert nx.bellman_ford_predecessor_and_distance(G, 0) == (
          {0: [], 1: [0], 2: [0], 3: [0], 4: [0], 5: [0]},
          {0: 0, 1: 1, 2: 1, 3: 1, 4: 1, 5: 1},
      )
      assert nx.goldberg_radzik(G, 0) == (
          {0: None, 1: 0, 2: 0, 3: 0, 4: 0, 5: 0},
          {0: 0, 1: 1, 2: 1, 3: 1, 4: 1, 5: 1},
      )
  
      # not connected, with a component not containing the source that
      # contains a negative cycle.
      G = nx.complete_graph(6)
      G.add_edges_from(
          [
              ("A", "B", {"load": 3}),
              ("B", "C", {"load": -10}),
              ("C", "A", {"load": 2}),
          ]
      )
      assert nx.single_source_bellman_ford_path(
          G, 0, weight="load"
      ) == {
          0: [0],
          1: [0, 1],
          2: [0, 2],
          3: [0, 3],
          4: [0, 4],
          5: [0, 5],
      }
      assert nx.single_source_bellman_ford_path_length(
          G, 0, weight="load"
      ) == {
          0: 0,
          1: 1,
          2: 1,
          3: 1,
          4: 1,
          5: 1,
      }
      assert nx.single_source_bellman_ford(G, 0, weight="load") == (
          {0: 0, 1: 1, 2: 1, 3: 1, 4: 1, 5: 1},
          {
              0: [0],
              1: [0, 1],
              2: [0, 2],
              3: [0, 3],
              4: [0, 4],
              5: [0, 5],
          },
      )
      assert nx.bellman_ford_predecessor_and_distance(
          G, 0, weight="load"
      ) == (
          {0: [], 1: [0], 2: [0], 3: [0], 4: [0], 5: [0]},
          {0: 0, 1: 1, 2: 1, 3: 1, 4: 1, 5: 1},
      )
      assert nx.goldberg_radzik(G, 0, weight="load") == (
          {0: None, 1: 0, 2: 0, 3: 0, 4: 0, 5: 0},
          {0: 0, 1: 1, 2: 1, 3: 1, 4: 1, 5: 1},
      )
  
imports: import pytest
  import networkx
  from networkx.utils import pairwise
label_desc: Use image node_id 12 for calling the TestBellmanFordAndGoldbergRadzik obj's underlying member method code with example usage: obj.test_not_connected() without return types