def test_has_param(self): from rosmaster.paramserver import ParamDictionary param_server = ParamDictionary(None) self.failIf(param_server.has_param('/new_param')) param_server.set_param('/new_param', 1) self.assert_(param_server.has_param('/new_param')) # test with param in sub-namespace self.failIf(param_server.has_param('/sub/sub2/new_param2')) # - verify that parameter tree does not exist yet (#587) for k in ['/sub/sub2/', '/sub/sub2', '/sub/', '/sub']: self.failIf(param_server.has_param(k)) param_server.set_param('/sub/sub2/new_param2', 1) self.assert_(param_server.has_param('/sub/sub2/new_param2')) # - verify that parameter tree now exists (#587) for k in ['/sub/sub2/', '/sub/sub2', '/sub/', '/sub']: self.assert_(param_server.has_param(k))
def test_set_param(self): from rosmaster.paramserver import ParamDictionary param_server = ParamDictionary(None) caller_id = '/node' val = random.randint(0, 10000) # verify error behavior with root try: param_server.set_param('/', 1) self.fail("ParamDictionary allowed root to be set to non-dictionary") except: pass # very similar to has param sequence self.failIf(param_server.has_param('/new_param')) param_server.set_param('/new_param', val) self.assertEquals(val, param_server.get_param('/new_param')) self.assertEquals(val, param_server.get_param('/new_param/')) self.assert_(param_server.has_param('/new_param')) # test with param in sub-namespace val = random.randint(0, 10000) self.failIf(param_server.has_param('/sub/sub2/new_param2')) param_server.set_param('/sub/sub2/new_param2', val) self.assertEquals(val, param_server.get_param('/sub/sub2/new_param2')) # test with param type mutation vals = ['a', {'a': 'b'}, 1, 1., 'foo', {'c': 'd'}, 4, {'a': {'b': 'c'}}, 3] for v in vals: param_server.set_param('/multi/multi_param', v) self.assertEquals(v, param_server.get_param('/multi/multi_param')) # - set value within subtree that mutates higher level value param_server.set_param('/multi2/multi_param', 1) self.assertEquals(1, param_server.get_param('/multi2/multi_param')) param_server.set_param('/multi2/multi_param/a', 2) self.assertEquals(2, param_server.get_param('/multi2/multi_param/a')) self.assertEquals({'a': 2}, param_server.get_param('/multi2/multi_param/')) param_server.set_param('/multi2/multi_param/a/b', 3) self.assertEquals(3, param_server.get_param('/multi2/multi_param/a/b')) self.assertEquals({'b': 3}, param_server.get_param('/multi2/multi_param/a/')) self.assertEquals({'a': {'b': 3}}, param_server.get_param('/multi2/multi_param/')) # test that parameter server namespace-set (#587) self.failIf(param_server.has_param('/gains/P')) self.failIf(param_server.has_param('/gains/I')) self.failIf(param_server.has_param('/gains/D')) self.failIf(param_server.has_param('/gains')) pid = {'P': random.randint(0, 10000), 'I': random.randint(0, 10000), 'D': random.randint(0, 10000)} param_server.set_param('/gains', pid) self.assertEquals(pid, param_server.get_param('/gains')) self.assertEquals(pid['P'], param_server.get_param('/gains/P')) self.assertEquals(pid['I'], param_server.get_param('/gains/I')) self.assertEquals(pid['D'], param_server.get_param('/gains/D')) subns = {'gains1': pid, 'gains2': pid} param_server.set_param('/ns', subns) self.assertEquals(pid['P'], param_server.get_param('/ns/gains1/P')) self.assertEquals(pid['I'], param_server.get_param('/ns/gains1/I')) self.assertEquals(pid['D'], param_server.get_param('/ns/gains1/D')) self.assertEquals(pid, param_server.get_param('/ns/gains1')) self.assertEquals(pid, param_server.get_param('/ns/gains2')) self.assertEquals(subns, param_server.get_param('/ns/')) # test empty dictionary set param_server.set_param('/ns', {}) # - param should still exist self.assert_(param_server.has_param('/ns/')) # - value should remain dictionary self.assertEquals({}, param_server.get_param('/ns/')) # - value2 below /ns/ should be erased self.failIf(param_server.has_param('/ns/gains1')) self.failIf(param_server.has_param('/ns/gains1/P')) # verify that root can be set and that it erases all values param_server.set_param('/', {}) self.failIf(param_server.has_param('/new_param')) param_server.set_param('/', {'foo': 1, 'bar': 2, 'baz': {'a': 'a'}}) self.assertEquals(1, param_server.get_param('/foo')) self.assertEquals(1, param_server.get_param('/foo/')) self.assertEquals(2, param_server.get_param('/bar')) self.assertEquals(2, param_server.get_param('/bar/')) self.assertEquals('a', param_server.get_param('/baz/a')) self.assertEquals('a', param_server.get_param('/baz/a/'))
def test_delete_param(self): from rosmaster.paramserver import ParamDictionary param_server = ParamDictionary(None) try: param_server.delete_param('/fake') self.fail("delete_param of non-existent should have failed") except: pass try: param_server.delete_param('/') self.fail("delete_param of root should have failed") except: pass param_server.set_param('/foo', 'foo') param_server.set_param('/bar', 'bar') self.assert_(param_server.has_param('/foo')) self.assert_(param_server.has_param('/bar')) param_server.delete_param('/foo') self.failIf(param_server.has_param('/foo')) # - test with trailing slash param_server.delete_param('/bar/') self.failIf(param_server.has_param('/bar')) # test with namespaces param_server.set_param("/sub/key/x", 1) param_server.set_param("/sub/key/y", 2) try: param_server.delete_param('/sub/key/z') self.fail("delete_param of non-existent should have failed") except: pass try: param_server.delete_param('/sub/sub2/z') self.fail("delete_param of non-existent should have failed") except: pass self.assert_(param_server.has_param('/sub/key/x')) self.assert_(param_server.has_param('/sub/key/y')) self.assert_(param_server.has_param('/sub/key')) param_server.delete_param('/sub/key') self.failIf(param_server.has_param('/sub/key')) self.failIf(param_server.has_param('/sub/key/x')) self.failIf(param_server.has_param('/sub/key/y')) # test with namespaces (dictionary vals) param_server.set_param('/sub2', {'key': { 'x' : 1, 'y' : 2}}) self.assert_(param_server.has_param('/sub2/key/x')) self.assert_(param_server.has_param('/sub2/key/y')) self.assert_(param_server.has_param('/sub2/key')) param_server.delete_param('/sub2/key') self.failIf(param_server.has_param('/sub2/key')) self.failIf(param_server.has_param('/sub2/key/x')) self.failIf(param_server.has_param('/sub2/key/y')) # test with namespaces: treat value as if its a namespace # - try to get the dictionary-of-dictionary code to fail # by descending a value key as if it is a namespace param_server.set_param('/a', 'b') self.assert_(param_server.has_param('/a')) try: param_server.delete_param('/a/b/c') self.fail_("should have raised key error") except: pass
def test_get_param(self): from rosmaster.paramserver import ParamDictionary param_server = ParamDictionary(None) val = random.randint(0, 10000) full_dict = {} # very similar to has param sequence self.failIf(param_server.has_param('/new_param')) self.failIf(param_server.has_param('/new_param/')) self.assertGetParamFail(param_server, '/new_param') param_server.set_param('/new_param', val) full_dict['new_param'] = val self.assertEquals(val, param_server.get_param('/new_param')) self.assertEquals(val, param_server.get_param('/new_param/')) # - test homonym self.assertEquals(val, param_server.get_param('/new_param//')) # test full get self.assertEquals(full_dict, param_server.get_param('/')) # test with param in sub-namespace val = random.randint(0, 10000) self.failIf(param_server.has_param('/sub/sub2/new_param2')) self.assertGetParamFail(param_server, '/sub/sub2/new_param2') param_server.set_param('/sub/sub2/new_param2', val) full_dict['sub'] = {'sub2': { 'new_param2': val }} self.assertEquals(val, param_server.get_param('/sub/sub2/new_param2')) # - test homonym self.assertEquals(val, param_server.get_param('/sub///sub2/new_param2/')) # test full get self.assertEquals(full_dict, param_server.get_param('/')) # test that parameter server namespace-get (#587) val1 = random.randint(0, 10000) val2 = random.randint(0, 10000) val3 = random.randint(0, 10000) for k in ['/gains/P', '/gains/I', '/gains/D', '/gains']: self.assertGetParamFail(param_server, k) self.failIf(param_server.has_param(k)) param_server.set_param('/gains/P', val1) param_server.set_param('/gains/I', val2) param_server.set_param('/gains/D', val3) pid = {'P': val1, 'I': val2, 'D': val3} full_dict['gains'] = pid self.assertEquals(pid, param_server.get_param('/gains')) self.assertEquals(pid, param_server.get_param('/gains/')) self.assertEquals(full_dict, param_server.get_param('/')) self.failIf(param_server.has_param('/ns/gains/P')) self.failIf(param_server.has_param('/ns/gains/I')) self.failIf(param_server.has_param('/ns/gains/D')) self.failIf(param_server.has_param('/ns/gains')) param_server.set_param('/ns/gains/P', val1) param_server.set_param('/ns/gains/I', val2) param_server.set_param('/ns/gains/D', val3) full_dict['ns'] = {'gains': pid} self.assertEquals(pid, param_server.get_param('/ns/gains')) self.assertEquals({'gains': pid}, param_server.get_param('/ns/')) self.assertEquals({'gains': pid}, param_server.get_param('/ns')) self.assertEquals(full_dict, param_server.get_param('/'))
def test_search_param(self): from rosmaster.paramserver import ParamDictionary param_server = ParamDictionary(None) caller_id = '/node' # vals are mostly identical, save some randomness. we want # identical structure in order to stress lookup rules val1 = { 'level1_p1': random.randint(0, 10000), 'level1_p2' : { 'level2_p2': random.randint(0, 10000) }} val2 = { 'level1_p1': random.randint(0, 10000), 'level1_p2' : { 'level2_p2': random.randint(0, 10000) }} val3 = { 'level1_p1': random.randint(0, 10000), 'level1_p2' : { 'level2_p2': random.randint(0, 10000) }} val4 = { 'level1_p1': random.randint(0, 10000), 'level1_p2' : { 'level2_p2': random.randint(0, 10000) }} full_dict = {} # test invalid input for k in ['', None, '~param']: try: param_server.search_param('/level1/level2', k) self.fail("param_server search should have failed on [%s]"%k) except ValueError: pass for ns in ['', None, 'relative', '~param']: try: param_server.search_param(ns, 'param') self.fail("param_server search should have failed on %s"%k) except ValueError: pass # set the val parameter at four levels so we can validate search # - set val1 self.failIf(param_server.has_param('/level1/param')) self.failIf(param_server.search_param('/level1/node', 'param')) param_server.set_param('/level1/param', val1) # - test param on val1 for ns in ['/level1/node', '/level1/level2/node', '/level1/level2/level3/node']: self.assertEquals('/level1/param', param_server.search_param(ns, 'param'), "failed with ns[%s]"%ns) self.assertEquals('/level1/param/', param_server.search_param(ns, 'param/')) self.assertEquals('/level1/param/level1_p1', param_server.search_param(ns, 'param/level1_p1')) self.assertEquals('/level1/param/level1_p2/level2_p2', param_server.search_param(ns, 'param/level1_p2/level2_p2')) self.assertEquals(None, param_server.search_param('/root', 'param')) self.assertEquals(None, param_server.search_param('/root', 'param/')) # - set val2 self.failIf(param_server.has_param('/level1/level2/param')) param_server.set_param('/level1/level2/param', val2) # - test param on val2 for ns in ['/level1/level2/node', '/level1/level2/level3/node', '/level1/level2/level3/level4/node']: self.assertEquals('/level1/level2/param', param_server.search_param(ns, 'param')) self.assertEquals('/level1/level2/param/', param_server.search_param(ns, 'param/')) self.assertEquals('/level1/param', param_server.search_param('/level1/node', 'param')) self.assertEquals('/level1/param/', param_server.search_param('/level1/node', 'param/')) self.assertEquals(None, param_server.search_param('/root', 'param')) # - set val3 self.failIf(param_server.has_param('/level1/level2/level3/param')) param_server.set_param('/level1/level2/level3/param', val3) # - test param on val3 for ns in ['/level1/level2/level3/node', '/level1/level2/level3/level4/node']: self.assertEquals('/level1/level2/level3/param', param_server.search_param(ns, 'param')) self.assertEquals('/level1/level2/param', param_server.search_param('/level1/level2/node', 'param')) self.assertEquals('/level1/param', param_server.search_param('/level1/node', 'param')) # test subparams before we set val4 on the root # - test looking for param/sub_param self.assertEquals(None, param_server.search_param('/root', 'param')) self.assertEquals(None, param_server.search_param('/root', 'param/level1_p1')) self.assertEquals(None, param_server.search_param('/not/level1/level2/level3/level4/node', 'param/level1_p1')) tests = [ ('/level1/node', '/level1/param/'), ('/level1/level2/', '/level1/level2/param/'), ('/level1/level2', '/level1/level2/param/'), ('/level1/level2/node', '/level1/level2/param/'), ('/level1/level2/notlevel3', '/level1/level2/param/'), ('/level1/level2/notlevel3/node', '/level1/level2/param/'), ('/level1/level2/level3/level4', '/level1/level2/level3/param/'), ('/level1/level2/level3/level4/', '/level1/level2/level3/param/'), ('/level1/level2/level3/level4/node', '/level1/level2/level3/param/'), ] for ns, pbase in tests: self.assertEquals(pbase+'level1_p1', param_server.search_param(ns, 'param/level1_p1')) retval = param_server.search_param(ns, 'param/level1_p2/level2_p2') self.assertEquals(pbase+'level1_p2/level2_p2', retval, "failed with ns[%s] pbase[%s]: %s"%(ns, pbase, retval)) # - set val4 on the root self.failIf(param_server.has_param('/param')) param_server.set_param('/param', val4) self.assertEquals('/param', param_server.search_param('/root', 'param')) self.assertEquals('/param', param_server.search_param('/notlevel1/node', 'param')) self.assertEquals('/level1/param', param_server.search_param('/level1/node', 'param')) self.assertEquals('/level1/param', param_server.search_param('/level1', 'param')) self.assertEquals('/level1/param', param_server.search_param('/level1/', 'param')) # make sure that partial match works val5 = { 'level1_p1': random.randint(0, 10000), 'level1_p2' : { }} self.failIf(param_server.has_param('/partial1/param')) param_server.set_param('/partial1/param', val5) self.assertEquals('/partial1/param', param_server.search_param('/partial1', 'param')) self.assertEquals('/partial1/param/level1_p1', param_server.search_param('/partial1', 'param/level1_p1')) # - this is the important check, should return key even if it doesn't exist yet based on stem match self.assertEquals('/partial1/param/non_existent', param_server.search_param('/partial1', 'param/non_existent')) self.assertEquals('/partial1/param/level1_p2/non_existent', param_server.search_param('/partial1', 'param/level1_p2/non_existent'))