def parse(cls, entity: Entity, parser: Parser):
"""Parse node."""
# See parse method of `ExecuteProcess`
_, kwargs = super().parse(entity, parser, 'args')
kwargs['arguments'] = kwargs['args']
del kwargs['args']
kwargs['node_name'] = kwargs['name']
del kwargs['name']
kwargs['package'] = parser.parse_substitution(entity.get_attr('pkg'))
kwargs['node_executable'] = parser.parse_substitution(
entity.get_attr('exec'))
ns = entity.get_attr('namespace', optional=True)
if ns is not None:
kwargs['node_namespace'] = parser.parse_substitution(ns)
remappings = entity.get_attr('remap', optional=True)
if remappings is not None:
kwargs['remappings'] = [
(parser.parse_substitution(remap.get_attr('from')),
parser.parse_substitution(remap.get_attr('to')))
for remap in remappings
]
parameters = entity.get_attr('param',
data_type=List[Entity],
optional=True)
if parameters is not None:
kwargs['parameters'] = cls.parse_nested_parameters(
parameters, parser)
return cls, kwargs
def parse(
cls,
entity: Entity,
parser: Parser,
):
"""Return the `RosTimer` action and kwargs for constructing it."""
_, kwargs = super().parse(entity, parser)
kwargs['period'] = parser.parse_if_substitutions(
entity.get_attr('period', data_type=float, can_be_str=True))
kwargs['actions'] = [
parser.parse_action(child) for child in entity.children
]
return cls, kwargs
def parse(cls, entity: Entity, parser: Parser):
"""Parse."""
_, kwargs = super().parse(entity, parser)
kwargs['session_name'] = entity.get_attr('session-name')
append_timestamp = entity.get_attr('append-timestamp',
data_type=bool,
optional=True,
can_be_str=False)
if append_timestamp is not None:
kwargs['append_timestamp'] = append_timestamp
base_path = entity.get_attr('base-path', optional=True)
if base_path:
kwargs['base_path'] = parser.parse_substitution(base_path)
# Make sure to handle empty strings and replace with empty lists,
# otherwise an empty string enables all events
events_ust = entity.get_attr('events-ust', optional=True)
if events_ust is not None:
kwargs['events_ust'] = cls._parse_cmdline(events_ust, parser) \
if events_ust else []
events_kernel = entity.get_attr('events-kernel', optional=True)
if events_kernel is not None:
kwargs['events_kernel'] = cls._parse_cmdline(events_kernel, parser) \
if events_kernel else []
context_fields = entity.get_attr('context-fields', optional=True)
if context_fields is not None:
kwargs['context_fields'] = cls._parse_cmdline(context_fields, parser) \
if context_fields else []
context_names = entity.get_attr('context-names', optional=True)
if context_names is not None:
kwargs['context_names'] = cls._parse_cmdline(context_names, parser) \
if context_names else []
return cls, kwargs
def test_reset():
xml_file = \
"""\
<launch>
<let name="foo" value="FOO"/>
<let name="bar" value="BAR"/>
<reset>
<keep name="bar" value="$(var bar)"/>
<keep name="baz" value="BAZ"/>
</reset>
</launch>
""" # noqa: E501
xml_file = textwrap.dedent(xml_file)
root_entity, parser = Parser.load(io.StringIO(xml_file))
ld = parser.parse_description(root_entity)
assert isinstance(ld.entities[0], SetLaunchConfiguration)
assert isinstance(ld.entities[1], SetLaunchConfiguration)
assert isinstance(ld.entities[2], ResetLaunchConfigurations)
lc = LaunchContext()
assert len(lc.launch_configurations) == 0
ld.entities[0].visit(lc)
ld.entities[1].visit(lc)
assert len(lc.launch_configurations) == 2
assert 'foo' in lc.launch_configurations.keys()
assert lc.launch_configurations['foo'] == 'FOO'
assert 'bar' in lc.launch_configurations.keys()
assert lc.launch_configurations['bar'] == 'BAR'
ld.entities[2].visit(lc)
assert 'foo' not in lc.launch_configurations.keys()
assert 'bar' in lc.launch_configurations.keys()
assert lc.launch_configurations['bar'] == 'BAR'
assert 'baz' in lc.launch_configurations.keys()
assert lc.launch_configurations['baz'] == 'BAZ'
def test_group():
yaml_file = \
"""\
launch:
- let:
name: 'foo'
value: 'FOO'
- let:
name: 'bar'
value: 'BAR'
- group:
scoped: True
forwarding: False
keep:
- name: 'bar'
value: $(var bar)
- name: 'baz'
value: 'BAZ'
children:
- let:
name: 'var1'
value: 'asd'
- let:
name: 'var2'
value: 'asd'
""" # noqa: E501
yaml_file = textwrap.dedent(yaml_file)
root_entity, parser = Parser.load(io.StringIO(yaml_file))
ld = parser.parse_description(root_entity)
assert isinstance(ld.entities[0], SetLaunchConfiguration)
assert isinstance(ld.entities[1], SetLaunchConfiguration)
assert isinstance(ld.entities[2], GroupAction)
lc = LaunchContext()
assert 0 == len(lc.launch_configurations)
ld.entities[0].visit(lc)
ld.entities[1].visit(lc)
assert 2 == len(lc.launch_configurations)
assert 'foo' in lc.launch_configurations.keys()
assert 'FOO' == lc.launch_configurations['foo']
assert 'bar' in lc.launch_configurations.keys()
assert 'BAR' == lc.launch_configurations['bar']
actions = ld.entities[2].execute(lc)
assert 5 == len(actions)
assert isinstance(actions[0], PushLaunchConfigurations)
assert isinstance(actions[1], ResetLaunchConfigurations)
assert isinstance(actions[2], SetLaunchConfiguration)
assert isinstance(actions[3], SetLaunchConfiguration)
assert isinstance(actions[4], PopLaunchConfigurations)
actions[0].visit(lc)
actions[1].visit(lc)
assert 'foo' not in lc.launch_configurations.keys()
assert 'bar' in lc.launch_configurations.keys()
assert 'BAR' == lc.launch_configurations['bar']
assert 'baz' in lc.launch_configurations.keys()
assert 'BAZ' == lc.launch_configurations['baz']
actions[2].visit(lc)
actions[3].visit(lc)
actions[4].visit(lc)
def test_executable():
"""Parse executable yaml example."""
yaml_file = \
"""\
launch:
- executable:
cmd: ls -l -a -s
cwd: '/'
name: my_ls
shell: true
output: log
launch_prefix: $(env LAUNCH_PREFIX)
env:
- name: var
value: '1'
"""
yaml_file = textwrap.dedent(yaml_file)
root_entity, parser = Parser.load(io.StringIO(yaml_file))
ld = parser.parse_description(root_entity)
executable = ld.entities[0]
cmd = [i[0].perform(None) for i in executable.cmd]
assert(
cmd == ['ls', '-l', '-a', '-s'])
assert(executable.cwd[0].perform(None) == '/')
assert(executable.name[0].perform(None) == 'my_ls')
assert(executable.shell is True)
assert(executable.output == 'log')
key, value = executable.additional_env[0]
key = key[0].perform(None)
value = value[0].perform(None)
assert(key == 'var')
assert(value == '1')
ls = LaunchService()
ls.include_launch_description(ld)
assert(0 == ls.run())
def _assert_launch_frontend_no_errors(self, file) -> Trace:
root_entity, parser = Parser.load(file)
ld = parser.parse_description(root_entity)
ls = LaunchService()
ls.include_launch_description(ld)
assert 0 == ls.run()
trace_action = ld.describe_sub_entities()[0]
return trace_action
def check_launch_namespace(file):
root_entity, parser = Parser.load(file)
ld = parser.parse_description(root_entity)
ls = LaunchService()
ls.include_launch_description(ld)
assert 0 == ls.run()
assert 'ros_namespace' in ls.context.launch_configurations
assert '/asd' == ls.context.launch_configurations['ros_namespace']
def _parse_cmdline(cls, cmd: Text,
parser: Parser) -> List[SomeSubstitutionsType]:
"""
Parse text apt for command line execution.
:param: cmd a space (' ') delimited command line arguments list.
All found `TextSubstitution` items are split and added to the
list again as a `TextSubstitution`.
:return: a list of command line arguments.
"""
result_args = []
arg: List[SomeSubstitutionsType] = []
def _append_arg():
nonlocal arg
result_args.append(arg)
arg = []
for sub in parser.parse_substitution(cmd):
if isinstance(sub, TextSubstitution):
tokens = shlex.split(sub.text)
if not tokens:
# Sting with just spaces.
# Appending args allow splitting two substitutions
# separated by a space.
# e.g.: `$(subst1 asd) $(subst2 bsd)` will be two separate arguments.
_append_arg()
continue
if sub.text[0].isspace():
# Needed for splitting from the previous argument
# e.g.: `$(find-exec bsd) asd`
# It splits `asd` from the path of `bsd` executable.
if len(arg) != 0:
_append_arg()
arg.append(TextSubstitution(text=tokens[0]))
if len(tokens) > 1:
# Needed to split the first argument when more than one token.
# e.g. `$(find-pkg-prefix csd)/asd bsd`
# will split `$(find-pkg-prefix csd)/asd` from `bsd`.
_append_arg()
arg.append(TextSubstitution(text=tokens[-1]))
if len(tokens) > 2:
# If there are more than two tokens, just add all the middle tokens to
# `result_args`.
# e.g. `$(find-pkg-prefix csd)/asd bsd dsd xsd`
# 'bsd' 'dsd' will be added.
result_args.extend([TextSubstitution(text=x)]
for x in tokens[1:-1])
if sub.text[-1].isspace():
# Allows splitting from next argument.
# e.g. `exec $(find-some-file)`
# Will split `exec` argument from the result of `find-some-file` substitution.
_append_arg()
else:
arg.append(sub)
if arg:
result_args.append(arg)
return result_args
def check_launch_node(file):
root_entity, parser = Parser.load(file)
ld = parser.parse_description(root_entity)
ls = LaunchService()
ls.include_launch_description(ld)
assert(0 == ls.run())
evaluated_parameters = evaluate_parameters(
ls.context,
ld.describe_sub_entities()[3]._Node__parameters
)
assert len(evaluated_parameters) == 3
assert isinstance(evaluated_parameters[0], dict)
assert isinstance(evaluated_parameters[1], dict)
assert isinstance(evaluated_parameters[2], pathlib.Path)
assert 'param1' in evaluated_parameters[0]
assert evaluated_parameters[0]['param1'] == 'ads'
param_dict = evaluated_parameters[1]
assert 'param_group1.param_group2.param2' in param_dict
assert 'param_group1.param3' in param_dict
assert 'param_group1.param4' in param_dict
assert 'param_group1.param5' in param_dict
assert 'param_group1.param6' in param_dict
assert 'param_group1.param7' in param_dict
assert 'param_group1.param8' in param_dict
assert 'param_group1.param9' in param_dict
assert 'param_group1.param10' in param_dict
assert 'param_group1.param11' in param_dict
assert 'param_group1.param12' in param_dict
assert 'param_group1.param13' in param_dict
assert 'param_group1.param14' in param_dict
assert 'param_group1.param15' in param_dict
assert param_dict['param_group1.param_group2.param2'] == 2
assert param_dict['param_group1.param3'] == [2, 5, 8]
assert param_dict['param_group1.param4'] == [2, 5, 8]
assert param_dict['param_group1.param5'] == '[2, 5, 8]'
assert param_dict['param_group1.param6'] == [2., 5., 8.]
assert param_dict['param_group1.param7'] == ['2', '5', '8']
assert param_dict['param_group1.param8'] == ["'2'", "'5'", "'8'"]
assert param_dict['param_group1.param9'] == ["'2'", "'5'", "'8'"]
assert param_dict['param_group1.param10'] == ["'asd'", "'bsd'", "'csd'"]
assert param_dict['param_group1.param11'] == ['asd', 'bsd', 'csd']
assert param_dict['param_group1.param12'] == ''
assert param_dict['param_group1.param13'] == '100'
assert param_dict['param_group1.param14'] == ["'2'", "'5'", "'8'"]
assert param_dict['param_group1.param15'] == ['2', '5', '8']
# Check remappings exist
remappings = ld.describe_sub_entities()[3]._Node__remappings
assert remappings is not None
assert len(remappings) == 2
listener_node_action = ld.describe_sub_entities()[4]
listener_node_cmd = listener_node_action.process_details['cmd']
assert [
sys.executable, '-c', 'import sys; print(sys.argv[1:])'
] == listener_node_cmd[:3]
def test_node_frontend(file):
"""Parse node xml example."""
root_entity, parser = Parser.load(io.StringIO(file))
ld = parser.parse_description(root_entity)
ls = LaunchService()
ls.include_launch_description(ld)
assert 0 == ls.run()
assert 'ros_namespace' in ls.context.launch_configurations
assert '/asd' == ls.context.launch_configurations['ros_namespace']
def generate_launch_description():
xml_file_path = str(
os.path.join(get_package_share_directory('crs_application'), 'launch',
XML_FILE_NAME))
print('Opening ROS2 launch file: %s' % (xml_file_path))
root_entity, parser = Parser.load(xml_file_path)
ld = parser.parse_description(root_entity)
return ld
def test_append_env():
xml_file = \
"""\
<launch>
<append_env name="my_env_var" value="asd"/>
<append_env name="my_env_var" value="zxc" separator="|"/>
<append_env name="my_other_env_var" value="fgh"/>
<append_env name="my_other_env_var" value="jkl" prepend="false"/>
<append_env name="my_other_env_var" value="qwe" prepend="yes"/>
<append_env name="my_other_env_var" value="rty" prepend="true" separator="|"/>
</launch>
"""
xml_file = textwrap.dedent(xml_file)
root_entity, parser = Parser.load(io.StringIO(xml_file))
ld = parser.parse_description(root_entity)
assert len(ld.entities) == 6
assert isinstance(ld.entities[0], AppendEnvironmentVariable)
assert isinstance(ld.entities[1], AppendEnvironmentVariable)
assert isinstance(ld.entities[2], AppendEnvironmentVariable)
assert isinstance(ld.entities[3], AppendEnvironmentVariable)
assert isinstance(ld.entities[4], AppendEnvironmentVariable)
assert isinstance(ld.entities[5], AppendEnvironmentVariable)
assert 'my_env_var' == ''.join(
[x.perform(None) for x in ld.entities[0].name])
assert 'my_env_var' == ''.join(
[x.perform(None) for x in ld.entities[0].name])
assert 'my_other_env_var' == ''.join(
[x.perform(None) for x in ld.entities[2].name])
assert 'my_other_env_var' == ''.join(
[x.perform(None) for x in ld.entities[3].name])
assert 'my_other_env_var' == ''.join(
[x.perform(None) for x in ld.entities[4].name])
assert 'my_other_env_var' == ''.join(
[x.perform(None) for x in ld.entities[5].name])
assert 'asd' == ''.join([x.perform(None) for x in ld.entities[0].value])
assert 'zxc' == ''.join([x.perform(None) for x in ld.entities[1].value])
assert 'fgh' == ''.join([x.perform(None) for x in ld.entities[2].value])
assert 'jkl' == ''.join([x.perform(None) for x in ld.entities[3].value])
assert 'qwe' == ''.join([x.perform(None) for x in ld.entities[4].value])
assert 'rty' == ''.join([x.perform(None) for x in ld.entities[5].value])
assert not ld.entities[0].prepend
assert not ld.entities[1].prepend
assert not ld.entities[2].prepend
assert not ld.entities[3].prepend
assert ld.entities[4].prepend
assert ld.entities[5].prepend
assert os.pathsep == ''.join(
[x.perform(None) for x in ld.entities[0].separator])
assert '|' == ''.join([x.perform(None) for x in ld.entities[1].separator])
assert os.pathsep == ''.join(
[x.perform(None) for x in ld.entities[2].separator])
assert os.pathsep == ''.join(
[x.perform(None) for x in ld.entities[3].separator])
assert os.pathsep == ''.join(
[x.perform(None) for x in ld.entities[4].separator])
assert '|' == ''.join([x.perform(None) for x in ld.entities[5].separator])
def test_deprecated_launch_file():
xml_file = \
"""\
<launch deprecated="MY_DEPRECATED_MESSAGE"/>
"""
xml_file = textwrap.dedent(xml_file)
root_entity, parser = Parser.load(io.StringIO(xml_file))
ld = parser.parse_description(root_entity)
assert isinstance(ld, LaunchDescription)
assert 'MY_DEPRECATED_MESSAGE' == ld.deprecated_reason
def test_arg_wrong_attribute():
xml_file = \
"""\
<launch>
<arg name="my_arg" whats_this="hello" default="asd" description="something"/>
</launch>
"""
xml_file = textwrap.dedent(xml_file)
root_entity, parser = Parser.load(io.StringIO(xml_file))
with pytest.raises(ValueError) as excinfo:
parser.parse_description(root_entity)
assert '`arg`' in str(excinfo.value)
assert 'whats_this' in str(excinfo.value)
def test_arg():
xml_file = \
"""\
<launch>
<arg name="my_arg" default="asd" description="something"/>
</launch>
"""
xml_file = textwrap.dedent(xml_file)
root_entity, parser = Parser.load(io.StringIO(xml_file))
ld = parser.parse_description(root_entity)
arg = ld.entities[0]
assert 'my_arg' == arg.name
assert 'asd' == ''.join([x.perform(None) for x in arg.default_value])
assert 'something' == arg.description
def test_unset_env():
xml_file = \
"""\
<launch>
<unset_env name="my_env_var"/>
</launch>
"""
xml_file = textwrap.dedent(xml_file)
root_entity, parser = Parser.load(io.StringIO(xml_file))
ld = parser.parse_description(root_entity)
assert len(ld.entities) == 1
unset_env = ld.entities[0]
assert isinstance(unset_env, UnsetEnvironmentVariable)
assert 'my_env_var' == ''.join([x.perform(None) for x in unset_env.name])
def parse(cls, entity: Entity, parser: Parser):
"""Parse load_composable_node."""
_, kwargs = super().parse(entity, parser)
kwargs['target_container'] = parser.parse_substitution(
entity.get_attr('target', data_type=str))
composable_nodes = entity.get_attr('composable_node', data_type=List[Entity])
kwargs['composable_node_descriptions'] = []
for entity in composable_nodes:
composable_node_cls, composable_node_kwargs = ComposableNode.parse(parser, entity)
kwargs['composable_node_descriptions'].append(
composable_node_cls(**composable_node_kwargs))
return cls, kwargs
def test_log():
launch_context = LaunchContext()
xml_file = \
"""\
<launch>
<log message="Hello world!" />
</launch>
"""
xml_file = textwrap.dedent(xml_file)
root_entity, parser = Parser.load(io.StringIO(xml_file))
launch_description = parser.parse_description(root_entity)
log_info = launch_description.entities[0]
assert isinstance(log_info, LogInfo)
assert perform_substitutions(launch_context,
log_info.msg) == 'Hello world!'
def test_group():
xml_file = \
"""\
<launch>
<let name="foo" value="FOO"/>
<let name="bar" value="BAR"/>
<group scoped="True" forwarding="False">
<keep name="bar" value="$(var bar)"/>
<keep name="baz" value="BAZ"/>
<let name="var1" value="asd"/>
<let name="var2" value="asd"/>
</group>
</launch>
""" # noqa: E501
xml_file = textwrap.dedent(xml_file)
root_entity, parser = Parser.load(io.StringIO(xml_file))
ld = parser.parse_description(root_entity)
assert isinstance(ld.entities[0], SetLaunchConfiguration)
assert isinstance(ld.entities[1], SetLaunchConfiguration)
assert isinstance(ld.entities[2], GroupAction)
lc = LaunchContext()
assert 0 == len(lc.launch_configurations)
ld.entities[0].visit(lc)
ld.entities[1].visit(lc)
assert 2 == len(lc.launch_configurations)
assert 'foo' in lc.launch_configurations.keys()
assert 'FOO' == lc.launch_configurations['foo']
assert 'bar' in lc.launch_configurations.keys()
assert 'BAR' == lc.launch_configurations['bar']
actions = ld.entities[2].execute(lc)
assert 5 == len(actions)
assert isinstance(actions[0], PushLaunchConfigurations)
assert isinstance(actions[1], ResetLaunchConfigurations)
assert isinstance(actions[2], SetLaunchConfiguration)
assert isinstance(actions[3], SetLaunchConfiguration)
assert isinstance(actions[4], PopLaunchConfigurations)
actions[0].visit(lc)
actions[1].visit(lc)
assert 'foo' not in lc.launch_configurations.keys()
assert 'bar' in lc.launch_configurations.keys()
assert 'BAR' == lc.launch_configurations['bar']
assert 'baz' in lc.launch_configurations.keys()
assert 'BAZ' == lc.launch_configurations['baz']
actions[2].visit(lc)
actions[3].visit(lc)
actions[4].visit(lc)
def test_list():
"""Parse tags with list attributes."""
xml_file = \
"""\
<root>
<tag attr="1,2,3" attr-sep=","/>
<tag attr="1 2 3" attr-sep=" "/>
<tag attr="1, 2, 3" attr-sep=", "/>
</root>
"""
xml_file = textwrap.dedent(xml_file)
root_entity, parser = Parser.load(io.StringIO(xml_file))
tags = root_entity.children
assert tags[0].get_attr('attr', data_type=List[str]) == ['1', '2', '3']
assert tags[0].get_attr('attr', data_type=List[int]) == [1, 2, 3]
assert tags[0].get_attr('attr', data_type=List[float]) == [1., 2., 3.]
def parse(cls, parser: Parser, entity: Entity):
"""Parse composable_node."""
from launch_ros.actions import Node
kwargs = {}
kwargs['package'] = parser.parse_substitution(entity.get_attr('pkg'))
kwargs['plugin'] = parser.parse_substitution(entity.get_attr('plugin'))
kwargs['name'] = parser.parse_substitution(entity.get_attr('name'))
namespace = entity.get_attr('namespace', optional=True)
if namespace is not None:
kwargs['namespace'] = parser.parse_substitution(namespace)
parameters = entity.get_attr('param', data_type=List[Entity], optional=True)
if parameters is not None:
kwargs['parameters'] = Node.parse_nested_parameters(parameters, parser)
remappings = entity.get_attr('remap', data_type=List[Entity], optional=True)
if remappings is not None:
kwargs['remappings'] = [
(
parser.parse_substitution(remap.get_attr('from')),
parser.parse_substitution(remap.get_attr('to'))
) for remap in remappings
]
for remap in remappings:
remap.assert_entity_completely_parsed()
extra_arguments = entity.get_attr('extra_arg', data_type=List[Entity], optional=True)
if extra_arguments is not None:
kwargs['extra_arguments'] = [
{
tuple(parser.parse_substitution(extra_arg.get_attr('name'))):
parser.parse_substitution(extra_arg.get_attr('value'))
} for extra_arg in extra_arguments
]
for extra_arg in extra_arguments:
extra_arg.assert_entity_completely_parsed()
entity.assert_entity_completely_parsed()
return cls, kwargs
def test_timer():
xml_file = \
"""\
<launch>
<timer period="5">
<executable cmd="ls -las"/>
</timer>
</launch>
"""
xml_file = textwrap.dedent(xml_file)
root_entity, parser = Parser.load(io.StringIO(xml_file))
ld = parser.parse_description(root_entity)
timer = ld.entities[0]
assert isinstance(timer, TimerAction)
assert isinstance(timer.period, float)
assert math.isclose(timer.period, 5.)
assert len(timer.actions) == 1
def parse(cls, entity: Entity, parser: Parser):
"""Parse node."""
# See parse method of `ExecuteProcess`
_, kwargs = super().parse(entity, parser, ignore=['cmd'])
args = entity.get_attr('args', optional=True)
if args is not None:
kwargs['arguments'] = super()._parse_cmdline(args, parser)
node_name = entity.get_attr('node-name', optional=True)
if node_name is not None:
kwargs['node_name'] = parser.parse_substitution(node_name)
node_name = entity.get_attr('name', optional=True)
if node_name is not None:
kwargs['name'] = parser.parse_substitution(node_name)
exec_name = entity.get_attr('exec_name', optional=True)
if exec_name is not None:
kwargs['exec_name'] = parser.parse_substitution(exec_name)
package = entity.get_attr('pkg', optional=True)
if package is not None:
kwargs['package'] = parser.parse_substitution(package)
kwargs['executable'] = parser.parse_substitution(
entity.get_attr('exec'))
ns = entity.get_attr('namespace', optional=True)
if ns is not None:
kwargs['namespace'] = parser.parse_substitution(ns)
remappings = entity.get_attr('remap',
data_type=List[Entity],
optional=True)
if remappings is not None:
kwargs['remappings'] = [
(parser.parse_substitution(remap.get_attr('from')),
parser.parse_substitution(remap.get_attr('to')))
for remap in remappings
]
for remap in remappings:
remap.assert_entity_completely_parsed()
parameters = entity.get_attr('param',
data_type=List[Entity],
optional=True)
if parameters is not None:
kwargs['parameters'] = cls.parse_nested_parameters(
parameters, parser)
return cls, kwargs
def test_let_var():
"""Parse let and var example."""
xml_file = \
"""\
<launch>
<let name="var1" value="asd"/>
<let name="var2" value="2 $(var var1)"/>
</launch>
"""
xml_file = textwrap.dedent(xml_file)
root_entity, parser = Parser.load(io.StringIO(xml_file))
ld = parser.parse_description(root_entity)
context = LaunchContext()
assert len(ld.entities) == 2
ld.entities[0].execute(context)
ld.entities[1].execute(context)
assert context.launch_configurations['var1'] == 'asd'
assert context.launch_configurations['var2'] == '2 asd'
def test_group():
xml_file = \
"""\
<launch>
<group scoped="False">
<let name="var1" value="asd"/>
<let name="var2" value="asd"/>
</group>
</launch>
""" # noqa: E501
xml_file = textwrap.dedent(xml_file)
root_entity, parser = Parser.load(io.StringIO(xml_file))
ld = parser.parse_description(root_entity)
group = ld.entities[0]
actions = group.execute(None)
assert 2 == len(actions)
assert isinstance(actions[0], SetLaunchConfiguration)
assert isinstance(actions[1], SetLaunchConfiguration)
def test_timer_period_is_substitution():
xml_file = \
"""\
<launch>
<timer period="$(var my_period 5)">
<executable cmd="ls -las"/>
</timer>
</launch>
"""
xml_file = textwrap.dedent(xml_file)
root_entity, parser = Parser.load(io.StringIO(xml_file))
ld = parser.parse_description(root_entity)
timer = ld.entities[0]
assert isinstance(timer, TimerAction)
assert isinstance(timer.period, list)
assert len(timer.period) == 1
assert isinstance(timer.period[0], LaunchConfiguration)
assert len(timer.actions) == 1
def test_node_frontend(file):
"""Parse node xml example."""
root_entity, parser = Parser.load(io.StringIO(file))
ld = parser.parse_description(root_entity)
ls = LaunchService()
ls.include_launch_description(ld)
assert (0 == ls.run())
evaluated_parameters = evaluate_parameters(
ls.context,
ld.describe_sub_entities()[2]._Node__parameters)
assert isinstance(evaluated_parameters[0], dict)
assert isinstance(evaluated_parameters[1], dict)
assert isinstance(evaluated_parameters[2], pathlib.Path)
assert 'param1' in evaluated_parameters[0]
assert evaluated_parameters[0]['param1'] == 'ads'
param_dict = evaluated_parameters[1]
assert 'param_group1.param_group2.param2' in param_dict
assert 'param_group1.param3' in param_dict
assert 'param_group1.param4' in param_dict
assert 'param_group1.param5' in param_dict
assert 'param_group1.param6' in param_dict
assert 'param_group1.param7' in param_dict
assert 'param_group1.param8' in param_dict
assert 'param_group1.param9' in param_dict
assert 'param_group1.param10' in param_dict
assert 'param_group1.param11' in param_dict
assert param_dict['param_group1.param_group2.param2'] == 2
assert param_dict['param_group1.param3'] == (2, 5, 8)
assert param_dict['param_group1.param4'] == (2, 5, 8)
assert param_dict['param_group1.param5'] == '[2, 5, 8]'
assert param_dict['param_group1.param6'] == (2., 5., 8.)
assert param_dict['param_group1.param7'] == ('2', '5', '8')
assert param_dict['param_group1.param8'] == ("'2'", "'5'", "'8'")
assert param_dict['param_group1.param9'] == ("'2'", "'5'", "'8'")
assert param_dict['param_group1.param10'] == ("'asd'", "'bsd'", "'csd'")
assert param_dict['param_group1.param11'] == ('asd', 'bsd', 'csd')
assert param_dict['param_group1.param12'] == ''
listener_node_action = ld.describe_sub_entities()[3]
listener_node_cmd = listener_node_action.process_details['cmd']
assert [sys.executable, '-c',
'import sys; print(sys.argv[1:])'] == listener_node_cmd[:3]
def test_include():
"""Parse node xml example."""
# Always use posix style paths in launch XML files.
path = (Path(__file__).parent / 'executable.xml').as_posix()
xml_file = \
"""\
<launch>
<include file="{}"/>
</launch>
""".format(path) # noqa: E501
xml_file = textwrap.dedent(xml_file)
root_entity, parser = Parser.load(io.StringIO(xml_file))
ld = parser.parse_description(root_entity)
include = ld.entities[0]
assert isinstance(include, IncludeLaunchDescription)
assert isinstance(include.launch_description_source, AnyLaunchDescriptionSource)
ls = LaunchService(debug=True)
ls.include_launch_description(ld)
assert 0 == ls.run()
def test_reset():
yaml_file = \
"""\
launch:
- let:
name: 'foo'
value: 'FOO'
- let:
name: 'bar'
value: 'BAR'
- reset:
keep:
- name: 'bar'
value: $(var bar)
- name: 'baz'
value: 'BAZ'
""" # noqa: E501
print('Load YAML')
yaml_file = textwrap.dedent(yaml_file)
print('Load Parser')
root_entity, parser = Parser.load(io.StringIO(yaml_file))
print('Parse Description')
ld = parser.parse_description(root_entity)
assert isinstance(ld.entities[0], SetLaunchConfiguration)
assert isinstance(ld.entities[1], SetLaunchConfiguration)
assert isinstance(ld.entities[2], ResetLaunchConfigurations)
lc = LaunchContext()
assert len(lc.launch_configurations) == 0
ld.entities[0].visit(lc)
ld.entities[1].visit(lc)
assert len(lc.launch_configurations) == 2
assert 'foo' in lc.launch_configurations.keys()
assert lc.launch_configurations['foo'] == 'FOO'
assert 'bar' in lc.launch_configurations.keys()
assert lc.launch_configurations['bar'] == 'BAR'
ld.entities[2].visit(lc)
assert 'foo' not in lc.launch_configurations.keys()
assert 'bar' in lc.launch_configurations.keys()
assert lc.launch_configurations['bar'] == 'BAR'
assert 'baz' in lc.launch_configurations.keys()
assert lc.launch_configurations['baz'] == 'BAZ'
