def test_set_and_unset_environment_variable_execute():
"""Test the execute() of the SetEnvironmentVariable and UnsetEnvironmentVariable classes."""
lc1 = LaunchContext()
# can set and overwrite environment variables
if 'NONEXISTENT_KEY' in os.environ:
del os.environ['NONEXISTENT_KEY']
assert os.environ.get('NONEXISTENT_KEY') is None
SetEnvironmentVariable('NONEXISTENT_KEY', 'value').visit(lc1)
assert os.environ.get('NONEXISTENT_KEY') == 'value'
SetEnvironmentVariable('NONEXISTENT_KEY', 'ANOTHER_NONEXISTENT_KEY').visit(lc1)
assert os.environ.get('NONEXISTENT_KEY') == 'ANOTHER_NONEXISTENT_KEY'
# can unset environment variables
if 'ANOTHER_NONEXISTENT_KEY' in os.environ:
del os.environ['ANOTHER_NONEXISTENT_KEY']
assert os.environ.get('ANOTHER_NONEXISTENT_KEY') is None
SetEnvironmentVariable('ANOTHER_NONEXISTENT_KEY', 'some value').visit(lc1)
assert os.environ.get('ANOTHER_NONEXISTENT_KEY') == 'some value'
UnsetEnvironmentVariable('ANOTHER_NONEXISTENT_KEY').visit(lc1)
assert os.environ.get('ANOTHER_NONEXISTENT_KEY') is None
# set and unset with substitutions
assert os.environ.get('ANOTHER_NONEXISTENT_KEY') is None
SetEnvironmentVariable(
'ANOTHER_NONEXISTENT_KEY',
EnvironmentVariable('NONEXISTENT_KEY')).visit(lc1)
assert os.environ.get('ANOTHER_NONEXISTENT_KEY') == 'ANOTHER_NONEXISTENT_KEY'
UnsetEnvironmentVariable(EnvironmentVariable('NONEXISTENT_KEY')).visit(lc1)
assert os.environ.get('ANOTHER_NONEXISTENT_KEY') is None
# cleanup environment variables
if 'NONEXISTENT_KEY' in os.environ:
del os.environ['NONEXISTENT_KEY']
def generate_launch_description():
parameters_file_dir = pathlib.Path(__file__).resolve().parent
parameters_file_path = parameters_file_dir /'test_ukf_localization_node_bag3.yaml'
os.environ['FILE_PATH'] = str(parameters_file_dir)
return LaunchDescription([
launch.actions.DeclareLaunchArgument(
'output_final_position',
default_value='false'),
launch.actions.DeclareLaunchArgument(
'output_location',
default_value='ukf3.txt'),
#*****test_ukf_localization_node_bag3.test*****
launch_ros.actions.Node(
package='robot_localization', node_executable='ukf_node', node_name='test_ukf_localization_node_bag3_ukf',
output='screen',
parameters=[
parameters_file_path,
str(parameters_file_path),
[EnvironmentVariable(name='FILE_PATH'), os.sep, 'test_ukf_localization_node_bag3.yaml'],
],
),
launch_ros.actions.Node(
package='robot_localization', node_executable='test_ukf_localization_node_bag3', node_name='test_ukf_localization_node_bag3_pose',
output='screen',
parameters=[
parameters_file_path,
str(parameters_file_path),
[EnvironmentVariable(name='FILE_PATH'), os.sep, 'test_ukf_localization_node_bag3.yaml'],
],
),
])
def test_launch_node_with_parameter_dict(self):
"""Test launching a node with parameters specified in a dictionary."""
os.environ['PARAM1_VALUE'] = 'param1_value'
os.environ['PARAM2'] = 'param2'
node_action = self._create_node(
parameters=[{
'param1': EnvironmentVariable(name='PARAM1_VALUE'),
EnvironmentVariable(name='PARAM2'): (EnvironmentVariable(name='PARAM2'), '_value'),
'param_group1': {
'list_params': [1.2, 3.4],
'param_group2': {
(EnvironmentVariable('PARAM2'), '_values'): ['param2_value'],
}
}
}],
)
self._assert_launch_no_errors([node_action])
# Check the expanded parameters (will be written to a file).
expanded_parameter_files = node_action._Node__expanded_parameter_files
assert len(expanded_parameter_files) == 1
with open(expanded_parameter_files[0], 'r') as h:
expanded_parameters_dict = yaml.load(h)
assert expanded_parameters_dict == {
'/my_ns': {
'my_node': {
'ros__parameters': {
'param1': 'param1_value',
'param2': 'param2_value',
'param_group1.list_params': (1.2, 3.4),
'param_group1.param_group2.param2_values': ('param2_value',),
}
}
}
}
def test_append_environment_variable_execute():
"""Test the execute() of the AppendEnvironmentVariable class."""
lc1 = LaunchContext()
# Sets environment variable if it does not exist
if 'NONEXISTENT_KEY' in os.environ:
del os.environ['NONEXISTENT_KEY']
assert os.environ.get('NONEXISTENT_KEY') is None
AppendEnvironmentVariable('NONEXISTENT_KEY', 'value').visit(lc1)
assert os.environ.get('NONEXISTENT_KEY') == 'value'
# Same result if prepending is enabled
del os.environ['NONEXISTENT_KEY']
AppendEnvironmentVariable('NONEXISTENT_KEY', 'value', prepend=True).visit(lc1)
assert os.environ.get('NONEXISTENT_KEY') == 'value'
# Appends to environment variable if it does exist
AppendEnvironmentVariable('NONEXISTENT_KEY', 'another value').visit(lc1)
assert os.environ.get('NONEXISTENT_KEY') == 'value' + os.pathsep + 'another value'
# Prepends to environment variable if it does exist and option is enabled
AppendEnvironmentVariable('NONEXISTENT_KEY', 'some value', prepend=True).visit(lc1)
assert os.environ.get('NONEXISTENT_KEY') == \
'some value' + os.pathsep + 'value' + os.pathsep + 'another value'
# Can use an optional separator
AppendEnvironmentVariable('NONEXISTENT_KEY', 'other value', separator='|').visit(lc1)
assert os.environ.get('NONEXISTENT_KEY') == \
'some value' + os.pathsep + 'value' + os.pathsep + 'another value' + '|' + 'other value'
# Appends/prepends with substitutions
assert os.environ.get('ANOTHER_NONEXISTENT_KEY') is None
AppendEnvironmentVariable(
'ANOTHER_NONEXISTENT_KEY',
EnvironmentVariable('NONEXISTENT_KEY'),
prepend=TextSubstitution(text='false')).visit(lc1)
assert os.environ.get('ANOTHER_NONEXISTENT_KEY') == \
'some value' + os.pathsep + 'value' + os.pathsep + 'another value' + '|' + 'other value'
os.environ['ANOTHER_NONEXISTENT_KEY'] = 'abc'
os.environ['SOME_SEPARATOR'] = '//'
AppendEnvironmentVariable(
'ANOTHER_NONEXISTENT_KEY',
TextSubstitution(text='def'),
separator=EnvironmentVariable('SOME_SEPARATOR'),
prepend=TextSubstitution(text='yes')).visit(lc1)
assert os.environ.get('ANOTHER_NONEXISTENT_KEY') == 'def' + '//' + 'abc'
# Cleanup environment variables
del os.environ['NONEXISTENT_KEY']
del os.environ['ANOTHER_NONEXISTENT_KEY']
del os.environ['SOME_SEPARATOR']
def test_launch_node_with_parameter_dict(self):
"""Test launching a node with parameters specified in a dictionary."""
os.environ['PARAM1_VALUE'] = 'param1_value'
os.environ['PARAM2'] = 'param2'
os.environ['PARAM4_INT'] = '100'
node_action = self._create_node(parameters=[{
'param1':
EnvironmentVariable(name='PARAM1_VALUE'),
EnvironmentVariable(name='PARAM2'):
(EnvironmentVariable(name='PARAM2'), '_value'),
'param_group1': {
'list_params': [1.2, 3.4],
'param_group2': {
(EnvironmentVariable('PARAM2'), '_values'):
['param2_value'],
}
},
'param3':
'',
'param4':
ParameterValue(EnvironmentVariable(name='PARAM4_INT'),
value_type=int),
}], )
self._assert_launch_no_errors([node_action])
# Check the expanded parameters (will be written to a file).
expanded_parameter_arguments = node_action._Node__expanded_parameter_arguments
assert len(expanded_parameter_arguments) == 1
file_path, is_file = expanded_parameter_arguments[0]
assert is_file
with open(file_path, 'r') as h:
expanded_parameters_dict = yaml.load(h, Loader=yaml.FullLoader)
assert expanded_parameters_dict == {
'/my_ns/my_node': {
'ros__parameters': {
'param1':
'param1_value',
'param2':
'param2_value',
'param3':
'',
'param4':
100,
'param_group1.list_params': (1.2, 3.4),
'param_group1.param_group2.param2_values':
('param2_value', ),
}
}
}
def generate_launch_description():
parameters_file_dir = pathlib.Path(__file__).resolve().parent
parameters_file_path = parameters_file_dir / 'test_ekf_localization_node_bag2.yaml'
os.environ['FILE_PATH'] = str(parameters_file_dir)
ekf_node = launch_ros.actions.Node(
package='robot_localization',
node_executable='ekf_node',
node_name='test_ekf_localization_node_bag2_ekf',
output='screen',
parameters=[
parameters_file_path,
str(parameters_file_path),
[
EnvironmentVariable(name='FILE_PATH'), os.sep,
'test_ekf_localization_node_bag2.yaml'
],
],
)
test_ekf_localization_node_bag2 = launch_ros.actions.Node(
package='robot_localization',
node_executable='test_ekf_localization_node_bag2',
node_name='test_ekf_localization_node_bag2_pose',
output='screen',
parameters=[
parameters_file_path,
str(parameters_file_path),
[
EnvironmentVariable(name='FILE_PATH'), os.sep,
'test_ekf_localization_node_bag2.yaml'
],
],
)
return LaunchDescription([
launch.actions.DeclareLaunchArgument('output_final_position',
default_value='False'),
launch.actions.DeclareLaunchArgument('output_location',
default_value='ekf2.txt'),
ekf_node,
test_ekf_localization_node_bag2,
launch.actions.
RegisterEventHandler(event_handler=launch.event_handlers.OnProcessExit(
target_action=test_ekf_localization_node_bag2,
on_exit=[launch.actions.EmitEvent(event=launch.events.Shutdown())],
)),
])
def test_unset_nonexistent_key():
"""Test that the UnsetEnvironmentVariable class doesn't raise an exception."""
lc1 = LaunchContext()
assert os.environ.get('ANOTHER_NONEXISTENT_KEY') is None
UnsetEnvironmentVariable(EnvironmentVariable('NONEXISTENT_KEY')).visit(lc1)
assert os.environ.get('ANOTHER_NONEXISTENT_KEY') is None
def generate_launch_description():
# Currently the output flag doesn't append argument as prefix, but uses the argument as the full path instead
# The workaround is copied from the rosbag2 source code whereby we give the user the ability to put a directory
# as the prefix path to the timestamped folder
output_dir = datetime.now().strftime('rosbag2_%Y_%m_%d-%H_%M_%S')
# Launch arguments
launch_arg_rosbag_topics = DeclareLaunchArgument('topics',
default_value='-a')
launch_arg_rosbag_output = DeclareLaunchArgument(
'output_prefix',
default_value=[EnvironmentVariable('HOME'), '/rosbags/'])
# rosbag2 can only be run as an executable, not node action
process_rosbag_record = ExecuteProcess(
cmd=[
'ros2', 'bag', 'record',
LaunchConfiguration('topics'), '-o',
[LaunchConfiguration('output_prefix'), output_dir]
],
# cmd=['ros2', 'bag', 'record', LaunchConfiguration('topics')],
output='screen')
return LaunchDescription([
launch_arg_rosbag_topics, launch_arg_rosbag_output,
process_rosbag_record
])
def test_launch_node_with_parameter_descriptions(self):
"""Test launching a node with parameters specified in a dictionary."""
os.environ['PARAM1_VALUE'] = 'param1_value'
os.environ['PARAM2'] = 'param2'
node_action = self._create_node(parameters=[
Parameter(
name='param1',
value=EnvironmentVariable(name='PARAM1_VALUE'),
value_type=str,
),
Parameter(
name=EnvironmentVariable(name='PARAM2'),
value=[[EnvironmentVariable(name='PARAM2')], '_value'],
value_type=List[str],
),
Parameter(
name='param_group1.list_params',
value=[1.2, 3.4],
),
Parameter(
name=[
'param_group1.param_group2.',
EnvironmentVariable('PARAM2'), '_values'
],
value=['param2_value'],
),
Parameter(
name='param3',
value='',
),
], )
self._assert_launch_no_errors([node_action])
expanded_parameter_arguments = node_action._Node__expanded_parameter_arguments
assert len(expanded_parameter_arguments) == 5
parameters = []
for item, is_file in expanded_parameter_arguments:
assert not is_file
name, value = item.split(':=')
parameters.append((name, yaml.safe_load(value)))
assert parameters == [
('param1', 'param1_value'),
('param2', ['param2', '_value']),
('param_group1.list_params', [1.2, 3.4]),
('param_group1.param_group2.param2_values', ['param2_value']),
('param3', ''),
]
def test_action_substitutions(self) -> None:
self.assertIsNone(os.environ.get('LD_PRELOAD'))
tmpdir = tempfile.mkdtemp(
prefix='TestTraceAction__test_action_substitutions')
self.assertIsNone(os.environ.get('TestTraceAction__event_ust', None))
os.environ['TestTraceAction__event_ust'] = 'ros2:*'
self.assertIsNone(
os.environ.get('TestTraceAction__context_field', None))
os.environ['TestTraceAction__context_field'] = 'vpid'
session_name_arg = DeclareLaunchArgument(
'session-name',
default_value='my-session-name',
description='the session name',
)
action = Trace(
session_name=LaunchConfiguration(session_name_arg.name),
base_path=TextSubstitution(text=tmpdir),
events_kernel=[],
events_ust=[
EnvironmentVariable(name='TestTraceAction__event_ust'),
TextSubstitution(text='*'),
],
context_fields={
'kernel': [],
'userspace': [
EnvironmentVariable(name='TestTraceAction__context_field'),
TextSubstitution(text='vtid'),
],
},
)
self._assert_launch_no_errors([session_name_arg, action])
self._check_trace_action(action, tmpdir)
self.assertDictEqual(
action.context_fields,
{
'kernel': [],
'userspace': ['vpid', 'vtid'],
},
)
shutil.rmtree(tmpdir)
del os.environ['TestTraceAction__event_ust']
del os.environ['TestTraceAction__context_field']
del os.environ['LD_PRELOAD']
def generate_launch_description():
parameters_file_dir = pathlib.Path(__file__).resolve().parent
parameters_file_path = parameters_file_dir / 'test_ekf_localization_node_bag1.yaml'
os.environ['FILE_PATH'] = str(parameters_file_dir)
return LaunchDescription([
launch.actions.DeclareLaunchArgument('output_final_position',
default_value='false'),
launch.actions.DeclareLaunchArgument('output_location',
default_value='ekf1.txt'),
#launch_ros.actions.Node(
# package='tf2_ros', node_executable='static_transform_publisher',node_name='bl_imu', output='screen',
# arguments=['0', '-0.3', '0.52', '-1.570796327', '0', '1.570796327', 'base_link', 'imu_link']
#),
launch_ros.actions.Node(
package='robot_localization',
executable='ekf_node',
name='test_ekf_localization_node_bag1_ekf',
output='screen',
parameters=[
parameters_file_path,
str(parameters_file_path),
[
EnvironmentVariable(name='FILE_PATH'), os.sep,
'test_ekf_localization_node_bag1.yaml'
],
],
),
launch_ros.actions.Node(
package='robot_localization',
executable='test_ekf_localization_node_bag1',
name='test_ekf_localization_node_bag1_pose',
output='screen',
arguments=['--time-limit', '10'],
parameters=[
parameters_file_path,
str(parameters_file_path),
[
EnvironmentVariable(name='FILE_PATH'), os.sep,
'test_ekf_localization_node_bag1.yaml'
],
],
),
])
def generate_launch_description():
parameters_file_dir = pathlib.Path(__file__).resolve().parent
parameters_file_path = parameters_file_dir / 'test_filter_base_diagnostics_timestamps.yaml'
os.environ['FILE_PATH'] = str(parameters_file_dir)
#*****test_filter_base_diagnostics_timestamps.test*****
se_node = launch_ros.actions.Node(
package='robot_localization',
node_executable='se_node',
node_name='ekf_localization',
output='screen',
parameters=[
parameters_file_path,
str(parameters_file_path),
[
EnvironmentVariable(name='FILE_PATH'), os.sep,
'test_filter_base_diagnostics_timestamps.yaml'
],
],
)
test_filter_base_diagnostics_timestamps = launch_ros.actions.Node(
package='robot_localization',
node_executable='test_filter_base_diagnostics_timestamps',
node_name='test_filter_base_diagnostics',
output='screen',
parameters=[
parameters_file_path,
str(parameters_file_path),
[
EnvironmentVariable(name='FILE_PATH'), os.sep,
'test_filter_base_diagnostics_timestamps.yaml'
],
],
)
return LaunchDescription([
se_node,
test_filter_base_diagnostics_timestamps,
launch.actions.
RegisterEventHandler(event_handler=launch.event_handlers.OnProcessExit(
target_action=test_filter_base_diagnostics_timestamps,
on_exit=[launch.actions.EmitEvent(event=launch.events.Shutdown())],
)),
])
def test_launch_node_with_remappings(self):
"""Test launching a node with remappings."""
# Pass remapping rules to node in a variety of forms.
# It is redundant to pass the same rule, but the goal is to test different parameter types.
os.environ['TOPIC_NAME'] = 'chatter'
topic_prefix = 'new_'
node_action = self._create_node(remappings=[
('chatter', 'new_chatter'),
(EnvironmentVariable(name='TOPIC_NAME'),
[topic_prefix,
EnvironmentVariable(name='TOPIC_NAME')])
], )
self._assert_launch_no_errors([node_action])
# Check the expanded parameters.
expanded_remappings = node_action._Node__expanded_remappings
assert len(expanded_remappings) == 2
for i in range(2):
assert expanded_remappings[i] == ('chatter', 'new_chatter')
def generate_launch_description() -> launch.LaunchDescription:
"""
Launch file to launch rqt input device.
:argument: use_sim_time, whether the node should use the simulation time as published on the /clock topic.
:argument: ping_safety_node, whether the node should regularly send an Alive message for the safety node.
"""
layout_file = [
PathJoinSubstitution([
get_package_share_directory("march_rqt_input_device"),
"config",
LaunchConfiguration("layout"),
]),
".json",
]
return launch.LaunchDescription([
DeclareLaunchArgument(
name="node_prefix",
default_value=[EnvironmentVariable("USER"), "_"],
description="Prefix for node names",
),
DeclareLaunchArgument(
name="ping_safety_node",
default_value="True",
description="Whether to ping the safety node",
),
DeclareLaunchArgument(
name="use_sim_time",
default_value="False",
description="Whether to use simulation time",
),
DeclareLaunchArgument(
name="layout",
default_value="training",
description=
"Layout .json file to use. Must be in the config directory.",
),
Node(
package="march_rqt_input_device",
executable="input_device",
output="screen",
name="input_device",
namespace="march",
parameters=[
{
"use_sim_time": LaunchConfiguration("use_sim_time")
},
{
"ping_safety_node": LaunchConfiguration("ping_safety_node")
},
{
"layout_file": layout_file
},
],
),
])
def generate_launch_description():
parameters_file_dir = pathlib.Path(__file__).resolve().parent
parameters_file_path = parameters_file_dir / 'test_laser_assembler.yaml'
os.environ['FILE_PATH'] = str(parameters_file_dir)
os.environ['TOPIC_NAME'] = 'scan'
topic_prefix = 'dummy_'
dummy_scan_producer = launch_ros.actions.Node(
package='laser_assembler', node_executable='dummy_scan_producer', output='screen')
laser_scan_assembler = launch_ros.actions.Node(
package='laser_assembler', node_executable='laser_scan_assembler',
output='screen',
remappings=[
('scan', 'dummy_scan'),
(EnvironmentVariable(name='TOPIC_NAME'), [
topic_prefix, EnvironmentVariable(name='TOPIC_NAME')])
],
parameters=[
parameters_file_path,
str(parameters_file_path),
[EnvironmentVariable(name='FILE_PATH'), os.sep, 'test_laser_assembler.yaml'],
])
test_laser_assembler = launch_ros.actions.Node(
package='laser_assembler', node_executable='test_assembler',
output='screen'
)
return LaunchDescription([
launch.actions.DeclareLaunchArgument(
'output_final_position',
default_value='false'),
dummy_scan_producer,
laser_scan_assembler,
test_laser_assembler,
launch.actions.RegisterEventHandler(
event_handler=launch.event_handlers.OnProcessExit(
target_action=test_laser_assembler,
on_exit=[launch.actions.EmitEvent(event=launch.events.Shutdown())],
)),
])
def test_substituted_properties():
os.environ['EXECUTABLE_NAME'] = 'name'
os.environ['EXECUTABLE_CWD'] = 'cwd'
os.environ['EXECUTABLE_ENVVAR'] = 'var'
os.environ['EXECUTABLE_ENVVAL'] = 'value'
name = EnvironmentVariable('EXECUTABLE_NAME')
cwd = EnvironmentVariable('EXECUTABLE_CWD')
env = {
EnvironmentVariable('EXECUTABLE_ENVVAR'):
EnvironmentVariable('EXECUTABLE_ENVVAL')
}
exe = Executable(cmd=['test'], name=name, cwd=cwd, env=env)
exe.prepare(LaunchContext(), None)
assert exe.final_name.startswith('name')
assert exe.final_cwd == 'cwd'
assert exe.final_env == {'var': 'value'}
del os.environ['EXECUTABLE_NAME']
del os.environ['EXECUTABLE_CWD']
del os.environ['EXECUTABLE_ENVVAR']
del os.environ['EXECUTABLE_ENVVAL']
def generate_launch_description():
#TODO: modify the path and finish .yaml .rviz file
para_dir = os.path.join(get_package_share_directory('object_tracker'),
'config', 'para_track.yaml')
rviz_config_dir = os.path.join(
get_package_share_directory('object_tracker'), 'config',
'default.rviz')
return LaunchDescription([
DeclareLaunchArgument('node_prefix',
default_value=[EnvironmentVariable("USER"), '_'],
description='Prefix for node names'),
Node(
package='ibeo_8l_client',
node_namespace='ibeo_8l_client',
node_executable='ibeo_live',
node_name='ibeo_live',
parameters=[para_dir],
remappings=None,
arguments=None,
output='screen',
),
Node(
package='ibeo_8l_client',
node_namespace='ibeo_8l_client',
node_executable='obj_visualization',
node_name='obj_visualization',
parameters=[para_dir],
remappings=None,
arguments=None,
output='screen',
),
Node(
package='rviz2',
node_namespace='rviz2',
node_executable='rviz2',
node_name=[LaunchConfiguration("node_prefix"), 'rviz2'],
parameters=None,
remappings=None,
arguments=['-d', rviz_config_dir],
output='screen',
),
Node(
package='object_tracker',
node_namespace='object_tracker',
node_executable='object_tracker',
node_name='object_tracker',
parameters=[para_dir],
remappings=None,
arguments=None,
output='screen',
)
])
def generate_launch_description():
para_dir = os.path.join(get_package_share_directory('ibeo_8l_client'),
'config', 'para_file_sim.yaml')
rviz_config_dir = os.path.join(
get_package_share_directory('ibeo_8l_client'), 'config',
'default.rviz')
return LaunchDescription([
DeclareLaunchArgument('node_prefix',
default_value=[EnvironmentVariable("USER"), '_'],
description='Prefix for node names'),
Node(
package='ibeo_8l_client',
node_namespace='ibeo_8l_client',
node_executable='ibeo_file_sim',
# node_name=[launch.substitutions.LaunchConfiguration('node_prefix'), 'ibeo_file_sim'],
node_name='ibeo_file_sim',
parameters=[para_dir],
remappings=None,
arguments=None,
output='screen',
),
Node(
package='ibeo_8l_client',
node_namespace='ibeo_8l_client',
node_executable='obj_visualization',
# node_name=[LaunchConfiguration("node_prefix"), 'obj_visualization'],
node_name='obj_visualization',
parameters=[para_dir],
# parameters=None,
remappings=None,
arguments=None,
output='screen',
),
Node(
package='rviz2',
node_namespace='rviz2',
node_executable='rviz2',
node_name=[LaunchConfiguration("node_prefix"), 'rviz2'],
parameters=None,
remappings=None,
arguments=['-d', rviz_config_dir],
output='screen',
)
])
def generate_launch_description():
parameters_file_dir = pathlib.Path(__file__).resolve().parent
parameters_file_path = parameters_file_dir / 'test_filter_base_diagnostics_timestamps.yaml'
os.environ['FILE_PATH'] = str(parameters_file_dir)
ekf_node = launch_ros.actions.Node(
package='robot_localization',
node_executable='ekf_node',
node_name='test_filter_base_diagnostics_timestamps',
output='screen',
parameters=[
parameters_file_path,
str(parameters_file_path),
[EnvironmentVariable(name='FILE_PATH'), os.sep, 'test_filter_base_diagnostics_timestamps.yaml'],
],)
return LaunchDescription([
ekf_node,
])
def test_launch_node_with_parameter_files(self):
"""Test launching a node with parameters specified in yaml files."""
parameters_file_dir = pathlib.Path(__file__).resolve().parent
parameters_file_path = parameters_file_dir / 'example_parameters.yaml'
# Pass parameter files to node in a variety of forms.
# It is redundant to pass the same file, but the goal is to test different parameter types.
os.environ['FILE_PATH'] = str(parameters_file_dir)
node_action = self._create_node(
parameters=[
parameters_file_path,
str(parameters_file_path),
[EnvironmentVariable(name='FILE_PATH'), os.sep, 'example_parameters.yaml'],
],
)
self._assert_launch_no_errors([node_action])
# Check the expanded parameters.
expanded_parameter_files = node_action._Node__expanded_parameter_files
assert len(expanded_parameter_files) == 3
for i in range(3):
assert expanded_parameter_files[i] == str(parameters_file_path)
def generate_launch_description():
parameters_file_dir = pathlib.Path(__file__).resolve().parent
parameters_file_path = parameters_file_dir / 'test_ukf_localization_node_interfaces.yaml'
os.environ['FILE_PATH'] = str(parameters_file_dir)
#*****test_ukf_localization_node_interfaces.test*****
ukf_node = launch_ros.actions.Node(
package='robot_localization',
node_executable='ukf_node',
node_name='test_ukf_localization_node_interfaces_ukf',
output='screen',
parameters=[
parameters_file_path,
str(parameters_file_path),
[
EnvironmentVariable(name='FILE_PATH'), os.sep,
'test_ukf_localization_node_interfaces.yaml'
],
],
)
return LaunchDescription([
ukf_node,
])
def test_this_launch_file_path():
if 'MY_ENVIRONMENT_VARIABLE' in os.environ:
del os.environ['MY_ENVIRONMENT_VARIABLE']
lc = LaunchContext()
sub1 = EnvironmentVariable('MY_ENVIRONMENT_VARIABLE')
with pytest.raises(SubstitutionFailure) as ex:
sub1.perform(lc)
ex.match("environment variable 'MY_ENVIRONMENT_VARIABLE' does not exist")
sub2 = EnvironmentVariable('MY_ENVIRONMENT_VARIABLE', default_value='')
assert '' == sub2.perform(lc)
sub3 = EnvironmentVariable('MY_ENVIRONMENT_VARIABLE', default_value='MY_DEFAULT_VALUE')
assert 'MY_DEFAULT_VALUE' == sub3.perform(lc)
SetEnvironmentVariable('MY_ENVIRONMENT_VARIABLE', 'SOME_VALUE').visit(lc)
assert 'SOME_VALUE' == sub1.perform(lc)
assert 'SOME_VALUE' == sub2.perform(lc)
assert 'SOME_VALUE' == sub3.perform(lc)
del os.environ['MY_ENVIRONMENT_VARIABLE']
def generate_launch_description():
ld = LaunchDescription()
world_arg = DeclareLaunchArgument(
'world',
default_value='empty.world',
description='Gazebo world file'
)
headless_arg = DeclareLaunchArgument(
'headless',
default_value='false',
description="Set to 'true' to run gazebo headless"
)
# We need to add the models and worlds directories to env so gazebo can find them
triton_gazebo_dir = get_package_share_directory('triton_gazebo')
gmp = 'GAZEBO_MODEL_PATH'
add_model_path = SetEnvironmentVariable(
name=gmp,
value=[
EnvironmentVariable(gmp),
os.pathsep + os.path.join(triton_gazebo_dir, 'gazebo', 'models')
]
)
grp = 'GAZEBO_RESOURCE_PATH'
add_resource_path = SetEnvironmentVariable(
name=grp,
value=[
EnvironmentVariable(grp),
os.pathsep + os.path.join(triton_gazebo_dir, 'gazebo')
]
)
gazebo_server = IncludeLaunchDescription(
launch_description_source=PythonLaunchDescriptionSource(
os.path.join(get_package_share_directory('gazebo_ros'),
'launch', 'gzserver.launch.py')
),
launch_arguments={
'world': ['worlds/', LaunchConfiguration('world')],
'verbose': 'true'
}.items()
)
gazebo_client = IncludeLaunchDescription(
launch_description_source=PythonLaunchDescriptionSource(
os.path.join(get_package_share_directory('gazebo_ros'),
'launch', 'gzclient.launch.py')
),
condition=UnlessCondition(LaunchConfiguration('headless')),
)
ld.add_action(world_arg)
ld.add_action(headless_arg)
ld.add_action(add_model_path)
ld.add_action(add_resource_path)
ld.add_action(gazebo_server)
ld.add_action(gazebo_client)
return ld
