def print_results(request, dico_results, holding_cone):
joint_list = qha_tools.use_section(CONFIG_FILE, "Joint")
direction_list = qha_tools.use_section(CONFIG_FILE, "Direction")
def fin():
"""Results printed at the end of test session."""
logging.info("")
logging.info("-" * 40)
logging.info(" TEST REPORT ")
logging.info("-" * 40)
logging.info("")
for joint in joint_list:
for direction in direction_list:
result_list_brut = dico_results[joint][direction]
result_list = [list(x) for x in zip(*result_list_brut)]
angle_list = result_list[0]
temperature_list = result_list[1]
min_value = numpy.amin(numpy.absolute(angle_list))
average_value = numpy.average(angle_list)
std_value = numpy.std(angle_list)
if min_value < abs(float(holding_cone[joint][direction])):
test_result = "FAILED"
else:
test_result = "PASSED"
logging.info("*" * 40)
logging.info("")
logging.info(" ".join(
["Results for",
joint.upper(),
direction.upper()]))
logging.info("Test result : " + test_result)
logging.info("Angles array : " + str(angle_list))
logging.info("Temperature array : " + str(temperature_list))
logging.info("Min value : " + str(min_value))
logging.info("Average : " + str(average_value))
logging.info("Std : " + str(std_value))
logging.info("")
logging.info("-" * 40)
request.addfinalizer(fin)
def joint_to_test():
'''
Docstring
'''
joints = qha_tools.use_section('TestConfig.cfg', 'Joints')
if ('HipPitch' in joints and 'KneePitch' not in joints) or \
('KneePitch' in joints and 'HipPitch' not in joints):
raise Exception(
"Warning", "Le KneePicth et \
HipPitch doivent etre acives ensemble")
return joints
def test_robollomes_with_dances(dcm, mem, session, packagemanager,
albehaviormanager, stop_bootconfig,
motion_wake_up, behavior):
"""
Test rollonomes with dances or behaviors : no fall down.
Launch requested dances (cf associated config file).
Assert True is no fall down detected.
@mem : proxy to ALMemory (object)
@session : Session in qi (object)
@albehaviormanager : proxy to ALBehaviorManager (object)
@motion_wake_up : robot does is wakeUp
@behaviors : dictionnary {"name":value} (dictionnary)
"""
# Subcribe to module
expected = {"ALMotion/RobotIsFalling": 1}
module_name = "EventChecker_{}_".format(uuid.uuid4())
robot_is_falling = EventModule(mem, "ALMotion/RobotIsFalling")
module_id = session.registerService(module_name, robot_is_falling)
robot_is_falling.subscribe(module_name, expected)
list_behaviors = qha_tools.use_section("pod_perf_009.cfg", behavior)
for k in list_behaviors:
packagemanager.install("/home/nao/behaviors_pkg/" + k + ".pkg")
log = log_pod.Log(dcm, mem, robot_is_falling, k + ".csv")
log.start()
run_behavior(albehaviormanager, k, log)
log.stop()
packagemanager.removePkg(k)
session.unregisterService(module_id)
if robot_is_falling.flag:
assert False
import pytest
import subdevice
import qha_tools
@pytest.fixture(scope="session")
def parameters():
"""
Return parameters (config file).
"""
return qha_tools.read_section("env_004.cfg", "TestParameters")
@pytest.fixture(params=qha_tools.use_section("env_004.cfg", "Speed"))
def speed(request):
"""
Speed
"""
return float(request.param)
@pytest.fixture(params=qha_tools.use_section("env_004.cfg", "Directions"))
def direction(request):
"""
Directions
"""
return str(direction)
import pytest
import subdevice
import qha_tools
@pytest.fixture(scope="session")
def parameters():
"""
Return parameters (config file).
"""
return qha_tools.read_section("safety_001.cfg", "TestParameters")
@pytest.fixture(params=qha_tools.use_section("safety_001.cfg", "Speed"))
def speed(request):
"""
Speed
"""
return float(request.param)
@pytest.fixture(params=qha_tools.use_section("safety_001.cfg", "Directions"))
def direction(request):
"""
Directions
"""
return str(request.param)
@pytest.fixture(params=qha_tools.use_section("safety_001.cfg", "Dance"))
def behavior(request):
import pytest
import qha_tools
import subdevice
import easy_plot_connection
@pytest.fixture(params=qha_tools.use_section("temperature_protection.cfg",
"JulietteJoints"))
def joint(request, dcm, mem):
"""
Create the appropriate objects for each joint.
"""
return subdevice.Joint(dcm, mem, request.param)
@pytest.fixture(params=qha_tools.use_section("temperature_protection.cfg",
"JulietteWheels"))
def wheel(request, dcm, mem):
"""
Create the appropriate objects for each wheel.
"""
return subdevice.Wheel(dcm, mem, request.param)
@pytest.fixture(scope="module")
def parameters():
"""It returns the test parameters"""
test_time = int(
qha_tools.read_parameter("temperature_protection.cfg", "Parameters",
"TestTime"))
test_time_limit = int(
@pytest.fixture(scope="session")
def obstacle_distance():
"""
@returns : Distance in meters.
@rtype : float
If the robot detects an obstacle closer than this distance, it does not
rotate around itself.
"""
return (float(
qha_tools.read_parameter(CONFIG_FILE, "GeneralParameters",
"ObstacleDistance")))
@pytest.fixture(params=qha_tools.use_section("stress_test.cfg", "Tests"))
def test_parameters_dico(request, motion, offset_protection):
"""
@returns : Dictionary of motion parameters
@rtype : dictionary
It returns as many dictionaries as arguments in params [len(params)]
"""
dico = qha_tools.read_section(CONFIG_FILE, request.param)
return dico
@pytest.fixture(scope="session")
def battery_charge(dcm, mem):
"""
@returns : BatteryCharge object
import pytest
import qha_tools
@pytest.fixture(scope="session")
def parameters():
"""
Return parameters (config file).
"""
return qha_tools.read_section("perf_003.cfg", "TestParameters")
@pytest.fixture(params=qha_tools.use_section("perf_003.cfg", "BehaviorsName"))
def behavior(request):
"""
Behaviors and dances.
"""
return str(request.param)
import pytest
import qha_tools
import subdevice
from math import radians
CONFIG_FILE_DETECTION = "sensor_detection.cfg"
CONFIG_FILE_FALSE_POSITIVE = "sensor_false_positive.cfg"
# ------------ Sensor detection fixtures ------------
@pytest.fixture(params=qha_tools.use_section(CONFIG_FILE_DETECTION,
"HeadSensors"))
def location(request):
"""Parametrize head capacitive sensor test."""
return request.param
@pytest.fixture(params=qha_tools.use_section(CONFIG_FILE_DETECTION,
"HandSensors"))
def hand_sensor(request):
"""Parametrize hand capacitive sensor test."""
return request.param
@pytest.fixture(scope="module")
def time_to_touch():
"""Defines times user needs to touch capacitive sensor."""
time_touch = \
qha_tools.read_parameter(CONFIG_FILE_DETECTION,
"GeneralParameters",
import pytest
import qha_tools
@pytest.fixture(params=qha_tools.use_section("pod_perf_009.cfg", "Behaviors"))
def behavior(request):
"""
Behaviors and dances.
"""
return str(request.param)
@pytest.fixture(scope="session")
def parameters():
"""
Return parameters (config file).
"""
return qha_tools.read_section("pod_perf_009.cfg", "TestParameters")
@pytest.fixture(scope="session")
def alleds(robot_ip, port):
""" Fixture which returns a proxy to ALLeds module."""
return ALProxy("ALLeds", robot_ip, port)
def unstiff_parts(dcm, mem):
joints = qha_tools.use_section("test_pod.cfg", "Parts")
for name in joints:
joint_hardness = subdevice.JointHardnessActuator(dcm, mem, name)
joint_hardness.qqvalue = 0.
value = property(_get_value)
class MotionSensorValue(object):
def __init__(self, mem, name):
self.mem = mem
self.name = name
def _get_value(self):
""" Get value from ALMemory. """
return float(self.mem.getData("Motion/Velocity/Sensor/" + self.name))
value = property(_get_value)
@pytest.fixture(params=qha_tools.use_section("touch_detection.cfg", "Joints"))
def test_objects_dico(request, dcm, mem):
"""
Create the appropriate objects for each joint.
"""
joint_position_actuator = subdevice.JointPositionActuator(
dcm, mem, request.param)
joint_position_sensor = subdevice.JointPositionSensor(
dcm, mem, request.param)
joint_speed_actuator = MotionActuatorValue(mem, request.param)
joint_speed_sensor = MotionSensorValue(mem, request.param)
joint_temperature = subdevice.JointTemperature(dcm, mem, request.param)
dico_objects = {
"jointName": str(request.param),
"jointPositionActuator": joint_position_actuator,
import pytest
import subdevice
import qha_tools
@pytest.fixture(params=qha_tools.use_section("joint_enslavement.cfg",
"JulietteJoints"))
def test_objects_dico(request, result_base_folder, dcm, mem):
"""
Create the appropriate objects for each joint.
It logs the informations into a dictionnary and save the data into a file
after each joint test.
"""
joint_position_actuator = subdevice.JointPositionActuator(
dcm, mem, request.param)
joint_position_sensor = subdevice.JointPositionSensor(
dcm, mem, request.param)
joint_test_limit = qha_tools.read_parameter("joint_enslavement.cfg",
"JointsLimits", request.param)
logger = qha_tools.Logger()
def fin():
"""Method executed after a joint test."""
result_file_path = "/".join([
result_base_folder, joint_position_actuator.subdevice_type,
"_".join([joint_position_actuator.short_name,
str(logger.flag)])
]) + ".csv"
logger.log_file_write(result_file_path)
request.addfinalizer(fin)
import pytest
import qha_tools
import subdevice
import logging
import math
import numpy
import os.path
import time
CONFIG_FILE = "brakes_tests.cfg"
# parametrable values
@pytest.fixture(params=qha_tools.use_section(CONFIG_FILE, "Joint"))
def hc_joint(request):
"""Returns a parametrized joint."""
return request.param
@pytest.fixture(params=qha_tools.use_section(CONFIG_FILE, "Direction"))
def hc_direction(request):
"""Returns a parametrized direction."""
return request.param
@pytest.fixture(scope="module")
def dico_results(request):
""""""
dico_result = {
"HipPitch": {
"Positive": [],
'''
Created on August 22, 2014
@author: amartin
'''
import pytest
import qha_tools
import ConfigParser
@pytest.fixture(scope="session")
def config_test():
"""
Reading test configuration file
"""
cfg = ConfigParser.ConfigParser()
cfg.read('TestConfig.cfg')
return cfg
@pytest.fixture(params=qha_tools.use_section("TestConfig.cfg", "Horizontal_Side"))
def side(request):
"""
Fixture which returns the side(s) to be tested
"""
return request.param
import pytest
import qha_tools
@pytest.fixture(params=qha_tools.use_section("reliability_002.cfg",
"BehaviorsName"))
def behavior(request):
"""
Behaviors and dances.
"""
return str(request.param)
import pytest
import subdevice
import qha_tools
@pytest.fixture(params=qha_tools.use_section("reliability_001.cfg", "Speed"))
def speed(request):
"""
Speed
"""
return float(request.param)
import pytest
import subdevice
import qha_tools
from naoqi import ALProxy
@pytest.fixture(scope="session")
def parameters():
"""
Return parameters (config file).
"""
return qha_tools.read_section("perf_002.cfg", "TestParameters")
@pytest.fixture(params=qha_tools.use_section("perf_002.cfg", "SpeedRotation"))
def speed_value(request):
"""
Speed
"""
return float(request.param)
@pytest.fixture(scope="session")
def remove_sensors(alnavigation):
"""
Fixture which remove base sensors.
"""
alnavigation._removeSensor("Laser")
alnavigation._removeSensor("Sonar")
alnavigation._removeSensor("Asus")
import pytest
import subdevice
import qha_tools
from naoqi import ALProxy
@pytest.fixture(scope="session")
def parameters():
"""
Return parameters (config file).
"""
return qha_tools.read_section("reliability_003.cfg", "TestParameters")
@pytest.fixture(params=qha_tools.use_section("reliability_003.cfg",
"Directions"))
def direction(request):
"""
Direction
"""
return request.param
import pytest
import qha_tools
import subdevice
import easy_plot_connection
@pytest.fixture(params=qha_tools.use_section("test_current_limitation.cfg", "JulietteJoints"))
def joint(request, dcm, mem):
"""
Create the appropriate objects for each joint.
"""
return subdevice.Joint(dcm, mem, request.param)
@pytest.fixture(scope="module")
def parameters():
"""It returns the test parameters"""
test_time = int(qha_tools.read_parameter(
"test_current_limitation.cfg", "Parameters", "TestTime"))
test_time_limit = int(qha_tools.read_parameter(
"test_current_limitation.cfg", "Parameters", "TestTimeLimit"))
limit_extension = int(qha_tools.read_parameter(
"test_current_limitation.cfg", "Parameters", "LimitExtension"))
limit_factor_sup = float(qha_tools.read_parameter(
"test_current_limitation.cfg", "Parameters", "LimitFactorSup"))
limit_factor_inf = float(qha_tools.read_parameter(
"test_current_limitation.cfg", "Parameters", "LimitFactorInf"))
sa_nb_points = int(qha_tools.read_parameter(
"test_current_limitation.cfg", "Parameters", "SlidingAverageNbPoints"))
# creating parameters dictionnary
value = property(_get_value)
class MotionSensorValue(object):
def __init__(self, mem, name):
self.mem = mem
self.name = name
def _get_value(self):
""" Get value from ALMemory. """
return float(self.mem.getData("Motion/Velocity/Sensor/" + self.name))
value = property(_get_value)
@pytest.fixture(params=qha_tools.use_section("perf_001.cfg", "Joints"))
def test_objects_dico(request, dcm, mem):
"""
Create the appropriate objects for each joint.
"""
joint_position_actuator = subdevice.JointPositionActuator(
dcm, mem, request.param)
joint_position_sensor = subdevice.JointPositionSensor(
dcm, mem, request.param)
joint_speed_actuator = MotionActuatorValue(mem, request.param)
joint_speed_sensor = MotionSensorValue(mem, request.param)
joint_temperature = subdevice.JointTemperature(dcm, mem, request.param)
joint_hardness = subdevice.JointHardnessActuator(dcm, mem, request.param)
dico_objects = {
"jointName": str(request.param),
import pytest
import subdevice
import qha_tools
import easy_plot_connection
@pytest.fixture(params=qha_tools.use_section("multifuse_scenario4.cfg",
"Test"))
def fuse(request, dcm, mem):
fuse_temperature = subdevice.FuseTemperature(dcm, mem, request.param)
fuse_current = subdevice.FuseCurrent(dcm, mem, request.param)
fuse_voltage = subdevice.FuseVoltage(dcm, mem, request.param)
fuse_resistor = subdevice.FuseResistor(dcm, mem, request.param)
dico_to_return = {
"FuseTemperature": fuse_temperature,
"FuseCurrent": fuse_current,
"FuseVoltage": fuse_voltage,
"FuseResistor": fuse_resistor
}
return dico_to_return
@pytest.fixture(scope="module")
def multi_fuseboard_ambiant_tmp(dcm, mem):
"""Object creation of ambiant temperature sensor."""
return subdevice.MultiFuseBoardAmbiantTemperature(dcm, mem)
@pytest.fixture(scope="module")
def multi_fuseboard_total_current(dcm, mem):
"""Object creation of total current sensor."""