class TestStatus(unittest.TestCase):
def setUp(self):
rospy.init_node('test_status')
self.robot = Robot('robot_0', 1, 0.5, 1, 1, pi/2)
self.robot1 = Robot('robot_1', 1, 0.5, 5, 5, pi/2)
# Execute robots a few times to allow statuses to become existant.
for i in range(0, 10):
self.robot.execute()
self.robot1.execute()
time.sleep(0.1)
def test_init(self):
"""Checks if status exists after initialising."""
self.assertIsNotNone(self.robot.curr_robot_messages)
self.assertIsNotNone(self.robot.curr_robot_messages[1])
self.assertIsNotNone(self.robot.curr_robot_messages[1].robot_id)
def test_robot_id(self):
"""Tests that the robots are publishing the correct id"""
self.assertEquals(self.robot.curr_robot_messages[1].robot_id, 'robot_1')
def test_position(self):
"""Tests whether the robots are publishing the correct position"""
self.assertAlmostEqual(self.robot.curr_robot_messages[1].x, 5.0, places=2)
def to_string(self):
return "test movement"
class TestStatus(unittest.TestCase):
def setUp(self):
rospy.init_node('test_status')
self.robot = Robot('robot_0', 1, 0.5, 1, 1, pi / 2)
self.robot1 = Robot('robot_1', 1, 0.5, 5, 5, pi / 2)
# Execute robots a few times to allow statuses to become existant.
for i in range(0, 10):
self.robot.execute()
self.robot1.execute()
time.sleep(0.1)
def test_init(self):
"""Checks if status exists after initialising."""
self.assertIsNotNone(self.robot.curr_robot_messages)
self.assertIsNotNone(self.robot.curr_robot_messages[1])
self.assertIsNotNone(self.robot.curr_robot_messages[1].robot_id)
def test_robot_id(self):
"""Tests that the robots are publishing the correct id"""
self.assertEquals(self.robot.curr_robot_messages[1].robot_id,
'robot_1')
def test_position(self):
"""Tests whether the robots are publishing the correct position"""
self.assertAlmostEqual(self.robot.curr_robot_messages[1].x,
5.0,
places=2)
def to_string(self):
return "test movement"
def __init__(self, robot_id, top_speed, angular_top_speed, x_offset,
y_offset, theta_offset):
Robot.__init__(self, robot_id, top_speed, angular_top_speed, x_offset,
y_offset, theta_offset)
self.type = type(self).__name__
self.command = None
rospy.Subscriber("move_command", String, self.cmd_handler)
def create_fleet(self):
robot1 = Robot("Bumblebee")
robot2 = Robot("Optimus Prime")
robot3 = Robot("Grimlock")
self.robots.append(robot1)
self.robots.append(robot2)
self.robots.append(robot3)
def __init__(self, robot_id, top_speed, angular_top_speed, x_offset, y_offset, theta_offset):
Robot.__init__(self, robot_id, top_speed, angular_top_speed, x_offset, y_offset, theta_offset)
#define max/min coordinates for orchard space
boundaries = locations.get_orchard_boundaries()
self.maxX = boundaries["max_x"]
self.maxY = boundaries["max_y"]
self.minX = boundaries["min_x"]
self.minY = boundaries["min_y"]
self.has_bin = False
self.type = type(self).__name__
# Unique variables for picker robots
# self.picker_dict = dict()
self.current_bin_x = 0
self.current_bin_y = 0
self.fruit_count = 0
self.has_finished = False
empty_response_pub = rospy.Publisher('empty_response_topic', empty_response, queue_size=10)
def callback(data):
"""Execute method in response to "bin_status" message."""
if data.is_empty:
# Data used to calculate if it's the closest to the bin
rospy.loginfo("Bin call: " + data.bin_id + " %.1f %.1f" % (data.x, data.y))
self.current_bin_x = data.x
self.current_bin_y = data.y
# rospy.loginfo(len(self.picker_dict))
if self.is_closest() and not self.has_bin: # and not self.slave and not data.is_carried:
self.has_finished = False
current_bin = robot_storage.getRobotWithId(data.bin_id)
if current_bin.designated_picker == None:
self.has_bin = True
self.add_action(NavigateAction(self.current_bin_x, self.current_bin_y))
rospy.loginfo("P Robot: " + self.robot_id + " " + "Bin closest: " + data.bin_id)
msg = empty_response()
msg.robot_id = self.robot_id
msg.bin_id = data.bin_id
rospy.loginfo(self.robot_id + msg.robot_id + msg.bin_id + data.bin_id)
empty_response_pub.publish(msg)
rospy.loginfo("??????????????????////???????????????????")
def initiate_picking(data):
if data.robot_id == self.robot_id:
pickerx = robot_storage.getRobotWithId(data.robot_id)
self.x_start = self.position['x']
self.y_start = self.position['y']
self.add_action(NavigatePickAction(pickerx.position["x"], self.maxY + 5))
rospy.Subscriber("bin_status_topic", bin_status, callback)
# rospy.Subscriber("statuses", robot_status, picker_locations)
rospy.Subscriber("latched_to_picker", empty_response, initiate_picking)
def test_name_does_not_change_when_rebooted():
robot = Robot()
robot.start()
name1 = robot.name()
robot.stop()
robot.start()
name2 = robot.name()
assert name1 == name2
def __init__(self, robot_id, top_speed, angular_top_speed, x_offset, y_offset, theta_offset):
Robot.__init__(self, robot_id, top_speed, angular_top_speed, x_offset, y_offset, theta_offset)
self.counter = 0
boundaries = locations.get_wall_boundaries()
self.min_x = int(boundaries["min_x"])
self.max_x = int(boundaries["max_x"])
self.min_y = int(boundaries["min_y"])
self.max_y = int(boundaries["max_y"])
def __init__(self, robot_id, top_speed, angular_top_speed, x_offset, y_offset, theta_offset):
Robot.__init__(self, robot_id, top_speed, angular_top_speed, x_offset, y_offset, theta_offset)
self.type = type(self).__name__
# Unique booleans for Bin instance
self.slow_down_counter = 0
self.is_publishing = True
self.is_empty = True
self.is_carried = False
self.designated_picker = None
self.designated_carrier = None
self.master = None
self.should_face = None
self.empty_response_msg = empty_response()
self.bin_latch = rospy.Publisher('latched_to_picker', empty_response, queue_size=1)
# self.bin_full_latch = rospy.Publisher('latched_to_carrier', full_response, queue_size=1)
def id_response(data):
"""Execute method in response to an empty_response message."""
# rospy.loginfo("SDAFDFDSFDSAFDSAFDSAFDSAFDSAFSADFADSFSADF")
if data.bin_id == self.robot_id:
self.is_publishing = False
robot = robot_storage.getRobotWithId(data.robot_id)
if robot.type == "PickerRobot":
self.designated_picker = data.robot_id
elif robot.type == "CarrierRobot":
self.designated_carrier = data.robot_id
# rospy.loginfo(self.robot_id + " " + data.robot_id)
# self.is_carried = True
def mimic_now(data):
"""Execute method in response to a robot_status message"""
if not self.should_face and data.robot_id == self.designated_picker and not self.master:
if (data.x - 0.4) <= self.position['x'] <= (data.x + 0.4):
if (data.y - 0.4) <= self.position['y'] <= (data.y + 0.4):
picker = robot_storage.getRobotWithId(data.robot_id)
# rospy.loginfo(data.robot_id)
self.latch(picker)
self.empty_response_msg.robot_id = data.robot_id
self.empty_response_msg.bin_id = self.robot_id
if not self.should_face and data.robot_id == self.designated_carrier and not self.master:
if (data.x - 0.4) <= self.position['x'] <= (data.x + 0.4):
if (data.y - 0.4) <= self.position['y'] <= (data.y + 0.4):
carrier = robot_storage.getRobotWithId(data.robot_id)
# rospy.loginfo(data.robot_id)
self.latch(carrier)
self.empty_response_msg.robot_id = data.robot_id
self.empty_response_msg.bin_id = self.robot_id
# Suscribe to topic to recieve response from pickers.
rospy.Subscriber("empty_response_topic", empty_response, id_response)
rospy.Subscriber("statuses", robot_status, mimic_now)
def setUp(self):
rospy.init_node('test_status')
self.robot = Robot('robot_0', 1, 0.5, 1, 1, pi/2)
self.robot1 = Robot('robot_1', 1, 0.5, 5, 5, pi/2)
# Execute robots a few times to allow statuses to become existant.
for i in range(0, 10):
self.robot.execute()
self.robot1.execute()
time.sleep(0.1)
def setUp(self):
rospy.init_node('test_status')
self.robot = Robot('robot_0', 1, 0.5, 1, 1, pi / 2)
self.robot1 = Robot('robot_1', 1, 0.5, 5, 5, pi / 2)
# Execute robots a few times to allow statuses to become existant.
for i in range(0, 10):
self.robot.execute()
self.robot1.execute()
time.sleep(0.1)
def __init__(self, robot_id, top_speed, angular_top_speed, x_offset,
y_offset, theta_offset):
Robot.__init__(self, robot_id, top_speed, angular_top_speed, x_offset,
y_offset, theta_offset)
self.counter = 0
boundaries = locations.get_wall_boundaries()
self.min_x = int(boundaries["min_x"])
self.max_x = int(boundaries["max_x"])
self.min_y = int(boundaries["min_y"])
self.max_y = int(boundaries["max_y"])
def __init__(self, robot_id, top_speed, angular_top_speed, x_offset, y_offset, theta_offset):
Robot.__init__(self, robot_id, top_speed, angular_top_speed, x_offset, y_offset, theta_offset)
self.type = type(self).__name__
# Unique variables for carrier robots
self.carrier_dict = dict()
self.current_bin_x = 0
self.current_bin_y = 0
self.has_bin = False
self.counter = 0
self.going_towards = None
empty_response_pub = rospy.Publisher('empty_response_topic', empty_response, queue_size=10)
def callback(data):
if not data.is_empty:
self.current_bin_x = data.x
self.current_bin_y = data.y
current_bin = robot_storage.getRobotWithId(data.bin_id)
if self.is_closest() and not self.has_bin and not current_bin.designated_carrier:
self.going_towards = data.bin_id
current_bin.designated_carrier = self.robot_id
rospy.loginfo("Carrier bot coming towards bin " + data.bin_id + " at " + str(self.current_bin_x) + ", " + str(self.current_bin_y))
self.has_bin = True
self.add_action(NavigateAction(self.current_bin_x, self.current_bin_y))
rospy.loginfo("P Robot: " + self.robot_id + " " + "Bin closest: " + data.bin_id)
msg = empty_response()
msg.robot_id = self.robot_id
msg.bin_id = data.bin_id
empty_response_pub.publish(msg)
def bin_carrying(data):
if data.robot_id == self.robot_id:
rospy.loginfo("carrier " + self.robot_id + " going up to driveway")
carrierx = robot_storage.getRobotWithId(data.robot_id)
for i in range(0,3):
if not bin_locations[i]['occupied']:
bin_locations[i]['occupied'] = True
self.add_action(NavigateAction(bin_locations[i]['x'], bin_locations[i]['y']))
self.add_action(UnlatchAction(self.slave))
break
if i is 3:
# Locations should never be all full, but who knows?
bin_locations[i]['occupied'] = True
self.add_action(NavigateAction(bin_locations[i]['x'], bin_locations[i]['y']))
rospy.Subscriber("latched_to_picker", empty_response, bin_carrying)
rospy.Subscriber("bin_status_topic", bin_status, callback)
def __init__(self, robot_id, top_speed, angular_top_speed, x_offset, y_offset, theta_offset):
Robot.__init__(self, robot_id, top_speed, angular_top_speed, x_offset, y_offset, theta_offset)
# Set boundaries
boundaries = locations.get_wall_boundaries()
self.min_x = boundaries["min_x"]
self.max_x = boundaries["max_x"]
self.min_y = boundaries["min_y"]
self.max_y = boundaries["max_y"]
# Instance variables
self.was_blocked = False
self.old_queue = []
self.d = 7
class RobotTests(unittest.TestCase):
def setUp(self):
self.mega_man = Robot("Mega Man", battery=50)
def test_charge(self):
# make new robot each time
# mega_man = Robot("Mega Man", battery=50) # Use setUp to make robot once
self.mega_man.charge()
self.assertEqual(self.mega_man.battery, 100)
def test_say_name(self):
# make new robot each time
# mega_man = Robot("Mega Man", battery=50) # Use setUp to make robot once
self.assertEqual(self.mega_man.say_name(),
"BEEP BOOP BEEP BOOP. I AM MEGA MAN")
self.assertEqual(self.mega_man.battery, 49)
def __init__(self, robot_id, top_speed, angular_top_speed, x_offset, y_offset, theta_offset):
Robot.__init__(self, robot_id, top_speed, angular_top_speed, x_offset, y_offset, theta_offset)
# Instance variables
self.type = type(self).__name__
self.robot_dict = dict()
self.currently_targeting = False
self.dict_index = -1
self.counter = 0
self.retreat = False
def robot_locations(data):
"""Stores picker and carrier data from the statuses topic"""
if data.robot_type == "PickerRobot" or data.robot_type == "CarrierRobot":
self.robot_dict[data.robot_id] = data
rospy.Subscriber("statuses", robot_status, robot_locations)
def test_robot_initial_position():
''' test all strings for bearings will work '''
bearings = ['north', 'south', 'east', 'west']
for b in bearings:
robot = Robot(1, 2, b)
assert robot.x == 1 and robot.y == 2 and robot.bearing == b
def __init__(self, robot_id, top_speed, angular_top_speed, x_offset,
y_offset, theta_offset):
Robot.__init__(self, robot_id, top_speed, angular_top_speed, x_offset,
y_offset, theta_offset)
# Set boundaries
boundaries = locations.get_wall_boundaries()
self.min_x = boundaries["min_x"]
self.max_x = boundaries["max_x"]
self.min_y = boundaries["min_y"]
self.max_y = boundaries["max_y"]
# Instance variables
self.was_blocked = False
self.old_queue = []
self.d = 7
def iniData(self, points, connections, first_point, robots):
if not robots:
robots = 1
self.first_point = first_point
self.points = points
self.points = [(x.x(), x.y()) for x in self.points]
self.connections = connections
self.robots = [Robot((first_point.x(), first_point.y())) for x in range(int(robots))]
def robo_turn(self):
self.show_robo_opponent_options()
input("Select opponent to attack: <1> , <2> , <3>.")
if input == 1:
Robot.attack(dinosaur=d1)
elif input == 2:
Robot.attack(dinosaur=d2)
elif input == 3:
Robot.attack(dinosaur=d3)
else:
input("Please select <1> , <2> or <3>.")
def setUp(self):
rospy.init_node('test_robot')
self.robot = Robot('robot_0', 1, 0.5, 1, 1, pi / 2)
for i in range(0, 20):
self.robot.execute()
class TestRobot(unittest.TestCase):
def setUp(self):
rospy.init_node('test_robot')
self.robot = Robot('robot_0', 1, 0.5, 1, 1, pi / 2)
for i in range(0, 20):
self.robot.execute()
def test_init(self):
"""Checks if subscribed information has been received."""
self.assertIsNot(self.robot.odometry, None)
self.assertIsNot(self.robot.leftLaser, None)
self.assertIsNot(self.robot.rightLaser, None)
def test_forward(self):
"""Checks if forward sets the velocity to its top speed."""
self.robot.forward()
self.assertEqual(self.robot.velocity.linear.x, 1)
def test_stop(self):
"""Checks if stop sets the linear and angular velocity to 0."""
self.robot.forward()
self.robot.start_rotate()
self.robot.stop()
self.assertEqual(self.robot.velocity.linear.x, 0)
self.assertEqual(self.robot.velocity.angular.z, 0)
def test_set_angular_velocity(self):
"""Checks if angular velocity is set to the specified value."""
self.robot.set_angular_velocity(0.2)
self.assertEqual(self.robot.velocity.angular.z, 0.2)
def test_set_linear_velocity(self):
"""Checks if linear velocity is set to the specified value."""
self.robot.set_linear_velocity(0.7)
self.assertEqual(self.robot.velocity.linear.x, 0.7)
def test_start_rotate(self):
"""Checks if angular velocity is set to angular_top_speed
and rotation_executing is set to true."""
self.robot.start_rotate()
self.assertEqual(self.robot.velocity.angular.z, 0.5)
self.assertTrue(self.robot.rotation_executing)
def test_start_rotate_opposite(self):
"""Checks if angular velocity is set to angular_top_speed in the
negative direction and rotation_executing is set to true."""
self.robot.start_rotate_opposite()
self.assertEqual(self.robot.velocity.angular.z, -0.5)
self.assertTrue(self.robot.rotation_executing)
def test_stop_rotate(self):
"""Checks to see if angular velocity is set to 0 and
rotation_executing is set to false."""
self.robot.stop_rotate()
self.assertEqual(self.robot.velocity.angular.z, 0)
self.assertFalse(self.robot.rotation_executing)
from robots import Robot
r1 = Robot(4, 10, 'est', 'Robert', 'Humanoide', 'En service')
print('r1 =', r1)
r2 = Robot(15, 7, 'sud', 'Juliette', 'Mobile', 'En service')
print('r2 =', r2)
r1.nom = "D2R2" # on a ajouté un nom à r1 mais r2 n'a pas de nom
def tourner_gauche(robot):
robot.direction = (robot.direction + 3) % 4
Robot.pivoter_gauche = tourner_gauche
r2.pivoter_gauche() # direction devient 'est'
print('r2 =', r2)
def test_can_create_a_robot(self):
orange = Robot()
# convert this laser reading to polar coordinate
distance=range_
angle=origin + num*increment
# get world coordinate of this laser reading
x=math.cos(angle+pose_theta)*distance
y=math.sin(angle+pose_theta)*distance
# and transform it to matrix index
i = int(self.position_in_map.x + x/self.granularity)
j = int(self.position_in_map.y + y/self.granularity)
# get path from robot position to each point on laser
path = Bresenham((self.position_in_map.x, self.position_in_map.y),
(i, j)).path
# set each point on path to free
for p in path:
self.map_cell_add_value(p[0], p[1], self._free)
# set the position for this laser reading as occupied
self.map_cell_add_value(i,j,self._occ)
if __name__ == '__main__':
from robots import Robot
robot = Robot()
ogm = OccupancyGridMap()
robot.start(ogm.update_map)
def setUp(self):
self.robot = Robot(COMPILER, SANDBOX)
self.make_file(IO_TEST_1_IN, """1 2 3 4 5\n""")
self.make_file(IO_TEST_1_OUT, """15 120\n""")
self.make_file(IO_TEST_2_IN, """0 1 2 3 4\n""")
self.make_file(IO_TEST_2_OUT, """10 0\n""")
def __init__(self, robot_id, top_speed, angular_top_speed, x_offset,
y_offset, theta_offset):
Robot.__init__(self, robot_id, top_speed, angular_top_speed, x_offset,
y_offset, theta_offset)
#define max/min coordinates for orchard space
boundaries = locations.get_orchard_boundaries()
self.maxX = boundaries["max_x"]
self.maxY = boundaries["max_y"]
self.minX = boundaries["min_x"]
self.minY = boundaries["min_y"]
self.has_bin = False
self.type = type(self).__name__
# Unique variables for picker robots
# self.picker_dict = dict()
self.current_bin_x = 0
self.current_bin_y = 0
self.fruit_count = 0
self.has_finished = False
empty_response_pub = rospy.Publisher('empty_response_topic',
empty_response,
queue_size=10)
def callback(data):
"""Execute method in response to "bin_status" message."""
if data.is_empty:
# Data used to calculate if it's the closest to the bin
rospy.loginfo("Bin call: " + data.bin_id + " %.1f %.1f" %
(data.x, data.y))
self.current_bin_x = data.x
self.current_bin_y = data.y
# rospy.loginfo(len(self.picker_dict))
if self.is_closest(
) and not self.has_bin: # and not self.slave and not data.is_carried:
self.has_finished = False
current_bin = robot_storage.getRobotWithId(data.bin_id)
if current_bin.designated_picker == None:
self.has_bin = True
self.add_action(
NavigateAction(self.current_bin_x,
self.current_bin_y))
rospy.loginfo("P Robot: " + self.robot_id + " " +
"Bin closest: " + data.bin_id)
msg = empty_response()
msg.robot_id = self.robot_id
msg.bin_id = data.bin_id
rospy.loginfo(self.robot_id + msg.robot_id +
msg.bin_id + data.bin_id)
empty_response_pub.publish(msg)
rospy.loginfo(
"??????????????????////???????????????????")
def initiate_picking(data):
if data.robot_id == self.robot_id:
pickerx = robot_storage.getRobotWithId(data.robot_id)
self.x_start = self.position['x']
self.y_start = self.position['y']
self.add_action(
NavigatePickAction(pickerx.position["x"], self.maxY + 5))
rospy.Subscriber("bin_status_topic", bin_status, callback)
# rospy.Subscriber("statuses", robot_status, picker_locations)
rospy.Subscriber("latched_to_picker", empty_response, initiate_picking)
def setUp(self):
self.mega_man = Robot("Mega Man", battery=50)
def __init__(self, robot_id, top_speed, angular_top_speed, x_offset, y_offset, theta_offset):
Robot.__init__(self, robot_id, top_speed, angular_top_speed, x_offset, y_offset, theta_offset)
self.type = type(self).__name__
self.command = None
rospy.Subscriber("move_command", String, self.cmd_handler)
def test_Robot():
r = Robot("Marvin", "Nürnberg")
assert r.name == "Marvin"
assert r.city == "Nürnberg"
def test_robot_forward_should_change_robot_position_to_next_position(self):
robot = Robot()
robot.forward()
self.assertEqual(2, robot.position)
def test_robot_back_should_change_robot_position_to_after_position(self):
robot = Robot()
robot.position = 2
robot.back()
self.assertEqual(1, robot.position)
def test_robot_can_starts_at_button_1(self):
self.assertEqual(1, Robot().position)
def setUp(self):
rospy.init_node('test_move_action')
self.robot = Robot('robot_0', 1, 0.5, 1, 1, pi / 2)
self.robot1 = Robot('robot_0', 1, 0.5, 0, 0, pi / 2)
from herd import Herd
from battlefield import Battlefield
from weapons import Weapons
import ctypes
import random
if __name__ == '__main__':
#Battlefield
battlefield = Battlefield()
#Weapons
weapons = Weapons()
# Robots
robot_wally = Robot("Wall-E")
robot_wally.power_level = 100
robot_wally.attack_power = 60
# weapons.choose_weapon(robot_wally)
robot_megaman = Robot("Megaman")
robot_megaman.power_level = 110
robot_megaman.attack_power = 100
# weapons.choose_weapon(robot_megaman)
robot_marvin = Robot("Marvin")
robot_marvin.power_level = 120
robot_marvin.attack_power = 70
# weapons.choose_weapon(robot_marvin)
#Dinos
#! /usr/bin/env python3
from robots import Robot
x = Robot("Marvin", "Nürnberg")
x.say_hi()
y = Robot("Hen", "Nürnberg")
y.say_hi()
try:
y.name = "Henry"
except NameError as e:
print(e)
try:
z = Robot("Hans", "München")
except NameError as e:
print(e)
w = x + y
w.say_hi()
print(w)
print(repr(w))
w2 = eval(repr(w))
w2.say_hi()
print(w == w2)
class RobotTest(unittest.TestCase):
def __init__(self, *args, **kwargs):
if not os.path.isdir(SANDBOX):
os.mkdir(SANDBOX)
super(RobotTest, self).__init__(*args, **kwargs)
def setUp(self):
self.robot = Robot(COMPILER, SANDBOX)
self.make_file(IO_TEST_1_IN, """1 2 3 4 5\n""")
self.make_file(IO_TEST_1_OUT, """15 120\n""")
self.make_file(IO_TEST_2_IN, """0 1 2 3 4\n""")
self.make_file(IO_TEST_2_OUT, """10 0\n""")
def make_file(self, path, content):
with open(path, 'w') as new:
new.write(content)
def test_compile_with_no_source(self):
with open(DEVNULL, 'w') as devnull:
self.assertRaises(ValueError, self.robot.compile, NO_SOURCE, EXECUTABLE, stdout=devnull, stderr=devnull)
def test_compile_with_bad_executable(self):
self.make_file(SOURCE, OK_SOURCE)
with open(DEVNULL, 'w') as devnull:
self.assertRaises(ValueError, self.robot.compile, SOURCE, BAD_EXECUTABLE, stdout=devnull, stderr=devnull)
def test_evaluate_with_no_executable(self):
self.make_file(SOURCE, CE_SOURCE)
with open(DEVNULL, 'w') as devnull:
self.robot.compile([SOURCE], EXECUTABLE, stdout=devnull, stderr=devnull)
self.assertRaises(ValueError, self.robot.evaluate, EXECUTABLE, INPUT, OUTPUT, stdout=devnull, stderr=devnull)
def test_evaluate_no_input(self):
self.make_file(SOURCE, OK_SOURCE)
with open(DEVNULL, 'w') as devnull, open(EXECUTABLE, 'w'):
self.assertRaises(ValueError, self.robot.evaluate, EXECUTABLE, NO_INPUT, OUTPUT, stdout=devnull, stderr=devnull)
def test_diff_with_equal_output(self):
test_output = """3\n1 2 3\n"""
user_output = """3 1 2 3\n"""
self.make_file(TEST_OUTPUT, test_output)
self.make_file(OUTPUT, user_output)
self.assertFalse(self.robot.diff(TEST_OUTPUT, OUTPUT))
def test_diff_with_non_equal_output(self):
test_output = """4 1 2 3 4\n"""
user_output = """3 1 2 3\n"""
self.make_file(TEST_OUTPUT, test_output)
self.make_file(OUTPUT, user_output)
self.assertTrue(self.robot.diff(TEST_OUTPUT, OUTPUT))
def test_diff_with_equal_float_output(self):
test_output = """12.9999999 9.9999999\n"""
user_output = """13 10\n"""
self.make_file(TEST_OUTPUT, test_output)
self.make_file(OUTPUT, user_output)
self.assertFalse(self.robot.diff(TEST_OUTPUT, OUTPUT))
def test_diff_with_non_equal_float_output(self):
test_output = """12.99999 9.99999\n"""
user_output = """13.0 10.1\n"""
self.make_file(TEST_OUTPUT, test_output)
self.make_file(OUTPUT, user_output)
self.assertTrue(self.robot.diff(TEST_OUTPUT, OUTPUT))
def test_run_with_ce_source(self):
self.make_file(SOURCE, CE_SOURCE)
test_cases = {1: dict(input=IO_TEST_1_IN, output=IO_TEST_1_OUT), 2: dict(input=IO_TEST_2_IN, output=IO_TEST_2_OUT)}
status, memory, time, failed, log = self.robot.run([SOURCE], test_cases, IO_TEST_TIME_LIMIT, IO_TEST_MEMORY_LIMIT)
self.assertEqual(status, Status.CE)
self.assertEqual(memory, None)
self.assertEqual(time, None)
self.assertEqual(failed, None)
self.assertNotEqual(log, None)
def test_run_with_ok_source(self):
self.make_file(SOURCE, OK_SOURCE)
test_cases = {1: dict(input=IO_TEST_1_IN, output=IO_TEST_1_OUT), 2: dict(input=IO_TEST_2_IN, output=IO_TEST_2_OUT)}
status, memory, time, failed, log = self.robot.run([SOURCE], test_cases, IO_TEST_TIME_LIMIT, IO_TEST_MEMORY_LIMIT)
self.assertEqual(status, Status.OK)
self.assertNotEqual(memory, None)
self.assertNotEqual(time, None)
self.assertEqual(failed, None)
self.assertEqual(log, None)
def test_run_with_fe_source(self):
self.make_file(SOURCE, FE_SOURCE)
test_cases = {1: dict(input=IO_TEST_1_IN, output=IO_TEST_1_OUT), 2: dict(input=IO_TEST_2_IN, output=IO_TEST_2_OUT)}
status, memory, time, failed, log = self.robot.run([SOURCE], test_cases, IO_TEST_TIME_LIMIT, IO_TEST_MEMORY_LIMIT)
self.assertEqual(status, Status.FE)
self.assertNotEqual(memory, None)
self.assertNotEqual(time, None)
self.assertEqual(failed, 2)
self.assertEqual(log, None)
def test_run_with_tl_source(self):
self.make_file(SOURCE, TL_SOURCE)
test_cases = {1: dict(input=IO_TEST_1_IN, output=IO_TEST_1_OUT), 2: dict(input=IO_TEST_2_IN, output=IO_TEST_2_OUT)}
status, memory, time, failed, log = self.robot.run([SOURCE], test_cases, IO_TEST_TIME_LIMIT, IO_TEST_MEMORY_LIMIT)
self.assertEqual(status, Status.TL)
self.assertEqual(memory, None)
self.assertEqual(time, None)
self.assertEqual(failed, 1)
self.assertEqual(log, None)
def test_run_with_sf_source(self):
self.make_file(SOURCE, SF_SOURCE)
test_cases = {1: dict(input=IO_TEST_1_IN, output=IO_TEST_1_OUT), 2: dict(input=IO_TEST_2_IN, output=IO_TEST_2_OUT)}
status, memory, time, failed, log = self.robot.run([SOURCE], test_cases, IO_TEST_TIME_LIMIT, IO_TEST_MEMORY_LIMIT)
self.assertEqual(status, Status.SF)
self.assertNotEqual(memory, None)
self.assertNotEqual(time, None)
self.assertEqual(failed, 1)
self.assertEqual(log, None)
def test_run_with_wa_source(self):
self.make_file(SOURCE, WA_SOURCE)
test_cases = {1: dict(input=IO_TEST_1_IN, output=IO_TEST_1_OUT), 2: dict(input=IO_TEST_2_IN, output=IO_TEST_2_OUT)}
status, memory, time, failed, log = self.robot.run([SOURCE], test_cases, IO_TEST_TIME_LIMIT, IO_TEST_MEMORY_LIMIT)
self.assertEqual(status, Status.WA)
self.assertNotEqual(memory, None)
self.assertNotEqual(time, None)
self.assertEqual(failed, 1)
self.assertEqual(log, None)
def test_run_with_re_source(self):
self.make_file(SOURCE, RE_SOURCE)
test_cases = {1: dict(input=IO_TEST_1_IN, output=IO_TEST_1_OUT), 2: dict(input=IO_TEST_2_IN, output=IO_TEST_2_OUT)}
status, memory, time, failed, log = self.robot.run([SOURCE], test_cases, IO_TEST_TIME_LIMIT, IO_TEST_MEMORY_LIMIT)
self.assertEqual(status, Status.RE)
self.assertNotEqual(memory, None)
self.assertNotEqual(time, None)
self.assertEqual(failed, 1)
self.assertEqual(log, None)
def setUp(self):
rospy.init_node('test_bin')
self.bin = Bin('robot_0', 1, 0.5, 1, 1, pi / 2)
self.robot = Robot('robot_1', 1, 0.5, 1, 1, pi / 2)
from robots import Robot
from dinosaurs import Dinosaur
from fleet import Fleet
from herd import Herd
from battlefield import Battlefield
r1 = Robot('WALL-E')
r2 = Robot('T-800')
r3 = Robot('Roomba')
d1 = Dinosaur('Trogdor', 55)
d2 = Dinosaur('Allosaurus', 42)
d3 = Dinosaur('Spinosaurus', 55)
Fleet(3)
Fleet.create_fleet(r1)
Fleet.create_fleet(r2)
Fleet.create_fleet(r3)
print(Fleet.robot_fleet)
Herd(3)
Herd.create_herd(d1)
Herd.create_herd(d2)
Herd.create_herd(d3)
print(Herd.dinosaur_herd)
def setUp(self):
rospy.init_node('test_navigate_action')
self.robot = Robot('robot_0', 1, 0.5, 1, 1, pi/2)
def main():
#initialize pygame
pygame.init()
screen = pygame.display.set_mode(SCREEN_SIZE)
bounds = screen.get_rect()
#initialize game
player = Player(bounds.center, bounds) #sets starting position fir player
robot = Robot((randrange(0,800),randrange(0,600)), bounds)
player_grp = GroupSingle(player)
#robot_grp = GroupSingle(robot)
robot_grp = Group()
robot_grp.add(Robot((randrange(0,800),randrange(0,600)), bounds))
robot_grp.add(Robot((randrange(0,800),randrange(0,600)), bounds))
robot_grp.add(Robot((randrange(0,800),randrange(0,600)), bounds))
meteors = Group()
impacts = Group()
score = 0
spawntime = 10
spawnticker = 0
font = pygame.font.Font(None,35)
#game loop
done = False
clock = pygame.time.Clock()
print "Loop Started"
while not done:
for event in pygame.event.get():
if event.type == QUIT:
done = True
elif event.type == KEYDOWN and event.key == K_ESCAPE:
done = True
elif event.type == KEYDOWN and event.key == K_SPACE:
if player.carrying:
player.drop()
else:
for robot in groupcollide(robot_grp, player_grp, False, False):
player.grab(robot)
score += 5
print "robot picked up"
break
#input
#spawn meteors
spawnticker += 1
if spawnticker >= spawntime:
#print "spawned!"
meteors.add(Meteor((randrange(0,800),randrange(0,600)),bounds, 90, "rock"))
spawnticker = 0
#update
meteors.update()
ImpactGroup.impacts.update()
player.update()
#collisions
coll = groupcollide(player_grp, ImpactGroup.impacts, False, False)
for robot in coll:
robot.damage(coll[robot][0])
coll = groupcollide(robot_grp, ImpactGroup.impacts, False, False)
for robot in coll:
robot.damage(coll[robot][0])
#draw
screen.fill(BG_COLOR)
robot_grp.draw(screen)
ImpactGroup.impacts.draw(screen)
meteors.draw(screen)
player_grp.draw(screen)
robot_grp.draw(screen)
clock.tick(30)
score_text = font.render("Score: %05d"%score, False, (255,255,255))
screen.blit(score_text, (5,5))
pygame.display.flip()
def test_robot_move_to_should_move_robot_step_by_step(self):
robot = Robot()
for i in range(9):
robot.move_to(10)
self.assertEqual(10, robot.position)
#---------------
if __name__ == '__main__':
params = Parameters(path="../config.yaml")
mean_time = []
std_time = []
for lambda_ in np.linspace(0, 2, 21):
times = []
n_failures = 0
for i in range(10):
q = make_queues()
env = Environment()
gt = set(env.ground_truth)
robot1 = Robot(1, q.robots, env)
robot2 = Robot(2, q.robots, env)
master = NaiveMaster(params, q.master, lambda_=lambda_)
robot1.start()
robot2.start()
master.start()
directive = {"type_directive": "request_run"}
q.gui.gui2master.put(Container(directive))
edges = {}
start_time = time.time()
while True:
if not q.gui.master2gui.empty():
directive = q.gui.master2gui.get_nowait()
edges = set(directive.summary.edges)
common = gt.intersection(edges)
overlap = float(len(common)) / float(len(gt))
from robots import Robot, RC_BLACK, RC_WHITE
from intcomp import IntcodeController
f = open('input11.txt', 'r')
ls1 = f.read().split(',')
vm = IntcodeController([int(s) for s in ls1], buffer=[])
r = Robot(vm)
r.run()
print(len(r.panel))
vm.reset()
r = Robot(vm, panel={(0, 0): RC_WHITE})
r.run()
r.print_as_picture()
