okstra 0.114.0 → 0.115.0

package/runtime/python/okstra_vendor/networkx/algorithms/connectivity/tests/test_kcomponents.py

@@ -1,323 +0,0 @@
-# Test for Moody and White k-components algorithm
-import pytest
-
-import networkx as nx
-from networkx.algorithms import flow
-from networkx.algorithms.connectivity.kcomponents import (
-    _consolidate,
-    build_k_number_dict,
-)
-
-FLOW_FUNCS = (
-    flow.boykov_kolmogorov,
-    flow.dinitz,
-    flow.edmonds_karp,
-    flow.preflow_push,
-    flow.shortest_augmenting_path,
-)
-
-
-##
-# A nice synthetic graph
-##
-def torrents_and_ferraro_graph():
-    # Graph from https://arxiv.org/pdf/1503.04476v1 p.26
-    G = nx.convert_node_labels_to_integers(
-        nx.grid_graph([5, 5]), label_attribute="labels"
-    )
-    rlabels = nx.get_node_attributes(G, "labels")
-    labels = {v: k for k, v in rlabels.items()}
-
-    for nodes in [(labels[(0, 4)], labels[(1, 4)]), (labels[(3, 4)], labels[(4, 4)])]:
-        new_node = G.order() + 1
-        # Petersen graph is triconnected
-        P = nx.petersen_graph()
-        G = nx.disjoint_union(G, P)
-        # Add two edges between the grid and P
-        G.add_edge(new_node + 1, nodes[0])
-        G.add_edge(new_node, nodes[1])
-        # K5 is 4-connected
-        K = nx.complete_graph(5)
-        G = nx.disjoint_union(G, K)
-        # Add three edges between P and K5
-        G.add_edge(new_node + 2, new_node + 11)
-        G.add_edge(new_node + 3, new_node + 12)
-        G.add_edge(new_node + 4, new_node + 13)
-        # Add another K5 sharing a node
-        G = nx.disjoint_union(G, K)
-        nbrs = G[new_node + 10]
-        G.remove_node(new_node + 10)
-        for nbr in nbrs:
-            G.add_edge(new_node + 17, nbr)
-        # This edge makes the graph biconnected; it's
-        # needed because K5s share only one node.
-        G.add_edge(new_node + 16, new_node + 8)
-
-    for nodes in [(labels[(0, 0)], labels[(1, 0)]), (labels[(3, 0)], labels[(4, 0)])]:
-        new_node = G.order() + 1
-        # Petersen graph is triconnected
-        P = nx.petersen_graph()
-        G = nx.disjoint_union(G, P)
-        # Add two edges between the grid and P
-        G.add_edge(new_node + 1, nodes[0])
-        G.add_edge(new_node, nodes[1])
-        # K5 is 4-connected
-        K = nx.complete_graph(5)
-        G = nx.disjoint_union(G, K)
-        # Add three edges between P and K5
-        G.add_edge(new_node + 2, new_node + 11)
-        G.add_edge(new_node + 3, new_node + 12)
-        G.add_edge(new_node + 4, new_node + 13)
-        # Add another K5 sharing two nodes
-        G = nx.disjoint_union(G, K)
-        nbrs = G[new_node + 10]
-        G.remove_node(new_node + 10)
-        for nbr in nbrs:
-            G.add_edge(new_node + 17, nbr)
-        nbrs2 = G[new_node + 9]
-        G.remove_node(new_node + 9)
-        for nbr in nbrs2:
-            G.add_edge(new_node + 18, nbr)
-    return G
-
-
-def test_directed():
-    with pytest.raises(nx.NetworkXNotImplemented):
-        G = nx.gnp_random_graph(10, 0.2, directed=True, seed=42)
-        nx.k_components(G)
-
-
-def test_empty_k_components():
-    G = nx.empty_graph(5)
-    assert nx.k_components(G) == {}
-
-
-@pytest.mark.parametrize("flow_func", FLOW_FUNCS)
-def test_k_components_alternative_flow_func(flow_func):
-    G = nx.lollipop_graph(5, 5)
-    result = nx.k_components(G, flow_func=flow_func)
-    _check_connectivity(G, result)
-
-
-# Helper function
-def _check_connectivity(G, k_components):
-    for k, components in k_components.items():
-        if k < 3:
-            continue
-        # check that k-components have node connectivity >= k.
-        for component in components:
-            C = G.subgraph(component)
-            K = nx.node_connectivity(C)
-            assert K >= k
-
-
-@pytest.mark.slow
-def test_torrents_and_ferraro_graph():
-    G = torrents_and_ferraro_graph()
-    result = nx.k_components(G)
-    _check_connectivity(G, result)
-
-    # In this example graph there are 8 3-components, 4 with 15 nodes
-    # and 4 with 5 nodes.
-    assert len(result[3]) == 8
-    assert len([c for c in result[3] if len(c) == 15]) == 4
-    assert len([c for c in result[3] if len(c) == 5]) == 4
-    # There are also 8 4-components all with 5 nodes.
-    assert len(result[4]) == 8
-    assert all(len(c) == 5 for c in result[4])
-
-
-@pytest.mark.parametrize(
-    ("n", "p"), [(10, 0.6), pytest.param(50, 0.2, marks=pytest.mark.slow)]
-)
-def test_random_gnp(n, p):
-    G = nx.gnp_random_graph(n, p, seed=42)
-    result = nx.k_components(G)
-    _check_connectivity(G, result)
-
-
-@pytest.mark.parametrize(
-    "constructor",
-    [
-        [(5, 8, 0.8), (8, 15, 0.6), (5, 24, 0.2)],
-        pytest.param([(20, 80, 0.8), (80, 180, 0.6)], marks=pytest.mark.slow),
-    ],
-)
-def test_shell(constructor):
-    G = nx.random_shell_graph(constructor, seed=42)
-    result = nx.k_components(G)
-    _check_connectivity(G, result)
-
-
-def test_configuration():
-    deg_seq = nx.random_powerlaw_tree_sequence(100, tries=5, seed=72)
-    G = nx.Graph(nx.configuration_model(deg_seq))
-    G.remove_edges_from(nx.selfloop_edges(G))
-    result = nx.k_components(G)
-    _check_connectivity(G, result)
-
-
-def test_karate():
-    G = nx.karate_club_graph()
-    result = nx.k_components(G)
-    _check_connectivity(G, result)
-
-
-def test_karate_component_number():
-    karate_k_num = {
-        0: 4,
-        1: 4,
-        2: 4,
-        3: 4,
-        4: 3,
-        5: 3,
-        6: 3,
-        7: 4,
-        8: 4,
-        9: 2,
-        10: 3,
-        11: 1,
-        12: 2,
-        13: 4,
-        14: 2,
-        15: 2,
-        16: 2,
-        17: 2,
-        18: 2,
-        19: 3,
-        20: 2,
-        21: 2,
-        22: 2,
-        23: 3,
-        24: 3,
-        25: 3,
-        26: 2,
-        27: 3,
-        28: 3,
-        29: 3,
-        30: 4,
-        31: 3,
-        32: 4,
-        33: 4,
-    }
-    G = nx.karate_club_graph()
-    k_components = nx.k_components(G)
-    k_num = build_k_number_dict(k_components)
-    assert karate_k_num == k_num
-
-
-def test_davis_southern_women():
-    G = nx.davis_southern_women_graph()
-    result = nx.k_components(G)
-    _check_connectivity(G, result)
-
-
-def test_davis_southern_women_detail_3_and_4():
-    solution = {
-        3: [
-            {
-                "Nora Fayette",
-                "E10",
-                "Myra Liddel",
-                "E12",
-                "E14",
-                "Frances Anderson",
-                "Evelyn Jefferson",
-                "Ruth DeSand",
-                "Helen Lloyd",
-                "Eleanor Nye",
-                "E9",
-                "E8",
-                "E5",
-                "E4",
-                "E7",
-                "E6",
-                "E1",
-                "Verne Sanderson",
-                "E3",
-                "E2",
-                "Theresa Anderson",
-                "Pearl Oglethorpe",
-                "Katherina Rogers",
-                "Brenda Rogers",
-                "E13",
-                "Charlotte McDowd",
-                "Sylvia Avondale",
-                "Laura Mandeville",
-            }
-        ],
-        4: [
-            {
-                "Nora Fayette",
-                "E10",
-                "Verne Sanderson",
-                "E12",
-                "Frances Anderson",
-                "Evelyn Jefferson",
-                "Ruth DeSand",
-                "Helen Lloyd",
-                "Eleanor Nye",
-                "E9",
-                "E8",
-                "E5",
-                "E4",
-                "E7",
-                "E6",
-                "Myra Liddel",
-                "E3",
-                "Theresa Anderson",
-                "Katherina Rogers",
-                "Brenda Rogers",
-                "Charlotte McDowd",
-                "Sylvia Avondale",
-                "Laura Mandeville",
-            }
-        ],
-    }
-    G = nx.davis_southern_women_graph()
-    result = nx.k_components(G)
-    for k, components in result.items():
-        if k < 3:
-            continue
-        assert len(components) == len(solution[k])
-        for component in components:
-            assert component in solution[k]
-
-
-def test_set_consolidation_rosettacode():
-    # Tests from http://rosettacode.org/wiki/Set_consolidation
-    def list_of_sets_equal(result, solution):
-        assert {frozenset(s) for s in result} == {frozenset(s) for s in solution}
-
-    question = [{"A", "B"}, {"C", "D"}]
-    solution = [{"A", "B"}, {"C", "D"}]
-    list_of_sets_equal(_consolidate(question, 1), solution)
-    question = [{"A", "B"}, {"B", "C"}]
-    solution = [{"A", "B", "C"}]
-    list_of_sets_equal(_consolidate(question, 1), solution)
-    question = [{"A", "B"}, {"C", "D"}, {"D", "B"}]
-    solution = [{"A", "C", "B", "D"}]
-    list_of_sets_equal(_consolidate(question, 1), solution)
-    question = [{"H", "I", "K"}, {"A", "B"}, {"C", "D"}, {"D", "B"}, {"F", "G", "H"}]
-    solution = [{"A", "C", "B", "D"}, {"G", "F", "I", "H", "K"}]
-    list_of_sets_equal(_consolidate(question, 1), solution)
-    question = [
-        {"A", "H"},
-        {"H", "I", "K"},
-        {"A", "B"},
-        {"C", "D"},
-        {"D", "B"},
-        {"F", "G", "H"},
-    ]
-    solution = [{"A", "C", "B", "D", "G", "F", "I", "H", "K"}]
-    list_of_sets_equal(_consolidate(question, 1), solution)
-    question = [
-        {"H", "I", "K"},
-        {"A", "B"},
-        {"C", "D"},
-        {"D", "B"},
-        {"F", "G", "H"},
-        {"A", "H"},
-    ]
-    solution = [{"A", "C", "B", "D", "G", "F", "I", "H", "K"}]
-    list_of_sets_equal(_consolidate(question, 1), solution)

package/runtime/python/okstra_vendor/networkx/algorithms/connectivity/tests/test_kcutsets.py

@@ -1,280 +0,0 @@
-# Jordi Torrents
-# Test for k-cutsets
-import itertools
-
-import pytest
-
-import networkx as nx
-from networkx.algorithms import flow
-from networkx.algorithms.connectivity.kcutsets import _is_separating_set
-
-MAX_CUTSETS_TO_TEST = 4  # originally 100. cut to decrease testing time
-
-flow_funcs = [
-    flow.boykov_kolmogorov,
-    flow.dinitz,
-    flow.edmonds_karp,
-    flow.preflow_push,
-    flow.shortest_augmenting_path,
-]
-
-
-##
-# Some nice synthetic graphs
-##
-def graph_example_1():
-    G = nx.convert_node_labels_to_integers(
-        nx.grid_graph([5, 5]), label_attribute="labels"
-    )
-    rlabels = nx.get_node_attributes(G, "labels")
-    labels = {v: k for k, v in rlabels.items()}
-
-    for nodes in [
-        (labels[(0, 0)], labels[(1, 0)]),
-        (labels[(0, 4)], labels[(1, 4)]),
-        (labels[(3, 0)], labels[(4, 0)]),
-        (labels[(3, 4)], labels[(4, 4)]),
-    ]:
-        new_node = G.order() + 1
-        # Petersen graph is triconnected
-        P = nx.petersen_graph()
-        G = nx.disjoint_union(G, P)
-        # Add two edges between the grid and P
-        G.add_edge(new_node + 1, nodes[0])
-        G.add_edge(new_node, nodes[1])
-        # K5 is 4-connected
-        K = nx.complete_graph(5)
-        G = nx.disjoint_union(G, K)
-        # Add three edges between P and K5
-        G.add_edge(new_node + 2, new_node + 11)
-        G.add_edge(new_node + 3, new_node + 12)
-        G.add_edge(new_node + 4, new_node + 13)
-        # Add another K5 sharing a node
-        G = nx.disjoint_union(G, K)
-        nbrs = G[new_node + 10]
-        G.remove_node(new_node + 10)
-        for nbr in nbrs:
-            G.add_edge(new_node + 17, nbr)
-        G.add_edge(new_node + 16, new_node + 5)
-    return G
-
-
-def torrents_and_ferraro_graph():
-    G = nx.convert_node_labels_to_integers(
-        nx.grid_graph([5, 5]), label_attribute="labels"
-    )
-    rlabels = nx.get_node_attributes(G, "labels")
-    labels = {v: k for k, v in rlabels.items()}
-
-    for nodes in [(labels[(0, 4)], labels[(1, 4)]), (labels[(3, 4)], labels[(4, 4)])]:
-        new_node = G.order() + 1
-        # Petersen graph is triconnected
-        P = nx.petersen_graph()
-        G = nx.disjoint_union(G, P)
-        # Add two edges between the grid and P
-        G.add_edge(new_node + 1, nodes[0])
-        G.add_edge(new_node, nodes[1])
-        # K5 is 4-connected
-        K = nx.complete_graph(5)
-        G = nx.disjoint_union(G, K)
-        # Add three edges between P and K5
-        G.add_edge(new_node + 2, new_node + 11)
-        G.add_edge(new_node + 3, new_node + 12)
-        G.add_edge(new_node + 4, new_node + 13)
-        # Add another K5 sharing a node
-        G = nx.disjoint_union(G, K)
-        nbrs = G[new_node + 10]
-        G.remove_node(new_node + 10)
-        for nbr in nbrs:
-            G.add_edge(new_node + 17, nbr)
-        # Commenting this makes the graph not biconnected !!
-        # This stupid mistake make one reviewer very angry :P
-        G.add_edge(new_node + 16, new_node + 8)
-
-    for nodes in [(labels[(0, 0)], labels[(1, 0)]), (labels[(3, 0)], labels[(4, 0)])]:
-        new_node = G.order() + 1
-        # Petersen graph is triconnected
-        P = nx.petersen_graph()
-        G = nx.disjoint_union(G, P)
-        # Add two edges between the grid and P
-        G.add_edge(new_node + 1, nodes[0])
-        G.add_edge(new_node, nodes[1])
-        # K5 is 4-connected
-        K = nx.complete_graph(5)
-        G = nx.disjoint_union(G, K)
-        # Add three edges between P and K5
-        G.add_edge(new_node + 2, new_node + 11)
-        G.add_edge(new_node + 3, new_node + 12)
-        G.add_edge(new_node + 4, new_node + 13)
-        # Add another K5 sharing two nodes
-        G = nx.disjoint_union(G, K)
-        nbrs = G[new_node + 10]
-        G.remove_node(new_node + 10)
-        for nbr in nbrs:
-            G.add_edge(new_node + 17, nbr)
-        nbrs2 = G[new_node + 9]
-        G.remove_node(new_node + 9)
-        for nbr in nbrs2:
-            G.add_edge(new_node + 18, nbr)
-    return G
-
-
-# Helper function
-def _check_separating_sets(G):
-    for cc in nx.connected_components(G):
-        if len(cc) < 3:
-            continue
-        Gc = G.subgraph(cc)
-        node_conn = nx.node_connectivity(Gc)
-        all_cuts = nx.all_node_cuts(Gc)
-        # Only test a limited number of cut sets to reduce test time.
-        for cut in itertools.islice(all_cuts, MAX_CUTSETS_TO_TEST):
-            assert node_conn == len(cut)
-            assert not nx.is_connected(nx.restricted_view(G, cut, []))
-
-
-@pytest.mark.slow
-def test_torrents_and_ferraro_graph():
-    G = torrents_and_ferraro_graph()
-    _check_separating_sets(G)
-
-
-def test_example_1():
-    G = graph_example_1()
-    _check_separating_sets(G)
-
-
-def test_random_gnp():
-    G = nx.gnp_random_graph(100, 0.1, seed=42)
-    _check_separating_sets(G)
-
-
-def test_shell():
-    constructor = [(20, 80, 0.8), (80, 180, 0.6)]
-    G = nx.random_shell_graph(constructor, seed=42)
-    _check_separating_sets(G)
-
-
-def test_configuration():
-    deg_seq = nx.random_powerlaw_tree_sequence(100, tries=5, seed=72)
-    G = nx.Graph(nx.configuration_model(deg_seq))
-    G.remove_edges_from(nx.selfloop_edges(G))
-    _check_separating_sets(G)
-
-
-def test_karate():
-    G = nx.karate_club_graph()
-    _check_separating_sets(G)
-
-
-def _generate_no_biconnected(max_attempts=50):
-    attempts = 0
-    while True:
-        G = nx.fast_gnp_random_graph(100, 0.0575, seed=42)
-        if nx.is_connected(G) and not nx.is_biconnected(G):
-            attempts = 0
-            yield G
-        else:
-            if attempts >= max_attempts:
-                msg = f"Tried {attempts} times: no suitable Graph."
-                raise Exception(msg)
-            else:
-                attempts += 1
-
-
-def test_articulation_points():
-    Ggen = _generate_no_biconnected()
-    for i in range(1):  # change 1 to 3 or more for more realizations.
-        G = next(Ggen)
-        articulation_points = [{a} for a in nx.articulation_points(G)]
-        for cut in nx.all_node_cuts(G):
-            assert cut in articulation_points
-
-
-def test_grid_2d_graph():
-    # All minimum node cuts of a 2d grid
-    # are the four pairs of nodes that are
-    # neighbors of the four corner nodes.
-    G = nx.grid_2d_graph(5, 5)
-    solution = [{(0, 1), (1, 0)}, {(3, 0), (4, 1)}, {(3, 4), (4, 3)}, {(0, 3), (1, 4)}]
-    for cut in nx.all_node_cuts(G):
-        assert cut in solution
-
-
-def test_disconnected_graph():
-    G = nx.fast_gnp_random_graph(100, 0.01, seed=42)
-    cuts = nx.all_node_cuts(G)
-    pytest.raises(nx.NetworkXError, next, cuts)
-
-
-@pytest.mark.slow
-@pytest.mark.parametrize("G", [nx.grid_2d_graph(4, 4), nx.cycle_graph(5)])
-@pytest.mark.parametrize("flow_func", flow_funcs)
-def test_alternative_flow_functions(G, flow_func):
-    node_conn = nx.node_connectivity(G)
-    all_cuts = nx.all_node_cuts(G, flow_func=flow_func)
-    # Only test a limited number of cut sets to reduce test time.
-    for cut in itertools.islice(all_cuts, MAX_CUTSETS_TO_TEST):
-        assert node_conn == len(cut)
-        assert not nx.is_connected(nx.restricted_view(G, cut, []))
-
-
-def test_is_separating_set_complete_graph():
-    G = nx.complete_graph(5)
-    assert _is_separating_set(G, {0, 1, 2, 3})
-
-
-def test_is_separating_set():
-    for i in [5, 10, 15]:
-        G = nx.star_graph(i)
-        max_degree_node = max(G, key=G.degree)
-        assert _is_separating_set(G, {max_degree_node})
-
-
-def test_non_repeated_cuts():
-    # The algorithm was repeating the cut {0, 1} for the giant biconnected
-    # component of the Karate club graph.
-    K = nx.karate_club_graph()
-    bcc = max(list(nx.biconnected_components(K)), key=len)
-    G = K.subgraph(bcc)
-    solution = [{32, 33}, {2, 33}, {0, 3}, {0, 1}, {29, 33}]
-    cuts = list(nx.all_node_cuts(G))
-    assert len(solution) == len(cuts)
-    for cut in cuts:
-        assert cut in solution
-
-
-def test_cycle_graph():
-    G = nx.cycle_graph(5)
-    solution = [{0, 2}, {0, 3}, {1, 3}, {1, 4}, {2, 4}]
-    cuts = list(nx.all_node_cuts(G))
-    assert len(solution) == len(cuts)
-    for cut in cuts:
-        assert cut in solution
-
-
-def test_complete_graph():
-    G = nx.complete_graph(5)
-    assert nx.node_connectivity(G) == 4
-    assert list(nx.all_node_cuts(G)) == []
-
-
-def test_all_node_cuts_simple_case():
-    G = nx.complete_graph(5)
-    G.remove_edges_from([(0, 1), (3, 4)])
-    expected = [{0, 1, 2}, {2, 3, 4}]
-    actual = list(nx.all_node_cuts(G))
-    assert len(actual) == len(expected)
-    for cut in actual:
-        assert cut in expected
-
-
-def test_all_node_cuts_sap():
-    """Non-slow test for `all_node_cuts` using the shortest augmenting path flow."""
-    G = nx.cycle_graph(5)
-    node_conn = nx.node_connectivity(G)
-    all_cuts = nx.all_node_cuts(G, flow_func=flow.shortest_augmenting_path)
-    # Only test a limited number of cut sets to reduce test time.
-    for cut in itertools.islice(all_cuts, MAX_CUTSETS_TO_TEST):
-        assert node_conn == len(cut)
-        assert not nx.is_connected(nx.restricted_view(G, cut, []))

package/runtime/python/okstra_vendor/networkx/algorithms/connectivity/tests/test_stoer_wagner.py

@@ -1,102 +0,0 @@
-from itertools import chain
-
-import pytest
-
-import networkx as nx
-
-
-def _check_partition(G, cut_value, partition, weight):
-    assert isinstance(partition, tuple)
-    assert len(partition) == 2
-    assert isinstance(partition[0], list)
-    assert isinstance(partition[1], list)
-    assert len(partition[0]) > 0
-    assert len(partition[1]) > 0
-    assert sum(map(len, partition)) == len(G)
-    assert set(chain.from_iterable(partition)) == set(G)
-    partition = tuple(map(set, partition))
-    w = 0
-    for u, v, e in G.edges(data=True):
-        if (u in partition[0]) == (v in partition[1]):
-            w += e.get(weight, 1)
-    assert w == cut_value
-
-
-def _test_stoer_wagner(G, answer, weight="weight"):
-    cut_value, partition = nx.stoer_wagner(G, weight, heap=nx.utils.PairingHeap)
-    assert cut_value == answer
-    _check_partition(G, cut_value, partition, weight)
-    cut_value, partition = nx.stoer_wagner(G, weight, heap=nx.utils.BinaryHeap)
-    assert cut_value == answer
-    _check_partition(G, cut_value, partition, weight)
-
-
-def test_graph1():
-    G = nx.Graph()
-    G.add_edge("x", "a", weight=3)
-    G.add_edge("x", "b", weight=1)
-    G.add_edge("a", "c", weight=3)
-    G.add_edge("b", "c", weight=5)
-    G.add_edge("b", "d", weight=4)
-    G.add_edge("d", "e", weight=2)
-    G.add_edge("c", "y", weight=2)
-    G.add_edge("e", "y", weight=3)
-    _test_stoer_wagner(G, 4)
-
-
-def test_graph2():
-    G = nx.Graph()
-    G.add_edge("x", "a")
-    G.add_edge("x", "b")
-    G.add_edge("a", "c")
-    G.add_edge("b", "c")
-    G.add_edge("b", "d")
-    G.add_edge("d", "e")
-    G.add_edge("c", "y")
-    G.add_edge("e", "y")
-    _test_stoer_wagner(G, 2)
-
-
-def test_graph3():
-    # Source:
-    # Stoer, M. and Wagner, F. (1997). "A simple min-cut algorithm". Journal of
-    # the ACM 44 (4), 585-591.
-    G = nx.Graph()
-    G.add_edge(1, 2, weight=2)
-    G.add_edge(1, 5, weight=3)
-    G.add_edge(2, 3, weight=3)
-    G.add_edge(2, 5, weight=2)
-    G.add_edge(2, 6, weight=2)
-    G.add_edge(3, 4, weight=4)
-    G.add_edge(3, 7, weight=2)
-    G.add_edge(4, 7, weight=2)
-    G.add_edge(4, 8, weight=2)
-    G.add_edge(5, 6, weight=3)
-    G.add_edge(6, 7, weight=1)
-    G.add_edge(7, 8, weight=3)
-    _test_stoer_wagner(G, 4)
-
-
-def test_weight_name():
-    G = nx.Graph()
-    G.add_edge(1, 2, weight=1, cost=8)
-    G.add_edge(1, 3, cost=2)
-    G.add_edge(2, 3, cost=4)
-    _test_stoer_wagner(G, 6, weight="cost")
-
-
-def test_exceptions():
-    G = nx.Graph()
-    pytest.raises(nx.NetworkXError, nx.stoer_wagner, G)
-    G.add_node(1)
-    pytest.raises(nx.NetworkXError, nx.stoer_wagner, G)
-    G.add_node(2)
-    pytest.raises(nx.NetworkXError, nx.stoer_wagner, G)
-    G.add_edge(1, 2, weight=-2)
-    pytest.raises(nx.NetworkXError, nx.stoer_wagner, G)
-    G = nx.DiGraph()
-    pytest.raises(nx.NetworkXNotImplemented, nx.stoer_wagner, G)
-    G = nx.MultiGraph()
-    pytest.raises(nx.NetworkXNotImplemented, nx.stoer_wagner, G)
-    G = nx.MultiDiGraph()
-    pytest.raises(nx.NetworkXNotImplemented, nx.stoer_wagner, G)