def camera_info(draw,
header=header(),
height=uint32(),
width=uint32(),
distortion_model=string(),
D=array(elements=float64()),
K=array(elements=float64(), min_size=9, max_size=9),
R=array(elements=float64(), min_size=9, max_size=9),
P=array(elements=float64(), min_size=12, max_size=12),
binning_x=uint32(),
binning_y=uint32(),
roi=region_of_interest()):
"""
Generate values for ROS1 sensor_msgs/CameraInfo.msg.
"""
header_value = draw(header)
height_value = draw(height)
width_value = draw(width)
distortion_model_value = draw(distortion_model)
d_value = draw(D)
k_value = draw(K)
r_value = draw(R)
p_value = draw(P)
binning_x_value = draw(binning_x)
binning_y_value = draw(binning_y)
roi_value = draw(roi)
return _CameraInfo(header_value, height_value, width_value,
distortion_model_value, d_value, k_value, r_value,
p_value, binning_x_value, binning_y_value, roi_value)
def imu(draw,
header=header(),
orientation=quaternion(),
orientation_covariance=array(elements=float64(),
min_size=9,
max_size=9),
angular_velocity=vector3(),
angular_velocity_covariance=array(elements=float64(),
min_size=9,
max_size=9),
linear_acceleration=vector3(),
linear_acceleration_covariance=array(elements=float64(),
min_size=9,
max_size=9)):
"""
Generate values for ROS1 sensor_msgs/Imu.msg.
Parameters
----------
header : hypothesis_ros.std_msgs.header()
Strategy to generate header value. (Default: Default hypothesis_ros strategy.)
orientation : hypothesis_ros.geometry_msgs.Quaternion()
Strategy to generate orientation value. (Default: Default hypothesis_ros strategy.)
orientation_covariance : hypothesis_ros.message_fields.array()
Strategy to generate orientation_covariance value. (Default: Customized to 9 elements of type float64().)
angular_velocity : hypothesis_ros.messages.geometry_msgs.vector3()
Strategy to generate angular_velocity value. (Default: Default hypothesis_ros strategy.)
angular_velocity_covariance : hypothesis_ros.message_fields.array()
Strategy to generate angular_velocity_covariance value. (Default: Customized to 9 elements of type float64().)
linear_acceleration : hypothesis_ros.messages.geometry_msgs.vector3()
Strategy to generate linear_acceleration value. (Default: Default hypothesis_ros strategy.)
linear_acceleration_covariance : hypothesis_ros.messages.message_fields.array()
Strategy to generate linear_acceleration_covariance value. (Default: Customized to 9 elements of type float64().)
"""
header_value = draw(header)
orientation_value = draw(orientation)
orientation_covariance_value = draw(orientation_covariance)
angular_velocity_value = draw(angular_velocity)
angular_velocity_covariance_value = draw(angular_velocity_covariance)
linear_acceleration_value = draw(linear_acceleration)
linear_acceleration_covariance_value = draw(linear_acceleration_covariance)
# TODO: add validation
return _Imu(header_value, orientation_value, orientation_covariance_value,
angular_velocity_value, angular_velocity_covariance_value,
linear_acceleration_value,
linear_acceleration_covariance_value)
def pose_with_covariance(draw,
pose=pose(),
covariance=array(elements=float64(),
min_size=36,
max_size=36)):
"""
Generate value for ROS geometry message type "PoseWithCovariance".
"""
pose_value, covariance_value = draw(pose), draw(covariance)
# TODO: add validation for covariance_value
return _PoseWithCovariance(pose_value, covariance_value)
def tfmessage(draw, transforms=array(elements=transform_stamped())):
"""
Generate value for ROS1 TFMessage.
Parameters
----------
transforms : hypothesis_ros.message_field.array()
Strategy to generate transforms value. (Default: Default hypothesis_ros strategy
with elements of type hypothesis_ros.message.geometry_msgs.transform_stamped().)
"""
transforms_value = draw(transforms_value)
return _TFMessage(transforms_value)
def image(draw,
header=header(),
height=uint32(),
width=uint32(),
encoding=sampled_from(IMAGE_ENCODINGS),
step=uint32(),
is_bigendian=uint8(),
data=array(elements=uint8(), max_size=10000**10000)):
"""
Generate values for ROS1 sensor_msgs/Image.msg.
Be aware that the element count of the "data" field value is not generated dependent on
steps and rows right now. Configuration of field "data" element size requires attention
to avoid exceptions raised in underlying hypothesis functionality.
Parameters
----------
header : hypothesis_ros.messages.std_msgs.header()
Strategy to generate header values. (Default: Default hypothesis_ros strategy.)
height : hypothesis_ros.message_fields.uint32()
Strategy to generate height value. (Default: Default hypothesis_ros strategy.)
width : hypothesis_ros.message_fields.uint32()
Strategy to generate width value. (Default: Default hypothesis_ros strategy.)
encoding : hypothesis.sampled_from()
Strategy to generate encoding value. For possible values refer to
include/sensor_msgs/image_encodings.h . (Default: hypothesis strategy with reasonable configuration.)
is_bigendian : hypothesis_ros.message_fields.uint8()
Strategy to generate bigendian value. (Default: Default hypothesis_ros strategy.)
data : hypothesis_ros.message_fields.array(elements=uint8())
Strategy to generate matrix data values. Size is steps x rows. (Default: hypothesis_ros strategy with reasonable configuration.)
"""
header_value = draw(header)
height_value = draw(height)
width_value = draw(width)
encoding_value = draw(encoding)
step_value = draw(step)
is_bigendian_value = draw(is_bigendian)
data_value = draw(data)
return _Image(header_value, height_value, width_value, encoding_value,
step_value, is_bigendian_value, data_value)
def compressed_image(draw,
header=header(),
format=sampled_from(['jpg', 'png']),
data=array(elements=uint8())):
"""
Generate values for ROS1 sensor_msgs/CompressedImage.msg.
Parameters
----------
header : hypothesis_ros.std_msgs.header()
Strategy to generate header value. (Default: Default hypothesis_ros strategy.)
format : hypothesis.strategies.sampled_from()
Strategy to generate format value. (Default: Customized hypothesis strategy.)
data : hypothesis_ros.message_fields.array()
Strategy to generate format value. (Default: Customized to elements of type uint8().)
"""
header_value = draw(header)
format_value = draw(format)
data_value = draw(data)
return _CompressedImage(header_value, format_value, data_value)
array,
float64,
uint32,
time,
)
@given(
array(elements=transform_stamped(
header(seq=uint32(min_value=0, max_value=0),
stamp=time(secs=uint32(min_value=1, max_value=1),
nsecs=uint32(min_value=2, max_value=2)),
frame_id=just('some_tf_frame_name')),
just('some_child_frame_id'),
transform(translation=vector3(x=float64(min_value=1.0, max_value=1.0),
y=float64(min_value=2.0, max_value=2.0),
z=float64(min_value=3.0, max_value=3.0)),
rotation=quaternion(x=float64(min_value=1.0, max_value=1.0),
y=float64(min_value=2.0, max_value=2.0),
z=float64(min_value=3.0, max_value=3.0),
w=float64(min_value=4.0,
max_value=4.0)))),
min_size=2,
max_size=2))
def test_tfmessage_accepts_customized_strategies(generated_value):
"""Exemplary customized TFMessage."""
assert generated_value == [
((0, (1, 2), 'some_tf_frame_name'), 'some_child_frame_id',
((1.0, 2.0, 3.0), (1.0, 2.0, 3.0, 4.0))),
((0, (1, 2), 'some_tf_frame_name'), 'some_child_frame_id',
((1.0, 2.0, 3.0), (1.0, 2.0, 3.0, 4.0)))
]
def log(
draw, # DEBUG=uint8(), INFO=uint8(), WARN=uint8(), ERROR=uint8(), FATAL=uint8(),
header=header(),
level=uint8(),
name=string(),
msg=string(),
file=string(),
function=string(),
line=uint32(),
topics=array(elements=string())):
"""
Generate value for ROS1 rosgraph message type "log".
Parameters
----------
header : hypothesis_ros.messages.std_msgs.header()
Strategy to generate header value. (Default: Default hypothesis_ros strategy.)
level : hypothesis_ros.message_fields.uint8()
Strategy to generate level value. (Default: Default hypothesis_ros strategy.)
name : hypothesis_ros.message_fields.string()
Strategy to generate name value. (Default: Default hypothesis_ros strategy.)
msg : hypothesis_ros.message_fields.string()
Strategy to generate msg value. (Default: Default hypothesis_ros strategy.)
file : hypothesis_ros.message_fields.string()
Strategy to generate file value. (Default: Default hypothesis_ros strategy.)
function : hypothesis_ros.message_fields.string()
Strategy to generate function value. (Default: Default hypothesis_ros strategy.)
line : hypothesis_ros.message_fields.string()
Strategy to generate line value. (Default: Default hypothesis_ros strategy.)
topics : hypothesis_ros.message_fields.array()
Strategy to generate topics value. (Default: Default hypothesis_ros strategy.)
"""
header_value = draw(header)
level_value = draw(level)
name_value = draw(name)
msg_value = draw(msg)
file_value = draw(file)
function_value = draw(function)
line_value = draw(line)
topics_value = draw(topics)
assert isinstance(
level_value, int
), 'drew invalid level={level_value} from {level} for int field'.format(
level_value, level)
assert isinstance(
name_value, str
), 'drew invalid name={name_value} from {name} for string field'.format(
name_value, name)
assert isinstance(
msg_value, str
), 'drew invalid msg={msg_value} from {msg} for string field'.format(
msg_value, msg)
assert isinstance(
file_value, str
), 'drew invalid file={file_value} from {file} for string field'.format(
file_value, file)
assert isinstance(
function_value, str
), 'drew invalid function={function_value} from {function} for string field'.format(
function_value, function)
assert isinstance(
line_value, int
), 'drew invalid line={line_value} from {line} for int field'.format(
line_value, line)
assert isinstance(
topics_value, list
), 'drew invalid topics={topics_value} from {msg} for list field'.format(
topics_value, topics)
return _Log(header_value, level_value, name_value, msg_value, file_value,
function_value, line_value, topics_value)
"""Exemplary customized region_of_interest message fields."""
assert generated_values == (1, 2, 3, 4, True)
@given(imu(header(seq=uint32(min_value=0, max_value=0),
stamp=time(secs=uint32(min_value=1, max_value=1),
nsecs=uint32(min_value=2, max_value=2)
),
frame_id=just('some_tf_frame_name')
),
quaternion(x=float64(min_value=1.0, max_value=1.0),
y=float64(min_value=2.0, max_value=2.0),
z=float64(min_value=3.0, max_value=3.0),
w=float64(min_value=4.0, max_value=4.0)
),
array(elements=float64(min_value=1.0, max_value=1.0), min_size=9, max_size=9),
vector3(x=float64(min_value=1.0, max_value=1.0),
y=float64(min_value=2.0, max_value=2.0),
z=float64(min_value=3.0, max_value=3.0)
),
array(elements=float64(min_value=2.0, max_value=2.0), min_size=9, max_size=9),
vector3(x=float64(min_value=1.0, max_value=1.0),
y=float64(min_value=2.0, max_value=2.0),
z=float64(min_value=3.0, max_value=3.0)
),
array(elements=float64(min_value=3.0, max_value=3.0), min_size=9, max_size=9)
)
)
def test_imu_accepts_customized_strategies(generated_values):
"""Exemplary customized imu message fields."""
assert generated_values == ((0, (1, 2), 'some_tf_frame_name'),
@given(
disparity_image(
header(seq=uint32(min_value=0, max_value=0),
stamp=time(secs=uint32(min_value=1, max_value=1),
nsecs=uint32(min_value=2, max_value=2)),
frame_id=just('some_tf_frame_name')),
image(
header(seq=uint32(min_value=0, max_value=0),
stamp=time(secs=uint32(min_value=1, max_value=1),
nsecs=uint32(min_value=2, max_value=2)),
frame_id=just('some_tf_frame_name')),
uint32(min_value=1, max_value=1), uint32(min_value=2, max_value=2),
just('rgb8'), uint32(min_value=3, max_value=3),
uint8(min_value=4, max_value=4),
array(elements=uint8(min_value=0, max_value=0),
min_size=4,
max_size=4)), float32(min_value=1.0, max_value=1.0),
float32(min_value=2.0, max_value=2.0),
region_of_interest(x_offset=uint32(min_value=1, max_value=1),
y_offset=uint32(min_value=2, max_value=2),
height=uint32(min_value=3, max_value=3),
width=uint32(min_value=4, max_value=4),
do_rectify=just(True)),
float32(min_value=3.0, max_value=3.0),
float32(min_value=4.0, max_value=4.0),
float32(min_value=5.0, max_value=5.0)))
def test_disparity_image_accepts_customized_strategies(generated_value):
"""Exemplary customized disparity_image."""
assert generated_value == ((0, (1, 2), 'some_tf_frame_name'),
((0, (1, 2), 'some_tf_frame_name'), 1, 2,
'rgb8', 3, 4, [0, 0, 0, 0]), 1.0, 2.0,
duration(secs=uint32(min_value=1, max_value=1),
nsecs=uint32(min_value=2, max_value=2)))
def test_duration_field_mapping(generated_value):
"""Verify mapping of duration fields."""
assert generated_value.secs == 1
assert generated_value.nsecs == 2
ARRAY_ELEMENT_COUNT = 5
ARRAY_ELEMENT_MIN_VALUE = 1
ARRAY_ELEMENT_MAX_VALUE = 3
@given(
array(elements=int8(min_value=ARRAY_ELEMENT_MIN_VALUE,
max_value=ARRAY_ELEMENT_MAX_VALUE),
min_size=ARRAY_ELEMENT_COUNT,
max_size=ARRAY_ELEMENT_COUNT))
def test_fixed_length_array_element_values_customizable(generated_array):
"""Exemplary customized fixed length array."""
assert len(generated_array) == ARRAY_ELEMENT_COUNT
for element in generated_array:
assert element >= ARRAY_ELEMENT_MIN_VALUE
assert element <= ARRAY_ELEMENT_MAX_VALUE
ARRAY_MIN_LENGHT = 1
ARRAY_MAX_LENGHT = 5
ARRAY_ELEMENT_MIN_VALUE = 1
ARRAY_ELEMENT_MAX_VALUE = 3
def test_pose_accepts_customized_strategies(generated_value):
"""Exemplary customized pose."""
assert generated_value == ((1.0, 2.0, 3.0), (1.0, 2.0, 3.0, 4.0))
@given(pose_with_covariance(pose(position=point(x=float64(min_value=1.0, max_value=1.0),
y=float64(min_value=2.0, max_value=2.0),
z=float64(min_value=3.0, max_value=3.0)
),
orientation=quaternion(x=float64(min_value=1.0, max_value=1.0),
y=float64(min_value=2.0, max_value=2.0),
z=float64(min_value=3.0, max_value=3.0),
w=float64(min_value=4.0, max_value=4.0)
)
),
array(elements=float64(min_value=0.0, max_value=0.0), min_size=36, max_size=36)
)
)
def test_pose_with_covariance_accepts_customized_strategies(generated_value):
"""Exemplary customized pose_with_covariance."""
assert generated_value == (((1.0, 2.0, 3.0),
(1.0, 2.0, 3.0, 4.0)
),
[0.0, 0.0, 0.0, 0.0, 0.0, 0.0,
0.0, 0.0, 0.0, 0.0, 0.0, 0.0,
0.0, 0.0, 0.0, 0.0, 0.0, 0.0,
0.0, 0.0, 0.0, 0.0, 0.0, 0.0,
0.0, 0.0, 0.0, 0.0, 0.0, 0.0,
0.0, 0.0, 0.0, 0.0, 0.0, 0.0
]
)
