def test_update_position_and_cleanStandardRobot(self):
"Test StandardRobot.update_position_and_clean"
r = ps3.EmptyRoom(3, 5, 1)
robot = ps3.StandardRobot(r, 1.0, 1)
robot.set_robot_position(test.Position(1.5, 2.5))
robot.set_robot_direction(90)
robot.update_position_and_clean()
self.assertEquals(robot.get_robot_direction(), 90,
"Robot direction is updated incorrectly by update_position_and_clean: expected %r, got %r" %
(90, robot.get_robot_direction()))
# check if robot position is valid
robotPos = robot.get_robot_position()
correctPos = test.Position(2.5, 2.5)
self.assertTrue(robotPos.get_x() == correctPos.get_x() and robotPos.get_y() == correctPos.get_y(),
"Robot position is updated incorrectly by update_position_and_clean: expected %r, got %r" %
(ps3.Position(2.5, 2.5), robot.get_robot_position()))
self.assertTrue(2>=r.get_num_cleaned_tiles() >= 1,
"update_position_and_clean should have marked one or two tiles as clean")
self.assertTrue(r.is_tile_cleaned(1, 2) or r.is_tile_cleaned(2, 2),
"update_position_and_clean should have marked either (1, 2) or (2, 2) as clean")
# Simulate a lot of time passing...
for i in range(20):
robot.update_position_and_clean()
self.assertTrue(r.is_position_in_room(robot.get_robot_position()),
"Robot position %r is not in room!" % (robot.get_robot_position(),))
self.assertNotEquals(robot.get_robot_direction(), 90,
"Robot direction should have been changed in update_position_and_clean")
self.assertTrue(r.get_num_cleaned_tiles() >= 1,
"update_position_and_clean should have marked another tile as clean")
def test_get_num_cleaned_tiles_OverClean(self):
"Test cleaning already clean tiles does not increment counter"
width, height, dirt_amount = (3, 4, 2)
room = ps3.RectangularRoom(width, height, dirt_amount)
# clean all of the tiles in the room
for x, y in xyrange(width, height):
room.clean_tile_at_position(test.Position(x + random.random(), y + random.random()), dirt_amount)
for x, y in xyrange(width, height):
room.clean_tile_at_position(test.Position(x + random.random(), y + random.random()), 1)
num_cleaned = room.get_num_cleaned_tiles()
self.assertEqual(num_cleaned, width * height,
"Number of clean tiles is incorrect: re-cleaning cleaned tiles must not increase number of cleaned tiles"
)
def test_get_num_cleaned_tiles_FullIn2(self):
"""Test get_num_cleaned_tiles for cleaning subset of room in two calls"""
width, height, dirt_amount = (3, 4, 2)
room = ps3.RectangularRoom(width, height, dirt_amount)
cleaned_tiles = 0
# Clean some tiles
for x, y in xyrange(width-1, height-1):
room.clean_tile_at_position(test.Position(x + random.random(), y + random.random()), 1)
room.clean_tile_at_position(test.Position(x + random.random(), y + random.random()), 1)
cleaned_tiles += 1
num_cleaned = room.get_num_cleaned_tiles()
self.assertEqual(num_cleaned, cleaned_tiles,
"Number of clean tiles is incorrect: expected {}, got {}".format(cleaned_tiles, num_cleaned)
)
def test_unimplemented_methods(self):
"""Test if student implemented methods in RectangularRoom abstract class that should not be implemented"""
room = ps3.RectangularRoom(2,2,1)
self.assertRaises(NotImplementedError, room.get_num_tiles)
pos = test.Position(1,1)
self.assertRaises(NotImplementedError, room.is_position_valid, pos)
self.assertRaises(NotImplementedError, room.get_random_position)
def test_is_position_valid(self):
""" Test is_position_valid
"""
for trial in range(5):
width, height, dirt_amount = (3, 4, 2)
room = ps3.FurnishedRoom(width, height, dirt_amount)
room.add_furniture_to_room()
sol_room = test.FurnishedRoom(width, height, dirt_amount)
sol_room.furniture_tiles = room.furniture_tiles
for x in [
0.0,
-0.1,
width - 0.1,
width,
width + 0.1,
room.furniture_tiles[0][0] + 0.3,
]:
for y in [
0.0,
-0.1,
height - 0.1,
height,
height + 0.1,
room.furniture_tiles[0][1] + 0.3,
]:
pos = test.Position(x, y)
self.assertEqual(
sol_room.is_position_valid(pos),
room.is_position_valid(pos),
"student code and solution code disagree on whether position is valid:" + str(pos),
)
def test_clean_tile_at_position_ZeroToZero(self):
""" Test if clean_tile_at_position removes all dirt"""
width, height, dirt_amount = (3, 4, 0)
room = ps3.RectangularRoom(width, height, dirt_amount)
# Clean the tiles and confirm they are marked as clean
for x, y in xyrange(width, height):
room.clean_tile_at_position(test.Position(x + random.random(), y + random.random()), 1)
# using random.random in case there is any issue with specific parts of a tile
for x, y in xyrange(width, height):
self.assertTrue(room.is_tile_cleaned(x, y),
"Clean tile {} was marked clean, no negative dirt allowed".format((x, y))
)
def test_is_position_in_room(self):
"Test is_position_in_room"
width, height, dirt_amount = (3, 4, 2)
room = ps3.RectangularRoom(width, height, dirt_amount)
solution_room = test.RectangularRoom(width, height, dirt_amount)
for x in [0.0, -0.1, width - 0.1, width, width + 0.1]:
for y in [0.0, -0.1, height - 0.1, height, height + 0.1]:
pos = test.Position(x, y)
self.assertEquals(solution_room.is_position_in_room(pos),room.is_position_in_room(pos),
"position {},{} is incorrect: expected {}, got {}".format(x, y, solution_room.is_position_in_room(pos), room.is_position_in_room(pos))
)
def test_is_position_valid(self):
""" Test is_position_valid
this should be refactored as it's mostly a copy of is_position_in_room code
"""
width, height, dirt_amount = (3, 4, 2)
room = ps3.EmptyRoom(width, height, dirt_amount)
solution_room = test.EmptyRoom(width, height, dirt_amount)
for x in [0.0, -0.1, width - 0.1, width, width + 0.1]:
for y in [0.0, -0.1, height - 0.1, height, height + 0.1]:
pos = test.Position(x, y)
self.assertEquals(solution_room.is_position_valid(pos), room.is_position_valid(pos),
"student code and solution code disagree on whether position is valid"
)
def test_is_position_furnished(self):
""" test_is_position_furnished """
for trial in range(5):
width, height, dirt_amount = (random.randint(2, 8), random.randint(2, 8), 1)
# create room using student's class, set furniture tiles for solution class
room = ps3.FurnishedRoom(width, height, dirt_amount)
room.add_furniture_to_room()
sol_room = test.FurnishedRoom(width, height, dirt_amount)
# this relies on knowing the underlying details of the class
sol_room.furniture_tiles = room.furniture_tiles
for x,y in xyrange(width,height):
pos = test.Position(x + random.random(), y + random.random())
self.assertEquals(room.is_position_furnished(pos),sol_room.is_position_furnished(pos),
"student code and solution code disagree on whether position is furnished"
)
