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_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_subscribe_param_tree(self): from rosmaster.registrations import RegistrationManager from rosmaster.paramserver import ParamDictionary # setup node and subscriber data reg_manager = RegistrationManager(ThreadPoolMock()) param_server = ParamDictionary(reg_manager) # Test Parameter Tree Subscriptions # simple case - subscribe and set whole tree gains = {'p': 'P', 'i': 'I', 'd' : 'D'} self.assertEquals({}, param_server.subscribe_param('/gains', ('ptnode', 'http://ptnode:1'))) param_server.set_param('/gains', gains.copy(), notify_task=self.notify_task) self.assertEquals([([('ptnode', 'http://ptnode:1')], '/gains/', gains), ], self.last_update) # - test with trailing slash param_server.set_param('/gains/', gains.copy(), notify_task=self.notify_task) self.assertEquals([([('ptnode', 'http://ptnode:1')], '/gains/', gains), ], self.last_update) # change params within tree param_server.set_param('/gains/p', 'P2', notify_task=self.notify_task) self.assertEquals([([('ptnode', 'http://ptnode:1')], '/gains/p/', 'P2'), ], self.last_update) param_server.set_param('/gains/i', 'I2', notify_task=self.notify_task) self.assertEquals([([('ptnode', 'http://ptnode:1')], '/gains/i/', 'I2'), ], self.last_update) # test overlapping subscriptions self.assertEquals('P2', param_server.subscribe_param('/gains/p', ('ptnode2', 'http://ptnode2:2'))) param_server.set_param('/gains', gains.copy(), notify_task=self.notify_task) self.assertEquals([([('ptnode', 'http://ptnode:1')], '/gains/', gains), \ ([('ptnode2', 'http://ptnode2:2')], '/gains/p/', 'P'), \ ], self.last_update) # - retest with trailing slash on subscribe self.last_update = None self.assertEquals('P', param_server.subscribe_param('/gains/p/', ('ptnode2', 'http://ptnode2:2'))) param_server.set_param('/gains', gains.copy(), notify_task=self.notify_task) self.assertEquals([([('ptnode', 'http://ptnode:1')], '/gains/', gains), \ ([('ptnode2', 'http://ptnode2:2')], '/gains/p/', 'P'), \ ], self.last_update) # test with overlapping (change to sub param) param_server.set_param('/gains/p', 'P3', notify_task=self.notify_task) # - this is a bit overtuned as a more optimal ps could use one update ptnode2 = ([('ptnode2', 'http://ptnode2:2')], '/gains/p/', 'P3') ptnode = ([('ptnode', 'http://ptnode:1')], '/gains/p/', 'P3') self.assertTrue(len(self.last_update) == 2) self.assertTrue(ptnode2 in self.last_update) self.assertTrue(ptnode in self.last_update) # virtual deletion: subscribe to subparam, parameter tree reset self.last_update = None param_server.set_param('/gains2', gains.copy(), notify_task=self.notify_task) self.assertEquals('P', param_server.subscribe_param('/gains2/p/', ('ptnode3', 'http://ptnode3:3'))) # - erase the sub parameters param_server.set_param('/gains2', {}, notify_task=self.notify_task) self.assertEquals([([('ptnode3', 'http://ptnode3:3')], '/gains2/p/', {}), ], self.last_update) #Final test: test subscription to entire tree self.last_update = None param_server.delete_param('/gains') param_server.delete_param('/gains2') self.assertEquals({}, param_server.get_param('/')) self.assertEquals({}, param_server.subscribe_param('/', ('allnode', 'http://allnode:1'))) param_server.set_param('/one', 1, notify_task=self.notify_task) self.assertEquals([([('allnode', 'http://allnode:1')], '/one/', 1), ], self.last_update) param_server.set_param('/two', 2, notify_task=self.notify_task) self.assertEquals([([('allnode', 'http://allnode:1')], '/two/', 2), ], self.last_update) param_server.set_param('/foo/bar', 'bar', notify_task=self.notify_task) self.assertEquals([([('allnode', 'http://allnode:1')], '/foo/bar/', 'bar'), ], self.last_update)