okstra 0.114.0 → 0.115.0

package/runtime/python/okstra_vendor/networkx/algorithms/isomorphism/tests/test_ismags.py

@@ -1,719 +0,0 @@
-"""
-Tests for ISMAGS isomorphism algorithm.
-"""
-
-import random
-
-import pytest
-
-import networkx as nx
-from networkx.algorithms import isomorphism as iso
-
-graph_classes = [nx.Graph, nx.DiGraph, nx.MultiGraph, nx.MultiDiGraph]
-
-
-def _matches_to_sets(matches):
-    """
-    Helper function to facilitate comparing collections of dictionaries in
-    which order does not matter.
-    """
-    return {frozenset(m.items()) for m in matches}
-
-
-graph_examples = [
-    # node_data, edge_data, [id used in name for the test]
-    pytest.param([0, 1, 2, 3], [(0, 0)], id="isolated-nodes-and-selfloops"),
-    pytest.param([], nx.star_graph(3).edges, id="3-star"),
-    pytest.param(
-        # 6-cycle with 2-paths stuck onto nodes 0, 2, 4 (stretched symmetry)
-        [],
-        [
-            (0, 1),
-            (1, 2),
-            (2, 3),
-            (3, 4),
-            (4, 5),
-            (5, 0),
-            (0, 6),
-            (6, 7),
-            (2, 8),
-            (8, 9),
-            (4, 10),
-            (10, 11),
-        ],
-        id="sun:6-cycle-with-2-path-rays",
-    ),
-    # 0-1-2-3-5
-    #  /     \
-    # 4       6
-    pytest.param([], [(0, 1), (1, 2), (1, 4), (2, 3), (3, 5), (3, 6)], id="tree"),
-    pytest.param([], nx.petersen_graph().edges, id="petersen_graph"),
-    # Example Fig 3 from Houbraken, et al (ISMAGS paper)
-    pytest.param(
-        [], nx.cycle_graph([1, 2, 4, 3]).edges, id="houbraken-ismags-paper-fig3"
-    ),
-    pytest.param(
-        # path with node labels
-        [
-            (0, {"name": "a"}),
-            (1, {"name": "a"}),
-            (2, {"name": "b"}),
-            (3, {"name": "b"}),
-            (4, {"name": "a"}),
-            (5, {"name": "a"}),
-        ],
-        [(0, 1), (1, 2), (2, 3), (3, 4), (4, 5)],
-        id="path-with-node-labels",
-    ),
-    pytest.param(
-        # 5 - 4 \     / 12 - 13
-        #        0 - 3
-        # 9 - 8 /     \ 16 - 17
-        # Assume 0 and 3 are coupled and no longer equivalent.
-        # Coupling node 4 to 8 means that 5 and 9
-        # are no longer equivalent, pushing them in their own partitions.
-        # So, [{5}, {9}] is no longer considered equivalent to {13, 17}.
-        # Minimal example with this trait. Adding all permutations of
-        # same-size parts at each step finds the symmetry.
-        [],
-        [
-            (0, 3),
-            (3, 0),  # added to provide symmetry for DiGraphs
-            (0, 4),
-            (4, 5),
-            (0, 8),
-            (8, 9),
-            (3, 12),
-            (12, 13),
-            (3, 16),
-            (16, 17),
-        ],
-        id="gh8055-tricky-case",
-    ),
-    pytest.param(
-        [], nx.path_graph([1, 2, 3, "a", "b", "c"]).edges, id="unsortable-nodes"
-    ),
-    # Example from Katebi, 2012, Fig 1-3.
-    # Node order specified to (almost) match their DFS order
-    pytest.param(
-        [3, 5, 6, 4, 2, 1, 0],
-        set(nx.cycle_graph(4).edges) | set(nx.cycle_graph(range(4, 7)).edges),
-        id="katebi-paper-fig2",
-    ),
-    pytest.param(
-        [], [(0, 1), (1, 2), (2, 3), (3, 6), (2, 4), (4, 5)], id="len-2-rays-tri-star"
-    ),
-    # Example of refining permutations with two different length parts at the same time.
-    # Underlying shape is a 4-cycle and 2-path. Multiedges make all nodes degree-3
-    # Full simple graph is then obtained by extending each edge as a path thru 1 node.
-    #                   0
-    # Underlying      // \     4       When 0->0 coupling occurs,
-    # MultiGraph     1    3    \\\     refining {1, 2, 3, 4, 5}
-    #                 \  //      5     refined parts [{1}, {3}, {2, 4, 5}]
-    #                   2              with different parts having different lengths.
-    #               0
-    #              /|\         4
-    #             6 7 8       /|\
-    # Full:       |/  |      / | \
-    #             1   3     12 13 14
-    #             |  / \     \ | /
-    #             9 10 11     \|/
-    #              \ | /       5
-    #                2
-    # Nodes 0-5 are the degree-3 nodes.
-    # Nodes 6-14 are degree 2 nodes on paths between the degree-3 nodes.
-    pytest.param(
-        [],
-        [
-            (0, 6),
-            (0, 7),
-            (0, 8),
-            (1, 6),
-            (1, 7),
-            (1, 9),
-            (2, 9),
-            (2, 10),
-            (2, 11),
-            (3, 8),
-            (3, 10),
-            (3, 11),
-            (4, 12),
-            (4, 13),
-            (4, 14),
-            (5, 12),
-            (5, 13),
-            (5, 14),
-        ],
-        id="refining-parts-finds-different-lengths",
-    ),
-    # Underlying structure from previous example
-    pytest.param(
-        [],
-        [(0, 1), (0, 1), (1, 2), (2, 3), (2, 3), (3, 0), (4, 5), (4, 5), (4, 5)],
-        id="basic-structure-for-refining-parts-test",
-    ),
-]
-
-
-@pytest.mark.parametrize("graph_constructor", graph_classes)
-class TestSelfIsomorphism:
-    @pytest.mark.parametrize(["node_data", "edge_data"], graph_examples)
-    def test_self_isomorphism(self, graph_constructor, node_data, edge_data):
-        """
-        For some small, symmetric graphs, make sure that 1) they are isomorphic
-        to themselves, and 2) that only the identity mapping is found.
-        """
-        graph = graph_constructor()
-        graph.add_nodes_from(node_data)
-        graph.add_edges_from(edge_data)
-
-        ismags = iso.ISMAGS(
-            graph, graph, node_match=iso.categorical_node_match("name", None)
-        )
-        assert ismags.is_isomorphic()
-        assert ismags.is_isomorphic(symmetry=True)
-        assert ismags.subgraph_is_isomorphic()
-        ismags_answer = list(ismags.subgraph_isomorphisms_iter(symmetry=True))
-        assert ismags_answer == [{n: n for n in graph.nodes}]
-
-
-class TestSubgraphIsomorphism:
-    def test_isomorphism_4_sun(self):
-        g1 = nx.cycle_graph(4)
-        g2 = nx.cycle_graph(4)
-        g2.add_edges_from(list(zip(g2, range(4, 8))))
-        ismags = iso.ISMAGS(g2, g1)
-        assert list(ismags.subgraph_isomorphisms_iter(symmetry=True)) == [
-            {n: n for n in g1.nodes}
-        ]
-        assert sum(1 for _ in ismags.subgraph_isomorphisms_iter(symmetry=False)) == 8
-
-    def test_isomorphism_path_in_tristar(self):
-        g1 = nx.path_graph(3)
-
-        g2 = g1.copy()
-        g2.add_edge(1, 3)
-
-        ismags = iso.ISMAGS(g2, g1)
-        matches = ismags.subgraph_isomorphisms_iter(symmetry=True)
-        expected_symmetric = [
-            {0: 0, 1: 1, 2: 2},
-            {0: 0, 1: 1, 3: 2},
-            {2: 0, 1: 1, 3: 2},
-        ]
-        assert _matches_to_sets(matches) == _matches_to_sets(expected_symmetric)
-
-        matches = ismags.subgraph_isomorphisms_iter(symmetry=False)
-        expected_asymmetric = [
-            {0: 2, 1: 1, 2: 0},
-            {0: 2, 1: 1, 3: 0},
-            {2: 2, 1: 1, 3: 0},
-        ]
-        assert _matches_to_sets(matches) == _matches_to_sets(
-            expected_symmetric + expected_asymmetric
-        )
-
-    def test_labeled_nodes(self):
-        g1 = nx.cycle_graph(3)
-        g1.nodes[1]["attr"] = True
-
-        g2 = g1.copy()
-        g2.add_edge(1, 3)
-        ismags = iso.ISMAGS(g2, g1, node_match=lambda x, y: x == y)
-        matches = ismags.subgraph_isomorphisms_iter(symmetry=True)
-        expected_symmetric = [{0: 0, 1: 1, 2: 2}]
-        assert _matches_to_sets(matches) == _matches_to_sets(expected_symmetric)
-
-        matches = ismags.subgraph_isomorphisms_iter(symmetry=False)
-        expected_asymmetric = [{0: 2, 1: 1, 2: 0}]
-        assert _matches_to_sets(matches) == _matches_to_sets(
-            expected_symmetric + expected_asymmetric
-        )
-
-    def test_labeled_edges(self):
-        g1 = nx.Graph()
-        nx.add_cycle(g1, range(3))
-        g1.edges[1, 2]["attr"] = True
-
-        g2 = g1.copy()
-        g2.add_edge(1, 3)
-        ismags = iso.ISMAGS(g2, g1, edge_match=lambda x, y: x == y)
-        matches = ismags.subgraph_isomorphisms_iter(symmetry=True)
-        expected_symmetric = [{0: 0, 1: 1, 2: 2}]
-        assert _matches_to_sets(matches) == _matches_to_sets(expected_symmetric)
-
-        matches = ismags.subgraph_isomorphisms_iter(symmetry=False)
-        expected_asymmetric = [{1: 2, 0: 0, 2: 1}]
-        assert _matches_to_sets(matches) == _matches_to_sets(
-            expected_symmetric + expected_asymmetric
-        )
-
-    def test_exceptions_for_bad_match_functions(self):
-        def non_transitive_match(attrs1, attrs2):
-            return abs(attrs1["freq"] - attrs2["freq"]) <= 1
-
-        def simple_non_commutative_match(attrs1, attrs2):
-            return attrs1["freq"] == 1 + attrs2["freq"]
-
-        def non_commutative_match(attrs1, attrs2):
-            # red matches red and green
-            # green and blue only match themselves
-            if attrs2["color"] == "red":
-                return attrs2["color"] in {"red", "green"}
-            else:
-                return attrs1["color"] == attrs2["color"]
-
-        G1 = nx.Graph()
-        G1.add_node(0, color="red", freq=0)
-        G1.add_node(1, color="red", freq=1)
-        G1.add_node(2, color="blue", freq=2)
-
-        G2 = nx.Graph()
-        G2.add_node("A", color="red", freq=0)
-        G2.add_node("B", color="green", freq=1)
-        G2.add_node("C", color="blue", freq=2)
-
-        with pytest.raises(nx.NetworkXError, match="\nInvalid partition"):
-            iso.ISMAGS(G1, G2, node_match=non_transitive_match)
-
-        with pytest.raises(nx.NetworkXError, match="\nInvalid partition"):
-            iso.ISMAGS(G1, G2, node_match=simple_non_commutative_match)
-
-        with pytest.raises(nx.NetworkXError, match="\nInvalid partition"):
-            iso.ISMAGS(G1, G2, node_match=non_commutative_match)
-
-
-def test_noncomparable_nodes():
-    node1 = object()
-    node2 = object()
-    node3 = object()
-
-    # Graph
-    G = nx.path_graph([node1, node2, node3])
-    gm = iso.ISMAGS(G, G)
-    assert gm.is_isomorphic()
-    assert gm.subgraph_is_isomorphic()
-
-    # DiGraph
-    G = nx.path_graph([node1, node2, node3], create_using=nx.DiGraph)
-    H = nx.path_graph([node3, node2, node1], create_using=nx.DiGraph)
-    dgm = iso.ISMAGS(G, H)
-    assert dgm.is_isomorphic()
-    assert dgm.is_isomorphic(symmetry=True)
-    assert dgm.subgraph_is_isomorphic()
-
-
-@pytest.mark.parametrize("graph_constructor", graph_classes)
-def test_selfloop(graph_constructor):
-    # Simple test for graphs with selfloops
-    g1 = graph_constructor([(0, 1), (0, 2), (1, 2), (1, 3), (2, 2), (2, 4)])
-    nodes = range(5)
-    rng = random.Random(42)
-
-    for _ in range(3):
-        new_nodes = list(nodes)
-        rng.shuffle(new_nodes)
-        d = dict(zip(nodes, new_nodes))
-        g2 = nx.relabel_nodes(g1, d)
-        assert iso.ISMAGS(g1, g2).is_isomorphic()
-
-
-class TestWikipediaExample:
-    # example in wikipedia is g1a and g2b
-    # 1 have letter nodes, 2 have number nodes
-    # b have some edges reversed vs a (undirected still isomorphic)
-    # reversed edges marked with comment `#`
-    # isomorphism = {'a': 1, 'g': 2, 'b': 3, 'c': 6, 'h': 4, 'i': 5, 'j': 7, 'd': 8}
-
-    # Nodes 'a', 'b', 'c' and 'd' form a column.
-    # Nodes 'g', 'h', 'i' and 'j' form a column.
-    g1a_edges = [
-        ["a", "g"],
-        ["a", "h"],  # edge direction swapped from g1b
-        ["a", "i"],
-        ["b", "g"],  # edge direction swapped from g1b
-        ["b", "h"],
-        ["b", "j"],
-        ["c", "g"],  # edge direction swapped from g1b
-        ["c", "i"],  # edge direction swapped from g1b
-        ["c", "j"],
-        ["d", "h"],  # edge direction swapped from g1b
-        ["d", "i"],
-        ["d", "j"],  # edge direction swapped from g1b
-    ]
-
-    g1b_edges = [
-        ["a", "g"],
-        ["h", "a"],  # edge direction swapped from g1a
-        ["a", "i"],
-        ["g", "b"],  # edge direction swapped from g1a
-        ["b", "h"],
-        ["b", "j"],
-        ["g", "c"],  # edge direction swapped from g1a
-        ["i", "c"],  # edge direction swapped from g1a
-        ["c", "j"],
-        ["h", "d"],  # edge direction swapped from g1a
-        ["d", "i"],
-        ["j", "d"],  # edge direction swapped from g1a
-    ]
-
-    g2b_edges = [
-        [1, 2],
-        [1, 4],  # edge direction swapped from g2a
-        [1, 5],
-        [3, 2],  # edge direction swapped from g2a
-        [3, 4],
-        [3, 7],
-        [6, 2],  # edge direction swapped from g2a
-        [6, 5],  # edge direction swapped from g2a
-        [6, 7],
-        [8, 4],  # edge direction swapped from g2a
-        [8, 5],
-        [8, 7],  # edge direction swapped from g2a
-    ]
-
-    # Nodes 1,2,3,4 form the clockwise corners of a large square.
-    # Nodes 5,6,7,8 form the clockwise corners of a small square
-    g2a_edges = [
-        [1, 2],
-        [4, 1],  # edge direction swapped from g2b
-        [1, 5],
-        [2, 3],  # edge direction swapped from g2b
-        [3, 4],
-        [3, 7],
-        [2, 6],  # edge direction swapped from g2b
-        [5, 6],  # edge direction swapped from g2b
-        [6, 7],
-        [4, 8],  # edge direction swapped from g2b
-        [8, 5],
-        [7, 8],  # edge direction swapped from g2b
-    ]
-
-    @pytest.mark.parametrize("graph_constructor", [nx.Graph, nx.MultiGraph])
-    def test_graph(self, graph_constructor):
-        g1a = graph_constructor(self.g1a_edges)
-        g1b = graph_constructor(self.g1b_edges)
-        g2a = graph_constructor(self.g2a_edges)
-        g2b = graph_constructor(self.g2b_edges)
-        assert iso.ISMAGS(g1a, g1b).is_isomorphic()
-        assert iso.ISMAGS(g1a, g2a).is_isomorphic()
-        assert iso.ISMAGS(g1a, g2b).is_isomorphic()
-
-        assert iso.ISMAGS(g1a, nx.path_graph(range(5))).subgraph_is_isomorphic()
-        assert not iso.ISMAGS(g1a, nx.path_graph(range(6))).subgraph_is_isomorphic()
-
-    @pytest.mark.parametrize("graph_constructor", [nx.DiGraph, nx.MultiDiGraph])
-    def test_digraph(self, graph_constructor):
-        g1a = graph_constructor(self.g1a_edges)
-        g1b = graph_constructor(self.g1b_edges)
-        g2a = graph_constructor(self.g2a_edges)
-        g2b = graph_constructor(self.g2b_edges)
-        assert iso.ISMAGS(g1a, g2b).is_isomorphic()
-        assert iso.ISMAGS(g1b, g2a).is_isomorphic()
-        assert not iso.ISMAGS(g1a, g1b).is_isomorphic()
-        assert not iso.ISMAGS(g2a, g2b).is_isomorphic()
-        assert not iso.ISMAGS(g1a, g2a).is_isomorphic()
-        assert not iso.ISMAGS(g1b, g2b).is_isomorphic()
-
-        P2 = nx.path_graph(range(2), create_using=graph_constructor)
-        assert iso.ISMAGS(g1a, P2).subgraph_is_isomorphic()
-        P3 = nx.path_graph(range(3), create_using=graph_constructor)
-        assert not iso.ISMAGS(g1a, P3).subgraph_is_isomorphic()
-
-
-class TestLargestCommonSubgraph:
-    def test_mcis(self):
-        # Example graphs from DOI: 10.1002/spe.588
-        graph1 = nx.Graph()
-        graph1.add_edges_from([(1, 2), (2, 3), (2, 4), (3, 4), (4, 5)])
-        graph1.nodes[1]["color"] = 0
-
-        graph2 = nx.Graph()
-        graph2.add_edges_from(
-            [(1, 2), (2, 3), (2, 4), (3, 4), (3, 5), (5, 6), (5, 7), (6, 7)]
-        )
-        graph2.nodes[1]["color"] = 1
-        graph2.nodes[6]["color"] = 2
-        graph2.nodes[7]["color"] = 2
-
-        ismags = iso.ISMAGS(
-            graph1, graph2, node_match=iso.categorical_node_match("color", None)
-        )
-        assert list(ismags.subgraph_isomorphisms_iter(symmetry=True)) == []
-        assert list(ismags.subgraph_isomorphisms_iter(symmetry=False)) == []
-        found_mcis = _matches_to_sets(ismags.largest_common_subgraph())
-        expected = _matches_to_sets(
-            [{2: 2, 3: 4, 4: 3, 5: 5}, {2: 4, 3: 2, 4: 3, 5: 5}]
-        )
-        assert expected == found_mcis
-
-        ismags = iso.ISMAGS(
-            graph2, graph1, node_match=iso.categorical_node_match("color", None)
-        )
-        assert list(ismags.subgraph_isomorphisms_iter(symmetry=True)) == []
-        assert list(ismags.subgraph_isomorphisms_iter(symmetry=False)) == []
-        found_mcis = _matches_to_sets(ismags.largest_common_subgraph())
-        # Same answer, but reversed.
-        expected = _matches_to_sets(
-            [{2: 2, 3: 4, 4: 3, 5: 5}, {4: 2, 2: 3, 3: 4, 5: 5}]
-        )
-        assert expected == found_mcis
-
-    def test_symmetry_mcis(self):
-        graph1 = nx.Graph()
-        nx.add_path(graph1, range(4))
-
-        graph2 = nx.Graph()
-        nx.add_path(graph2, range(3))
-        graph2.add_edge(1, 3)
-
-        # Only the symmetry of graph2 is taken into account here.
-        ismags1 = iso.ISMAGS(
-            graph1, graph2, node_match=iso.categorical_node_match("color", None)
-        )
-        assert list(ismags1.subgraph_isomorphisms_iter(symmetry=True)) == []
-        found_mcis = _matches_to_sets(ismags1.largest_common_subgraph())
-        expected = _matches_to_sets([{0: 0, 1: 1, 2: 2}, {1: 0, 3: 2, 2: 1}])
-        assert expected == found_mcis
-
-        # Only the symmetry of graph1 is taken into account here.
-        ismags2 = iso.ISMAGS(
-            graph2, graph1, node_match=iso.categorical_node_match("color", None)
-        )
-        assert list(ismags2.subgraph_isomorphisms_iter(symmetry=True)) == []
-        found_mcis = _matches_to_sets(ismags2.largest_common_subgraph())
-        expected = _matches_to_sets(
-            [
-                {3: 2, 0: 0, 1: 1},
-                {2: 0, 0: 2, 1: 1},
-                {3: 0, 0: 2, 1: 1},
-                {3: 0, 1: 1, 2: 2},
-                {0: 0, 1: 1, 2: 2},
-                {2: 0, 3: 2, 1: 1},
-            ]
-        )
-
-        assert expected == found_mcis
-
-        found_mcis1 = _matches_to_sets(ismags1.largest_common_subgraph(symmetry=False))
-        found_mcis2 = ismags2.largest_common_subgraph(symmetry=False)
-        found_mcis2 = [{v: k for k, v in d.items()} for d in found_mcis2]
-        found_mcis2 = _matches_to_sets(found_mcis2)
-
-        expected = _matches_to_sets(
-            [
-                {3: 2, 1: 3, 2: 1},
-                {2: 0, 0: 2, 1: 1},
-                {1: 2, 3: 3, 2: 1},
-                {3: 0, 1: 3, 2: 1},
-                {0: 2, 2: 3, 1: 1},
-                {3: 0, 1: 2, 2: 1},
-                {2: 0, 0: 3, 1: 1},
-                {0: 0, 2: 3, 1: 1},
-                {1: 0, 3: 3, 2: 1},
-                {1: 0, 3: 2, 2: 1},
-                {0: 3, 1: 1, 2: 2},
-                {0: 0, 1: 1, 2: 2},
-            ]
-        )
-        assert expected == found_mcis1
-        assert expected == found_mcis2
-
-
-def is_isomorphic(G, SG, edge_match=None, node_match=None):
-    return iso.ISMAGS(G, SG, node_match, edge_match).is_isomorphic()
-
-
-class TestDiGraphISO:
-    def test_wikipedia_graph(self):
-        edges1 = [
-            (1, 5),
-            (1, 2),
-            (1, 4),
-            (3, 2),
-            (6, 2),
-            (3, 4),
-            (7, 3),
-            (4, 8),
-            (5, 8),
-            (6, 5),
-            (6, 7),
-            (7, 8),
-        ]
-        mapped = {1: "a", 2: "h", 3: "d", 4: "i", 5: "g", 6: "b", 7: "j", 8: "c"}
-
-        G1 = nx.DiGraph(edges1)
-        G2 = nx.relabel_nodes(G1, mapped)
-
-        result = next(nx.isomorphism.ISMAGS(G1, G2).find_isomorphisms())
-        assert result == mapped
-
-        # Change the direction of an edge
-        G1.remove_edge(1, 5)
-        G1.add_edge(5, 1)
-        result = list(nx.isomorphism.ISMAGS(G1, G2).find_isomorphisms())
-        assert result == []
-
-    def test_non_isomorphic_same_degree_sequence(self):
-        r"""
-                G1                           G2
-        1-------------2              1-------------2
-        | \           |              | \           |
-        |  5-------6  |              |  5-------6  |
-        |  |       |  |              |  |       |  |
-        |  8-------7  |              |  8-------7  |
-        | /           |              |           \ |
-        4-------------3              4-------------3
-        """
-        edges1 = [
-            (1, 5),
-            (1, 2),
-            (4, 1),
-            (3, 2),
-            (3, 4),
-            (5, 8),
-            (6, 5),
-            (6, 7),
-            (7, 8),
-            (4, 8),
-        ]
-        edges2 = [
-            (1, 5),
-            (1, 2),
-            (4, 1),
-            (3, 2),
-            (3, 4),
-            (5, 8),
-            (6, 5),
-            (6, 7),
-            (8, 7),
-            (3, 7),
-        ]
-
-        G1 = nx.DiGraph(edges1)
-        G2 = nx.DiGraph(edges2)
-        assert not is_isomorphic(G1, G2)
-
-    def test_is_isomorphic(self):
-        G1 = nx.Graph([[1, 2], [1, 3], [1, 5], [2, 3]])
-        G2 = nx.Graph([[10, 20], [20, 30], [10, 30], [10, 50]])
-        G4 = nx.Graph([[1, 2], [1, 3], [1, 5], [2, 4]])
-        assert is_isomorphic(G1, G2)
-        assert not is_isomorphic(G1, G4)
-        assert is_isomorphic(G1.to_directed(), G2.to_directed())
-        assert not is_isomorphic(G1.to_directed(), G4.to_directed())
-        with pytest.raises(
-            ValueError, match="Directed and undirected graphs cannot be compared."
-        ):
-            is_isomorphic(G1.to_directed(), G1)
-
-
-@pytest.mark.parametrize("graph_class", graph_classes)
-def test_simple_node_match(graph_class):
-    g1 = graph_class([(0, 0), (0, 1), (1, 0)])
-    g2 = g1.copy()
-    nm = iso.numerical_node_match("size", 1)
-    assert is_isomorphic(g1, g2, node_match=nm)
-
-    g2.nodes[0]["size"] = 3
-    assert not is_isomorphic(g1, g2, node_match=nm)
-
-
-@pytest.mark.parametrize("graph_class", graph_classes)
-def test_simple_node_and_edge_match(graph_class):
-    g1 = graph_class()
-    g1.add_weighted_edges_from([(0, 0, 1.2), (0, 1, 1.4), (1, 0, 1.6)])
-    g2 = g1.copy()
-    nm = iso.numerical_node_match("size", 1)
-    if g1.is_multigraph():
-        em = iso.numerical_multiedge_match("weight", 1)
-    else:
-        em = iso.numerical_edge_match("weight", 1)
-    assert is_isomorphic(g1, g2, node_match=nm, edge_match=em)
-
-    g2.nodes[0]["size"] = 3
-    assert not is_isomorphic(g1, g2, node_match=nm, edge_match=em)
-
-    g2 = g1.copy()
-    if g1.is_multigraph():
-        g2.edges[0, 1, 0]["weight"] = 2.1
-    else:
-        g2.edges[0, 1]["weight"] = 2.1
-    assert not is_isomorphic(g1, g2, node_match=nm, edge_match=em)
-
-    g2 = g1.copy()
-    g2.nodes[0]["size"] = 3
-    if g1.is_multigraph():
-        g2.edges[0, 1, 0]["weight"] = 2.1
-    else:
-        g2.edges[0, 1]["weight"] = 2.1
-    assert not is_isomorphic(g1, g2, node_match=nm, edge_match=em)
-
-
-@pytest.mark.parametrize("graph_class", graph_classes)
-def test_simple_edge_match(graph_class):
-    # 16 simple tests
-    w = "weight"
-    edges = [(0, 0, 1), (0, 0, 1.5), (0, 1, 2), (1, 0, 3)]
-    g1 = graph_class()
-    g1.add_weighted_edges_from(edges)
-    g2 = g1.copy()
-    if g1.is_multigraph():
-        em = iso.numerical_multiedge_match("weight", 1)
-    else:
-        em = iso.numerical_edge_match("weight", 1)
-    assert is_isomorphic(g1, g2, edge_match=em)
-
-    for mod1, mod2 in [(False, True), (True, False), (True, True)]:
-        # mod1 tests a regular edge weight difference
-        # mod2 tests a selfloop weight difference
-        if g1.is_multigraph():
-            if mod1:
-                data1 = {0: {"weight": 10}}
-            if mod2:
-                data2 = {0: {"weight": 1}, 1: {"weight": 2.5}}
-        else:
-            if mod1:
-                data1 = {"weight": 10}
-            if mod2:
-                data2 = {"weight": 2.5}
-
-        g2 = g1.copy()
-        if mod1:
-            if not g1.is_directed():
-                g2._adj[1][0] = data1
-                g2._adj[0][1] = data1
-            else:
-                g2._succ[1][0] = data1
-                g2._pred[0][1] = data1
-        if mod2:
-            if not g1.is_directed():
-                g2._adj[0][0] = data2
-            else:
-                g2._succ[0][0] = data2
-                g2._pred[0][0] = data2
-
-        assert not is_isomorphic(g1, g2, edge_match=em)
-
-
-@pytest.mark.parametrize("graph_class", graph_classes)
-def test_weightkey(graph_class):
-    g1 = graph_class()
-    g2 = graph_class()
-    if g1.is_multigraph():
-        edge_match = iso.numerical_multiedge_match
-    else:
-        edge_match = iso.numerical_edge_match
-
-    g1.add_edge("A", "B", weight=1)
-    g2.add_edge("C", "D", weight=0)
-
-    assert nx.is_isomorphic(g1, g2)
-    em = edge_match("nonexistent attribute", 1)
-    assert nx.is_isomorphic(g1, g2, edge_match=em)
-    em = edge_match("weight", 1)
-    assert not nx.is_isomorphic(g1, g2, edge_match=em)
-
-    g2 = graph_class()
-    g2.add_edge("C", "D")
-    assert nx.is_isomorphic(g1, g2, edge_match=em)