def __init__(self, tc_name, global_config):
"""
Constructor
"""
# Call LAB_EM_BASE Init function
EmUsecaseBase.__init__(self, tc_name, global_config)
# Read CHARGER_TYPE from TC parameters
self.__charger_type = \
str(self._tc_parameters.get_param_value("CHARGER_TYPE"))
# Read PLUG_TIMEOUT from TC parameters
self.__action_timeout = \
int(self._tc_parameters.get_param_value("ACTION_TIMEOUT"))
# Read UNPLUG_TIMEOUT from TC parameters
self.__action_order = \
str(self._tc_parameters.get_param_value("ACTION_ORDER")).strip()
self.__action = None
# init ac charger status
self.__is_ac_charger_plugged = False
# init timing offset due to embedded uecmd com
self.__uecmd_com_timing = 16
# declare uc name here to ease inheritance
self._uc_name = "LAB_EM_BATT_PLUG_UNPLUG"
def __init__(self, tc_name, global_config):
"""
Constructor
"""
# Call UseCase base Init function
EmUsecaseBase.__init__(self, tc_name, global_config)
# init fuel gauging parameters
self.em_core_module.init_fg_param()
setup_load = self._tc_parameters.get_param_value("SETUP_TECHNO", "")
self.__cooldown = self._tc_parameters.get_param_value("SETUP_TIME_COOLDOWN_BOARD", 120, default_cast_type=int)
self.__start_temp = self._tc_parameters.get_param_value("SETUP_START_TEMPERATURE", 30, default_cast_type=int)
self.__temp_target = self._tc_parameters.get_param_value("TARGET_MAX_TEMPERATURE", default_cast_type=int)
self.__benchmark_module = BenchmarkModule()
self.__load_module = LoadModule()
self.__load_module.add_load(setup_load)
# measurement file
meas_file_name = os.path.join(self._saving_directory, "EM_meas_report.xml")
self.__em_meas_tab = XMLMeasurementFile(meas_file_name)
meas_file_name = os.path.join(self._saving_directory, "temperature_report.xml")
self.__temp_meas_tab = XMLMeasurementFile(meas_file_name)
meas_file_name = os.path.join(self._saving_directory, "benchmark_score_report.xml")
self.__benchamrk_tab = XMLMeasurementFile(meas_file_name)
self.__temp_camera = self._em.get_thermal_camera("THERMAL_CAMERA")
self.__pic_folder = self._saving_directory
self.__ref_temp = None
self.__host_test_start_time = None
self.__bk_delay = 30
def __init__(self, tc_name, global_config):
# Call LAB_EM_BASE Init function
EmUsecaseBase.__init__(self, tc_name, global_config)
# Get the emergency battery voltage
self._emergency_voltage = float(
self._tc_parameters.get_param_value("EMERGENCY_BATTERY_VOLTAGE",
"2.7"))
# get the normal battery voltage
self._normal_battery_voltage = float(
self._tc_parameters.get_param_value("NORMAL_BATTERY_VOLTAGE", 3.8))
# Redefine initial value for setting USBDIO:
# - BatteryType = ANALOG
self.em_core_module.io_card_init_state[
"BatteryType"] = self.phone_info["BATTERY"]["BATTID_TYPE"]
# - Battery
self.em_core_module.io_card_init_state["Battery"] = True
# - Platform
self.em_core_module.io_card_init_state["Platform"] = "ON"
# - USBChargerType
self.em_core_module.io_card_init_state[
"USBChargerType"] = "USB_HOST_PC"
# - USBCharger
self.em_core_module.io_card_init_state["USBCharger"] = False
# - BatteryTemperature
self.em_core_module.io_card_init_state["BatteryTemperature"] = 25
# Set initial value for setting Power Supply VBATT:
# - VoltageLevel
self.em_core_module.eqp_init_state["BATT"][
"VoltageLevel"] = self._normal_battery_voltage
def __init__(self, tc_name, global_config):
"""
Constructor
"""
# Call UseCase base Init function
EmUsecaseBase.__init__(self, tc_name, global_config)
# save global config into an attribute in
# order to retrieve value in set_up method
self.__global_config = global_config
# Read OFF_TIMEOUT from test case xml file
self._sleep_time = \
int(self._tc_parameters.get_param_value(
"OFF_TIMEOUT"))
# Initialize EM xml object
# measurement file
meas_file_name = os.path.join(self._saving_directory,
"EM_meas_report.xml")
self.__em_meas_tab = EMUtil.XMLMeasurementFile(meas_file_name)
# Call ConfigsParser to parse Energy_Management
self._em_targets = self._target_file.parse_energy_management_targets(
"LAB_EM_BATT_BOOT_COS_MOS",
self._tc_parameters.get_params_as_dict(),
self._device.get_phone_model())
# load targets in order to measure iteration
self._em_meas_verdict.load_target(self._em_targets)
# init variables
self._off_timeout = 300
def __init__(self, tc_name, global_config):
"""
Constructor
"""
# Call LAB_EM_BASE Init function
EmUsecaseBase.__init__(self, tc_name, global_config)
# Read CHARGER from TC parameters
self._charger = str(self._tc_parameters.get_param_value("CHARGER_TYPE"))
# Call ConfigsParser to parse Energy_Management
self._em_targets = self._target_file.parse_energy_management_targets(
"LAB_EM_HW_CHARGING", self._tc_parameters.get_params_as_dict(),
self._device.get_phone_model())
# load targets in order to measure iteration
self._em_meas_verdict.load_target(self._em_targets)
# Redefine initial value for setting IO_CARD:
# - BatteryType = ANALOG
self.em_core_module.io_card_init_state["BatteryType"] = self.phone_info["BATTERY"]["BATTID_TYPE"]
# - Battery
self.em_core_module.io_card_init_state["Battery"] = True
# - Platform
self.em_core_module.io_card_init_state["Platform"] = "OFF"
# - USBChargerType
self.em_core_module.io_card_init_state["USBChargerType"] = self._charger
# - USBCharger
self.em_core_module.io_card_init_state["USBCharger"] = False
# - BatteryTemperature
self.em_core_module.io_card_init_state["BatteryTemperature"] = 25
# Set initial value for setting Power Supply VBATT:
# - VoltageLevel = VBATT
self.em_core_module.eqp_init_state["BATT"]["VoltageLevel"] = self.em_core_module.vbatt
def __init__(self, tc_name, global_config):
"""
Constructor
"""
# Call LAB_EM_BASE Init function
EmUsecaseBase.__init__(self, tc_name, global_config)
# Read parameters from TC parameters
self._execution_time = \
int(self._tc_parameters.get_param_value("EXECUTION_TIME", 300))
self._sleep_residency_passrate = \
int(self._tc_parameters.get_param_value("SLEEP_RESIDENCY_PASSRATE", 60))
self._logger.info("Time of sample rate : %d" % self._execution_time)
self._logger.info("Passrate of sleep residency : %d" %
self._sleep_residency_passrate)
# Call ConfigsParser to parse Energy_Management
self._em_targets = self._target_file.parse_energy_management_targets(
"LAB_EM_BATT_OTG_INSERTION",
self._tc_parameters.get_params_as_dict(),
self._device.get_phone_model())
# load targets in order to measure iteration
self._em_meas_verdict.load_target(self._em_targets)
def __init__(self, tc_name, global_config):
"""
Constructor
"""
# Call the LAB_EM_USE_CASE init method
EmUsecaseBase.__init__(self, tc_name, global_config)
# Read mandatory charger info
tmp_charger_minfo = self._tc_parameters.get_param_value("SYSFS_MANDATORY_INFO")
tmp_charger_minfo = filter(None, tmp_charger_minfo.split(';'))
tmp_charger_minfo = map(str.strip, tmp_charger_minfo)
self.__sysfs_mandatory_charger_info = []
self.__charger_type = self._tc_parameters.get_param_value("CHARGER_TYPE")
self.__action_to_perform = self._tc_parameters.get_param_value("ACTION")
self.__delay = self._tc_parameters.get_param_value("DELAY_BEFORE_CHECKING_INFO", 0, default_cast_type=int)
if self.__action_to_perform == "BOOT_BOARD":
for ele in tmp_charger_minfo:
self.__sysfs_mandatory_charger_info.append(ele + self.__VARIATION_TAG)
else:
self.__sysfs_mandatory_charger_info = tmp_charger_minfo
# get target and initialize measurement
self._em_targets = self._target_file.parse_energy_management_targets(
"LAB_EM_EXPORT_INFO_ABOUT_CHARGER", self._tc_parameters.get_params_as_dict(),
self._device.get_phone_model())
# load targets in order to measure iteration
self._em_meas_verdict.load_target(self._em_targets, self.__sysfs_mandatory_charger_info)
# measurement file
meas_file_name = os.path.join(self._saving_directory, "EM_meas_report.xml")
self.__em_meas_tab = XMLMeasurementFile(meas_file_name)
def __init__(self, tc_name, global_config):
EmUsecaseBase.__init__(self, tc_name, global_config)
# init fuel gauging parameters
self.em_core_module.init_fg_param()
# get the tc parameters
self.__tested_capacity = self._tc_parameters.get_param_value(
"TESTED_CAPACITY", default_cast_type=int)
self.__charger = self._tc_parameters.get_param_value("CHARGER")
self.__load = self._tc_parameters.get_param_value("LOAD")
self.__jump_allowed = self._tc_parameters.get_param_value(
"JUMP_ALLOWED", default_cast_type=float)
self.__time_to_log = self._tc_parameters.get_param_value(
"PLUG_DURATION", default_cast_type=int)
# vars
self.__time_to_charge = 60
self.__time_to_discharge = 60
self.__reports_file_name = os.path.join(self._saving_directory,
"EM_meas_report.xml")
# create a report file
self.__em_meas_tab = XMLMeasurementFile(self.__reports_file_name)
# Activate Loadmodule instance
self.__load_module = LoadModule()
self.__load_module.add_load(self.__load)
def __init__(self, tc_name, global_config):
EmUsecaseBase.__init__(self, tc_name, global_config)
# get parameters
self.__charger_to_use = self._tc_parameters.get_param_value("CHARGER")
self.__load = self._tc_parameters.get_param_value("LOAD")
self.__time_to_charge_full = self._tc_parameters.get_param_value(
"TIME_TO_FULL", default_cast_type=int)
self.__exit_maint_threshold = self._tc_parameters.get_param_value(
"EXIT_MAINTENANCE_CHARGING_THRESHOLD", default_cast_type=float)
self.__time_to_stabilize_board = self._tc_parameters.get_param_value(
"TIME_TO_STABILIZE_BOARD", default_cast_type=int)
self.__test_type = str(
self._tc_parameters.get_param_value("TEST_TYPE")).upper()
self.__test_timeout = self._tc_parameters.get_param_value(
"TEST_TIMEOUT", default_cast_type=int)
# create a report file to save all charge/discharge value for debug
self.__report_file_handler = XMLMeasurementFile(
os.path.join(self._saving_directory, "em_meas_report.xml"))
# instance of load module
self.__load_module = LoadModule()
self.__load_module.add_load(self.__load)
# constant
self.__full_status = "FULL"
self.__charging_status = "CHARGING"
def __init__(self, tc_name, global_config):
"""
Constructor
"""
# Call UseCase base Init function
EmUsecaseBase.__init__(self, tc_name, global_config)
# init fuel gauging parameters
self.em_core_module.init_fg_param()
# Read STAND_DURATION from test case xml file
self._stand_mode = \
self._tc_parameters.get_param_value(
"STAND_MODE")
# Read STANDBY_DURATION from test case xml file
self._stand_duration = \
int(self._tc_parameters.get_param_value(
"STAND_DURATION"))
# Initialize EM xml object
# measurement file
meas_file_name = os.path.join(self._saving_directory,
"EM_meas_report.xml")
self.__em_meas_tab = EMUtil.XMLMeasurementFile(meas_file_name)
self._em_targets = self._target_file.parse_energy_management_targets(
"LAB_EM_BATT_IBATT_STANDBY_MODE",
self._tc_parameters.get_params_as_dict(),
self._device.get_phone_model())
# load targets in order to measure iteration
self._em_meas_verdict.load_target(self._em_targets)
# get network api
self._network_api = self._device.get_uecmd("Networking")
def __init__(self, tc_name, global_config):
"""
Constructor
"""
# Call UseCase base Init function
EmUsecaseBase.__init__(self, tc_name, global_config)
#-----------------------------------------------------------------------
# create a list of file to test
file_to_test_list = self._tc_parameters.get_param_value("FILE")
file_to_test_list = file_to_test_list.split(';')
self.__file_to_test_list = map(str.strip, file_to_test_list)
# get the list of expected result
result_list = self._tc_parameters.get_param_value("EXPECTED_RESULT")
result_list = result_list.split(';')
self.__expected_result_list = map(str.strip, result_list)
self.__action_to_perform = str(
self._tc_parameters.get_param_value("ACTION")).upper()
self.__user_privilege = self._tc_parameters.get_param_value(
"USER_PRIVILEGE")
self.__file_api = self._device.get_uecmd("File")
# all this are related to fuel gauging file
self.__file_secure_copy_list = []
self.__file_original_permission_list = []
self.__dangerous_action_performed = False
# Instantiate the Secondary Report object
self.__secondary_report = SecondaryTestReport(
self._device.get_report_tree().get_report_path())
def __init__(self, tc_name, global_config):
"""
Constructor
"""
# Call LAB_EM_BASE Init function
EmUsecaseBase.__init__(self, tc_name, global_config)
# Read STABILIZATION_TIME from TC parameters
self.__stabilization_time = int(
self._tc_parameters.get_param_value("STABILIZATION_TIME"))
# prepare LOAD
self.__load = self._tc_parameters.get_param_value("LOAD", "NO_LOAD")
self._em_targets = self._target_file.parse_energy_management_targets(
"LAB_EM_TURN_OFF_DISPLAY",
self._tc_parameters.get_params_as_dict(),
self._device.get_phone_model())
# load targets in order to measure iteration
self._em_meas_verdict.load_target(self._em_targets, self.tcd_to_test)
# Measure current from Vbatt
self._pwrs = self._em.get_power_supply("BATT")
self.__load_module = None
self.__screen_timeout = 60 * 60
def __init__(self, tc_name, global_config):
"""
Constructor
"""
# Call LAB_EM_BASE_PS Init function
EmUsecaseBase.__init__(self, tc_name, global_config)
# Read power_button_time_to_on from TC parameters
self._power_button_time_to_on = \
float(self._tc_parameters.get_param_value("PWR_BT_TIME_TO_ON"))
# get targets
self._em_targets = self._target_file.parse_energy_management_targets(
"LAB_EM_PS_BOOT_ON_POWER_BUTTON",
self._tc_parameters.get_params_as_dict(),
self._device.get_phone_model())
# load targets in order to measure iteration
self._em_meas_verdict.load_target(self._em_targets)
# Redefine initial value for setting USBDIO:
self.em_core_module.io_card_init_state[
"BatteryType"] = self.phone_info["BATTERY"]["BATTID_TYPE"]
self.em_core_module.io_card_init_state["Battery"] = True
self.em_core_module.io_card_init_state["Platform"] = "OFF"
self.em_core_module.io_card_init_state[
"USBChargerType"] = self._io_card.USB_HOST_PC
self.em_core_module.io_card_init_state["USBCharger"] = False
self.em_core_module.io_card_init_state["BatteryTemperature"] = 25
# Set initial value for setting Power Supply VBATT:
# - VoltageLevel = VBATT
self.em_core_module.eqp_init_state["BATT"][
"VoltageLevel"] = self.em_core_module.vbatt
def __init__(self, tc_name, global_config):
"""
Constructor
"""
# Call LAB_EM_BASE Init function
EmUsecaseBase.__init__(self, tc_name, global_config)
# Read parameters from TC parameters
self._usb_compliancy = \
self._tc_parameters.get_param_value("USB_COMPLIANCY", "FALSE")
self._schedule_time = \
int(self._tc_parameters.get_param_value("SCHEDULE_TIME", 30))
self._sample_rate = \
int(self._tc_parameters.get_param_value("SAMPLE_RATE", 10))
self._logger.info("Activation of USB COMPLIANCY : %s" % self._usb_compliancy)
self._logger.info("Time of scheduling : %d" % self._schedule_time)
self._logger.info("Time of sample rate : %d" % self._sample_rate)
# Call ConfigsParser to parse Energy_Management
self._em_targets = self._target_file.parse_energy_management_targets(
"LAB_EM_BATT_DATA_COM_ERROR", self._tc_parameters.get_params_as_dict(),
self._device.get_phone_model())
# load targets in order to measure iteration
self._em_meas_verdict.load_target(self._em_targets)
def __init__(self, tc_name, global_config):
"""
Constructor
"""
# Call LAB_EM_BASE Init function
EmUsecaseBase.__init__(self, tc_name, global_config)
# Read BATTERY_TEMPERATURE from TC parameters
self._vcritical = float(
self._tc_parameters.get_param_value("VBATT_CRITICAL"))
# Call ConfigsParser to parse Energy_Management
self._em_targets = self._target_file.parse_energy_management_targets(
"LAB_EM_BOOT_PRESS_ON", self._tc_parameters.get_params_as_dict(),
self._device.get_phone_model())
# load targets in order to measure iteration
self._em_meas_verdict.load_target(self._em_targets)
# Redefine initial value for setting USBDIO:
# - Battery = True (inserted)
self.em_core_module.io_card_init_state["Battery"] = True
# - Platform = True (ON)
self.em_core_module.io_card_init_state["Platform"] = "ON"
# Set initial value for setting Power Supply VBATT:
# - VoltageLevel = VBATT
self.em_core_module.eqp_init_state["BATT"][
"VoltageLevel"] = self.em_core_module.vbatt
# Retrieve the power supply equipment
self.em_core_module.pwrs_vbatt = self._em.get_power_supply("BATT")
def __init__(self, tc_name, global_config):
"""
Constructor
"""
# Call LAB_EM_BASE Init function
EmUsecaseBase.__init__(self, tc_name, global_config)
self.__charger_type = self._tc_parameters.get_param_value(
"CHARGER_TYPE", "DCP")
self.__start_battery_voltage = float(
self._tc_parameters.get_param_value("START_BATTERY_VOLTAGE", 2.6))
self.__end_battery_voltage = float(
self._tc_parameters.get_param_value("END_BATTERY_VOLTAGE", 2.3))
self.__battery_step = float(
self._tc_parameters.get_param_value("BATTERY_STEP", 0.025))
self.__expected_charge_current = float(
self._tc_parameters.get_param_value("EXPECTED_CHARGE_CURRENT",
0.40))
self.__wait_time = int(
self._tc_parameters.get_param_value("WAIT_TIME", 120))
# Redefine initial value for setting USBDIO:
# - Platform
self.em_core_module.io_card_init_state["Platform"] = "OFF"
def __init__(self, tc_name, global_config):
"""
Constructor
"""
# Call LAB_EM_BASE Init function
EmUsecaseBase.__init__(self, tc_name, global_config)
# Read parameters from TC parameters
self._wait_end_freeze_timeout = \
int(self._tc_parameters.get_param_value("WAIT_END_FREEZE_TIMEOUT", 900))
self._start_os = \
self._tc_parameters.get_param_value("START_OS", "MOS")
self._crash_type = \
self._tc_parameters.get_param_value("CRASH_TYPE", "SECURITY")
self._logger.info("Value of timeout : %d" %
self._wait_end_freeze_timeout)
self._logger.info("Start OS is : %s" % self._start_os)
self._logger.info("Crash type is : %s" % self._crash_type)
# Call ConfigsParser to parse Energy_Management
self._em_targets = self._target_file.parse_energy_management_targets(
"LIVE_PUPDR_FALLBACK_POLICY",
self._tc_parameters.get_params_as_dict(),
self._device.get_phone_model())
# load targets in order to measure iteration
self._em_meas_verdict.load_target(self._em_targets)
def __init__(self, tc_name, global_config):
"""
Constructor
"""
# Call LAB_EM_BASE Init function
EmUsecaseBase.__init__(self, tc_name, global_config)
# Initialize variables
self.__transition_combo = None
# Read parameters from TC parameters
self.__transition_timeout = \
self._tc_parameters.get_param_value("TRANSITION_TIMEOUT")
if self.__transition_timeout not in [None, ""]:
# convert to int if not None else leave it to None
self.__transition_timeout = int(self.__transition_timeout)
else:
self.__transition_timeout = self._device.get_boot_timeout()
self.__transition_combo_raw = \
str(self._tc_parameters.get_param_value("TRANSITION_COMBO"))
# Call ConfigsParser to parse Energy_Management
self._em_targets = self._target_file.parse_energy_management_targets(
"LAB_PUPDR_BOOT_TRANSITION", self._tc_parameters.get_params_as_dict(),
self._device.get_phone_model())
# load targets in order to measure iteration
self._em_meas_verdict.load_target(self._em_targets)
def __init__(self, tc_name, global_config):
"""
Constructor
"""
# Call LAB_EM_BASE Init function
EmUsecaseBase.__init__(self, tc_name, global_config)
# init fuel gauging parameters
self.em_core_module.init_fg_param()
self.__raw_behavior = str(
self._tc_parameters.get_param_value("CYCLE_BEHAVIOR")).upper()
load = self._tc_parameters.get_param_value("LOAD")
self.__charger_type = self._tc_parameters.get_param_value(
"CHARGER_TYPE")
# Load Module Initialization
self.__load_module = LoadModule()
self.__load_module.add_load(load)
# Initialize EM xml object
# measurement file
meas_file_name = os.path.join(self._saving_directory,
"EM_meas_report.xml")
self.__em_meas_tab = XMLMeasurementFile(meas_file_name)
# track the case where DUT is lost to gather em info later
self.__fail_to_get_em_info = False
def __init__(self, tc_name, global_config):
"""
Constructor
"""
# Call UseCase base Init function
EmUsecaseBase.__init__(self, tc_name, global_config)
# init fuel gauging parameters
self.em_core_module.init_fg_param()
# Read the battery capacity expected for the init of the test
self.__high_load_timeout = self._tc_parameters.get_param_value("HIGH_LOAD_DISCHARGE_TIME", default_cast_type=int)
self.__light_load_timeout = self._tc_parameters.get_param_value("LIGHT_LOAD_DISCHARGE_TIME", default_cast_type=int)
self.__light_load = self._tc_parameters.get_param_value("LIGHT_LOAD", "")
self.__high_load = self._tc_parameters.get_param_value("HIGH_LOAD")
self.__load_module = LoadModule()
self.__load_module.add_load(self.__light_load)
self.__load_module.add_load(self.__high_load)
#-----------------------------------------------------------------------
# Call ConfigsParser to parse Energy_Management
self._em_targets = self._target_file.parse_energy_management_targets(
"LAB_EM_BATT_CRIT_THRESHOLD_ADAPTED", self._tc_parameters.get_params_as_dict(),
self._device.get_phone_model())
# load targets in order to measure iteration
self._em_meas_verdict.load_target(self._em_targets)
# Initialize EM xml object
# measurement file
meas_file_name = os.path.join(self._saving_directory, "EM_meas_report.xml")
self.__em_meas_tab = XMLMeasurementFile(meas_file_name)
def __init__(self, tc_name, global_config):
"""
Constructor
"""
# Call UseCase base Init function
EmUsecaseBase.__init__(self, tc_name, global_config)
# init fuel gauging parameters
self.em_core_module.init_fg_param()
setup_load = self._tc_parameters.get_param_value("SETUP_TECHNO", "")
self.__record_duration = self._tc_parameters.get_param_value("VIDEO_RECORD_DURATION", 120, default_cast_type=int)
self.__cooldown = self._tc_parameters.get_param_value("SETUP_TIME_COOLDOWN_BOARD", 120, default_cast_type=int)
self.__start_temp = self._tc_parameters.get_param_value("SETUP_START_TEMPERATURE", 30, default_cast_type=int)
self.__host_media = self._tc_parameters.get_param_value("MEDIA_TO_RECORD", "", default_cast_type=str)
self.__host_monitor = self._tc_parameters.get_param_value("MONITOR_ON_WHICH_MEDIA_IS_PLAY", -1, default_cast_type=int)
self.__temp_target = self._tc_parameters.get_param_value("TARGET_MAX_TEMPERATURE", default_cast_type=int)
# load targets in order to measure iteration
self.__video_capture_mod = VideoCaptureModule()
self.__load_module = LoadModule()
self.__load_module.add_load(setup_load)
self.__video_record_api = self._device.get_uecmd("VideoRecorder", True)
self.__media_player = None
if self.__host_media != "":
self.__media_player = MediaPlayer()
# measurement file
meas_file_name = os.path.join(self._saving_directory, "EM_meas_report.xml")
self.__em_meas_tab = XMLMeasurementFile(meas_file_name)
meas_file_name = os.path.join(self._saving_directory, "temperature_report.xml")
self.__temp_meas_tab = XMLMeasurementFile(meas_file_name)
self.__temp_camera = self._em.get_thermal_camera("THERMAL_CAMERA")
self.__pic_folder = self._saving_directory
self.__ref_temp = None
def __init__(self, tc_name, global_config):
"""
Constructor
"""
# Call Init function
EmUsecaseBase.__init__(self, tc_name, global_config)
# Read parameters from tc
self.__vbatt_lo = self._tc_parameters.get_param_value("VBATT_LOW", default_cast_type=float)
self.__vbatt_hi = self._tc_parameters.get_param_value("VBATT_HIGH" , default_cast_type=float)
self.__charger_to_plug = self._tc_parameters.get_param_value("CHARGE_TYPE_DURING_TEST")
self.__max_time_high = self._tc_parameters.get_param_value("MAX_TIME_TO_SEE_CHANGE_FOR_VBATT_HIGH", default_cast_type=int)
self.__max_time_low = self._tc_parameters.get_param_value("MAX_TIME_TO_SEE_CHANGE_FOR_VBATT_LOW", default_cast_type=int)
self.__set_board_in_idle = self._tc_parameters.get_param_value("IDLE_STATE", default_cast_type=str_to_bool)
self.__idle_time = self._tc_parameters.get_param_value("TIME_TO_WAIT_AFTER_IDLE_STATE", default_value=0, default_cast_type=int)
# load targets in order to compute verdict
self._em_targets = self._target_file.parse_energy_management_targets(
"LAB_EM_BATT_OVER_VOLTAGE", self._tc_parameters.get_params_as_dict(), self._device.get_phone_model())
self._em_meas_verdict.load_target(self._em_targets, self.tcd_to_test)
# Set initial value for setting Power Supply VBATT:
# - VoltageLevel
self.em_core_module.eqp_init_state["BATT"]["VoltageLevel"] = self.__vbatt_lo
# measurement file
meas_file_name = os.path.join(self._saving_directory, "EM_meas_report.xml")
self.__em_meas_tab = XMLMeasurementFile(meas_file_name)
def __init__(self, tc_name, global_config):
"""
Constructor
"""
# Call the LAB_EM_USE_CASE init method
EmUsecaseBase.__init__(self, tc_name, global_config)
# Read CHARGER_TYPE from TC parameters
self.__charger_type = self._tc_parameters.get_param_value(
"CHARGER_TYPE", "SDP")
# Read load to activate
self.__load = self._tc_parameters.get_param_value("LOAD")
# Activate Loadmodule instance
self.__load_module = LoadModule()
# Add list of LOAD to the loadmodule
self.__load_module.add_load(self.__load)
# get target and initialise measurment
self._em_targets = self._target_file.parse_energy_management_targets(
"LAB_EM_UPPER_CURRENT_DRAWN_THAN_CHG_CURRENT",
self._tc_parameters.get_params_as_dict(),
self._device.get_phone_model())
# load targets in order to measure iteration
self._em_meas_verdict.load_target(self._em_targets, self.tcd_to_test)
self.__scheduled_timer = 60
def __init__(self, tc_name, global_config):
"""
Constructor
"""
# Call LAB_EM_BASE Init function
EmUsecaseBase.__init__(self, tc_name, global_config)
# Read CHARGER_TYPE from TC parameters
self._charger_type = self._tc_parameters.get_param_value(
"CHARGER_TYPE")
# Read START_OS from TC parameters
self._start_os = self._tc_parameters.get_param_value("START_OS", "MOS")
# Call ConfigsParser to parse Energy_Management
self._em_targets = self._target_file.parse_energy_management_targets(
"LAB_EM_REMOVE_CHARGER", self._tc_parameters.get_params_as_dict(),
self._device.get_phone_model())
# load targets in order to measure iteration
self._em_meas_verdict.load_target(self._em_targets, self.tcd_to_test)
# - Delay to wait for scheduled commands
self._scheduled_timer_1 = int(
self._tc_parameters.get_param_value("DELAY_TO_MEASURE_BEFORE_PLUG",
60))
self._scheduled_timer_2 = int(
self._tc_parameters.get_param_value("DELAY_TO_MEASURE_AFTER_PLUG",
90))
def __init__(self, tc_name, global_config):
EmUsecaseBase.__init__(self, tc_name, global_config)
# get base module
self.em_core_module = UcBatteryModule(self)
# get the tc parameters
self.__tested_capacity = self._tc_parameters.get_param_value(
"TESTED_CAPACITY", default_cast_type=int)
self.__charger = self._tc_parameters.get_param_value("CHARGER")
self.__status = self._tc_parameters.get_param_value("STATUS").upper()
self.__load = self._tc_parameters.get_param_value("LOAD")
# vars
self.__time_to_charge = 60
self.__time_to_discharge = 60
self.__reports_file_name = os.path.join(self._saving_directory,
"EM_meas_report.xml")
self.__time_to_log = 60
# create a report file
self.__report_file_handler = XMLMeasurementFile(
self.__reports_file_name)
# Activate Loadmodule instance
self.__load_module = LoadModule()
self.__load_module.add_load(self.__load)
# delay to launch autologger
self.__autolog_delay = 20
def __init__(self, tc_name, global_config):
"""
Constructor
"""
# Call LAB_EM_BASE Init function
EmUsecaseBase.__init__(self, tc_name, global_config)
self.__charger_type = self._tc_parameters.get_param_value(
"CHARGER_TYPE")
self.__cos_shutdown_timeout_value = int(
self._tc_parameters.get_param_value("COS_SHUTDOWN_TIMEOUT_VALUE",
120))
self.__mos_boot_timeout = int(
self._tc_parameters.get_param_value("MOS_BOOT_TIMEOUT", 60))
self.__cos_boot_timeout = int(
self._tc_parameters.get_param_value("COS_BOOT_TIMEOUT", 120))
self.__screen_off_wait = int(
self._tc_parameters.get_param_value("SCREEN_OFF_WAIT", 300))
self.__cos_battery_voltage = float(
self._tc_parameters.get_param_value("COS_BATTERY_VOLTAGE"))
self.__current_range_value = float(
self._tc_parameters.get_param_value("CURRENT_RANGE_VALUE", 0.002))
# Redefine initial value for setting USBDIO:
# - Platform
self.em_core_module.io_card_init_state["Platform"] = "OFF"
# Set initial value for setting Power Supply VBATT:
# - VoltageLevel = VBATT
self.em_core_module.eqp_init_state["BATT"][
"VoltageLevel"] = self.__cos_battery_voltage
def __init__(self, tc_name, global_config):
"""
Constructor
"""
# Call LAB_EM_BASE Init function
EmUsecaseBase.__init__(self, tc_name, global_config)
# Read USB_CHARGER_TYPE from TC parameters
self._charger_type = \
str(self._tc_parameters.get_param_value("CHARGER_TYPE"))
# Redefine initial value for setting USBDIO:
# - BatteryType
self.em_core_module.io_card_init_state[
"BatteryType"] = self.phone_info["BATTERY"]["BATTID_TYPE"]
# - Battery
self.em_core_module.io_card_init_state["Battery"] = True
# - Platform
self.em_core_module.io_card_init_state["Platform"] = "OFF"
# - USBCharger
self.em_core_module.io_card_init_state["USBCharger"] = False
# Set initial value for setting Power Supply VBATT:
# - VoltageLevel = VBATT
self.em_core_module.eqp_init_state["BATT"][
"VoltageLevel"] = self.em_core_module.vbatt
self.em_core_module.pwrs_vbatt = self._em.get_power_supply("BATT")
def __init__(self, tc_name, global_config):
"""
Constructor
"""
# Call the LAB_EM_USE_CASE init method
EmUsecaseBase.__init__(self, tc_name, global_config)
# Read mandatory battery info
tmp_batt_minfo = self._tc_parameters.get_param_value(
"SYSFS_MANDATORY_INFO")
self.__sysfs_mandatory_batt_info = tmp_batt_minfo.split(';')
# Read optional battery info
self.__number_of_pass = self._tc_parameters.get_param_value(
"NUMBER_PASS", default_cast_type=int)
self.em_core_module.io_card_init_state[
"BatteryType"] = self.phone_info["BATTERY"]["BATTID_TYPE"]
# - Battery
self.em_core_module.io_card_init_state["Battery"] = True
# - Platform
self.em_core_module.io_card_init_state["Platform"] = "ON"
self.em_core_module.io_card_init_state[
"USBChargerType"] = self._io_card.USB_HOST_PC
self.em_core_module.io_card_init_state["USBCharger"] = True
# get target and initialize measurement
self._em_targets = self._target_file.parse_energy_management_targets(
"LAB_EM_EXPORT_BAT_INFO_ROB",
self._tc_parameters.get_params_as_dict(),
self._device.get_phone_model())
# load targets in order to measure iteration
self._em_meas_verdict.load_target(self._em_targets)
def __init__(self, tc_name, global_config):
"""
Constructor
"""
# Call LAB_EM_BASE Init function
EmUsecaseBase.__init__(self, tc_name, global_config)
# init fuel gauging parameters
self.em_core_module.init_fg_param()
# misc parameter
self.__battery_critical_threshold = self._tc_parameters.get_param_value(
"BATTERY_CRITICAL_THRESHOLD", default_cast_type=int)
load_to_apply_in_setup = self._tc_parameters.get_param_value(
"LOAD_DURING_DISCHARGE", "")
# call parameter
self.__call_timeout = self._tc_parameters.get_param_value(
"CALL_HOLD_TIME", default_cast_type=int)
self.__hands_free_activation = self._tc_parameters.get_param_value(
"HANDS_FREE_ACTIVATION", default_cast_type="str_to_bool")
self.__fake_emergency_phone_number = self._tc_parameters.get_param_value(
"PHONE_NUMBER", "012345")
call_type = self._tc_parameters.get_param_value("CALL_TYPE")
# Summarize the parameters
self._logger.info("[TESTCASE]\tBattery Critical Threshold: %s%%" %
self.__battery_critical_threshold)
self._logger.info("[TESTCASE]\tEmergency Phone Number : %s" %
self.__fake_emergency_phone_number)
self._logger.info(
"[TESTCASE]\tthe holding time of the call when battery reach critical level: %ss"
% self.__call_timeout)
self._logger.info("[TESTCASE]\tType of the call : %s" % call_type)
self._logger.info("[TESTCASE]\tActivation of Hands Free : %s" %
self.__hands_free_activation)
# Initial Emergency Number
if call_type == "3G":
# Initialization of module 3g
self.__telmodule = TelephonyModule3g()
elif call_type == "2G":
# Initialization of module 3g
self.__telmodule = TelephonyModule2g()
else:
txt = "Type of the call is not correct => Quit the test"
self._logger.error(txt)
raise AcsConfigException(AcsConfigException.INVALID_PARAMETER, txt)
# measurement file
meas_file_name = os.path.join(self._saving_directory,
"EM_meas_report.xml")
self.__em_meas_tab = XMLMeasurementFile(meas_file_name)
# Store the initial list of emergency number from UECmdTypes
self.__initial_ue_command_em_number = UECmdTypes.EMERGENCY_NUMBERS_LIST
# init load module used to discharge board
self.__load_module = LoadModule()
self.__load_module.add_load(load_to_apply_in_setup)
self.__initial_emergency_numbers = None
self.__original_airplane_state = None
def __init__(self, tc_name, global_config):
"""
Constructor
"""
# Call the LabEmBaseCommon Init function
EmUsecaseBase.__init__(self, tc_name, global_config) # pylint: disable=W0233
load_off = self._tc_parameters.get_param_value("LOAD_OFF", "")
self.__load_module = LoadModule()
self.__load_module.add_load(load_off)
