def test_comparisons(): """Tests comparison operations between graphs. """ # __eq__ and equals for directed in [True, False]: for static1 in [True, False]: for static2 in [True, False]: g1 = cg.graph(static=static1, directed=directed, vertices=list(range(3))) g2 = cg.graph(static=static2, directed=directed, vertices=list(range(3))) with pytest.raises(ValueError): g1 == g2 g2 == g1 assert g1.equals(g2) assert g2.equals(g1) g1.add_edge(0, 1) assert not g1.equals(g2) assert not g2.equals(g1) g2.add_edge(0, 1) assert g1.equals(g2) assert g2.equals(g1) g1.set_edge_attribute((0, 1), key="Attribute", val=True) assert not g1.equals(g2, edge_attrs=True) assert not g2.equals(g1, edge_attrs=True) g1.set_vertex_attribute(0, key="Attribute", val=True) assert not g1.equals(g2, vertex_attrs=True) assert not g2.equals(g1, vertex_attrs=True)
def test_get_shortest_path_dijkstra(): """Tests get_shortest_path_dijkstra function. """ for static in [True, False]: undirected_graph = cg.graph(static=static, directed=False, vertices=[ 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 's' ]) undirected_graph_edges = [('s', 'a', 7.0), ('s', 'b', 2.0), ('s', 'c', 3.0), ('a', 'b', 3.0), ('a', 'd', 4.0), ('b', 'h', 4.0), ('b', 'd', 1.0), ('c', 'l', 2.0), ('d', 'f', 5.0), ('l', 'i', 4.0), ('l', 'j', 4.0), ('i', 'k', 4.0), ('i', 'j', 6.0), ('j', 'k', 4.0), ('k', 'e', 5.0), ('f', 'h', 3.0), ('h', 'g', 2.0), ('g', 'e', 2.0)] for edge in undirected_graph_edges: undirected_graph.add_edge(*edge) undirected_path = alg.get_shortest_path_dijkstra( undirected_graph, 's', 'e') assert undirected_path == ['s', 'b', 'h', 'g', 'e'] with pytest.raises(ValueError): alg.get_shortest_path_dijkstra(undirected_graph, 'y', 'z') disconnected_undirected_graph = cg.graph(static=static, directed=False, vertices=['a', 'b']) with pytest.raises(ValueError): alg.get_shortest_path_dijkstra(disconnected_undirected_graph, 'a', 'b') directed_graph = cg.graph( static=static, directed=True, vertices=['s', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h']) directed_graph_edges = [('s', 'a', 2.0), ('a', 'e', 3.0), ('e', 'h', 4.0), ('h', 'g', 1.0), ('h', 'e', 2.0), ('g', 'd', 2.0), ('d', 's', 20.0), ('e', 'b', 1.0), ('e', 'g', 6.0), ('b', 'c', 7.0), ('c', 'f', 5.0), ('f', 'b', 0.0)] for edge in directed_graph_edges: directed_graph.add_edge(*edge) directed_path = alg.get_shortest_path_dijkstra(directed_graph, 's', 'e') assert directed_path == ['s', 'a', 'e'] disconnected_directed_graph = cg.graph(static=static, directed=True, vertices=['a', 'b']) disconnected_directed_graph.add_edge('a', 'b') with pytest.raises(ValueError): alg.get_shortest_path_dijkstra(disconnected_directed_graph, 'b', 'a')
def test_partition_karger(): """ Tests partition_karger function. """ sample_vertices = list(range(1, 6)) sample_edges = list(itertools.combinations(sample_vertices, 2)) sample_graphs = { 'static': { 'undirected': cg.graph(static=True, directed=False, vertices=sample_vertices), 'directed': cg.graph(static=True, directed=True, vertices=sample_vertices) }, 'dynamic': { 'undirected': cg.graph(static=False, directed=False, vertices=sample_vertices), 'directed': cg.graph(static=False, directed=True, vertices=sample_vertices) } } for graph in [g for s in sample_graphs for g in sample_graphs[s].values()]: for edge in sample_edges: if not graph.has_edge(*edge): graph.add_edge(*edge) for static in sample_graphs: g2 = cg.graph(static=(static == 'static'), directed=False, vertices=[]) with pytest.raises(ValueError): alg.partition_karger(g2) g2.add_vertex(1) with pytest.raises(ValueError): alg.partition_karger(g2) g = sample_graphs[static]['directed'] with pytest.raises(NotImplementedError): alg.partition_karger(g) for graphs in sample_graphs.values(): input_graph = graphs['undirected'] output_g1, output_g2, cutset = alg.partition_karger(input_graph) # Check that all edges and vertices of original graph are in # the new graphs and the cutset. output_edges = output_g1.edges | output_g2.edges | cutset input_edges = input_graph.edges for edge in set(output_edges): output_edges.remove(edge) output_edges.add((tuple(sorted(edge[:2])), edge[2])) for edge in set(input_edges): input_edges.remove(edge) input_edges.add((tuple(sorted(edge[:2])), edge[2])) assert input_edges == output_edges assert set(output_g1.vertices + output_g2.vertices) \ == set(input_graph.vertices)
def test_pickling(): """Tests serialization functionality. """ for static in [True, False]: g = cg.graph(static=static, vertices=list(range(3))) g.add_edges({(0, 1), (1, 2), (2, 0)}) with open('tmp.pickle', 'wb+') as f: pickle.dump(g, f) with open('tmp.pickle', 'rb') as f: loaded_g = pickle.load(f) os.remove('tmp.pickle') assert g.equals(loaded_g) assert loaded_g.equals(g)
def test_get_strongly_connected_components(): """Tests get_strongly_connected_components and get_number_strongly_connected_components function. """ edges = [('a', 'b'), ('b', 'c'), ('b', 'e'), ('b', 'f'), ('c', 'd'), ('c', 'g'), ('d', 'c'), ('d', 'h'), ('h', 'd'), ('h', 'g'), ('g', 'f'), ('f', 'g'), ('e', 'a'), ('e', 'f')] component_vertices = [{'a', 'b', 'e'}, {'c', 'd', 'h'}, {'f', 'g'}] component_edges = [{('a', 'b'), ('b', 'e'), ('e', 'a')}, {('f', 'g'), ('g', 'f')}, {('h', 'd'), ('d', 'h'), ('d', 'c'), ('c', 'd')}] for static in [True, False]: g = cg.graph(static=static, directed=True, vertices=list(string.ascii_lowercase[:8])) for edge in edges: g.add_edge(*edge) test_components = alg.get_strongly_connected_components(g, static=True) for component in test_components: assert set(component.vertices) in component_vertices test_component_edges = {e[:-1] for e in component.edges} assert test_component_edges in component_edges test_components_dynamic = alg.get_strongly_connected_components( g, static=False) for component in test_components: assert set(component.vertices) in component_vertices test_component_edges = {e[:-1] for e in component.edges} assert test_component_edges in component_edges assert alg.get_number_strongly_connected_components(g) == 3 g2 = cg.graph(static=static, directed=False) with pytest.raises(NotImplementedError): alg.get_strongly_connected_components(g2) with pytest.raises(NotImplementedError): alg.get_number_strongly_connected_components(g2)
def test_get_connected_components(): """Tests get_connected_components and get_number_connected_components functions. """ for static in [True, False]: g1 = cg.graph(static=static, directed=False, vertices=['a', 'b', 'c']) components = alg.get_connected_components(g1, static=True) for component in components: assert component.vertices in [['a'], ['b'], ['c']] assert len(alg.get_connected_components(component)) == 1 dynamic_components = alg.get_connected_components(g1, static=False) for component in dynamic_components: assert component.vertices in [['a'], ['b'], ['c']] assert len(alg.get_connected_components(component)) == 1 assert alg.get_number_connected_components(g1) == 3 g2 = cg.graph(static=static, directed=True, vertices=['a', 'b', 'c']) with pytest.raises(NotImplementedError): alg.get_connected_components(g2) with pytest.raises(NotImplementedError): alg.get_number_connected_components(g2)
def test_vertices(): """Tests various vertex-related methods. Tests methods: - add_vertex - has_vertex - vertices - remove_vertex - add_vertices for StaticGraph and DynamicGraph classes. """ for static in [True, False]: g = cg.graph(static=static, directed=True) # Adding to graph with no vertices. g.add_vertex('s') # Adding to graph with vertices. g.add_vertex(1) with pytest.raises(TypeError): g.add_vertex([]) with pytest.raises(ValueError): g.add_vertex('s') # vertices attribute assert g.vertices == ['s', 1] # has_vertex assert g.has_vertex('s') assert g.has_vertex(1) assert not g.has_vertex(2) # remove_vertex g.remove_vertex('s') with pytest.raises(ValueError): g.remove_vertex(2) assert not g.has_vertex('s') # add_vertices g.add_vertices({'a', 'b', 's'}) assert g.has_vertex('a') assert g.has_vertex('b') assert g.has_vertex('s') with pytest.raises(ValueError): g.add_vertices({'c', 's'}) assert not g.has_vertex('c') assert g.has_vertex('s')
def test_edges(): """Tests various edge-related methods. Tests: - add_edge - get_children - get_parents - edges - has_edge - remove_edge - adjacency_matrix - adjacency_list - add_edges for StaticGraph and DynamicGraph classes. """ for static in [True, False]: # Directed graph. g = cg.graph(static=static, directed=True, vertices=['s', 'a', 'b', 'e']) # add_edge method g.add_edge('s', 'a', weight=0.0) # Make sure weight zero edges are tested. g.add_edge('a', 's') g.add_edge('a', 'b') g.add_edge('b', 'e', weight=0.5) with pytest.raises(ValueError): g.add_edge('b', 'e', weight=1.0) with pytest.raises(ValueError): g.add_edge('d', 'f') # set_edge_weight g.set_edge_weight('b', 'e', weight=1.0) with pytest.raises(ValueError): g.set_edge_weight('e', 'b', weight=1.0) # edges property g_edges = g.edges assert g_edges == {('s', 'a', 0.0), ('a', 'b', 1.0), ('b', 'e', 1.0), ('a', 's', 1.0)} # has_edge for edge in g_edges: assert g.has_edge(edge[0], edge[1]) assert not g.has_edge('e', 'b') assert not g.has_edge(1, 2) # remove_edge g.remove_edge('s', 'a') with pytest.raises(ValueError): g.remove_edge('sdaf', 'dsafsd') with pytest.warns(Warning): g.remove_edge('s', 'e') assert not g.has_edge('s', 'a') assert g.has_edge('a', 's') # get_edge_weight assert g.get_edge_weight('a', 'b') == 1.0 with pytest.raises(ValueError): g.get_edge_weight('b', 'a') # get_children assert g.get_children('a') == {'s', 'b'} with pytest.raises(ValueError): g.get_children('d') # get_parents assert g.get_parents('e') == {'b'} with pytest.raises(ValueError): g.get_parents('d') # add_edges g.add_edges({('b', 'a', 2.0), ('e', 'b')}) assert g.get_edge_weight('b', 'a') == 2.0 assert g.get_edge_weight('e', 'b') == 1.0 with pytest.raises(ValueError): g.add_edges({('s', 'a'), ('sdaf', 'dsafsd')}) assert not g.has_edge('s', 'a') # Undirected graph. g2 = cg.graph(static=static, directed=False, vertices=['s', 'a', 'b', 'e']) # add_edge method g2.add_edge('s', 'a', weight=0.0) # Make sure weight zero edges are tested. g2.add_edge('a', 'b') g2.add_edge('b', 'e', weight=0.5) with pytest.raises(ValueError): g2.add_edge('b', 'e', weight=1.0) with pytest.raises(ValueError): g2.add_edge('d', 'f') # set_edge_weight g2.set_edge_weight('e', 'b', weight=1.0) with pytest.raises(ValueError): g2.set_edge_weight('a', 'e', weight=1.0) # edges property g2_edges = g2.edges assert len(g2_edges) == 3 for edge in g2_edges: assert set(edge) in [{'s', 'a', 0.0}, {'a', 'b', 1.0}, {'b', 'e', 1.0}] # has_edge for edge in g2_edges: assert g2.has_edge(edge[0], edge[1]) assert g2.has_edge('e', 'b') assert not g2.has_edge(1, 2) # remove_edge g2.remove_edge('s', 'a') with pytest.raises(ValueError): g2.remove_edge('sdaf', 'dsafsd') with pytest.warns(Warning): g2.remove_edge('s', 'e') assert not g2.has_edge('s', 'a') assert not g2.has_edge('a', 's') # get_edge_weight assert g2.get_edge_weight('b', 'a') == 1.0 with pytest.raises(ValueError): g2.get_edge_weight('d', 'e') # get_children assert g2.get_children('a') == {'b'} with pytest.raises(ValueError): g2.get_children('d') # get_parents assert g2.get_parents('a') == {'b'} with pytest.raises(ValueError): g2.get_parents('d') # add_edges g.remove_edge('e', 'b') g.add_edges({('s', 'e', 2.0), ('e', 'b')}) assert g.get_edge_weight('s', 'e') == 2.0 assert g.get_edge_weight('e', 'b') == 1.0 with pytest.raises(ValueError): g.add_edges({('s', 'a'), ('sdaf', 'dsafsd')}) assert not g.has_edge('s', 'a') # adjacency_matrix and adjacency_list g = cg.graph(static=static, directed=False, vertices=list(range(3))) g.add_edge(0, 1) g.add_edge(1, 2) undirected_adj = [[0, 1, 0], [1, 0, 1], [0, 1, 0]] if static: assert (np.nan_to_num(g.adjacency_matrix) == undirected_adj).all() else: assert g.adjacency_matrix == \ [[None if not x else x for x in lst] for lst in undirected_adj] assert g.adjacency_list == [[1], [0, 2], [1]] g = cg.graph(static=static, directed=True, vertices=list(range(3))) g.add_edge(0, 1) g.add_edge(1, 2) directed_adj = [[0, 1, 0], [0, 0, 1], [0, 0, 0]] if static: assert (np.nan_to_num(g.adjacency_matrix) == directed_adj).all() else: assert g.adjacency_matrix == \ [[None if not x else x for x in lst] for lst in directed_adj] assert g.adjacency_list == [[1], [2], []]
def test_attributes(): """Tests various edge and vertex attribute-related methods. Tests: - set_vertex_attribute - get_vertex_attribute - set_edge_attribute - get_edge_attribute for StaticGraph and DynamicGraph classes """ # Edge attributes. for static in [True, False]: # Directed graph. g = cg.graph(static=static, directed=True, vertices=['a', 'b', 'c']) g.add_edge('a', 'b') # Setting attributes. g.set_edge_attribute(('a', 'b'), key='key', val='val') with pytest.raises(TypeError): g.set_edge_attribute(('a', 'b'), key=[], val='val') with pytest.raises(ValueError): g.set_edge_attribute(('b', 'a'), key='key 2', val='val') g.set_edge_attribute(('a', 'b'), key='key', val='new val') # set_edge_attributes g.set_edge_attributes(('a', 'b'), {'key1': 'val1', 'key2': 'val2'}) with pytest.raises(ValueError): g.set_edge_attributes(('b', 'a'), {'key1': 'val1', 'key2': 'val2'}) # Getting attributes. assert g.get_edge_attribute(('a', 'b'), key='key') == 'new val' assert g.get_edge_attribute(('a', 'b'), key='key1') == 'val1' assert g.get_edge_attribute(('a', 'b'), key='key2') == 'val2' with pytest.raises(TypeError): g.get_edge_attribute(('a', 'b'), key=[]) with pytest.raises(ValueError): g.get_edge_attribute(('b', 'a'), key='key') with pytest.raises(KeyError): g.get_edge_attribute(('a', 'b'), key="this is not a key") # Removing attributes. with pytest.raises(ValueError): g.remove_edge_attribute(('a', 'c'), key='key') with pytest.raises(ValueError): g.remove_edge_attribute(('b', 'a'), key='key') with pytest.raises(KeyError): g.remove_edge_attribute(('a', 'b'), key="this is not a key") g.remove_edge_attribute(('a', 'b'), key='key') with pytest.raises(KeyError): g.get_edge_attribute(('a', 'b'), key='key') # Undirected graph. g2 = cg.graph(static=static, directed=False, vertices=['a', 'b', 'c']) g2.add_edge('a', 'b') # Setting attributes. g2.set_edge_attribute(('a', 'b'), key='key', val='val') with pytest.raises(TypeError): g2.set_edge_attribute(('a', 'b'), key=[], val='val') with pytest.raises(ValueError): g2.set_edge_attribute(('a', 'c'), key='key 2', val='val') g2.set_edge_attribute(('a', 'b'), key='key', val='new val') # set_edge_attributes g2.set_edge_attributes(('a', 'b'), {'key1': 'val1', 'key2': 'val2'}) # Getting attributes. assert g2.get_edge_attribute(('a', 'b'), key='key') == 'new val' assert g2.get_edge_attribute(('b', 'a'), key='key') == 'new val' assert g2.get_edge_attribute(('a', 'b'), key='key1') == 'val1' assert g2.get_edge_attribute(('a', 'b'), key='key2') == 'val2' with pytest.raises(TypeError): g2.get_edge_attribute(('a', 'b'), key=[]) with pytest.raises(ValueError): g2.get_edge_attribute(('a', 'c'), key='key') with pytest.raises(KeyError): g2.get_edge_attribute(('a', 'b'), key="this is not a key") # Removing attributes. with pytest.raises(ValueError): g2.remove_edge_attribute(('a', 'c'), key='key') with pytest.raises(KeyError): g2.remove_edge_attribute(('a', 'b'), key="this is not a key") g2.remove_edge_attribute(('a', 'b'), key='key') with pytest.raises(KeyError): g2.get_edge_attribute(('a', 'b'), key='key') with pytest.raises(KeyError): g2.get_edge_attribute(('b', 'a'), key='key') g2.set_edge_attribute(('a', 'b'), key='key', val='val') g2.remove_edge_attribute(('b', 'a'), key='key') with pytest.raises(KeyError): g2.get_edge_attribute(('a', 'b'), key='key') with pytest.raises(KeyError): g2.get_edge_attribute(('b', 'a'), key='key') # Vertex attributes. for static in [True, False]: for directed in [True, False]: g = cg.graph(static=static, directed=directed, vertices=['a', 'b', 'c']) # Setting attributes g.set_vertex_attribute('a', key='key', val='val') with pytest.raises(TypeError): g.set_vertex_attribute('a', key=[], val='val') with pytest.raises(ValueError): g.set_vertex_attribute('d', key='key', val='val') # Getting attributes assert g.get_vertex_attribute('a', key='key') == 'val' with pytest.raises(TypeError): g.get_vertex_attribute('a', key=[]) with pytest.raises(ValueError): g.get_vertex_attribute('d', key='key') with pytest.raises(KeyError): g.get_vertex_attribute('a', key='this is not a key') # Removing attributes with pytest.raises(TypeError): g.remove_vertex_attribute('a', key=[]) with pytest.raises(ValueError): g.remove_vertex_attribute('d', key='key') with pytest.raises(KeyError): g.remove_vertex_attribute('a', key="this is not a key") g.remove_vertex_attribute('a', 'key') with pytest.raises(KeyError): g.get_vertex_attribute('a', key='key')
def test_constructor(): """Tests initialization of a StaticGraph and DynamicGraph objects. """ graphs = [] # Smoke tests. cg.graph() vertex_lists = [['s', 'e'], [0, 1]] for lst in vertex_lists: for directed in [True, False]: for static in [True, False]: g = cg.graph(static=static, directed=directed, vertices=lst) graphs.append(g) # Exception-raising tests. for directed in [True, False]: for static in [True, False]: with pytest.raises(TypeError): # Non-hashable type vertices. g = cg.graph(static=static, directed=directed, vertices=[['s'], ['e']]) graphs.append(g) # Generating from graph data structures. adjacency_matrix = [[0, 1, 0, 0, 0, 0, 0], [1, 0, 1, 0, 0, 0, 0], [0, 1, 0, 1, 1, 1, 0], [0, 0, 1, 0, 0, 0, 0], [0, 0, 1, 0, 0, 1, 0], [0, 0, 1, 0, 1, 0, 1], [0, 0, 0, 0, 0, 1, 0]] adjacency_list = [[1], [0, 2], [1, 3, 4, 5], [2], [2, 5], [2, 4, 6], [5]] edges = [(0, 1), (1, 2), (2, 3), (2, 4), (2, 5), (4, 5), (5, 6)] for static in [True, False]: adj_list_graph = cg.graph(static=static, vertices=list(range(7)), adjacency_list=adjacency_list) if static: np_adjacency_matrix = [[val if val else np.nan for val in row] for row in adjacency_matrix] np_adjacency_matrix = np.array(np_adjacency_matrix) adj_mat_graph = cg.graph(static=static, vertices=list(range(7)), adjacency_matrix=np_adjacency_matrix) else: adj_mat_graph = cg.graph( static=static, vertices=list(range(7)), adjacency_matrix=[[val if val else None for val in row] for row in adjacency_matrix]) for edge in edges: assert adj_list_graph.has_edge(*edge) assert adj_mat_graph.has_edge(*edge) for edge in adj_mat_graph.edges: assert edge[:-1] in edges for edge in adj_list_graph.edges: assert edge[:-1] in edges graphs.append(adj_list_graph) graphs.append(adj_mat_graph) # Copying another graph. for graph in graphs: g = cg.graph(graph_=graph) assert g.vertices == graph.vertices assert g.edges == graph.edges
def __init__(self): self.graph = cg.graph(static=False, graph_=None, directed=True, vertices=[])
def test_get_articulation_points(): """Tests get_articulation_points function. """ random_graph = { 0: {74, 11, 76}, 1: {33, 59, 77}, 2: {53, 78}, 3: {64}, 4: {74}, 5: {80, 81, 89}, 6: {29, 70, 47}, 7: {8}, 8: {58, 36, 7, 95}, 9: {26, 23}, 10: set(), 11: {0, 70}, 12: {73}, 13: {99, 62, 39}, 14: set(), 15: {26, 50, 76}, 16: {93, 22}, 17: {84, 86}, 18: {50, 77}, 19: set(), 20: {56, 58, 66, 39}, 21: {97, 67, 71, 50, 28}, 22: {16, 77}, 23: {9}, 24: {49, 33}, 25: set(), 26: {9, 15}, 27: {41, 82, 33}, 28: {80, 21, 70}, 29: {43, 6}, 30: {73, 46}, 31: {80, 50, 82}, 32: {46}, 33: {1, 73, 80, 24, 57, 27}, 34: {48, 84, 70, 71}, 35: {65, 63}, 36: {8, 46, 47}, 37: set(), 38: {98, 85}, 39: {69, 20, 13, 54}, 40: {66}, 41: {56, 27}, 42: set(), 43: {88, 29}, 44: {68}, 45: {48}, 46: {32, 36, 30}, 47: {36, 6}, 48: {81, 34, 45}, 49: {24, 81, 54}, 50: {18, 15, 21, 31}, 51: set(), 52: set(), 53: {2}, 54: {65, 49, 39}, 55: {89}, 56: {65, 41, 73, 20, 59}, 57: {33}, 58: {8, 97, 20}, 59: {56, 1}, 60: set(), 61: set(), 62: {13}, 63: {35}, 64: {3}, 65: {56, 81, 35, 54}, 66: {40, 90, 20}, 67: {21}, 68: {44}, 69: {97, 93, 39}, 70: {34, 6, 11, 86, 28}, 71: {73, 34, 21}, 72: {98, 94}, 73: {33, 71, 12, 56, 30}, 74: {0, 4}, 75: set(), 76: {0, 15}, 77: {1, 18, 22}, 78: {2}, 79: set(), 80: {33, 5, 87, 28, 31}, 81: {65, 49, 48, 5}, 82: {27, 31}, 83: {87}, 84: {17, 34}, 85: {90, 38}, 86: {17, 70}, 87: {80, 83}, 88: {43}, 89: {5, 55}, 90: {66, 85}, 91: set(), 92: set(), 93: {16, 69}, 94: {72}, 95: {8}, 96: set(), 97: {58, 69, 21}, 98: {72, 38}, 99: {13} } sample_graphs = { 'static': { 'undirected': cg.graph(static=True, directed=False, vertices=list(random_graph)), 'directed': cg.graph(static=True, directed=True, vertices=list(random_graph)) }, 'dynamic': { 'undirected': cg.graph(static=False, directed=False, vertices=list(random_graph)), 'directed': cg.graph(static=False, directed=True, vertices=list(random_graph)) } } for graph in [g for s in sample_graphs for g in sample_graphs[s].values()]: for vertex in random_graph: for neighbor in random_graph[vertex]: if not graph.has_edge(vertex, neighbor): graph.add_edge(vertex, neighbor) random_graph_articulation_points = { 33, 46, 48, 13, 39, 21, 89, 5, 87, 80, 35, 65, 73, 9, 26, 15, 72, 98, 38, 85, 90, 66, 20, 8, 43, 29, 6, 74, 0, 2 } for static in sample_graphs: g1 = sample_graphs[static]['directed'] with pytest.raises(NotImplementedError): alg.get_articulation_points(g1) g2 = sample_graphs[static]['undirected'] assert alg.get_articulation_points( g2) == random_graph_articulation_points