def test_Machine(self):
from roslaunch.core import Machine
m = Machine('name1', '/ros/root1', '/rpp1', '1.2.3.4')
str(m), m.config_key() #test for error
self.assertEquals(m, m)
self.assertEquals(m, Machine('name1', '/ros/root1', '/rpp1', '1.2.3.4'))
# verify that config_equals is not tied to name or assignable, but is tied to other properties
self.assert_(m.config_equals(Machine('name1b', '/ros/root1', '/rpp1', '1.2.3.4')))
self.assert_(m.config_equals(Machine('name1c', '/ros/root1', '/rpp1', '1.2.3.4', assignable=False)))
self.failIf(m.config_equals(Machine('name1d', '/ros/root2', '/rpp1', '1.2.3.4')))
self.failIf(m.config_equals(Machine('name1e', '/ros/root1', '/rpp2', '1.2.3.4')))
self.failIf(m.config_equals(Machine('name1f', '/ros/root1', '/rpp1', '2.2.3.4')))
self.assertEquals(m.name, 'name1')
self.assertEquals(m.ros_root, '/ros/root1')
self.assertEquals(m.ros_package_path, '/rpp1')
self.assertEquals(m.address, '1.2.3.4')
self.assertEquals(m.assignable, True)
self.assertEquals(m.ssh_port, 22)
self.assertEquals(m.env_args, [])
for p in ['ros_ip', 'user', 'password']:
self.assertEquals(getattr(m, p), None)
m = Machine('name2', '/ros/root2', '/rpp2', '2.2.3.4', assignable=False)
self.assertEquals(m.assignable, False)
str(m), m.config_key() #test for error
self.assertEquals(m, m)
self.assertEquals(m, Machine('name2', '/ros/root2', '/rpp2', '2.2.3.4', assignable=False))
self.assert_(m.config_equals(Machine('name2b', '/ros/root2', '/rpp2', '2.2.3.4', assignable=False)))
self.assert_(m.config_equals(Machine('name2c', '/ros/root2', '/rpp2', '2.2.3.4', assignable=True)))
m = Machine('name3', '/ros/root3', '/rpp3', '3.3.3.4', ros_ip='4.5.6.7')
self.assertEquals(m.ros_ip, '4.5.6.7')
str(m) #test for error
self.assertEquals(m, m)
self.assertEquals(m, Machine('name3', '/ros/root3', '/rpp3', '3.3.3.4', ros_ip='4.5.6.7'))
self.assert_(m.config_equals(Machine('name3b', '/ros/root3', '/rpp3', '3.3.3.4', ros_ip='4.5.6.7')))
m = Machine('name4', '/ros/root4', '/rpp4', '4.4.3.4', user='******')
self.assertEquals(m.user, 'user4')
str(m), m.config_key() #test for error
self.assertEquals(m, m)
self.assertEquals(m, Machine('name4', '/ros/root4', '/rpp4', '4.4.3.4', user='******'))
self.assert_(m.config_equals(Machine('name4b', '/ros/root4', '/rpp4', '4.4.3.4', user='******')))
self.failIf(m.config_equals(Machine('name4b', '/ros/root4', '/rpp4', '4.4.3.4', user='******')))
m = Machine('name5', '/ros/root5', '/rpp5', '5.5.3.4', password='******')
self.assertEquals(m.password, 'password5')
str(m), m.config_key() #test for error
self.assertEquals(m, m)
self.assertEquals(m, Machine('name5', '/ros/root5', '/rpp5', '5.5.3.4', password='******'))
self.assert_(m.config_equals(Machine('name5b', '/ros/root5', '/rpp5', '5.5.3.4', password='******')))
self.failIf(m.config_equals(Machine('name5c', '/ros/root5', '/rpp5', '5.5.3.4', password='******')))
m = Machine('name6', '/ros/root6', '/rpp6', '6.6.3.4', ssh_port=23)
self.assertEquals(m.ssh_port, 23)
str(m) #test for error
m.config_key()
self.assertEquals(m, m)
self.assertEquals(m, Machine('name6', '/ros/root6', '/rpp6', '6.6.3.4', ssh_port=23))
self.assert_(m.config_equals(Machine('name6b', '/ros/root6', '/rpp6', '6.6.3.4', ssh_port=23)))
self.failIf(m.config_equals(Machine('name6c', '/ros/root6', '/rpp6', '6.6.3.4', ssh_port=24)))
m = Machine('name7', '/ros/root7', '/rpp7', '7.7.3.4', env_args=[('ARG', 'val'), ('ARG2', 'val')])
self.assertEquals(m.env_args, [('ARG', 'val'), ('ARG2', 'val')])
str(m), m.config_key() #test for error
self.assertEquals(m, m)
self.assertEquals(m, Machine('name7', '/ros/root7', '/rpp7', '7.7.3.4', env_args=[('ARG', 'val'), ('ARG2', 'val')]))
self.assert_(m.config_equals(Machine('name7b', '/ros/root7', '/rpp7', '7.7.3.4', env_args=[('ARG', 'val'), ('ARG2', 'val')])))
self.assert_(m.config_equals(Machine('name7b', '/ros/root7', '/rpp7', '7.7.3.4', env_args=[('ARG2', 'val'), ('ARG', 'val')])))
self.failIf(m.config_equals(Machine('name7c', '/ros/root7', '/rpp7', '7.7.3.4', env_args=[('ARGc', 'valc'), ('ARG2', 'val')])))
def test_create_local_process_env(self):
# this is almost entirely identical to the setup_env test in test_core, with some additional
# higher level checks
from roslaunch.core import Node, Machine
from roslaunch.node_args import create_local_process_env
ros_root = '/ros/root1'
rpp = '/rpp1'
master_uri = 'http://masteruri:1234'
n = Node('nodepkg', 'nodetype')
m = Machine('name1', ros_root, rpp, '1.2.3.4')
d = create_local_process_env(n, m, master_uri)
self.assertEquals(d['ROS_MASTER_URI'], master_uri)
self.assertEquals(d['ROS_ROOT'], ros_root)
self.assertEquals(d['PYTHONPATH'],
os.path.join(ros_root, 'core', 'roslib', 'src'))
self.assertEquals(d['ROS_PACKAGE_PATH'], rpp)
for k in ['ROS_IP', 'ROS_NAMESPACE']:
if k in d:
self.fail('%s should not be set: %s' % (k, d[k]))
# test that it inherits local environment
env = os.environ.copy()
env['PATH'] = '/some/path'
env['FOO'] = 'foo'
d = create_local_process_env(n, m, master_uri, env=env)
self.assertEquals(d['FOO'], 'foo')
# test that it defaults to os.environ
os.environ['FOO'] = 'bar'
d = create_local_process_env(n, m, master_uri)
self.assertEquals(d['FOO'], 'bar')
# test that our ROS_ROOT and PYTHONPATH override env
env = os.environ.copy()
env['ROS_ROOT'] = '/not/ros/root/'
env['PYTHONPATH'] = '/some/path'
d = create_local_process_env(n, m, master_uri, env=env)
self.assertEquals(d['ROS_ROOT'], ros_root)
self.assertEquals(d['PYTHONPATH'],
os.path.join(ros_root, 'core', 'roslib', 'src'))
# - make sure it didn't pollute original env
self.assertEquals(env['ROS_ROOT'], '/not/ros/root/')
self.assertEquals(env['PYTHONPATH'], '/some/path')
# don't set ROS_ROOT and ROS_PACKAGE_PATH. ROS_ROOT should default, ROS_PACKAGE_PATH does not
m = Machine('name1', '', '', '1.2.3.4')
d = create_local_process_env(n, m, master_uri)
val = os.environ['ROS_ROOT']
self.assertEquals(d['ROS_ROOT'], val)
self.assertEquals(d['PYTHONPATH'],
os.path.join(val, 'core', 'roslib', 'src'))
self.failIf('ROS_PACKAGE_PATH' in d,
'ROS_PACKAGE_PATH should not be set: %s' % d)
# test ROS_IP
m = Machine('name1', ros_root, rpp, '1.2.3.4', ros_ip="4.5.6.7")
n = Node('nodepkg', 'nodetype', namespace="/ns1")
d = create_local_process_env(n, m, master_uri)
self.assertEquals(d['ROS_NAMESPACE'], "/ns1")
# test stripping
n = Node('nodepkg', 'nodetype', namespace="/ns2/")
d = create_local_process_env(n, m, master_uri)
self.assertEquals(d['ROS_NAMESPACE'], "/ns2")
# test ROS_NAMESPACE
m = Machine('name1', ros_root, rpp, '1.2.3.4', ros_ip="4.5.6.7")
d = create_local_process_env(n, m, master_uri)
self.assertEquals(d['ROS_IP'], "4.5.6.7")
# test node.env_args
n = Node('nodepkg',
'nodetype',
env_args=[('NENV1', 'val1'), ('NENV2', 'val2'),
('ROS_ROOT', '/new/root')])
d = create_local_process_env(n, m, master_uri)
self.assertEquals(d['ROS_ROOT'], "/new/root")
self.assertEquals(d['NENV1'], "val1")
self.assertEquals(d['NENV2'], "val2")
# test machine.env_args
m = Machine('name1',
ros_root,
rpp,
'1.2.3.4',
ros_ip="4.5.6.7",
env_args=[('MENV1', 'val1'), ('MENV2', 'val2'),
('ROS_ROOT', '/new/root2')])
n = Node('nodepkg', 'nodetype')
d = create_local_process_env(n, m, master_uri)
self.assertEquals(d['ROS_ROOT'], "/new/root2")
self.assertEquals(d['MENV1'], "val1")
self.assertEquals(d['MENV2'], "val2")
# test node.env_args precedence
m = Machine('name1',
ros_root,
rpp,
'1.2.3.4',
ros_ip="4.5.6.7",
env_args=[('MENV1', 'val1'), ('MENV2', 'val2')])
n = Node('nodepkg', 'nodetype', env_args=[('MENV1', 'nodeval1')])
d = create_local_process_env(n, m, master_uri)
self.assertEquals(d['MENV1'], "nodeval1")
self.assertEquals(d['MENV2'], "val2")
timeout)
elif timeout == '':
raise XmlParseException("'timeout' cannot be empty")
if timeout is not None and timeout <= 0.:
raise XmlParseException(
"'timeout' be a positive number: [%s]" % timeout)
#TODO: change Machine representation to use an environment
# dictionary instead of the umpteen ROS environment
# variable settings.
m = Machine(name,
rosroot,
ros_package_path,
address,
ros_ip=ros_host_name,
ssh_port=ssh_port,
user=user,
password=password,
assignable=assignable,
env_args=context.env_args,
timeout=timeout)
return (m, is_default)
except KeyError, e:
raise XmlParseException(
"<machine> tag is missing required attribute: %s" % e)
except SubstitutionException, e:
raise XmlParseException("%s. \n\nMachine xml is %s" %
(e, tag.toxml()))
except RLException, e:
raise XmlParseException("%s. \n\nMachine xml is %s" %
(e, tag.toxml()))
def test_setup_env(self):
from roslaunch.core import setup_env, Node, Machine
ros_root = '/ros/root1'
rpp = '/rpp1'
master_uri = 'http://masteruri:1234'
n = Node('nodepkg', 'nodetype')
m = Machine('name1', ros_root, rpp, '1.2.3.4')
d = setup_env(n, m, master_uri)
self.assertEquals(d['ROS_MASTER_URI'], master_uri)
self.assertEquals(d['ROS_ROOT'], ros_root)
self.assertEquals(d['PYTHONPATH'],
os.path.join(ros_root, 'core', 'roslib', 'src'))
self.assertEquals(d['ROS_PACKAGE_PATH'], rpp)
for k in ['ROS_IP', 'ROS_NAMESPACE']:
if k in d:
self.fail('%s should not be set: %s' % (k, d[k]))
# don't set ROS_ROOT and ROS_PACKAGE_PATH. ROS_ROOT should default, ROS_PACKAGE_PATH does not
m = Machine('name1', '', '', '1.2.3.4')
d = setup_env(n, m, master_uri)
val = os.environ['ROS_ROOT']
self.assertEquals(d['ROS_ROOT'], val)
self.assertEquals(d['PYTHONPATH'],
os.path.join(val, 'core', 'roslib', 'src'))
self.failIf('ROS_PACKAGE_PATH' in d,
'ROS_PACKAGE_PATH should not be set: %s' % d)
# test ROS_IP
m = Machine('name1', ros_root, rpp, '1.2.3.4', ros_ip="4.5.6.7")
n = Node('nodepkg', 'nodetype', namespace="/ns1")
d = setup_env(n, m, master_uri)
self.assertEquals(d['ROS_NAMESPACE'], "/ns1")
# test stripping
n = Node('nodepkg', 'nodetype', namespace="/ns2/")
d = setup_env(n, m, master_uri)
self.assertEquals(d['ROS_NAMESPACE'], "/ns2")
# test ROS_NAMESPACE
m = Machine('name1', ros_root, rpp, '1.2.3.4', ros_ip="4.5.6.7")
d = setup_env(n, m, master_uri)
self.assertEquals(d['ROS_IP'], "4.5.6.7")
# test node.env_args
n = Node('nodepkg',
'nodetype',
env_args=[('NENV1', 'val1'), ('NENV2', 'val2'),
('ROS_ROOT', '/new/root')])
d = setup_env(n, m, master_uri)
self.assertEquals(d['ROS_ROOT'], "/new/root")
self.assertEquals(d['NENV1'], "val1")
self.assertEquals(d['NENV2'], "val2")
# test machine.env_args
m = Machine('name1',
ros_root,
rpp,
'1.2.3.4',
ros_ip="4.5.6.7",
env_args=[('MENV1', 'val1'), ('MENV2', 'val2'),
('ROS_ROOT', '/new/root2')])
n = Node('nodepkg', 'nodetype')
d = setup_env(n, m, master_uri)
self.assertEquals(d['ROS_ROOT'], "/new/root2")
self.assertEquals(d['MENV1'], "val1")
self.assertEquals(d['MENV2'], "val2")
# test node.env_args precedence
m = Machine('name1',
ros_root,
rpp,
'1.2.3.4',
ros_ip="4.5.6.7",
env_args=[('MENV1', 'val1'), ('MENV2', 'val2')])
n = Node('nodepkg', 'nodetype', env_args=[('MENV1', 'nodeval1')])
d = setup_env(n, m, master_uri)
self.assertEquals(d['MENV1'], "nodeval1")
self.assertEquals(d['MENV2'], "val2")
def test_create_node_process(self):
from roslaunch.core import Node, Machine, RLException
from roslaunch.node_args import NodeParamsException
from roslaunch.nodeprocess import create_node_process, LocalProcess
# have to use real ROS configuration for these tests
ros_root = os.environ['ROS_ROOT']
rpp = os.environ.get('ROS_PACKAGE_PATH', None)
master_uri = 'http://masteruri:1234'
m = Machine('name1', ros_root, rpp, '1.2.3.4')
run_id = 'id'
# test invalid params
n = Node('not_a_real_package', 'not_a_node')
n.machine = m
n.name = 'foo'
try: # should fail b/c node cannot be found
create_node_process(run_id, n, master_uri)
self.fail("should have failed")
except NodeParamsException:
pass
# have to specify a real node
n = Node('test_ros', 'talker.py')
n.machine = m
try: # should fail b/c n.name is not set
create_node_process(run_id, n, master_uri)
self.fail("should have failed")
except ValueError:
pass
# have to specify a real node
n = Node('test_ros', 'talker.py')
n.machine = None
n.name = 'talker'
try: # should fail b/c n.machine is not set
create_node_process(run_id, n, master_uri)
self.fail("should have failed")
except RLException:
pass
# basic integration test
n.machine = m
p = create_node_process(run_id, n, master_uri)
self.assert_(isinstance(p, LocalProcess))
# repeat some setup_local_process_env tests
d = p.env
self.assertEquals(d['ROS_MASTER_URI'], master_uri)
self.assertEquals(d['ROS_ROOT'], ros_root)
self.assertEquals(d['PYTHONPATH'],
os.path.join(ros_root, 'core', 'roslib', 'src'))
if rpp:
self.assertEquals(d['ROS_PACKAGE_PATH'], rpp)
for k in ['ROS_IP', 'ROS_NAMESPACE']:
if k in d:
self.fail('%s should not be set: %s' % (k, d[k]))
# test package and name
self.assertEquals(p.package, 'test_ros')
# - no 'correct' full answer here
self.assert_(p.name.startswith('talker'), p.name)
# test log_output
n.output = 'log'
self.assert_(create_node_process(run_id, n, master_uri).log_output)
n.output = 'screen'
self.failIf(create_node_process(run_id, n, master_uri).log_output)
# test respawn
n.respawn = True
self.assert_(create_node_process(run_id, n, master_uri).respawn)
n.respawn = False
self.failIf(create_node_process(run_id, n, master_uri).respawn)
# test cwd
n.cwd = None
self.assertEquals(create_node_process(run_id, n, master_uri).cwd, None)
n.cwd = 'ros-root'
self.assertEquals(
create_node_process(run_id, n, master_uri).cwd, 'ros-root')
n.cwd = 'node'
self.assertEquals(
create_node_process(run_id, n, master_uri).cwd, 'node')
# test args
# - simplest test (no args)
n.args = ''
p = create_node_process(run_id, n, master_uri)
# - the first arg should be the path to the node executable
cmd = roslib.packages.find_node('test_ros', 'talker.py', ros_root, rpp)
self.assertEquals(p.args[0], cmd)
# - test basic args
n.args = "arg1 arg2 arg3"
p = create_node_process(run_id, n, master_uri)
self.assertEquals(p.args[0], cmd)
for a in "arg1 arg2 arg3".split():
self.assert_(a in p.args)
# - test remap args
n.remap_args = [('KEY1', 'VAL1'), ('KEY2', 'VAL2')]
p = create_node_process(run_id, n, master_uri)
self.assert_('KEY1:=VAL1' in p.args)
self.assert_('KEY2:=VAL2' in p.args)
# - test __name
n = Node('test_ros', 'talker.py')
n.name = 'fooname'
n.machine = m
self.assert_('__name:=fooname' in create_node_process(
run_id, n, master_uri).args)
# - test substitution args
os.environ['SUB_TEST'] = 'subtest'
os.environ['SUB_TEST2'] = 'subtest2'
n.args = 'foo $(env SUB_TEST) $(env SUB_TEST2)'
p = create_node_process(run_id, n, master_uri)
self.failIf('SUB_TEST' in p.args)
self.assert_('foo' in p.args)
self.assert_('subtest' in p.args)
self.assert_('subtest2' in p.args)
def test_Machine():
from roslaunch.core import Machine
m = Machine("foo", "localhost")
assert "foo" in str(m)
assert m.name == "foo"
assert m.env_loader == None
assert m.assignable == True
assert m == m
assert not m.__eq__(1)
assert not m.config_equals(1)
assert m == Machine("foo", "localhost")
assert m.config_equals(Machine("foo", "localhost"))
assert m.config_key() == Machine("foo", "localhost").config_key()
assert m.config_equals(Machine("foo", "localhost"))
assert m.config_key() == Machine("foo", "localhost", ssh_port=22).config_key()
assert m.config_equals(Machine("foo", "localhost", ssh_port=22))
assert m.config_key() == Machine("foo", "localhost", assignable=False).config_key()
assert m.config_equals(Machine("foo", "localhost", assignable=False))
# original test suite
m = Machine("name1", "1.2.3.4")
str(m), m.config_key() # test for error
assert m == m
assert m == Machine("name1", "1.2.3.4")
# verify that config_equals is not tied to name or assignable, but is tied to other properties
assert m.config_equals(Machine("name1b", "1.2.3.4"))
assert m.config_equals(Machine("name1c", "1.2.3.4", assignable=False))
assert not m.config_equals(Machine("name1f", "2.2.3.4"))
assert m.name == "name1"
assert m.address == "1.2.3.4"
assert m.assignable == True
assert m.ssh_port == 22
assert m.env_loader == None
for p in ["user", "password"]:
assert getattr(m, p) is None
m = Machine("name2", "2.2.3.4", assignable=False)
assert not m.assignable
str(m), m.config_key() # test for error
assert m == m
assert m == Machine("name2", "2.2.3.4", assignable=False)
assert m.config_equals(Machine("name2b", "2.2.3.4", assignable=False))
assert m.config_equals(Machine("name2c", "2.2.3.4", assignable=True))
m = Machine("name3", "3.3.3.4")
str(m) # test for error
assert m == m
assert m == Machine("name3", "3.3.3.4")
assert m.config_equals(Machine("name3b", "3.3.3.4"))
m = Machine("name4", "4.4.3.4", user="******")
assert m.user == "user4"
str(m), m.config_key() # test for error
assert m == m
assert m == Machine("name4", "4.4.3.4", user="******")
assert m.config_equals(Machine("name4b", "4.4.3.4", user="******"))
assert not m.config_equals(Machine("name4b", "4.4.3.4", user="******"))
m = Machine("name5", "5.5.3.4", password="******")
assert m.password == "password5"
str(m), m.config_key() # test for error
assert m == m
assert m == Machine("name5", "5.5.3.4", password="******")
assert m.config_equals(Machine("name5b", "5.5.3.4", password="******"))
assert not m.config_equals(Machine("name5c", "5.5.3.4", password="******"))
m = Machine("name6", "6.6.3.4", ssh_port=23)
assert m.ssh_port == 23
str(m) # test for error
m.config_key()
assert m == m
assert m == Machine("name6", "6.6.3.4", ssh_port=23)
assert m.config_equals(Machine("name6b", "6.6.3.4", ssh_port=23))
assert not m.config_equals(Machine("name6c", "6.6.3.4", ssh_port=24))
m = Machine("name6", "6.6.3.4", env_loader="/opt/ros/fuerte/setup.sh")
assert m.env_loader == "/opt/ros/fuerte/setup.sh"
str(m) # test for error
m.config_key()
assert m == m
assert m == Machine("name6", "6.6.3.4", env_loader="/opt/ros/fuerte/setup.sh")
assert m.config_equals(Machine("name6b", "6.6.3.4", env_loader="/opt/ros/fuerte/setup.sh"))
assert not m.config_equals(Machine("name6c", "6.6.3.4", env_loader="/opt/ros/groovy/setup.sh"))
def test_Machine():
from roslaunch.core import Machine
m = Machine('foo', 'localhost')
assert 'foo' in str(m)
assert m.name == 'foo'
assert m.env_loader == None
assert m.assignable == True
assert m == m
assert not m.__eq__(1)
assert not m.config_equals(1)
assert m == Machine('foo', 'localhost')
assert m.config_equals(Machine('foo', 'localhost'))
assert m.config_key() == Machine('foo', 'localhost').config_key()
assert m.config_equals(Machine('foo', 'localhost'))
assert m.config_key() == Machine('foo', 'localhost',
ssh_port=22).config_key()
assert m.config_equals(Machine('foo', 'localhost', ssh_port=22))
assert m.config_key() == Machine('foo', 'localhost',
assignable=False).config_key()
assert m.config_equals(Machine('foo', 'localhost', assignable=False))
# original test suite
m = Machine('name1', '1.2.3.4')
str(m), m.config_key() #test for error
assert m == m
assert m == Machine('name1', '1.2.3.4')
# verify that config_equals is not tied to name or assignable, but is tied to other properties
assert m.config_equals(Machine('name1b', '1.2.3.4'))
assert m.config_equals(Machine('name1c', '1.2.3.4', assignable=False))
assert not m.config_equals(Machine('name1f', '2.2.3.4'))
assert m.name == 'name1'
assert m.address == '1.2.3.4'
assert m.assignable == True
assert m.ssh_port == 22
assert m.env_loader == None
for p in ['user', 'password']:
assert getattr(m, p) is None
m = Machine('name2', '2.2.3.4', assignable=False)
assert not m.assignable
str(m), m.config_key() #test for error
assert m == m
assert m == Machine('name2', '2.2.3.4', assignable=False)
assert m.config_equals(Machine('name2b', '2.2.3.4', assignable=False))
assert m.config_equals(Machine('name2c', '2.2.3.4', assignable=True))
m = Machine('name3', '3.3.3.4')
str(m) #test for error
assert m == m
assert m == Machine('name3', '3.3.3.4')
assert m.config_equals(Machine('name3b', '3.3.3.4'))
m = Machine('name4', '4.4.3.4', user='******')
assert m.user == 'user4'
str(m), m.config_key() #test for error
assert m == m
assert m == Machine('name4', '4.4.3.4', user='******')
assert m.config_equals(Machine('name4b', '4.4.3.4', user='******'))
assert not m.config_equals(Machine('name4b', '4.4.3.4', user='******'))
m = Machine('name5', '5.5.3.4', password='******')
assert m.password == 'password5'
str(m), m.config_key() #test for error
assert m == m
assert m == Machine('name5', '5.5.3.4', password='******')
assert m.config_equals(Machine('name5b', '5.5.3.4', password='******'))
assert not m.config_equals(
Machine('name5c', '5.5.3.4', password='******'))
m = Machine('name6', '6.6.3.4', ssh_port=23)
assert m.ssh_port == 23
str(m) #test for error
m.config_key()
assert m == m
assert m == Machine('name6', '6.6.3.4', ssh_port=23)
assert m.config_equals(Machine('name6b', '6.6.3.4', ssh_port=23))
assert not m.config_equals(Machine('name6c', '6.6.3.4', ssh_port=24))
m = Machine('name6', '6.6.3.4', env_loader='/opt/ros/fuerte/setup.sh')
assert m.env_loader == '/opt/ros/fuerte/setup.sh'
str(m) #test for error
m.config_key()
assert m == m
assert m == Machine('name6',
'6.6.3.4',
env_loader='/opt/ros/fuerte/setup.sh')
assert m.config_equals(
Machine('name6b', '6.6.3.4', env_loader='/opt/ros/fuerte/setup.sh'))
assert not m.config_equals(
Machine('name6c', '6.6.3.4', env_loader='/opt/ros/groovy/setup.sh'))
def test_Machine():
from roslaunch.core import Machine
m = Machine('foo', 'localhost')
assert 'foo' in str(m)
assert m.name == 'foo'
assert m.env_loader == None
assert m.assignable == True
assert m == m
assert not m.__eq__(1)
assert not m.config_equals(1)
assert m == Machine('foo', 'localhost')
assert m.config_equals(Machine('foo', 'localhost'))
assert m.config_key() == Machine('foo', 'localhost').config_key()
assert m.config_equals(Machine('foo', 'localhost'))
assert m.config_key() == Machine('foo', 'localhost', ssh_port=22).config_key()
assert m.config_equals(Machine('foo', 'localhost', ssh_port=22))
assert m.config_key() == Machine('foo', 'localhost', assignable=False).config_key()
assert m.config_equals(Machine('foo', 'localhost', assignable=False))
# original test suite
m = Machine('name1', '1.2.3.4')
str(m), m.config_key() #test for error
assert m == m
assert m == Machine('name1', '1.2.3.4')
# verify that config_equals is not tied to name or assignable, but is tied to other properties
assert m.config_equals(Machine('name1b', '1.2.3.4'))
assert m.config_equals(Machine('name1c', '1.2.3.4', assignable=False))
assert not m.config_equals(Machine('name1f', '2.2.3.4'))
assert m.name == 'name1'
assert m.address == '1.2.3.4'
assert m.assignable == True
assert m.ssh_port == 22
assert m.env_loader == None
for p in ['user', 'password']:
assert getattr(m, p) is None
m = Machine('name2', '2.2.3.4', assignable=False)
assert not m.assignable
str(m), m.config_key() #test for error
assert m == m
assert m == Machine('name2', '2.2.3.4', assignable=False)
assert m.config_equals(Machine('name2b', '2.2.3.4', assignable=False))
assert m.config_equals(Machine('name2c', '2.2.3.4', assignable=True))
m = Machine('name3', '3.3.3.4')
str(m) #test for error
assert m == m
assert m == Machine('name3', '3.3.3.4')
assert m.config_equals(Machine('name3b', '3.3.3.4'))
m = Machine('name4', '4.4.3.4', user='******')
assert m.user == 'user4'
str(m), m.config_key() #test for error
assert m == m
assert m == Machine('name4', '4.4.3.4', user='******')
assert m.config_equals(Machine('name4b', '4.4.3.4', user='******'))
assert not m.config_equals(Machine('name4b', '4.4.3.4', user='******'))
m = Machine('name5', '5.5.3.4', password='******')
assert m.password == 'password5'
str(m), m.config_key() #test for error
assert m == m
assert m == Machine('name5', '5.5.3.4', password='******')
assert m.config_equals(Machine('name5b', '5.5.3.4', password='******'))
assert not m.config_equals(Machine('name5c', '5.5.3.4', password='******'))
m = Machine('name6', '6.6.3.4', ssh_port=23)
assert m.ssh_port == 23
str(m) #test for error
m.config_key()
assert m == m
assert m == Machine('name6', '6.6.3.4', ssh_port=23)
assert m.config_equals(Machine('name6b', '6.6.3.4', ssh_port=23))
assert not m.config_equals(Machine('name6c', '6.6.3.4', ssh_port=24))
m = Machine('name6', '6.6.3.4', env_loader='/opt/ros/fuerte/setup.sh')
assert m.env_loader == '/opt/ros/fuerte/setup.sh'
str(m) #test for error
m.config_key()
assert m == m
assert m == Machine('name6', '6.6.3.4', env_loader='/opt/ros/fuerte/setup.sh')
assert m.config_equals(Machine('name6b', '6.6.3.4', env_loader='/opt/ros/fuerte/setup.sh'))
assert not m.config_equals(Machine('name6c', '6.6.3.4', env_loader='/opt/ros/groovy/setup.sh'))
