def test_param_values(self):
import math
from rosmaster.paramserver import ParamDictionary
param_server = ParamDictionary(None)
test_vals = [
['int', [0, 1024, 2147483647, -2147483647]],
['boolean', [True, False]],
#no longer testing null char
#['string', ['', '\0', 'x', 'hello', ''.join([chr(n) for n in xrange(0, 255)])]],
['unicode-string', [u'', u'hello', unicode('Andr\302\202', 'utf-8'), unicode('\377\376A\000n\000d\000r\000\202\000', 'utf-16')]],
['string-easy-ascii', [chr(n) for n in xrange(32, 128)]],
#['string-mean-ascii-low', [chr(n) for n in xrange(9, 10)]], #separate for easier book-keeping
#['string-mean-ascii-low', [chr(n) for n in xrange(1, 31)]], #separate for easier book-keeping
#['string-mean-signed', [chr(n) for n in xrange(129, 256)]],
['string', ['', 'x', 'hello-there', 'new\nline', 'tab\t']],
['double', [0.0, math.pi, -math.pi, 3.4028235e+38, -3.4028235e+38]],
#TODO: microseconds?
['datetime', [datetime.datetime(2005, 12, 6, 12, 13, 14), datetime.datetime(1492, 12, 6, 12, 13, 14)]],
['array', [[], [1, 2, 3], ['a', 'b', 'c'], [0.0, 0.1, 0.2, 2.0, 2.1, -4.0],
[1, 'a', True], [[1, 2, 3], ['a', 'b', 'c'], [1.0, 2.1, 3.2]]]
],
]
print "Putting parameters onto the server"
# put our params into the parameter server
contexts = ['', 'scope1', 'scope/subscope1', 'scope/sub1/sub2']
my_state = {}
failures = []
for ctx in contexts:
self._set_param(ctx, my_state, test_vals, param_server)
self._check_param_state(param_server, my_state)
print "Deleting all of our parameters"
# delete all of our parameters
param_keys = my_state.keys()
count = 0
for key in param_keys:
count += 1
param_server.delete_param(key)
del my_state[key]
# far too intensive to check every time
if count % 50 == 0:
self._check_param_state(param_server, my_state)
self._check_param_state(param_server, my_state)
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_subscribe_param_deletion(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)
# subscription to then delete parameter
self.assertEquals({}, param_server.subscribe_param('/foo', ('node1', 'http://node1:1')))
param_server.set_param('/foo', 1, notify_task=self.notify_task)
param_server.delete_param('/foo', notify_task=self.notify_task)
self.assertEquals([([('node1', 'http://node1:1')], '/foo/', {}), ], self.last_update)
# subscribe to and delete whole tree
gains = {'p': 'P', 'i': 'I', 'd' : 'D'}
self.assertEquals({}, param_server.subscribe_param('/gains', ('deltree', 'http://deltree:1')))
param_server.set_param('/gains', gains.copy(), notify_task=self.notify_task)
param_server.delete_param('/gains', notify_task=self.notify_task)
self.assertEquals([([('deltree', 'http://deltree:1')], '/gains/', {}), ], self.last_update)
# subscribe to and delete params within subtree
self.assertEquals({}, param_server.subscribe_param('/gains2', ('deltree2', 'http://deltree2:2')))
param_server.set_param('/gains2', gains.copy(), notify_task=self.notify_task)
param_server.delete_param('/gains2/p', notify_task=self.notify_task)
self.assertEquals([([('deltree2', 'http://deltree2:2')], '/gains2/p/', {}), ], self.last_update)
param_server.delete_param('/gains2/i', notify_task=self.notify_task)
self.assertEquals([([('deltree2', 'http://deltree2:2')], '/gains2/i/', {}), ], self.last_update)
param_server.delete_param('/gains2', notify_task=self.notify_task)
self.assertEquals([([('deltree2', 'http://deltree2:2')], '/gains2/', {}), ], self.last_update)
# delete parent tree
k = '/ns1/ns2/ns3/key'
self.assertEquals({}, param_server.subscribe_param(k, ('del_parent', 'http://del_parent:1')))
param_server.set_param(k, 1, notify_task=self.notify_task)
param_server.delete_param('/ns1/ns2', notify_task=self.notify_task)
self.assertEquals([([('del_parent', 'http://del_parent:1')], '/ns1/ns2/ns3/key/', {}), ], self.last_update)
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)