def main():
global tp, reconfig_client
regression_test = rospy.get_param('~regression_test', False)
tp = TriggerChecker(plot = not regression_test, silent = regression_test)
head_trig = Trigger(tp, '/head_camera_trigger')
l_forearm_trig = Trigger(tp, 'l_forearm_cam_trigger')
r_forearm_trig = Trigger(tp, 'r_forearm_cam_trigger')
Camera(tp, '/narrow_stereo_both', head_trig)
tp.set_projector(Trigger(tp, '/projector_trigger'))
Camera(tp, '/wide_stereo_both', head_trig)
Camera(tp, '/l_forearm_cam', l_forearm_trig)
Camera(tp, '/r_forearm_cam', r_forearm_trig)
if regression_test:
import rostest
rospy.loginfo("Running in unit test mode")
reconfig_client = dynamic_reconfigure.client.Client('synchronizer')
rostest.rosrun(PKG, 'test_bare_bones', Test)
else:
rospy.loginfo("Running in plotting mode")
while not rospy.is_shutdown():
time.sleep(0.1)
import unittest
from cob_camera_calibration import CalibrationData
TEST_FILE = "test/data/calibration_data.yaml"
TEST_OUT = "/tmp/calibration_data.yaml"
class TestCalibrationData(unittest.TestCase):
def test_read(self):
data = CalibrationData("camera", "frame", "image_width",
"image_height")
data.read_camera_yaml_file(TEST_FILE)
def test_read_write(self):
data = CalibrationData("camera", "frame", "image_width",
"image_height")
data.read_camera_yaml_file(TEST_FILE)
data.save_camera_yaml_file(TEST_OUT)
# compare with correct results
self.assertTrue(self._cmp_files(TEST_FILE, TEST_OUT))
def _cmp_files(self, f1, f2):
return open(f1).read() == open(f2).read()
if __name__ == '__main__':
import rostest
rostest.rosrun(PKG, 'TestCalibrationData', TestCalibrationData)
import roslib; roslib.load_manifest(PKG)
import sys
import unittest
## A simple unit test to make sure python module structure and files aren't broken
class TestImports(unittest.TestCase):
## import everything
def test_imports(self):
from actionlib import simple_action_client
from actionlib import action_client
from actionlib import goal_id_generator
from actionlib import handle_tracker_deleter
from actionlib import server_goal_handle
from actionlib import status_tracker
from actionlib import action_server
from actionlib import simple_action_server
self.assertEquals(1, 1, "1!=1")
if __name__ == '__main__':
import rostest
print sys.path
rostest.rosrun(PKG, 'test_imports', TestImports)
self.assertEqual(vs.sum_forward, lf+rf, "different value: sum_forward")
def test_node_exist(self):
nodes = rosnode.get_node_names()
self.assertIn('/lightsensors',nodes, "node does not exist")
def test_get_value(self):
rospy.set_param('/lightsensors/frequency',10) #センサの値取得の周期を10Hzに
time.sleep(2) #パラメータの反映を待つ
with open("/dev/rtlightsensor0","w") as f: #ダミーの値をダミーのファイルに
f.write("-1 0 123 4321\n")
time.sleep(3)
###コールバック関数が最低1回は呼ばれ、値が取得できているかを確認###
self.assertFalse(self.count == 0,"cannot subscribe the topic")
self.check_values(4321,123,0,-1)
def test_change_parameter(self):
rospy.set_param('/lightsensors/frequency',1) #センサの値取得の周期を1Hzに
time.sleep(2) #反映を待つ
c_prev = self.count #callbackが呼ばれた回数を記録
time.sleep(3)
###コールバック関数が3秒間で最低1回、最高でも4回しか呼ばれてないことを確認###
self.assertTrue(self.count < c_prev + 4,"freq does not change")
self.assertFalse(self.count == c_prev,"subscriber is stopped")
if __name__ == '__main__':
time.sleep(3)
rospy.init_node('travis_test_lightsensors')
rostest.rosrun('raspimouse_ros_2','travis_test_lightsensors',LightsensorTest)
400,
False,
# arm
1,
0,
0,
0,
0,
0,
0,
)
armed = True
if (
self.local_position.pose.position.x > 5
and self.local_position.pose.position.z > 5
and self.local_position.pose.position.y < -5
):
break
count = count + 1
self.assertTrue(count < timeout, "took too long to cross boundaries")
if __name__ == "__main__":
import rostest
rostest.rosrun(PKG, "mavros_offboard_attctl_test", MavrosOffboardAttctlTest)
# unittest.main()
self.relay.start()
# grace delay
time.sleep(1.0)
def tearDown(self):
self.relay.stop()
self.server.shutdown()
self.server_thread.join()
def test_relay(self):
"""Test bi-directional communication over the relay."""
remote_sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
remote_sock.settimeout(1.0)
remote_sock.connect(('127.0.0.1', self.remote_port))
remote_sock.sendall(MAGIC)
response = remote_sock.recv(1024)
self.assertEqual(MAGIC, response)
self.assertEqual(1, len(self.server.messages))
self.assertEqual(MAGIC, self.server.messages[0])
remote_sock.close()
if __name__ == '__main__':
import rostest
rostest.rosrun(PKG, NAME, TestTCPRelay)
# vim: tabstop=8 expandtab shiftwidth=4 softtabstop=4
PKG = 'test_uniboard_service'
class TestUniboardService(unittest.TestCase):
def test_motor_left(self):
rospy.wait_for_service('uniboard_service')
self.uniboard_service = rospy.ServiceProxy('uniboard_service', communication)
left = self.uniboard_service('motor_left', 1, str('0.1'), rospy.Time(secs=500))
self.assertEquals(left.status, True)
self.assertEquals(left.response, 'Success')
self.assertEquals(left.data, '')
def test_addToQueue(self):
controller = UniboardCommunication()
req = Bunch()
req.priority = 1
req.function = 'motor_left'
req.data = "0.12"
req.timestamp = rospy.Time(secs=500)
t = threading.Thread(target=controller.addToQueue, args=(req,))
t.daemon = True
t.start()
item = controller.get()
self.assertEquals(item[1],controller.motor_left)
self.assertEquals(item[2], req.data)
self.assertEquals(item[3], req.timestamp)
self.assertEquals(item[4], [])
if __name__ == '__main__':
rostest.rosrun(PKG, 'test_uniboard_service', TestUniboardService)
cmd = "%s pkg-config openhrp3.1 --variable=idl_dir"%(self.PKG_CONFIG_PATH)
fname = "../sample/model/PA10/pa10.main.wrl"
# check if model file exists
print "`"+cmd+"`"+fname+" = "+os.path.join(check_output(cmd, shell=True).rstrip(), fname)
self.assertTrue(os.path.exists(os.path.join(check_output(cmd, shell=True).rstrip(), fname)))
def test_sample_samplerobot(self):
cmd = "%s pkg-config openhrp3.1 --variable=idl_dir"%(self.PKG_CONFIG_PATH)
fname = "../sample/model/sample1.wrl"
# check if model file exists
print "`"+cmd+"`"+fname+" = "+os.path.join(check_output(cmd, shell=True).rstrip(), fname)
self.assertTrue(os.path.exists(os.path.join(check_output(cmd, shell=True).rstrip(), fname)), "cmd = %r, fname = %r"%(cmd, fname))
#
# check if walk data file exists
fname = "../sample/controller/SampleController/etc/Sample.pos"
print "`"+cmd+"`"+fname+" = "+os.path.join(check_output(cmd, shell=True).rstrip(), fname)
self.assertTrue(os.path.exists(os.path.join(check_output(cmd, shell=True).rstrip(), fname)), "cmd = %r, fname = %r"%(cmd, fname))
#unittest.main()
if __name__ == '__main__':
import rostest
global PID
PID = os.getpid()
f = open("/tmp/%d-openhrp3-sample.cpp"%(PID),'w')
f.write(code)
f.close()
rostest.rosrun(PKG, 'test_openhrp3', TestCompile)
'D-5': 'p'
},
'7': {
'D-1': 'x'
}
},
'cleaning_methods': {
'1': DRY_TASK,
'10': BOTH_TASKS,
'7': DRY_TASK
}
}]
expected_outputs = [{
'1': {TRASH_TASK, DRY_TASK},
'10': {TRASH_TASK},
'7': {DRY_TASK, TRASH_TASK}
}]
self.applyScenarios(scenarios=scenarios,
expected_outputs=expected_outputs,
evaluator=self.overdueRoomsEvaluator)
def testComputeAllRooms(self):
# test both due and overdue rooms
pass
if __name__ == '__main__':
import rostest
rostest.rosrun(PKG, NAME, TestDatabaseHandler)
import rostest
import rospy
from pandora_testing_tools.testing_interface import alert_delivery
from test_base import distance
from test_base import direction
import test_base
DIR = os.path.dirname(os.path.realpath(__file__))
class SubscriberTest(test_base.TestBase):
def test_new_subscriber(self):
self.deliveryBoy.deliverHoleOrder(0, 0, 1)
self.deliveryBoy.deliverHoleOrder(0, 0, 1)
outs = []
self.fillInfo(outs)
# Benchmark new subscriber style...
self.assertEqual(len(outs[0].holes), 1)
if __name__ == '__main__':
rospy.sleep(2)
rospy.init_node(NAME, anonymous=True, log_level=rospy.DEBUG)
SubscriberTest.connect()
rostest.rosrun(PKG, NAME, SubscriberTest, sys.argv)
SubscriberTest.disconnect()
import time
class WallStopTest(unittest.TestCase):
def set_and_get(self,lf,ls,rs,rf):
with open("/dev/rtlightsensor0","w") as f:
f.write("%d %d %d %d\n" % (rf,rs,ls,lf))
time.sleep(0.3)
with open("/dev/rtmotor_raw_l0","r") as lf,\
open("/dev/rtmotor_raw_r0","r") as rf:
left = int(lf.readline().rstrip())
right = int(rf.readline().rstrip())
return left, right
def test_io(self):
left, right = self.set_and_get(400,100,100,0) #total: 600
self.assertTrue(left == 0 and right == 0, "can't stop")
left, right = self.set_and_get(400,0,0,99) #total: 499
self.assertTrue(left != 0 and right != 0, "can't move again")
left, right = self.set_and_get(150,0,200,150) #total; 500
self.assertTrue(left == 0 and right == 0, "can't stop")
if __name__ == '__main__':
time.sleep(3)
rospy.init_node('travis_test_wall_stop')
rostest.rosrun('pimouse_run_corridor','travis_test_wall_stop',WallStopTest)
first_level_network.add_precondition(pre_con)
goal_with_same_cond = OfflineGoal('CentralGoal2', planner_prefix=planner_prefix)
goal_with_same_cond.add_condition(condition)
first_level_network.add_goal(goal_with_same_cond)
increaser_behavior = IncreaserBehavior(effect_name=sensor.name, topic_name=topic_name,
name=method_prefix + "TopicIncreaser",
planner_prefix=first_level_network.get_manager_prefix())
increaser_behavior.add_precondition(pre_con)
# activate the first_level_network increaser_Behavior
for x in range(0, 3, 1):
self.assertFalse(first_level_network._isExecuting)
m.step()
pre_con_sensor.update(True)
rospy.sleep(0.1)
self.assertTrue(first_level_network._isExecuting)
for x in range(0, 4, 1):
m.step()
rospy.sleep(0.1)
self.assertTrue(increaser_behavior._isExecuting)
if __name__ == '__main__':
rostest.rosrun(PKG, 'NetworkBehaviourTestNode', TestNetworkBehaviour)
"Should be active")
self.assertEqual(g2.get_goal_status(), GoalStatus.ACTIVE,
"Should be active")
self.assertEqual(g3.get_goal_status(), GoalStatus.ACTIVE,
"Shoule be active")
self.assertEqual(g4.get_goal_status(), GoalStatus.ACTIVE,
"Should be active")
g5 = client.send_goal(goal_result)
rospy.sleep(0.5)
self.assertEqual(g5.get_goal_status(), GoalStatus.SUCCEEDED,
"Should be done")
self.assertEqual(g1.get_goal_status(), GoalStatus.SUCCEEDED)
self.assertEqual(g1.get_result().result, 4)
self.assertEqual(g2.get_goal_status(), GoalStatus.ABORTED)
self.assertEqual(g2.get_result().result, 3)
self.assertEqual(g3.get_goal_status(), GoalStatus.SUCCEEDED)
self.assertEqual(g3.get_result().result, 2)
self.assertEqual(g4.get_goal_status(), GoalStatus.ABORTED)
self.assertEqual(g4.get_result().result, 1)
g6 = client.send_goal(goal_abort)
rospy.sleep(0.5)
if __name__ == '__main__':
import rostest
rospy.init_node('test_ref_simple_action_server')
rostest.rosrun('actionlib', 'test_simple_action_client_python',
TestRefSimpleActionServer)
dummy0 = Dummy()
dummy0.value = 354
dummy1 = Dummy()
dummy1.value = 5649
id_from_setter0 = set_srv(dummy0)
# id_from_setter cannot be passed to get_srv because of
# type incompatibility, "transform" it to a Get...Request()
id_to_getter0 = GetDummyDescriptorRequest()
id_to_getter0.id = id_from_setter0.id
response0 = get_srv(id_to_getter0)
id_from_setter1 = set_srv(dummy1)
# id_from_setter cannot be passed to get_srv because of
# type incompatibility, "transform" it to a Get...Request()
id_to_getter1 = GetDummyDescriptorRequest()
id_to_getter1.id = id_from_setter1.id
response1 = get_srv(id_to_getter1)
self.assertIsNot(dummy0, response0.descriptor)
self.assertIsNot(dummy0.value, response0.descriptor.value)
self.assertIsNot(dummy1, response1.descriptor)
self.assertEqual(dummy0.value, response0.descriptor.value)
self.assertEqual(dummy1.value, response1.descriptor.value)
if __name__ == '__main__':
import rostest
rostest.rosrun('nlj_dummy', 'test_db_message_passing',
TestDbMessagePassing)
#! /usr/bin/env python
import rospy
import rosunit
import unittest
import rostest
import time
PKG = 'pointcloud_merger'
NAME = 'pointcloud_merger_test'
class TestPCM(unittest.TestCase):
def setUp(self):
rospy.init_node('test_node')
def test_merge(self):
self.assertTrue((True), "Integration error")
if __name__ == '__main__':
rostest.rosrun(PKG, NAME, TestPCM)
number = 0
path = "./se306Project1/src/"
files = []
for i in os.listdir(path):
if os.path.isfile(os.path.join(path, i)) and re.match('Visitor\d.py',i):
number += 1
config_number = int(self.config.get('visitor.number').rstrip())
if config_number > 4:
config_number = 4
self.assertEqual(number, config_number, "Testing visitor files generated")
def test_WorkerGenerated(self):
number = 0
path = "./se306Project1/src/"
files = []
for i in os.listdir(path):
if os.path.isfile(os.path.join(path, i)) and re.match('Visitor\d.py',i):
number += 1
config_number = int(self.config.get('worker.number').rstrip())
if config_number > 4:
config_number = 4
self.assertEqual(number, config_number, "Testing worker files generated")
def tearDown(self):
generateEntity.exit_process(self.list)
if __name__ == '__main__':
# unittest.main()
import rostest
rostest.rosrun('se306Project1', 'test_bare_bones', Test_Generate_Files)
from robots import Animal, PickerRobot
from speedkiwi_msgs.msg import robot_status
PKG = 'speedkiwi_test'
class TestAnimal(unittest.TestCase):
def setUp(self):
rospy.init_node('test_animal')
self.animal = Animal('robot_0', 2, 0.5, 0, 0, 0)
def test_init(self):
"""Checks if animal attributes are set correctly after init."""
animal = self.animal
self.assertFalse(animal.currently_targeting)
self.assertEqual(animal.dict_index, -1)
self.assertEqual(animal.counter, 0)
self.assertFalse(animal.retreat, False)
def test_dog_stops_retreating(self):
"""Check the dog stops retreating when it reaches the kennel"""
animal = self.animal
animal.retreat = True
animal.execute_callback()
self.assertFalse(animal.retreat)
if __name__ == '__main__':
import rostest
rostest.rosrun(PKG, 'test_animal', TestAnimal, sys.argv)
F = ghmm.Float()
Abig = [[0.0, 1.0], [1.0, 0.0]]
Bbig = [[[1.0, 1.0, 1.0],
[0.9, 0.4, 0.2, 0.4, 2.2, 0.5, 0.2, 0.5, 1.0]],
[[10.0, 10.0, 10.0],
[1.0, 0.2, 0.8, 0.2, 2.0, 0.6, 0.8, 0.6, 0.9]]]
piBig = [0.5, 0.5]
modelBig = ghmm.HMMFromMatrices(
F, ghmm.MultivariateGaussianDistribution(F), Abig, Bbig, piBig)
modelBig.sample(10, 100, seed=3586662)
e = modelBig.sampleSingle(1)
print[x for x in e]
# get log P(seq | model)
logp = model.loglikelihood(seq)
print logp
# cacluate viterbi path
path = model.viterbi(seq)
print path
# train model parameters
model.baumWelch(seq_set, 500, 0.0001)
if __name__ == '__main__':
import rostest
rostest.rosrun(PKG, 'TestHMM', TestCustomHMMGestureModel)
"windows":[
{
"activity":"streetview",
"assets":["%s", "foo", "bar"],
"height":600,
"presentation_viewport":"center",
"width":800,
"x_coord":100,
"y_coord":100
}
]
}
""" % panoid
# get existing asset
asset = get_first_asset_from_activity(
load_director_message(director_msg), "streetview")
self.assertEqual(asset, panoid, 'Invalid asset returned')
# get non existing asset
asset = get_first_asset_from_activity(
load_director_message(director_msg), "panoview")
self.assertEqual(asset, None, 'No asset should have been returned')
self.check_soft_relaunch()
if __name__ == '__main__':
rostest.rosrun(PKG, NAME, TestSVServer, sys.argv)
# vim: tabstop=8 expandtab shiftwidth=4 softtabstop=4
self.assertTrue(
time_since_last_execution < 2 * Constants.max_action_duration,
"Too long since last goal was executed; likely due to a deadlock")
def execute_callback(self, goal):
# Note down last_execution time
self.last_execution_time = rospy.Time.now()
# Determine duration of this action
action_duration = random.uniform(0, Constants.max_action_duration)
with self.condition:
if not self.action_server.is_preempt_requested():
self.condition.wait(action_duration)
if self.action_server.is_preempt_requested():
self.action_server.set_preempted()
else:
self.action_server.set_succeeded()
def preempt_callback(self):
with self.condition:
self.condition.notify()
if __name__ == '__main__':
import rostest
rospy.init_node(Constants.node)
rostest.rosrun(Constants.pkg, Constants.node, DeadlockTest)
(2, 2, -2),
(2, -2, -2),
(-2, -2, -2),
(2, 2, -2))
# flight path assertion
self.fpa = FlightPathAssertion(positions, 1, 0)
self.fpa.start()
for i in range(0, len(positions)):
self.reach_position(positions[i][0], positions[i][1], positions[i][2], 120)
self.assertFalse(self.fpa.failed, "breached flight path tunnel (%d)" % i)
# does it hold the position for Y seconds?
count = 0
timeout = 50
while count < timeout:
if not self.is_at_position(2, 2, -2, 0.5):
break
count = count + 1
self.rate.sleep()
self.assertTrue(count == timeout, "position could not be held")
self.fpa.stop()
if __name__ == '__main__':
import rostest
rostest.rosrun(PKG, 'direct_offboard_posctl_test', DirectOffboardPosctlTest)
#unittest.main()
pub = rospy.Publisher(TOPIC, String, queue_size=1)
def publish_timer():
rospy.sleep(WARMUP_DELAY)
pub.publish(String(STRING))
rospy.sleep(TIME_LIMIT)
reactor.stop()
reactor.callInThread(publish_timer)
reactor.run()
self.assertEqual(len(test_client_received), 1)
websocket_message = decode_cbor(test_client_received[0])
self.assertEqual(websocket_message['topic'], TOPIC)
buff = io.BytesIO()
String(STRING).serialize(buff)
self.assertEqual(websocket_message['msg']['bytes'], buff.getvalue())
PKG = 'rosbridge_server'
NAME = 'test_websocket_cbor_raw'
if __name__ == '__main__':
rospy.init_node(NAME)
while not rospy.is_shutdown() and not rospy.has_param(
'/rosbridge_websocket/actual_port'):
rospy.sleep(1.0)
rostest.rosrun(PKG, NAME, TestWebsocketCborRaw)
self.assertEqual(res, self.correct_loglikelihoods["qtcc"])
def test_qtcbc_create(self):
res = self._create_hmm(self.QTCBC_QSR, 'qtcbc')
self.assertEqual(hashlib.md5(res).hexdigest(), self.correct_hashsum["qtcbc"])
def test_qtcbc_sample(self):
res = self._create_sample(self.QTCBC_SAMPLE_TEST_HMM, 'qtcbc')
self.assertEqual(res, self.correct_samples["qtcbc"])
def test_qtcbc_loglikelihood(self):
res = self._calculate_loglikelihood(self.QTCBC_PASSBY_LEFT_HMM, self.QTCBC_QSR, 'qtcbc')
self.assertEqual(res, self.correct_loglikelihoods["qtcbc"])
def test_rcc3_create(self):
res = self._create_hmm(self.RCC3_QSR, 'rcc3')
self.assertEqual(hashlib.md5(res).hexdigest(), self.correct_hashsum["rcc3"])
def test_rcc3_sample(self):
res = self._create_sample(self.RCC3_TEST_HMM, 'rcc3')
self.assertTrue(type(res) == list and len(res) > 0)
def test_rcc3_loglikelihood(self):
res = self._calculate_loglikelihood(self.RCC3_TEST_HMM, self.RCC3_QSR, 'rcc3')
self.assertEqual(res, self.correct_loglikelihoods["rcc3"])
if __name__ == '__main__':
import rostest
rostest.rosrun(PKG, NAME, TestHMM, sys.argv)
import time
from src.Animal import Animal
import math
import logging
from TestModule import TestModule
import inspect
"""
@class
This is a test for the correct construction of the Animal object.
"""
class Test_Animal_Setup(unittest.TestCase, TestModule):
animal = Animal("Node", 2, -10, -28, math.pi / 2)
def test_robot_carrier_setup(self):
self.assertEqual(self.animal.linearX, 3, "Setting linearX")
self.assertEqual(self.animal.dict_of_visitors, {},
"Setting dict_of_visitors")
self.assertEqual(self.animal.animal_state, "", "Setting animal_state")
if __name__ == '__main__':
# unittest.main()
import rostest
rostest.rosrun('se306Project1', 'test_bare_bones', Test_Animal_Setup)
self.tractor._action_queue[:] = [] #clear the list
self.tractor.execute_callback()
self.assertEqual(len(self.tractor._action_queue),4)
def test_execute_callback_was_blocked_true(self):
"""test was_blocked is true and action queue is old
queue when was_blocked is true"""
self.tractor.was_blocked = True
self.tractor.old_queue = []
self.tractor.execute_callback()
self.assertFalse(self.tractor.was_blocked)
self.assertEqual(self.tractor._action_queue,self.tractor.old_queue)
def test_orchard_get_coordinates(self):
"""Test the boundary values obtained from file are floats
NOTE: This is based on default world file. If configured world is run last this will fail"""
boundaries = locations.get_wall_boundaries()
self.tractor.min_x = boundaries["min_x"]
self.tractor.max_x = boundaries["max_x"]
self.tractor.min_y = boundaries["min_y"]
self.tractor.max_y = boundaries["max_y"]
self.assertEqual(self.tractor.min_x, -35)
self.assertEqual(self.tractor.min_y, -60)
self.assertEqual(self.tractor.max_x, 35)
self.assertEqual(self.tractor.max_y, 60)
if __name__ == '__main__':
import rostest
rostest.rosrun(PKG, 'test_tractor', TestTractor, sys.argv)
sensor_msgs.msg.Imu,
self.incoming_imu,
queue_size=1000)
def incoming_imu(self, imu_data):
with self.openzen_imu_access:
self.openzen_imu.append(imu_data)
def test_imu_data_incoming(self):
# wait for some data to arrive
rospy.sleep(0.5)
with self.openzen_imu_access:
self.assertTrue(len(self.openzen_imu) > 0)
# some sanity check on content
last_imu = self.openzen_imu.pop()
self.assertAlmostEqual(0.0, last_imu.linear_acceleration.x, 2)
self.assertAlmostEqual(0.0, last_imu.linear_acceleration.y, 2)
self.assertAlmostEqual(9.81, last_imu.linear_acceleration.z, 2)
# the test sensor will output some arbitrary gyro values
self.assertLess(0.0, last_imu.angular_velocity.x)
self.assertLess(0.0, last_imu.angular_velocity.y, 2)
self.assertLess(0.0, last_imu.angular_velocity.z, 2)
if __name__ == '__main__':
rostest.rosrun('openzen_driver', 'test_openzen_readout', TestOpenZen)
def test_run(self):
self.pose.orientation.x = 0.0
self.pose.orientation.y = 0.0
self.pose.orientation.z = 0.0
self.pose.orientation.w = 1.0
self.pose.position.x = 5.0
self.pose.position.y = 4.0
self.pose.position.z = 3.0
self.transform.translation.x = 2.0
self.transform.translation.y = 2.0
self.transform.translation.z = 2.0
self.transform.rotation.x = 0.0
self.transform.rotation.y = 0.0
self.transform.rotation.z = 0.0
self.transform.rotation.w = 1.0
self.expected.orientation = self.pose.orientation
self.expected.position.x = 7.0
self.expected.position.y = 6.0
self.expected.position.z = 5.0
self.execute()
if __name__ == '__main__':
import rostest
rostest.rosrun('estirabot_apps', 'testHomogeneoustranformOnlyrotation',
TestHomogeneousTranformOnlyRotation)
rostest.rosrun('estirabot_apps', 'testHomogeneoustranformonlytranslation',
TestHomogeneousTranformOnlyTranslation)
u'arm')
def test_cartpole_dynamics_solver(self):
check_dynamics_solver_derivatives('exotica/CartpoleDynamicsSolver')
def test_pendulum_dynamics_solver(self):
check_dynamics_solver_derivatives('exotica/PendulumDynamicsSolver')
# def test_quadrotor_dynamics_solver(self):
# check_dynamics_solver_derivatives('exotica/QuadrotorDynamicsSolver',
# u'{exotica_examples}/resources/robots/quadrotor.urdf',
# u'{exotica_examples}/resources/robots/quadrotor.srdf',
# u'base')
def test_pinocchio_dynamics_solver(self):
check_dynamics_solver_derivatives('exotica/PinocchioDynamicsSolver',
u'{exotica_examples}/resources/robots/lwr_simplified.urdf',
u'{exotica_examples}/resources/robots/lwr_simplified.srdf',
u'arm')
def test_pinocchio_gravity_compensation_dynamics_solver(self):
check_dynamics_solver_derivatives('exotica/PinocchioDynamicsSolverWithGravityCompensation',
u'{exotica_examples}/resources/robots/lwr_simplified.urdf',
u'{exotica_examples}/resources/robots/lwr_simplified.srdf',
u'arm')
if __name__ == '__main__':
import rostest
rostest.rosrun(PKG, 'TestDynamicsSolver', TestDynamicsSolver)
self.subs += [sub]
self.subs += subs
self.assertTrue(self.wait(), "Wait for throttled topic")
self.assertAlmostEqual(self.count, 5, delta=1)
self.assertEqual(self.max_diff, 0.0)
def test_async_delay(self):
sub = rospy.Subscriber("/foo", PoseStamped, self.delay_baz_cb)
subs = [
MF.Subscriber("/foo/async", PoseStamped, queue_size=1),
MF.Subscriber("/bar/async", PoseStamped, queue_size=1),
MF.Subscriber("/baz/async", PoseStamped, queue_size=1),
]
sync = MF.ApproximateTimeSynchronizer(subs, queue_size=10, slop=0.01)
sync.registerCallback(self.throttle_cb)
self.subs += [sub]
self.subs += subs
self.assertTrue(self.wait(), "Wait for throttled topic")
self.assertAlmostEqual(self.count, 5, delta=1)
self.assertLess(self.max_diff, 0.002)
if __name__ == '__main__':
import rostest
rospy.init_node("test_synchronized_throttle")
rostest.rosrun("jsk_topic_tools", "test_synchronized_throttle", TestSynchronizedThrottle)
#!/usr/bin/env python
import sys
import unittest
import rospy
from actions import NavigateAction, MoveAction, RotateAction
from world_locations import locations
from robots import Robot, CarrierRobot
from math import pi
PKG = 'speedkiwi_test'
class TestCarrier(unittest.TestCase):
def setUp(self):
rospy.init_node('test_picker')
self.carrier = CarrierRobot('robot_0', 2, 0.9, -20, 43, 0)
def test_execute_callback_speed(self):
"""Checks carrier sets speed to top speed in execute_callback"""
self.carrier.current_speed = 0
self.carrier.execute_callback()
self.assertEqual(self.carrier.current_speed, self.carrier.top_speed)
if __name__ == '__main__':
import rostest
rostest.rosrun(PKG, 'test_carrier', TestCarrier, sys.argv)
PKG = 'smart_home_core'
NAME = 'command_server_test'
import unittest
import sys
import rospy, rostest
from smart_home_core.srv import *
class TestCommandServer(unittest.TestCase):
def test_empty_call(self):
rospy.wait_for_service('command')
command = rospy.ServiceProxy('command', Command)
resp = command('').response.decode('utf-8')
self.assertTrue(resp.startswith(u'неизвестная команда'))
def test_wrong_call(self):
rospy.wait_for_service('command')
command = rospy.ServiceProxy('command', Command)
resp = command('unknown').response.decode('utf-8')
self.assertTrue(resp.startswith(u'неизвестная команда unknown'))
def test_ok_call(self):
rospy.wait_for_service('command')
command = rospy.ServiceProxy('command', Command)
resp = command('test param').response.decode('utf-8')
self.assertTrue(resp.startswith('test ok, param:param'))
if __name__ == '__main__':
rostest.rosrun(PKG, NAME, TestCommandServer, sys.argv)
start_pose.pose.position.z = 3.0
start_pose.pose.orientation.x = 0.0
start_pose.pose.orientation.y = 0.0
start_pose.pose.orientation.z = 1.0
start_pose.pose.orientation.w = 0.0
goal_pose.pose.position.x = 1.0
start_pose.pose.position.y = 2.0
goal_pose.pose.position.z = 3.0
# 180 degrees rotation around the X axis
goal_pose.pose.orientation.x = 1.0
goal_pose.pose.orientation.y = 0.0
goal_pose.pose.orientation.z = 0.0
goal_pose.pose.orientation.w = 0.0
while not self.wait_for_result:
self.event_out.publish('e_start')
self.start_pose.publish(start_pose)
self.goal_pose.publish(goal_pose)
assert type(self.result) is geometry_msgs.msg.PoseArray
def result_callback(self, msg):
self.result = msg
self.wait_for_result = True
if __name__ == '__main__':
rospy.init_node('dmp_based_task_space_test')
rostest.rosrun(PKG, 'dmp_based_task_space_test', TestDmpBasedTaskSpace)
import sys
import time
import unittest
import rospy
import rostest
from std_msgs.msg import String
class TestOnShutdown(unittest.TestCase):
def __init__(self, *args):
super(TestOnShutdown, self).__init__(*args)
self.success = False
def callback(self, data):
print rospy.get_caller_id(), "I heard %s"%data.data
#greetings is only sent over peer_publish callback, so hearing it is a success condition
if "I'm dead" in data.data:
self.success = True
def test_notify(self):
rospy.Subscriber("chatter", String, self.callback)
rospy.init_node(NAME, anonymous=True)
timeout_t = time.time() + 10.0*1000 #10 seconds
while not rospy.is_shutdown() and not self.success and time.time() < timeout_t:
time.sleep(0.1)
self.assert_(self.success, str(self.success))
if __name__ == '__main__':
rostest.rosrun(PKG, NAME, TestOnShutdown, sys.argv)
from std_msgs.msg import Float32
def eps_equal(a, b, err=0.001):
return abs(a - b) < err
hz_msg = None
def topic_cb(msg):
global hz_msg
hz_msg = msg
class TestHzMeasure(unittest.TestCase):
def test_hz(self):
global hz_msg
while hz_msg == None:
if not rospy.is_shutdown():
rospy.sleep(1.0) #wait 1 sec
# should be 30Hz
self.assertTrue(eps_equal(hz_msg.data, 30, 1))
if __name__ == "__main__":
import rostest
rospy.init_node("test_hz_measure")
s = rospy.Subscriber("/hz/output", Float32, topic_cb)
rostest.rosrun("jsk_topic_tools", "test_hz_measure", TestHzMeasure)
def step2(self):
rospy.loginfo('Step 2')
self.verify([self.rq1, self.rq2])
# send another request, which should wait
self.rq3 = self.request_turtlebot()
self.verify([self.rq1, self.rq2, self.rq3])
self.rqr.send_requests()
self.next_step = self.step3
def step3(self):
rospy.loginfo('Step 3')
self.verify([self.rq1, self.rq2, self.rq3])
self.rqr.rset[self.rq2].cancel()
self.rq4 = self.request_turtlebot()
self.verify([self.rq1, self.rq2, self.rq3, self.rq4])
self.rqr.send_requests()
self.next_step = self.step4
def step4(self):
rospy.loginfo('Step 4')
self.verify([self.rq1, self.rq3, self.rq4])
self.next_step = None
if __name__ == '__main__':
import rostest
rostest.rosrun('concert_scheduler_requests',
'timeout_requester', TestTimeoutRequester)
self.assertEquals(len(task_events), 2)
# task must start
self.assertEquals(task_events[0].event, TaskEvent.TASK_STARTED)
# might be preempted or failed, but not succeeeded
self.assertIn(task_events[1].event,
[TaskEvent.TASK_FAILED, TaskEvent.TASK_PREEMPTED])
def test_execution(self):
te = TestEntry('execution_test')
test = rospy.get_param('~test', 0)
if test == 0:
te.run_test(self.list_empty)
elif test == 1:
te.run_test(self.list_empty, test_tasks=5, pause_count=3)
elif test == 2:
te.run_test(self.list_empty,
test_tasks=10,
time_critical_tasks=3,
time_diffs_fn=self.check_time_diffs)
elif test == 3:
te.run_test(self.list_empty,
time_critical_tasks=5,
demanded_tasks=3,
test_tasks=5)
elif test == 4:
te.bad_timings(self.check_task_events)
if __name__ == '__main__':
rostest.rosrun('task_executor', 'executor_tests', TestWrapper, sys.argv)
import rospy
import rostest
import roslib.scriptutil as scriptutil
from std_msgs.msg import String
class TestListenerConnectionHeader(unittest.TestCase):
def __init__(self, *args):
super(TestListenerConnectionHeader, self).__init__(*args)
self.success = False
def callback(self, data):
chatter = data.data
if 'callerid' in data._connection_header:
who = data._connection_header['callerid']
self.success = True
else:
who = 'unknown'
print "I just heard %s from %s"%(chatter, who)
def test_notify(self):
rospy.Subscriber("chatter", String, self.callback)
rospy.init_node(NAME, anonymous=True)
timeout_t = time.time() + 10.0*1000 #10 seconds
while not rospy.is_shutdown() and not self.success and time.time() < timeout_t:
time.sleep(0.1)
self.assert_(self.success, str(self.success))
if __name__ == '__main__':
rostest.rosrun(PKG, NAME, TestListenerConnectionHeader, sys.argv)
self.safety.timing()
self.proxy_pass = False
msg = self.create_msg(m, self.safety.get_abs_pos('motor2','min',0.95))
self.pub['motor2'].publish(msg)
time.sleep(self._TIMEOUT)
# Check if same limit applies
self.assertMessageVal(expected,m)
# After time is passed limit is gradually increased with timing call
mock_time.return_value = start + 5.1
self.safety.timing()
msg = self.create_msg(m, self.safety.get_abs_pos('motor2','min',0.95))
self.pub['motor2'].publish(msg)
time.sleep(self._TIMEOUT)
self.assertMessageVal(expected, m, equal=False)
# Limit is beack to extreme position after multiple timing calls
# Should be similar number of calls as for decreasing the limit
self.safety.timing()
self.safety.timing()
self.safety.timing()
# Check if extreme messages are not modified after returniong back to normal value
self.proxy_pass = False
msg = self.create_msg(m, self.safety.get_abs_pos('motor2','min',0.99))
self.pub['motor2'].publish(msg)
time.sleep(self._TIMEOUT)
self.assertMessageVal(m['default'] + (m['min']-m['default'])*0.99,m)
if __name__ == "__main__":
import rostest
rostest.rosrun('motors_safety', 'test', MotorSafetyTest)
self.elapsed_time = rospy.rostime.get_time() - self.start_time
self.log[self.PKG]["simulation"]["elapsed_time"] = self.elapsed_time
self.log[self.PKG]["simulation"]["number_collisions"] = self.collisions_ctr
self.log[self.PKG]["simulation"]["direction_changes"] = self.dir_chg
yaml.dump(self.log, self.log_file, default_flow_style=False)
self.log_file.close()
def navigationGoal(self, GX, GY, GTh):
goal = PoseStamped()
goal.header.frame_id = "/map"
goal.header.stamp = rospy.get_rostime()
goal.pose.position.x = GX
goal.pose.position.y = GY
quat = quaternion_from_euler(0, 0, GTh)
goal.pose.orientation.w = quat[3]
return goal
if __name__ == "__main__":
rospy.init_node("test", anonymous=True)
rostest.rosrun("cob_navigation_global", "NavigationDiagnostics", TestNavigation, sys.argv)
#!/usr/bin/env python
#encoding: utf8
import rospy, unittest, rostest
import rosnode
import time
class HelloWorldTest(unittest.TestCase):
def test_node_exist(self):
nodes = rosnode.get_node_names()
self.assertIn('/hello_world', nodes, 'node does not exist')
if __name__ == '__main__':
time.sleep(3) # テスト対象のノードが立ち上がるのを待つ
rospy.init_node('test_hello_world.')
rostest.rosrun('frootspi_hello_world', 'test_hello_world', HelloWorldTest)
## Talker/listener demo validation
PKG = 'rospy_tutorials'
NAME = 'talker_listener_test'
import sys, unittest, time
import rospy, rostest
from std_msgs.msg import *
class TestTalkerListener(unittest.TestCase):
def __init__(self, *args):
super(TestTalkerListener, self).__init__(*args)
self.success = False
def callback(self, data):
print(rospy.get_caller_id(), "I heard %s"%data.data)
self.success = data.data and data.data.startswith('hello world')
def test_talker_listener(self):
rospy.init_node(NAME, anonymous=True)
rospy.Subscriber("chatter", String, self.callback)
timeout_t = time.time() + 10.0 #10 seconds
while not rospy.is_shutdown() and not self.success and time.time() < timeout_t:
time.sleep(0.1)
self.assert_(self.success)
if __name__ == '__main__':
rostest.rosrun(PKG, NAME, TestTalkerListener, sys.argv)
if lhz == prev_lhz and rhz == prev_rhz:
continue
if lhz > rhz: r_turn_count += 1
if lhz < rhz: l_turn_count += 1
prev_lhz, prev_rhz = lhz, rhz
count += 1
rate.sleep()
r_turn_rate = 1.0*r_turn_count / count
l_turn_rate = 1.0*l_turn_count / count
turn = None
if r_turn_rate > 0.6 and l_turn_rate < 0.2: turn = "right"
if l_turn_rate > 0.6 and r_turn_rate < 0.2: turn = "left"
self.assertFalse(turn is None,
"direction is not fixed. l:" + str(l_turn_rate) + " r:" + str(r_turn_rate))
self.assertEqual(sys.argv[1], turn,
"wrong direction. l: " + str(l_turn_rate) + " r:" + str(r_turn_rate))
if __name__ == '__main__':
rospy.init_node('test_face_to_face')
rostest.rosrun('cpimouse_vision_control','test_face_to_face', VisionTest)
# Copyright 2016 Ryuichi Ueda
# Released under the MIT License.
# To make line numbers be identical with the book, this statement is written here. Don't move it to the header.
# There was no error...check that this was okay.
self.assertTrue(rows_dim_is_dynamic or R == ii, testType)
self.assertTrue(cols_dim_is_dynamic or C == jj, testType)
# Check that the matrices are the same.
self.assertMatrixClose(numpyM,eigenM, testType)
except TypeError as inst:
# There was a type error. Check that this was expected.
self.assertFalse( (rows_dim_is_dynamic or R == ii) and (cols_dim_is_dynamic or C == jj), testType)
def vectorTests(self,t,i,j):
x = 1
# um...
def test_eigen(self):
T = ['double']
N = ('01','02','03','04','05','06','07','08','09','10','11','12','13','14','15','16','D')
#N = (1,2,3,4,'dynamic')
for t in T:
for i in N:
for j in N:
self.matrixTests(t,i,j)
if __name__ == '__main__':
import rostest
rostest.rosrun('numpy_eigen', 'test_eigen', TestEigen)
name = "Test{}".format(2 * i)
self.assertStatus(self.save_workspace(name, robot_poses))
ret_get_pos = self.get_workspace_poses(name)
self.assertStatus(ret_get_pos[0])
self.assertEqual(ret_get_pos[1], robot_poses)
name2 = "Test{}".format(2 * i + 1)
self.assertStatus(self.save_workspace_from_points(name2, points))
list_names.append(name)
list_names.append(name2)
self.assertEqual(self.get_workspace_list(), list_names)
for name in list_names:
self.assertStatus(self.delete_workspace(name))
self.assertEqual(self.get_workspace_list(), [])
if __name__ == '__main__':
while not rospy.has_param('/niryo_robot_poses_handlers/initialized'):
rospy.sleep(0.10)
position_dir = os.path.expanduser(
rospy.get_param('/niryo_robot_poses_handlers/poses_dir'))
trajectory_dir = os.path.expanduser(
rospy.get_param('/niryo_robot_poses_handlers/trajectories_dir'))
workspace_dir = os.path.expanduser(
rospy.get_param('/niryo_robot_poses_handlers/workspace_dir'))
# Going to execute all unittest.TestCase subclasses in the file -> Import are also concerned
rostest.rosrun("poses_handlers", "test_poses_handlers", __name__)
def test_ros_to_ntp(self):
r = rospy.Time(secs=self.secs, nsecs=self.nsecs)
ntp = ROStime_to_NTP64(r)
self.assertEqual(ntp >> 32, self.secs)
# seems to be some rounding imprecision with the division,
# it's irrelevent at this level so just account for it
ntp32 = ntp & 0xffffffff
diff = abs(ntp32 - self.frac32)
self.assertTrue((diff < 4))
def test_ntpsplit_to_ros(self):
r = NTP64split_to_ROStime(self.secs, self.frac32)
self.assertEqual(r.secs, self.secs)
# seems to be some rounding imprecision with the division,
# it's irrelevent at this level so just account for it
diff = abs(r.nsecs - self.nsecs)
self.assertTrue(diff < 2)
def test_bitstring(self):
self.assertEqual(bitString(6), '00000110')
self.assertEqual(bitString(0), '00000000')
self.assertEqual(bitString(0xa5), '10100101')
self.assertEqual(bitString(0xff), '11111111')
self.assertEqual(bitString(0xdeadbeef), '11011110101011011011111011101111')
self.assertEqual(bitString(0x1234), '1001000110100')
if __name__ == '__main__':
rospy.init_node('ldmrs_utils', disable_rostime=True)
rostest.rosrun(PKG, 'ldmrs_util', TestUtils)
goal.durations = [2, 2, 2, 2]
self.client.wait_for_server()
self.client.send_goal(goal, feedback_cb=self.feedback_cb)
self.client.wait_for_result()
self.assertTrue(self.client.get_result(), "invalid result")
self.assertEqual(
goal.freqs, self.device_values, "invalid feedback:" +
",".join([str(e) for e in self.device_values]))
### preemption ###
self.device_values = []
self.client.send_goal(goal, feedback_cb=self.feedback_cb)
self.client.wait_for_result(rospy.Duration.from_sec(0.5))
self.assertFalse(self.client.get_result(),
"stop is requested but return true")
self.assertFalse(goal.freqs == self.device_values, "not stopped")
def feedback_cb(self, feedback):
with open("/dev/rtbuzzer0", "r") as f:
data = f.readline()
self.device_values.append(int(data.rstrip()))
if __name__ == '__main__':
time.sleep(3)
rospy.init_node('travis_test_buzzer')
rostest.rosrun('pimouse_ros', 'travis_test_buzzer', BuzzerTest)
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
# FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
# COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
# BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
# LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
# ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
# POSSIBILITY OF SUCH DAMAGE.
PKG = 'test_rosmaster'
NAME = 'test_ps_encapsulation'
import sys
import rospy
import rostest
from param_server_test_case import ParamServerTestCase
class PsEncapsulationTestCase(ParamServerTestCase):
def testEncapsulation(self):
return self._testEncapsulation()
if __name__ == '__main__':
rospy.init_node(NAME)
rostest.rosrun(PKG, NAME, PsEncapsulationTestCase, sys.argv)
#!/usr/bin/env python
PKG = 'openrtm_ros_bridge'
import roslib; roslib.load_manifest(PKG)
import rospy
import unittest
import openrtm_ros_bridge.srv
#from openrtm_ros_bridge.srv import *
class TestMyServiceRosBridge(unittest.TestCase):
@classmethod
def setUpClass(self):
rospy.init_node('test_myservice_rosbridge')
def testEcho(self):
rospy.wait_for_service("/bridge/echo")
echo = rospy.ServiceProxy("/bridge/echo", openrtm_ros_bridge.srv.SimpleService_MyService_echo)
req = openrtm_ros_bridge.srv.SimpleService_MyService_echo
msg = "this is test data 123"
rospy.loginfo("send request > " + msg)
res = echo(msg)
rospy.loginfo("check return < " + res.operation_return)
self.assertTrue(res.operation_return == msg, "SimpleService.echo returns incorrect string")
if __name__ == '__main__':
import rostest
rostest.rosrun(PKG, 'test_myservice_rosbridge', TestMyServiceRosBridge)
# Test method
#
def test_posctl(self):
"""Test offboard position control"""
# make sure the simulation is ready to start the mission
self.wait_for_topics(60)
self.wait_for_landed_state(mavutil.mavlink.MAV_LANDED_STATE_ON_GROUND,
10, -1)
self.log_topic_vars()
self.set_mode("OFFBOARD", 5)
self.set_arm(True, 5)
rospy.loginfo("run mission")
positions = ((0, 0, 0), (2, 2, 2), (2, -2, 2), (-2, -2, 2), (2, 2, 2))
for i in xrange(len(positions)):
self.reach_position(positions[i][0], positions[i][1],
positions[i][2], 18)
self.set_arm(False, 5)
if __name__ == '__main__':
import rostest
rospy.init_node('test_node', anonymous=True)
rostest.rosrun(PKG, 'mavros_offboard_posctl_test',
MavrosOffboardPosctlTest)
if __name__ == '__main__':
parser = argparse.ArgumentParser(description='Manual exection of ATF recording phase.', formatter_class=argparse.RawTextHelpFormatter)
parser.add_argument('pkg', type=str,
help='test package name')
parser.add_argument('-g', dest='test_generation_config_file',
default='atf/test_generation_config.yaml',
help='path to test_generation_config file, relative to package root')
parser.add_argument('-t', dest='test',
default="ts*",
help='test identifier, e.g. \n'
+ '* or ts* --> record all tests (default)\n'
+ 'ts0_* --> record all tests with ts0\n'
+ 'ts0_*_r0_* --> record all tests with ts0 and r0\n'
+ 'ts0_c0_r0_e0_s0_0 --> record a single test ts0_c0_r0_e0_s0_0\n'
+ 'ts0_c0_r0_e0_s0_* --> record all iterations of test ts0_c0_r0_e0_s0_*\n'
)
parser.add_argument('-e', dest='execute_as_test', action='count',
help='execute as rostest')
parser.add_argument('-d', dest='dry_run', action='count',
help='execute dry run')
args, unknown = parser.parse_known_args()
if args.execute_as_test:
rostest.rosrun("atf_core", 'recording', TestRecording)
else:
args = parser.parse_args() # strictly parse only known arguments again. will raise an error if unknown arguments are specified
print("recording test in package '%s' with test generation file '%s'"%(args.pkg, args.test_generation_config_file))
recorder = Recorder()
recorder.record(args.pkg, args.test_generation_config_file, args.dry_run)
import sys
import unittest
import rospy
import rostest
from rbe_3002.srv import *
class TestAStar(unittest.TestCase):
def test_correct_response(self):
# When we setup access to the aStar service
rospy.loginfo("Starting Unit Test")
rospy.wait_for_service('a_star')
s = rospy.ServiceProxy('a_star', AStar)
startPoint = (4, 4)
goalPoint = (7, 9)
# When we make a request to this service
req = AStarRequest(startPoint, goalPoint)
pathResponse = s(req)
path = zip(pathResponse.pathx, pathResponse.pathy)
#Then the first and last values returned by the path should be the start and goal repspectively
self.assertEquals(goalPoint, path[0], "The first elemet of the returned tuple was not the goal point")
self.assertEquals(startPoint, path[-1], "The last elemet of the returned tuple was not the start point")
if __name__ == '__main__':
rostest.rosrun(PKG, NAME, TestAStar, sys.argv)
class TestSimpleActionClient(unittest.TestCase):
def testsimple(self):
client = SimpleActionClient('reference_action', TestAction)
self.assertTrue(client.wait_for_server(rospy.Duration(10.0)),
'Could not connect to the action server')
goal = TestGoal(1)
client.send_goal(goal)
self.assertTrue(client.wait_for_result(rospy.Duration(10.0)),
"Goal didn't finish")
self.assertEqual(GoalStatus.SUCCEEDED, client.get_state())
self.assertEqual("The ref server has succeeded",
client.get_goal_status_text())
goal = TestGoal(2)
client.send_goal(goal)
self.assertTrue(client.wait_for_result(rospy.Duration(10.0)),
"Goal didn't finish")
self.assertEqual(GoalStatus.ABORTED, client.get_state())
self.assertEqual("The ref server has aborted",
client.get_goal_status_text())
if __name__ == '__main__':
import rostest
rospy.init_node('simple_python_client_test')
rostest.rosrun('actionlib', 'test_simple_action_client_python',
TestSimpleActionClient)
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
# FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
# COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
# BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
# LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
# ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
# POSSIBILITY OF SUCH DAMAGE.
PKG = 'test_rosmaster'
NAME = 'test_ps_values'
import sys
import rospy
import rostest
from param_server_test_case import ParamServerTestCase
class PsValuesTestCase(ParamServerTestCase):
def testParamValues(self):
return self._testParamValues()
if __name__ == '__main__':
rospy.init_node(NAME)
rostest.rosrun(PKG, NAME, PsValuesTestCase, sys.argv)
self.assertEqual(vs.sum_forward, lf+rf, "different value: sum_forward")
def test_node_exist(self):
nodes = rosnode.get.node_names()
self.assertIn('/lightsensors' ,nodes, "node does not exist")
def test_get_value(self):
rospy.set_param('lightsensors_freq' ,10)
time.sleep(2)
with open("/dev/rtlightsensor0","w") as f:
f.write("-1 0 123 4567\n")
time.sleep(3)
self.assertFalse(self.count == 0 , "cannot subscribe the topic")
self.check_values(4321,123,0,-1)
def test_change_parameter(self):
rospy.set_param('lightsensors_freq',1)
time.sleep(2)
c_prev = self.count
time.sleep(3)
self.assertTrue(self.count < c_prev + 4,"freq does not change")
self.assertFalse(self.count == c_prev , "subscriver is stopped")
if __name__ == '__main__':
time.sleep(3)
rospy.init_node('travis_test_lightsensors')
rostest.rosrun('pimouse_ros','travis_test_lightsensors',LightsensorTest)
req = WeatherReporterCurrentSrvRequest()
response = self._test_service(req)
self.assertEqual(response.error,
"'City provided is wrong or not supported'")
# @unittest.expectedFailure
@unittest.skip('Skipping tests - Uncomment decorators to test manually')
def test_actual_city(self):
req = WeatherReporterCurrentSrvRequest()
for city in self._cities:
req.city = city
response = self._test_service(req)
self.assertEqual(response.error, "")
self.assertNotEqual(response.temperature, "")
# @unittest.expectedFailure
@unittest.skip('Skipping tests - Uncomment decorators to test manually')
def test_random_city(self):
req = WeatherReporterCurrentSrvRequest()
req.city = \
''.join(random.choice(string.ascii_letters) for _ in range(20))
response = self._test_service(req)
self.assertEqual(response.error,
"'City provided is wrong or not supported'")
if __name__ == '__main__':
rostest.rosrun(
'rapp_weather_reporter',
'yweather_reporter_current_test',
TestCurrentYWeatherReporter)
time.sleep(0.3)
with open("/dev/rtmotor_raw_l0","r") as lf,\
open("/dev/rtmotor_raw_r0","r") as rf:
left = int(lf.readline().rstrip())
right = int(rf.readline().rstrip())
return left, right
def test_io(self):
left, right = self.set_and_get(400, 100, 100, 0) #total:600
self.assertTrue(left == 0 and right == 0, "can't stop")
left, right = self.set_and_get(0, 5, 1000, 0) #side direction is not a trigger of stop
self.assertTrue( left == right != 0, "stop wrongly by side sensors")
left, right = self.set_and_get(0, 10, 0, 0) #curve to left
self.assertTrue( left < right, "don't curve to left")
left, right = self.set_and_get(0, 200, 0, 0) #curve to right
self.assertTrue( left > right, "don't curve to right")
left, right = self.set_and_get(0, 5, 0, 0) #don't control when far from a wall
self.assertTrue( 0 < left == right, "curve wrongly")
if __name__=='__main__':
time.sleep(3)
rospy.init_node('travis_test_wall_trace')
rostest.rosrun('pimouse_run_corridor','travis_test_wall_trace',WallTraceTest)
with capture_screen(video, timeout):
pub.publish(msg_class(*targets[name]))
add_text_to_video(video)
videos.append(video)
ofile = "%s/face.avi" % self.output_dir
concatenate_videos(videos, ofile, True)
pub.unregister()
def test_long_viseme(self):
filename = get_rosbag_file("long_viseme")
# job = play_rosbag(filename)
# job.join()
pub, msg_class = rostopic.create_publisher("/blender_api/queue_viseme", "blender_api_msgs/Viseme", True)
bag = rosbag.Bag(filename)
duration = bag.get_end_time() - bag.get_start_time()
fps = bag.get_message_count() / float(duration)
wait = 1.0 / fps / 10 # 10 times faster than the speed of the msg recoreded
for topic, msg, _ in rosbag_msg_generator(filename):
pub.publish(msg)
time.sleep(wait)
# Test if blender is still alive
self.assertIn("/blender_api", rosnode.get_node_names())
self.assertTrue(any(["blender_api" in name for name in self.runner.pm.get_active_names()]))
if __name__ == "__main__":
import rostest
rostest.rosrun(PKG, "blender_api", BlenderAPITest)
# unittest.main()
self.as_server = actionlib.SimpleActionServer(as_name,
MoveBaseAction,
execute_cb=self.base_cb,
auto_start=False)
self.as_server.start()
client = actionlib.SimpleActionClient('/script_server', ScriptAction)
self.cb_move_executed = False
if not client.wait_for_server(rospy.Duration(10)):
self.fail('Action server not ready')
client.send_goal(goal)
client.wait_for_result(rospy.Duration(10))
#if not client.wait_for_result(rospy.Duration(10)):
# self.fail('Action didnt give a result before timeout')
#if not self.cb_executed:
# self.fail('Action Server not called. script server error_code: ' + str(client.get_result().error_code))
def base_cb(self, goal):
self.cb_move_executed = True
result = MoveBaseResult()
self.as_server.set_succeeded(result)
# test move trajectory commands
#TODO
if __name__ == '__main__':
import rostest
rostest.rosrun(PKG, 'action_interface', TestActionInterface)
#!/usr/bin/env python
#-*- coding: utf-8 -*-
PKG = 'jenkins_test_repro'
#import roslib; roslib.load_manifest(PKG) # This line is not needed with Catkin.
import os
import rostest
import unittest
from MetricTester import MetricTester
class TestMetricStarter(unittest.TestCase):
def test_metrics(self):
mt = MetricTester()
#self.assertTrue(False, os.getcwd())
#self.assertTrue(False, os.listdir(os.getcwd()))
self.assertTrue(mt.load_yaml_config(), "loading yaml-config")
self.assertTrue(mt.triggerFeedbackServer(), "feedback server response")
self.assertTrue(mt.download_resources(), "downloading resources")
self.assertTrue(mt.cleanup_resources(), "cleanup resources")
if __name__ == '__main__':
rostest.rosrun(PKG, 'MetricStarter', TestMetricStarter)
self.assertEqual(grasp.id, "super_amazing_grasp")
self.assertEqual(grasp.grasp_pose.pose.position.x, 0.5)
self.assertEqual(grasp.grasp_pose.pose.position.y, 0.5)
self.assertEqual(grasp.grasp_pose.pose.position.z, 0.7)
self.assertEqual(round_sig(grasp.grasp_pose.pose.orientation.x, 5),
round_sig(0.396609862374, 5))
self.assertEqual(round_sig(grasp.grasp_pose.pose.orientation.y, 5),
round_sig(0.443462541797, 5))
self.assertEqual(round_sig(grasp.grasp_pose.pose.orientation.z, 5),
round_sig(0.770688050305, 5))
self.assertEqual(round_sig(grasp.grasp_pose.pose.orientation.w, 5),
round_sig(0.2282137599, 5))
self.assertEqual(1, 1)
if __name__ == '__main__':
import rostest
rospy.sleep(20)
# rostest.rosrun("test_service_running",
# "test_fast_grasp_planner",
# TestFastGraspPlanner)
rostest.rosrun("test_grasp_selection",
'test_fast_grasp_planner',
TestFastGraspPlanner)
