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"