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'