def run_tests(): # run the tests in this thread import rosunit try: rosunit.unitrun(PKG, 'test_camera_info_manager', TestCameraInfoManager) finally: rospy.signal_shutdown('test complete') # terminate the test node
def run_tests(): # run the tests in this thread import rosunit try: rosunit.unitrun('rocon_scheduler_requests', 'test_rocon_scheduler_requests_py', TestSchedulerRequestManager) finally: rospy.signal_shutdown('test complete') # terminate the test node
def unitrun(package, test_name, test, sysargs=None, coverage_packages=None): """ Wrapper routine from running python unitttests with JUnit-compatible XML output. This is meant for unittests that do not not need a running ROS graph (i.e. offline tests only). This enables JUnit-compatible test reporting so that test results can be reported to higher-level tools. @param package: name of ROS package that is running the test @type package: str @param coverage_packages: list of Python package to compute coverage results for. Defaults to package @type coverage_packages: [str] """ rosunit.unitrun(package, test_name, test, sysargs=sysargs, coverage_packages=coverage_packages)
idx_stamps = i i += 1 i = 0 for point in pc2.read_points(cloud_out): ri = scan.ranges[i] ai = scan.angle_min + i * scan.angle_increment self.assertAlmostEqual(point[idx_x], ri * np.cos(ai), tolerance, "x not equal") self.assertAlmostEqual(point[idx_y], ri * np.sin(ai), tolerance, "y not equal") self.assertAlmostEqual(point[idx_z], 0, tolerance, "z not equal") self.assertAlmostEqual(point[idx_intensity], scan.intensities[i], tolerance, "Intensity not equal") self.assertAlmostEqual(point[idx_index], i, tolerance, "Index not equal") self.assertAlmostEqual(point[idx_distance], ri, tolerance, "Distance not equal") self.assertAlmostEqual(point[idx_stamps], i * scan.time_increment, tolerance, "Timestamp not equal") i += 1 if __name__ == '__main__': import rosunit rosunit.unitrun(PKG, 'projection_test', ProjectionTest)
from ecto_image_pipeline.io.source.ros import BagReader from ecto_image_pipeline.io.source.camera_base import _assert_source_interface import unittest class TestSourceBagReader(unittest.TestCase): def test_interface(self): br = BagReader() print br.__doc__ assert 'image_message' in br.__doc__ assert 'depth' in br.__doc__ assert 'image' in br.__doc__ assert 'K' in br.__doc__ #verify some types. assert 'boost::shared_ptr<sensor_msgs::Image_<std::allocator<void> > const>' == br.outputs.at('image_message').type_name #this should pass our interface check _assert_source_interface(br) #test the bag file name parameter br = BagReader(bag='testy.bag') assert br.params.bag == 'testy.bag' assert br.source.params.bag == 'testy.bag' _assert_source_interface(br) if __name__ == '__main__': import rosunit rosunit.unitrun('ecto_image_pipeline', 'test_source_bag_reader', TestSourceBagReader)
## A sample python unit test class TestUrdf(unittest.TestCase): def test_correct_format(self): print sys.argv print len(sys.argv) if len(sys.argv) < 2: self.fail("no urdf file given, usage: " + os.path.basename(sys.argv[0]) + " file.urdf.xacro. \ninput parameters are: " + str(sys.argv)) file_to_test = sys.argv[1] print "testing " + file_to_test # check if file exists if not os.path.exists(file_to_test): self.fail('file "' + file_to_test + '" not found') # check if xacro can be converted if os.system("`rospack find xacro`/xacro.py " + file_to_test + " > /tmp/test.urdf") != 0: self.fail("cannot convert xacro. file: " + file_to_test) # check if urdf is correct if os.system("check_urdf /tmp/test.urdf") != 0: self.fail("urdf not correct. file: " + file_to_test) if __name__ == '__main__': import rosunit rosunit.unitrun(PKG, 'test_urdf', TestUrdf) ########NEW FILE########
def test_json_with_invalid_message_fields(self): self.assertRaises(ValueError, json_message_converter.convert_json_to_ros_message, 'std_msgs/String', '{"not_data": "Hello"}') def serialize_deserialize(message): """ Serialize and then deserialize a message. This simulates sending a message between ROS nodes and makes sure that the ROS messages being tested are actually serializable, and are in the same format as they would be received over the network. In rospy, it is possible to assign an illegal data type to a message field (for example, `message = String(data=42)`), but trying to publish this message will throw `SerializationError: field data must be of type str`. This method will expose such bugs. """ from StringIO import StringIO buff = StringIO() message.serialize(buff) result = message.__class__() # create new instance of same class as message result.deserialize(buff.getvalue()) return result PKG = 'rospy_message_converter' NAME = 'test_json_message_converter' if __name__ == '__main__': import rosunit rosunit.unitrun(PKG, NAME, TestJsonMessageConverter)
rr = os.path.abspath('test2') retcode, retval = self._rospack_langs(rr, None, None) self.assertEquals(0, retcode) self.failIf(retval, "rospack langs on empty directory returned value %s"%retval) # Test auto-inclusion of msg_gen include directories, #3018 def test_msg_gen(self): test_path = os.path.abspath('test') pkgs = ['msg_gen_no_export', 'msg_gen_no_cpp', 'msg_gen_no_cflags'] for p in pkgs: self.rospack_succeed(p, "cflags-only-I") self.assertEquals(os.path.join(test_path, p, "msg_gen/cpp/include"), self.strip_opt_ros(self.run_rospack(p, "cflags-only-I"))) # Test that -q option suppresses errors, #3177. def test_quiet_option(self): ros_root = os.path.abspath('test') # With -q: look for non-existent package, make sure that it fails, yet # produces nothing on stderr. status_code, stdout, stderr = self._run_rospack(ros_root, None, 'nonexistentpackage', 'find -q') self.assertNotEquals(0, status_code) self.assertEquals(0, len(stderr)) # Without -q: look for non-existent package, make sure that it fails, # and produces somthing on stderr. status_code, stdout, stderr = self._run_rospack(ros_root, None, 'nonexistentpackage', 'find') self.assertNotEquals(0, status_code) self.assertNotEquals(0, len(stderr)) if __name__ == "__main__": import rosunit rosunit.unitrun(PKG, 'rospack_exe_process', RospackTestCase)
def test_update_baseline_zero(self): # do update updater = camera_yaml_updater.CameraYamlUpdater(FILE_IN, FILE_OUT) updater.update_baseline(0.0) # compare with correct results self.assertTrue(self._cmp_yaml_files(FILE_OUT, FILE_IN)) def test_update_baseline_positive(self): # do update updater = camera_yaml_updater.CameraYamlUpdater(FILE_IN, FILE_OUT) updater.update_baseline(10.0) # compare with correct results self.assertTrue(self._cmp_yaml_files(FILE_OUT, FILE_OUT_RES_POS)) def test_update_baseline_negative(self): # do update updater = camera_yaml_updater.CameraYamlUpdater(FILE_IN, FILE_OUT) updater.update_baseline(-10.0) # compare with correct results self.assertTrue(self._cmp_yaml_files(FILE_OUT, FILE_OUT_RES_NEG)) def _cmp_yaml_files(self, f1, f2): return yaml.load(file(f1)) == yaml.load(file(f2)) if __name__ == '__main__': import rosunit rosunit.unitrun(PKG, 'TestCameraYamlUpdater', TestCameraYamlUpdater)
self.assertEqual(out.vel.z(), 2) self.assertEqual(out.rot.x(), 4) self.assertEqual(out.rot.y(), -5) self.assertEqual(out.rot.z(), -6) w = PyKDL.Wrench(PyKDL.Vector(1,2,3), PyKDL.Vector(4,5,6)) out = b.transform(tf2_ros.Stamped(w, rospy.Time(2), 'a'), 'b') self.assertEqual(out.force.x(), 1) self.assertEqual(out.force.y(), -2) self.assertEqual(out.force.z(), -3) self.assertEqual(out.torque.x(), 4) self.assertEqual(out.torque.y(), -8) self.assertEqual(out.torque.z(), -4) def test_convert(self): v = PyKDL.Vector(1,2,3) vs = tf2_ros.Stamped(v, rospy.Time(2), 'a') vs2 = tf2_ros.convert(vs, PyKDL.Vector) self.assertEqual(vs.x(), 1) self.assertEqual(vs.y(), 2) self.assertEqual(vs.z(), 3) self.assertEqual(vs2.x(), 1) self.assertEqual(vs2.y(), 2) self.assertEqual(vs2.z(), 3) if __name__ == '__main__': import rosunit rospy.init_node('test_tf2_kdl_python') rosunit.unitrun("test_tf2_kdl", "test_tf2_kdl_python", KDLConversions)
# Check number of alternatives self.assertEqual(len(response.alternatives), 0) def test_notExistentFile(self): rospack = rospkg.RosPack() google_service = rospy.get_param(\ "rapp_speech_detection_google_detect_speech_topic") rospy.wait_for_service(google_service) stt_service = rospy.ServiceProxy(google_service, SpeechToTextSrv) req = SpeechToTextSrvRequest() req.filename = rospack.get_path('rapp_testing_tools') + \ '/test_data/something.flac' req.audio_type = 'nao_wav_1_ch' req.user = '******' req.language = 'en' response = stt_service(req) words_basic = len(response.words) # self.assertEqual(response.words, 1) # Check number of words self.assertEqual(words_basic, 0) # Check number of alternatives self.assertEqual(len(response.alternatives), 0) if __name__ == '__main__': import rosunit rosunit.unitrun(PKG, 'SpeechToTextFunc', SpeechToTextFunc)
rospy.wait_for_service(service) test_service = rospy.ServiceProxy(\ service, ontologyLoadDumpSrv) req = ontologyLoadDumpSrvRequest() req.file_url = "testDump.owl" response = test_service(req) self.assertEqual(response.success, True) ## Test dump ontology with invalid path def test_dump_invalid_path(self): service = rospy.get_param(\ "rapp_knowrob_wrapper_dump_ontology_topic") rospy.wait_for_service(service) test_service = rospy.ServiceProxy(\ service, ontologyLoadDumpSrv) req = ontologyLoadDumpSrvRequest() req.file_url = "/someInvalidPath/testDump.owl" response = test_service(req) self.assertEqual(response.success, False) ## The main function. Initializes the Cognitive Exercise System functional tests if __name__ == '__main__': import rosunit rosunit.unitrun(PKG, 'OntologyFunc', OntologyFunc)
class TestBagSystemIO(unittest.TestCase): def test_init(self): self.assertTrue(BagSystemIO()) def test_input(self): bag_system_io = BagSystemIO() input = [(0.1, (1, 2, 2, 2, 2, 2)), (0.1, (1, 2, 2, 2, 2, 2)), (0.1, (1, 2, 2, 2, 2, 2))] output = [(0.1, (1, 2)), (0.1, (1, 2)), (0.1, (1, 2))] self.assertEqual(bag_system_io.get_input(input), output) def test_output(self): bag_system_io = BagSystemIO() input = [(0.1, (1, 2, 2, 2, 2, 2)), (0.1, (1, 2, 2, 2, 2, 2)), (0.1, (1, 2, 2, 2, 2, 2))] output = [(0.1, (1, 2)), (0.1, (1, 2)), (0.1, (1, 2))] self.assertEqual(bag_system_io.get_output(input), output) def test_states(self): bag_system_io = BagSystemIO() input = [(0.1, (1, 1, 0, 0, 0, 1, 1, 1, 0, 0, 0, 1)), (0.1, (1, 1, 0, 0, 0, 1, 1, 1, 0, 0, 0, 1))] output = [(0.1, (1, 1, 1, 1, 1, 1)), (0.1, (1, 1, 1, 1, 1, 1))] self.assertEqual(bag_system_io.get_states(input), output) if __name__ == '__main__': rosunit.unitrun("adapt_kalman", 'test_bag_system_io', TestBagSystemIO)
param(logm='errorf', rosm='logerr'), param(logm='fatalf', rosm='logfatal'), ]) @patch('fiware_ros_bridge.logging.rospy') def test_log_w_params(self, mocked_rospy, logm, rosm): name = 'foo' message = 'test message' arg0 = 'arg0' arg1 = 'arg1' kwargs0 = 'kwargs0' kwargs1 = 'kwargs1' log_message = '[{name}:{caller}] {message}, {arg1}, {kwargs0}, {arg0}, {kwargs1}'.format( name=name, caller=self.__class__.__name__ + '.' + sys._getframe().f_code.co_name, message=message, arg0=arg0, arg1=arg1, kwargs0=kwargs0, kwargs1=kwargs1, ) logger = getLogger(name) assert logger.name == name getattr(logger, logm)(message + ', {1}, {kwargs0}, {0}, {kwargs1}', arg0, arg1, kwargs1=kwargs1, kwargs0=kwargs0) getattr(mocked_rospy, rosm).assert_called_once_with(log_message) if __name__ == '__main__': rosunit.unitrun('fiware_ros_bridge', 'test_logging', TestGetLogger)
param(mcmd='circle', rcmd='circle'), param(mcmd='square', rcmd='square'), param(mcmd='triangle', rcmd='triangle'), param(mcmd='cross', rcmd='stop'), param(mcmd='up', rcmd='up'), param(mcmd='down', rcmd='down'), param(mcmd='left', rcmd='left'), param(mcmd='right', rcmd='right'), param(mcmd='invalid', rcmd=None), ]) @patch('fiware_ros_bridge.cmd_bridge.rospy') def test__on_message(self, mocked_rospy, mcmd, rcmd): mocked_rospy.get_param.return_value = utils.get_cmd_params() mocked_client = MagicMock() msg = type('msg', (object,), {'payload': 'deviceid@move|{}'.format(mcmd)}) CmdBridge()._on_message(mocked_client, None, msg) if mcmd in ('circle', 'square', 'triangle', 'cross', 'up', 'down', 'left', 'right'): mocked_rospy.Publisher.return_value.publish.assert_called_once_with(String(data=rcmd)) mocked_client.publish.assert_called_once_with('/robot/turtlebot3/cmdexe', 'deviceid@move|cmd {} executed successfully'.format(mcmd)) else: mocked_rospy.Publisher.return_value.publish.assert_not_called() mocked_client.publish.assert_called_once_with('/robot/turtlebot3/cmdexe', 'deviceid@move|unknown cmd {} did not executed'.format(mcmd)) if __name__ == '__main__': rosunit.unitrun('fiware_ros_bridge', 'test_cmd_bridge', TestCmdBridge)
self.assertIsInstance( Constraint.create('LogBarrierMethod', 'test_log', 'x'), LogBarrierMethod, 'Log barrier constraint object could not be created') self.assertIsInstance( Constraint.create('InverseBarrierMethod', 'test_inverse', 'x'), InverseBarrierMethod, 'Inverse barrier constraint object could not be created') self.assertIsInstance( Constraint.create('PenaltyFunction', 'test_penalty', 'x'), PenaltyFunction, 'Penalty constraint object could not be created') def test_penalty(self): p_fcn = Constraint.create('PenaltyFunction', 'test_penalty', 'x') p_fcn.from_dict(self.penalty_params_valid) self.assertEquals(p_fcn.compute(0), 0, 'Invalid output for value in the feasible set') self.assertGreater( p_fcn.compute(self.penalty_params_valid['offset'] + 1), 0, 'Invalid output for value outside of the feasible set') def test_barrier(self): pass if __name__ == '__main__': import rosunit rosunit.unitrun(PKG, NAME, TestConstraint)
for pt2 in g.points: path = pl.planner(makeRequest(g.id.uuid, pt1.id.uuid, pt2.id.uuid)) def test_3x3_grid(self): # generate a fully-connected 3x3 grid g = grid_graph(-0.003, -0.003, 0.0, 0.0) pl = Planner(g) # all pairs of points should have a valid path for pt1 in g.points: for pt2 in g.points: path = pl.planner(makeRequest(g.id.uuid, pt1.id.uuid, pt2.id.uuid)) def test_10x10_grid(self): # generate a fully-connected 10x10 grid g = grid_graph(0.0, 0.0, 0.01, 0.01) pl = Planner(g) # all pairs of points should have a valid path for pt1 in g.points: for pt2 in g.points: path = pl.planner(makeRequest(g.id.uuid, pt1.id.uuid, pt2.id.uuid)) if __name__ == '__main__': import rosunit rosunit.unitrun(PKG, 'test_planner_py', TestPlanner)
capping of input values between 0 and 1.""" # Preparing mocks within the widget self.psi.barSpeed = MagicMock() self.psi.barSpeed.setValue = MagicMock() # 0 speed should be displayed as 0% self.psi.set_speed(0) self.psi.barSpeed.setValue.assert_called_with(0) # 0.5 speed should be displayed as 50% self.psi.set_speed(.5) self.psi.barSpeed.setValue.assert_called_with(50) # 1 speed should be displayed as 100% self.psi.set_speed(1) self.psi.barSpeed.setValue.assert_called_with(100) # speed values below 0 should be displayed as 0% self.psi.set_speed(-1) self.psi.barSpeed.setValue.assert_called_with(0) # speed values above 1 should be displayed as 100% self.psi.set_speed(2) self.psi.barSpeed.setValue.assert_called_with(100) if __name__ == '__main__': import rosunit rosunit.unitrun('pilz_status_indicator_rqt', 'test_status_indicator_widget', TestStatusIndicatorWidget)
r = resolve_args('$(anon foo)/bar') self.assert_('/bar' in r) self.failIf('$(anon foo)' in r) # test against strings that should not match noop_tests = [ '$(find roslib', '$find roslib', '', ' ', 'noop', 'find roslib', 'env ROS_ROOT', '$$', ')', '(', '()', None, ] for t in noop_tests: self.assertEquals(t, resolve_args(t)) failures = [ '$((find roslib))', '$(find $roslib)', '$(find)', '$(find roslib roslib)', '$(export roslib)', '$(env)', '$(env ROS_ROOT alternate)', '$(env NOT_SET)', '$(optenv)', '$(anon)', '$(anon foo bar)', ] for f in failures: try: resolve_args(f) self.fail("resolve_args(%s) should have failed"%f) except SubstitutionException: pass if __name__ == '__main__': rosunit.unitrun('test_roslib', 'test_substitution_args', SubArgsTest, coverage_packages=['roslib.substitution_args'])
import roslib roslib.load_manifest('test_roslib_comm') import unittest import rosunit from test_roslib_comm.msg import * class TestMd5sums(unittest.TestCase): def test_field_name_change(self): self.assertNotEquals(FieldNameChange1._md5sum, FieldNameChange2._md5sum) def test_type_name_change(self): self.assertEquals(TypeNameChange1._md5sum, TypeNameChange2._md5sum) def test_type_name_change_array(self): self.assertEquals(TypeNameChangeArray1._md5sum, TypeNameChangeArray2._md5sum) def test_type_name_change_complex(self): self.assertEquals(TypeNameChangeComplex1._md5sum, TypeNameChangeComplex2._md5sum) if __name__ == '__main__': rosunit.unitrun('test_roslib_comm', 'test_md5sums', TestMd5sums, coverage_packages=[])
self.client.login() # Test unsuccessful delete of image from server. # Set an image on the server, then try to delete the image from # the server. self.object.set_image(generate_image()) server.set_post_object_image_response(1) self.object.sync() # Delete the image. self.object.delete_image() # Try to delete the image from the server. codes = [400, 404, 500] for code in codes: server.set_delete_object_image_response(1, code=code) self.object.sync() self.assertFalse(self.object._needs_adding) self.assertFalse(self.object._needs_updating) self.assertFalse(self.object._needs_deleting) self.assertFalse(self.object._image_needs_setting) self.assertTrue(self.object._image_needs_deleting) self.assertTrue(self.object.image_is_on_server) if __name__ == "__main__": rospy.init_node("test_local_objects") rosunit.unitrun("test_local_objects", "test_object", TestObject)
from __future__ import absolute_import, print_function import uuid import unittest # module being tested: import rocon_scheduler_requests.common as common TEST_UUID_HEX = '0123456789abcdef0123456789abcdef' TEST_UUID = uuid.UUID(hex=TEST_UUID_HEX) class TestCommonModule(unittest.TestCase): """Unit tests for scheduler request manager common module. These tests do not require a running ROS core. """ def test_feedback_default_topic(self): self.assertEqual(common.feedback_topic(TEST_UUID), common.SCHEDULER_TOPIC + '_' + TEST_UUID_HEX) def test_feedback_topic(self): topic = common.feedback_topic(TEST_UUID, scheduler_topic='xxx') self.assertEqual(topic, 'xxx_' + TEST_UUID_HEX) if __name__ == '__main__': import rosunit rosunit.unitrun('rocon_scheduler_requests_common', 'test_common_module', TestCommonModule)
self.assertLess( difference, max_error, msg="Failed on request {}, with error {}, producing {}".format( (fx, fy, moment), difference, net ) ) return success tests = [ (0, 0, 0), (20, 70, -3), (100, 0, 0), (0, 0, 5), (180, 0, 0), (200, 0, 0), (100, 20, -3), (120, 15, 12), ] results = {} for test in tests: result = run_test(*test) if __name__ == '__main__': import rosunit rosunit.unitrun(PKG, 'test_azi_drive', Test_Azi_Drive)
def test_calculate_sync_velocity_angular(self): """ Tests that the 'calculate_sync_velocity' function returns the correct value, given linear and angular velocities (i.e. a six-dimensional list). """ max_time = 2.0 error_1 = [1.0, 2.0, 3.0, 4.0, 5.0, 6.0] velocity_1 = [1.0, -2.0, 3.0, -4.0, -5.0, 6.0] desired_1 = [0.5, -1.0, 1.5, -2.0, -2.5, 3.0] error_2 = [1.0, 2.0, 0.0, 0.0, 0.0, 6.0] velocity_2 = [1.0, -2.0, 3.0, -4.0, -5.0, 6.0] desired_2 = [0.5, -1.0, 0.0, 0.0, 0.0, 3.0] actual_1 = twist_synchronizer_utils.calculate_sync_velocity( error_1, velocity_1, max_time, angular_synchronization=True ) actual_2 = twist_synchronizer_utils.calculate_sync_velocity( error_2, velocity_2, max_time, angular_synchronization=True ) testing.assert_almost_equal(actual_1, desired_1, decimal=4) testing.assert_almost_equal(actual_2, desired_2, decimal=4) if __name__ == '__main__': rosunit.unitrun(PKG, 'test_twist_synchronizer', TestTwistSynchronizer)
def test_Servo_ExceedsVelocityLimitThrows(self): velocity_limits = self._robot.GetDOFVelocityLimits(self._indices) velocity_limits_small = -velocity_limits - 0.1 * numpy.ones(self._num_dofs) velocity_limits_large = velocity_limits + 0.1 * numpy.ones(self._num_dofs) self.assertRaises(Exception, self._wam.Servo, (velocity_limits_small, 0.3)) self.assertRaises(Exception, self._wam.Servo, (velocity_limits_large, 0.3)) def test_Servo_InvalidAccelTimeThrows(self): velocity_limits = 0.1 * numpy.ones(self._num_dofs) self.assertRaises(Exception, self._wam.Servo, (velocity_limits, -0.1)) self.assertRaises(Exception, self._wam.Servo, (velocity_limits, 0.0)) def test_SetVelocityLimits_SetsLimits(self): velocity_limits = 0.1 * numpy.ones(self._num_dofs) self._wam.SetVelocityLimits(velocity_limits, 0.3) numpy.testing.assert_array_almost_equal(self._robot.GetDOFVelocityLimits(self._indices), velocity_limits) def test_MoveUntilTouch_ZeroDirectionThrows(self): self.assertRaises(Exception, self._wam.MoveUntilTouch, (numpy.zeros(3), 0.1)) def test_MoveUntilTouch_ZeroDistanceThrows(self): self.assertRaises(Exception, self._wam.MoveUntilTouch, (numpy.array([ 1., 0., 0. ]), 0.0)) def test_MoveUntilTouch_NonPositiveForceThrows(self): self.assertRaises(Exception, self._wam.MoveUntilTouch, (numpy.array([ 1., 0., 0. ]), 0.1, 0.)) if __name__ == '__main__': import rosunit rosunit.unitrun(PKG, 'test_wam', WamTest)
def perform_rostest(self, test_pkg): TestCase = type(test_pkg + '_test_class', (unittest.TestCase, ), self._evaluation_tests) rosunit.unitrun(test_pkg, test_pkg + '_flexbe_tests', TestCase)
l = len(cache.getInterval(rospy.Time(0), rospy.Time(4))) self.assertEquals(l, 5, "invalid number of messages" + " returned in getInterval 3") s = cache.getElemAfterTime(rospy.Time(0)).header.stamp self.assertEqual(s, rospy.Time(0), "invalid msg return by getElemAfterTime") s = cache.getElemBeforeTime(rospy.Time(3.5)).header.stamp self.assertEqual(s, rospy.Time(3), "invalid msg return by getElemBeforeTime") s = cache.getLastestTime() self.assertEqual(s, rospy.Time(4), "invalid stamp return by getLastestTime") s = cache.getOldestTime() self.assertEqual(s, rospy.Time(0), "invalid stamp return by getOldestTime") # Add another msg to fill the buffer msg = AnonymMsg() msg.header.stamp = rospy.Time(5) cache.add(msg) # Test that it discarded the right one s = cache.getOldestTime() self.assertEqual(s, rospy.Time(1), "wrong message discarded") if __name__ == "__main__": import rosunit rosunit.unitrun(PKG, "test_message_filters_cache", TestCache)
def recv_job_status(self, msg): if msg.data == "finished": self.job_finish_event.set() def test_pick_and_place(self): rospy.Subscriber('/state_machine/state', String, self.recv_state) rospy.Subscriber('/job_status', String, self.recv_job_status) self._start_pick_place = rospy.Publisher('/start_pick_place', Empty, queue_size=10) rospy.sleep(1) # Wait until the system is initialized, if it is still uninitialized if not self.robot_state == 'standby': rospy.loginfo("Waiting until system is ready") self.robot_state_event.clear() self.robot_state_event.wait() rospy.sleep(1) rospy.loginfo("Sending command to start the job") self.job_finish_event.clear() self._start_pick_place.publish() self.job_finish_event.wait() if __name__ == '__main__': # unittest.main() import rosunit rosunit.unitrun(PKG, 'test_pick_place', TestPickPlace)
class TPCC_Test(Abstractclass_Unittest_Triadic): def __init__(self, *args): super(TPCC_Test, self).__init__(*args) self._unique_id = "tpcc" # data1 contains data for only 2 objects so the default tests has to be with data2 # would be same as test_without_bounding_boxes in other QSRs tests def test_defaults(self): self.assertItemsEqual(*self.defaults("data3", "data3_tpcc_defaults.txt")) def test_qsrs_for_global_namespace(self): self.assertItemsEqual(*self.qsrs_for_global_namespace("data3", "data3_tpcc_qsrs_for_global_namespace.txt")) def test_qsrs_for_qsr_namespace(self): self.assertItemsEqual(*self.qsrs_for_qsr_namespace("data3", "data3_tpcc_qsrs_for_qsr_namespace.txt")) # precedes "for_all_qsrs" namespace self.assertItemsEqual(*self.qsrs_for_qsr_namespace_over_global_namespace("data3", "data3_tpcc_qsrs_for_qsr_namespace.txt")) def test_with_bounding_boxes(self): self.assertItemsEqual(*self.defaults("data2", "data2_tpcc_defaults.txt")) def test_floats(self): self.assertItemsEqual(*self.defaults("data4", "data4_tpcc_defaults.txt")) if __name__ == '__main__': import rosunit rosunit.unitrun("qsr_lib", "tpcc_test", TPCC_Test, sys.argv)
cs_params.P[3].y = 100 cs_params.T[0].x = 0 cs_params.T[0].y = 0 cs_params.resolution = 1000 try: self.projector_manager.connect_and_setup() status = self.projector_manager.get_connection_status() if status: # create coordinate system self.projector_manager.define_coordinate_system( cs_params, False) cs_read = self.projector_manager.get_coordinate_system_params( name) self.assertEquals(cs_read.distance, cs_params.distance) # create axes and frame self.projector_manager.cs_axes_create(cs_params) self.projector_manager.cs_frame_create(cs_params) pass else: self.fail("connection error") except Exception as e: self.fail("Exception raised: {}".format(e)) if __name__ == '__main__': rosunit.unitrun('z_laser_zlp1', 'test_manager_coordinate_system', TestProjectorManager, sysargs=None)
import roslib roslib.load_manifest(PKG) def call_xacro(xml_file): assert os.path.isfile(xml_file), 'Invalid XML xacro file' return subprocess.check_output(['xacro', '--inorder', xml_file]) class TestRexROVURDFFiles(unittest.TestCase): def test_xacro(self): # Retrieve the root folder for the tests test_dir = os.path.abspath(os.path.dirname(__file__)) robots_dir = os.path.join(test_dir, '..', 'robots') for item in os.listdir(robots_dir): if 'oberon' in item: continue if not os.path.isfile(os.path.join(robots_dir, item)): continue output = call_xacro(os.path.join(robots_dir, item)) self.assertNotIn(output, 'XML parsing error', 'Parsing error found for file {}'.format(item)) self.assertNotIn(output, 'No such file or directory', 'Some file not found in {}'.format(item)) if __name__ == '__main__': import rosunit rosunit.unitrun(PKG, NAME, TestRexROVURDFFiles)
req.file_size = len(file_bytes) response = up_prox(req) status = response.status self.assertEqual( status, True ) if __name__ == '__main__': import rosunit home = expanduser("~") if os.path.isdir(home+"/rapp_platform_files/maps/functional_test"): shutil.rmtree(home+"/rapp_platform_files/maps/functional_test") rospack = rospkg.RosPack() map_server_path = rospack.get_path("rapp_map_server") shutil.copytree(map_server_path+"/maps/", home+"/rapp_platform_files/maps/functional_test/") rosunit.unitrun(PKG, 'PathPlanFunc', PathPlanFunc) shutil.rmtree(home+"/rapp_platform_files/maps/functional_test")
# 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. # # Author: Brian Gerkey PKG = 'rosrt' import roslib; roslib.load_manifest(PKG) import unittest import os from subprocess import Popen, PIPE class TestPublisherNoInitializeTestCase(unittest.TestCase): # Check that test_publisher_no_initialize exits cleanly, as opposed to, # for example, seg-faulting, #3569. def test_no_initialize(self): cmd = os.path.join(roslib.packages.get_pkg_dir(PKG), 'bin', 'test_publisher_no_initialize') p = Popen([cmd], stdout=PIPE, stderr=PIPE) p.communicate() self.assertEquals(p.returncode, 0) if __name__ == "__main__": import rosunit rosunit.unitrun(PKG, 'test_publisher_no_initialize', TestPublisherNoInitializeTestCase)
self.fail("error test3") # test start projection without active coordinate system defined should return error def test4_start_proj(self): license_path = (os.path.dirname(os.path.dirname(os.path.abspath(__file__)))+'/lic/1900027652.lic') projector_manager = ZLPProjectorManager(projector_IP = "192.168.10.10", server_IP = "192.168.10.11", connection_port = 9090, lic_path=license_path) try: projector_manager.connect_and_setup() status = projector_manager.get_connection_status() if status: projector_manager.start_projection() projector_manager.deactivate() projector_manager.client_server_disconnect() pass else: self.fail("error test4") except Exception: projector_manager.deactivate() projector_manager.client_server_disconnect() pass if __name__ == '__main__': rosunit.unitrun('z_laser_zlp1', 'test_manager_connection', TestProjectorManager, sysargs=None)
# *** abstractmethods def qsrs_for_global_namespace(self, world_name, gt_filename): dynamic_args = deepcopy(self.__dynamic_args) dynamic_args["for_all_qsrs"] = {"qsrs_for": [("o2", "o1"), "o2"]} return self.custom(world_name, gt_filename, dynamic_args) def qsrs_for_qsr_namespace(self, world_name, gt_filename): dynamic_args = deepcopy(self.__dynamic_args) # cherry pick some of the qsrs dynamic_args["rcc2"] = {"qsrs_for": [("o1", "o2")]} dynamic_args["qtcbs"]["qsrs_for"] = [("o1", "o2")] dynamic_args["mwe"] = {"qsrs_for": [("o1", "o2")]} dynamic_args["mos"] = {"qsrs_for": ["o1"]} return self.custom(world_name, gt_filename, dynamic_args) def qsrs_for_qsr_namespace_over_global_namespace(self, world_name, gt_filename): dynamic_args = deepcopy(self.__dynamic_args) dynamic_args["for_all_qsrs"] = {"qsrs_for": [("o2", "o1"), "o2"]} # cherry pick some of the qsrs dynamic_args["rcc2"] = {"qsrs_for": [("o1", "o2")]} dynamic_args["qtcbs"]["qsrs_for"] = [("o1", "o2")] dynamic_args["mwe"] = {"qsrs_for": [("o1", "o2")]} dynamic_args["mos"] = {"qsrs_for": ["o1"]} return self.custom(world_name, gt_filename, dynamic_args) # *** eof abstractmethods if __name__ == '__main__': import rosunit rosunit.unitrun("qsr_lib", "multiple_test", Multiple_Test, sys.argv)
@patch("sensehat_ros.host.SenseHat") def test_get_environmental(self, sense): # Configure mocked hardware senseObj = sense.return_value # to track instance methods we need to target the instance mock, not the class senseObj.get_humidity.return_value = 1.0 senseObj.get_temperature_from_humidity.return_value = 2.0 senseObj.get_temperature_from_pressure.return_value = 3.0 senseObj.get_pressure.return_value = 4.0 # Create a patched Host without requiring the SenseHat hardware host = self.get_host(smoothing=0) # Read sensor values environmental = host._get_environmental(datetime.now()) senseObj.get_humidity.assert_called_once() senseObj.get_temperature_from_humidity.assert_called_once() senseObj.get_temperature_from_pressure.assert_called_once() senseObj.get_pressure.assert_called_once() # Assert self.assertEqual(environmental.humidity, self.calibration['humidity'] + 1) self.assertEqual(environmental.temperature_from_humidity, self.calibration['temperature_from_humidity'] + 2) self.assertEqual(environmental.temperature_from_pressure, self.calibration['temperature_from_pressure'] + 3) self.assertEqual(environmental.pressure, self.calibration['pressure'] + 4) if __name__ == '__main__': import rosunit rosunit.unitrun(PKG, 'TestHost', TestHost)
self.assertRaises(TypeError, SEUID, ("hello", "world")) def test_msg_hostmsg(self): s = SEUID(hs) self.assertEqual(s.host, "127.0.0.1") def test_get_seuid(self): s = SEUID(hs) self.assertEqual("h!127.0.0.1", s.get_seuid("host")) def test_get_seuid_invalid(self): s = SEUID() self.assertRaises(AttributeError, s.get_seuid, "host") s = SEUID(hs) self.assertRaises(KeyError, s.get_seuid, "node") if __name__ == '__main__': import rosunit data = rospy.get_param('/arni/test/mockdata') hs = HostStatistics() for k in data.keys(): try: setattr(hs, k, data[k]) except Exception: pass rosunit.unitrun(PKG, 'test_seuid', TestSeuid)
error = [1.0 for _ in range(10)] max_error = 20.0 error[2] = max_error # Not using a ROS bag to calculate the KPIs kpi = KPI.get_kpi('max_error', 'test', False) self.assertIsNotNone(kpi, 'The KPI instance was not created properly') self.assertEqual(kpi.compute(error), max_error, 'Max. error was not calculated properly') def test_mean_error_without_bag(self): error = np.random.rand(10) + 2 # Not using a ROS bag to calculate the KPIs kpi = KPI.get_kpi('mean_error', 'test', False) self.assertIsNotNone(kpi, 'The KPI instance was not created properly') self.assertIsNotNone(kpi.compute(error), 'Mean error was not calculated properly') def test_rms_error_without_bag(self): error = np.random.rand(10) + 2 # Not using a ROS bag to calculate the KPIs kpi = KPI.get_kpi('rmse', 'test', False) self.assertIsNotNone(kpi, 'The KPI instance was not created properly') self.assertIsNotNone(kpi.compute(error), 'RMS error was not calculated properly') if __name__ == '__main__': import rosunit rosunit.unitrun(PKG, NAME, TestKPIS)
sys.argv = real_argv def test_create_local_xmlrpc_uri(self): from roslib.network import parse_http_host_and_port, create_local_xmlrpc_uri self.assertEquals(type(create_local_xmlrpc_uri(1234)), str) os.environ['ROS_HOSTNAME'] = 'localhost' self.assertEquals(('localhost', 1234), parse_http_host_and_port(create_local_xmlrpc_uri(1234))) def setUp(self): self._ros_hostname = self._ros_ip = None if 'ROS_HOSTNAME' in os.environ: self._ros_hostname = os.environ['ROS_HOSTNAME'] del os.environ['ROS_HOSTNAME'] if 'ROS_IP' in os.environ: self._ros_ip = os.environ['ROS_IP'] del os.environ['ROS_IP'] def tearDown(self): if 'ROS_HOSTNAME' in os.environ: del os.environ['ROS_HOSTNAME'] if 'ROS_IP' in os.environ: del os.environ['ROS_IP'] if self._ros_hostname: os.environ['ROS_HOSTNAME'] = self._ros_hostname if self._ros_ip: os.environ['ROS_IP'] = self._ros_ip if __name__ == '__main__': rosunit.unitrun('test_roslib', 'test_network', NetworkTest, coverage_packages=['roslib.network'])
""" r in 'rxyz' is 'r'otating frames indicating rotations are applied consecutively with respect to current frames' axes, "relative-rotation". Order of rotations are first X, second Y and third Z. Rotation matrix composition rule for relative rotations: Rx * Ry * Rz. s in 'sxyz' is 's'tationary frames indicating rotations are applied with respect to the coordinate frame of the INITIAL frame, "fixed-axis rotation". Rotation matrix composition rule for fixed-axis rotations: Rz * Ry * Rx. """ Rx_90 = tr.rotation_matrix( math.pi / 4, [1, 0, 0]) # first, rotate 90 degrees around x axis Ry_90 = tr.rotation_matrix( math.pi / 5, [0, 1, 0]) # second, 45 degrees around y axis of the current frame Rz_90 = tr.rotation_matrix( math.pi / 6, [0, 0, 1]) # third, 30 degrees around z axis of the current frame R1 = np.matmul(Rz_90, Ry_90) R = np.matmul(R1, Rx_90) euler_angles = tr.euler_from_matrix(R, 'sxyz') euler_angles_expected = [math.pi / 4, math.pi / 5, math.pi / 6] np.testing.assert_almost_equal(euler_angles, euler_angles_expected) if __name__ == '__main__': rosunit.unitrun('apriltags2_ros', 'test_rotation_utils', RotationUtils)
#!/usr/bin/env python PKG='wet6' import roslib; roslib.load_manifest(PKG) import sys import os import unittest class TestSample(unittest.TestCase): def test_sample(self): # nothing to report pass if __name__ == '__main__': import rosunit rosunit.unitrun(PKG, 'test_urdf', TestSample)
class TestFaceDetector(unittest.TestCase): def set_up(self): # Harr cascade classifiers self.c1 = cv2.CascadeClassifier("haarcascade_frontalface_alt.xml") self.c2 = cv2.CascadeClassifier("haarcascade_frontalface_alt") self.c3 = cv2.CascadeClassifier("haarcascade_profileface.xml") self.test_image_face = self.convert_cv_to_img(cv2.imread('test_face.jpg',0)) self.test_image_no_face = self.convert_cv_to_img(cv2.imread('test_no_face.jpg',0)) self.no_image = np.zeros((0,0), np.uint8) self.test_images_good = self.import_test_images self.test_images_bad = self.generate_bad_images def import_test_images(self): test_images = [] prefix = "i" filetype = ".jpg" for suffix in range(0,12): im_name = prefix+str(suffix)+filetype im = self.convert_cv_to_img(cv2.imread(im_name,0)) test_images.append return test_images def generate_bad_images(self): good images = self.import_test_images() bad_images = good_images[0:6] bad_images.append(self.no_image) bad_images = good_images[7:11] bad_images.append(self.no_image) return bad_images def test_face_detector_face(self): fd.set_classifiers(c1, c2, c3) face_box = fd.detect_face(self.test_image_face) if face_box is not None: x1 = face_box.x y1 = face_box.y x2 = face_box.width + x1 y2 = face_box.height + y1 self.assertTrue(face_box is not None, "Image contains a face between (%d,%d) and (%d,%d)"%(x1,y1,x2,y2)) def test_face_detector_no_face(self): fd.set_classifiers(c1, c2, c3) face_box = fd.detect_face(self.test_image_face) x1 = face_box.x y1 = face_box.y x2 = face_box.width + x1 y2 = face_box.height + y1 self.assertTrue(face_box is None, "Image does not contain a face!") def test_multiple_faces(self, faces): fd.set_classifiers(c1, c2, c3) for image in faces: index = 0 face_box = fd.detect_face(image) if face_box is not None: x1 = face_box.x y1 = face_box.y x2 = face_box.width + x1 y2 = face_box.height + y1 self.assertTrue(face_box is not None, "Image %d contains a face between (%d,%d) and (%d,%d)"%(index,x1,y1,x2,y2)) else: self.assertTrue(face_box is None, "Image %d contains no face!"%s(index)) index+=1 def test_face_detector_multiple_good_faces(self): self.test_multiple_faces(self.test_images_good) def test_face_detector_multiple_bad_faces(self): self.test_multiple_faces(self.test_images_bad) if __name__ == '__main__': import rosunit rosunit.unitrun(PKG, 'unit_test_face_detector', TestFaceDetector)
import unittest import rosunit import rosdep.core import rosdep.installers class RosdepSourceTest(unittest.TestCase): def test_aptinstaller_installed(self): args = {} args["packages"] = "libc6 gcc" ai = rosdep.installers.AptInstaller(args) self.assertTrue(ai.check_presence()) ## Requires sudo self.assertTrue(ai.generate_package_install_command()) def test_aptinstaller_not_installed(self): args = {} args["packages"] = "not-a-package" ai = rosdep.installers.AptInstaller(args) self.assertFalse(ai.check_presence()) ## Requres sudo self.assertFalse(ai.generate_package_install_command()) if __name__ == '__main__': os.environ["ROSDEP_TEST_OS"] = "rosdep_test_os" rosunit.unitrun('test_rosdep', 'test_source', RosdepSourceTest, coverage_packages=['rosdep.core'])
from rqt_dep.dotcode_pack import RosPackageGraphDotcodeGenerator PKG = 'rqt_deps' class DotcodeGeneratorTest(unittest.TestCase): def test_packages_only(self): with patch('rospkg.RosPack') as rospack: with patch('rospkg.RosStack') as rosstack: factoryMock = Mock() graphMock = Mock() rospack.list.return_value = [] rosstack.list.return_value = [] factoryMock.get_graph.return_value = graphMock gen = RosPackageGraphDotcodeGenerator(rospack, rosstack) graph = gen.generate_dotcode(factoryMock) rospack.list.assert_called() rosstack.list.assert_called() factoryMock.get_graph.assert_called_with(simplify=True, rank='same', ranksep=0.2, rankdir='TB') factoryMock.create_dot.assert_called_with(graphMock) if __name__ == '__main__': import rosunit rosunit.unitrun(PKG, 'test_packages_only', DotcodeGeneratorTest)
# Points points = [] normals = [] for item in docking: points.append(item['point']) normals.append(item['normal']) # Expected expected_points = [[3, 5], [4, 4], [6, 4]] expected_normals = [[1, 0], [0, 1], [0, 1]] outcome = True for p in expected_points: if not p in points: outcome = False break if not np.allclose(normals, expected_normals): outcome = False err_msg = 'wrong result is: ' for i in range(3): err_msg += '[' + `points[i][0]` + ', ' + `points[i][1]` + ']' for i in range(3): err_msg += '[' + `normals[i][0]` + ', ' + `normals[i][1]` + ']' self.assertTrue(outcome, err_msg) if __name__ == '__main__': rosunit.unitrun(PKG, 'docking_test', TestDocking)
board.n_rows = setup.rows board.dim = self.board_width_dim mc = MonoCalibrator([board], flags=cv2.CALIB_FIX_K3, pattern=setup.pattern) if 0: # display the patterns viewed by the camera for pattern_warped in self.limages[i]: cv2.imshow("toto", pattern_warped) cv2.waitKey(0) mc.cal(self.limages[i]) self.assert_good_mono(mc, self.limages[i], setup.lin_err) # Make sure the intrinsics are similar err_intrinsics = numpy.linalg.norm(mc.intrinsics - self.K, ord=numpy.inf) self.assert_( err_intrinsics < setup.K_err, 'intrinsics error is %f for resolution i = %d' % (err_intrinsics, i)) print('intrinsics error is %f' % numpy.linalg.norm(mc.intrinsics - self.K, ord=numpy.inf)) if __name__ == '__main__': #rosunit.unitrun('camera_calibration', 'directed', TestDirected) rosunit.unitrun('camera_calibration', 'artificial', TestArtificial)
#remove user ros_service = rospy.get_param("rapp_mysql_wrapper_remove_platform_user_service_topic") rospy.wait_for_service(ros_service) test_service = rospy.ServiceProxy(ros_service, removePlatformUserSrv) req = removePlatformUserSrvRequest() req.username="******" response = test_service(req) self.assertTrue(response.success) ## The main function. Initializes the Cognitive Exercise System functional tests if __name__ == '__main__': import rosunit rosunit.unitrun(PKG, 'CognitiveExerciseFunc', CognitiveExerciseFunc)
self.assertEqual(expected, result) def test_add(self): expected = 3 result = self._calculator.add(1, 2) self.assertEqual(expected, result) expected = 2.5 result = self._calculator.add(1.7, 0.8) self.assertAlmostEqual(expected, result) def test_set_value(self): value = 4 self._calculator.set_value(value) result = self._calculator.get_value() self.assertEqual(value, result) def test_delete_value(self): self._calculator.set_value(2.4) self._calculator.delete_value() expected = None result = self._calculator.get_value() self.assertEqual(expected, result) if __name__ == "__main__": import rosunit rosunit.unitrun('frootspi_hello_world', 'test_hello', TestHello)
"Launch file not copied.") self.assertTrue(os.path.exists(self.pjoin("etc/ros", os.getenv("ROS_DISTRO"), "baz.d/b.launch")), "Launch file not copied.") def test_uninstall(self): j = segway_upstart.Job(name="boo") j.add('segway_upstart', glob='test/launch/*.launch') j.install(sudo=None, root=self.root_dir) j.uninstall(sudo=None, root=self.root_dir) self.assertFalse(os.path.exists(self.pjoin("etc/ros", os.getenv("ROS_DISTRO"), "boo.d")), "Job dir not removed.") self.assertFalse(os.path.exists(self.pjoin("etc/ros", os.getenv("ROS_DISTRO"), "usr/sbin/foo-start")), "Start script not removed.") def test_uninstall_user_file(self): j = segway_upstart.Job(name="goo") j.add('segway_upstart', glob='test/launch/*.launch') j.install(sudo=None, root=self.root_dir) with open(self.pjoin("etc/ros", os.getenv("ROS_DISTRO"), "goo.d/c.launch"), "w") as f: f.write("<launch></launch>") j.uninstall(sudo=None, root=self.root_dir) self.assertTrue(os.path.exists(self.pjoin("etc/ros", os.getenv("ROS_DISTRO"), "goo.d/c.launch")), "User launch file wrongly removed.") if __name__ == '__main__': import rosunit rosunit.unitrun('segway_upstart', 'test_basics', TestBasics)
} r = Robot.from_urdf_file(donbot_urdf) self.assertSetEqual(set(r.get_joint_names_controllable()), expected) def test_get_joint_names_boxy(self): expected = { u'left_arm_2_joint', u'neck_joint_end', u'neck_wrist_1_joint', u'right_arm_2_joint', u'right_arm_4_joint', u'neck_wrist_3_joint', u'right_arm_3_joint', u'right_gripper_base_gripper_right_joint', u'left_gripper_base_gripper_right_joint', u'left_arm_0_joint', u'right_gripper_base_gripper_left_joint', u'left_arm_4_joint', u'left_arm_6_joint', u'right_arm_1_joint', u'left_arm_1_joint', u'neck_wrist_2_joint', u'triangle_base_joint', u'neck_elbow_joint', u'right_arm_5_joint', u'left_arm_3_joint', u'neck_shoulder_pan_joint', u'right_arm_0_joint', u'neck_shoulder_lift_joint', u'left_arm_5_joint', u'left_gripper_base_gripper_left_joint', u'right_arm_6_joint' } r = Robot.from_urdf_file(body_urdf) self.assertSetEqual(set(r.get_joint_names_controllable()), expected) if __name__ == '__main__': import rosunit rosunit.unitrun(package=PKG, test_name='TestSymengineController', test=TestSymengineController)
def _Timer_callback(self, event): self.timer_callbacks += 1 self.timer_event = event def callback(event): print('last_expected: ', event.last_expected) print('last_real: ', event.last_real) print('current_expected: ', event.current_expected) print('current_real: ', event.current_real) print('current_error: ', (event.current_real - event.current_expected).to_sec()) print('profile.last_duration:', event.last_duration) if event.last_real: print('last_error: ', (event.last_real - event.last_expected).to_sec(), 'secs') def test_Timer(self): import rospy timer = rospy.Timer(rospy.Duration(1), self._Timer_callback) time.sleep(10) timer.shutdown() # make sure we got an approximately correct number of callbacks self.assert_(abs(self.timer_callbacks - 10) < 2) # make sure error is approximately correct. the Timer # implementation tracks error in accumulated real time. ev = self.timer_event self.assert_(ev is not None) self.assert_(abs((ev.current_real - ev.current_expected).to_sec()) < 2.) if __name__ == '__main__': rosunit.unitrun('test_rospy', sys.argv[0], TestRospyTimerOnline, coverage_packages=['rospy.timer'])
timeout_t = time.time() + 5. t2 = TestTask(task2) t2.start() while not t2.done and time.time() < timeout_t: time.sleep(0.5) self.assert_(t2.success) self.assert_('hello' in t2.value.data) # test wait for message with timeout FAILURE def task3(): # #2842 raising bounds from .1 to .3 for amazon VM return rospy.wait_for_message('fake_topic', std_msgs.msg.String, timeout=.3) timeout_t = time.time() + 2. t3 = TestTask(task3) t3.start() while not t3.done and time.time() < timeout_t: time.sleep(0.5) self.failIf(t3.success) self.assert_(t3.done) self.assert_(t3.value is None) if __name__ == '__main__': rosunit.unitrun('test_rospy', sys.argv[0], TestRospyClientOnline, coverage_packages=['rospy.client', 'rospy.msproxy'])
test_service = rospy.ServiceProxy(conf_service, AudioProcessingSetNoiseProfileSrv) req = AudioProcessingSetNoiseProfileSrvRequest() req.audio_file_type = 'nao_wav_6_ch' req.noise_audio_file = aux + '/silence_wav_d05_a1.wav' req.user = '******' response = test_service(req) self.assertNotEqual( response.error, '' ) self.assertEqual( response.success, 'false' ) def test_setNoiseProfileService_no_silence_file(self): rospack = rospkg.RosPack() aux = rospack.get_path('rapp_testing_tools') + '/test_data' conf_service = rospy.get_param("rapp_audio_processing_set_noise_profile_topic") rospy.wait_for_service(conf_service) test_service = rospy.ServiceProxy(conf_service, AudioProcessingSetNoiseProfileSrv) req = AudioProcessingSetNoiseProfileSrvRequest() req.audio_file_type = 'nao_wav_4_ch' req.noise_audio_file = aux + '/silence_wav_d05_a1_nope.wav' req.user = '******' response = test_service(req) self.assertNotEqual( response.error, '' ) self.assertEqual( response.success, 'false' ) if __name__ == '__main__': import rosunit rosunit.unitrun(PKG, 'AudioProcessingSetNoiseProfileFunc', AudioProcessingSetNoiseProfileFunc)
plasm.connect(inc, "out", printer, "in") # # o = open('graph.dot', 'w') # print >>o, plasm.viz() # o.close() # print "\n", plasm.viz(), "\n" sched = Sched(plasm) sched.execute(niter) print("RESULT:", inc.outputs.out) shouldbe = float(n_nodes + niter - 1) print("expected:", shouldbe) assert inc.outputs.out == shouldbe def test_plasm1(self): self.execute_plasm(ecto.Scheduler, 1, 1, 1, 50) def test_plasm2(self): self.execute_plasm(ecto.Scheduler, 1, 5, 5, 50) def test_plasm3(self): self.execute_plasm(ecto.Scheduler, 10, 10, 10, 50) def test_plasm4(self): self.execute_plasm(ecto.Scheduler, 15, 25, 35, 50) if __name__ == '__main__': import rosunit rosunit.unitrun('ecto', 'test_lineplasm', TestActionlib)
go here</author> <license>Public Domain with other stuff</license> <url>http://ros.org/stack/</url> <logo>http://www.willowgarage.com/files/willowgarage/robot10.jpg</logo> <depend stack="stackname" /> <depend stack="common"/> </stack>""" STACK_INVALID1 = """<stack> <description brief="a brief description">Line 1</description> <author>The authors</author> <license>Public Domain</license> <rosdep name="python" /> </stack>""" STACK_INVALID2 = """<stack> <description brief="a brief description">Line 1</description> <author>The authors</author> <license>Public Domain</license> <export> <cpp cflags="-I${prefix}/include" lflags="-L${prefix}/lib -lros"/> <cpp os="osx" cflags="-I${prefix}/include" lflags="-L${prefix}/lib -lrosthread -framework CoreServices"/> </export> </stack>""" if __name__ == '__main__': rosunit.unitrun('test_roslib', 'test_stack_manifest', RoslibStackManifestTest, coverage_packages=['roslib.stack_manifest'])
def test_single_merge(self): msg1 = Request(id=unique_id.toMsg(TEST_UUID), resources=[TEST_WILDCARD], status=Request.NEW) rset = RequestSet([msg1], RQR_UUID) self.assertEqual(rset[TEST_UUID].msg.status, Request.NEW) self.assertEqual(rset[TEST_UUID].msg.resources, [TEST_WILDCARD]) self.assertEqual(rset[TEST_UUID].msg.id, unique_id.toMsg(TEST_UUID)) # merge an updated request set: resource list should change msg2 = Request(id=unique_id.toMsg(TEST_UUID), resources=[TEST_RESOURCE], status=Request.GRANTED) rset.merge(RequestSet([msg2], RQR_UUID, contents=ActiveRequest)) self.assertEqual(len(rset), 1) self.assertIn(TEST_UUID, rset) self.assertEqual(rset[TEST_UUID].msg.status, Request.GRANTED) self.assertEqual(rset[TEST_UUID].msg.resources, [TEST_RESOURCE]) sch_msg = SchedulerRequests(requester=unique_id.toMsg(RQR_UUID), requests=[msg2]) self.assertEqual(rset.to_msg(stamp=rospy.Time()), sch_msg) if __name__ == '__main__': import rosunit rosunit.unitrun('concert_scheduler_requests', 'test_transitions', TestTransitions) rosunit.unitrun('concert_scheduler_requests', 'test_request_sets', TestRequestSets)
self.assertEqual(data["autonomous"], object_.autonomous) def test_object_image_serializer(self): """Tests object image serializer can be deserialized.""" # Create random 40 x 30 RGB image. width = 40 height = 30 nparr = np.random.randint(0, 256, (width, height, 3)).astype(np.uint8) # Convert to ROS Image. bridge = CvBridge() msg = bridge.cv2_to_imgmsg(nparr) # Serialize. png = serializers.ObjectImageSerializer.from_msg(msg) # Deserialize. converted_msg = serializers.ObjectImageSerializer.from_raw(png) # Convert to array. converted_img = bridge.imgmsg_to_cv2(converted_msg) converted_arr = np.asarray(converted_img) # Test if we get the original image. self.assertTrue((converted_arr == nparr).all()) if __name__ == "__main__": rospy.init_node("test_serializers") rosunit.unitrun("test_serializers", "test_serializers", TestSerializers)
service_name, ontologyIsSubSuperClassOfSrv) req = ontologyIsSubSuperClassOfSrvRequest() req.parent_class = 'Aoua' req.child_class = 'Aoua2' req.recursive = True response = test_service(req) self.assertEqual(response.result, False) self.assertEqual(response.success, False) self.assertEqual(response.error, "Class: Aoua does not exist") ## The main function. Initializes the Cognitive Exercise System functional tests if __name__ == '__main__': import rosunit rosunit.unitrun(PKG, 'OntologyFunc', OntologyFunc)
#!/usr/bin/env python import rosunit from .entry_model_test import EntryModelTest from .entry_test import EntryTest from .filter_map_test import FilterMapTest PKG = "march_rqt_note_taker" if __name__ == "__main__": rosunit.unitrun(PKG, "entry_mode_test", EntryModelTest) rosunit.unitrun(PKG, "entry_test", EntryTest) rosunit.unitrun(PKG, "filter_test", FilterMapTest)