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'))
