okstra 0.114.0 → 0.116.0

package/runtime/python/okstra_vendor/networkx/algorithms/tests/test_asteroidal.py

@@ -1,23 +0,0 @@
-import networkx as nx
-
-
-def test_is_at_free():
-    is_at_free = nx.asteroidal.is_at_free
-
-    cycle = nx.cycle_graph(6)
-    assert not is_at_free(cycle)
-
-    path = nx.path_graph(6)
-    assert is_at_free(path)
-
-    small_graph = nx.complete_graph(2)
-    assert is_at_free(small_graph)
-
-    petersen = nx.petersen_graph()
-    assert not is_at_free(petersen)
-
-    clique = nx.complete_graph(6)
-    assert is_at_free(clique)
-
-    line_clique = nx.line_graph(clique)
-    assert not is_at_free(line_clique)

package/runtime/python/okstra_vendor/networkx/algorithms/tests/test_boundary.py

@@ -1,154 +0,0 @@
-"""Unit tests for the :mod:`networkx.algorithms.boundary` module."""
-
-from itertools import combinations
-
-import pytest
-
-import networkx as nx
-from networkx import convert_node_labels_to_integers as cnlti
-from networkx.utils import edges_equal
-
-
-class TestNodeBoundary:
-    """Unit tests for the :func:`~networkx.node_boundary` function."""
-
-    def test_null_graph(self):
-        """Tests that the null graph has empty node boundaries."""
-        null = nx.null_graph()
-        assert nx.node_boundary(null, []) == set()
-        assert nx.node_boundary(null, [], []) == set()
-        assert nx.node_boundary(null, [1, 2, 3]) == set()
-        assert nx.node_boundary(null, [1, 2, 3], [4, 5, 6]) == set()
-        assert nx.node_boundary(null, [1, 2, 3], [3, 4, 5]) == set()
-
-    def test_path_graph(self):
-        P10 = cnlti(nx.path_graph(10), first_label=1)
-        assert nx.node_boundary(P10, []) == set()
-        assert nx.node_boundary(P10, [], []) == set()
-        assert nx.node_boundary(P10, [1, 2, 3]) == {4}
-        assert nx.node_boundary(P10, [4, 5, 6]) == {3, 7}
-        assert nx.node_boundary(P10, [3, 4, 5, 6, 7]) == {2, 8}
-        assert nx.node_boundary(P10, [8, 9, 10]) == {7}
-        assert nx.node_boundary(P10, [4, 5, 6], [9, 10]) == set()
-
-    def test_complete_graph(self):
-        K10 = cnlti(nx.complete_graph(10), first_label=1)
-        assert nx.node_boundary(K10, []) == set()
-        assert nx.node_boundary(K10, [], []) == set()
-        assert nx.node_boundary(K10, [1, 2, 3]) == {4, 5, 6, 7, 8, 9, 10}
-        assert nx.node_boundary(K10, [4, 5, 6]) == {1, 2, 3, 7, 8, 9, 10}
-        assert nx.node_boundary(K10, [3, 4, 5, 6, 7]) == {1, 2, 8, 9, 10}
-        assert nx.node_boundary(K10, [4, 5, 6], []) == set()
-        assert nx.node_boundary(K10, K10) == set()
-        assert nx.node_boundary(K10, [1, 2, 3], [3, 4, 5]) == {4, 5}
-
-    def test_petersen(self):
-        """Check boundaries in the petersen graph
-
-        cheeger(G,k)=min(|bdy(S)|/|S| for |S|=k, 0<k<=|V(G)|/2)
-
-        """
-
-        def cheeger(G, k):
-            return min(len(nx.node_boundary(G, nn)) / k for nn in combinations(G, k))
-
-        P = nx.petersen_graph()
-        assert cheeger(P, 1) == pytest.approx(3.00, abs=1e-2)
-        assert cheeger(P, 2) == pytest.approx(2.00, abs=1e-2)
-        assert cheeger(P, 3) == pytest.approx(1.67, abs=1e-2)
-        assert cheeger(P, 4) == pytest.approx(1.00, abs=1e-2)
-        assert cheeger(P, 5) == pytest.approx(0.80, abs=1e-2)
-
-    def test_directed(self):
-        """Tests the node boundary of a directed graph."""
-        G = nx.DiGraph([(0, 1), (1, 2), (2, 3), (3, 4), (4, 0)])
-        S = {0, 1}
-        boundary = nx.node_boundary(G, S)
-        expected = {2}
-        assert boundary == expected
-
-    def test_multigraph(self):
-        """Tests the node boundary of a multigraph."""
-        G = nx.MultiGraph(list(nx.cycle_graph(5).edges()) * 2)
-        S = {0, 1}
-        boundary = nx.node_boundary(G, S)
-        expected = {2, 4}
-        assert boundary == expected
-
-    def test_multidigraph(self):
-        """Tests the edge boundary of a multidigraph."""
-        edges = [(0, 1), (1, 2), (2, 3), (3, 4), (4, 0)]
-        G = nx.MultiDiGraph(edges * 2)
-        S = {0, 1}
-        boundary = nx.node_boundary(G, S)
-        expected = {2}
-        assert boundary == expected
-
-
-class TestEdgeBoundary:
-    """Unit tests for the :func:`~networkx.edge_boundary` function."""
-
-    def test_null_graph(self):
-        null = nx.null_graph()
-        assert list(nx.edge_boundary(null, [])) == []
-        assert list(nx.edge_boundary(null, [], [])) == []
-        assert list(nx.edge_boundary(null, [1, 2, 3])) == []
-        assert list(nx.edge_boundary(null, [1, 2, 3], [4, 5, 6])) == []
-        assert list(nx.edge_boundary(null, [1, 2, 3], [3, 4, 5])) == []
-
-    def test_path_graph(self):
-        P10 = cnlti(nx.path_graph(10), first_label=1)
-        assert list(nx.edge_boundary(P10, [])) == []
-        assert list(nx.edge_boundary(P10, [], [])) == []
-        assert list(nx.edge_boundary(P10, [1, 2, 3])) == [(3, 4)]
-        assert sorted(nx.edge_boundary(P10, [4, 5, 6])) == [(4, 3), (6, 7)]
-        assert sorted(nx.edge_boundary(P10, [3, 4, 5, 6, 7])) == [(3, 2), (7, 8)]
-        assert list(nx.edge_boundary(P10, [8, 9, 10])) == [(8, 7)]
-        assert sorted(nx.edge_boundary(P10, [4, 5, 6], [9, 10])) == []
-        assert list(nx.edge_boundary(P10, [1, 2, 3], [3, 4, 5])) == [(2, 3), (3, 4)]
-
-    def test_complete_graph(self):
-        K10 = cnlti(nx.complete_graph(10), first_label=1)
-
-        def ilen(iterable):
-            return sum(1 for i in iterable)
-
-        assert list(nx.edge_boundary(K10, [])) == []
-        assert list(nx.edge_boundary(K10, [], [])) == []
-        assert ilen(nx.edge_boundary(K10, [1, 2, 3])) == 21
-        assert ilen(nx.edge_boundary(K10, [4, 5, 6, 7])) == 24
-        assert ilen(nx.edge_boundary(K10, [3, 4, 5, 6, 7])) == 25
-        assert ilen(nx.edge_boundary(K10, [8, 9, 10])) == 21
-        assert edges_equal(
-            nx.edge_boundary(K10, [4, 5, 6], [9, 10]),
-            [(4, 9), (4, 10), (5, 9), (5, 10), (6, 9), (6, 10)],
-        )
-        assert edges_equal(
-            nx.edge_boundary(K10, [1, 2, 3], [3, 4, 5]),
-            [(1, 3), (1, 4), (1, 5), (2, 3), (2, 4), (2, 5), (3, 4), (3, 5)],
-        )
-
-    def test_directed(self):
-        """Tests the edge boundary of a directed graph."""
-        G = nx.DiGraph([(0, 1), (1, 2), (2, 3), (3, 4), (4, 0)])
-        S = {0, 1}
-        boundary = list(nx.edge_boundary(G, S))
-        expected = [(1, 2)]
-        assert boundary == expected
-
-    def test_multigraph(self):
-        """Tests the edge boundary of a multigraph."""
-        G = nx.MultiGraph(list(nx.cycle_graph(5).edges()) * 2)
-        S = {0, 1}
-        boundary = list(nx.edge_boundary(G, S))
-        expected = [(0, 4), (0, 4), (1, 2), (1, 2)]
-        assert boundary == expected
-
-    def test_multidigraph(self):
-        """Tests the edge boundary of a multidigraph."""
-        edges = [(0, 1), (1, 2), (2, 3), (3, 4), (4, 0)]
-        G = nx.MultiDiGraph(edges * 2)
-        S = {0, 1}
-        boundary = list(nx.edge_boundary(G, S))
-        expected = [(1, 2), (1, 2)]
-        assert boundary == expected

package/runtime/python/okstra_vendor/networkx/algorithms/tests/test_bridges.py

@@ -1,144 +0,0 @@
-"""Unit tests for bridge-finding algorithms."""
-
-import pytest
-
-import networkx as nx
-
-
-class TestBridges:
-    """Unit tests for the bridge-finding function."""
-
-    def test_single_bridge(self):
-        edges = [
-            # DFS tree edges.
-            (1, 2),
-            (2, 3),
-            (3, 4),
-            (3, 5),
-            (5, 6),
-            (6, 7),
-            (7, 8),
-            (5, 9),
-            (9, 10),
-            # Nontree edges.
-            (1, 3),
-            (1, 4),
-            (2, 5),
-            (5, 10),
-            (6, 8),
-        ]
-        G = nx.Graph(edges)
-        source = 1
-        bridges = list(nx.bridges(G, source))
-        assert bridges == [(5, 6)]
-
-    def test_barbell_graph(self):
-        # The (3, 0) barbell graph has two triangles joined by a single edge.
-        G = nx.barbell_graph(3, 0)
-        source = 0
-        bridges = list(nx.bridges(G, source))
-        assert bridges == [(2, 3)]
-
-    def test_multiedge_bridge(self):
-        edges = [
-            (0, 1),
-            (0, 2),
-            (1, 2),
-            (1, 2),
-            (2, 3),
-            (3, 4),
-            (3, 4),
-        ]
-        G = nx.MultiGraph(edges)
-        assert list(nx.bridges(G)) == [(2, 3)]
-
-
-class TestHasBridges:
-    """Unit tests for the has bridges function."""
-
-    def test_single_bridge(self):
-        edges = [
-            # DFS tree edges.
-            (1, 2),
-            (2, 3),
-            (3, 4),
-            (3, 5),
-            (5, 6),  # The only bridge edge
-            (6, 7),
-            (7, 8),
-            (5, 9),
-            (9, 10),
-            # Nontree edges.
-            (1, 3),
-            (1, 4),
-            (2, 5),
-            (5, 10),
-            (6, 8),
-        ]
-        G = nx.Graph(edges)
-        assert nx.has_bridges(G)  # Default root
-        assert nx.has_bridges(G, root=1)  # arbitrary root in G
-
-    def test_has_bridges_raises_root_not_in_G(self):
-        G = nx.Graph()
-        G.add_nodes_from([1, 2, 3])
-        with pytest.raises(nx.NodeNotFound):
-            nx.has_bridges(G, root=6)
-
-    def test_multiedge_bridge(self):
-        edges = [
-            (0, 1),
-            (0, 2),
-            (1, 2),
-            (1, 2),
-            (2, 3),
-            (3, 4),
-            (3, 4),
-        ]
-        G = nx.MultiGraph(edges)
-        assert nx.has_bridges(G)
-        # Make every edge a multiedge
-        G.add_edges_from([(0, 1), (0, 2), (2, 3)])
-        assert not nx.has_bridges(G)
-
-    def test_bridges_multiple_components(self):
-        G = nx.Graph()
-        nx.add_path(G, [0, 1, 2])  # One connected component
-        nx.add_path(G, [4, 5, 6])  # Another connected component
-        assert list(nx.bridges(G, root=4)) == [(4, 5), (5, 6)]
-
-
-class TestLocalBridges:
-    """Unit tests for the local_bridge function."""
-
-    @classmethod
-    def setup_class(cls):
-        cls.BB = nx.barbell_graph(4, 0)
-        cls.square = nx.cycle_graph(4)
-        cls.tri = nx.cycle_graph(3)
-
-    def test_nospan(self):
-        expected = {(3, 4), (4, 3)}
-        assert next(nx.local_bridges(self.BB, with_span=False)) in expected
-        assert set(nx.local_bridges(self.square, with_span=False)) == self.square.edges
-        assert list(nx.local_bridges(self.tri, with_span=False)) == []
-
-    def test_no_weight(self):
-        inf = float("inf")
-        expected = {(3, 4, inf), (4, 3, inf)}
-        assert next(nx.local_bridges(self.BB)) in expected
-        expected = {(u, v, 3) for u, v in self.square.edges}
-        assert set(nx.local_bridges(self.square)) == expected
-        assert list(nx.local_bridges(self.tri)) == []
-
-    def test_weight(self):
-        inf = float("inf")
-        G = self.square.copy()
-
-        G.edges[1, 2]["weight"] = 2
-        expected = {(u, v, 5 - wt) for u, v, wt in G.edges(data="weight", default=1)}
-        assert set(nx.local_bridges(G, weight="weight")) == expected
-
-        expected = {(u, v, 6) for u, v in G.edges}
-        lb = nx.local_bridges(G, weight=lambda u, v, d: 2)
-        assert set(lb) == expected

package/runtime/python/okstra_vendor/networkx/algorithms/tests/test_broadcasting.py

@@ -1,109 +0,0 @@
-"""Unit tests for the broadcasting module."""
-
-import math
-
-import pytest
-
-import networkx as nx
-
-
-def test_example_tree_broadcast():
-    """
-    Test the BROADCAST algorithm on the example in the paper titled: "Information Dissemination in Trees"
-    """
-    edge_list = [
-        (0, 1),
-        (1, 2),
-        (2, 7),
-        (3, 4),
-        (5, 4),
-        (4, 7),
-        (6, 7),
-        (7, 9),
-        (8, 9),
-        (9, 13),
-        (13, 14),
-        (14, 15),
-        (14, 16),
-        (14, 17),
-        (13, 11),
-        (11, 10),
-        (11, 12),
-        (13, 18),
-        (18, 19),
-        (18, 20),
-    ]
-    G = nx.Graph(edge_list)
-    b_T, b_C = nx.tree_broadcast_center(G)
-    assert b_T == 6
-    assert b_C == {13, 9}
-    # test broadcast time from specific vertex
-    assert nx.tree_broadcast_time(G, 17) == 8
-    assert nx.tree_broadcast_time(G, 3) == 9
-    # test broadcast time of entire tree
-    assert nx.tree_broadcast_time(G) == 10
-
-
-@pytest.mark.parametrize("n", range(2, 12))
-def test_path_broadcast(n):
-    G = nx.path_graph(n)
-    b_T, b_C = nx.tree_broadcast_center(G)
-    assert b_T == math.ceil(n / 2)
-    assert b_C == {
-        math.ceil(n / 2),
-        n // 2,
-        math.ceil(n / 2 - 1),
-        n // 2 - 1,
-    }
-    assert nx.tree_broadcast_time(G) == n - 1
-
-
-def test_empty_graph_broadcast():
-    H = nx.empty_graph(1)
-    b_T, b_C = nx.tree_broadcast_center(H)
-    assert b_T == 0
-    assert b_C == {0}
-    assert nx.tree_broadcast_time(H) == 0
-
-
-@pytest.mark.parametrize("n", range(4, 12))
-def test_star_broadcast(n):
-    G = nx.star_graph(n)
-    b_T, b_C = nx.tree_broadcast_center(G)
-    assert b_T == n
-    assert b_C == set(G.nodes())
-    assert nx.tree_broadcast_time(G) == b_T
-
-
-@pytest.mark.parametrize("n", range(2, 8))
-def test_binomial_tree_broadcast(n):
-    G = nx.binomial_tree(n)
-    b_T, b_C = nx.tree_broadcast_center(G)
-    assert b_T == n
-    assert b_C == {0, 2 ** (n - 1)}
-    assert nx.tree_broadcast_time(G) == 2 * n - 1
-
-
-@pytest.mark.parametrize("fn", [nx.tree_broadcast_center, nx.tree_broadcast_time])
-@pytest.mark.parametrize("graph_type", [nx.DiGraph, nx.MultiGraph, nx.MultiDiGraph])
-def test_raises_graph_type(fn, graph_type):
-    """Check that broadcast functions properly raise for directed and multigraph types."""
-    G = nx.path_graph(5, create_using=graph_type)
-    with pytest.raises(nx.NetworkXNotImplemented, match=r"not implemented for"):
-        fn(G)
-
-
-@pytest.mark.parametrize("fn", [nx.tree_broadcast_center, nx.tree_broadcast_time])
-@pytest.mark.parametrize("gen", [nx.empty_graph, nx.cycle_graph])
-def test_raises_not_tree(fn, gen):
-    """Check that broadcast functions properly raise for nontree graphs."""
-    G = gen(5)
-    with pytest.raises(nx.NotATree, match=r"not a tree"):
-        fn(G)
-
-
-def test_raises_node_not_in_G():
-    """Check that `tree_broadcast_time` properly raises for invalid nodes."""
-    G = nx.path_graph(5)
-    with pytest.raises(nx.NodeNotFound, match=r"node.*not in G"):
-        nx.tree_broadcast_time(G, node=10)

package/runtime/python/okstra_vendor/networkx/algorithms/tests/test_chains.py

@@ -1,136 +0,0 @@
-"""Unit tests for the chain decomposition functions."""
-
-from itertools import cycle, islice
-
-import pytest
-
-import networkx as nx
-
-
-def cycles(seq):
-    """Yields cyclic permutations of the given sequence.
-
-    For example::
-
-        >>> list(cycles("abc"))
-        [('a', 'b', 'c'), ('b', 'c', 'a'), ('c', 'a', 'b')]
-
-    """
-    n = len(seq)
-    cycled_seq = cycle(seq)
-    for x in seq:
-        yield tuple(islice(cycled_seq, n))
-        next(cycled_seq)
-
-
-def cyclic_equals(seq1, seq2):
-    """Decide whether two sequences are equal up to cyclic permutations.
-
-    For example::
-
-        >>> cyclic_equals("xyz", "zxy")
-        True
-        >>> cyclic_equals("xyz", "zyx")
-        False
-
-    """
-    # Cast seq2 to a tuple since `cycles()` yields tuples.
-    seq2 = tuple(seq2)
-    return any(x == tuple(seq2) for x in cycles(seq1))
-
-
-class TestChainDecomposition:
-    """Unit tests for the chain decomposition function."""
-
-    def assertContainsChain(self, chain, expected):
-        # A cycle could be expressed in two different orientations, one
-        # forward and one backward, so we need to check for cyclic
-        # equality in both orientations.
-        reversed_chain = list(reversed([tuple(reversed(e)) for e in chain]))
-        for candidate in expected:
-            if cyclic_equals(chain, candidate):
-                break
-            if cyclic_equals(reversed_chain, candidate):
-                break
-        else:
-            self.fail("chain not found")
-
-    def test_decomposition(self):
-        edges = [
-            # DFS tree edges.
-            (1, 2),
-            (2, 3),
-            (3, 4),
-            (3, 5),
-            (5, 6),
-            (6, 7),
-            (7, 8),
-            (5, 9),
-            (9, 10),
-            # Nontree edges.
-            (1, 3),
-            (1, 4),
-            (2, 5),
-            (5, 10),
-            (6, 8),
-        ]
-        G = nx.Graph(edges)
-        expected = [
-            [(1, 3), (3, 2), (2, 1)],
-            [(1, 4), (4, 3)],
-            [(2, 5), (5, 3)],
-            [(5, 10), (10, 9), (9, 5)],
-            [(6, 8), (8, 7), (7, 6)],
-        ]
-        chains = list(nx.chain_decomposition(G, root=1))
-        assert len(chains) == len(expected)
-
-    def test_barbell_graph(self):
-        # The (3, 0) barbell graph has two triangles joined by a single edge.
-        G = nx.barbell_graph(3, 0)
-        chains = list(nx.chain_decomposition(G, root=0))
-        expected = [[(0, 1), (1, 2), (2, 0)], [(3, 4), (4, 5), (5, 3)]]
-        assert len(chains) == len(expected)
-        for chain in chains:
-            self.assertContainsChain(chain, expected)
-
-    def test_disconnected_graph(self):
-        """Test for a graph with multiple connected components."""
-        G = nx.barbell_graph(3, 0)
-        H = nx.barbell_graph(3, 0)
-        mapping = dict(zip(range(6), "abcdef"))
-        nx.relabel_nodes(H, mapping, copy=False)
-        G = nx.union(G, H)
-        chains = list(nx.chain_decomposition(G))
-        expected = [
-            [(0, 1), (1, 2), (2, 0)],
-            [(3, 4), (4, 5), (5, 3)],
-            [("a", "b"), ("b", "c"), ("c", "a")],
-            [("d", "e"), ("e", "f"), ("f", "d")],
-        ]
-        assert len(chains) == len(expected)
-        for chain in chains:
-            self.assertContainsChain(chain, expected)
-
-    def test_disconnected_graph_root_node(self):
-        """Test for a single component of a disconnected graph."""
-        G = nx.barbell_graph(3, 0)
-        H = nx.barbell_graph(3, 0)
-        mapping = dict(zip(range(6), "abcdef"))
-        nx.relabel_nodes(H, mapping, copy=False)
-        G = nx.union(G, H)
-        chains = list(nx.chain_decomposition(G, root="a"))
-        expected = [
-            [("a", "b"), ("b", "c"), ("c", "a")],
-            [("d", "e"), ("e", "f"), ("f", "d")],
-        ]
-        assert len(chains) == len(expected)
-        for chain in chains:
-            self.assertContainsChain(chain, expected)
-
-    def test_chain_decomposition_root_not_in_G(self):
-        """Test chain decomposition when root is not in graph"""
-        G = nx.Graph()
-        G.add_nodes_from([1, 2, 3])
-        with pytest.raises(nx.NodeNotFound):
-            nx.has_bridges(G, root=6)

package/runtime/python/okstra_vendor/networkx/algorithms/tests/test_chordal.py

@@ -1,129 +0,0 @@
-import pytest
-
-import networkx as nx
-
-
-class TestMCS:
-    @classmethod
-    def setup_class(cls):
-        # simple graph
-        connected_chordal_G = nx.Graph()
-        connected_chordal_G.add_edges_from(
-            [
-                (1, 2),
-                (1, 3),
-                (2, 3),
-                (2, 4),
-                (3, 4),
-                (3, 5),
-                (3, 6),
-                (4, 5),
-                (4, 6),
-                (5, 6),
-            ]
-        )
-        cls.connected_chordal_G = connected_chordal_G
-
-        chordal_G = nx.Graph()
-        chordal_G.add_edges_from(
-            [
-                (1, 2),
-                (1, 3),
-                (2, 3),
-                (2, 4),
-                (3, 4),
-                (3, 5),
-                (3, 6),
-                (4, 5),
-                (4, 6),
-                (5, 6),
-                (7, 8),
-            ]
-        )
-        chordal_G.add_node(9)
-        cls.chordal_G = chordal_G
-
-        non_chordal_G = nx.Graph()
-        non_chordal_G.add_edges_from([(1, 2), (1, 3), (2, 4), (2, 5), (3, 4), (3, 5)])
-        cls.non_chordal_G = non_chordal_G
-
-        self_loop_G = nx.Graph()
-        self_loop_G.add_edges_from([(1, 1)])
-        cls.self_loop_G = self_loop_G
-
-    @pytest.mark.parametrize("G", (nx.DiGraph(), nx.MultiGraph(), nx.MultiDiGraph()))
-    def test_is_chordal_not_implemented(self, G):
-        with pytest.raises(nx.NetworkXNotImplemented):
-            nx.is_chordal(G)
-
-    def test_is_chordal(self):
-        assert not nx.is_chordal(self.non_chordal_G)
-        assert nx.is_chordal(self.chordal_G)
-        assert nx.is_chordal(self.connected_chordal_G)
-        assert nx.is_chordal(nx.Graph())
-        assert nx.is_chordal(nx.complete_graph(3))
-        assert nx.is_chordal(nx.cycle_graph(3))
-        assert not nx.is_chordal(nx.cycle_graph(5))
-        assert nx.is_chordal(self.self_loop_G)
-
-    def test_induced_nodes(self):
-        G = nx.generators.classic.path_graph(10)
-        Induced_nodes = nx.find_induced_nodes(G, 1, 9, 2)
-        assert Induced_nodes == {1, 2, 3, 4, 5, 6, 7, 8, 9}
-        pytest.raises(
-            nx.NetworkXTreewidthBoundExceeded, nx.find_induced_nodes, G, 1, 9, 1
-        )
-        Induced_nodes = nx.find_induced_nodes(self.chordal_G, 1, 6)
-        assert Induced_nodes == {1, 2, 4, 6}
-        pytest.raises(nx.NetworkXError, nx.find_induced_nodes, self.non_chordal_G, 1, 5)
-
-    def test_graph_treewidth(self):
-        with pytest.raises(nx.NetworkXError, match="Input graph is not chordal"):
-            nx.chordal_graph_treewidth(self.non_chordal_G)
-
-    def test_chordal_find_cliques(self):
-        cliques = {
-            frozenset([9]),
-            frozenset([7, 8]),
-            frozenset([1, 2, 3]),
-            frozenset([2, 3, 4]),
-            frozenset([3, 4, 5, 6]),
-        }
-        assert set(nx.chordal_graph_cliques(self.chordal_G)) == cliques
-        with pytest.raises(nx.NetworkXError, match="Input graph is not chordal"):
-            set(nx.chordal_graph_cliques(self.non_chordal_G))
-        with pytest.raises(nx.NetworkXError, match="Input graph is not chordal"):
-            set(nx.chordal_graph_cliques(self.self_loop_G))
-
-    def test_chordal_find_cliques_path(self):
-        G = nx.path_graph(10)
-        cliqueset = nx.chordal_graph_cliques(G)
-        for u, v in G.edges():
-            assert frozenset([u, v]) in cliqueset or frozenset([v, u]) in cliqueset
-
-    def test_chordal_find_cliquesCC(self):
-        cliques = {frozenset([1, 2, 3]), frozenset([2, 3, 4]), frozenset([3, 4, 5, 6])}
-        cgc = nx.chordal_graph_cliques
-        assert set(cgc(self.connected_chordal_G)) == cliques
-
-    def test_complete_to_chordal_graph(self):
-        fgrg = nx.fast_gnp_random_graph
-        test_graphs = [
-            nx.barbell_graph(6, 2),
-            nx.cycle_graph(15),
-            nx.wheel_graph(20),
-            nx.grid_graph([10, 4]),
-            nx.ladder_graph(15),
-            nx.star_graph(5),
-            nx.bull_graph(),
-            fgrg(20, 0.3, seed=1),
-        ]
-        for G in test_graphs:
-            H, a = nx.complete_to_chordal_graph(G)
-            assert nx.is_chordal(H)
-            assert len(a) == H.number_of_nodes()
-            if nx.is_chordal(G):
-                assert G.number_of_edges() == H.number_of_edges()
-                assert set(a.values()) == {0}
-            else:
-                assert len(set(a.values())) == H.number_of_nodes()