def test_room():
Room.room_counter = 0
bl = Node(Vector(0, 0))
tl = Node(Vector(0, 1))
br = Node(Vector(1, 0))
tr = Node(Vector(1, 1))
room_node = RoomNode(Vector(0.5, 0.5), RoomType.kitchen)
room = Room(name='name', corners=[tl, bl, tr, br], room_node=room_node)
fail_if(room != room)
fail_if(room.room_count != 0)
fail_if(Room.room_counter != 1)
fail_if(
str(room) != f"Room defined by" + f" [(1.0, 1.0)" + f", (1.0, 0.0)" +
f", (0.0, 0.0)" + f", (0.0, 1.0)]" + f" labelled: {RoomType.kitchen}" +
f" name: name" + f" | count: 0")
try:
Room(name='test', corners=[tl, bl, tr, br], room_node=tl)
pytest.fail()
except ValueError:
pass
try:
Room(name=0, corners=[tl, bl, tr, br], room_node=room_node)
pytest.fail()
except ValueError:
pass
def add_wall(floor_plan: FloorPlan, node_a: Node,
node_b: Node) -> Tuple[FloorPlan, Tuple[Node, Node]]:
edge = Edge(edge_type=EdgeType.wall, node_a=node_a, node_b=node_b)
node_a.add_edge(edge)
node_b.add_edge(edge)
floor_plan.add_node(node_a)
floor_plan.add_node(node_b)
floor_plan.add_edge(edge)
return floor_plan, (node_a, node_b)
def test_staircase():
bl = Node(Vector(0.0, 0.0))
tl = Node(Vector(0.0, 1.0))
br = Node(Vector(1.0, 0.0))
tr = Node(Vector(1.0, 1.0))
stairs = Staircase([bl, tl, br, tr])
fail_if(
str(stairs) != "Staircase defined by" + f" [NE: (1.0, 1.0)" +
f", SE: (1.0, 0.0)" + f", SW: (0.0, 0.0)" + f", NW: (0.0, 1.0)]")
def add_corner(self, points: List[Tuple[int, int]]):
cur_x, cur_y = points[0]
node = Node(Vector(cur_x, cur_y))
prev_x, prev_y = self.corners[-1]
if abs(cur_x - prev_x) < abs(cur_y - prev_y):
self.corners.append((prev_x, cur_y))
else:
self.corners.append((cur_x, prev_y))
def house_32_floor_0():
floor_plan = FloorPlan('house_32_floor_0', status=FloorPlanStatus.start)
# origin = (6, 7)
# footprint
floor_plan, (node_a, node_b) = add_wall(floor_plan,
node_a=Node(Vector(0, 0)),
node_b=Node(Vector(58, 0)))
floor_plan, (node_a, node_b) = add_wall(floor_plan,
node_a=node_b,
node_b=Node(Vector(386, 0)))
floor_plan, (node_a, node_b) = add_wall(floor_plan,
node_a=node_b,
node_b=Node(Vector(386, -183)))
floor_plan, (node_a, node_b) = add_wall(floor_plan,
node_a=node_b,
node_b=Node(Vector(184, -183)))
floor_plan, (node_a, node_b) = add_wall(floor_plan,
node_a=node_b,
node_b=Node(Vector(184, -165)))
floor_plan, (node_a, node_b) = add_wall(floor_plan,
node_a=node_b,
node_b=Node(Vector(127, -165)))
floor_plan, (node_a, node_b) = add_wall(floor_plan,
node_a=node_b,
node_b=Node(Vector(127, -183)))
floor_plan, (node_a, node_b) = add_wall(floor_plan,
node_a=node_b,
node_b=Node(Vector(14, -183)))
floor_plan, (node_a, node_b) = add_wall(floor_plan,
node_a=node_b,
node_b=Node(Vector(14, -77)))
floor_plan, (node_a, node_b) = add_wall(floor_plan,
node_a=node_b,
node_b=Node(Vector(56, -77)))
floor_plan, (node_a, node_b) = add_wall(floor_plan,
node_a=node_b,
node_b=Node(Vector(58, 0)))
floor_plan, (node_a, node_b, node_c,
node_d) = add_room(floor_plan,
corners=[
Node(Vector(134, 0)),
Node(Vector(201, 0)),
Node(Vector(201, -77)),
Node(Vector(134, -77))
],
room_type=RoomType.staircase,
name='stairs',
midpoint=(167.5, -38.5))
floor_plan, (node_a, node_b, node_c, node_d) = add_room(
floor_plan,
corners=[node_b,
Node(Vector(254, 0)),
Node(Vector(254, -77)), node_c],
room_type=RoomType.bath,
name='stairs',
midpoint=(227.5, -38.5))
floor_plan, (node_a, node_b, node_c, node_d) = add_room(
floor_plan,
corners=[node_b,
Node(Vector(341, 0)),
Node(Vector(341, -77)), node_c],
room_type=RoomType.bed,
name='stairs',
midpoint=(297.5, -38.5))
def test_door():
bl = Node(Vector(0.0, 0.0))
tl = Node(Vector(0.0, 1.0))
br = Node(Vector(1.0, 0.0))
tr = Node(Vector(1.0, 1.0))
def test_window():
bl = Node(Vector(0.0, 0.0))
tl = Node(Vector(0.0, 1.0))
br = Node(Vector(1.0, 0.0))
tr = Node(Vector(1.0, 1.0))
def test_rectangle():
bl = Node(Vector(0, 0))
tl = Node(Vector(0, 1))
br = Node(Vector(1, 0))
tr = Node(Vector(1, 1))
try:
Rectangle([bl, tl])
pytest.fail()
except ValueError:
pass
try:
Rectangle([bl, tl, tr, 0])
pytest.fail()
except ValueError:
pass
try:
Rectangle([bl, tl, tr, tl])
pytest.fail()
except ValueError:
pass
rectangle = Rectangle([tl, bl, tr, br])
fail_if(rectangle.NE != tr)
fail_if(rectangle.SE != br)
fail_if(rectangle.SW != bl)
fail_if(rectangle.NW != tl)
fail_if(rectangle.NE.vector.x != rectangle.SE.vector.x
or rectangle.NW.vector.x != rectangle.SW.vector.x
or rectangle.NE.vector.y != rectangle.NW.vector.y
or rectangle.SE.vector.y != rectangle.SW.vector.y)
fail_if(rectangle.width != 1)
fail_if(rectangle.height != 1)
fail_if(rectangle.is_vertical)
fail_if(rectangle.is_horizontal)
fail_if(not rectangle.is_square)
bl = Node(Vector(0, 0))
tl = Node(Vector(0, 2))
br = Node(Vector(1, 0))
tr = Node(Vector(1, 2))
rectangle2 = Rectangle([tl, bl, tr, br])
fail_if(not rectangle2.is_vertical)
fail_if(rectangle2.is_horizontal)
fail_if(rectangle2.is_square)
fail_if(rectangle2.width != 1)
fail_if(rectangle2.height != 2)
bl = Node(Vector(0, 0))
tl = Node(Vector(0, 1))
br = Node(Vector(2, 0))
tr = Node(Vector(2, 1))
rectangle3 = Rectangle([tl, bl, tr, br])
fail_if(rectangle3.is_vertical)
fail_if(not rectangle3.is_horizontal)
fail_if(rectangle3.is_square)
fail_if(rectangle3.width != 2)
fail_if(rectangle3.height != 1)
fail_if(rectangle != rectangle)
fail_if(rectangle == rectangle3)
# check overlap
bl = Node(Vector(0, 0))
tl = Node(Vector(0, 10))
br = Node(Vector(10, 0))
tr = Node(Vector(10, 10))
rectangle = Rectangle([tl, bl, tr, br])
bl = Node(Vector(5, 5))
tl = Node(Vector(5, 15))
br = Node(Vector(15, 5))
tr = Node(Vector(15, 15))
rectangle2 = Rectangle([tl, bl, tr, br])
bl = Node(Vector(-5, -5))
tl = Node(Vector(-5, 5))
br = Node(Vector(5, -5))
tr = Node(Vector(5, 5))
rectangle3 = Rectangle([tl, bl, tr, br])
bl = Node(Vector(5, 5))
tl = Node(Vector(5, 15))
br = Node(Vector(15, 5))
tr = Node(Vector(15, 15))
rectangle4 = Rectangle([tl, bl, tr, br])
bl = Node(Vector(5, -5))
tl = Node(Vector(5, 1))
br = Node(Vector(10, -5))
tr = Node(Vector(10, 1))
rectangle5 = Rectangle([tl, bl, tr, br])
bl = Node(Vector(100, 100))
tl = Node(Vector(100, 110))
br = Node(Vector(110, 100))
tr = Node(Vector(110, 110))
rectangle6 = Rectangle([tl, bl, tr, br])
fail_if(not rectangle.overlap_with(rectangle))
fail_if(not rectangle.overlap_with(rectangle2))
fail_if(not rectangle.overlap_with(rectangle3))
fail_if(not rectangle.overlap_with(rectangle4))
fail_if(not rectangle.overlap_with(rectangle5))
fail_if(rectangle.overlap_with(rectangle6))
try:
rectangle.overlap_with(0)
pytest.fail()
except Exception:
pass
fail_if(not rectangle.contains_node(Node(Vector(0, 0.5))))
fail_if(rectangle.contains_node(Node(Vector(0, 100))))
def test_node_and_edge():
Node.node_counter = 0
vector = Vector(0, 0)
node = Node(vector)
fail_if(len(node.neighbour_edges) != 8)
# fail_if(sum([arg is not None for arg in node.neighbour_edges]) != 0)
fail_if(node.vector != vector)
print(node.node_count)
fail_if(node.node_count != 0)
fail_if(Node.node_counter != 1)
fail_if(str(node) != f"Node 0 - @ {str(vector)}")
# that this shouldn't be allowed when building the graph, but ok for now
node2 = Node(vector)
fail_if(node2.node_count != 1)
fail_if(Node.node_counter != 2)
fail_if(node != node)
fail_if(node2 != node2)
fail_if(node.vector != node2.vector)
try:
Node(0, 0)
pytest.fail()
except Exception:
pass
# directions
fail_if(node.left_of(Node(Vector(-1, 0))))
fail_if(not node.left_of(Node(Vector(1, 1))))
fail_if(node.right_of(Node(Vector(1, 0))))
fail_if(not node.right_of(Node(Vector(-1, 0))))
fail_if(node.above(Node(Vector(1, 1))))
fail_if(not node.above(Node(Vector(1, -1))))
fail_if(node.beneath(Node(Vector(0, -1))))
fail_if(not node.beneath(Node(Vector(0, 1))))
# direction to
fail_if(node.get_direction_to(Node(Vector(0, 1))) != EdgeDirection('N'))
fail_if(node.get_direction_to(Node(Vector(1, 0))) != EdgeDirection('E'))
fail_if(node.get_direction_to(Node(Vector(1, 1))) != EdgeDirection('NE'))
fail_if(node.get_direction_to(Node(Vector(0, -1))) != EdgeDirection('S'))
fail_if(node.get_direction_to(Node(Vector(-1, 0))) != EdgeDirection('W'))
fail_if(node.get_direction_to(Node(Vector(-1, -1))) != EdgeDirection('SW'))
fail_if(node.get_direction_to(Node(Vector(-1, 1))) != EdgeDirection('NW'))
fail_if(node.get_direction_to(Node(Vector(1, -1))) != EdgeDirection('SE'))
# SOME EDGE STUFF
node2 = Node(Vector(0, 1))
direction = EdgeDirection('N')
to = node.get_direction_to(node2)
fail_if(to != direction)
fail_if(direction.reverse() != EdgeDirection('S'))
fail_if(node2.get_direction_to(node) != direction.reverse())
et = EdgeType.wall
edge = Edge(edge_type=et, node_a=node, node_b=node2)
try:
Edge(edge_type=et, node_a=node, node_b=node)
pytest.fail()
except ValueError:
pass
node.add_edge(edge)
node2.add_edge(edge)
try:
node.add_edge(edge)
pytest.fail()
except ValueError:
pass
try:
node.add_edge(0)
pytest.fail()
except ValueError:
pass
fail_if(edge.midpoint != Vector(0, 0.5))
fail_if(node.neighbour_edges[0] != edge)
fail_if(node2.neighbour_edges[4] != edge)
fail_if(node.neighbour_edges['N'] != edge)
fail_if(node2.neighbour_edges['S'] != edge)
fail_if(edge.get_other_node(node) != node2)
fail_if(edge.get_other_node(node2) != node)
fail_if(edge.get_upper_node() != node2)
fail_if(edge.get_bottom_node() != node)
fail_if(edge.get_right_node() is not None)
fail_if(edge.get_left_node() is not None)
fail_if(edge.is_horizontal())
fail_if(not edge.is_vertical())
fail_if(node.get_neighbour_edge(EdgeDirection('N')) != edge)
fail_if(node.get_neighbour_node(EdgeDirection('N')) != node2)
try:
node.get_neighbour_edge('N')
pytest.fail()
except ValueError:
pass
try:
node.get_neighbour_node('N')
pytest.fail()
except ValueError:
pass
try:
Edge(edge_type='N', node_a=node, node_b=node)
pytest.fail()
except ValueError:
pass
try:
str(edge)
except Exception:
pytest.fail()
fail_if(abs(edge) != 1.0)
def test_floor_plan_nodes():
name = 'test'
status = FloorPlanStatus.start
fp = FloorPlan(name, status)
vector_orig = Vector(0, 0)
node = Node(vector_orig)
fp.add_node(node)
vector2 = Vector(0, 1)
try:
fp.add_node(vector2)
pytest.fail()
except ValueError:
pass
fail_if(fp.nodes[str(vector_orig)] != node)
# can't add a duplicate node/vector location
fail_if(fp.add_node(node))
try:
fp.remove_node(Vector(0, 0))
pytest.fail()
except ValueError:
pass
fail_if(not fp.remove_node(node))
# doesn't exist
fail_if(fp.remove_node(Node(Vector(0, 100))))
fp.add_node(node)
fail_if(fp.get_node(vector_orig) is None)
fail_if(fp.get_node(Vector(0, 100)) is not None)
try:
fp.get_node((0, 0))
pytest.fail()
except ValueError:
pass
fail_if(not fp.node_exists(node))
fail_if(not fp.node_exists(vector_orig))
try:
fp.node_exists((0, 0))
pytest.fail()
except ValueError:
pass
_, exists = fp.nodes_exist([node])
fail_if(not exists)
_, exists = fp.nodes_exist([node, vector_orig])
fail_if(not exists)
_, exists = fp.nodes_exist([node, Vector(0, 100)])
fail_if(exists)
try:
fp.nodes_exist([node, (0, 0)])
pytest.fail()
except ValueError:
pass
try:
fp.nodes_exist((0, 0))
pytest.fail()
except ValueError:
pass
try:
fp.nodes_exist(node)
pytest.fail()
except ValueError:
pass
# test update
node, ret = fp.update_node_vector(node, vector2)
fail_if(not ret)
fail_if(node.vector == vector_orig)
fail_if(node.vector != vector2)
fail_if(str(vector_orig) in fp.nodes)
fail_if(not str(vector2) in fp.nodes)
fail_if(fp.get_node(vector2) != node)
fail_if(fp.nodes[str(vector2)].vector != vector2)
fail_if(len(fp.nodes) != 1)
try:
fp.update_node_vector(node, (0, 0))
pytest.fail()
except ValueError:
pass
fail_if(fp.update_node_vector(Node(Vector(0, 100)), Vector(0, 300)))
def test_floor_plan_edges():
name = 'test'
status = FloorPlanStatus.start
fp = FloorPlan(name, status)
node = Node(Vector(0, 1))
node_b = Node(Vector(0, 2))
fp.add_node(node)
fp.add_node(node_b)
edge = Edge(edge_type=EdgeType.wall, node_a=node, node_b=node_b)
node.add_edge(edge)
node_b.add_edge(edge)
fail_if(fp.get_node(Vector(0, 1)).neighbour_edges[0] != edge)
fail_if(fp.get_node(Vector(0, 1)).neighbour_edges[0].upper_node != node_b)
fail_if(fp.get_node(Vector(0, 1)).neighbour_edges[0].bottom_node != node)
fp.add_edge(edge)
fail_if(fp.edges[f'{node}_{node.get_direction_to(node_b)}'] != edge)
fail_if(fp.edges[f'{node_b}_{node_b.get_direction_to(node)}'] != edge)
fail_if(fp.edges[str(edge)] != edge)
try:
fp.add_edge(0)
pytest.fail()
except ValueError:
pass
try:
fp.remove_edge(0)
pytest.fail()
except ValueError:
pass
fail_if(not fp.remove_edge(edge))
fp.add_edge(edge)
node_3 = Node(Vector(0, 10))
node_4 = Node(Vector(0, 30))
edge2 = Edge(EdgeType.wall, node_a=node_3, node_b=node_4)
fail_if(fp.remove_edge(edge2))
fp.add_edge(edge2)
fail_if(len(fp.edges) != 2)
fail_if(fp.edges[f'{node}_{node.get_direction_to(node_b)}'] != edge)
fail_if(fp.edges[f'{node_b}_{node_b.get_direction_to(node)}'] != edge)
fail_if(fp.edges[str(edge)] != edge)
fail_if(fp.edges[f'{node_3}_{node_3.get_direction_to(node_4)}'] == edge)
fail_if(fp.edges[f'{node_3}_{node_3.get_direction_to(node_4)}'] != edge2)
fail_if(fp.edges[f'{node_4}_{node_4.get_direction_to(node_3)}'] != edge2)
fail_if(fp.edges[str(edge2)] != edge2)
fail_if(not fp.edge_exists(edge))
fail_if(not fp.edge_exists(edge2))
edge3 = Edge(EdgeType.wall, node_a=node, node_b=node_4)
fail_if(fp.edge_exists(edge3))
try:
fp.edge_exists(0)
pytest.fail()
except ValueError:
pass
_, ret = fp.edges_exist([edge, edge2])
fail_if(not ret)
edge_ret, ret = fp.edges_exist([edge, edge2, edge3])
fail_if(ret)
fail_if(edge_ret != edge3)
try:
_, ret = fp.edges_exist([edge, edge2, 0])
pytest.fail()
except ValueError:
pass
try:
_, ret = fp.edges_exist(edge)
pytest.fail()
except ValueError:
pass
node_4 = Node(Vector(0, -10))
edge = Edge(EdgeType.wall, node_a=node, node_b=node_4)
fail_if(node.neighbour_edges[node.get_direction_to(node_4).integer_value]
is not None)
fp.add_edge(edge)
node.add_edge(edge)
node_4.add_edge(edge)
fail_if(node.neighbour_edges[node.get_direction_to(
node_4).integer_value] is None)
print(fp.nodes)
fail_if(fp.nodes[str(node.vector)].neighbour_edges[
node.get_direction_to(node_4).integer_value] != edge)