def test_setup_env(self): from roslaunch.core import setup_env, Node, Machine master_uri = 'http://masteruri:1234' n = Node('nodepkg', 'nodetype') m = Machine('name1', '1.2.3.4') d = setup_env(n, m, master_uri) self.assertEquals(d['ROS_MASTER_URI'], master_uri) m = Machine('name1', '1.2.3.4') d = setup_env(n, m, master_uri) val = os.environ['ROS_ROOT'] self.assertEquals(d['ROS_ROOT'], val) # test ROS_NAMESPACE # test stripping n = Node('nodepkg', 'nodetype', namespace="/ns2/") d = setup_env(n, m, master_uri) self.assertEquals(d['ROS_NAMESPACE'], "/ns2") # test node.env_args n = Node('nodepkg', 'nodetype', env_args=[('NENV1', 'val1'), ('NENV2', 'val2'), ('ROS_ROOT', '/new/root')]) d = setup_env(n, m, master_uri) self.assertEquals(d['ROS_ROOT'], "/new/root") self.assertEquals(d['NENV1'], "val1") self.assertEquals(d['NENV2'], "val2")
def handle_spawn_vehicle(self, req): """ Spawn new vehicle. This includes starting a new vehicle node and (if a looping node is set) calling its /set_loop service, as well as its /toggle_simulation service. @param req: I{(SpawnVehicle)} Request messgae of the service that spawns a new vehicle. """ namespace = "vehicle_" + str(req.vehicle_id) args = "%i %s %f %f %f %f" % (req.vehicle_id, req.class_name, req.x, req.y, req.yaw, req.v) node = Node('sml_world', 'vehicle.py', namespace=namespace, args=args, name=req.class_name.lower()) self.launch_queue.put(node) loop_service = '/' + namespace + '/set_loop' rospy.wait_for_service(loop_service) if bool(req.node_id): try: set_loop = rospy.ServiceProxy(loop_service, SetLoop) set_loop(req.node_id) except rospy.ServiceException, e: raise "Service call failed: %s" % e
def test_local_process_stop_timeouts(self): from roslaunch.core import Node, Machine # have to use real ROS configuration for these tests ros_root = os.environ['ROS_ROOT'] rpp = os.environ.get('ROS_PACKAGE_PATH', None) master_uri = 'http://masteruri:1234' m = Machine('name1', ros_root, rpp, '1.2.3.4') run_id = 'id' n = Node('roslaunch', 'signal_logger.py') n.name = 'logger' n.machine = m self.check_stop_timeouts(master_uri, n, run_id, 1.0, 1.0) self.check_stop_timeouts(master_uri, n, run_id, 0.00001, 1.0) # shorter sigterm times are risky in the test - the signal file might not get written; but in the wild, it's ok self.check_stop_timeouts(master_uri, n, run_id, 1.0, 0.001) self.check_stop_timeouts(master_uri, n, run_id, 2.0, 3.0)
def launch_coms(self): """Launch and register the communications used by the vehicle.""" # Go through list of comunication. for com in self.coms: com_name = com.partition(' ')[0] subpub_name = com_name.lower() + '_com' args = str(self.vehicle_id) + ' ' + com node = Node('sml_world', 'communication.py', namespace=self.namespace, args=args, name=com_name.lower()) self.launcher.launch(node) # Register subscriptions for each of them. rospy.Subscriber(self.namespace + subpub_name, getattr(msgs, com_name + 'Com'), getattr(self, 'process_' + subpub_name))
def launch_sensors(self): """Launch and register the sensors used by the vehicle.""" # Go through sensor list. for sensor in self.sensors: # Launch sensor node. sensor_name = sensor.partition(' ')[0] subpub_name = sensor_name.lower() + '_readings' args = str(self.vehicle_id) + ' ' + sensor node = Node('sml_world', 'sensor.py', namespace=self.namespace, args=args, name=sensor_name.lower()) self.launcher.launch(node) # Register subscriptions for each of them. rospy.Subscriber(self.namespace + subpub_name, getattr(msgs, sensor_name + 'Readings'), getattr(self, 'process_' + subpub_name))
def test_create_node_process(self): from roslaunch.core import Node, Machine, RLException from roslaunch.node_args import NodeParamsException from roslaunch.nodeprocess import create_node_process, LocalProcess # have to use real ROS configuration for these tests ros_root = os.environ['ROS_ROOT'] rpp = os.environ.get('ROS_PACKAGE_PATH', None) master_uri = 'http://masteruri:1234' m = Machine('name1', ros_root, rpp, '1.2.3.4') run_id = 'id' # test invalid params n = Node('not_a_real_package','not_a_node') n.machine = m n.name = 'foo' try: # should fail b/c node cannot be found create_node_process(run_id, n, master_uri) self.fail("should have failed") except NodeParamsException: pass # have to specify a real node n = Node('rospy','talker.py') n.machine = m try: # should fail b/c n.name is not set create_node_process(run_id, n, master_uri) self.fail("should have failed") except ValueError: pass # have to specify a real node n = Node('rospy','talker.py') n.machine = None n.name = 'talker' try: # should fail b/c n.machine is not set create_node_process(run_id, n, master_uri) self.fail("should have failed") except RLException: pass # basic integration test n.machine = m p = create_node_process(run_id, n, master_uri) self.assert_(isinstance(p, LocalProcess)) # repeat some setup_local_process_env tests d = p.env self.assertEquals(d['ROS_MASTER_URI'], master_uri) self.assertEquals(d['ROS_ROOT'], ros_root) self.assertEquals(d['PYTHONPATH'], os.environ['PYTHONPATH']) if rpp: self.assertEquals(d['ROS_PACKAGE_PATH'], rpp) for k in ['ROS_IP', 'ROS_NAMESPACE']: if k in d: self.fail('%s should not be set: %s'%(k,d[k])) # test package and name self.assertEquals(p.package, 'rospy') # - no 'correct' full answer here self.assert_(p.name.startswith('talker'), p.name) # test log_output n.output = 'log' self.assert_(create_node_process(run_id, n, master_uri).log_output) n.output = 'screen' self.failIf(create_node_process(run_id, n, master_uri).log_output) # test respawn n.respawn = True self.assert_(create_node_process(run_id, n, master_uri).respawn) n.respawn = False self.failIf(create_node_process(run_id, n, master_uri).respawn) # test cwd n.cwd = None self.assertEquals(create_node_process(run_id, n, master_uri).cwd, None) n.cwd = 'ros-root' self.assertEquals(create_node_process(run_id, n, master_uri).cwd, 'ros-root') n.cwd = 'node' self.assertEquals(create_node_process(run_id, n, master_uri).cwd, 'node') # test args # - simplest test (no args) n.args = '' p = create_node_process(run_id, n, master_uri) # - the first arg should be the path to the node executable rospack = rospkg.RosPack() cmd = roslib.packages.find_node('rospy', 'talker.py', rospack)[0] self.assertEquals(p.args[0], cmd) # - test basic args n.args = "arg1 arg2 arg3" p = create_node_process(run_id, n, master_uri) self.assertEquals(p.args[0], cmd) for a in "arg1 arg2 arg3".split(): self.assert_(a in p.args) # - test remap args n.remap_args = [('KEY1', 'VAL1'), ('KEY2', 'VAL2')] p = create_node_process(run_id, n, master_uri) self.assert_('KEY1:=VAL1' in p.args) self.assert_('KEY2:=VAL2' in p.args) # - test __name n = Node('rospy','talker.py') n.name = 'fooname' n.machine = m self.assert_('__name:=fooname' in create_node_process(run_id, n, master_uri).args) # - test substitution args os.environ['SUB_TEST'] = 'subtest' os.environ['SUB_TEST2'] = 'subtest2' n.args = 'foo $(env SUB_TEST) $(env SUB_TEST2)' p = create_node_process(run_id, n, master_uri) self.failIf('SUB_TEST' in p.args) self.assert_('foo' in p.args) self.assert_('subtest' in p.args) self.assert_('subtest2' in p.args)
def test_create_local_process_env(self): # this is almost entirely identical to the setup_env test in test_core, with some additional # higher level checks from roslaunch.core import Node, Machine from roslaunch.node_args import create_local_process_env ros_root = '/ros/root1' rpp = '/rpp1' master_uri = 'http://masteruri:1234' n = Node('nodepkg','nodetype') m = Machine('name1', ros_root, rpp, '1.2.3.4') d = create_local_process_env(n, m, master_uri) self.assertEquals(d['ROS_MASTER_URI'], master_uri) self.assertEquals(d['ROS_ROOT'], ros_root) self.assertEquals(d['PYTHONPATH'], os.path.join(ros_root, 'core', 'roslib', 'src')) self.assertEquals(d['ROS_PACKAGE_PATH'], rpp) for k in ['ROS_IP', 'ROS_NAMESPACE']: if k in d: self.fail('%s should not be set: %s'%(k,d[k])) # test that it inherits local environment env = os.environ.copy() env['PATH'] = '/some/path' env['FOO'] = 'foo' d = create_local_process_env(n, m, master_uri, env=env) self.assertEquals(d['FOO'], 'foo') # test that it defaults to os.environ os.environ['FOO'] = 'bar' d = create_local_process_env(n, m, master_uri) self.assertEquals(d['FOO'], 'bar') # test that our ROS_ROOT and PYTHONPATH override env env = os.environ.copy() env['ROS_ROOT'] = '/not/ros/root/' env['PYTHONPATH'] = '/some/path' d = create_local_process_env(n, m, master_uri, env=env) self.assertEquals(d['ROS_ROOT'], ros_root) self.assertEquals(d['PYTHONPATH'], os.path.join(ros_root, 'core', 'roslib', 'src')) # - make sure it didn't pollute original env self.assertEquals(env['ROS_ROOT'], '/not/ros/root/') self.assertEquals(env['PYTHONPATH'], '/some/path') # don't set ROS_ROOT and ROS_PACKAGE_PATH. ROS_ROOT should default, ROS_PACKAGE_PATH does not m = Machine('name1', '', '', '1.2.3.4') d = create_local_process_env(n, m, master_uri) val = os.environ['ROS_ROOT'] self.assertEquals(d['ROS_ROOT'], val) self.assertEquals(d['PYTHONPATH'], os.path.join(val, 'core', 'roslib', 'src')) self.failIf('ROS_PACKAGE_PATH' in d, 'ROS_PACKAGE_PATH should not be set: %s'%d) # test ROS_IP m = Machine('name1', ros_root, rpp, '1.2.3.4', ros_ip="4.5.6.7") n = Node('nodepkg','nodetype', namespace="/ns1") d = create_local_process_env(n, m, master_uri) self.assertEquals(d['ROS_NAMESPACE'], "/ns1") # test stripping n = Node('nodepkg','nodetype', namespace="/ns2/") d = create_local_process_env(n, m, master_uri) self.assertEquals(d['ROS_NAMESPACE'], "/ns2") # test ROS_NAMESPACE m = Machine('name1', ros_root, rpp, '1.2.3.4', ros_ip="4.5.6.7") d = create_local_process_env(n, m, master_uri) self.assertEquals(d['ROS_IP'], "4.5.6.7") # test node.env_args n = Node('nodepkg','nodetype', env_args=[('NENV1', 'val1'), ('NENV2', 'val2'), ('ROS_ROOT', '/new/root')]) d = create_local_process_env(n, m, master_uri) self.assertEquals(d['ROS_ROOT'], "/new/root") self.assertEquals(d['NENV1'], "val1") self.assertEquals(d['NENV2'], "val2") # test machine.env_args m = Machine('name1', ros_root, rpp, '1.2.3.4', ros_ip="4.5.6.7", env_args=[('MENV1', 'val1'), ('MENV2', 'val2'), ('ROS_ROOT', '/new/root2')]) n = Node('nodepkg','nodetype') d = create_local_process_env(n, m, master_uri) self.assertEquals(d['ROS_ROOT'], "/new/root2") self.assertEquals(d['MENV1'], "val1") self.assertEquals(d['MENV2'], "val2") # test node.env_args precedence m = Machine('name1', ros_root, rpp, '1.2.3.4', ros_ip="4.5.6.7", env_args=[('MENV1', 'val1'), ('MENV2', 'val2')]) n = Node('nodepkg','nodetype', env_args=[('MENV1', 'nodeval1')]) d = create_local_process_env(n, m, master_uri) self.assertEquals(d['MENV1'], "nodeval1") self.assertEquals(d['MENV2'], "val2")
def test_create_node_process(self): from roslaunch.core import Node, Machine, RLException from roslaunch.node_args import NodeParamsException from roslaunch.nodeprocess import create_node_process, LocalProcess # have to use real ROS configuration for these tests ros_root = os.environ['ROS_ROOT'] rpp = os.environ.get('ROS_PACKAGE_PATH', None) master_uri = 'http://masteruri:1234' m = Machine('name1', ros_root, rpp, '1.2.3.4') run_id = 'id' # test invalid params n = Node('not_a_real_package', 'not_a_node') n.machine = m n.name = 'foo' try: # should fail b/c node cannot be found create_node_process(run_id, n, master_uri) self.fail("should have failed") except NodeParamsException: pass # have to specify a real node n = Node('roslaunch', 'talker.py') n.machine = m try: # should fail b/c n.name is not set create_node_process(run_id, n, master_uri) self.fail("should have failed") except ValueError: pass # have to specify a real node n = Node('roslaunch', 'talker.py') n.machine = None n.name = 'talker' try: # should fail b/c n.machine is not set create_node_process(run_id, n, master_uri) self.fail("should have failed") except RLException: pass # basic integration test n.machine = m p = create_node_process(run_id, n, master_uri) self.assert_(isinstance(p, LocalProcess)) # repeat some setup_local_process_env tests d = p.env self.assertEquals(d['ROS_MASTER_URI'], master_uri) self.assertEquals(d['ROS_ROOT'], ros_root) self.assertEquals(d['PYTHONPATH'], os.environ['PYTHONPATH']) if rpp: self.assertEquals(d['ROS_PACKAGE_PATH'], rpp) for k in ['ROS_IP', 'ROS_NAMESPACE']: if k in d: self.fail('%s should not be set: %s' % (k, d[k])) # test package and name self.assertEquals(p.package, 'roslaunch') # - no 'correct' full answer here self.assert_(p.name.startswith('talker'), p.name) # test log_output n.output = 'log' self.assert_(create_node_process(run_id, n, master_uri).log_output) n.output = 'screen' self.failIf(create_node_process(run_id, n, master_uri).log_output) # test respawn n.respawn = True self.assert_(create_node_process(run_id, n, master_uri).respawn) n.respawn = False self.failIf(create_node_process(run_id, n, master_uri).respawn) # test cwd n.cwd = None self.assertEquals(create_node_process(run_id, n, master_uri).cwd, None) n.cwd = 'ros-root' self.assertEquals( create_node_process(run_id, n, master_uri).cwd, 'ros-root') n.cwd = 'node' self.assertEquals( create_node_process(run_id, n, master_uri).cwd, 'node') # sigint timeout self.assertEquals( create_node_process(run_id, n, master_uri).sigint_timeout, 15) self.assertEquals( create_node_process(run_id, n, master_uri, sigint_timeout=1).sigint_timeout, 1) self.assertRaises(RLException, create_node_process, run_id, n, master_uri, sigint_timeout=0) # sigterm timeout self.assertEquals( create_node_process(run_id, n, master_uri).sigterm_timeout, 2) self.assertEquals( create_node_process(run_id, n, master_uri, sigterm_timeout=1).sigterm_timeout, 1) self.assertRaises(RLException, create_node_process, run_id, n, master_uri, sigterm_timeout=0) # test args # - simplest test (no args) n.args = '' p = create_node_process(run_id, n, master_uri) # - the first arg should be the path to the node executable rospack = rospkg.RosPack() cmd = roslib.packages.find_node('roslaunch', 'talker.py', rospack)[0] self.assertEquals(p.args[0], cmd) # - test basic args n.args = "arg1 arg2 arg3" p = create_node_process(run_id, n, master_uri) self.assertEquals(p.args[0], cmd) for a in "arg1 arg2 arg3".split(): self.assert_(a in p.args) # - test remap args n.remap_args = [('KEY1', 'VAL1'), ('KEY2', 'VAL2')] p = create_node_process(run_id, n, master_uri) self.assert_('KEY1:=VAL1' in p.args) self.assert_('KEY2:=VAL2' in p.args) # - test __name n = Node('roslaunch', 'talker.py') n.name = 'fooname' n.machine = m self.assert_('__name:=fooname' in create_node_process( run_id, n, master_uri).args) # - test substitution args os.environ['SUB_TEST'] = 'subtest' os.environ['SUB_TEST2'] = 'subtest2' n.args = 'foo $(env SUB_TEST) $(env SUB_TEST2)' p = create_node_process(run_id, n, master_uri) self.failIf('SUB_TEST' in p.args) self.assert_('foo' in p.args) self.assert_('subtest' in p.args) self.assert_('subtest2' in p.args)
def test_Node(): from roslaunch.core import Node n = Node('package', 'node_type') assert n.package == 'package' assert n.type == 'node_type' assert n.xmltype() == 'node' assert n.xmlattrs() == [('pkg', 'package'), ('type', 'node_type'), ('machine', None), ('ns', '/'), ('args', ''), ('output', None), ('cwd', None), ('respawn', False), ('respawn_delay', 0.0), ('name', None), ('launch-prefix', None), ('required', False)], \ n.xmlattrs() assert n.output == None #tripwire for now n.to_xml() val = n.to_remote_xml() assert 'machine' not in val # test bad constructors try: n = Node('package', 'node_type', cwd='foo') assert False except ValueError: pass try: n = Node('package', 'node_type', output='foo') assert False except ValueError: pass try: n = Node('package', '') assert False except ValueError: pass try: n = Node('', 'node_type') assert False except ValueError: pass try: n = Node('package', 'node_type', name='ns/node') assert False except ValueError: pass try: n = Node('package', 'node_type', respawn=True, required=True) assert False except ValueError: pass
def _node_tag(self, tag, context, ros_config, default_machine, is_test=False, verbose=True): """ Process XML <node> or <test> tag @param tag: DOM node @type tag: Node @param context: namespace context @type context: L{LoaderContext} @param params: ROS parameter list @type params: [L{Param}] @param clear_params: list of ROS parameter names to clear before setting parameters @type clear_params: [str] @param default_machine: default machine to assign to node @type default_machine: str @param is_test: if set, will load as L{Test} object instead of L{Node} object @type is_test: bool """ try: if is_test: self._check_attrs(tag, context, ros_config, XmlLoader.TEST_ATTRS) (name,) = self.opt_attrs(tag, context, ('name',)) test_name, time_limit, retry = self._test_attrs(tag, context) if not name: name = test_name else: self._check_attrs(tag, context, ros_config, XmlLoader.NODE_ATTRS) (name,) = self.reqd_attrs(tag, context, ('name',)) if not roslib.names.is_legal_name(name): ros_config.add_config_error("WARN: illegal <node> name '%s'.\nhttp://ros.org/wiki/Names\nThis will likely cause problems with other ROS tools.\nNode xml is %s"%(name, tag.toxml())) child_ns = self._ns_clear_params_attr('node', tag, context, ros_config, node_name=name) param_ns = child_ns.child(name) # required attributes pkg, node_type = self.reqd_attrs(tag, context, ('pkg', 'type')) # optional attributes machine, args, output, respawn, cwd, launch_prefix, required = \ self.opt_attrs(tag, context, ('machine', 'args', 'output', 'respawn', 'cwd', 'launch-prefix', 'required')) if tag.hasAttribute('machine') and not len(machine.strip()): raise XmlParseException("<node> 'machine' must be non-empty: [%s]"%machine) if not machine and default_machine: machine = default_machine.name # validate respawn, required required, respawn = [_bool_attr(*rr) for rr in ((required, False, 'required'),\ (respawn, False, 'respawn'))] # each node gets its own copy of <remap> arguments, which # it inherits from its parent remap_context = context.child('') # nodes can have individual env args set in addition to # the ROS-specific ones. for t in [c for c in tag.childNodes if c.nodeType == DomNode.ELEMENT_NODE]: tag_name = t.tagName.lower() if tag_name == 'remap': r = self._remap_tag(t, context, ros_config) if r is not None: remap_context.add_remap(r) elif tag_name == 'param': self._param_tag(t, param_ns, ros_config, force_local=True, verbose=verbose) elif tag_name == 'rosparam': self._rosparam_tag(t, param_ns, ros_config, verbose=verbose) elif tag_name == 'env': self._env_tag(t, context, ros_config) else: ros_config.add_config_error("WARN: unrecognized '%s' tag in <node> tag. Node xml is %s"%(t.tagName, tag.toxml())) # #1036 evaluate all ~params in context # TODO: can we get rid of force_local (above), remove this for loop, and just rely on param_tag logic instead? for p in itertools.chain(context.params, param_ns.params): pkey = p.key if is_private(pkey): # strip leading ~, which is optional/inferred pkey = pkey[1:] pkey = param_ns.ns + pkey ros_config.add_param(Param(pkey, p.value), verbose=verbose) if not is_test: return Node(pkg, node_type, name=name, namespace=child_ns.ns, machine_name=machine, args=args, respawn=respawn, remap_args=remap_context.remap_args(), env_args=context.env_args, output=output, cwd=cwd, launch_prefix=launch_prefix, required=required, filename=context.filename) else: return Test(test_name, pkg, node_type, name=name, namespace=child_ns.ns, machine_name=machine, args=args, remap_args=remap_context.remap_args(), env_args=context.env_args, time_limit=time_limit, cwd=cwd, launch_prefix=launch_prefix, retry=retry, filename=context.filename) except KeyError, e: raise XmlParseException( "<%s> tag is missing required attribute: %s. Node xml is %s"%(tag.tagName, e, tag.toxml()))
def test_setup_env(self): from roslaunch.core import setup_env, Node, Machine ros_root = '/ros/root1' rpp = '/rpp1' master_uri = 'http://masteruri:1234' n = Node('nodepkg','nodetype') m = Machine('name1', ros_root, rpp, '1.2.3.4') d = setup_env(n, m, master_uri) self.assertEquals(d['ROS_MASTER_URI'], master_uri) self.assertEquals(d['ROS_ROOT'], ros_root) self.assertEquals(d['PYTHONPATH'], os.path.join(ros_root, 'core', 'roslib', 'src')) self.assertEquals(d['ROS_PACKAGE_PATH'], rpp) for k in ['ROS_IP', 'ROS_NAMESPACE']: if k in d: self.fail('%s should not be set: %s'%(k,d[k])) # don't set ROS_ROOT and ROS_PACKAGE_PATH. ROS_ROOT should default, ROS_PACKAGE_PATH does not m = Machine('name1', '', '', '1.2.3.4') d = setup_env(n, m, master_uri) val = os.environ['ROS_ROOT'] self.assertEquals(d['ROS_ROOT'], val) self.assertEquals(d['PYTHONPATH'], os.path.join(val, 'core', 'roslib', 'src')) self.failIf('ROS_PACKAGE_PATH' in d, 'ROS_PACKAGE_PATH should not be set: %s'%d) # test ROS_IP m = Machine('name1', ros_root, rpp, '1.2.3.4', ros_ip="4.5.6.7") n = Node('nodepkg','nodetype', namespace="/ns1") d = setup_env(n, m, master_uri) self.assertEquals(d['ROS_NAMESPACE'], "/ns1") # test stripping n = Node('nodepkg','nodetype', namespace="/ns2/") d = setup_env(n, m, master_uri) self.assertEquals(d['ROS_NAMESPACE'], "/ns2") # test ROS_NAMESPACE m = Machine('name1', ros_root, rpp, '1.2.3.4', ros_ip="4.5.6.7") d = setup_env(n, m, master_uri) self.assertEquals(d['ROS_IP'], "4.5.6.7") # test node.env_args n = Node('nodepkg','nodetype', env_args=[('NENV1', 'val1'), ('NENV2', 'val2'), ('ROS_ROOT', '/new/root')]) d = setup_env(n, m, master_uri) self.assertEquals(d['ROS_ROOT'], "/new/root") self.assertEquals(d['NENV1'], "val1") self.assertEquals(d['NENV2'], "val2") # test machine.env_args m = Machine('name1', ros_root, rpp, '1.2.3.4', ros_ip="4.5.6.7", env_args=[('MENV1', 'val1'), ('MENV2', 'val2'), ('ROS_ROOT', '/new/root2')]) n = Node('nodepkg','nodetype') d = setup_env(n, m, master_uri) self.assertEquals(d['ROS_ROOT'], "/new/root2") self.assertEquals(d['MENV1'], "val1") self.assertEquals(d['MENV2'], "val2") # test node.env_args precedence m = Machine('name1', ros_root, rpp, '1.2.3.4', ros_ip="4.5.6.7", env_args=[('MENV1', 'val1'), ('MENV2', 'val2')]) n = Node('nodepkg','nodetype', env_args=[('MENV1', 'nodeval1')]) d = setup_env(n, m, master_uri) self.assertEquals(d['MENV1'], "nodeval1") self.assertEquals(d['MENV2'], "val2")
def test_Node(): from roslaunch.core import Node n = Node("package", "node_type") assert n.package == "package" assert n.type == "node_type" assert n.xmltype() == "node" assert n.xmlattrs() == [ ("pkg", "package"), ("type", "node_type"), ("machine", None), ("ns", "/"), ("args", ""), ("output", None), ("cwd", None), ("respawn", False), ("respawn_delay", 0.0), ("name", None), ("launch-prefix", None), ("required", False), ], n.xmlattrs() assert n.output == None # tripwire for now n.to_xml() val = n.to_remote_xml() assert "machine" not in val # test bad constructors try: n = Node("package", "node_type", cwd="foo") assert False except ValueError: pass try: n = Node("package", "node_type", output="foo") assert False except ValueError: pass try: n = Node("package", "") assert False except ValueError: pass try: n = Node("", "node_type") assert False except ValueError: pass try: n = Node("package", "node_type", name="ns/node") assert False except ValueError: pass try: n = Node("package", "node_type", respawn=True, required=True) assert False except ValueError: pass
def test_Node(): from roslaunch.core import Node n = Node('package', 'node_type') assert n.package == 'package' assert n.type == 'node_type' assert n.xmltype() == 'node' assert n.xmlattrs() == [('pkg', 'package'), ('type', 'node_type'), ('machine', None), ('ns', '/'), ('args', ''), ('output', None), ('cwd', None), ('respawn', False), ('name', None), ('launch-prefix', None), ('required', False)], n.xmlattrs() assert n.output == None #tripwire for now n.to_xml() val = n.to_remote_xml() assert 'machine' not in val # test bad constructors try: n = Node('package', 'node_type', cwd='foo') assert False except ValueError: pass try: n = Node('package', 'node_type', output='foo') assert False except ValueError: pass try: n = Node('package', '') assert False except ValueError: pass try: n = Node('', 'node_type') assert False except ValueError: pass try: n = Node('package', 'node_type', name='ns/node') assert False except ValueError: pass try: n = Node('package', 'node_type', respawn=True, required=True) assert False except ValueError: pass