updated tests

Author: atomassi

networkx/algorithms/approximation/kcutsets.py

@@ -196,7 +196,7 @@ def minimum_k_cut(G, k, weight=None):
     if not 1 <= k <= len(G):
         raise nx.NetworkXError(f"k should be within 1 and {len(G)}")
 
-    # extract edges weight, and set edges weights with no attribute to 1
+    # extract edges weights, and set edges weights with no attribute to 1
     edges_weights = G.edges(data=weight, default=1)
     # create a new Graph G2
     G2 = nx.Graph()

networkx/algorithms/approximation/tests/test_kcutsets.py

@@ -1,5 +1,6 @@
 """Unit tests for the :mod:`networkx.algorithms.approximation.kcutsets` module."""
 
+import itertools
 import pytest
 import networkx as nx
 from networkx.algorithms.approximation import minimum_multiway_cut, minimum_k_cut
@@ -72,15 +73,15 @@ def test_complete_graph(self):
             nx.tutte_graph,
         ],
     )
-    def test_compare_min_cut(self, graph_class):
+    @pytest.mark.parametrize("s,t", itertools.combinations(range(5), 2))
+    def test_compare_min_cut(self, graph_class, s, t):
         """Compare minimum_cut_value and minimum_multiway_cut considering 2 nodes.
 
         For two nodes the minimum_cut_value(G, s, t) should be equivalent to
         minimum_multiway_cut(G, {s,t}).
         """
         G = graph_class()
         nx.set_edge_attributes(G, values=10, name="weight")
-        s, t = min(G), max(G)
         cut_value, cutset = minimum_multiway_cut(G, {s, t}, weight="weight")
         assert cut_value == minimum_cut_value(G, s, t, capacity="weight")
 
@@ -113,64 +114,23 @@ def test_invalid_k(self):
         with pytest.raises(nx.NetworkXError, match="k should be within 1 and 10"):
             minimum_k_cut(G, 11)
 
-    def test_path_graph_unweighted(self):
-        """Test min k-cut for a path graph."""
-        G = nx.path_graph(2)
-        cut_value, cutset = minimum_k_cut(G, 2)
-        assert cut_value == 1
-        G.remove_edges_from(cutset)
-        assert len(list(nx.connected_components(G))) == 2
-
-    def test_path_graph_weighted_k2(self):
-        """Test min k-cut for a path graph with weights."""
-        G = nx.Graph()
-        G.add_weighted_edges_from(
-            [(0, 1, 10), (1, 2, 10), (2, 3, 5)], weight="capacity"
-        )
-        cut_value, cutset = minimum_k_cut(G, 2, weight="capacity")
-        assert cut_value == 5
+    @pytest.mark.parametrize("k,expected", [(1, 0), (2, 1), (3, 2), (4, 3), (5, 4)])
+    def test_path_graph(self, k, expected):
+        """Test various k for a path graph of 5 nodes."""
+        G = nx.path_graph(n=5)
+        cut_value, cutset = minimum_k_cut(G, k, weight="capacity")
+        assert cut_value == expected
         G.remove_edges_from(cutset)
-        assert len(list(nx.connected_components(G))) == 2
+        assert len(list(nx.connected_components(G))) == k
 
-    def test_path_graph_weighted_k3(self):
-        """Test min k-cut for a path graph with weights."""
-        G = nx.Graph()
-        G.add_weighted_edges_from(
-            [(0, 1, 10), (1, 2, 10), (2, 3, 5)], weight="capacity"
-        )
-        cut_value, cutset = minimum_k_cut(G, 3, weight="capacity")
-        assert cut_value == 15
-        G.remove_edges_from(cutset)
-        assert len(list(nx.connected_components(G))) == 3
-
-    def test_complete_graph_k2(self):
-        """Test min k-cut for a complete graph for k=2."""
+    @pytest.mark.parametrize("k,expected", [(1, 0), (2, 4), (3, 7), (4, 9), (5, 10)])
+    def test_complete_graph(self, k, expected):
+        """Test various k for a complete graph of 5 nodes."""
         G = nx.complete_graph(5)
-        cut_value, cutset = minimum_k_cut(G, 2)
-        # it should contain all the edges incident to a node
-        assert cut_value == 4
-        # remove the edges
-        G.remove_edges_from(cutset)
-        assert len(list(nx.connected_components(G))) == 2
-
-    def test_complete_graph_all(self):
-        """Test min k-cut for a complete graph."""
-        G = nx.complete_graph(5)
-        cut_value, cutset = minimum_k_cut(G, 5)
-        assert cut_value == 10
-        # remove the edges
-        G.remove_edges_from(cutset)
-        assert set(G.edges()) == set()
-
-    def test_complete_graph_weighted(self):
-        """Test min k-cut for a weighted complete graph."""
-        G = nx.complete_graph(5)
-        nx.set_edge_attributes(G, values=10, name="weight")
-        cut_value, cutset = minimum_k_cut(G, 5, weight="weight")
-        assert cut_value == 100
-        # remove the edges
+        cut_value, cutset = minimum_k_cut(G, k)
+        assert cut_value == expected
         G.remove_edges_from(cutset)
-        assert set(G.edges()) == set()
+        assert len(list(nx.connected_components(G))) >= k
 
     @pytest.mark.parametrize(
         "graph_class",
@@ -184,9 +144,30 @@ def test_complete_graph_weighted(self):
         ],
     )
     @pytest.mark.parametrize("k", list(range(1, 11)))
-    def test_compare_min_cut(self, graph_class, k):
+    def test_connected_components(self, graph_class, k):
         """Test multiple graph types and k."""
         G = graph_class()
         cut_value, cutset = minimum_k_cut(G, k)
         G.remove_edges_from(cutset)
         assert len(list(nx.connected_components(G))) >= k
+
+    def test_complete_graph_weighted(self):
+        """Test min k-cut for a weighted complete graph."""
+        G = nx.complete_graph(5)
+        nx.set_edge_attributes(G, values=10, name="weight")
+        cut_value, cutset = minimum_k_cut(G, 5, weight="weight")
+        assert cut_value == 100
+        # remove the edges
+        G.remove_edges_from(cutset)
+        assert set(G.edges()) == set()
+
+    def test_path_graph_weighted(self):
+        """Test min k-cut for a weighted path graph."""
+        G = nx.Graph()
+        G.add_weighted_edges_from(
+            [(0, 1, 10), (1, 2, 10), (2, 3, 5)], weight="capacity"
+        )
+        cut_value, cutset = minimum_k_cut(G, 3, weight="capacity")
+        assert cut_value == 15
+        G.remove_edges_from(cutset)
+        assert len(list(nx.connected_components(G))) == 3