def test_reachable_nodes(self):
self.assertEqual(1, len(self.g.reachable_nodes(Node("A"))))
self.g.add_not_oriented_connections([["A", "B"], ["B", "C"],
["D", "E"]])
self.assertEqual(3, len(self.g.reachable_nodes(Node("A"))))
self.assertEqual(2, len(self.g.reachable_nodes(Node("D"))))
self.assertEqual(1, len(self.g.reachable_nodes(Node("F"))))
def test_get_degree(self):
self.g.add_oriented_connections([["A", "B"], ["B", "C"], ["D", "E"]])
self.assertEqual(1, self.g.get_degree(Node("A")))
self.assertEqual(2, self.g.get_degree(Node("B")))
self.assertEqual(1, self.g.get_degree(Node("C")))
self.assertEqual(1, self.g.get_degree(Node("D")))
self.assertEqual(0, self.g.get_degree(Node("F")))
def build_graph_from_source(self):
# Recieve all the string data from the file
file_list = str(self.graph_file).split("\n")
# Iterate over all parts of the file except for the last since that will be blank
for line in file_list[0:-1]:
# continue if there is a comment character in this line ignore it
if "#" in line:
continue
# split the line into from and to nodes
pair = line.split("\t")
to_node = int(pair[0])
from_node = int(pair[1])
# make the nodes if they do not exist
if to_node not in self.graph:
self.graph[to_node] = Node()
self.node_count += 1
if from_node not in self.graph:
self.graph[from_node] = Node()
self.node_count += 1
# add this edge
self.graph[to_node].add(from_node)
self.graph[from_node].add(to_node)
self.edge_count += 1
def test_add_not_oriented_connection(self):
self.g.add_not_oriented_connection(Node("A"), Node("B"))
self.assertTrue(self.g.is_connection("A", "B"))
self.assertTrue(self.g.is_connection("B", "A"))
self.assertFalse(self.g.is_connection("A", "C"))
with self.assertRaises(ValueError):
self.g.add_not_oriented_connection(Node("A"), Node("Z"))
def hamiltonian_cycle_cheapest_insertion(points):
first_node = Node(points[0], None)
second_node = Node(points[1], None)
first_node.next = second_node
second_node.next = first_node
points.remove(first_node.value)
points.remove(second_node.value)
last_added = second_node
left_neighbour = first_node
right_neighbour = first_node
incert_infos = {}
for point in points:
incert_infos[point] = {"point": point, "price": float("inf"), "place": (first_node, second_node)}
while len(incert_infos) > 0:
incertion_price_recount(incert_infos, last_added, left_neighbour, right_neighbour)
cheapest = get_cheapest_price(incert_infos)
left_neighbour, right_neighbour = cheapest["place"]
last_added = incert(left_neighbour, right_neighbour, cheapest["point"])
incert_infos.pop(cheapest["point"])
return linked_list_to_list(last_added)
class TestVectorMethods(unittest.TestCase):
n1 = Node(0)
n2 = Node(1)
def test_constructor(self):
vector = Vector((self.n1, self.n2), 0)
self.assertEqual(vector.endpoints_nodes, (self.n1, self.n2),
"failed constructor node set")
self.assertEqual(vector.weight, 0, "failed constructor weight")
def test_equal(self):
v1 = Vector((self.n1, self.n2), 0)
v2 = Vector((self.n1, self.n2), 0)
self.assertEqual(v1, v2, "failed equality")
def test_not_equal_weight(self):
v1 = Vector((self.n1, self.n2), 0)
v2 = Vector((self.n1, self.n2), 4)
self.assertNotEqual(v1, v2, "failed weight not equal")
def test_not_equal_direction(self):
v1 = Vector((self.n1, self.n2), 0)
v2 = Vector((self.n2, self.n1), 0)
self.assertNotEqual(v1, v2, "failed direction not equal")
def test_make_vector(self):
v1 = Vector.make_vector(self.n1, self.n2, 0)
v2 = Vector((self.n1, self.n2), 0)
self.assertEqual(v1, v2)
def assert_nodes_parsed_correctly():
node0 = Node('0')
node0.in_degree = 0
node0.out_degree = 2
node1 = Node('1')
node1.in_degree = 1
node1.out_degree = 0
node2 = Node('2')
node2.in_degree = 1
node2.out_degree = 0
expected_nodes = [node0, node1, node2]
edges = [{'source': '0', 'target': '2'}, {'source': '0', 'target': '1'}]
actual_nodes = extract_nodes(edges)
actual_nodes.sort(key=lambda node: node.id)
should_be_true = True
for i in range(len(actual_nodes)):
actual_node = actual_nodes[i]
expected_node = expected_nodes[i]
should_be_true = should_be_true \
and (expected_node.id == actual_node.id) \
and (expected_node.in_degree == actual_node.in_degree) \
and (expected_node.out_degree == actual_node.out_degree)
return should_be_true
def test_get_node_with_highest_degree(self):
self.g.add_oriented_connections([["A", "B"], ["B", "C"], ["F", "E"]])
self.assertEqual(Node("B"), self.g.get_node_with_highest_degree())
self.g.add_oriented_connections([["B", "A"], ["D", "E"]])
self.assertEqual(Node("B"), self.g.get_node_with_highest_degree())
self.g.add_oriented_connections([["D", "A"], ["A", "E"]])
self.assertEqual(Node("A"), self.g.get_node_with_highest_degree())
def testPrint(self): n1 = Node(1) n2 = Node(2) n3 = Node(3) n2.setStart(n1.getId(), 12) n2.setEnd(n3.getId(), 23) self.assertEqual(n2.__repr__(), "2: |edges out| 1 |edges in| 1")
def testGetId(self): n1 = Node(0) n2 = Node(0) self.assertEqual(n1.getId(), n2.getId()) self.assertEqual(n1.getId(), 0) n2 = Node(1) self.assertNotEqual(n1.getId(), n2.getId())
def testJson(self):
n1 = Node(1)
n2 = Node(2)
n3 = Node(3)
n2.setStart(n1.getId(), 12)
n2.setEnd(n3.getId(), 23)
self.assertEqual(n2.toJson(), {'id': 2})
def testConnections(self): n1 = Node(0) n2 = Node(1) self.assertEqual(n1.getStart(), n2.getStart()) n1.setEnd(n2, 1) n2.setStart(n1, 1) self.assertNotEqual(n1.getStart(), n2.getStart()) self.assertNotEqual(n1.getEnd(), n2.getEnd())
def full_expression(self, depth, terminals):
if depth < self.max_depth:
operator = randint(0, len(self.functions) - 1)
return Node(self.functions[operator],
self.full_expression(depth + 1, terminals),
self.full_expression(depth + 1, terminals))
else:
value = terminals.pop(randint(0, len(terminals) - 1))
self.node_values.append(value)
return Node(value)
def testPos(self): n1 = Node(0) n2 = Node(0) self.assertEqual(n1.getPos(), n2.getPos()) n1.setPos((0, 0, 1)) self.assertNotEqual(n1.getPos(), n2.getPos()) n2.setPos((0, 0, 1)) self.assertEqual(n1.getPos(), n2.getPos()) n1.incPos(5) self.assertEqual(n1.getPos(), (0, 0, 50))
def test_get_node_with_lowest_value(self):
a = Node("A", "B", 3)
nodes = {a}
self.assertEqual(a, self.g.get_node_with_lowest_value(nodes))
b = Node("B", "C", 2)
nodes.add(b)
self.assertEqual(b, self.g.get_node_with_lowest_value(nodes))
c = Node("C", None, 0)
d = Node("D", None, None)
nodes.add(c)
nodes.add(d)
self.assertEqual(c, self.g.get_node_with_lowest_value(nodes))
class TestVectorSetMethods(unittest.TestCase):
# define useful testing nodes
parent_node = Node(0)
n1 = Node(1)
n2 = Node(2)
# define useful testing vectors
vP1 = Vector((parent_node, n1))
vP2 = Vector((parent_node, n2))
v12 = Vector((n1, n2))
def test_len_0(self):
vs = VectorSet(self.parent_node)
self.assertEqual(len(vs), 0)
def test_add(self):
vs = VectorSet(self.parent_node)
try:
vs.add(self.vP1)
except ValueError as ve:
self.fail(ve.args)
def test_add_repeat_vector(self):
vs = VectorSet(self.parent_node)
vs.add(self.vP1)
self.assertEqual(vs.add(self.vP1), False)
def test_len_same_after_failed_add(self):
vs = VectorSet(self.parent_node)
vs.add(self.vP1)
length = len(vs)
vs.add(self.vP1)
self.assertEqual(len(vs), length)
def test_remove_succeed(self):
vs = VectorSet(self.parent_node)
vs.add(self.vP1)
self.assertEqual(vs.remove(self.vP1), True)
def test_remove_failure(self):
vs = VectorSet(self.parent_node)
self.assertEqual(vs.remove(self.vP1), False)
def test_in_true(self):
vs = VectorSet(self.parent_node)
vs.add(self.vP1)
self.assertEqual(self.vP1 in vs, True)
def test_in_false(self):
vs = VectorSet(self.parent_node)
self.assertEqual(self.vP1 in vs, False)
def start_search(self):
if self.maze.create_maze(
): # Verifica se conseguiu ler o arquivo e criar a matriz do labirinto
self.player = Player(self.maze.get_start(
)) # Posiciona o jogador no inicio do labirinto
self.root_node = Node(self.player.get_position(), None, 0,
0) # Cria o no raiz da árvore
self.calculate_cost(self.root_node)
self.opened_list.append(
self.root_node) # Adiciona o nó raiz na lista de abertos
success = False
while len(self.opened_list) != 0:
self.print_fluxograma()
current_node = self.opened_list.pop(
0) # Pega o primeiro nó da lista de abertos
self.player.set_position(current_node.get_position())
if not self.is_success(
current_node): # Se não for sucesso, explora esse nó
self.explore_node(current_node)
else:
success = True
print("------------- Final ---------------")
self.create_success_way(current_node)
print("\n O custo real eh: {}".format(
current_node.get_real_cost()))
print("\n A arvore gerada eh: ")
self.pprint_tree(self.root_node, "", True)
print("\n O caminho no labirinto sera: \n")
self.maze_solution()
break
if not success:
print('Não encontrou solução')
else:
print('Não foi possível criar o labirinto')
def assert_dummy_vertices_get_correct_positions():
nodes = [Node('0'), Node('1')]
nodes[0].layer = 1
nodes[0].pos_in_layer = 1
nodes[1].layer = 2
nodes[1].pos_in_layer = 2
dummy_vertices = [Node('2'), Node('3'), Node('4')]
dummy_vertices[0].layer = 1
dummy_vertices[1].layer = 2
dummy_vertices[2].layer = 2
assign_positions_for_dummy_vertices(nodes, dummy_vertices)
return dummy_vertices[0].pos_in_layer == 2 \
and dummy_vertices[1].pos_in_layer == 3\
and dummy_vertices[2].pos_in_layer == 4
def add_node(self, node_id: int, pos: tuple = None) -> bool:
if node_id not in self.__graph.get('node') and node_id >= 0:
self.__graph.get('node').update({node_id: Node(node_id, pos)})
self.__mc = self.__mc + 1
return True
else:
return False
def test_get_pos(self):
id = 10
pos = (1, 2, 0)
node = Node(id)
node.setPos(pos)
x, y, z = node.getPos()
self.assertTrue(x == 1)
self.assertTrue(y == 2)
def __init__(self, screen):
self.screen = screen
self.running = True
self.tile = maptile()
self.node = Node(10, 10, 15, 30)
self.clock = pygame.time.Clock()
self.main_loop()
self.map_init()
def test_get_neighbors(self):
self.g.add_not_oriented_connections([["A", "B"], ["B", "C"],
["D", "E"]])
self.assertEqual({Node("B")}, self.g.get_neighbors(Node("A")))
self.assertEqual({Node("A"), Node("C")},
self.g.get_neighbors(Node("B")))
self.assertEqual({Node("D")}, self.g.get_neighbors(Node("E")))
def test_remove_node(self):
self.g.add_not_oriented_connections([[Node("A"), Node("B")],
[Node("B"), Node("C")],
[Node("D"), Node("E")]])
self.g.remove_node(Node("B"))
self.assertEqual(5, len(self.g.nodes))
self.assertEqual(1, len(self.g.connections))
def add_node(self, node_id: int, pos: tuple = None) -> bool:
if node_id not in self.nodedict:
if pos is None:
pos = (random.random() * 40, random.random() * 40, 0.0)
n = Node(node_id, pos)
self.nodedict[node_id] = n
self.mc += 1
return True
return False
def test_get_hamilton_path_nodes(self):
self.g = Graph(["A", "B", "C", "D"])
connections = [["A", "B", 10], ["A", "C", 3], ["A", "D", 2],
["B", "C", 1], ["B", "D", 5], ["C", "D", 7]]
self.g.add_not_oriented_valued_connections(connections)
self.assertEqual(4, len(self.g.get_hamilton_path_nodes()))
self.assertIn(self.g.get_hamilton_path_nodes(),
[[Node("B"), Node("C"),
Node("A"), Node("D")],
[Node("A"), Node("D"),
Node("C"), Node("B")]])
def test_get_leaving_edges_size(self):
self.g.add_not_oriented_connections([["A", "B"], ["B", "C"],
["D", "E"]])
self.assertEqual(1, self.g.get_leaving_edges_size(Node("A")))
self.assertEqual(2, self.g.get_leaving_edges_size(Node("B")))
self.assertEqual(1, self.g.get_leaving_edges_size(Node("C")))
self.assertEqual(0, self.g.get_leaving_edges_size(Node("F")))
self.g.add_oriented_connections([["C", "A"]])
self.assertEqual(1, self.g.get_leaving_edges_size(Node("A")))
self.assertEqual(2, self.g.get_leaving_edges_size(Node("B")))
self.assertEqual(2, self.g.get_leaving_edges_size(Node("C")))
self.assertEqual(0, self.g.get_leaving_edges_size(Node("F")))
def _fill_nodes(self):
nodes = {}
pos = 1
dx = self.GlobalData.W / (self.GlobalData.nW - 1)
dy = self.GlobalData.H / (self.GlobalData.nH - 1)
for i in range(0, self.GlobalData.nW):
for j in range(0, self.GlobalData.nH):
nodes[pos] = Node(i * dx, j * dy, self.GlobalData.t0)
pos += 1
return nodes
def test_get_num_of_unique_neigbors(self):
self.g.add_not_oriented_connections([["A", "B"], ["B", "C"],
["D", "E"]])
self.assertEqual(1, self.g.get_num_of_unique_neigbors({Node("A")}))
self.assertEqual(0, self.g.get_num_of_unique_neigbors({Node("F")}))
self.assertEqual(2, self.g.get_num_of_unique_neigbors({Node("B")}))
self.assertEqual(
2, self.g.get_num_of_unique_neigbors({Node("A"),
Node("D")}))
self.assertEqual(
2,
self.g.get_num_of_unique_neigbors(
{Node("A"), Node("B"), Node("D")}))
def _set_nodes(self, nodes: int):
self._tmp = [[0 for _ in range(self._map.size[0])]
for _ in range(self._map.size[1])]
while len(self._map.nodes) != nodes:
new_coordinate = Coordinate.random_coordinate(
(SECURITY_ZONE, MAP_SIZE[0] - SECURITY_ZONE - 1),
(SECURITY_ZONE, MAP_SIZE[1] - SECURITY_ZONE - 1))
if self._check_node_place(new_coordinate):
self._map.nodes.append(
Node(len(self._map.nodes), new_coordinate))
self._tmp[new_coordinate.y][new_coordinate.x] = 1
def __convert_to_graph(self, data, dimension, points=[]):
nodes = [Node(i) for i in range(dimension)]
for i, costs in enumerate(data):
neighborhood = []
for j, cost in enumerate(costs):
neighborhood.append(Neighbor(node=nodes[j], cost=cost))
nodes[i].neighborhood = neighborhood
return nodes
