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 set_up(self):
"""
Initialize the test
"""
# Call the UseCaseBase Setup function
EmUsecaseBase.set_up(self)
# Check expected result first
if self.__what_to_check not in self.__ACTION:
txt = "wrong value for TC parameter WHAT_TO_CHECK %s, can only be %s" % (
self.__what_to_check, str(self.__ACTION))
self._logger.error(txt)
raise AcsConfigException(AcsConfigException.INVALID_PARAMETER, txt)
# Update Battery Information
em_info = self.update_battery_info()
if self.em_core_module.is_batt_capacity_above_target(
em_info, self.em_core_module.batt_start_capacity):
# Discharge part
self.em_core_module.monitor_discharging(
self.em_core_module.batt_start_capacity,
self.em_core_module.discharge_time, self.__em_meas_tab,
self.__load_module)
elif self.em_core_module.is_batt_capacity_below_target(
em_info, self.em_core_module.batt_start_capacity):
# Charge part
self.em_core_module.monitor_charging(
self.em_core_module.batt_start_capacity,
self.em_core_module.charge_time, self.__em_meas_tab)
return Global.SUCCESS, "No errors"
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 tear_down(self):
"""
End and dispose the test
"""
# call tear down after some operations
EmUsecaseBase.tear_down(self)
# retrieve measurement from test
self.__em_meas_tab.generate_global_file()
# set CMU cell phone OFF
self._data_2g.set_data_cell_off()
# Disconnect from the equipment (Network simulator)
self._ns.release()
if self.is_board_and_acs_ok():
self.em_api.set_usb_charging("on")
# call tear down after some operations
self.em_core_module.clean_up()
if self.is_board_and_acs_ok():
self.phonesystem_api.set_screen_timeout(30)
self.phonesystem_api.clean_daemon_files()
return Global.SUCCESS, "No errors"
def tear_down(self):
"""
End and dispose the test
"""
EmUsecaseBase.tear_down(self)
if self.__temp_camera is not None:
try:
self.__temp_camera.delete_all_pictures()
self.__temp_camera.set_linear_temperature_mode(False)
except Exception as e:
self._logger.error(
"error happen when releasing thermal camera %s" % str(e))
finally:
self.__temp_camera.release()
if not self.__media_player is None:
self.__media_player.stop()
# stop all load
self.em_core_module.clean_up()
self.__load_module.stop_load()
# stop any remaining video capture
self.__video_record_api.force_stop()
self.__video_record_api.restore_camera_setup()
self.__video_record_api.clean_video_storage()
return Global.SUCCESS, "No errors"
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 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 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 run_test_body(self):
"""
Execute the test
"""
# Call LAB_EM_BASE Run function
EmUsecaseBase.run_test_body(self)
# Run the sub test about power on with power button
status = self._boot_on_power_button()
if status != Global.SUCCESS:
self._logger.error(
"Phone has can't start on power button press. " +
"Test STOPS!")
# Save data report in xml file
self._error.Code = self._em_meas_verdict.get_global_result()
self._error.Msg = self._em_meas_verdict.save_data_report_file()
return self._error.Code, self._error.Msg
# Run the sub test about User Alarm
self._no_boot_on_alarm()
# Run the sub test about Not booting under critical Voltage
self._no_boot_under_critical_voltage()
# generate em verdict
self._em_meas_verdict.compare_list(self._meas_list, self._em_targets)
self._meas_list.clean()
self._error.Code = self._em_meas_verdict.get_current_result()
self._error.Msg = self._em_meas_verdict.save_data_report_file()
return self._error.Code, self._error.Msg
def run_test_body(self):
EmUsecaseBase.run_test_body(self)
# charge board
self.__charge_phase_mos()
# setting for discharge loop
# set CMU cell phone ON
self.__data_2g.set_data_cell_on()
# register phone
self.__data_2g.data_register_dut(None,
self._registration_timeout)
# Check registration status on DUT
self.modem_api.check_cdk_registration_bfor_timeout(
self._registration_timeout)
# establish call
if self.__call_origin == "SIMULATOR":
self.__data_2g.data_call(self.__data_call_mode)
self.__data_2g.check_data_call_connected(60)
elif self.__call_origin == "PHONE":
self.voicecall_api.dial("OOOO12121121")
# discharge the board
self.__discharge_phase()
return(self._em_meas_verdict.get_global_result(),
self._em_meas_verdict.generate_msg_verdict())
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 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 tear_down(self):
"""
End and dispose the test
"""
# call tear down after some operations
EmUsecaseBase.tear_down(self)
# get just the aplogs
if self._device.get_state() == "alive":
# restart acs connection to have clean rooted device
self._device.disconnect_board()
self._device.connect_board()
self.get_application_logs()
if len(self.__file_secure_copy_list) > 0:
self._logger.info("Restoring and deleting generated file")
# parse all secure copy
for index in range(len(self.__file_secure_copy_list)):
secure_copy_file = self.__file_secure_copy_list[index]
# if a copy exist, compare it if original
if self.__file_api.exist(secure_copy_file)[0]:
original_file = self.__file_to_test_list[index]
self.__file_api.remount()
if (not self.__file_api.exist(original_file)[0]
or not self.__file_api.is_equal(
original_file, secure_copy_file)
) and self.__dangerous_action_performed:
self._logger.info("restoring file")
self.__restore_file(index)
# delete it the end
self.__file_api.delete(secure_copy_file)
self.__dangerous_action_performed = False
return Global.SUCCESS, "No errors"
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 run_test_body(self):
"""
Execute the test
"""
# Call LAB_EM_BASE Init function
EmUsecaseBase.run_test_body(self)
# do the test for the loop
for i in range(self._loop_number):
self._logger.info("-*-*Test Iteration %s*-*-" % str(i + 1))
# compute the time to wait after we start to boot
timing_after_turn_on = self._first_turn_off_timing + i * self._turn_off_step
# begin to boot the board and return after pressing the power button
self._begin_boot_board(self._pwr_button_press_time)
# wait the good time
self._logger.info("***Wait %s second before initiating a shutdown***"
% str(timing_after_turn_on))
time.sleep(timing_after_turn_on)
# Turn off the board
self._turn_off_board(self._turn_off_way)
# check the board status
self._check_board(self._pwr_button_press_time)
# add measure to the verdict
self._em_meas_verdict.compare_list(self._meas_list, self._em_targets, True)
self._em_meas_verdict.judge(ignore_blocked_tc=True)
# Save data report in xml file
self._error.Code = self._em_meas_verdict.get_current_result()
self._error.Msg += self._em_meas_verdict.save_data_report_file()
return self._error.Code, self._error.Msg
def run_test_body(self):
"""
Execute the test
Check the end of the main battery charge
"""
# Call LAB_EM_BASE Run function
EmUsecaseBase.run_test_body(self)
# Check the battery capacity to 0%
self._logger.info(
"BEGIN OF THE TEST : Battery capacity is equal to %d%%" %
self.batt_capacity)
# if registration has been lost, register again
if self.modem_api.get_network_registration_status() not in [
"registered", "roaming"
]:
self.__telmodule.register_to_network()
# if fake number has been lost restore it here
if self.__fake_emergency_phone_number not in self.modem_api.get_emergency_numbers(
):
self.modem_api.set_emergency_numbers(
[self.__fake_emergency_phone_number], False)
# First Part, Check emergency call alone
# establish voice call
self._logger.info("Board is in MOS, Initiate the call !")
self.voicecall_api.emergency_dial(self.__fake_emergency_phone_number)
# Add the hands free
if self.__hands_free_activation:
self._logger.info("Activate the Speaker !")
self.phonesystem_api.switch_audio_output("speaker")
# Discharge the board
return self.__discharge_when_data(0)
def set_up(self):
"""
Initialize the test:
"""
EmUsecaseBase.set_up(self)
# Call ConfigsParser to parse Energy_Management
self._em_targets = self._target_file.parse_energy_management_targets(
"LAB_EM_PS_TURN_OFF_DURING_BOOT", 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)
# check parameter turn off way
if self._turn_off_way not in ["HARDWARE_SHUTDOWN",
"EMERGENCY_SHUTDOWN", "BATTERY_REMOVAL"]:
raise AcsConfigException(AcsConfigException.INVALID_PARAMETER,
"The parameter TURN_OFF_WAY '%s' is not a valid way to turn off the board"
% self._turn_off_way)
# check parameter first turn off timing
if self._first_turn_off_timing > 45:
raise AcsConfigException(AcsConfigException.INVALID_PARAMETER,
"The parameter FIRST_TURN_OFF_TIMING '%s'" % self._first_turn_off_timing
+ " shall be under 45s or the test will be done after booting")
return Global.SUCCESS, "No errors"
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)
# 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):
"""
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 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 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 tear_down(self):
"""
End and dispose the test
"""
EmUsecaseBase.tear_down(self)
benchmark_stopped = False
# stop benchmark here to prevent it from running in loop while charging below
if self.is_board_and_acs_ok():
try:
self.__benchmark_module.clean()
benchmark_stopped = True
except Exception as e:
self._logger.error("error happen when stopping benchmark %s" %
str(e))
# stop camera anyway
if self.__temp_camera is not None:
try:
self.__temp_camera.delete_all_pictures()
self.__temp_camera.set_linear_temperature_mode(False)
except Exception as e:
self._logger.error(
"error happen when releasing thermal camera %s" % str(e))
finally:
self.__temp_camera.release()
# stop all load
self.em_core_module.clean_up()
self.__load_module.stop_load()
if not benchmark_stopped:
self.__benchmark_module.clean()
# stop benchmark
return Global.SUCCESS, "No errors"
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)
# 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 set_up(self):
EmUsecaseBase.set_up(self)
# get the tested capacity
batt_info = self.update_battery_info()
# initial state is dut charge at max_range
if self.em_core_module.is_batt_capacity_below_target(
batt_info, self.__tested_capacity):
self._logger.info("Device capacity is %s : going to %s" %
(self.batt_capacity, self.__tested_capacity))
self.em_core_module.monitor_charging(self.__tested_capacity,
self.__time_to_charge,
self.__report_file_handler)
else:
self._logger.info("Device capacity is %s : going to %s" %
(self.batt_capacity, self.__tested_capacity))
self.em_core_module.monitor_discharging(
self.__tested_capacity,
self.__time_to_discharge,
self.__report_file_handler,
load_module=self.__load_module)
return Global.SUCCESS, "No errors"
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 set_up(self):
EmUsecaseBase.set_up(self)
self._logger.info("Wait 40s for the phone to be switched off")
time.sleep(40)
return Global.SUCCESS, "No errors"
def set_up(self):
EmUsecaseBase.set_up(self)
if self.__load != "NO_LOAD":
# Activate Loadmodule instance
self.__load_module = LoadModule()
# Add list of LOAD to the loadmodule
self.__load_module.add_load(self.__load)
# Set the brightness mode to manual
self.phonesystem_api.set_brightness_mode("manual")
time.sleep(2)
# set brightness to 100%
self.phonesystem_api.set_display_brightness(100)
time.sleep(2)
# Set screen timeout to 30 minutes
self.phonesystem_api.set_screen_timeout(self.__screen_timeout)
time.sleep(1)
# wake up the board if necessary
if not self.phonesystem_api.get_screen_status():
self._io_card.press_power_button(0.3)
time.sleep(1)
# run a load upon parameter configuration
if self.__load != "NO_LOAD":
# start HIGH LOAD
self.__load_module.start_load()
time.sleep(10)
return Global.SUCCESS, "No errors"
def tear_down(self):
"""
End and dispose the test
"""
# call tear down after some operations
EmUsecaseBase.tear_down(self)
# retrieve measurement from test
self.__em_meas_tab.generate_global_file()
# release equipment
if self.tc_module is not None:
self.tc_module.release_eq()
# clean the board state and retrieve logs
self.em_core_module.clean_up()
# clean autolog
if self.is_board_and_acs_ok():
self.em_api.clean_autolog()
# toggle techno off depending of what was put in LOAD var
if "WIFI" in self.__load:
self.networking_api.set_wifi_power("off")
if "BLUETOOTH" in self.__load:
self.bt_api.set_bt_power("off")
if "TORCH" in self.__load:
self.phonesystem_api.set_torchlight("off")
if "VIBRA" in self.__load:
self.phonesystem_api.set_vibration("off")
return Global.SUCCESS, "No errors"
