okstra 0.114.0 → 0.115.0

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

@@ -1,220 +0,0 @@
-import pytest
-
-import networkx as nx
-
-null = nx.null_graph()
-
-
-class TestGeneratorsSmall:
-    def test__LCF_graph(self):
-        # If n<=0, then return the null_graph
-        G = nx.LCF_graph(-10, [1, 2], 100)
-        assert nx.could_be_isomorphic(G, null)
-        G = nx.LCF_graph(0, [1, 2], 3)
-        assert nx.could_be_isomorphic(G, null)
-        G = nx.LCF_graph(0, [1, 2], 10)
-        assert nx.could_be_isomorphic(G, null)
-
-        # Test that LCF(n,[],0) == cycle_graph(n)
-        for a, b, c in [(5, [], 0), (10, [], 0), (5, [], 1), (10, [], 10)]:
-            G = nx.LCF_graph(a, b, c)
-            assert nx.could_be_isomorphic(G, nx.cycle_graph(a))
-
-        # Generate the utility graph K_{3,3}
-        G = nx.LCF_graph(6, [3, -3], 3)
-        utility_graph = nx.complete_bipartite_graph(3, 3)
-        assert nx.could_be_isomorphic(G, utility_graph)
-
-        with pytest.raises(nx.NetworkXError, match="Directed Graph not supported"):
-            G = nx.LCF_graph(6, [3, -3], 3, create_using=nx.DiGraph)
-
-    def test_properties_of_named_small_graphs(self):
-        G = nx.bull_graph()
-        assert sorted(G) == list(range(5))
-        assert G.number_of_edges() == 5
-        assert sorted(d for n, d in G.degree()) == [1, 1, 2, 3, 3]
-        assert nx.diameter(G) == 3
-        assert nx.radius(G) == 2
-
-        G = nx.chvatal_graph()
-        assert sorted(G) == list(range(12))
-        assert G.number_of_edges() == 24
-        assert [d for n, d in G.degree()] == 12 * [4]
-        assert nx.diameter(G) == 2
-        assert nx.radius(G) == 2
-
-        G = nx.cubical_graph()
-        assert sorted(G) == list(range(8))
-        assert G.number_of_edges() == 12
-        assert [d for n, d in G.degree()] == 8 * [3]
-        assert nx.diameter(G) == 3
-        assert nx.radius(G) == 3
-
-        G = nx.desargues_graph()
-        assert sorted(G) == list(range(20))
-        assert G.number_of_edges() == 30
-        assert [d for n, d in G.degree()] == 20 * [3]
-        assert nx.is_isomorphic(G, nx.generalized_petersen_graph(10, 3))
-
-        G = nx.diamond_graph()
-        assert sorted(G) == list(range(4))
-        assert sorted(d for n, d in G.degree()) == [2, 2, 3, 3]
-        assert nx.diameter(G) == 2
-        assert nx.radius(G) == 1
-
-        G = nx.dodecahedral_graph()
-        assert sorted(G) == list(range(20))
-        assert G.number_of_edges() == 30
-        assert [d for n, d in G.degree()] == 20 * [3]
-        assert nx.diameter(G) == 5
-        assert nx.radius(G) == 5
-        assert nx.is_isomorphic(G, nx.generalized_petersen_graph(10, 2))
-
-        G = nx.frucht_graph()
-        assert sorted(G) == list(range(12))
-        assert G.number_of_edges() == 18
-        assert [d for n, d in G.degree()] == 12 * [3]
-        assert nx.diameter(G) == 4
-        assert nx.radius(G) == 3
-
-        G = nx.generalized_petersen_graph(10, 4)
-        assert sorted(G) == list(range(20))
-        assert G.number_of_edges() == 30
-        assert [d for n, d in G.degree()] == 20 * [3]
-        assert nx.diameter(G) == 4
-        assert nx.radius(G) == 4
-
-        G = nx.heawood_graph()
-        assert sorted(G) == list(range(14))
-        assert G.number_of_edges() == 21
-        assert [d for n, d in G.degree()] == 14 * [3]
-        assert nx.diameter(G) == 3
-        assert nx.radius(G) == 3
-
-        G = nx.hoffman_singleton_graph()
-        assert sorted(G) == list(range(50))
-        assert G.number_of_edges() == 175
-        assert [d for n, d in G.degree()] == 50 * [7]
-        assert nx.diameter(G) == 2
-        assert nx.radius(G) == 2
-
-        G = nx.house_graph()
-        assert sorted(G) == list(range(5))
-        assert G.number_of_edges() == 6
-        assert sorted(d for n, d in G.degree()) == [2, 2, 2, 3, 3]
-        assert nx.diameter(G) == 2
-        assert nx.radius(G) == 2
-
-        G = nx.house_x_graph()
-        assert sorted(G) == list(range(5))
-        assert G.number_of_edges() == 8
-        assert sorted(d for n, d in G.degree()) == [2, 3, 3, 4, 4]
-        assert nx.diameter(G) == 2
-        assert nx.radius(G) == 1
-
-        G = nx.icosahedral_graph()
-        assert sorted(G) == list(range(12))
-        assert G.number_of_edges() == 30
-        assert [d for n, d in G.degree()] == [5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5]
-        assert nx.diameter(G) == 3
-        assert nx.radius(G) == 3
-
-        G = nx.krackhardt_kite_graph()
-        assert sorted(G) == list(range(10))
-        assert G.number_of_edges() == 18
-        assert sorted(d for n, d in G.degree()) == [1, 2, 3, 3, 3, 4, 4, 5, 5, 6]
-
-        G = nx.moebius_kantor_graph()
-        assert sorted(G) == list(range(16))
-        assert G.number_of_edges() == 24
-        assert [d for n, d in G.degree()] == 16 * [3]
-        assert nx.diameter(G) == 4
-        assert nx.is_isomorphic(G, nx.generalized_petersen_graph(8, 3))
-
-        G = nx.octahedral_graph()
-        assert sorted(G) == list(range(6))
-        assert G.number_of_edges() == 12
-        assert [d for n, d in G.degree()] == 6 * [4]
-        assert nx.diameter(G) == 2
-        assert nx.radius(G) == 2
-
-        G = nx.pappus_graph()
-        assert sorted(G) == list(range(18))
-        assert G.number_of_edges() == 27
-        assert [d for n, d in G.degree()] == 18 * [3]
-        assert nx.diameter(G) == 4
-
-        G = nx.petersen_graph()
-        assert sorted(G) == list(range(10))
-        assert G.number_of_edges() == 15
-        assert [d for n, d in G.degree()] == 10 * [3]
-        assert nx.diameter(G) == 2
-        assert nx.radius(G) == 2
-        assert nx.is_isomorphic(G, nx.generalized_petersen_graph(5, 2))
-
-        G = nx.sedgewick_maze_graph()
-        assert sorted(G) == list(range(8))
-        assert G.number_of_edges() == 10
-        assert sorted(d for n, d in G.degree()) == [1, 2, 2, 2, 3, 3, 3, 4]
-
-        G = nx.tetrahedral_graph()
-        assert sorted(G) == list(range(4))
-        assert G.number_of_edges() == 6
-        assert [d for n, d in G.degree()] == [3, 3, 3, 3]
-        assert nx.diameter(G) == 1
-        assert nx.radius(G) == 1
-
-        G = nx.truncated_cube_graph()
-        assert sorted(G) == list(range(24))
-        assert G.number_of_edges() == 36
-        assert [d for n, d in G.degree()] == 24 * [3]
-
-        G = nx.truncated_tetrahedron_graph()
-        assert sorted(G) == list(range(12))
-        assert G.number_of_edges() == 18
-        assert [d for n, d in G.degree()] == 12 * [3]
-
-        G = nx.tutte_graph()
-        assert sorted(G) == list(range(46))
-        assert G.number_of_edges() == 69
-        assert [d for n, d in G.degree()] == 46 * [3]
-
-        MG = nx.tutte_graph(create_using=nx.MultiGraph)
-        assert sorted(MG.edges()) == sorted(G.edges())
-
-        # Test create_using with directed or multigraphs on small graphs
-        with pytest.raises(nx.NetworkXError, match="Directed Graph not supported "):
-            nx.generalized_petersen_graph(5, 2, create_using=nx.DiGraph)
-        with pytest.raises(nx.NetworkXError, match="Directed Graph not supported "):
-            nx.generalized_petersen_graph(5, 2, create_using=nx.MultiDiGraph)
-        G = nx.generalized_petersen_graph(5, 2)
-        MG = nx.generalized_petersen_graph(5, 2, create_using=nx.MultiGraph)
-        assert sorted(MG.edges()) == sorted(G.edges())
-
-
-@pytest.mark.parametrize(
-    "fn",
-    (
-        nx.bull_graph,
-        nx.chvatal_graph,
-        nx.cubical_graph,
-        nx.diamond_graph,
-        nx.house_graph,
-        nx.house_x_graph,
-        nx.icosahedral_graph,
-        nx.krackhardt_kite_graph,
-        nx.octahedral_graph,
-        nx.petersen_graph,
-        nx.truncated_cube_graph,
-        nx.tutte_graph,
-    ),
-)
-@pytest.mark.parametrize(
-    "create_using", (nx.DiGraph, nx.MultiDiGraph, nx.DiGraph([(0, 1)]))
-)
-def tests_raises_with_directed_create_using(fn, create_using):
-    with pytest.raises(nx.NetworkXError, match="Directed Graph not supported"):
-        fn(create_using=create_using)
-    # All these functions have `create_using` as the first positional argument too
-    with pytest.raises(nx.NetworkXError, match="Directed Graph not supported"):
-        fn(create_using)

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

@@ -1,49 +0,0 @@
-import pytest
-
-pytest.importorskip("numpy")
-pytest.importorskip("scipy")
-
-
-from networkx import is_isomorphic
-from networkx.exception import NetworkXError
-from networkx.generators import karate_club_graph
-from networkx.generators.spectral_graph_forge import spectral_graph_forge
-from networkx.utils import nodes_equal
-
-
-def test_spectral_graph_forge():
-    G = karate_club_graph()
-
-    seed = 54321
-
-    # common cases, just checking node number preserving and difference
-    # between identity and modularity cases
-    H = spectral_graph_forge(G, 0.1, transformation="identity", seed=seed)
-    assert nodes_equal(G, H)
-
-    I = spectral_graph_forge(G, 0.1, transformation="identity", seed=seed)
-    assert nodes_equal(G, H)
-    assert is_isomorphic(I, H)
-
-    I = spectral_graph_forge(G, 0.1, transformation="modularity", seed=seed)
-    assert nodes_equal(G, I)
-
-    assert not is_isomorphic(I, H)
-
-    # with all the eigenvectors, output graph is identical to the input one
-    H = spectral_graph_forge(G, 1, transformation="modularity", seed=seed)
-    assert nodes_equal(G, H)
-    assert is_isomorphic(G, H)
-
-    # invalid alpha input value, it is silently truncated in [0,1]
-    H = spectral_graph_forge(G, -1, transformation="identity", seed=seed)
-    assert nodes_equal(G, H)
-
-    H = spectral_graph_forge(G, 10, transformation="identity", seed=seed)
-    assert nodes_equal(G, H)
-    assert is_isomorphic(G, H)
-
-    # invalid transformation mode, checking the error raising
-    pytest.raises(
-        NetworkXError, spectral_graph_forge, G, 0.1, transformation="unknown", seed=seed
-    )

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

@@ -1,72 +0,0 @@
-"""Unit tests for the :mod:`networkx.generators.stochastic` module."""
-
-import pytest
-
-import networkx as nx
-
-
-class TestStochasticGraph:
-    """Unit tests for the :func:`~networkx.stochastic_graph` function."""
-
-    def test_default_weights(self):
-        G = nx.DiGraph()
-        G.add_edge(0, 1)
-        G.add_edge(0, 2)
-        S = nx.stochastic_graph(G)
-        assert nx.is_isomorphic(G, S)
-        assert sorted(S.edges(data=True)) == [
-            (0, 1, {"weight": 0.5}),
-            (0, 2, {"weight": 0.5}),
-        ]
-
-    def test_in_place(self):
-        """Tests for an in-place reweighting of the edges of the graph."""
-        G = nx.DiGraph()
-        G.add_edge(0, 1, weight=1)
-        G.add_edge(0, 2, weight=1)
-        nx.stochastic_graph(G, copy=False)
-        assert sorted(G.edges(data=True)) == [
-            (0, 1, {"weight": 0.5}),
-            (0, 2, {"weight": 0.5}),
-        ]
-
-    def test_arbitrary_weights(self):
-        G = nx.DiGraph()
-        G.add_edge(0, 1, weight=1)
-        G.add_edge(0, 2, weight=1)
-        S = nx.stochastic_graph(G)
-        assert sorted(S.edges(data=True)) == [
-            (0, 1, {"weight": 0.5}),
-            (0, 2, {"weight": 0.5}),
-        ]
-
-    def test_multidigraph(self):
-        G = nx.MultiDiGraph()
-        G.add_edges_from([(0, 1), (0, 1), (0, 2), (0, 2)])
-        S = nx.stochastic_graph(G)
-        d = {"weight": 0.25}
-        assert sorted(S.edges(data=True)) == [
-            (0, 1, d),
-            (0, 1, d),
-            (0, 2, d),
-            (0, 2, d),
-        ]
-
-    def test_zero_weights(self):
-        """Smoke test: ensure ZeroDivisionError is not raised."""
-        G = nx.DiGraph()
-        G.add_edge(0, 1, weight=0)
-        G.add_edge(0, 2, weight=0)
-        S = nx.stochastic_graph(G)
-        assert sorted(S.edges(data=True)) == [
-            (0, 1, {"weight": 0}),
-            (0, 2, {"weight": 0}),
-        ]
-
-    def test_graph_disallowed(self):
-        with pytest.raises(nx.NetworkXNotImplemented):
-            nx.stochastic_graph(nx.Graph())
-
-    def test_multigraph_disallowed(self):
-        with pytest.raises(nx.NetworkXNotImplemented):
-            nx.stochastic_graph(nx.MultiGraph())

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

@@ -1,92 +0,0 @@
-"""Unit tests for the :mod:`networkx.generators.sudoku_graph` module."""
-
-import pytest
-
-import networkx as nx
-
-
-def test_sudoku_negative():
-    """Raise an error when generating a Sudoku graph of order -1."""
-    pytest.raises(nx.NetworkXError, nx.sudoku_graph, n=-1)
-
-
-@pytest.mark.parametrize("n", [0, 1, 2, 3, 4])
-def test_sudoku_generator(n):
-    """Generate Sudoku graphs of various sizes and verify their properties."""
-    G = nx.sudoku_graph(n)
-    expected_nodes = n**4
-    expected_degree = (n - 1) * (3 * n + 1)
-    expected_edges = expected_nodes * expected_degree // 2
-    assert not G.is_directed()
-    assert not G.is_multigraph()
-    assert G.number_of_nodes() == expected_nodes
-    assert G.number_of_edges() == expected_edges
-    assert all(d == expected_degree for _, d in G.degree)
-
-    if n == 2:
-        assert sorted(G.neighbors(6)) == [2, 3, 4, 5, 7, 10, 14]
-    elif n == 3:
-        assert sorted(G.neighbors(42)) == [
-            6,
-            15,
-            24,
-            33,
-            34,
-            35,
-            36,
-            37,
-            38,
-            39,
-            40,
-            41,
-            43,
-            44,
-            51,
-            52,
-            53,
-            60,
-            69,
-            78,
-        ]
-    elif n == 4:
-        assert sorted(G.neighbors(0)) == [
-            1,
-            2,
-            3,
-            4,
-            5,
-            6,
-            7,
-            8,
-            9,
-            10,
-            11,
-            12,
-            13,
-            14,
-            15,
-            16,
-            17,
-            18,
-            19,
-            32,
-            33,
-            34,
-            35,
-            48,
-            49,
-            50,
-            51,
-            64,
-            80,
-            96,
-            112,
-            128,
-            144,
-            160,
-            176,
-            192,
-            208,
-            224,
-            240,
-        ]

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

@@ -1,64 +0,0 @@
-"""Unit tests for the :mod:`networkx.generators.time_series` module."""
-
-import itertools
-
-import networkx as nx
-
-
-def test_visibility_graph__empty_series__empty_graph():
-    null_graph = nx.visibility_graph([])  # move along nothing to see here
-    assert nx.is_empty(null_graph)
-
-
-def test_visibility_graph__single_value_ts__single_node_graph():
-    node_graph = nx.visibility_graph([10])  # So Lonely
-    assert node_graph.number_of_nodes() == 1
-    assert node_graph.number_of_edges() == 0
-
-
-def test_visibility_graph__two_values_ts__single_edge_graph():
-    edge_graph = nx.visibility_graph([10, 20])  # Two of Us
-    assert list(edge_graph.edges) == [(0, 1)]
-
-
-def test_visibility_graph__convex_series__complete_graph():
-    series = [i**2 for i in range(10)]  # no obstructions
-    expected_series_length = len(series)
-
-    actual_graph = nx.visibility_graph(series)
-
-    assert actual_graph.number_of_nodes() == expected_series_length
-    assert actual_graph.number_of_edges() == 45
-    assert nx.is_isomorphic(actual_graph, nx.complete_graph(expected_series_length))
-
-
-def test_visibility_graph__concave_series__path_graph():
-    series = [-(i**2) for i in range(10)]  # Slip Slidin' Away
-    expected_node_count = len(series)
-
-    actual_graph = nx.visibility_graph(series)
-
-    assert actual_graph.number_of_nodes() == expected_node_count
-    assert actual_graph.number_of_edges() == expected_node_count - 1
-    assert nx.is_isomorphic(actual_graph, nx.path_graph(expected_node_count))
-
-
-def test_visibility_graph__flat_series__path_graph():
-    series = [0] * 10  # living in 1D flatland
-    expected_node_count = len(series)
-
-    actual_graph = nx.visibility_graph(series)
-
-    assert actual_graph.number_of_nodes() == expected_node_count
-    assert actual_graph.number_of_edges() == expected_node_count - 1
-    assert nx.is_isomorphic(actual_graph, nx.path_graph(expected_node_count))
-
-
-def test_visibility_graph_cyclic_series():
-    series = list(itertools.islice(itertools.cycle((2, 1, 3)), 17))  # It's so bumpy!
-    expected_node_count = len(series)
-
-    actual_graph = nx.visibility_graph(series)
-
-    assert actual_graph.number_of_nodes() == expected_node_count
-    assert actual_graph.number_of_edges() == 25

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

@@ -1,195 +0,0 @@
-import random
-
-import pytest
-
-import networkx as nx
-from networkx.utils import arbitrary_element, graphs_equal
-
-
-@pytest.mark.parametrize("prefix_tree_fn", (nx.prefix_tree, nx.prefix_tree_recursive))
-def test_basic_prefix_tree(prefix_tree_fn):
-    # This example is from the Wikipedia article "Trie"
-    # <https://en.wikipedia.org/wiki/Trie>.
-    strings = ["a", "to", "tea", "ted", "ten", "i", "in", "inn"]
-    T = prefix_tree_fn(strings)
-    root, NIL = 0, -1
-
-    def source_label(v):
-        return T.nodes[v]["source"]
-
-    # First, we check that the tree has the expected
-    # structure. Recall that each node that corresponds to one of
-    # the input strings has an edge to the NIL node.
-    #
-    # Consider the three children at level 1 in the trie.
-    a, i, t = sorted(T[root], key=source_label)
-    # Check the 'a' branch.
-    assert len(T[a]) == 1
-    nil = arbitrary_element(T[a])
-    assert len(T[nil]) == 0
-    # Check the 'i' branch.
-    assert len(T[i]) == 2
-    nil, in_ = sorted(T[i], key=source_label)
-    assert len(T[nil]) == 0
-    assert len(T[in_]) == 2
-    nil, inn = sorted(T[in_], key=source_label)
-    assert len(T[nil]) == 0
-    assert len(T[inn]) == 1
-    nil = arbitrary_element(T[inn])
-    assert len(T[nil]) == 0
-    # Check the 't' branch.
-    te, to = sorted(T[t], key=source_label)
-    assert len(T[to]) == 1
-    nil = arbitrary_element(T[to])
-    assert len(T[nil]) == 0
-    tea, ted, ten = sorted(T[te], key=source_label)
-    assert len(T[tea]) == 1
-    assert len(T[ted]) == 1
-    assert len(T[ten]) == 1
-    nil = arbitrary_element(T[tea])
-    assert len(T[nil]) == 0
-    nil = arbitrary_element(T[ted])
-    assert len(T[nil]) == 0
-    nil = arbitrary_element(T[ten])
-    assert len(T[nil]) == 0
-
-    # Next, we check that the "sources" of each of the nodes is the
-    # rightmost letter in the string corresponding to the path to
-    # that node.
-    assert source_label(root) is None
-    assert source_label(a) == "a"
-    assert source_label(i) == "i"
-    assert source_label(t) == "t"
-    assert source_label(in_) == "n"
-    assert source_label(inn) == "n"
-    assert source_label(to) == "o"
-    assert source_label(te) == "e"
-    assert source_label(tea) == "a"
-    assert source_label(ted) == "d"
-    assert source_label(ten) == "n"
-    assert source_label(NIL) == "NIL"
-
-
-@pytest.mark.parametrize(
-    "strings",
-    (
-        ["a", "to", "tea", "ted", "ten", "i", "in", "inn"],
-        ["ab", "abs", "ad"],
-        ["ab", "abs", "ad", ""],
-        ["distant", "disparaging", "distant", "diamond", "ruby"],
-    ),
-)
-def test_implementations_consistent(strings):
-    """Ensure results are consistent between prefix_tree implementations."""
-    assert graphs_equal(nx.prefix_tree(strings), nx.prefix_tree_recursive(strings))
-
-
-def test_random_labeled_rooted_tree():
-    for i in range(1, 10):
-        t1 = nx.random_labeled_rooted_tree(i, seed=42)
-        t2 = nx.random_labeled_rooted_tree(i, seed=42)
-        assert nx.utils.misc.graphs_equal(t1, t2)
-        assert nx.is_tree(t1)
-        assert "root" in t1.graph
-        assert "roots" not in t1.graph
-
-
-def test_random_labeled_tree_n_zero():
-    """Tests if n = 0 then the NetworkXPointlessConcept exception is raised."""
-    with pytest.raises(nx.NetworkXPointlessConcept):
-        T = nx.random_labeled_tree(0, seed=1234)
-    with pytest.raises(nx.NetworkXPointlessConcept):
-        T = nx.random_labeled_rooted_tree(0, seed=1234)
-
-
-def test_random_labeled_rooted_forest():
-    for i in range(1, 10):
-        t1 = nx.random_labeled_rooted_forest(i, seed=42)
-        t2 = nx.random_labeled_rooted_forest(i, seed=42)
-        assert nx.utils.misc.graphs_equal(t1, t2)
-        for c in nx.connected_components(t1):
-            assert nx.is_tree(t1.subgraph(c))
-        assert "root" not in t1.graph
-        assert "roots" in t1.graph
-
-
-def test_random_labeled_rooted_forest_n_zero():
-    """Tests generation of empty labeled forests."""
-    F = nx.random_labeled_rooted_forest(0, seed=1234)
-    assert len(F) == 0
-    assert len(F.graph["roots"]) == 0
-
-
-def test_random_unlabeled_rooted_tree():
-    for i in range(1, 10):
-        t1 = nx.random_unlabeled_rooted_tree(i, seed=42)
-        t2 = nx.random_unlabeled_rooted_tree(i, seed=42)
-        assert nx.utils.misc.graphs_equal(t1, t2)
-        assert nx.is_tree(t1)
-        assert "root" in t1.graph
-        assert "roots" not in t1.graph
-    t = nx.random_unlabeled_rooted_tree(15, number_of_trees=10, seed=43)
-    random.seed(43)
-    s = nx.random_unlabeled_rooted_tree(15, number_of_trees=10, seed=random)
-    for i in range(10):
-        assert nx.utils.misc.graphs_equal(t[i], s[i])
-        assert nx.is_tree(t[i])
-        assert "root" in t[i].graph
-        assert "roots" not in t[i].graph
-
-
-def test_random_unlabeled_tree_n_zero():
-    """Tests if n = 0 then the NetworkXPointlessConcept exception is raised."""
-    with pytest.raises(nx.NetworkXPointlessConcept):
-        T = nx.random_unlabeled_tree(0, seed=1234)
-    with pytest.raises(nx.NetworkXPointlessConcept):
-        T = nx.random_unlabeled_rooted_tree(0, seed=1234)
-
-
-def test_random_unlabeled_rooted_forest():
-    with pytest.raises(ValueError):
-        nx.random_unlabeled_rooted_forest(10, q=0, seed=42)
-    for i in range(1, 10):
-        for q in range(1, i + 1):
-            t1 = nx.random_unlabeled_rooted_forest(i, q=q, seed=42)
-            t2 = nx.random_unlabeled_rooted_forest(i, q=q, seed=42)
-            assert nx.utils.misc.graphs_equal(t1, t2)
-            for c in nx.connected_components(t1):
-                assert nx.is_tree(t1.subgraph(c))
-                assert len(c) <= q
-            assert "root" not in t1.graph
-            assert "roots" in t1.graph
-    t = nx.random_unlabeled_rooted_forest(15, number_of_forests=10, seed=43)
-    random.seed(43)
-    s = nx.random_unlabeled_rooted_forest(15, number_of_forests=10, seed=random)
-    for i in range(10):
-        assert nx.utils.misc.graphs_equal(t[i], s[i])
-        for c in nx.connected_components(t[i]):
-            assert nx.is_tree(t[i].subgraph(c))
-        assert "root" not in t[i].graph
-        assert "roots" in t[i].graph
-
-
-def test_random_unlabeled_forest_n_zero():
-    """Tests generation of empty unlabeled forests."""
-    F = nx.random_unlabeled_rooted_forest(0, seed=1234)
-    assert len(F) == 0
-    assert len(F.graph["roots"]) == 0
-
-
-def test_random_unlabeled_tree():
-    for i in range(1, 10):
-        t1 = nx.random_unlabeled_tree(i, seed=42)
-        t2 = nx.random_unlabeled_tree(i, seed=42)
-        assert nx.utils.misc.graphs_equal(t1, t2)
-        assert nx.is_tree(t1)
-        assert "root" not in t1.graph
-        assert "roots" not in t1.graph
-    t = nx.random_unlabeled_tree(10, number_of_trees=10, seed=43)
-    random.seed(43)
-    s = nx.random_unlabeled_tree(10, number_of_trees=10, seed=random)
-    for i in range(10):
-        assert nx.utils.misc.graphs_equal(t[i], s[i])
-        assert nx.is_tree(t[i])
-        assert "root" not in t[i].graph
-        assert "roots" not in t[i].graph