def test_rosapi_topics_blocking():
ros = Ros(host, port)
ros.run()
topic_list = ros.get_topics()
print(topic_list)
assert ('/rosout' in topic_list)
ros.close()
def run_reconnect_does_not_trigger_on_client_close():
ros = Ros('127.0.0.1', 9090)
ros.run()
assert ros.is_connected, "ROS initially connected"
time.sleep(0.5)
event = threading.Event()
ros.on('close', lambda m: event.set())
ros.close()
event.wait(5)
assert not ros.is_connected, "Successful disconnect"
assert not ros.is_connecting, "Not trying to re-connect"
def test_empty_service():
ros = Ros('127.0.0.1', 9090)
ros.run()
service = Service(ros, '/test_empty_service', 'std_srvs/Empty')
service.advertise(lambda req, resp: True)
time.sleep(1)
client = Service(ros, '/test_empty_service', 'std_srvs/Empty')
client.call(ServiceRequest())
service.unadvertise()
time.sleep(2)
ros.close()
def test_param_manipulation():
ros = Ros('127.0.0.1', 9090)
ros.run()
param = Param(ros, 'test_param')
assert param.get() is None
param.set('test_value')
assert param.get() == 'test_value'
param.delete()
assert param.get() is None
ros.close()
def test_rosapi_topics():
context = dict(wait=threading.Event(), result=None)
ros = Ros(host, port)
ros.run()
def callback(topic_list):
context['result'] = topic_list
context['wait'].set()
ros.get_topics(callback)
if not context['wait'].wait(5):
raise Exception
assert ('/rosout' in context['result']['topics'])
ros.close()
def test_topic_pubsub():
context = dict(wait=threading.Event(), counter=0)
ros = Ros('127.0.0.1', 9090)
ros.run()
listener = Topic(ros, '/chatter', 'std_msgs/String')
publisher = Topic(ros, '/chatter', 'std_msgs/String')
def receive_message(message):
context['counter'] += 1
assert message['data'] == 'hello world', 'Unexpected message content'
if context['counter'] == 3:
listener.unsubscribe()
context['wait'].set()
def start_sending():
while True:
if context['counter'] >= 3:
break
publisher.publish(Message({'data': 'hello world'}))
time.sleep(0.1)
publisher.unadvertise()
def start_receiving():
listener.subscribe(receive_message)
t1 = threading.Thread(target=start_receiving)
t2 = threading.Thread(target=start_sending)
t1.start()
t2.start()
if not context['wait'].wait(10):
raise Exception
t1.join()
t2.join()
assert context[
'counter'] >= 3, 'Expected at least 3 messages but got ' + str(
context['counter'])
ros.close()
def test_closing_event():
ros = Ros(url)
ros.run()
ctx = dict(closing_event_called=False, was_still_connected=False)
def handle_closing():
ctx['closing_event_called'] = True
ctx['was_still_connected'] = ros.is_connected
time.sleep(1.5)
ts_start = time.time()
ros.on('closing', handle_closing)
ros.close()
ts_end = time.time()
closing_was_handled_synchronously_before_close = ts_end - ts_start >= 1.5
assert ctx['closing_event_called']
assert ctx['was_still_connected']
assert closing_was_handled_synchronously_before_close
def test_add_two_ints_service():
ros = Ros('127.0.0.1', 9090)
ros.run()
def add_two_ints(request, response):
response['sum'] = request['a'] + request['b']
return False
service_name = '/test_sum_service'
service_type = 'rospy_tutorials/AddTwoInts'
service = Service(ros, service_name, service_type)
service.advertise(add_two_ints)
time.sleep(1)
client = Service(ros, service_name, service_type)
result = client.call(ServiceRequest({'a': 2, 'b': 40}))
assert (result['sum'] == 42)
service.unadvertise()
time.sleep(2)
ros.close()
def test_tf_test():
context = dict(wait=threading.Event(), counter=0)
ros = Ros('127.0.0.1', 9090)
ros.run()
tf_client = TFClient(ros, fixed_frame='world')
def callback(message):
context['message'] = message
context['counter'] += 1
context['wait'].set()
tf_client.subscribe(frame_id='/world', callback=callback)
if not context['wait'].wait(5):
raise Exception
assert context['counter'] > 0
assert context['message']['translation'] == dict(
x=0.0, y=0.0, z=0.0), 'Unexpected translation received'
assert context['message']['rotation'] == dict(
x=0.0, y=0.0, z=0.0, w=1.0), 'Unexpected rotation received'
ros.close()
def test_url_connection():
ros = Ros(url)
ros.run()
assert ros.is_connected
ros.close()
def test_connection():
ros = Ros(host, port)
ros.run()
assert ros.is_connected
ros.close()
