def test_get_random_position(self):
"""Test get_random_position
checks for distribution of positions and validity of positions
"""
width, height, dirt_amount = (5, 10, 1)
room = ps3.EmptyRoom(width, height, dirt_amount)
sol_room = ps3.EmptyRoom(width, height, dirt_amount)
freq_buckets = {}
for i in range(50000):
pos = room.get_random_position()
# confirm from test that this is a valid position
self.assertTrue(sol_room.is_position_valid(pos))
try:
x, y = pos.get_x(), pos.get_y()
except AttributeError:
self.fail(
"get_random_position returned {} which is not a Position".
format(pos))
self.assertTrue(
0 <= x < width and 0 <= y < height,
"get_random_position returned {} which is not in [0, {}), [0, {})"
.format(pos, width, height))
x0, y0 = int(x), int(y)
freq_buckets[(x0, y0)] = freq_buckets.get((x0, y0), 0) + 1
for t in xyrange(width, height):
num_in_bucket = freq_buckets.get(t, 0)
self.assertTrue(
# This is a 99.7% confidence interval for a uniform
# distribution. Fail if the total of any bucket falls outside
# this range.
865 < num_in_bucket < 1135,
"The distribution of positions from get_random_position "
"looks incorrect (it should be uniform)")
def test_get_num_tiles(self):
""" test get_num_tiles method"""
for i in range(10):
width, height, dirt_amount = (random.randint(1,10), random.randint(1,10), 1)
room_num_tiles = ps3.EmptyRoom(width, height, dirt_amount).get_num_tiles()
sol_room_tiles = ps3.EmptyRoom(width, height, dirt_amount).get_num_tiles()
self.assertEquals(room_num_tiles, sol_room_tiles,
"student code number of room tiles = {}, not equal to solution code num tiles {}".format(room_num_tiles, sol_room_tiles)
)
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 = ps3.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 = ps3.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_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 createRoomAndRobots(num_robots):
# Create common room
room = ps3.EmptyRoom(5, 7, 1)
# Create robots
speed = 1.0
capacity = 1
robots = [
ps3.StandardRobot(room, speed, capacity) for i in range(num_robots)
]
return room, robots
"Test strict inequalities in random positions for the EmptyRoom and StandardRobot"
def test_getset_robot_direction(self):
"""Test get_robot_direction and set_robot_direction"""
# instantiate EmptyRoom from solutions for testing
width, height, dirt_amount = (3, 4, 2)
solution_room = ps3.EmptyRoom(width, height, dirt_amount)
robots = [ps3.Robot(solution_room, 1.0, 1) for i in range(4)]
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.assertEquals(robot_dir, directions[dir_index],
"Robot direction set or retrieved incorrectly: expected {}, got {}".format(
directions[dir_index], robot_dir)
)
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)
x, y = helper.get_robot_true_position()
if x > room.width or y > room.height:
#print(str(helper), str(helper.get_robot_true_position()))
upperboundscheck += 1
def createRoomAndRobots(self, num_robots):
r = ps3.EmptyRoom(5, 7, 1)
robots = [ps3.StandardRobot(r, 1.0, 1) for i in range(num_robots)]
return r, robots
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Created on Mon Jun 15 18:32:10 2020
@author: Sharad
"""
import ps3
width, height, dirt_amount = (5, 10, 1)
room = ps3.EmptyRoom(width, height, dirt_amount)
freq_buckets = {}
for i in range(10000):
pos = room.get_random_position()
x, y = pos.get_x(), pos.get_y()
x0, y0 = int(x), int(y)
freq_buckets[(x0, y0)] = freq_buckets.get((x0, y0), 0) + 1
if x0 > 4 or y0 >4:
print('haha')
def test_unimplemented_methods(self):
"""Test if student implemented methods in Robot abstract class that should not be implemented"""
room = ps3.EmptyRoom(2, 2, 1)
robot = ps3.Robot(room, 1, 1)
self.assertRaises(NotImplementedError, robot.update_position_and_clean)
