okstra 0.114.0 → 0.115.0

package/runtime/python/okstra_vendor/networkx/generators/tests/test_lattice.py

@@ -1,264 +0,0 @@
-"""Unit tests for the :mod:`networkx.generators.lattice` module."""
-
-from itertools import product
-
-import pytest
-
-import networkx as nx
-from networkx.utils import edges_equal
-
-
-def test_hexagonal_lattice_no_pos():
-    # Test positions are note computed/stored when with_positions=False
-    G = nx.hexagonal_lattice_graph(6, 6, with_positions=False)
-    assert all(pos is None for _, pos in G.nodes(data="pos"))
-
-
-@pytest.mark.parametrize(
-    "lattice_graph", (nx.triangular_lattice_graph, nx.hexagonal_lattice_graph)
-)
-def test_2D_lattice_no_contraction_leftovers(lattice_graph):
-    """hexagonal_lattice_graph and triangular_lattice_graph use nx.contracted_nodes
-    under-the-hood when periodic=True. Check that there are no leftover
-    "contraction" node attributes on the returned graph."""
-    G = lattice_graph(6, 6, with_positions=False, periodic=True)
-    assert all(data == {} for _, data in G.nodes(data=True))
-    assert all(data == {} for _, _, data in G.edges(data=True))
-
-
-class TestGrid2DGraph:
-    """Unit tests for :func:`networkx.generators.lattice.grid_2d_graph`"""
-
-    def test_number_of_vertices(self):
-        m, n = 5, 6
-        G = nx.grid_2d_graph(m, n)
-        assert len(G) == m * n
-
-    def test_degree_distribution(self):
-        m, n = 5, 6
-        G = nx.grid_2d_graph(m, n)
-        expected_histogram = [0, 0, 4, 2 * (m + n) - 8, (m - 2) * (n - 2)]
-        assert nx.degree_histogram(G) == expected_histogram
-
-    def test_directed(self):
-        m, n = 5, 6
-        G = nx.grid_2d_graph(m, n)
-        H = nx.grid_2d_graph(m, n, create_using=nx.DiGraph())
-        assert H.succ == G.adj
-        assert H.pred == G.adj
-
-    def test_multigraph(self):
-        m, n = 5, 6
-        G = nx.grid_2d_graph(m, n)
-        H = nx.grid_2d_graph(m, n, create_using=nx.MultiGraph())
-        assert list(H.edges()) == list(G.edges())
-
-    def test_periodic(self):
-        G = nx.grid_2d_graph(0, 0, periodic=True)
-        assert dict(G.degree()) == {}
-
-        for m, n, H in [
-            (2, 2, nx.cycle_graph(4)),
-            (1, 7, nx.cycle_graph(7)),
-            (7, 1, nx.cycle_graph(7)),
-            (2, 5, nx.circular_ladder_graph(5)),
-            (5, 2, nx.circular_ladder_graph(5)),
-            (2, 4, nx.cubical_graph()),
-            (4, 2, nx.cubical_graph()),
-        ]:
-            G = nx.grid_2d_graph(m, n, periodic=True)
-            assert nx.could_be_isomorphic(G, H)
-
-    def test_periodic_iterable(self):
-        m, n = 3, 7
-        for a, b in product([0, 1], [0, 1]):
-            G = nx.grid_2d_graph(m, n, periodic=(a, b))
-            assert G.number_of_nodes() == m * n
-            assert G.number_of_edges() == (m + a - 1) * n + (n + b - 1) * m
-
-    def test_periodic_directed(self):
-        G = nx.grid_2d_graph(4, 2, periodic=True)
-        H = nx.grid_2d_graph(4, 2, periodic=True, create_using=nx.DiGraph())
-        assert H.succ == G.adj
-        assert H.pred == G.adj
-
-    def test_periodic_multigraph(self):
-        G = nx.grid_2d_graph(4, 2, periodic=True)
-        H = nx.grid_2d_graph(4, 2, periodic=True, create_using=nx.MultiGraph())
-        assert list(G.edges()) == list(H.edges())
-
-    def test_exceptions(self):
-        pytest.raises(nx.NetworkXError, nx.grid_2d_graph, -3, 2)
-        pytest.raises(nx.NetworkXError, nx.grid_2d_graph, 3, -2)
-        pytest.raises(TypeError, nx.grid_2d_graph, 3.3, 2)
-        pytest.raises(TypeError, nx.grid_2d_graph, 3, 2.2)
-
-    def test_node_input(self):
-        G = nx.grid_2d_graph(4, 2, periodic=True)
-        H = nx.grid_2d_graph(range(4), range(2), periodic=True)
-        assert nx.is_isomorphic(H, G)
-        H = nx.grid_2d_graph("abcd", "ef", periodic=True)
-        assert nx.is_isomorphic(H, G)
-        G = nx.grid_2d_graph(5, 6)
-        H = nx.grid_2d_graph(range(5), range(6))
-        assert edges_equal(H, G)
-
-
-class TestGridGraph:
-    """Unit tests for :func:`networkx.generators.lattice.grid_graph`"""
-
-    def test_grid_graph(self):
-        """grid_graph([n,m]) is a connected simple graph with the
-        following properties:
-        number_of_nodes = n*m
-        degree_histogram = [0,0,4,2*(n+m)-8,(n-2)*(m-2)]
-        """
-        for n, m in [(3, 5), (5, 3), (4, 5), (5, 4)]:
-            dim = [n, m]
-            g = nx.grid_graph(dim)
-            assert len(g) == n * m
-            assert nx.degree_histogram(g) == [
-                0,
-                0,
-                4,
-                2 * (n + m) - 8,
-                (n - 2) * (m - 2),
-            ]
-
-        for n, m in [(1, 5), (5, 1)]:
-            dim = [n, m]
-            g = nx.grid_graph(dim)
-            assert len(g) == n * m
-            assert nx.is_isomorphic(g, nx.path_graph(5))
-
-    #        mg = nx.grid_graph([n,m], create_using=MultiGraph())
-    #        assert_equal(mg.edges(), g.edges())
-
-    def test_node_input(self):
-        G = nx.grid_graph([range(7, 9), range(3, 6)])
-        assert len(G) == 2 * 3
-        assert nx.is_isomorphic(G, nx.grid_graph([2, 3]))
-
-    def test_periodic_iterable(self):
-        m, n, k = 3, 7, 5
-        for a, b, c in product([0, 1], [0, 1], [0, 1]):
-            G = nx.grid_graph([m, n, k], periodic=(a, b, c))
-            num_e = (m + a - 1) * n * k + (n + b - 1) * m * k + (k + c - 1) * m * n
-            assert G.number_of_nodes() == m * n * k
-            assert G.number_of_edges() == num_e
-
-
-class TestHypercubeGraph:
-    """Unit tests for :func:`networkx.generators.lattice.hypercube_graph`"""
-
-    def test_special_cases(self):
-        for n, H in [
-            (0, nx.null_graph()),
-            (1, nx.path_graph(2)),
-            (2, nx.cycle_graph(4)),
-            (3, nx.cubical_graph()),
-        ]:
-            G = nx.hypercube_graph(n)
-            assert nx.could_be_isomorphic(G, H)
-
-    def test_degree_distribution(self):
-        for n in range(1, 10):
-            G = nx.hypercube_graph(n)
-            expected_histogram = [0] * n + [2**n]
-            assert nx.degree_histogram(G) == expected_histogram
-
-
-class TestTriangularLatticeGraph:
-    "Tests for :func:`networkx.generators.lattice.triangular_lattice_graph`"
-
-    def test_lattice_points(self):
-        """Tests that the graph is really a triangular lattice."""
-        for m, n in [(2, 3), (2, 2), (2, 1), (3, 3), (3, 2), (3, 4)]:
-            G = nx.triangular_lattice_graph(m, n)
-            N = (n + 1) // 2
-            assert len(G) == (m + 1) * (1 + N) - (n % 2) * ((m + 1) // 2)
-        for i, j in G.nodes():
-            nbrs = G[(i, j)]
-            if i < N:
-                assert (i + 1, j) in nbrs
-            if j < m:
-                assert (i, j + 1) in nbrs
-            if j < m and (i > 0 or j % 2) and (i < N or (j + 1) % 2):
-                assert (i + 1, j + 1) in nbrs or (i - 1, j + 1) in nbrs
-
-    def test_directed(self):
-        """Tests for creating a directed triangular lattice."""
-        G = nx.triangular_lattice_graph(3, 4, create_using=nx.Graph())
-        H = nx.triangular_lattice_graph(3, 4, create_using=nx.DiGraph())
-        assert H.is_directed()
-        for u, v in H.edges():
-            assert v[1] >= u[1]
-            if v[1] == u[1]:
-                assert v[0] > u[0]
-
-    def test_multigraph(self):
-        """Tests for creating a triangular lattice multigraph."""
-        G = nx.triangular_lattice_graph(3, 4, create_using=nx.Graph())
-        H = nx.triangular_lattice_graph(3, 4, create_using=nx.MultiGraph())
-        assert list(H.edges()) == list(G.edges())
-
-    def test_periodic(self):
-        G = nx.triangular_lattice_graph(4, 6, periodic=True)
-        assert len(G) == 12
-        assert G.size() == 36
-        # all degrees are 6
-        assert len([n for n, d in G.degree() if d != 6]) == 0
-        G = nx.triangular_lattice_graph(5, 7, periodic=True)
-        TLG = nx.triangular_lattice_graph
-        pytest.raises(nx.NetworkXError, TLG, 2, 4, periodic=True)
-        pytest.raises(nx.NetworkXError, TLG, 4, 4, periodic=True)
-        pytest.raises(nx.NetworkXError, TLG, 2, 6, periodic=True)
-
-
-class TestHexagonalLatticeGraph:
-    "Tests for :func:`networkx.generators.lattice.hexagonal_lattice_graph`"
-
-    def test_lattice_points(self):
-        """Tests that the graph is really a hexagonal lattice."""
-        for m, n in [(4, 5), (4, 4), (4, 3), (3, 2), (3, 3), (3, 5)]:
-            G = nx.hexagonal_lattice_graph(m, n)
-            assert len(G) == 2 * (m + 1) * (n + 1) - 2
-        C_6 = nx.cycle_graph(6)
-        hexagons = [
-            [(0, 0), (0, 1), (0, 2), (1, 0), (1, 1), (1, 2)],
-            [(0, 2), (0, 3), (0, 4), (1, 2), (1, 3), (1, 4)],
-            [(1, 1), (1, 2), (1, 3), (2, 1), (2, 2), (2, 3)],
-            [(2, 0), (2, 1), (2, 2), (3, 0), (3, 1), (3, 2)],
-            [(2, 2), (2, 3), (2, 4), (3, 2), (3, 3), (3, 4)],
-        ]
-        for hexagon in hexagons:
-            assert nx.is_isomorphic(G.subgraph(hexagon), C_6)
-
-    def test_directed(self):
-        """Tests for creating a directed hexagonal lattice."""
-        G = nx.hexagonal_lattice_graph(3, 5, create_using=nx.Graph())
-        H = nx.hexagonal_lattice_graph(3, 5, create_using=nx.DiGraph())
-        assert H.is_directed()
-        pos = nx.get_node_attributes(H, "pos")
-        for u, v in H.edges():
-            assert pos[v][1] >= pos[u][1]
-            if pos[v][1] == pos[u][1]:
-                assert pos[v][0] > pos[u][0]
-
-    def test_multigraph(self):
-        """Tests for creating a hexagonal lattice multigraph."""
-        G = nx.hexagonal_lattice_graph(3, 5, create_using=nx.Graph())
-        H = nx.hexagonal_lattice_graph(3, 5, create_using=nx.MultiGraph())
-        assert list(H.edges()) == list(G.edges())
-
-    def test_periodic(self):
-        G = nx.hexagonal_lattice_graph(4, 6, periodic=True)
-        assert len(G) == 48
-        assert G.size() == 72
-        # all degrees are 3
-        assert len([n for n, d in G.degree() if d != 3]) == 0
-        G = nx.hexagonal_lattice_graph(5, 8, periodic=True)
-        HLG = nx.hexagonal_lattice_graph
-        pytest.raises(nx.NetworkXError, HLG, 2, 7, periodic=True)
-        pytest.raises(nx.NetworkXError, HLG, 1, 4, periodic=True)
-        pytest.raises(nx.NetworkXError, HLG, 2, 1, periodic=True)

package/runtime/python/okstra_vendor/networkx/generators/tests/test_line.py

@@ -1,316 +0,0 @@
-import pytest
-
-import networkx as nx
-from networkx.generators import line
-from networkx.utils import edges_equal
-
-
-class TestGeneratorLine:
-    def test_star(self):
-        G = nx.star_graph(5)
-        L = nx.line_graph(G)
-        assert nx.is_isomorphic(L, nx.complete_graph(5))
-
-    def test_path(self):
-        G = nx.path_graph(5)
-        L = nx.line_graph(G)
-        assert nx.is_isomorphic(L, nx.path_graph(4))
-
-    def test_cycle(self):
-        G = nx.cycle_graph(5)
-        L = nx.line_graph(G)
-        assert nx.is_isomorphic(L, G)
-
-    def test_digraph1(self):
-        G = nx.DiGraph([(0, 1), (0, 2), (0, 3)])
-        L = nx.line_graph(G)
-        # no edge graph, but with nodes
-        assert L.adj == {(0, 1): {}, (0, 2): {}, (0, 3): {}}
-
-    def test_multigraph1(self):
-        G = nx.MultiGraph([(0, 1), (0, 1), (1, 0), (0, 2), (2, 0), (0, 3)])
-        L = nx.line_graph(G)
-        # no edge graph, but with nodes
-        assert edges_equal(
-            L.edges(),
-            [
-                ((0, 3, 0), (0, 1, 0)),
-                ((0, 3, 0), (0, 2, 0)),
-                ((0, 3, 0), (0, 2, 1)),
-                ((0, 3, 0), (0, 1, 1)),
-                ((0, 3, 0), (0, 1, 2)),
-                ((0, 1, 0), (0, 1, 1)),
-                ((0, 1, 0), (0, 2, 0)),
-                ((0, 1, 0), (0, 1, 2)),
-                ((0, 1, 0), (0, 2, 1)),
-                ((0, 1, 1), (0, 1, 2)),
-                ((0, 1, 1), (0, 2, 0)),
-                ((0, 1, 1), (0, 2, 1)),
-                ((0, 1, 2), (0, 2, 0)),
-                ((0, 1, 2), (0, 2, 1)),
-                ((0, 2, 0), (0, 2, 1)),
-            ],
-        )
-
-    def test_multigraph2(self):
-        G = nx.MultiGraph([(1, 2), (2, 1)])
-        L = nx.line_graph(G)
-        assert edges_equal(L.edges(), [((1, 2, 0), (1, 2, 1))])
-
-    def test_multidigraph1(self):
-        G = nx.MultiDiGraph([(1, 2), (2, 1)])
-        L = nx.line_graph(G)
-        assert edges_equal(
-            L.edges(), [((1, 2, 0), (2, 1, 0)), ((2, 1, 0), (1, 2, 0))], directed=True
-        )
-
-    def test_multidigraph2(self):
-        G = nx.MultiDiGraph([(0, 1), (0, 1), (0, 1), (1, 2)])
-        L = nx.line_graph(G)
-        assert edges_equal(
-            L.edges(),
-            [((0, 1, 0), (1, 2, 0)), ((0, 1, 1), (1, 2, 0)), ((0, 1, 2), (1, 2, 0))],
-            directed=True,
-        )
-
-    def test_digraph2(self):
-        G = nx.DiGraph([(0, 1), (1, 2), (2, 3)])
-        L = nx.line_graph(G)
-        assert edges_equal(
-            L.edges(), [((0, 1), (1, 2)), ((1, 2), (2, 3))], directed=True
-        )
-
-    def test_create1(self):
-        G = nx.DiGraph([(0, 1), (1, 2), (2, 3)])
-        L = nx.line_graph(G, create_using=nx.Graph())
-        assert edges_equal(L.edges(), [((0, 1), (1, 2)), ((1, 2), (2, 3))])
-
-    def test_create2(self):
-        G = nx.Graph([(0, 1), (1, 2), (2, 3)])
-        L = nx.line_graph(G, create_using=nx.DiGraph())
-        assert edges_equal(
-            L.edges(), [((0, 1), (1, 2)), ((1, 2), (2, 3))], directed=True
-        )
-
-
-class TestGeneratorInverseLine:
-    def test_example(self):
-        G = nx.Graph()
-        G_edges = [
-            [1, 2],
-            [1, 3],
-            [1, 4],
-            [1, 5],
-            [2, 3],
-            [2, 5],
-            [2, 6],
-            [2, 7],
-            [3, 4],
-            [3, 5],
-            [6, 7],
-            [6, 8],
-            [7, 8],
-        ]
-        G.add_edges_from(G_edges)
-        H = nx.inverse_line_graph(G)
-        solution = nx.Graph()
-        solution_edges = [
-            ("a", "b"),
-            ("a", "c"),
-            ("a", "d"),
-            ("a", "e"),
-            ("c", "d"),
-            ("e", "f"),
-            ("e", "g"),
-            ("f", "g"),
-        ]
-        solution.add_edges_from(solution_edges)
-        assert nx.is_isomorphic(H, solution)
-
-    def test_example_2(self):
-        G = nx.Graph()
-        G_edges = [[1, 2], [1, 3], [2, 3], [3, 4], [3, 5], [4, 5]]
-        G.add_edges_from(G_edges)
-        H = nx.inverse_line_graph(G)
-        solution = nx.Graph()
-        solution_edges = [("a", "c"), ("b", "c"), ("c", "d"), ("d", "e"), ("d", "f")]
-        solution.add_edges_from(solution_edges)
-        assert nx.is_isomorphic(H, solution)
-
-    def test_pair(self):
-        G = nx.path_graph(2)
-        H = nx.inverse_line_graph(G)
-        solution = nx.path_graph(3)
-        assert nx.is_isomorphic(H, solution)
-
-    def test_line(self):
-        G = nx.path_graph(5)
-        solution = nx.path_graph(6)
-        H = nx.inverse_line_graph(G)
-        assert nx.is_isomorphic(H, solution)
-
-    def test_triangle_graph(self):
-        G = nx.complete_graph(3)
-        H = nx.inverse_line_graph(G)
-        alternative_solution = nx.Graph()
-        alternative_solution.add_edges_from([[0, 1], [0, 2], [0, 3]])
-        # there are two alternative inverse line graphs for this case
-        # so long as we get one of them the test should pass
-        assert nx.is_isomorphic(H, G) or nx.is_isomorphic(H, alternative_solution)
-
-    def test_cycle(self):
-        G = nx.cycle_graph(5)
-        H = nx.inverse_line_graph(G)
-        assert nx.is_isomorphic(H, G)
-
-    def test_empty(self):
-        G = nx.Graph()
-        H = nx.inverse_line_graph(G)
-        assert nx.is_isomorphic(H, nx.complete_graph(1))
-
-    def test_K1(self):
-        G = nx.complete_graph(1)
-        H = nx.inverse_line_graph(G)
-        solution = nx.path_graph(2)
-        assert nx.is_isomorphic(H, solution)
-
-    def test_edgeless_graph(self):
-        G = nx.empty_graph(5)
-        with pytest.raises(nx.NetworkXError, match="edgeless graph"):
-            nx.inverse_line_graph(G)
-
-    def test_selfloops_error(self):
-        G = nx.cycle_graph(4)
-        G.add_edge(0, 0)
-        pytest.raises(nx.NetworkXError, nx.inverse_line_graph, G)
-
-    def test_non_line_graphs(self):
-        # Tests several known non-line graphs for impossibility
-        # Adapted from L.W.Beineke, "Characterizations of derived graphs"
-
-        # claw graph
-        claw = nx.star_graph(3)
-        pytest.raises(nx.NetworkXError, nx.inverse_line_graph, claw)
-
-        # wheel graph with 6 nodes
-        wheel = nx.wheel_graph(6)
-        pytest.raises(nx.NetworkXError, nx.inverse_line_graph, wheel)
-
-        # K5 with one edge remove
-        K5m = nx.complete_graph(5)
-        K5m.remove_edge(0, 1)
-        pytest.raises(nx.NetworkXError, nx.inverse_line_graph, K5m)
-
-        # graph without any odd triangles (contains claw as induced subgraph)
-        G = nx.compose(nx.path_graph(2), nx.complete_bipartite_graph(2, 3))
-        pytest.raises(nx.NetworkXError, nx.inverse_line_graph, G)
-
-        ## Variations on a diamond graph
-
-        # Diamond + 2 edges (+ "roof")
-        G = nx.diamond_graph()
-        G.add_edges_from([(4, 0), (5, 3)])
-        pytest.raises(nx.NetworkXError, nx.inverse_line_graph, G)
-        G.add_edge(4, 5)
-        pytest.raises(nx.NetworkXError, nx.inverse_line_graph, G)
-
-        # Diamond + 2 connected edges
-        G = nx.diamond_graph()
-        G.add_edges_from([(4, 0), (4, 3)])
-        pytest.raises(nx.NetworkXError, nx.inverse_line_graph, G)
-
-        # Diamond + K3 + one edge (+ 2*K3)
-        G = nx.diamond_graph()
-        G.add_edges_from([(4, 0), (4, 1), (4, 2), (5, 3)])
-        pytest.raises(nx.NetworkXError, nx.inverse_line_graph, G)
-        G.add_edges_from([(5, 1), (5, 2)])
-        pytest.raises(nx.NetworkXError, nx.inverse_line_graph, G)
-
-        # 4 triangles
-        G = nx.diamond_graph()
-        G.add_edges_from([(4, 0), (4, 1), (5, 2), (5, 3)])
-        pytest.raises(nx.NetworkXError, nx.inverse_line_graph, G)
-
-    def test_wrong_graph_type(self):
-        G = nx.DiGraph()
-        G_edges = [[0, 1], [0, 2], [0, 3]]
-        G.add_edges_from(G_edges)
-        pytest.raises(nx.NetworkXNotImplemented, nx.inverse_line_graph, G)
-
-        G = nx.MultiGraph()
-        G_edges = [[0, 1], [0, 2], [0, 3]]
-        G.add_edges_from(G_edges)
-        pytest.raises(nx.NetworkXNotImplemented, nx.inverse_line_graph, G)
-
-    def test_line_inverse_line_complete(self):
-        G = nx.complete_graph(10)
-        H = nx.line_graph(G)
-        J = nx.inverse_line_graph(H)
-        assert nx.is_isomorphic(G, J)
-
-    def test_line_inverse_line_path(self):
-        G = nx.path_graph(10)
-        H = nx.line_graph(G)
-        J = nx.inverse_line_graph(H)
-        assert nx.is_isomorphic(G, J)
-
-    def test_line_inverse_line_hypercube(self):
-        G = nx.hypercube_graph(5)
-        H = nx.line_graph(G)
-        J = nx.inverse_line_graph(H)
-        assert nx.is_isomorphic(G, J)
-
-    def test_line_inverse_line_cycle(self):
-        G = nx.cycle_graph(10)
-        H = nx.line_graph(G)
-        J = nx.inverse_line_graph(H)
-        assert nx.is_isomorphic(G, J)
-
-    def test_line_inverse_line_star(self):
-        G = nx.star_graph(20)
-        H = nx.line_graph(G)
-        J = nx.inverse_line_graph(H)
-        assert nx.is_isomorphic(G, J)
-
-    def test_line_inverse_line_multipartite(self):
-        G = nx.complete_multipartite_graph(3, 4, 5)
-        H = nx.line_graph(G)
-        J = nx.inverse_line_graph(H)
-        assert nx.is_isomorphic(G, J)
-
-    def test_line_inverse_line_dgm(self):
-        G = nx.dorogovtsev_goltsev_mendes_graph(4)
-        H = nx.line_graph(G)
-        J = nx.inverse_line_graph(H)
-        assert nx.is_isomorphic(G, J)
-
-    def test_line_different_node_types(self):
-        G = nx.path_graph([1, 2, 3, "a", "b", "c"])
-        H = nx.line_graph(G)
-        J = nx.inverse_line_graph(H)
-        assert nx.is_isomorphic(G, J)
-
-
-class TestGeneratorPrivateFunctions:
-    def test_triangles_error(self):
-        G = nx.diamond_graph()
-        pytest.raises(nx.NetworkXError, line._triangles, G, (4, 0))
-        pytest.raises(nx.NetworkXError, line._triangles, G, (0, 3))
-
-    def test_odd_triangles_error(self):
-        G = nx.diamond_graph()
-        pytest.raises(nx.NetworkXError, line._odd_triangle, G, (0, 1, 4))
-        pytest.raises(nx.NetworkXError, line._odd_triangle, G, (0, 1, 3))
-
-    def test_select_starting_cell_error(self):
-        G = nx.diamond_graph()
-        pytest.raises(nx.NetworkXError, line._select_starting_cell, G, (4, 0))
-        pytest.raises(nx.NetworkXError, line._select_starting_cell, G, (0, 3))
-
-    def test_diamond_graph(self):
-        G = nx.diamond_graph()
-        for edge in G.edges:
-            cell = line._select_starting_cell(G, starting_edge=edge)
-            # Starting cell should always be one of the two triangles
-            assert len(cell) == 3
-            assert all(v in G[u] for u in cell for v in cell if u != v)

package/runtime/python/okstra_vendor/networkx/generators/tests/test_mycielski.py

@@ -1,30 +0,0 @@
-"""Unit tests for the :mod:`networkx.generators.mycielski` module."""
-
-import pytest
-
-import networkx as nx
-
-
-class TestMycielski:
-    def test_construction(self):
-        G = nx.path_graph(2)
-        M = nx.mycielskian(G)
-        assert nx.is_isomorphic(M, nx.cycle_graph(5))
-
-    def test_size(self):
-        G = nx.path_graph(2)
-        M = nx.mycielskian(G, 2)
-        assert len(M) == 11
-        assert M.size() == 20
-
-    def test_mycielski_graph_generator(self):
-        G = nx.mycielski_graph(1)
-        assert nx.is_isomorphic(G, nx.empty_graph(1))
-        G = nx.mycielski_graph(2)
-        assert nx.is_isomorphic(G, nx.path_graph(2))
-        G = nx.mycielski_graph(3)
-        assert nx.is_isomorphic(G, nx.cycle_graph(5))
-        G = nx.mycielski_graph(4)
-        assert nx.is_isomorphic(G, nx.mycielskian(nx.cycle_graph(5)))
-        with pytest.raises(nx.NetworkXError, match="must satisfy n >= 1"):
-            nx.mycielski_graph(0)

package/runtime/python/okstra_vendor/networkx/generators/tests/test_nonisomorphic_trees.py

@@ -1,82 +0,0 @@
-"""
-Unit tests for WROM algorithm generator in generators/nonisomorphic_trees.py
-"""
-
-import pytest
-
-import networkx as nx
-from networkx.utils import edges_equal
-
-
-def test_nonisomorphic_tree_negative_order():
-    with pytest.raises(ValueError, match="order must be non-negative"):
-        nx.number_of_nonisomorphic_trees(-1)
-    with pytest.raises(ValueError, match="order must be non-negative"):
-        next(nx.nonisomorphic_trees(-1))
-
-
-def test_nonisomorphic_tree_order_0():
-    assert nx.number_of_nonisomorphic_trees(0) == 0
-    assert list(nx.nonisomorphic_trees(0)) == []
-
-
-def test_nonisomorphic_tree_order_1():
-    assert nx.number_of_nonisomorphic_trees(1) == 1
-    nit_list = list(nx.nonisomorphic_trees(1))
-    assert len(nit_list) == 1
-    G = nit_list[0]
-    assert nx.utils.graphs_equal(G, nx.empty_graph(1))
-
-
-@pytest.mark.parametrize("n", range(5))
-def test_nonisomorphic_tree_low_order_agreement(n):
-    """Ensure all the order<2 'special cases' are consistent."""
-    assert len(list(nx.nonisomorphic_trees(n))) == nx.number_of_nonisomorphic_trees(n)
-
-
-class TestGeneratorNonIsomorphicTrees:
-    def test_tree_structure(self):
-        # test for tree structure for nx.nonisomorphic_trees()
-        def f(x):
-            return list(nx.nonisomorphic_trees(x))
-
-        for i in f(6):
-            assert nx.is_tree(i)
-        for i in f(8):
-            assert nx.is_tree(i)
-
-    def test_nonisomorphism(self):
-        # test for nonisomorphism of trees for nx.nonisomorphic_trees()
-        def f(x):
-            return list(nx.nonisomorphic_trees(x))
-
-        trees = f(6)
-        for i in range(len(trees)):
-            for j in range(i + 1, len(trees)):
-                assert not nx.is_isomorphic(trees[i], trees[j])
-        trees = f(8)
-        for i in range(len(trees)):
-            for j in range(i + 1, len(trees)):
-                assert not nx.is_isomorphic(trees[i], trees[j])
-
-    def test_number_of_nonisomorphic_trees(self):
-        # http://oeis.org/A000055
-        assert nx.number_of_nonisomorphic_trees(2) == 1
-        assert nx.number_of_nonisomorphic_trees(3) == 1
-        assert nx.number_of_nonisomorphic_trees(4) == 2
-        assert nx.number_of_nonisomorphic_trees(5) == 3
-        assert nx.number_of_nonisomorphic_trees(6) == 6
-        assert nx.number_of_nonisomorphic_trees(7) == 11
-        assert nx.number_of_nonisomorphic_trees(8) == 23
-        assert nx.number_of_nonisomorphic_trees(9) == 47
-        assert nx.number_of_nonisomorphic_trees(10) == 106
-        assert nx.number_of_nonisomorphic_trees(20) == 823065
-        assert nx.number_of_nonisomorphic_trees(30) == 14830871802
-
-    def test_nonisomorphic_trees(self):
-        def f(x):
-            return list(nx.nonisomorphic_trees(x))
-
-        assert edges_equal(f(3)[0].edges(), [(0, 1), (0, 2)])
-        assert edges_equal(f(4)[0].edges(), [(0, 1), (0, 3), (1, 2)])
-        assert edges_equal(f(4)[1].edges(), [(0, 1), (0, 2), (0, 3)])