def __init__(self, tc_name, global_config):
"""
Constructor
"""
# Call UseCase base Init function
EmUsecaseBase.__init__(self, tc_name, global_config)
# Read Band from test case xml file (str)
self._cell_band = str(self._tc_parameters.get_param_value("CELL_BAND"))
# Read UL_UARFCN from test case xml file
self._ul_uarfcn = int(self._tc_parameters.get_param_value("UL_UARFCN"))
# Read mobile power from test case xml file (int)
self._mobile_power = int(self._tc_parameters.get_param_value("MOBILE_POWER"))
# Read CELL_POWER from test case xml file
self._cell_power = \
int(self._tc_parameters.get_param_value("CELL_POWER"))
# Read REBOOT_MODE from test case xml file
self._reboot_mode = str(self._tc_parameters.get_param_value("REBOOT_MODE"))
# Init fuel gauging param
self.em_core_module.init_fg_param()
# Instantiate ConversionToolBox into conv_toolbox object
self._conversion_toolbox = get_conversion_toolbox()
# Read registrationTimeout from Phone_Catalog.xml
self._registration_timeout = \
int(self._dut_config.get("registrationTimeout"))
# Create cellular network simulator and retrieve 3g APIs
self._ns = self._em.get_cellular_network_simulator("NETWORK_SIMULATOR1")
self._ns_3g = self._ns.get_cell_3g()
# 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)
# result file
ocv_file_name = os.path.join(self._saving_directory,
"Energy_Management_result_report.xml")
self._em_meas_result = EMUtil.XMLMeasurementFile(ocv_file_name)
# enable Global Measurement file
name = os.path.join(self._campaign_folder,
self._em_cst.GLOBAL_MEAS_FILE)
self.__em_meas_tab.enable_global_meas(name, self._name)
# init variables
self._ocv_list = []
self._network_type = "3G"
def __init__(self, tc_name, global_config):
"""
Get parameter from xml testcase file
"""
# Call UseCase base Init function
EmUsecaseBase.__init__(self, tc_name, global_config)
# init fuel gauging parameters
self.em_core_module.init_fg_param()
# Read MAINTENANCE_CHARGING_TIMEOUT from test case xml file
self.__maintenance_timeout = \
int(self._tc_parameters.get_param_value("MAINTENANCE_CHARGING_TIMEOUT"))
# Read EXPECTED_BATTERY_STATE from test case xml file
self.__expected_batt_state = \
str(self._tc_parameters.get_param_value(
"EXPECTED_BATT_STATE")).upper()
# Read DATA_POLLING from test case xml file
self.__data_polling = \
int(self._tc_parameters.get_param_value(
"DATA_POLLING"))
# Read CAPABILITY_TAG from test case xml file
self._capability_tag = \
str(self._tc_parameters.get_param_value(
"CAPABILITY_TAG"))
# Read MULTIMEDIA_TYPE from test case xml file
self.__multimedia_type = \
str(self._tc_parameters.get_param_value("MULTIMEDIA_TYPE")).upper()
# Get Multimedia Parameters
self.__multimedia_file = self._tc_parameters.get_param_value(
"MULTIMEDIA_FILE")
self.__volume = int(self._tc_parameters.get_param_value("VOLUME"))
# Get path to multimedia files
self.__multimedia_path = self._device.multimedia_path
# Initialize EM xml object
# measurement file
name = os.path.join(self._saving_directory, "EM_meas_report.xml")
self.__em_meas_tab = EMUtil.XMLMeasurementFile(name)
# enable Global Measurement file
name = os.path.join(self._campaign_folder,
self._em_cst.GLOBAL_MEAS_FILE)
self.__em_meas_tab.enable_global_meas(name, self._name)
# hysteresis file
name = os.path.join(self._saving_directory, "EM_hysteresis_report.xml")
self.__em_hysteresis_tab = EMUtil.XMLMeasurementFile(name)
# init variables
self.__multimedia_api = None
self._system_api = self._device.get_uecmd("System", True)
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)
# 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):
"""
Get parameter from xml testcase file
"""
# Call UseCase base Init function
EmUsecaseBase.__init__(self, tc_name, global_config)
self.em_core_module.init_fg_param()
# Read MAINTENANCE_CHARGING_TIMEOUT from test case xml file
self.__maintenance_timeout = int(
self._tc_parameters.get_param_value(
"MAINTENANCE_CHARGING_TIMEOUT"))
# Read EXPECTED_BATTERY_STATE from test case xml file
self.__expected_batt_state = str(
self._tc_parameters.get_param_value(
"EXPECTED_BATT_STATE")).upper()
# Read DATA_POLLING from test case xml file
self.__data_polling = int(
self._tc_parameters.get_param_value("DATA_POLLING"))
# Read TEMPERATURE from test case xml file
self.tc_module = None
self.__chamber_tag = "ROOM"
self.__temperature = str(
self._tc_parameters.get_param_value("TEMPERATURE"))
if self.__temperature != "ROOM":
# get temperature chamber equipment if not room temperature
self.__temperature = int(self.__temperature)
self.tc_module = ThermalChamberModule(self.__temperature)
# inform module that this is not a default thermal test
self.tc_module.set_test_type("SPECIFIC")
self.__chamber_tag = self.tc_module.get_chamber_tag()
# Read LOAD from test case xml file
self.__load = \
str(self._tc_parameters.get_param_value("LOAD")).upper()
# Initialize EM xml object
# measurement file
name = os.path.join(self._saving_directory, "EM_meas_report.xml")
self.__em_meas_tab = EMUtil.XMLMeasurementFile(name)
# enable Global Measurement file
name = os.path.join(self._campaign_folder,
self._em_cst.GLOBAL_MEAS_FILE)
self.__em_meas_tab.enable_global_meas(name, self._name)
# hysteresis file
name = os.path.join(self._saving_directory, "EM_hysteresis_report.xml")
self.__em_hysteresis_tab = EMUtil.XMLMeasurementFile(name)
def __init__(self, tc_name, global_config):
"""
Advanced ON OFF test that also provide action to charge the board
"""
# Call UseCase base Init function
EmUsecaseBase.__init__(self, tc_name, global_config)
# init fuel gauging parameters
self.em_core_module.init_fg_param()
# time to wait to boot
self.__boot_timeout = self._tc_parameters.get_param_value(
"BOOT_TIMEOUT",
self._device.get_boot_timeout(),
default_cast_type=int)
# time to wait just after the boot action and before wait to successfully boot
self.__after_perform_boot_time = self._tc_parameters.get_param_value(
"TIME_TO_WAIT_AFTER_JUST_PERFORM_BOOT", 10, default_cast_type=int)
# time to wait to shutdown
self.__shutdown_timeout = self._tc_parameters.get_param_value(
"SHUTDOWN_TIMEOUT", default_cast_type=int)
# cable to insert to make board boot
self.__cable_type = self._tc_parameters.get_param_value("CABLE_TYPE")
self.__keep_cable_during_shutdown = self._tc_parameters.get_param_value(
"KEEP_CABLE_DURING_SHUTDOWN", True, default_cast_type=str_to_bool)
# cable to insert to make board boot
self.__max_iteration = self._tc_parameters.get_param_value(
"MAX_ITERATION", default_cast_type=int)
# time to wait to shutdown
self.__max_fail = self._tc_parameters.get_param_value(
"MAX_CONSECUTIVE_FAIL", 0, default_cast_type=int)
self.__min_capacity_stop = self._tc_parameters.get_param_value(
"MIN_CAPACITY_TO_STOP_TEST", 0, default_cast_type=int)
# time to wait to shutdown
# 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.__parser_api = self._device.get_uecmd("Aplog", True)
self.__fail_boot = 0
self.__pass_boot = 0
def __init__(self, tc_name, global_config):
"""
Constructor
"""
# Call Init function
EmUsecaseBase.__init__(self, tc_name, global_config)
# Read READ_INFO_TIMEOUT from test case xml file
self._read_info_timeout = \
int(self._tc_parameters.get_param_value("READ_INFO_TIMEOUT"))
# Read CHARGER_TYPE from TC parameters
self._charger_type = \
str(self._tc_parameters.get_param_value("CHARGER_TYPE"))
# Read all temperatures from TC parameters
temperatures = str(
self._tc_parameters.get_param_value("TEMPERATURE_CYCLE"))
self._em_targets = self._target_file.parse_energy_management_targets(
"LAB_EM_BATT_TEMP_MEAS_CYCLE",
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 temperature chamber equipment
self.tc_module = ThermalChamberModule(self._ambient_temperature)
self.tc_module.set_test_type("SPECIFIC")
# Initialize EM xml object
# measurement file
name = os.path.join(self._saving_directory, "EM_meas_report.xml")
self.__em_meas_tab = EMUtil.XMLMeasurementFile(name)
self._temperature_cycle = []
for temperature in temperatures.split(","):
self._temperature_cycle.append(int(temperature))
def __init__(self, tc_name, global_config):
"""
Constructor
"""
# Call UseCase base Init function
EmUsecaseBase.__init__(self, tc_name, global_config)
# Read REBOOT_MODE from test case xml file
self._reboot_mode = str(
self._tc_parameters.get_param_value("REBOOT_MODE"))
# Init fuel gauging param
self.em_core_module.init_fg_param()
# 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)
# enable Global Measurement file
name = os.path.join(self._campaign_folder,
self._em_cst.GLOBAL_MEAS_FILE)
self.__em_meas_tab.enable_global_meas(name, self._name)
def __init__(self, tc_name, global_config):
"""
Constructor
"""
# Call UseCase base Init function
EmUsecaseBase.__init__(self, tc_name, global_config)
# Read Band from test case xml file (str)
self._cell_band = str(self._tc_parameters.get_param_value("CELL_BAND"))
# Read CELL_SERVICE from test case xml file
self._cell_service = \
str(self._tc_parameters.get_param_value("CELL_SERVICE"))
# Read TCH_ARFCN from test case xml file
self._tch_arfcn = int(self._tc_parameters.get_param_value("TCH_ARFCN"))
# Read UPLINK_CHANNEL from test case xml file
self._uplink_channel = int(self._tc_parameters.get_param_value("UPLINK_CHANNEL"))
# Read CELL_POWER from test case xml file
self._cell_power = \
int(self._tc_parameters.get_param_value("CELL_POWER"))
# Read DATA_CALL from test case xml file
self._data_call = str_to_bool(self._tc_parameters.get_param_value("DATA_CALL"))
# Read DATA_CALL_MODE from test case xml file
self._data_call_mode = str(self._tc_parameters.get_param_value("DATA_CALL_MODE"))
# Init fuel gauging param
self.em_core_module.init_fg_param()
# Read registrationTimeout from Phone_Catalog.xml
self._registration_timeout = \
int(self._dut_config.get("registrationTimeout"))
# Create cellular network simulator and retrieve 2G APIs
self._ns = self._em.get_cellular_network_simulator("NETWORK_SIMULATOR1")
self._ns_2g = self._ns.get_cell_2g()
self._data_2g = self._ns_2g.get_data()
self._vc_2g = self._ns_2g.get_voice_call()
self._test_mode_2g = self._ns_2g.get_test_mode()
# Initialize EM xml object
meas_file_name = os.path.join(self._saving_directory,
"EM_meas_report.xml")
self.__em_meas_tab = EMUtil.XMLMeasurementFile(meas_file_name)
# enable Global Measurement file
name = os.path.join(self._campaign_folder,
self._em_cst.GLOBAL_MEAS_FILE)
self.__em_meas_tab.enable_global_meas(name, self._name)
# Call ConfigsParser to parse Energy_Management
self._em_targets = self._target_file.parse_energy_management_targets(
"LAB_EM_BATT_MONITOR_BURST_CTRL", 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._total_test = 0
self._shutdown_timeout = 60
self._network_type = "2G"
self._slots_conf = []
# prepare to launch scheduled test depending of battery capacity
# enter test like below (battery_min, battery_max, test id): function_to_call
self.scheduled_test = {
(65, 81, "1"): self.__ber_test,
(12, 19, "2"): self.__ber_test,
(1, 5, "3"): self.__ber_test,
}
def __init__(self, tc_name, global_config):
"""
Constructor
"""
# Call UseCase base Init function
EmUsecaseBase.__init__(self, tc_name, global_config)
# Read Band from test case xml file (str)
self._cell_band = str(self._tc_parameters.get_param_value("CELL_BAND"))
# Read CELL_SERVICE from test case xml file
self._cell_service = \
str(self._tc_parameters.get_param_value("CELL_SERVICE"))
# Read TCH_ARFCN from test case xml file
self._tch_arfcn = int(self._tc_parameters.get_param_value("TCH_ARFCN"))
# Read UPLINK_CHANNEL from test case xml file
self._uplink_channel = int(
self._tc_parameters.get_param_value("UPLINK_CHANNEL"))
# Read CELL_POWER from test case xml file
self._cell_power = \
int(self._tc_parameters.get_param_value("CELL_POWER"))
# Read DATA_CALL from test case xml file
self._data_call = str_to_bool(
self._tc_parameters.get_param_value("DATA_CALL"))
# Read DATA_CALL_MODE from test case xml file
self._data_call_mode = str(
self._tc_parameters.get_param_value("DATA_CALL_MODE"))
# Read REBOOT_MODE from test case xml file
self._reboot_mode = str(
self._tc_parameters.get_param_value("REBOOT_MODE"))
# Init fuel gauging param
self.em_core_module.init_fg_param()
# Read registrationTimeout from Device_Catalog.xml
self._registration_timeout = \
int(self._dut_config.get("registrationTimeout"))
# Create cellular network simulator and retrieve 2G APIs
self._ns = self._em.get_cellular_network_simulator(
"NETWORK_SIMULATOR1")
self._ns_2g = self._ns.get_cell_2g()
self._data_2g = self._ns_2g.get_data()
# 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)
# result file
ocv_file_name = os.path.join(self._saving_directory,
"Energy_Management_result_report.xml")
self._em_meas_result = EMUtil.XMLMeasurementFile(ocv_file_name)
# enable Global Measurement file
name = os.path.join(self._campaign_folder,
self._em_cst.GLOBAL_MEAS_FILE)
self.__em_meas_tab.enable_global_meas(name, self._name)
# init variables
self._ocv_list = []
self._slots_conf = []
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 LOAD from test case xml file
self._load = \
str(self._tc_parameters.get_param_value("LOAD"))
# Read BATT_MIN_CAPACITY from test case xml file
# Init fuel gauging param
self.em_core_module.init_fg_param()
# Read STRESS_PERIOD from test case xml file
self.hard_stress_time = \
int(self._tc_parameters.get_param_value(
"STRESS_PERIOD"))
# Read NO_STRESS_PERIOD from test case xml file
self.soft_stress_time = \
int(self._tc_parameters.get_param_value(
"NO_STRESS_PERIOD"))
if self._load in ["HEAVY", "MEDIUM"]:
# Read Band from test case xml file (str)
self._cell_band = str(
self._tc_parameters.get_param_value("CELL_BAND"))
# Read CELL_SERVICE from test case xml file
self._cell_service = \
str(self._tc_parameters.get_param_value("CELL_SERVICE"))
# Read TCH_ARFCN from test case xml file
self._tch_arfcn = int(
self._tc_parameters.get_param_value("TCH_ARFCN"))
# Read UPLINK_CHANNEL from test case xml file
self._uplink_channel = int(
self._tc_parameters.get_param_value("UPLINK_CHANNEL"))
# Read CELL_POWER from test case xml file
self._cell_power = \
int(self._tc_parameters.get_param_value("CELL_POWER"))
# Read registrationTimeout from Phone_Catalog.xml
self._registration_timeout = \
int(self._dut_config.get("registrationTimeout"))
# Create cellular network simulator and retrieve 2G APIs
self._ns = self._em.get_cellular_network_simulator(
"NETWORK_SIMULATOR1")
self._ns_2g = self._ns.get_cell_2g()
self._data_2g = self._ns_2g.get_data()
self._test_mode_2g = self._ns_2g.get_test_mode()
# Get Multimedia Parameters
self._audio_file = self._tc_parameters.get_param_value(
"AUDIO_FILE")
self._volume = int(self._tc_parameters.get_param_value("VOLUME"))
# Get path to multimedia files
self._multimedia_path = self._device.multimedia_path
# import special api
self._audio_api = self._device.get_uecmd("Audio")
self._system_api = self._device.get_uecmd("System")
if self._load in ["HEAVY"]:
# Get FTP server parameters
server = self.__global_config.benchConfig.\
get_parameters("WIFI_SERVER")
self._ftp_ip_address = server.get_param_value("IP")
self._ftp_username = server.get_param_value("username")
self._ftp_password = server.get_param_value("password")
if server.has_parameter("ftp_path"):
self._ftp_path = server.get_param_value("ftp_path")
else:
self._ftp_path = ""
# get file to download info
self._dlfilename = os.path.join(
self._ftp_path, self._tc_parameters.get_param_value("DL_FILE"))
# get wifi parameters
self._wifi_router_name = None
self._standard = None
self._ssid = ""
self._standard_read = None
self._security = None
self._security_read = None
self._passphrase = None
self._is_router_name_found = True
self._is_router_found = False
supported_wifi_standard = [
'a', 'b', 'g', 'n', 'an', 'bg', 'gb', 'bgn', 'ngb', 'n2.4G',
'n5G', 'off'
]
bench_config = self.__global_config.benchConfig
# Retrieve wifi access point
self._wifi_router_name = \
str(self._tc_parameters.get_param_value("WIFI_ACCESS_POINT"))
# if wifi router name is not specified, exit
if self._wifi_router_name in [None, "", "NONE"]:
self._is_router_name_found = False
elif (bench_config.has_parameter(self._wifi_router_name)
and self.__global_config.benchConfig.get_parameters(
self._wifi_router_name) != ""):
self._is_router_found = True
self._wifirouter = self.__global_config.benchConfig.\
get_parameters(self._wifi_router_name)
ssid_read = self._wifirouter.get_param_value("SSID")
self._standard_read = self._wifirouter.get_param_value(
"standard")
self._security_read = self._wifirouter.\
get_param_value("WIFI_SECURITY").upper()
if ssid_read != "":
self._ssid = ssid_read
if self._standard_read in supported_wifi_standard:
self._standard = self._standard_read
# retrieve wifi router parameters
if self._security_read in ("NONE", "OPEN"):
self._logger.debug("OPEN"
'Wifi Security type selected,' +
'getting parameters')
self._security = self._security_read
elif self._security_read in ("WEP", "WPA", "WPA2"):
self._security = self._security_read
self._logger.debug(
str(self._security) +
" Wifi Security selected, getting parameters")
passphrase = self._wifirouter.get_param_value("passphrase")
self._passphrase = passphrase
# 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)
# enable Global Measurement file
name = os.path.join(self._campaign_folder,
self._em_cst.GLOBAL_MEAS_FILE)
self.__em_meas_tab.enable_global_meas(name, self._name)
# init variables
self.__total_test = 0
self._slots_conf = []
self._data_call_mode = "TEST_MODE_B"
self.measurement_fail = 0
self._em_targets = None