okstra 0.113.0 → 0.115.0

package/runtime/python/okstra_vendor/networkx/classes/tests/test_coreviews.py

@@ -1,362 +0,0 @@
-import pickle
-
-import pytest
-
-import networkx as nx
-
-
-class TestAtlasView:
-    # node->data
-    def setup_method(self):
-        self.d = {0: {"color": "blue", "weight": 1.2}, 1: {}, 2: {"color": 1}}
-        self.av = nx.classes.coreviews.AtlasView(self.d)
-
-    def test_pickle(self):
-        view = self.av
-        pview = pickle.loads(pickle.dumps(view, -1))
-        assert view == pview
-        assert view.__slots__ == pview.__slots__
-        pview = pickle.loads(pickle.dumps(view))
-        assert view == pview
-        assert view.__slots__ == pview.__slots__
-
-    def test_len(self):
-        assert len(self.av) == len(self.d)
-
-    def test_iter(self):
-        assert list(self.av) == list(self.d)
-
-    def test_getitem(self):
-        assert self.av[1] is self.d[1]
-        assert self.av[2]["color"] == 1
-        pytest.raises(KeyError, self.av.__getitem__, 3)
-
-    def test_copy(self):
-        avcopy = self.av.copy()
-        assert avcopy[0] == self.av[0]
-        assert avcopy == self.av
-        assert avcopy[0] is not self.av[0]
-        assert avcopy is not self.av
-        avcopy[5] = {}
-        assert avcopy != self.av
-
-        avcopy[0]["ht"] = 4
-        assert avcopy[0] != self.av[0]
-        self.av[0]["ht"] = 4
-        assert avcopy[0] == self.av[0]
-        del self.av[0]["ht"]
-
-        assert not hasattr(self.av, "__setitem__")
-
-    def test_items(self):
-        assert sorted(self.av.items()) == sorted(self.d.items())
-
-    def test_str(self):
-        out = str(self.d)
-        assert str(self.av) == out
-
-    def test_repr(self):
-        out = "AtlasView(" + str(self.d) + ")"
-        assert repr(self.av) == out
-
-
-class TestAdjacencyView:
-    # node->nbr->data
-    def setup_method(self):
-        dd = {"color": "blue", "weight": 1.2}
-        self.nd = {0: dd, 1: {}, 2: {"color": 1}}
-        self.adj = {3: self.nd, 0: {3: dd}, 1: {}, 2: {3: {"color": 1}}}
-        self.adjview = nx.classes.coreviews.AdjacencyView(self.adj)
-
-    def test_pickle(self):
-        view = self.adjview
-        pview = pickle.loads(pickle.dumps(view, -1))
-        assert view == pview
-        assert view.__slots__ == pview.__slots__
-
-    def test_len(self):
-        assert len(self.adjview) == len(self.adj)
-
-    def test_iter(self):
-        assert list(self.adjview) == list(self.adj)
-
-    def test_getitem(self):
-        assert self.adjview[1] is not self.adj[1]
-        assert self.adjview[3][0] is self.adjview[0][3]
-        assert self.adjview[2][3]["color"] == 1
-        pytest.raises(KeyError, self.adjview.__getitem__, 4)
-
-    def test_copy(self):
-        avcopy = self.adjview.copy()
-        assert avcopy[0] == self.adjview[0]
-        assert avcopy[0] is not self.adjview[0]
-
-        avcopy[2][3]["ht"] = 4
-        assert avcopy[2] != self.adjview[2]
-        self.adjview[2][3]["ht"] = 4
-        assert avcopy[2] == self.adjview[2]
-        del self.adjview[2][3]["ht"]
-
-        assert not hasattr(self.adjview, "__setitem__")
-
-    def test_items(self):
-        view_items = sorted((n, dict(d)) for n, d in self.adjview.items())
-        assert view_items == sorted(self.adj.items())
-
-    def test_str(self):
-        out = str(dict(self.adj))
-        assert str(self.adjview) == out
-
-    def test_repr(self):
-        out = self.adjview.__class__.__name__ + "(" + str(self.adj) + ")"
-        assert repr(self.adjview) == out
-
-
-class TestMultiAdjacencyView(TestAdjacencyView):
-    # node->nbr->key->data
-    def setup_method(self):
-        dd = {"color": "blue", "weight": 1.2}
-        self.kd = {0: dd, 1: {}, 2: {"color": 1}}
-        self.nd = {3: self.kd, 0: {3: dd}, 1: {0: {}}, 2: {3: {"color": 1}}}
-        self.adj = {3: self.nd, 0: {3: {3: dd}}, 1: {}, 2: {3: {8: {}}}}
-        self.adjview = nx.classes.coreviews.MultiAdjacencyView(self.adj)
-
-    def test_getitem(self):
-        assert self.adjview[1] is not self.adj[1]
-        assert self.adjview[3][0][3] is self.adjview[0][3][3]
-        assert self.adjview[3][2][3]["color"] == 1
-        pytest.raises(KeyError, self.adjview.__getitem__, 4)
-
-    def test_copy(self):
-        avcopy = self.adjview.copy()
-        assert avcopy[0] == self.adjview[0]
-        assert avcopy[0] is not self.adjview[0]
-
-        avcopy[2][3][8]["ht"] = 4
-        assert avcopy[2] != self.adjview[2]
-        self.adjview[2][3][8]["ht"] = 4
-        assert avcopy[2] == self.adjview[2]
-        del self.adjview[2][3][8]["ht"]
-
-        assert not hasattr(self.adjview, "__setitem__")
-
-
-class TestUnionAtlas:
-    # node->data
-    def setup_method(self):
-        self.s = {0: {"color": "blue", "weight": 1.2}, 1: {}, 2: {"color": 1}}
-        self.p = {3: {"color": "blue", "weight": 1.2}, 4: {}, 2: {"watch": 2}}
-        self.av = nx.classes.coreviews.UnionAtlas(self.s, self.p)
-
-    def test_pickle(self):
-        view = self.av
-        pview = pickle.loads(pickle.dumps(view, -1))
-        assert view == pview
-        assert view.__slots__ == pview.__slots__
-
-    def test_len(self):
-        assert len(self.av) == len(self.s.keys() | self.p.keys()) == 5
-
-    def test_iter(self):
-        assert set(self.av) == set(self.s) | set(self.p)
-
-    def test_getitem(self):
-        assert self.av[0] is self.s[0]
-        assert self.av[4] is self.p[4]
-        assert self.av[2]["color"] == 1
-        pytest.raises(KeyError, self.av[2].__getitem__, "watch")
-        pytest.raises(KeyError, self.av.__getitem__, 8)
-
-    def test_copy(self):
-        avcopy = self.av.copy()
-        assert avcopy[0] == self.av[0]
-        assert avcopy[0] is not self.av[0]
-        assert avcopy is not self.av
-        avcopy[5] = {}
-        assert avcopy != self.av
-
-        avcopy[0]["ht"] = 4
-        assert avcopy[0] != self.av[0]
-        self.av[0]["ht"] = 4
-        assert avcopy[0] == self.av[0]
-        del self.av[0]["ht"]
-
-        assert not hasattr(self.av, "__setitem__")
-
-    def test_items(self):
-        expected = dict(self.p.items())
-        expected.update(self.s)
-        assert sorted(self.av.items()) == sorted(expected.items())
-
-    def test_str(self):
-        out = str(dict(self.av))
-        assert str(self.av) == out
-
-    def test_repr(self):
-        out = f"{self.av.__class__.__name__}({self.s}, {self.p})"
-        assert repr(self.av) == out
-
-
-class TestUnionAdjacency:
-    # node->nbr->data
-    def setup_method(self):
-        dd = {"color": "blue", "weight": 1.2}
-        self.nd = {0: dd, 1: {}, 2: {"color": 1}}
-        self.s = {3: self.nd, 0: {}, 1: {}, 2: {3: {"color": 1}}}
-        self.p = {3: {}, 0: {3: dd}, 1: {0: {}}, 2: {1: {"color": 1}}}
-        self.adjview = nx.classes.coreviews.UnionAdjacency(self.s, self.p)
-
-    def test_pickle(self):
-        view = self.adjview
-        pview = pickle.loads(pickle.dumps(view, -1))
-        assert view == pview
-        assert view.__slots__ == pview.__slots__
-
-    def test_len(self):
-        assert len(self.adjview) == len(self.s)
-
-    def test_iter(self):
-        assert sorted(self.adjview) == sorted(self.s)
-
-    def test_getitem(self):
-        assert self.adjview[1] is not self.s[1]
-        assert self.adjview[3][0] is self.adjview[0][3]
-        assert self.adjview[2][3]["color"] == 1
-        pytest.raises(KeyError, self.adjview.__getitem__, 4)
-
-    def test_copy(self):
-        avcopy = self.adjview.copy()
-        assert avcopy[0] == self.adjview[0]
-        assert avcopy[0] is not self.adjview[0]
-
-        avcopy[2][3]["ht"] = 4
-        assert avcopy[2] != self.adjview[2]
-        self.adjview[2][3]["ht"] = 4
-        assert avcopy[2] == self.adjview[2]
-        del self.adjview[2][3]["ht"]
-
-        assert not hasattr(self.adjview, "__setitem__")
-
-    def test_str(self):
-        out = str(dict(self.adjview))
-        assert str(self.adjview) == out
-
-    def test_repr(self):
-        clsname = self.adjview.__class__.__name__
-        out = f"{clsname}({self.s}, {self.p})"
-        assert repr(self.adjview) == out
-
-
-class TestUnionMultiInner(TestUnionAdjacency):
-    # nbr->key->data
-    def setup_method(self):
-        dd = {"color": "blue", "weight": 1.2}
-        self.kd = {7: {}, "ekey": {}, 9: {"color": 1}}
-        self.s = {3: self.kd, 0: {7: dd}, 1: {}, 2: {"key": {"color": 1}}}
-        self.p = {3: {}, 0: {3: dd}, 1: {}, 2: {1: {"span": 2}}}
-        self.adjview = nx.classes.coreviews.UnionMultiInner(self.s, self.p)
-
-    def test_len(self):
-        assert len(self.adjview) == len(self.s.keys() | self.p.keys()) == 4
-
-    def test_getitem(self):
-        assert self.adjview[1] is not self.s[1]
-        assert self.adjview[0][7] is self.adjview[0][3]
-        assert self.adjview[2]["key"]["color"] == 1
-        assert self.adjview[2][1]["span"] == 2
-        pytest.raises(KeyError, self.adjview.__getitem__, 4)
-        pytest.raises(KeyError, self.adjview[1].__getitem__, "key")
-
-    def test_copy(self):
-        avcopy = self.adjview.copy()
-        assert avcopy[0] == self.adjview[0]
-        assert avcopy[0] is not self.adjview[0]
-
-        avcopy[2][1]["width"] = 8
-        assert avcopy[2] != self.adjview[2]
-        self.adjview[2][1]["width"] = 8
-        assert avcopy[2] == self.adjview[2]
-        del self.adjview[2][1]["width"]
-
-        assert not hasattr(self.adjview, "__setitem__")
-        assert hasattr(avcopy, "__setitem__")
-
-
-class TestUnionMultiAdjacency(TestUnionAdjacency):
-    # node->nbr->key->data
-    def setup_method(self):
-        dd = {"color": "blue", "weight": 1.2}
-        self.kd = {7: {}, 8: {}, 9: {"color": 1}}
-        self.nd = {3: self.kd, 0: {9: dd}, 1: {8: {}}, 2: {9: {"color": 1}}}
-        self.s = {3: self.nd, 0: {3: {7: dd}}, 1: {}, 2: {3: {8: {}}}}
-        self.p = {3: {}, 0: {3: {9: dd}}, 1: {}, 2: {1: {8: {}}}}
-        self.adjview = nx.classes.coreviews.UnionMultiAdjacency(self.s, self.p)
-
-    def test_getitem(self):
-        assert self.adjview[1] is not self.s[1]
-        assert self.adjview[3][0][9] is self.adjview[0][3][9]
-        assert self.adjview[3][2][9]["color"] == 1
-        pytest.raises(KeyError, self.adjview.__getitem__, 4)
-
-    def test_copy(self):
-        avcopy = self.adjview.copy()
-        assert avcopy[0] == self.adjview[0]
-        assert avcopy[0] is not self.adjview[0]
-
-        avcopy[2][3][8]["ht"] = 4
-        assert avcopy[2] != self.adjview[2]
-        self.adjview[2][3][8]["ht"] = 4
-        assert avcopy[2] == self.adjview[2]
-        del self.adjview[2][3][8]["ht"]
-
-        assert not hasattr(self.adjview, "__setitem__")
-        assert hasattr(avcopy, "__setitem__")
-
-
-class TestFilteredGraphs:
-    def setup_method(self):
-        self.Graphs = [nx.Graph, nx.DiGraph, nx.MultiGraph, nx.MultiDiGraph]
-
-    def test_hide_show_nodes(self):
-        SubGraph = nx.subgraph_view
-        for Graph in self.Graphs:
-            G = nx.path_graph(4, Graph)
-            SG = G.subgraph([2, 3])
-            RG = SubGraph(G, filter_node=nx.filters.hide_nodes([0, 1]))
-            assert SG.nodes == RG.nodes
-            assert SG.edges == RG.edges
-            SGC = SG.copy()
-            RGC = RG.copy()
-            assert SGC.nodes == RGC.nodes
-            assert SGC.edges == RGC.edges
-
-    def test_str_repr(self):
-        SubGraph = nx.subgraph_view
-        for Graph in self.Graphs:
-            G = nx.path_graph(4, Graph)
-            SG = G.subgraph([2, 3])
-            RG = SubGraph(G, filter_node=nx.filters.hide_nodes([0, 1]))
-            str(SG.adj)
-            str(RG.adj)
-            repr(SG.adj)
-            repr(RG.adj)
-            str(SG.adj[2])
-            str(RG.adj[2])
-            repr(SG.adj[2])
-            repr(RG.adj[2])
-
-    def test_copy(self):
-        SubGraph = nx.subgraph_view
-        for Graph in self.Graphs:
-            G = nx.path_graph(4, Graph)
-            SG = G.subgraph([2, 3])
-            RG = SubGraph(G, filter_node=nx.filters.hide_nodes([0, 1]))
-            RsG = SubGraph(G, filter_node=nx.filters.show_nodes([2, 3]))
-            assert G.adj.copy() == G.adj
-            assert G.adj[2].copy() == G.adj[2]
-            assert SG.adj.copy() == SG.adj
-            assert SG.adj[2].copy() == SG.adj[2]
-            assert RG.adj.copy() == RG.adj
-            assert RG.adj[2].copy() == RG.adj[2]
-            assert RsG.adj.copy() == RsG.adj
-            assert RsG.adj[2].copy() == RsG.adj[2]

package/runtime/python/okstra_vendor/networkx/classes/tests/test_digraph.py

@@ -1,331 +0,0 @@
-import pytest
-
-import networkx as nx
-from networkx.utils import nodes_equal
-
-from .test_graph import BaseAttrGraphTester, BaseGraphTester
-from .test_graph import TestEdgeSubgraph as _TestGraphEdgeSubgraph
-from .test_graph import TestGraph as _TestGraph
-
-
-class BaseDiGraphTester(BaseGraphTester):
-    def test_has_successor(self):
-        G = self.K3
-        assert G.has_successor(0, 1)
-        assert not G.has_successor(0, -1)
-
-    def test_successors(self):
-        G = self.K3
-        assert sorted(G.successors(0)) == [1, 2]
-        with pytest.raises(nx.NetworkXError):
-            G.successors(-1)
-
-    def test_has_predecessor(self):
-        G = self.K3
-        assert G.has_predecessor(0, 1)
-        assert not G.has_predecessor(0, -1)
-
-    def test_predecessors(self):
-        G = self.K3
-        assert sorted(G.predecessors(0)) == [1, 2]
-        with pytest.raises(nx.NetworkXError):
-            G.predecessors(-1)
-
-    def test_edges(self):
-        G = self.K3
-        assert sorted(G.edges()) == [(0, 1), (0, 2), (1, 0), (1, 2), (2, 0), (2, 1)]
-        assert sorted(G.edges(0)) == [(0, 1), (0, 2)]
-        assert sorted(G.edges([0, 1])) == [(0, 1), (0, 2), (1, 0), (1, 2)]
-        with pytest.raises(nx.NetworkXError):
-            G.edges(-1)
-
-    def test_out_edges(self):
-        G = self.K3
-        assert sorted(G.out_edges()) == [(0, 1), (0, 2), (1, 0), (1, 2), (2, 0), (2, 1)]
-        assert sorted(G.out_edges(0)) == [(0, 1), (0, 2)]
-        with pytest.raises(nx.NetworkXError):
-            G.out_edges(-1)
-
-    def test_out_edges_dir(self):
-        G = self.P3
-        assert sorted(G.out_edges()) == [(0, 1), (1, 2)]
-        assert sorted(G.out_edges(0)) == [(0, 1)]
-        assert sorted(G.out_edges(2)) == []
-
-    def test_out_edges_data(self):
-        G = nx.DiGraph([(0, 1, {"data": 0}), (1, 0, {})])
-        assert sorted(G.out_edges(data=True)) == [(0, 1, {"data": 0}), (1, 0, {})]
-        assert sorted(G.out_edges(0, data=True)) == [(0, 1, {"data": 0})]
-        assert sorted(G.out_edges(data="data")) == [(0, 1, 0), (1, 0, None)]
-        assert sorted(G.out_edges(0, data="data")) == [(0, 1, 0)]
-
-    def test_in_edges_dir(self):
-        G = self.P3
-        assert sorted(G.in_edges()) == [(0, 1), (1, 2)]
-        assert sorted(G.in_edges(0)) == []
-        assert sorted(G.in_edges(2)) == [(1, 2)]
-
-    def test_in_edges_data(self):
-        G = nx.DiGraph([(0, 1, {"data": 0}), (1, 0, {})])
-        assert sorted(G.in_edges(data=True)) == [(0, 1, {"data": 0}), (1, 0, {})]
-        assert sorted(G.in_edges(1, data=True)) == [(0, 1, {"data": 0})]
-        assert sorted(G.in_edges(data="data")) == [(0, 1, 0), (1, 0, None)]
-        assert sorted(G.in_edges(1, data="data")) == [(0, 1, 0)]
-
-    def test_degree(self):
-        G = self.K3
-        assert sorted(G.degree()) == [(0, 4), (1, 4), (2, 4)]
-        assert dict(G.degree()) == {0: 4, 1: 4, 2: 4}
-        assert G.degree(0) == 4
-        assert list(G.degree(iter([0]))) == [(0, 4)]  # run through iterator
-
-    def test_in_degree(self):
-        G = self.K3
-        assert sorted(G.in_degree()) == [(0, 2), (1, 2), (2, 2)]
-        assert dict(G.in_degree()) == {0: 2, 1: 2, 2: 2}
-        assert G.in_degree(0) == 2
-        assert list(G.in_degree(iter([0]))) == [(0, 2)]  # run through iterator
-
-    def test_out_degree(self):
-        G = self.K3
-        assert sorted(G.out_degree()) == [(0, 2), (1, 2), (2, 2)]
-        assert dict(G.out_degree()) == {0: 2, 1: 2, 2: 2}
-        assert G.out_degree(0) == 2
-        assert list(G.out_degree(iter([0]))) == [(0, 2)]
-
-    def test_size(self):
-        G = self.K3
-        assert G.size() == 6
-        assert G.number_of_edges() == 6
-
-    def test_to_undirected_reciprocal(self):
-        G = self.Graph()
-        G.add_edge(1, 2)
-        assert G.to_undirected().has_edge(1, 2)
-        assert not G.to_undirected(reciprocal=True).has_edge(1, 2)
-        G.add_edge(2, 1)
-        assert G.to_undirected(reciprocal=True).has_edge(1, 2)
-
-    def test_reverse_copy(self):
-        G = nx.DiGraph([(0, 1), (1, 2)])
-        R = G.reverse()
-        assert sorted(R.edges()) == [(1, 0), (2, 1)]
-        R.remove_edge(1, 0)
-        assert sorted(R.edges()) == [(2, 1)]
-        assert sorted(G.edges()) == [(0, 1), (1, 2)]
-
-    def test_reverse_nocopy(self):
-        G = nx.DiGraph([(0, 1), (1, 2)])
-        R = G.reverse(copy=False)
-        assert sorted(R.edges()) == [(1, 0), (2, 1)]
-        with pytest.raises(nx.NetworkXError):
-            R.remove_edge(1, 0)
-
-    def test_reverse_hashable(self):
-        class Foo:
-            pass
-
-        x = Foo()
-        y = Foo()
-        G = nx.DiGraph()
-        G.add_edge(x, y)
-        assert nodes_equal(G.nodes(), G.reverse().nodes())
-        assert [(y, x)] == list(G.reverse().edges())
-
-    def test_di_cache_reset(self):
-        G = self.K3.copy()
-        old_succ = G.succ
-        assert id(G.succ) == id(old_succ)
-        old_adj = G.adj
-        assert id(G.adj) == id(old_adj)
-
-        G._succ = {}
-        assert id(G.succ) != id(old_succ)
-        assert id(G.adj) != id(old_adj)
-
-        old_pred = G.pred
-        assert id(G.pred) == id(old_pred)
-        G._pred = {}
-        assert id(G.pred) != id(old_pred)
-
-    def test_di_attributes_cached(self):
-        G = self.K3.copy()
-        assert id(G.in_edges) == id(G.in_edges)
-        assert id(G.out_edges) == id(G.out_edges)
-        assert id(G.in_degree) == id(G.in_degree)
-        assert id(G.out_degree) == id(G.out_degree)
-        assert id(G.succ) == id(G.succ)
-        assert id(G.pred) == id(G.pred)
-
-
-class BaseAttrDiGraphTester(BaseDiGraphTester, BaseAttrGraphTester):
-    def test_edges_data(self):
-        G = self.K3
-        all_edges = [
-            (0, 1, {}),
-            (0, 2, {}),
-            (1, 0, {}),
-            (1, 2, {}),
-            (2, 0, {}),
-            (2, 1, {}),
-        ]
-        assert sorted(G.edges(data=True)) == all_edges
-        assert sorted(G.edges(0, data=True)) == all_edges[:2]
-        assert sorted(G.edges([0, 1], data=True)) == all_edges[:4]
-        with pytest.raises(nx.NetworkXError):
-            G.edges(-1, True)
-
-    def test_in_degree_weighted(self):
-        G = self.K3.copy()
-        G.add_edge(0, 1, weight=0.3, other=1.2)
-        assert sorted(G.in_degree(weight="weight")) == [(0, 2), (1, 1.3), (2, 2)]
-        assert dict(G.in_degree(weight="weight")) == {0: 2, 1: 1.3, 2: 2}
-        assert G.in_degree(1, weight="weight") == 1.3
-        assert sorted(G.in_degree(weight="other")) == [(0, 2), (1, 2.2), (2, 2)]
-        assert dict(G.in_degree(weight="other")) == {0: 2, 1: 2.2, 2: 2}
-        assert G.in_degree(1, weight="other") == 2.2
-        assert list(G.in_degree(iter([1]), weight="other")) == [(1, 2.2)]
-
-    def test_out_degree_weighted(self):
-        G = self.K3.copy()
-        G.add_edge(0, 1, weight=0.3, other=1.2)
-        assert sorted(G.out_degree(weight="weight")) == [(0, 1.3), (1, 2), (2, 2)]
-        assert dict(G.out_degree(weight="weight")) == {0: 1.3, 1: 2, 2: 2}
-        assert G.out_degree(0, weight="weight") == 1.3
-        assert sorted(G.out_degree(weight="other")) == [(0, 2.2), (1, 2), (2, 2)]
-        assert dict(G.out_degree(weight="other")) == {0: 2.2, 1: 2, 2: 2}
-        assert G.out_degree(0, weight="other") == 2.2
-        assert list(G.out_degree(iter([0]), weight="other")) == [(0, 2.2)]
-
-
-class TestDiGraph(BaseAttrDiGraphTester, _TestGraph):
-    """Tests specific to dict-of-dict-of-dict digraph data structure"""
-
-    def setup_method(self):
-        self.Graph = nx.DiGraph
-        # build dict-of-dict-of-dict K3
-        ed1, ed2, ed3, ed4, ed5, ed6 = ({}, {}, {}, {}, {}, {})
-        self.k3adj = {0: {1: ed1, 2: ed2}, 1: {0: ed3, 2: ed4}, 2: {0: ed5, 1: ed6}}
-        self.k3edges = [(0, 1), (0, 2), (1, 2)]
-        self.k3nodes = [0, 1, 2]
-        self.K3 = self.Graph()
-        self.K3._succ = self.k3adj  # K3._adj is synced with K3._succ
-        self.K3._pred = {0: {1: ed3, 2: ed5}, 1: {0: ed1, 2: ed6}, 2: {0: ed2, 1: ed4}}
-        self.K3._node = {}
-        self.K3._node[0] = {}
-        self.K3._node[1] = {}
-        self.K3._node[2] = {}
-
-        ed1, ed2 = ({}, {})
-        self.P3 = self.Graph()
-        self.P3._succ = {0: {1: ed1}, 1: {2: ed2}, 2: {}}
-        self.P3._pred = {0: {}, 1: {0: ed1}, 2: {1: ed2}}
-        # P3._adj is synced with P3._succ
-        self.P3._node = {}
-        self.P3._node[0] = {}
-        self.P3._node[1] = {}
-        self.P3._node[2] = {}
-
-    def test_data_input(self):
-        G = self.Graph({1: [2], 2: [1]}, name="test")
-        assert G.name == "test"
-        assert sorted(G.adj.items()) == [(1, {2: {}}), (2, {1: {}})]
-        assert sorted(G.succ.items()) == [(1, {2: {}}), (2, {1: {}})]
-        assert sorted(G.pred.items()) == [(1, {2: {}}), (2, {1: {}})]
-
-    def test_add_edge(self):
-        G = self.Graph()
-        G.add_edge(0, 1)
-        assert G.adj == {0: {1: {}}, 1: {}}
-        assert G.succ == {0: {1: {}}, 1: {}}
-        assert G.pred == {0: {}, 1: {0: {}}}
-        G = self.Graph()
-        G.add_edge(*(0, 1))
-        assert G.adj == {0: {1: {}}, 1: {}}
-        assert G.succ == {0: {1: {}}, 1: {}}
-        assert G.pred == {0: {}, 1: {0: {}}}
-        with pytest.raises(ValueError, match="None cannot be a node"):
-            G.add_edge(None, 3)
-
-    def test_add_edges_from(self):
-        G = self.Graph()
-        G.add_edges_from([(0, 1), (0, 2, {"data": 3})], data=2)
-        assert G.adj == {0: {1: {"data": 2}, 2: {"data": 3}}, 1: {}, 2: {}}
-        assert G.succ == {0: {1: {"data": 2}, 2: {"data": 3}}, 1: {}, 2: {}}
-        assert G.pred == {0: {}, 1: {0: {"data": 2}}, 2: {0: {"data": 3}}}
-
-        with pytest.raises(nx.NetworkXError):
-            G.add_edges_from([(0,)])  # too few in tuple
-        with pytest.raises(nx.NetworkXError):
-            G.add_edges_from([(0, 1, 2, 3)])  # too many in tuple
-        with pytest.raises(TypeError):
-            G.add_edges_from([0])  # not a tuple
-        with pytest.raises(ValueError, match="None cannot be a node"):
-            G.add_edges_from([(None, 3), (3, 2)])
-
-    def test_remove_edge(self):
-        G = self.K3.copy()
-        G.remove_edge(0, 1)
-        assert G.succ == {0: {2: {}}, 1: {0: {}, 2: {}}, 2: {0: {}, 1: {}}}
-        assert G.pred == {0: {1: {}, 2: {}}, 1: {2: {}}, 2: {0: {}, 1: {}}}
-        with pytest.raises(nx.NetworkXError):
-            G.remove_edge(-1, 0)
-
-    def test_remove_edges_from(self):
-        G = self.K3.copy()
-        G.remove_edges_from([(0, 1)])
-        assert G.succ == {0: {2: {}}, 1: {0: {}, 2: {}}, 2: {0: {}, 1: {}}}
-        assert G.pred == {0: {1: {}, 2: {}}, 1: {2: {}}, 2: {0: {}, 1: {}}}
-        G.remove_edges_from([(0, 0)])  # silent fail
-
-    def test_clear(self):
-        G = self.K3
-        G.graph["name"] = "K3"
-        G.clear()
-        assert list(G.nodes) == []
-        assert G.succ == {}
-        assert G.pred == {}
-        assert G.graph == {}
-
-    def test_clear_edges(self):
-        G = self.K3
-        G.graph["name"] = "K3"
-        nodes = list(G.nodes)
-        G.clear_edges()
-        assert list(G.nodes) == nodes
-        expected = {0: {}, 1: {}, 2: {}}
-        assert G.succ == expected
-        assert G.pred == expected
-        assert list(G.edges) == []
-        assert G.graph["name"] == "K3"
-
-
-class TestEdgeSubgraph(_TestGraphEdgeSubgraph):
-    """Unit tests for the :meth:`DiGraph.edge_subgraph` method."""
-
-    def setup_method(self):
-        # Create a doubly-linked path graph on five nodes.
-        G = nx.DiGraph(nx.path_graph(5))
-        # Add some node, edge, and graph attributes.
-        for i in range(5):
-            G.nodes[i]["name"] = f"node{i}"
-        G.edges[0, 1]["name"] = "edge01"
-        G.edges[3, 4]["name"] = "edge34"
-        G.graph["name"] = "graph"
-        # Get the subgraph induced by the first and last edges.
-        self.G = G
-        self.H = G.edge_subgraph([(0, 1), (3, 4)])
-
-    def test_pred_succ(self):
-        """Test that nodes are added to predecessors and successors.
-
-        For more information, see GitHub issue #2370.
-
-        """
-        G = nx.DiGraph()
-        G.add_edge(0, 1)
-        H = G.edge_subgraph([(0, 1)])
-        assert list(H.predecessors(0)) == []
-        assert list(H.successors(0)) == [1]
-        assert list(H.predecessors(1)) == [0]
-        assert list(H.successors(1)) == []