def test_is_complete(self):
graph = Graph(input_graph=json.dumps(self.complete_graph))
self.assertTrue(is_complete(graph))
graph = Graph(input_graph=json.dumps(self.isolated_graph))
self.assertFalse(is_complete(graph))
json_graph = {"name": "", "graph": {"A": ["B"], "B": []}}
graph = Graph(input_graph=json.dumps(json_graph))
self.assertFalse(is_complete(graph))
def test_density(self):
graph = Graph(input_graph=json.dumps(self.connected_graph))
self.assertAlmostEqual(0.4666666666666667, density(graph))
graph = Graph(input_graph=json.dumps(self.complete_graph))
self.assertEqual(1.0, density(graph))
graph = Graph(input_graph=json.dumps(self.isolated_graph))
self.assertEqual(0.0, density(graph))
def test_complete_digraph(self):
graph = Graph(input_graph=json.dumps(self.complete_digraph))
self.assertTrue(is_complete(graph))
json_graph = {
"name": "",
"directed": True,
"graph": {
"A": ["B"],
"B": []
}
}
graph = Graph(input_graph=json.dumps(json_graph))
self.assertFalse(is_complete(graph))
def test_str(self):
answer = """my graph
A -> B
B -> 0"""
json_graph = {"label": "my graph", "graph": {"A": ["B"], "B": []}}
graph = Graph(input_graph=json.dumps(json_graph))
self.assertEqual(answer, str(graph))
def test_edges(self):
json_graph = {"label": "my graph", "graph": {"A": ["B"], "B": []}}
graph = Graph(input_graph=json.dumps(json_graph))
self.assertEqual(json_graph['label'], graph.get_label())
self.assertEqual(False, graph.is_directed())
self.assertEqual(json_graph['graph'], graph.get_graph())
self.assertEqual([Edge('A', 'B')], graph.edges())
def test_get_adjacency_matrix(self):
json_graph = {"graph": {"A": ["B"], "B": []}}
graph = Graph(input_graph=json.dumps(json_graph))
matrix = graph.get_adjacency_matrix()
answer = np.array([[0, 1], [0, 0]])
np.testing.assert_equal(matrix, answer)
self.assertEqual(answer.size, matrix.size)
def test_arrival_departure_dfs(self):
disjoint_graph = {
"graph": {
"a": ["b", "c"],
"b": [],
"c": ["d", "e"],
"d": ["b", "f"],
"e": ["f"],
"f": [],
"g": ["h"],
"h": []
},
"directed": True
}
graph = Graph(input_graph=json.dumps(disjoint_graph))
# list to store the arrival time of vertex
arrival = {v: 0 for v in graph.vertices()}
# list to store the departure time of vertex
departure = {v: 0 for v in graph.vertices()}
# mark all the vertices as not discovered
discovered = {v: False for v in graph.vertices()}
time = -1
for v in graph.vertices():
if not discovered[v]:
time = arrival_departure_dfs(graph, v, discovered, arrival,
departure, time)
# pair up the arrival and departure times and ensure correct ordering
result = list(zip(arrival.values(), departure.values()))
expected_times = [(0, 11), (1, 2), (3, 10), (4, 7), (8, 9), (5, 6),
(12, 15), (13, 14)]
self.assertListEqual(expected_times, result)
def test_read_graph_from_file(self):
json_graph = {"label": "my graph", "graph": {"A": ["B"], "B": []}}
with open(path.join(self.test_dir, 'test.txt'), 'w') as out_file:
out_file.write(json.dumps(json_graph))
graph = Graph(input_file=str(path.join(self.test_dir, 'test.txt')))
self.assertEqual(json_graph["label"], graph.get_label())
self.assertEqual(False, graph.is_directed())
self.assertEqual(json_graph["graph"], graph.get_graph())
def test_add_edge(self):
graph = Graph("my graph")
graph.add_vertex("A")
graph.add_vertex("B")
graph.add_edge("A", "B")
self.assertEqual(1, len(graph.edges()))
graph.add_edge("X", "Y")
self.assertEqual(2, len(graph.edges()))
self.assertEqual(4, len(graph.vertices()))
def test_is_dag(self):
cycle_graph = {
"directed": True,
"graph": {
"A": ["B"],
"B": ["C", "D"],
"C": [],
"D": ["E", "A"], # cycle A -> B -> D -> A
"E": []
}
}
graph = Graph(input_graph=json.dumps(cycle_graph))
self.assertFalse(is_dag(graph))
dag = cycle_graph
# remove the cycle
dag["graph"]["D"] = ["E"]
graph2 = Graph(input_graph=json.dumps(dag))
self.assertTrue(is_dag(graph2))
def get_complement(graph: Graph) -> Graph:
"""
If graph is represented as a matrix, invert that matrix
:param graph:
:return: inversion of graph
"""
adj = graph.get_adjacency_matrix()
complement = invert(adj)
return Graph(label=f"{graph.get_label()} complement",
input_array=complement)
def test_save_to_json(self):
answer = "{\"label\": \"my graph\", \"directed\": false," \
" \"graph\": {\"A\": [\"B\"], \"B\": []}}"
json_graph = {"label": "my graph", "graph": {"A": ["B"], "B": []}}
graph = Graph(input_graph=json.dumps(json_graph))
save_to_json(graph, self.test_dir)
outfile = path.join(self.test_dir, graph.get_label() + ".json")
with open(outfile) as dot_file:
dot_lines = "".join(dot_file.readlines())
self.assertEqual(dot_lines, answer)
def test_find_circuit(self):
circuit_graph = {
"directed": True,
"graph": {
"A": ["B"],
"B": ["C"],
"C": ["A"] # circuit A -> C -> B -> A
}
}
graph = Graph(input_graph=json.dumps(circuit_graph))
circuit = find_circuit(graph)
expected_circuit = ["A", "C", "B", "A"]
self.assertListEqual(circuit, expected_circuit)
def test_save_to_graphviz(self):
answer = """// my graph
graph {
A [label=A]
A -- B
B [label=B]
}
"""
json_graph = {"label": "my graph", "graph": {"A": ["B"], "B": []}}
graph = Graph(input_graph=json.dumps(json_graph))
save_to_dot(graph, self.test_dir)
outfile = path.join(self.test_dir, graph.get_label() + ".gv")
with open(outfile) as dot_file:
dot_lines = "".join(dot_file.readlines())
self.assertEqual(dot_lines, answer)
def test_topological_sort(self):
t_sort_graph = {
"directed": True,
"graph": {
"A": [],
"B": [],
"C": ["D"],
"D": ["B"],
"E": ["A", "B"],
"F": ["A", "C"]
}
}
graph = Graph(input_graph=json.dumps(t_sort_graph))
expected_results = ["F", "E", "C", "D", "B", "A"]
results = topological(graph)
self.assertListEqual(expected_results, results)
def test_find_all_paths(self):
json_graph = {
"label": "test2",
"directed": False,
"graph": {
"a": ["d", "f"],
"b": ["c"],
"c": ["b", "c", "d", "e"],
"d": ["a", "c"],
"e": ["c"],
"f": ["d"]
}
}
graph = Graph(input_graph=json.dumps(json_graph))
paths = find_all_paths(graph, "a", "b")
self.assertListEqual([['a', 'd', 'c', 'b'], ['a', 'f', 'd', 'c', 'b']],
paths)
paths = find_all_paths(graph, "z", "b")
self.assertListEqual([], paths)
def test_iterator(self):
json_graph = {
"name": "my graph",
"graph": {
"A": ["B", "C", "D"],
"B": [],
"C": [],
"D": []
}
}
graph = Graph(input_graph=json.dumps(json_graph))
iterations = 0
for key in graph:
iterations += 1
if key == "A":
self.assertEqual(len(graph[key]), 3)
else:
self.assertEqual(len(graph[key]), 0)
self.assertEqual(iterations, 4)
def test_find_path(self):
json_graph = {
"label": "test",
"directed": False,
"graph": {
"a": ["d"],
"b": ["c"],
"c": ["b", "c", "d", "e"],
"d": ["a", "c"],
"e": ["c"],
"f": []
}
}
graph = Graph(input_graph=json.dumps(json_graph))
path = find_path(graph, "a", "b")
self.assertListEqual(['a', 'd', 'c', 'b'], path)
path = find_path(graph, "a", "f")
self.assertListEqual([], path)
path = find_path(graph, "c", "c")
self.assertListEqual(['c'], path)
path = find_path(graph, "z", "a")
self.assertListEqual([], path)
def test_get_neighbors(self):
json_graph = {"label": "my graph", "graph": {"A": ["B"], "B": []}}
graph = Graph(input_graph=json.dumps(json_graph))
self.assertEqual(graph.get_neighbors("A"), ["B"])
self.assertEqual(graph.get_neighbors("B"), [])
def test_set_from_adjacency_matrix(self):
array_graph = np.array([[0, 1], [1, 0]], dtype=object)
graph = Graph(input_array=array_graph)
self.assertEqual(2, len(graph.vertices()))
self.assertEqual(1, len(graph.edges()))
def test_order_and_size(self):
json_graph = {"graph": {"A": ["B"], "B": []}}
graph = Graph(input_graph=json.dumps(json_graph))
self.assertEqual(2, graph.order())
self.assertEqual(1, graph.size())
def test_is_regular_graph(self):
graph = Graph(input_graph=json.dumps(self.big_graph))
self.assertFalse(is_regular(graph))
one_reg_graph = Graph(input_graph=json.dumps(self.one_regular_graph))
self.assertTrue(is_regular(one_reg_graph))
def test_generate_edges(self):
json_graph = {"name": "", "graph": {"A": ["B"], "B": []}}
graph = Graph(input_graph=json.dumps(json_graph))
edges = generate_edges(graph)
self.assertEqual(len(edges), 1)
def test_is_simple(self):
graph = Graph(input_graph=json.dumps(self.straight_line))
self.assertTrue(is_simple(graph))
lolli = Graph(input_graph=json.dumps(self.lollipop_graph))
self.assertFalse(is_simple(lolli))
def test_is_sparse(self):
graph = Graph(input_graph=json.dumps(self.isolated_graph))
self.assertTrue(is_sparse(graph))
def test_repr(self):
graph = Graph("graph")
self.assertEqual('graph', repr(graph))
def test_name(self):
graph = Graph("graph")
self.assertEqual('graph', graph.get_label())
def test_add_vertex(self):
graph = Graph("my graph")
graph.add_vertex("A")
self.assertEqual(['A'], graph.vertices())
def test_find_isolated_nodes(self):
json_graph = {"name": "", "graph": {"A": ["B"], "B": ["A"], "C": []}}
graph = Graph(input_graph=json.dumps(json_graph))
isolated = find_isolated_vertices(graph)
self.assertEqual(len(isolated), 1)
self.assertEqual(isolated[0], 'C')
def test_complement(self):
graph = Graph(input_graph=json.dumps(self.isolated_graph))
complement = get_complement(graph)
self.assertTrue(is_complete(complement))
