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_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_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.assertEqual(
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_getset_robot_direction(self): #TODO - shouldn't need it
"""Test get_robot_direction and set_robot_direction"""
# instantiate RectangularRoom from solutions for testing
width, height, dirt_amount = (3, 4, 2)
solution_room = ps3.RectangularRoom(width, height, dirt_amount)
robots = [ps3.Robot(solution_room, 1.0, 1) for i in range(5)]
directions = [1, 333, 105, 75, 74.3]
for dir_index, robot in enumerate(robots):
robot.set_robot_direction(directions[dir_index])
for dir_index, robot in enumerate(robots):
robot_dir = robot.get_robot_direction()
self.assertEqual(robot_dir, directions[dir_index],
"Robot direction set or retrieved incorrectly: expected {}, got {}".format(directions[dir_index], robot_dir)
)
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_update_position_and_cleanStandardRobot(self):
"Test StandardRobot.update_position_and_clean"
r = ps3.RectangularRoom(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.assertEqual(
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.assertNotEqual(
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 createRoomAndRobots(self, num_robots):
r = ps3.RectangularRoom(5, 7, 1)
robots = [ps3.StandardRobot(r, 1.0, 1) for i in range(num_robots)]
return r, robots
import unittest
import ps3
import random
print('Creating 5x5 room')
room = ps3.RectangularRoom(5, 5, 20)
print('get_dirt_amopunt(1,3)', room.get_dirt_amount(1, 3))
print('get_num_cleaned_tiles', room.get_num_cleaned_tiles())
print('is_tile_cleaned(1,3)', room.is_tile_cleaned(1, 3))
botpos = ps3.Position(1, 3)
room.clean_tile_at_position(botpos, 15)
print('1,3 after 15 cleaning (5)', room.is_tile_cleaned(1, 3),
room.get_dirt_amount(1, 3))
room.clean_tile_at_position(botpos, 5)
print('1,3 after 5 more cleaning (0)', room.is_tile_cleaned(1, 3))
room.clean_tile_at_position(botpos, 5)
print('1,3 after 5 more cleaning (-5)', room.is_tile_cleaned(1, 3))
# create robot
room = ps3.EmptyRoom(5, 5, 20)
for i in range(0, 15):
helper = ps3.Robot(room, 1, 1)
print(str(helper), str(helper.get_robot_true_position()))
upperboundscheck = 0
normal_check = 0
err_check = 0
count = 0
err_list = []
while count < 1000:
count += 1
helper = ps3.Robot(room, 1, 1)
def test_unimplemented_methods(self): #TODO - shouldn't need it
"""Test if student implemented methods in Robot abstract class that should not be implemented"""
room = ps3.RectangularRoom(2,2,1)
robot = ps3.Robot(room,1,1)
self.assertRaises(NotImplementedError, robot.update_position_and_clean)
