def test_if_unless(self):
mock = RosLaunchMock()
loader = roslaunch.xmlloader.XmlLoader()
filename = os.path.join(self.xml_dir, 'test-if-unless.xml')
loader.load(filename, mock, argv=[])
param_d = {}
for p in mock.params:
param_d[p.key] = p.value
keys = ['group_if', 'group_unless', 'param_if', 'param_unless']
for k in keys:
self.assert_('/' + k + '_pass' in param_d, param_d)
self.failIf('/' + k + '_fail' in param_d, k)
# Also check the result of Python-parsed expressions
self.assert_('/py_' + k + '_pass' in param_d, param_d)
self.failIf('/py_' + k + '_fail' in param_d, k)
n = mock.nodes[0]
for k in ['if', 'unless']:
self.assert_(['from_%s_pass' %
k, 'to_%s_pass' % k] in n.remap_args)
self.failIf(['from_%s_fail' % k, 'to_%s_fail' % k] in n.remap_args)
# Also check the result of Python-parsed expressions
self.assert_(['py_from_%s_pass' %
k, 'py_to_%s_pass' % k] in n.remap_args)
self.failIf(['py_from_%s_fail' %
k, 'py_to_%s_fail' % k] in n.remap_args)
def _load(self, test_file):
loader = roslaunch.xmlloader.XmlLoader()
mock = RosLaunchMock()
self.assert_(os.path.exists(test_file),
"cannot locate test file %s" % test_file)
loader.load(test_file, mock)
return mock
def test_if_unless(self):
mock = RosLaunchMock()
loader = roslaunch.xmlloader.XmlLoader()
filename = os.path.join(self.xml_dir, 'test-if-unless.xml')
loader.load(filename, mock, argv=[])
param_d = {}
for p in mock.params:
param_d[p.key] = p.value
keys = ['group_if', 'group_unless', 'param_if', 'param_unless']
for k in keys:
self.assert_('/'+k+'_pass' in param_d, param_d)
self.failIf('/'+k+'_fail' in param_d, k)
# Also check the result of Python-parsed expressions
self.assert_('/py_'+k+'_pass' in param_d, param_d)
self.failIf('/py_'+k+'_fail' in param_d, k)
n = mock.nodes[0]
for k in ['if', 'unless']:
self.assert_(['from_%s_pass'%k, 'to_%s_pass'%k] in n.remap_args)
self.failIf(['from_%s_fail'%k, 'to_%s_fail'%k] in n.remap_args)
# Also check the result of Python-parsed expressions
self.assert_(['py_from_%s_pass'%k, 'py_to_%s_pass'%k] in n.remap_args)
self.failIf(['py_from_%s_fail'%k, 'py_to_%s_fail'%k] in n.remap_args)
def test_machines(self):
tests = ['test-machine-invalid.xml', \
'test-machine-invalid-4.xml', 'test-machine-invalid-5.xml',
'test-machine-invalid-6.xml', 'test-machine-invalid-7.xml',
'test-machine-invalid-8.xml', 'test-machine-invalid-9.xml',
'test-machine-invalid-10.xml', 'test-machine-invalid-11.xml',
'test-machine-invalid-12.xml',
]
loader = roslaunch.xmlloader.XmlLoader()
for filename in tests:
filename = os.path.join(self.xml_dir, filename)
try:
self.assert_(os.path.exists(filename))
loader.load(filename, RosLaunchMock())
self.fail("xmlloader did not throw an xmlparseexception for [%s]"%filename)
except roslaunch.xmlloader.XmlParseException:
pass
machines = self._load_valid_machines(['machine1', 'machine6', 'machine7', 'machine8', 'machine9'])
for m in machines:
if m.name == 'machine1':
self.assertEquals(m.address, 'address1')
elif m.name == 'machine7':
self.assertEquals(m.timeout, 10.0)
elif m.name == 'machine8':
self.assertEquals(m.timeout, 1.)
elif m.name == 'machine9':
self.assertEquals(m.env_loader, '/opt/ros/fuerte/env.sh')
def test_machines(self):
tests = ['test-machine-invalid.xml', \
'test-machine-invalid-4.xml', 'test-machine-invalid-5.xml',
'test-machine-invalid-6.xml', 'test-machine-invalid-7.xml',
'test-machine-invalid-8.xml', 'test-machine-invalid-9.xml',
'test-machine-invalid-10.xml', 'test-machine-invalid-11.xml',
'test-machine-invalid-12.xml',
]
loader = roslaunch.xmlloader.XmlLoader()
for filename in tests:
filename = os.path.join(self.xml_dir, filename)
try:
self.assert_(os.path.exists(filename))
loader.load(filename, RosLaunchMock())
self.fail(
"xmlloader did not throw an xmlparseexception for [%s]" %
filename)
except roslaunch.xmlloader.XmlParseException:
pass
machines = self._load_valid_machines(
['machine1', 'machine6', 'machine7', 'machine8', 'machine9'])
for m in machines:
if m.name == 'machine1':
self.assertEquals(m.address, 'address1')
elif m.name == 'machine7':
self.assertEquals(m.timeout, 10.0)
elif m.name == 'machine8':
self.assertEquals(m.timeout, 1.)
elif m.name == 'machine9':
self.assertEquals(m.env_loader, '/opt/ros/fuerte/env.sh')
def load_roscore(loader, config, verbose=True):
"""
Load roscore configuration into the ROSLaunchConfig using the specified XmlLoader
@param config ROSLaunchConfig
@param loader XmlLoader
"""
f_roscore = get_roscore_filename()
logging.getLogger('roslaunch').info('loading roscore config file %s'%f_roscore)
loader.load(f_roscore, config, core=True, verbose=verbose)
def load_roscore(loader, config, verbose=True):
"""
Load roscore configuration into the ROSLaunchConfig using the specified XmlLoader
@param config ROSLaunchConfig
@param loader XmlLoader
"""
f_roscore = get_roscore_filename()
logging.getLogger('roslaunch').info('loading roscore config file %s'%f_roscore)
loader.load(f_roscore, config, core=True, verbose=verbose)
def test_arg_invalid(self):
mock = RosLaunchMock()
loader = roslaunch.xmlloader.XmlLoader()
filename = os.path.join(self.xml_dir, 'test-arg.xml')
# this should raise, not sure XmlParseException is what we want as it destroys semantic info
try:
loader.load(filename, mock, argv=[])
self.fail("should have raised with missing arg")
except roslaunch.xmlloader.XmlParseException, e:
self.assert_('required' in str(e))
def load_roscore(loader, config, verbose=True):
"""
Load roscore configuration into the ROSLaunchConfig using the specified XmlLoader
@param config ROSLaunchConfig
@param loader XmlLoader
"""
import roslib.packages
f_roscore = os.path.join(roslib.packages.get_pkg_dir('roslaunch'), 'roscore.xml')
logging.getLogger('roslaunch').info('loading roscore config file %s'%f_roscore)
loader.load(f_roscore, config, core=True, verbose=verbose)
def test_arg_invalid(self):
mock = RosLaunchMock()
loader = roslaunch.xmlloader.XmlLoader()
filename = os.path.join(self.xml_dir, 'test-arg.xml')
# this should raise, not sure XmlParseException is what we want as it destroys semantic info
try:
loader.load(filename, mock, argv=[])
self.fail("should have raised with missing arg")
except roslaunch.xmlloader.XmlParseException, e:
self.assert_('required' in str(e))
def test_rosparam_invalid(self):
tests = ['test-rosparam-invalid-%s.xml'%i for i in range(1, 6)]
loader = roslaunch.xmlloader.XmlLoader()
for filename in tests:
filename = os.path.join(self.xml_dir, filename)
try:
self.assert_(os.path.exists(filename))
loader.load(filename, RosLaunchMock())
self.fail("xmlloader did not throw an xmlloadexception for [%s]"%filename)
except roslaunch.loader.LoadException:
pass
def test_node_rosparam_invalid(self):
tests = ['test-node-rosparam-invalid-name.xml']
loader = roslaunch.xmlloader.XmlLoader()
for filename in tests:
filename = os.path.join(self.xml_dir, filename)
try:
self.assert_(os.path.exists(filename))
loader.load(filename, RosLaunchMock())
self.fail("xmlloader did not throw an xmlparseexception for [%s]"%filename)
except roslaunch.xmlloader.XmlParseException, e:
pass
def test_rosparam_invalid(self):
tests = ['test-rosparam-invalid-%s.xml'%i for i in range(1, 6)]
loader = roslaunch.xmlloader.XmlLoader()
for filename in tests:
filename = os.path.join(self.xml_dir, filename)
try:
self.assert_(os.path.exists(filename))
loader.load(filename, RosLaunchMock())
self.fail("xmlloader did not throw an xmlloadexception for [%s]"%filename)
except roslaunch.loader.LoadException, e:
pass
def test_node_rosparam_invalid(self):
tests = ['test-node-rosparam-invalid-name.xml']
loader = roslaunch.xmlloader.XmlLoader()
for filename in tests:
filename = os.path.join(self.xml_dir, filename)
try:
self.assert_(os.path.exists(filename))
loader.load(filename, RosLaunchMock())
self.fail("xmlloader did not throw an xmlparseexception for [%s]"%filename)
except roslaunch.xmlloader.XmlParseException:
pass
def test_if_unless_invalid(self):
mock = RosLaunchMock()
loader = roslaunch.xmlloader.XmlLoader()
filename = os.path.join(self.xml_dir, 'test-if-unless-invalid-both.xml')
# this should raise, not sure XmlParseException is what we want as it destroys semantic info
try:
loader.load(filename, mock, argv=[])
self.fail("should have raised with invalid if and unless spec")
except roslaunch.xmlloader.XmlParseException as e:
self.assert_('unless' in str(e))
self.assert_('if' in str(e))
def test_if_unless_invalid(self):
mock = RosLaunchMock()
loader = roslaunch.xmlloader.XmlLoader()
filename = os.path.join(self.xml_dir, 'test-if-unless-invalid-both.xml')
# this should raise, not sure XmlParseException is what we want as it destroys semantic info
try:
loader.load(filename, mock, argv=[])
self.fail("should have raised with invalid if and unless spec")
except roslaunch.xmlloader.XmlParseException, e:
self.assert_('unless' in str(e))
self.assert_('if' in str(e))
def test_clear_params_invalid(self):
tests = ['test-clear-params-invalid-1.xml', 'test-clear-params-invalid-2.xml',
'test-clear-params-invalid-3.xml','test-clear-params-invalid-4.xml',]
loader = roslaunch.xmlloader.XmlLoader()
for filename in tests:
filename = os.path.join(self.xml_dir, filename)
try:
self.assert_(os.path.exists(filename))
loader.load(filename, RosLaunchMock())
self.fail("xmlloader did not throw an xmlparseexception for [%s]"%filename)
except roslaunch.xmlloader.XmlParseException, e:
pass
def load_roscore(loader, config, verbose=True):
"""
Load roscore configuration into the ROSLaunchConfig using the specified XmlLoader
@param config ROSLaunchConfig
@param loader XmlLoader
"""
import roslib.packages
f_roscore = os.path.join(roslib.packages.get_pkg_dir('roslaunch'),
'roscore.xml')
logging.getLogger('roslaunch').info('loading roscore config file %s' %
f_roscore)
loader.load(f_roscore, config, core=True, verbose=verbose)
def test_clear_params_invalid(self):
tests = ['test-clear-params-invalid-1.xml', 'test-clear-params-invalid-2.xml',
'test-clear-params-invalid-3.xml','test-clear-params-invalid-4.xml',]
loader = roslaunch.xmlloader.XmlLoader()
for filename in tests:
filename = os.path.join(self.xml_dir, filename)
try:
self.assert_(os.path.exists(filename))
loader.load(filename, RosLaunchMock())
self.fail("xmlloader did not throw an xmlparseexception for [%s]"%filename)
except roslaunch.xmlloader.XmlParseException:
pass
def test_dirname(self):
loader = roslaunch.xmlloader.XmlLoader()
filename = os.path.join(self.xml_dir, 'test-dirname.xml')
mock = RosLaunchMock()
loader.load(filename, mock)
param_d = {}
for p in mock.params:
param_d[p.key] = p.value
self.assertEquals(param_d['/foo'], self.xml_dir + '/bar')
self.assertEquals(param_d['/bar'], self.xml_dir + '/test-dirname/baz')
def load_config_default(roslaunch_files,
port,
roslaunch_strs=None,
loader=None,
verbose=False,
assign_machines=True):
"""
Base routine for creating a ROSLaunchConfig from a set of
roslaunch_files and or launch XML strings and initializing it. This
config will have a core definition and also set the master to run
on port.
@param roslaunch_files: list of launch files to load
@type roslaunch_files: [str]
@param port: roscore/master port override. Set to 0 or None to use default.
@type port: int
@param roslaunch_strs: (optional) roslaunch XML strings to load
@type roslaunch_strs: [str]
@param verbose: (optional) print info to screen about model as it is loaded.
@type verbose: bool
@param assign_machines: (optional) assign nodes to machines (default: True)
@type assign_machines: bool
@return: initialized rosconfig instance
@rytpe: L{ROSLaunchConfig} initialized rosconfig instance
@raises: RLException
"""
logger = logging.getLogger('roslaunch.config')
# This is the main roslaunch server process. Load up the
# files specified on the command line and launch the
# requested resourcs.
config = ROSLaunchConfig()
if port:
config.master.uri = rosgraph.network.create_local_xmlrpc_uri(port)
loader = loader or roslaunch.xmlloader.XmlLoader()
# load the roscore file first. we currently have
# last-declaration wins rules. roscore is just a
# roslaunch file with special load semantics
load_roscore(loader, config, verbose=verbose)
# load the roslaunch_files into the config
for f in roslaunch_files:
try:
logger.info('loading config file %s' % f)
loader.load(f, config, verbose=verbose)
except roslaunch.xmlloader.XmlParseException, e:
raise RLException(e)
except roslaunch.loader.LoadException, e:
raise RLException(e)
def test_master(self):
from roslaunch.core import Master
tests = ['test-master-1.xml','test-master-2.xml',
'test-master-3.xml','test-master-4.xml',
'test-master-5.xml',
]
# tests should still load, but nothing more
for x in xrange(1, 6):
loader = roslaunch.xmlloader.XmlLoader()
for filename in tests:
filename = os.path.join(self.xml_dir, 'test-master-%s.xml'%x)
self.assert_(os.path.exists(filename))
mock = RosLaunchMock()
loader.load(filename, mock)
def test_machines(self):
tests = ['test-machine-invalid.xml', 'test-machine-invalid-2.xml', \
'test-machine-invalid-4.xml', 'test-machine-invalid-5.xml',
'test-machine-invalid-6.xml', 'test-machine-invalid-7.xml',
'test-machine-invalid-8.xml',
]
loader = roslaunch.xmlloader.XmlLoader()
for filename in tests:
filename = os.path.join(self.xml_dir, filename)
try:
self.assert_(os.path.exists(filename))
loader.load(filename, RosLaunchMock())
self.fail("xmlloader did not throw an xmlparseexception for [%s]"%filename)
except roslaunch.xmlloader.XmlParseException, e:
pass
def test_master(self):
from roslaunch.core import Master
tests = [
'test-master-1.xml',
'test-master-2.xml',
'test-master-3.xml',
'test-master-4.xml',
'test-master-5.xml',
]
# tests should still load, but nothing more
for x in xrange(1, 6):
loader = roslaunch.xmlloader.XmlLoader()
for filename in tests:
filename = os.path.join(self.xml_dir, 'test-master-%s.xml' % x)
self.assert_(os.path.exists(filename))
mock = RosLaunchMock()
loader.load(filename, mock)
def test_machines(self):
tests = ['test-machine-invalid.xml', 'test-machine-invalid-2.xml', \
'test-machine-invalid-4.xml', 'test-machine-invalid-5.xml',
'test-machine-invalid-6.xml', 'test-machine-invalid-7.xml',
'test-machine-invalid-8.xml',
]
loader = roslaunch.xmlloader.XmlLoader()
for filename in tests:
filename = os.path.join(self.xml_dir, filename)
try:
self.assert_(os.path.exists(filename))
loader.load(filename, RosLaunchMock())
self.fail(
"xmlloader did not throw an xmlparseexception for [%s]" %
filename)
except roslaunch.xmlloader.XmlParseException, e:
pass
def load_config_default(roslaunch_files, port, roslaunch_strs=None, loader=None, verbose=False, assign_machines=True):
"""
Base routine for creating a ROSLaunchConfig from a set of
roslaunch_files and or launch XML strings and initializing it. This
config will have a core definition and also set the master to run
on port.
@param roslaunch_files: list of launch files to load
@type roslaunch_files: [str]
@param port: roscore/master port override. Set to 0 or None to use default.
@type port: int
@param roslaunch_strs: (optional) roslaunch XML strings to load
@type roslaunch_strs: [str]
@param verbose: (optional) print info to screen about model as it is loaded.
@type verbose: bool
@param assign_machines: (optional) assign nodes to machines (default: True)
@type assign_machines: bool
@return: initialized rosconfig instance
@rytpe: L{ROSLaunchConfig} initialized rosconfig instance
"""
logger = logging.getLogger('roslaunch.config')
# This is the main roslaunch server process. Load up the
# files specified on the command line and launch the
# requested resourcs.
config = ROSLaunchConfig()
if port:
config.master.uri = roslib.network.create_local_xmlrpc_uri(port)
loader = loader or roslaunch.xmlloader.XmlLoader()
# load the roscore file first. we currently have
# last-declaration wins rules. roscore is just a
# roslaunch file with special load semantics
load_roscore(loader, config, verbose=verbose)
# load the roslaunch_files into the config
for f in roslaunch_files:
try:
logger.info('loading config file %s'%f)
loader.load(f, config, verbose=verbose)
except roslaunch.xmlloader.XmlParseException, e:
raise RLException(e)
except roslaunch.loader.LoadException, e:
raise RLException(e)
def test_node_invalid(self):
tests = [
'test-node-invalid-type.xml',
'test-node-invalid-type-2.xml',
'test-node-invalid-pkg.xml',
'test-node-invalid-pkg-2.xml',
# 1 and 2 have been disabled for now until we re-remove ability to have unnamed nodes with params
'test-node-invalid-name-1.xml',
'test-node-invalid-name-2.xml',
'test-node-invalid-name-3.xml',
'test-node-invalid-machine.xml',
'test-node-invalid-respawn.xml',
'test-node-invalid-respawn-required.xml',
'test-node-invalid-required-1.xml',
'test-node-invalid-required-2.xml',
'test-node-invalid-ns.xml',
'test-node-invalid-ns-2.xml',
'test-node-invalid-env-name.xml',
'test-node-invalid-env-name-2.xml',
'test-node-invalid-env-value.xml',
'test-node-invalid-output.xml',
'test-node-invalid-cwd.xml',
'test-node-invalid-exception.xml',
# rostest <test> tests
'test-test-invalid-reqd-1.xml',
'test-test-invalid-reqd-2.xml',
'test-test-invalid-respawn.xml',
'test-test-invalid-output.xml',
'test-test-invalid-time-limit-1.xml',
'test-test-invalid-time-limit-2.xml',
'test-test-invalid-retry.xml',
]
loader = roslaunch.xmlloader.XmlLoader()
for filename in tests:
filename = os.path.join(self.xml_dir, filename)
try:
self.assert_(os.path.exists(filename))
loader.load(filename, RosLaunchMock())
self.fail(
"xmlloader did not throw an xmlparseexception for [%s]" %
filename)
except roslaunch.xmlloader.XmlParseException, e:
pass
def test_remap(self):
loader = roslaunch.xmlloader.XmlLoader()
mock = RosLaunchMock()
loader.load(os.path.join(self.xml_dir, 'test-remap-valid.xml'), mock)
names = ["node%s"%i for i in range(1, 7)]
nodes = [n for n in mock.nodes if n.type in names]
for n in nodes:
if n.type == 'node1':
self.assertEquals([['foo', 'bar']], n.remap_args)
elif n.type == 'node2':
self.assertEquals([['foo', 'baz']], n.remap_args)
elif n.type == 'node3':
self.assertEquals([['foo', 'bar']], n.remap_args)
elif n.type == 'node4':
self.assertEquals([['foo', 'far']], n.remap_args)
elif n.type == 'node5':
self.assertEquals([['foo', 'fad'], ['a', 'b'], ['c', 'd']], n.remap_args)
elif n.type == 'node6':
self.assertEquals([['foo', 'far'], ['old1', 'new1'], ['old2', 'new2'], ['old3', 'new3']], n.remap_args)
def test_remap(self):
loader = roslaunch.xmlloader.XmlLoader()
mock = RosLaunchMock()
loader.load(os.path.join(self.xml_dir, 'test-remap-valid.xml'), mock)
names = ["node%s"%i for i in xrange(1, 7)]
nodes = [n for n in mock.nodes if n.type in names]
for n in nodes:
if n.type == 'node1':
self.assertEquals([['foo', 'bar']], n.remap_args)
elif n.type == 'node2':
self.assertEquals([['foo', 'baz']], n.remap_args)
elif n.type == 'node3':
self.assertEquals([['foo', 'bar']], n.remap_args)
elif n.type == 'node4':
self.assertEquals([['foo', 'far']], n.remap_args)
elif n.type == 'node5':
self.assertEquals([['foo', 'fad'], ['a', 'b'], ['c', 'd']], n.remap_args)
elif n.type == 'node6':
self.assertEquals([['foo', 'far'], ['old1', 'new1'], ['old2', 'new2'], ['old3', 'new3']], n.remap_args)
def syntastic_checker():
import re
import roslaunch
import roslaunch.loader
conf = roslaunch.ROSLaunchConfig()
loader = roslaunch.XmlLoader()
try:
loader.load(vimp.buf.name, conf, verbose=False)
except roslaunch.XmlParseException as e:
rx = re.compile('(?:while processing (?P<filename>.*):\n)*'
'(?P<text>.*)'
'(?:: line (?P<lnum>\d+), column (?P<col>\d+))?')
g = rx.match(e.message)
if g is not None:
return [syntastic.Error(**g.groupdict())]
else:
return [
syntastic.Error(text='UPDATE RE TO HANDLE THIS TYPE OF'
'ERROR MESSAGE!' + str(e.message))
]
except roslaunch.loader.LoadException as e:
return [syntastic.Error(text=str(e.message))]
except roslaunch.RLException as e:
return [syntastic.Error(text=str(e.message))]
# no parsing errors, but there could be warnigns
warn = list()
for e in conf.config_errors:
g = re.match(r'\[(.*)\] (.*)', e)
if g is not None:
fn, text = g.groups()
warn.append(syntastic.Error(filename=fn, text=text, type='W'))
continue
g = re.match(r'WARN: (.*)', e)
if g is not None:
warn.append(syntastic.Error(text=g.groups()[0], type='W'))
continue
warn.append(
syntastic.Error(text='vim-ros does not know how to '
'parse this warning: "%s"' % e,
type='W'))
return warn
def test_arg_all_includes(self):
loader = roslaunch.xmlloader.XmlLoader()
# Test 1:
# Can't explicitly set an arg when including a file that sets the same
# arg as constant.
mock = RosLaunchMock()
filename = os.path.join(self.xml_dir, 'test-arg-invalid-include.xml')
try:
loader.load(filename, mock)
self.fail('should have thrown an exception')
except roslaunch.xmlloader.XmlParseException:
pass
# Test 2:
# Can have arg set in parent launch file, then include a file that sets
# it constant, with pass_all_args="true"
mock = RosLaunchMock()
filename = os.path.join(self.xml_dir, 'test-arg-valid-include.xml')
# Just make sure there's no exception
loader.load(filename, mock)
def test_arg_all_includes(self):
loader = roslaunch.xmlloader.XmlLoader()
# Test 1:
# Can't explicitly set an arg when including a file that sets the same
# arg as constant.
mock = RosLaunchMock()
filename = os.path.join(self.xml_dir, 'test-arg-invalid-include.xml')
try:
loader.load(filename, mock)
self.fail('should have thrown an exception')
except roslaunch.xmlloader.XmlParseException:
pass
# Test 2:
# Can have arg set in parent launch file, then include a file that sets
# it constant, with pass_all_args="true"
mock = RosLaunchMock()
filename = os.path.join(self.xml_dir, 'test-arg-valid-include.xml')
# Just make sure there's no exception
loader.load(filename, mock)
def test_arg_invalid(self):
mock = RosLaunchMock()
loader = roslaunch.xmlloader.XmlLoader()
filename = os.path.join(self.xml_dir, 'test-arg.xml')
# this should raise, not sure XmlParseException is what we want as it destroys semantic info
try:
loader.load(filename, mock, argv=[])
self.fail("should have raised with missing arg")
except roslaunch.xmlloader.XmlParseException as e:
self.assert_('required' in str(e))
# test with invalid $(arg unknown)
filename = os.path.join(self.xml_dir, 'test-arg-invalid-sub.xml')
try:
loader.load(filename, mock, argv=[])
self.fail("should have raised with unknown arg")
except roslaunch.xmlloader.XmlParseException as e:
self.assert_('missing' in str(e))
# test with invalid $(arg unknown)
filename = os.path.join(self.xml_dir, 'test-arg-invalid-redecl.xml')
try:
loader.load(filename, mock, argv=[])
self.fail("should have raised with multiple decl")
except roslaunch.xmlloader.XmlParseException as e:
self.assert_('grounded' in str(e))
def test_arg_invalid(self):
mock = RosLaunchMock()
loader = roslaunch.xmlloader.XmlLoader()
filename = os.path.join(self.xml_dir, 'test-arg.xml')
# this should raise, not sure XmlParseException is what we want as it destroys semantic info
try:
loader.load(filename, mock, argv=[])
self.fail("should have raised with missing arg")
except roslaunch.xmlloader.XmlParseException as e:
self.assert_('required' in str(e))
# test with invalid $(arg unknown)
filename = os.path.join(self.xml_dir, 'test-arg-invalid-sub.xml')
try:
loader.load(filename, mock, argv=[])
self.fail("should have raised with unknown arg")
except roslaunch.xmlloader.XmlParseException as e:
self.assert_('missing' in str(e))
# test with invalid $(arg unknown)
filename = os.path.join(self.xml_dir, 'test-arg-invalid-redecl.xml')
try:
loader.load(filename, mock, argv=[])
self.fail("should have raised with multiple decl")
except roslaunch.xmlloader.XmlParseException as e:
self.assert_('grounded' in str(e))
def syntastic_checker():
import re
import roslaunch
import roslaunch.loader
conf = roslaunch.ROSLaunchConfig()
loader = roslaunch.XmlLoader()
try:
loader.load(vimp.buf.name, conf, verbose=False)
except roslaunch.XmlParseException as e:
rx = re.compile('(?:while processing (?P<filename>.*):\n)*'
'(?P<text>.*)'
'(?:: line (?P<lnum>\d+), column (?P<col>\d+))?')
g = rx.match(e.message)
if g is not None:
return [syntastic.Error(**g.groupdict())]
else:
return [syntastic.Error(text='UPDATE RE TO HANDLE THIS TYPE OF'
'ERROR MESSAGE!' + str(e.message))]
except roslaunch.loader.LoadException as e:
return [syntastic.Error(text=str(e.message))]
except roslaunch.RLException as e:
return [syntastic.Error(text=str(e.message))]
# no parsing errors, but there could be warnigns
warn = list()
for e in conf.config_errors:
g = re.match(r'\[(.*)\] (.*)', e)
if g is not None:
fn, text = g.groups()
warn.append(syntastic.Error(filename=fn, text=text, type='W'))
continue
g = re.match(r'WARN: (.*)', e)
if g is not None:
warn.append(syntastic.Error(text=g.groups()[0], type='W'))
continue
warn.append(syntastic.Error(text='vim-ros does not know how to '
'parse this warning: "%s"' % e,
type='W'))
return warn
def test_node_invalid(self):
tests = ['test-node-invalid-type.xml','test-node-invalid-type-2.xml',
'test-node-invalid-pkg.xml','test-node-invalid-pkg-2.xml',
# 1 and 2 have been disabled for now until we re-remove ability to have unnamed nodes with params
'test-node-invalid-name-1.xml',
'test-node-invalid-name-2.xml',
'test-node-invalid-name-3.xml',
'test-node-invalid-machine.xml',
'test-node-invalid-respawn.xml',
'test-node-invalid-respawn-required.xml',
'test-node-invalid-required-1.xml',
'test-node-invalid-required-2.xml',
'test-node-invalid-ns.xml','test-node-invalid-ns-2.xml',
'test-node-invalid-env-name.xml','test-node-invalid-env-name-2.xml',
'test-node-invalid-env-value.xml',
'test-node-invalid-output.xml',
'test-node-invalid-cwd.xml',
'test-node-invalid-exception.xml',
# rostest <test> tests
'test-test-invalid-reqd-1.xml',
'test-test-invalid-reqd-2.xml',
'test-test-invalid-respawn.xml',
'test-test-invalid-output.xml',
'test-test-invalid-time-limit-1.xml',
'test-test-invalid-time-limit-2.xml',
'test-test-invalid-retry.xml',
]
loader = roslaunch.xmlloader.XmlLoader()
for filename in tests:
filename = os.path.join(self.xml_dir, filename)
try:
self.assert_(os.path.exists(filename))
loader.load(filename, RosLaunchMock())
self.fail("xmlloader did not throw an xmlparseexception for [%s]"%filename)
except roslaunch.xmlloader.XmlParseException, e:
pass
def test_load(self):
# make sure load isn't broken
loader = roslaunch.xmlloader.XmlLoader()
# test against empty data
loader.load(os.path.join(self.xml_dir, 'test-valid.xml'), RosLaunchMock())
# sanity check with real data
mock = RosLaunchMock()
loader.load(os.path.join(self.xml_dir, 'test-node-valid.xml'), mock)
self.assert_(mock.nodes)
self.assert_([n for n in mock.nodes if n.type == 'test_base'])
# check exception case
try:
loader.load(os.path.join(self.xml_dir, 'invalid-xml.xml'), mock)
self.fail('load_string should have thrown an exception')
except roslaunch.xmlloader.XmlParseException:
pass
def test_load(self):
# make sure load isn't broken
loader = roslaunch.xmlloader.XmlLoader()
# test against empty data
loader.load(os.path.join(self.xml_dir, 'test-valid.xml'), RosLaunchMock())
# sanity check with real data
mock = RosLaunchMock()
loader.load(os.path.join(self.xml_dir, 'test-node-valid.xml'), mock)
self.assert_(mock.nodes)
self.assert_([n for n in mock.nodes if n.type == 'test_base'])
# check exception case
try:
loader.load(os.path.join(self.xml_dir, 'invalid-xml.xml'), mock)
self.fail('load_string should have thrown an exception')
except roslaunch.xmlloader.XmlParseException:
pass
def test_arg(self):
loader = roslaunch.xmlloader.XmlLoader()
filename = os.path.join(self.xml_dir, 'test-arg.xml')
mock = RosLaunchMock()
loader.load(filename, mock, argv=["required:=test_arg", "if_test:=0"])
param_d = {}
for p in mock.params:
param_d[p.key] = p.value
self.assertEquals(param_d['/p1_test'], 'test_arg')
self.assertEquals(param_d['/p2_test'], 'not_set')
self.assertEquals(param_d['/p3_test'], 'set')
self.assertEquals(param_d['/succeed'], 'yes')
self.assertEquals(param_d['/if_test'], 'not_ran')
self.assertEquals(param_d['/if_param'], False)
self.assertEquals(param_d['/int_param'], 1234)
self.assertAlmostEquals(param_d['/float_param'], 3.)
self.failIf('/fail' in param_d)
# context tests
# - args are scoped to their context, and thus can be rebound in a sibling context
self.assertEquals(param_d['/context1'], 'group1')
self.assertEquals(param_d['/context2'], 'group2')
# include tests
self.assertEquals(param_d['/include_test/p1_test'], 'required1')
self.assertEquals(param_d['/include_test/p2_test'], 'not_set')
self.assertEquals(param_d['/include_test/p3_test'], 'set')
self.assertEquals(param_d['/include_test/p4_test'], 'initial')
self.assertEquals(param_d['/include2/include_test/p1_test'], 'required2')
self.assertEquals(param_d['/include2/include_test/p2_test'], 'optional2')
self.assertEquals(param_d['/include2/include_test/p3_test'], 'set')
self.assertEquals(param_d['/include2/include_test/p4_test'], 'new2')
self.assert_('/include3/include_test/p1_test' not in param_d)
self.assert_('/include3/include_test/p2_test' not in param_d)
self.assert_('/include3/include_test/p3_test' not in param_d)
self.assert_('/include3/include_test/p4_test' not in param_d)
# test again with optional value set
mock = RosLaunchMock()
loader.load(filename, mock, argv=["required:=test_arg", "optional:=test_arg2", "if_test:=1"])
param_d = {}
for p in mock.params:
param_d[p.key] = p.value
self.assertEquals(param_d['/p1_test'], 'test_arg')
self.assertEquals(param_d['/p2_test'], 'test_arg2')
self.assertEquals(param_d['/p3_test'], 'set')
self.assertEquals(param_d['/context1'], 'group1')
self.assertEquals(param_d['/context2'], 'group2')
self.assertEquals(param_d['/succeed'], 'yes')
self.assertEquals(param_d['/if_test'], 'ran')
self.assertEquals(param_d['/if_param'], True)
self.failIf('/fail' in param_d)
# include tests
self.assertEquals(param_d['/include_test/p1_test'], 'required1')
self.assertEquals(param_d['/include_test/p2_test'], 'not_set')
self.assertEquals(param_d['/include_test/p3_test'], 'set')
self.assertEquals(param_d['/include_test/p4_test'], 'initial')
self.assertEquals(param_d['/include2/include_test/p1_test'], 'required2')
self.assertEquals(param_d['/include2/include_test/p2_test'], 'optional2')
self.assertEquals(param_d['/include2/include_test/p3_test'], 'set')
self.assertEquals(param_d['/include2/include_test/p4_test'], 'new2')
self.assertEquals(param_d['/include3/include_test/p1_test'], 'required3')
self.assertEquals(param_d['/include3/include_test/p2_test'], 'optional3')
self.assertEquals(param_d['/include3/include_test/p3_test'], 'set')
self.assertEquals(param_d['/include3/include_test/p4_test'], 'new3')
def test_arg_all(self):
loader = roslaunch.xmlloader.XmlLoader()
filename = os.path.join(self.xml_dir, 'test-arg-all.xml')
# Test suite A: load without an optional arg set externally
mock = RosLaunchMock()
loader.load(filename, mock, argv=["required:=test_arg"])
param_d = {}
for p in mock.params:
param_d[p.key] = p.value
# Sanity check: Parent namespace
self.assertEquals(param_d['/p1_test'], 'test_arg')
self.assertEquals(param_d['/p2_test'], 'not_set')
self.assertEquals(param_d['/p3_test'], 'parent')
# Test case 1: include without pass_all_args
self.assertEquals(param_d['/notall/include_test/p1_test'], 'test_arg')
self.assertEquals(param_d['/notall/include_test/p2_test'], 'not_set')
self.assertEquals(param_d['/notall/include_test/p3_test'], 'set')
# Test case 2: include without pass_all_args attribute, and pass optional arg
# internally
self.assertEquals(param_d['/notall_optional/include_test/p1_test'], 'test_arg')
self.assertEquals(param_d['/notall_optional/include_test/p2_test'], 'not_set')
self.assertEquals(param_d['/notall_optional/include_test/p3_test'], 'set')
# Test case 3: include with pass_all_args attribute, instead of passing individual
# args
self.assertEquals(param_d['/all/include_test/p1_test'], 'test_arg')
self.assertEquals(param_d['/all/include_test/p2_test'], 'not_set')
self.assertEquals(param_d['/all/include_test/p3_test'], 'set')
# Test case 4: include with pass_all_args attribute, and override one
# arg inside the include tag
self.assertEquals(param_d['/all_override/include_test/p1_test'], 'override')
self.assertEquals(param_d['/all_override/include_test/p2_test'], 'not_set')
self.assertEquals(param_d['/all_override/include_test/p3_test'], 'set')
# Test suite B: load with an optional arg set externally
mock = RosLaunchMock()
loader.load(filename, mock, argv=["required:=test_arg", "optional:=test_arg2"])
param_d = {}
for p in mock.params:
param_d[p.key] = p.value
# Sanity check: Parent namespace
self.assertEquals(param_d['/p1_test'], 'test_arg')
self.assertEquals(param_d['/p2_test'], 'test_arg2')
self.assertEquals(param_d['/p3_test'], 'parent')
# Test case 1: include without pass_all_args attribute
self.assertEquals(param_d['/notall/include_test/p1_test'], 'test_arg')
self.assertEquals(param_d['/notall/include_test/p2_test'], 'not_set')
self.assertEquals(param_d['/notall/include_test/p3_test'], 'set')
# Test case 2: include without pass_all_args attribute, and pass optional arg
# internally
self.assertEquals(param_d['/notall_optional/include_test/p1_test'], 'test_arg')
self.assertEquals(param_d['/notall_optional/include_test/p2_test'], 'test_arg2')
self.assertEquals(param_d['/notall_optional/include_test/p3_test'], 'set')
# Test case 3: include with pass_all_args attribute, instead of passing individual
# args
self.assertEquals(param_d['/all/include_test/p1_test'], 'test_arg')
self.assertEquals(param_d['/all/include_test/p2_test'], 'test_arg2')
self.assertEquals(param_d['/all/include_test/p3_test'], 'set')
# Test case 4: include with pass_all_args attribute, and override one
# arg inside the include tag
self.assertEquals(param_d['/all_override/include_test/p1_test'], 'override')
self.assertEquals(param_d['/all_override/include_test/p2_test'], 'test_arg2')
self.assertEquals(param_d['/all_override/include_test/p3_test'], 'set')
def test_arg_invalid(self):
mock = RosLaunchMock()
loader = roslaunch.xmlloader.XmlLoader()
filename = os.path.join(self.xml_dir, 'test-arg.xml')
# this should raise, not sure XmlParseException is what we want as it destroys semantic info
try:
loader.load(filename, mock, argv=[])
self.fail("should have raised with missing arg")
except roslaunch.xmlloader.XmlParseException, e:
self.assert_('required' in str(e))
# test with invalid $(arg unknown)
filename = os.path.join(self.xml_dir, 'test-arg-invalid-sub.xml')
try:
loader.load(filename, mock, argv=[])
self.fail("should have raised with unknown arg")
except roslaunch.xmlloader.XmlParseException, e:
self.assert_('missing' in str(e))
# test with invalid $(arg unknown)
filename = os.path.join(self.xml_dir, 'test-arg-invalid-redecl.xml')
try:
loader.load(filename, mock, argv=[])
self.fail("should have raised with multiple decl")
except roslaunch.xmlloader.XmlParseException, e:
self.assert_('grounded' in str(e))
def test_arg(self):
loader = roslaunch.xmlloader.XmlLoader()
def _load(self, test_file):
loader = roslaunch.xmlloader.XmlLoader()
mock = RosLaunchMock()
self.assert_(os.path.exists(test_file), "cannot locate test file %s"%test_file)
loader.load(test_file, mock)
return mock
def test_arg_all(self):
loader = roslaunch.xmlloader.XmlLoader()
filename = os.path.join(self.xml_dir, 'test-arg-all.xml')
# Test suite A: load without an optional arg set externally
mock = RosLaunchMock()
loader.load(filename, mock, argv=["required:=test_arg"])
param_d = {}
for p in mock.params:
param_d[p.key] = p.value
# Sanity check: Parent namespace
self.assertEquals(param_d['/p1_test'], 'test_arg')
self.assertEquals(param_d['/p2_test'], 'not_set')
self.assertEquals(param_d['/p3_test'], 'parent')
# Test case 1: include without pass_all_args
self.assertEquals(param_d['/notall/include_test/p1_test'], 'test_arg')
self.assertEquals(param_d['/notall/include_test/p2_test'], 'not_set')
self.assertEquals(param_d['/notall/include_test/p3_test'], 'set')
# Test case 2: include without pass_all_args attribute, and pass optional arg
# internally
self.assertEquals(param_d['/notall_optional/include_test/p1_test'],
'test_arg')
self.assertEquals(param_d['/notall_optional/include_test/p2_test'],
'not_set')
self.assertEquals(param_d['/notall_optional/include_test/p3_test'],
'set')
# Test case 3: include with pass_all_args attribute, instead of passing individual
# args
self.assertEquals(param_d['/all/include_test/p1_test'], 'test_arg')
self.assertEquals(param_d['/all/include_test/p2_test'], 'not_set')
self.assertEquals(param_d['/all/include_test/p3_test'], 'set')
# Test case 4: include with pass_all_args attribute, and override one
# arg inside the include tag
self.assertEquals(param_d['/all_override/include_test/p1_test'],
'override')
self.assertEquals(param_d['/all_override/include_test/p2_test'],
'not_set')
self.assertEquals(param_d['/all_override/include_test/p3_test'], 'set')
# Test suite B: load with an optional arg set externally
mock = RosLaunchMock()
loader.load(filename,
mock,
argv=["required:=test_arg", "optional:=test_arg2"])
param_d = {}
for p in mock.params:
param_d[p.key] = p.value
# Sanity check: Parent namespace
self.assertEquals(param_d['/p1_test'], 'test_arg')
self.assertEquals(param_d['/p2_test'], 'test_arg2')
self.assertEquals(param_d['/p3_test'], 'parent')
# Test case 1: include without pass_all_args attribute
self.assertEquals(param_d['/notall/include_test/p1_test'], 'test_arg')
self.assertEquals(param_d['/notall/include_test/p2_test'], 'not_set')
self.assertEquals(param_d['/notall/include_test/p3_test'], 'set')
# Test case 2: include without pass_all_args attribute, and pass optional arg
# internally
self.assertEquals(param_d['/notall_optional/include_test/p1_test'],
'test_arg')
self.assertEquals(param_d['/notall_optional/include_test/p2_test'],
'test_arg2')
self.assertEquals(param_d['/notall_optional/include_test/p3_test'],
'set')
# Test case 3: include with pass_all_args attribute, instead of passing individual
# args
self.assertEquals(param_d['/all/include_test/p1_test'], 'test_arg')
self.assertEquals(param_d['/all/include_test/p2_test'], 'test_arg2')
self.assertEquals(param_d['/all/include_test/p3_test'], 'set')
# Test case 4: include with pass_all_args attribute, and override one
# arg inside the include tag
self.assertEquals(param_d['/all_override/include_test/p1_test'],
'override')
self.assertEquals(param_d['/all_override/include_test/p2_test'],
'test_arg2')
self.assertEquals(param_d['/all_override/include_test/p3_test'], 'set')
def load_config_default(roslaunch_files, port, roslaunch_strs=None, loader=None, verbose=False, assign_machines=True, ignore_unset_args=False):
"""
Base routine for creating a ROSLaunchConfig from a set of
roslaunch_files and or launch XML strings and initializing it. This
config will have a core definition and also set the master to run
on port.
@param roslaunch_files: list of launch files to load. Each item may also
be a tuple where the first item is the launch file and the second item
is a string containing arguments.
@type roslaunch_files: [str|(str, str)]
@param port: roscore/master port override. Set to 0 or None to use default.
@type port: int
@param roslaunch_strs: (optional) roslaunch XML strings to load
@type roslaunch_strs: [str]
@param verbose: (optional) print info to screen about model as it is loaded.
@type verbose: bool
@param assign_machines: (optional) assign nodes to machines (default: True)
@type assign_machines: bool
@param ignore_unset_args: (optional) ignore default arg requirements (default: False)
@type ignore_unset_args: bool
@return: initialized rosconfig instance
@rytpe: L{ROSLaunchConfig} initialized rosconfig instance
@raises: RLException
"""
logger = logging.getLogger('roslaunch.config')
# This is the main roslaunch server process. Load up the
# files specified on the command line and launch the
# requested resourcs.
config = ROSLaunchConfig()
if port:
config.master.uri = rosgraph.network.create_local_xmlrpc_uri(port)
loader = loader or roslaunch.xmlloader.XmlLoader()
loader.ignore_unset_args = ignore_unset_args
# load the roscore file first. we currently have
# last-declaration wins rules. roscore is just a
# roslaunch file with special load semantics
load_roscore(loader, config, verbose=verbose)
# load the roslaunch_files into the config
for f in roslaunch_files:
if isinstance(f, tuple):
f, args = f
else:
args = None
try:
logger.info('loading config file %s'%f)
loader.load(f, config, argv=args, verbose=verbose)
except roslaunch.xmlloader.XmlParseException as e:
raise RLException(e)
except roslaunch.loader.LoadException as e:
raise RLException(e)
# we need this for the hardware test systems, which builds up
# roslaunch launch files in memory
if roslaunch_strs:
for launch_str in roslaunch_strs:
try:
logger.info('loading config file from string')
loader.load_string(launch_str, config)
except roslaunch.xmlloader.XmlParseException as e:
raise RLException('Launch string: %s\nException: %s'%(launch_str, e))
except roslaunch.loader.LoadException as e:
raise RLException('Launch string: %s\nException: %s'%(launch_str, e))
# choose machines for the nodes
if assign_machines:
config.assign_machines()
return config
def test_arg(self):
loader = roslaunch.xmlloader.XmlLoader()
filename = os.path.join(self.xml_dir, 'test-arg.xml')
mock = RosLaunchMock()
loader.load(filename, mock, argv=["required:=test_arg", "if_test:=0"])
param_d = {}
for p in mock.params:
param_d[p.key] = p.value
self.assertEquals(param_d['/p1_test'], 'test_arg')
self.assertEquals(param_d['/p2_test'], 'not_set')
self.assertEquals(param_d['/p3_test'], 'set')
self.assertEquals(param_d['/succeed'], 'yes')
self.assertEquals(param_d['/if_test'], 'not_ran')
self.assertEquals(param_d['/if_param'], False)
self.assertEquals(param_d['/int_param'], 1234)
self.assertAlmostEquals(param_d['/float_param'], 3.)
self.failIf('/fail' in param_d)
# context tests
# - args are scoped to their context, and thus can be rebound in a sibling context
self.assertEquals(param_d['/context1'], 'group1')
self.assertEquals(param_d['/context2'], 'group2')
# include tests
self.assertEquals(param_d['/include_test/p1_test'], 'required1')
self.assertEquals(param_d['/include_test/p2_test'], 'not_set')
self.assertEquals(param_d['/include_test/p3_test'], 'set')
self.assertEquals(param_d['/include_test/p4_test'], 'initial')
self.assertEquals(param_d['/include2/include_test/p1_test'],
'required2')
self.assertEquals(param_d['/include2/include_test/p2_test'],
'optional2')
self.assertEquals(param_d['/include2/include_test/p3_test'], 'set')
self.assertEquals(param_d['/include2/include_test/p4_test'], 'new2')
self.assert_('/include3/include_test/p1_test' not in param_d)
self.assert_('/include3/include_test/p2_test' not in param_d)
self.assert_('/include3/include_test/p3_test' not in param_d)
self.assert_('/include3/include_test/p4_test' not in param_d)
# test again with optional value set
mock = RosLaunchMock()
loader.load(
filename,
mock,
argv=["required:=test_arg", "optional:=test_arg2", "if_test:=1"])
param_d = {}
for p in mock.params:
param_d[p.key] = p.value
self.assertEquals(param_d['/p1_test'], 'test_arg')
self.assertEquals(param_d['/p2_test'], 'test_arg2')
self.assertEquals(param_d['/p3_test'], 'set')
self.assertEquals(param_d['/context1'], 'group1')
self.assertEquals(param_d['/context2'], 'group2')
self.assertEquals(param_d['/succeed'], 'yes')
self.assertEquals(param_d['/if_test'], 'ran')
self.assertEquals(param_d['/if_param'], True)
self.failIf('/fail' in param_d)
# include tests
self.assertEquals(param_d['/include_test/p1_test'], 'required1')
self.assertEquals(param_d['/include_test/p2_test'], 'not_set')
self.assertEquals(param_d['/include_test/p3_test'], 'set')
self.assertEquals(param_d['/include_test/p4_test'], 'initial')
self.assertEquals(param_d['/include2/include_test/p1_test'],
'required2')
self.assertEquals(param_d['/include2/include_test/p2_test'],
'optional2')
self.assertEquals(param_d['/include2/include_test/p3_test'], 'set')
self.assertEquals(param_d['/include2/include_test/p4_test'], 'new2')
self.assertEquals(param_d['/include3/include_test/p1_test'],
'required3')
self.assertEquals(param_d['/include3/include_test/p2_test'],
'optional3')
self.assertEquals(param_d['/include3/include_test/p3_test'], 'set')
self.assertEquals(param_d['/include3/include_test/p4_test'], 'new3')
def test_arg_invalid(self):
mock = RosLaunchMock()
loader = roslaunch.xmlloader.XmlLoader()
filename = os.path.join(self.xml_dir, 'test-arg.xml')
# this should raise, not sure XmlParseException is what we want as it destroys semantic info
try:
loader.load(filename, mock, argv=[])
self.fail("should have raised with missing arg")
except roslaunch.xmlloader.XmlParseException, e:
self.assert_('required' in str(e))
# test with invalid $(arg unknown)
filename = os.path.join(self.xml_dir, 'test-arg-invalid-sub.xml')
try:
loader.load(filename, mock, argv=[])
self.fail("should have raised with unknown arg")
except roslaunch.xmlloader.XmlParseException, e:
self.assert_('missing' in str(e))
# test with invalid $(arg unknown)
filename = os.path.join(self.xml_dir, 'test-arg-invalid-redecl.xml')
try:
loader.load(filename, mock, argv=[])
self.fail("should have raised with multiple decl")
except roslaunch.xmlloader.XmlParseException, e:
self.assert_('grounded' in str(e))
def test_arg(self):
loader = roslaunch.xmlloader.XmlLoader()
filename = os.path.join(self.xml_dir, 'test-arg.xml')
def test_master(self):
from roslaunch.core import Master
old_env = os.environ.get('ROS_MASTER_URI', None)
try:
master_uri = 'http://foo:789'
os.environ['ROS_MASTER_URI'] = master_uri
tests = [
'test-master-1.xml',
'test-master-2.xml',
'test-master-3.xml',
'test-master-4.xml',
'test-master-5.xml',
]
for x in xrange(1, 6):
loader = roslaunch.xmlloader.XmlLoader()
for filename in tests:
filename = os.path.join(self.xml_dir,
'test-master-%s.xml' % x)
self.assert_(os.path.exists(filename))
mock = RosLaunchMock()
loader.load(filename, mock)
if x == 1:
self.assertEquals(Master.AUTO_START, mock.master.auto)
self.assertEquals(master_uri, mock.master.uri)
elif x == 2:
self.assertEquals(Master.AUTO_RESTART,
mock.master.auto)
self.assertEquals(master_uri, mock.master.uri)
elif x == 3:
self.assertEquals(Master.AUTO_NO, mock.master.auto)
self.assertEquals(master_uri, mock.master.uri)
elif x == 4:
self.assertEquals(Master.AUTO_NO, mock.master.auto)
self.assertEquals(master_uri, mock.master.uri)
elif x == 5:
self.assertEquals(Master.AUTO_NO, mock.master.auto)
host, port = roslib.network.parse_http_host_and_port(
mock.master.uri)
self.assertEquals(12345, port)
# should have been remapped to machine name
self.assertNotEquals(host, 'localhost')
tests = ['test-master-invalid-1.xml','test-master-invalid-2.xml', \
'test-master-invalid-3.xml', 'test-master-invalid-4.xml' ]
loader = roslaunch.xmlloader.XmlLoader()
for filename in tests:
filename = os.path.join(self.xml_dir, filename)
try:
self.assert_(os.path.exists(filename))
loader.load(filename, RosLaunchMock())
self.fail(
"xmlloader did not throw an xmlparseexception for [%s]"
% filename)
except roslaunch.xmlloader.XmlParseException, e:
pass
finally:
if old_env is None:
del os.environ['ROS_MASTER_URI']
else:
os.environ['ROS_MASTER_URI'] = old_env
