def graph():
letters = Graph()
a = letters.add_node("a")
b = letters.add_node("b")
c = letters.add_node("c")
d = letters.add_node("d")
e = letters.add_node("e")
f = letters.add_node("f")
g = letters.add_node("g")
h = letters.add_node("h")
letters.add_edge(a, b)
letters.add_edge(b, c)
letters.add_edge(c, g)
letters.add_edge(a, d)
letters.add_edge(d, e)
letters.add_edge(d, h)
letters.add_edge(d, f)
letters.add_edge(h, f)
return letters
def test_has_node():
_graph = Graph()
_node1 = Node(4)
_node2 = Node(5)
_graph.add_node(_node1)
assert _graph.had_node(_node1) == True
assert _graph.had_node(_node2) == False
def test_add_undirected_edge(self):
print('Test: test_add_undirected_edge')
g = Graph()
n, n1 = g.add_node(), g.add_node()
g.add_undirected_edge(n, n1, 5)
self.assertIn([n1, 5], n.neighbors)
self.assertIn([n, 5], n1.neighbors)
print('Success: test_add_undirected_edge')
def test_add_edge():
g = Graph()
apple = g.add_node("apple")
banana = g.add_node("banana")
g.add_edge(apple, banana, 5)
neighbors = g.get_neighbors(apple)
assert len(neighbors) == 1
assert neighbors[0].vertex.value == "banana"
assert neighbors[0].weight == 5
def test_size():
graph = Graph()
graph.add_node("spam")
expected = 1
actual = graph.size()
assert actual == expected
def create_graph3():
graph = Graph()
nodes = [1, 2, 3, 4, 5]
edges = [
(1, 3, 1), (1, 2, 2), (3, 6, 3),
(2, 4, 2), (4, 5, 1)
]
for n in nodes:
graph.add_node(n)
for e in edges:
graph.add_edge(e[0], e[1], e[2])
return graph
def create_graph():
graph = Graph()
nodes = [1, 2, 3, 4, 5]
edges = [
(1, 2, 1), (2, 3, 2),
(3, 4, 3), (4, 5, 6)
]
for n in nodes:
graph.add_node(n)
for e in edges:
# node1, node2, weight
graph.add_edge(e[0], e[1], e[2])
return graph
def cyclical_graph():
graph = Graph()
nodes = [1, 2, 3, 4, 5, 6, 7]
edges = [
(1, 2, 3), (2, 3, 3), (3, 5, 2),
(5, 4, 2), (5, 6, 1), (4, 2, 1),
(4, 7, 1)
]
for n in nodes:
graph.add_node(n)
for e in edges:
graph.add_edge(e[0], e[1], e[2])
return graph
def test_get_nodes():
graph = Graph()
banana = graph.add_node("banana")
apple = graph.add_node("apple")
loner = Vertex("loner")
expected = 2
actual = len(graph.get_nodes())
assert actual == expected
def create_spaghetti():
graph = Graph()
nodes = [1, 2, 3, 4, 5, 6, 7, 8, 9]
edges = [
(1, 2, 3), (1, 3, 2), (1, 4, 5),
(2, 9, 5), (2, 5, 3), (2, 6, 6),
(3, 5, 5), (3, 7, 2), (4, 6, 6),
(4, 8, 2), (9, 5, 4), (6, 9, 4),
(7, 8, 5)
]
for n in nodes:
graph.add_node(n)
for e in edges:
graph.add_edge(e[0], e[1], e[2])
return graph
def test_add_edge(self):
print('Test: test_add_edge')
g = Graph()
print('Test: Invalid input')
self.assertRaises(ValueError, g.add_edge, None, None)
print('Test: general case')
n, n1 = g.add_node(), g.add_node()
g.add_edge(n, n1)
self.assertIn([n1, 0], n.neighbors)
n2 = g.add_node()
g.add_edge(n1, n2, 5)
self.assertIn([n2, 5], n1.neighbors)
print('Success: test_add_edge')
def test_bouquet():
g = Graph()
apple = g.add_node("apple")
g.add_edge(apple, apple, 10)
neighbors = g.get_neighbors(apple)
assert len(neighbors) == 1
assert neighbors[0].vertex.value == "apple"
assert neighbors[0].weight == 10
def test_add_node():
graph = Graph()
expected = "spam" # a vertex's value that comes back
actual = graph.add_node("spam").value
assert actual == expected
def test_add_edge_interloper_end():
graph = Graph()
end = Vertex("end")
start = graph.add_node("start")
with pytest.raises(KeyError):
graph.add_edge(start, end)
def test_get_neighbors():
graph = Graph()
banana = graph.add_node("banana")
apple = graph.add_node("apple")
graph.add_edge(apple, banana, 44)
neighbors = graph.get_neighbors(apple)
assert len(neighbors) == 1
neighbor_edge = neighbors[0]
assert neighbor_edge.vertex.value == "banana"
assert neighbor_edge.weight == 44
def graph():
realms = Graph()
pandora = realms.add_node("Pandora")
arendelle = realms.add_node("Arendelle")
metroville = realms.add_node("Metroville")
monstropolis = realms.add_node("Monstropolis")
narnia = realms.add_node("Narnia")
naboo = realms.add_node("Naboo")
realms.add_edge(pandora, arendelle)
realms.add_edge(arendelle, pandora)
realms.add_edge(arendelle, metroville)
realms.add_edge(arendelle, monstropolis)
realms.add_edge(metroville, arendelle)
realms.add_edge(metroville, monstropolis)
realms.add_edge(metroville, narnia)
realms.add_edge(monstropolis, arendelle)
realms.add_edge(monstropolis, metroville)
realms.add_edge(monstropolis, naboo)
realms.add_edge(narnia, metroville)
realms.add_edge(narnia, naboo)
realms.add_edge(naboo, metroville)
realms.add_edge(naboo, monstropolis)
realms.add_edge(naboo, narnia)
return realms
def test_remove_node(self):
print('Test: test_remove_node')
g = Graph()
print('Test: remove a non-existent node')
self.assertRaises(ValueError, g.remove_node, 0)
print('Test: general case')
n = g.add_node()
self.assertEqual(len(g._nodes), 1)
g.remove_node(n.key)
self.assertEqual(len(g._nodes), 0)
print('Success: test_remove_node')
def test_dijkstra(self):
print('Test: test_dijkstra')
graph = Graph(letters=True)
a, b, c, d, e, f, g, h = (graph.add_node(), graph.add_node(),
graph.add_node(), graph.add_node(),
graph.add_node(), graph.add_node(),
graph.add_node(), graph.add_node())
graph.add_undirected_edge(a, b, 8)
graph.add_undirected_edge(a, c, 2)
graph.add_undirected_edge(a, d, 5)
graph.add_undirected_edge(c, d, 2)
graph.add_undirected_edge(c, e, 5)
graph.add_undirected_edge(e, d, 1)
graph.add_undirected_edge(e, g, 1)
graph.add_undirected_edge(g, d, 3)
graph.add_undirected_edge(g, f, 2)
graph.add_undirected_edge(g, h, 6)
graph.add_undirected_edge(h, f, 3)
graph.add_undirected_edge(f, d, 6)
graph.add_undirected_edge(f, b, 13)
graph.add_undirected_edge(b, d, 2)
self.assertEqual(dijkstra(graph, h, a),
(['a', 'c', 'd', 'e', 'g', 'f', 'h'], 11))
print('Success: test_dijkstra')
def test_add_node(self):
print('Test: test_add_node')
print('Test: keys are numbers')
g = Graph()
g.add_node()
self.assertEqual(len(g._nodes), 1)
self.assertEqual(g._counter, 1)
print('Test: keys are chars')
g = Graph(letters=True)
g.add_node()
self.assertEqual(len(g._nodes), 1)
self.assertEqual(g._counter, 98)
print('Test: keys are chars (not enough keys)')
for i in range(98, 123):
g.add_node()
self.assertRaises(NotEnoughKeys, g.add_node)
print('Success: test_add_node')
def planets():
graph = Graph()
metroville = graph.add_node("Metroville")
pandora = graph.add_node("Pandora")
arendelle = graph.add_node("Arendelle")
new_monstropolis = graph.add_node("New Monstropolis")
naboo = graph.add_node("Naboo")
narnia = graph.add_node("Narnia")
graph.add_edge(pandora, arendelle, 150)
graph.add_edge(arendelle, pandora, 150)
graph.add_edge(pandora, metroville, 82)
graph.add_edge(metroville, pandora, 82)
graph.add_edge(metroville, arendelle, 99)
graph.add_edge(arendelle, metroville, 99)
graph.add_edge(new_monstropolis, arendelle, 42)
graph.add_edge(arendelle, new_monstropolis, 42)
graph.add_edge(new_monstropolis, metroville, 105)
graph.add_edge(metroville, new_monstropolis, 105)
graph.add_edge(new_monstropolis, naboo, 73)
graph.add_edge(naboo, new_monstropolis, 73)
graph.add_edge(metroville, naboo, 26)
graph.add_edge(naboo, metroville, 26)
graph.add_edge(metroville, narnia, 37)
graph.add_edge(narnia, metroville, 37)
graph.add_edge(narnia, naboo, 250)
graph.add_edge(naboo, narnia, 250)
return graph
def test_island_empty():
graph = Graph()
lonely = graph.add_node("lonely")
actual = graph.depth_first_search(lonely)
expected = ["lonely"]
assert actual == expected
def test_add_node(self):
""" Tests that add_node properly adds nodes to adjecency list """
graph = Graph()
expected_graph = {'a': {'b'}}
graph.add_node('a', ['b'])
self.assertDictEqual(expected_graph, graph._adjecents)
expected_graph['a'].add('c')
graph.add_node('a', 'c')
self.assertDictEqual(expected_graph, graph._adjecents)
expected_graph['b'] = set({'a', 'd', 'e'})
graph.add_node('b', ['a', 'd', 'e'])
self.assertDictEqual(expected_graph, graph._adjecents)
expected_graph['c'] = set('f')
graph.add_node('c', 'f')
self.assertDictEqual(expected_graph, graph._adjecents)
expected_graph['d'] = set('b')
graph.add_node('d', 'b')
self.assertDictEqual(expected_graph, graph._adjecents)
expected_graph['e'] = set({'b', 'f'})
graph.add_node('e', 'b')
graph.add_node('e', 'f')
self.assertDictEqual(expected_graph, graph._adjecents)
expected_graph['f'] = set({'c', 'e'})
graph.add_node('f', 'c')
graph.add_node('f', 'e')
self.assertDictEqual(expected_graph, graph._adjecents)
def test_add_node():
g = Graph()
g.add_node(Node(4))
assert g.graph == {'n0': {}}
def test_floyd_warshall(make_weighted_graph):
graph_obj = Graph()
graph_obj.name_counter = 1
n1 = Node('n1', {'n2': 2, 'n3': 4})
n2 = Node('n2', {'n1': 2, 'n3': 1, 'n4': 5})
n3 = Node('n3', {'n1': 4, 'n2': 1, 'n4': 3})
n4 = Node('n4', {'n2': 5, 'n3': 3})
graph_obj.add_node(n1)
graph_obj.add_node(n2)
graph_obj.add_node(n3)
graph_obj.add_node(n4)
graph = graph_obj.graph
inf = float('inf')
adj_matrix_of_graph = {
'n1': {
'n1': 0,
'n2': 2,
'n3': 4,
'n4': inf
},
'n2': {
'n1': 2,
'n2': 0,
'n3': 1,
'n4': 5
},
'n3': {
'n1': 4,
'n2': 1,
'n3': 0,
'n4': 3
},
'n4': {
'n1': inf,
'n2': 5,
'n3': 3,
'n4': 0
}
}
adj_matrix_of_graph_with_shortest_path = {
'n1': {
'n1': 0,
'n2': 2,
'n3': 3,
'n4': 6
},
'n2': {
'n1': 2,
'n2': 0,
'n3': 1,
'n4': 4
},
'n3': {
'n1': 3,
'n2': 1,
'n3': 0,
'n4': 3
},
'n4': {
'n1': 6,
'n2': 4,
'n3': 3,
'n4': 0
}
}
t = graph_obj.floyd_warshall(graph)
assert t[0] == adj_matrix_of_graph
assert t[1] == adj_matrix_of_graph_with_shortest_path
